diff --git a/README.md b/README.md index 718d266..e1093d9 100644 --- a/README.md +++ b/README.md @@ -33,7 +33,7 @@ English | [简体中文](README_CN.md) - + @@ -116,13 +116,17 @@ cd paddle_quantum/QAOA/example python main.py ``` -> For the introduction of QAOA, please refer to our [QAOA tutorial](https://github.com/PaddlePaddle/Quantum/tree/master/tutorial/combinatorial_optimization/QAOA_EN.ipynb). +> For the introduction of QAOA, please refer to our [QAOA tutorial](./tutorials/combinatorial_optimization/QAOA_EN.ipynb). + +### Breaking Change + +In version 2.2.0 of Paddle Quantum, we have made an incompatible upgrade to the code architecture, and the new version's structure and usage can be found in our [tutorials](https://qml.baidu.com/tutorials/overview.html), [API documentation](https://qml.baidu.com/api/introduction.html), and [the source code](https://github.com/PaddlePaddle/Quantum). Also, we support connecting to a real quantum computer via [QuLeaf](https://github.com/baidu/QCompute), using `paddle_quantum.set_backend('quleaf')` to select QuLeaf as the backend. ## Introduction and developments ### Quick start -[Paddle Quantum Quick Start Manual](https://github.com/PaddlePaddle/Quantum/tree/master/introduction) is probably the best place to get started with Paddle Quantum. Currently, we support online reading and running the Jupyter Notebook locally. The manual includes the following contents: +[Paddle Quantum Quick Start Manual](./introduction) is probably the best place to get started with Paddle Quantum. Currently, we support online reading and running the Jupyter Notebook locally. The manual includes the following contents: - Detailed installation tutorials for Paddle Quantum - Introduction to quantum computing and quantum neural networks (QNNs) @@ -131,61 +135,60 @@ python main.py - PaddlePaddle optimizer tutorial - Introduction to the quantum chemistry module in Paddle Quantum - How to train QNN with GPU -- Some frequently used functions in Paddle Quantum ### Tutorials We provide tutorials covering quantum simulation, machine learning, combinatorial optimization, local operations and classical communication (LOCC), and other popular QML research topics. Each tutorial currently supports reading on our website and running Jupyter Notebooks locally. For interested developers, we recommend them to download Jupyter Notebooks and play around with it. Here is the tutorial list, -- [Quantum Simulation](./tutorial/quantum_simulation) - 1. [Building Molecular Hamiltonian](./tutorial/quantum_simulation/BuildingMolecule_EN.ipynb) - 2. [Variational Quantum Eigensolver (VQE)](./tutorial/quantum_simulation/VQE_EN.ipynb) - 3. [Subspace Search-Quantum Variational Quantum Eigensolver (SSVQE)](./tutorial/quantum_simulation/SSVQE_EN.ipynb) - 4. [Variational Quantum State Diagonalization (VQSD)](./tutorial/quantum_simulation/VQSD_EN.ipynb) - 5. [Gibbs State Preparation](./tutorial/quantum_simulation/GibbsState_EN.ipynb) - 6. [The Classical Shadow of Unknown Quantum States](./tutorial/quantum_simulation/ClassicalShadow_Intro_EN.ipynb) - 7. [Estimation of Quantum State Properties Based on the Classical Shadow](./tutorial/quantum_simulation/ClassicalShadow_Application_EN.ipynb) - 8. [Hamiltonian Simulation with Product Formula](./tutorial/quantum_simulation/HamiltonianSimulation_EN.ipynb) - 9. [Simulate the Spin Dynamics on a Heisenberg Chain](./tutorial/quantum_simulation/SimulateHeisenberg_EN.ipynb) - 10. [Distributed Variational Quantum Eigensolver Based on Schmidt Decomposition](./tutorial/quantum_simulation/DistributedVQE_EN.ipynb) - -- [Machine Learning](./tutorial/machine_learning) - 1. [Encoding Classical Data into Quantum States](./tutorial/machine_learning/DataEncoding_EN.ipynb) - 2. [Quantum Classifier](./tutorial/machine_learning/QClassifier_EN.ipynb) - 3. [Variational Shadow Quantum Learning (VSQL)](./tutorial/machine_learning/VSQL_EN.ipynb) - 4. [Quantum Kernel Methods](./tutorial/machine_learning/QKernel_EN.ipynb) - 5. [Quantum Autoencoder](./tutorial/machine_learning/QAutoencoder_EN.ipynb) - 6. [Quantum GAN](./tutorial/machine_learning/QGAN_EN.ipynb) - 7. [Variational Quantum Singular Value Decomposition (VQSVD)](./tutorial/machine_learning/VQSVD_EN.ipynb) - -- [Combinatorial Optimization](./tutorial/combinatorial_optimization) - 1. [Quantum Approximation Optimization Algorithm (QAOA)](./tutorial/combinatorial_optimization/QAOA_EN.ipynb) - 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) - 2. [Entanglement Distillation -- the BBPSSW protocol](./tutorial/locc/EntanglementDistillation_BBPSSW_EN.ipynb) - 3. [Entanglement Distillation -- the DEJMPS protocol](./tutorial/locc/EntanglementDistillation_DEJMPS_EN.ipynb) - 4. [Entanglement Distillation -- Protocol design with LOCCNet](./tutorial/locc/EntanglementDistillation_LOCCNET_EN.ipynb) - 5. [Quantum Teleportation](./tutorial/locc/QuantumTeleportation_EN.ipynb) - 6. [Quantum State Discrimination](./tutorial/locc/StateDiscrimination_EN.ipynb) - -- [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) - 4. [Expressibility of Quantum Neural Network](./tutorial/qnn_research/Expressibility_EN.ipynb) - 5. [Variational Quantum Circuit Compiling](./tutorial/qnn_research/VQCC_EN.ipynb) - 6. [Quantum Fisher Information](./tutorial/qnn_research/Fisher_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). - -In a recent update, the measurement-based quantum computation (MBQC) module has been added to Paddle Quantum. Unlike the conventional quantum circuit model, MBQC has its unique way of computing. Interested readers are welcomed to read our [tutorials](./tutorial/mbqc) on how to use the MBQC module and its use cases. +- [Quantum Simulation](./tutorials/quantum_simulation) + 1. [Building Molecular Hamiltonian](./tutorials/quantum_simulation/BuildingMolecule_EN.ipynb) + 2. [Variational Quantum Eigensolver (VQE)](./tutorials/quantum_simulation/VQE_EN.ipynb) + 3. [Subspace Search-Quantum Variational Quantum Eigensolver (SSVQE)](./tutorials/quantum_simulation/SSVQE_EN.ipynb) + 4. [Variational Quantum State Diagonalization (VQSD)](./tutorials/quantum_simulation/VQSD_EN.ipynb) + 5. [Gibbs State Preparation](./tutorials/quantum_simulation/GibbsState_EN.ipynb) + 6. [The Classical Shadow of Unknown Quantum States](./tutorials/quantum_simulation/ClassicalShadow_Intro_EN.ipynb) + 7. [Estimation of Quantum State Properties Based on the Classical Shadow](./tutorials/quantum_simulation/ClassicalShadow_Application_EN.ipynb) + 8. [Hamiltonian Simulation with Product Formula](./tutorials/quantum_simulation/HamiltonianSimulation_EN.ipynb) + 9. [Simulate the Spin Dynamics on a Heisenberg Chain](./tutorials/quantum_simulation/SimulateHeisenberg_EN.ipynb) + 10. [Distributed Variational Quantum Eigensolver Based on Schmidt Decomposition](./tutorials/quantum_simulation/DistributedVQE_EN.ipynb) + +- [Machine Learning](./tutorials/machine_learning) + 1. [Encoding Classical Data into Quantum States](./tutorials/machine_learning/DataEncoding_EN.ipynb) + 2. [Quantum Classifier](./tutorials/machine_learning/QClassifier_EN.ipynb) + 3. [Variational Shadow Quantum Learning (VSQL)](./tutorials/machine_learning/VSQL_EN.ipynb) + 4. [Quantum Kernel Methods](./tutorials/machine_learning/QKernel_EN.ipynb) + 5. [Quantum Autoencoder](./tutorials/machine_learning/QAutoencoder_EN.ipynb) + 6. [Quantum GAN](./tutorials/machine_learning/QGAN_EN.ipynb) + 7. [Variational Quantum Singular Value Decomposition (VQSVD)](./tutorials/machine_learning/VQSVD_EN.ipynb) + +- [Combinatorial Optimization](./tutorials/combinatorial_optimization) + 1. [Quantum Approximation Optimization Algorithm (QAOA)](./tutorials/combinatorial_optimization/QAOA_EN.ipynb) + 2. [Solving Max-Cut Problem with QAOA](./tutorials/combinatorial_optimization/MAXCUT_EN.ipynb) + 3. [Large-scale QAOA via Divide-and-Conquer](./tutorials/combinatorial_optimization/DC-QAOA_EN.ipynb) + 4. [Travelling Salesman Problem](./tutorials/combinatorial_optimization/TSP_EN.ipynb) + 5. [Quantum Finance Application on Arbitrage Opportunity Optimization](./tutorials/combinatorial_optimization/ArbitrageOpportunityOptimation_EN.ipynb) + 6. [Quantum Finance Application on Portfolio Optimization](./tutorials/combinatorial_optimization/PortfolioOptimization_EN.ipynb) + 7. [Quantum Finance Application on Portfolio Diversification](./tutorials/combinatorial_optimization/PortfolioDiversification_EN.ipynb) + +- [LOCC with QNN (LOCCNet)](./tutorials/locc) + 1. [Local Operations and Classical Communication in QNN (LOCCNet)](./tutorials/locc/LOCCNET_Tutorial_EN.ipynb) + 2. [Entanglement Distillation -- the BBPSSW protocol](./tutorials/locc/EntanglementDistillation_BBPSSW_EN.ipynb) + 3. [Entanglement Distillation -- the DEJMPS protocol](./tutorials/locc/EntanglementDistillation_DEJMPS_EN.ipynb) + 4. [Entanglement Distillation -- Protocol design with LOCCNet](./tutorials/locc/EntanglementDistillation_LOCCNET_EN.ipynb) + 5. [Quantum Teleportation](./tutorials/locc/QuantumTeleportation_EN.ipynb) + 6. [Quantum State Discrimination](./tutorials/locc/StateDiscrimination_EN.ipynb) + +- [QNN Research](./tutorials/qnn_research) + 1. [The Barren Plateaus Phenomenon on Quantum Neural Networks (Barren Plateaus)](./tutorials/qnn_research/BarrenPlateaus_EN.ipynb) + 2. [Noise Model and Quantum Channel](./tutorials/qnn_research/Noise_EN.ipynb) + 3. [Expressibility of Quantum Neural Network](./tutorials/qnn_research/Expressibility_EN.ipynb) + 4. [Variational Quantum Circuit Compiling](./tutorials/qnn_research/VQCC_EN.ipynb) + 5. [Quantum Fisher Information](./tutorials/qnn_research/Fisher_EN.ipynb) + 6. [VAns-Variable Ansatz](./tutorials/qnn_research/VAns_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](./tutorials/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](./tutorials/qnn_research/Noise_EN.ipynb). + +In a recent update, the measurement-based quantum computation (MBQC) module has been added to Paddle Quantum. Unlike the conventional quantum circuit model, MBQC has its unique way of computing. Interested readers are welcomed to read our [tutorials](./tutorials/mbqc) on how to use the MBQC module and its use cases. ### API documentation diff --git a/README_CN.md b/README_CN.md index 97338ff..d0f18ca 100644 --- a/README_CN.md +++ b/README_CN.md @@ -34,7 +34,7 @@ - + @@ -118,7 +118,12 @@ cd paddle_quantum/QAOA/example python main.py ``` -> 关于 QAOA 的介绍可以参考我们的 [QAOA 教程](./tutorial/combinatorial_optimization/QAOA_CN.ipynb)。 +> 关于 QAOA 的介绍可以参考我们的 [QAOA 教程](./tutorials/combinatorial_optimization/QAOA_CN.ipynb)。 + + +### 重大更新 + +在量桨 2.2.0 版本中，我们对代码架构进行了不兼容升级，新版的结构和用法可以参考我们的[教程](https://qml.baidu.com/tutorials/overview.html)、[API 文档](https://qml.baidu.com/api/introduction.html)和[源代码](https://github.com/PaddlePaddle/Quantum)。同时，我们也支持通过[量易伏](https://github.com/baidu/QCompute)连接到真实量子计算机上，使用`paddle_quantum.set_backend('quleaf')`即可选择量易伏作为后端。 ## 入门与开发 @@ -137,7 +142,6 @@ python main.py - 飞桨（PaddlePaddle）优化器的使用教程 - 量桨中量子化学模块的使用介绍 - 如何基于 GPU 训练量子神经网络 -- 量桨中初学者常用的函数 ### 案例入门 @@ -145,55 +149,55 @@ Paddle Quantum（量桨）建立起了人工智能与量子计算的桥梁，为 在这里，我们提供了涵盖量子模拟、机器学习、组合优化、本地操作与经典通讯（local operations and classical communication, LOCC）、量子神经网络等多个领域的案例供大家学习。每个教程目前支持网页阅览和运行 Jupyter Notebook 两种方式。我们推荐用户下载 Notebook 后，本地运行进行实践。 -- [量子模拟](./tutorial/quantum_simulation) - 1. [哈密顿量的构造](./tutorial/quantum_simulation/BuildingMolecule_CN.ipynb) - 2. [变分量子特征求解器（VQE）](./tutorial/quantum_simulation/VQE_CN.ipynb) - 3. [子空间搜索 - 量子变分特征求解器（SSVQE）](./tutorial/quantum_simulation/SSVQE_CN.ipynb) - 4. [变分量子态对角化算法（VQSD）](./tutorial/quantum_simulation/VQSD_CN.ipynb) - 5. [吉布斯态的制备（Gibbs State Preparation）](./tutorial/quantum_simulation/GibbsState_CN.ipynb) - 6. [未知量子态的经典影子](./tutorial/quantum_simulation/ClassicalShadow_Intro_CN.ipynb) - 7. [基于经典影子的量子态性质估计](./tutorial/quantum_simulation/ClassicalShadow_Application_CN.ipynb) - 8. [利用 Product Formula 模拟时间演化](./tutorial/quantum_simulation/HamiltonianSimulation_CN.ipynb) - 9. [模拟一维海森堡链的自旋动力学](./tutorial/quantum_simulation/SimulateHeisenberg_CN.ipynb) - 10. [基于施密特分解的分布式变分量子本征求解器](./tutorial/quantum_simulation/DistributedVQE_CN.ipynb) - -- [机器学习](./tutorial/machine_learning) - 1. [量子态编码经典数据](./tutorial/machine_learning/DataEncoding_CN.ipynb) - 2. [量子分类器（Quantum Classifier）](./tutorial/machine_learning/QClassifier_CN.ipynb) - 3. [变分影子量子学习（VSQL）](./tutorial/machine_learning/VSQL_CN.ipynb) - 4. [量子核方法（Quantum Kernel）](./tutorial/machine_learning/QKernel_CN.ipynb) - 5. [量子变分自编码器（Quantum Autoencoder）](./tutorial/machine_learning/QAutoencoder_CN.ipynb) - 6. [量子生成对抗网络（Quantum GAN）](./tutorial/machine_learning/QGAN_CN.ipynb) - 7. [变分量子奇异值分解（VQSVD）](./tutorial/machine_learning/VQSVD_CN.ipynb) - -- [组合优化](./tutorial/combinatorial_optimization) - 1. [量子近似优化算法（QAOA）](./tutorial/combinatorial_optimization/QAOA_CN.ipynb) - 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) - 2. [纠缠蒸馏 -- BBPSSW 协议](./tutorial/locc/EntanglementDistillation_BBPSSW_CN.ipynb) - 3. [纠缠蒸馏 -- DEJMPS 协议](./tutorial/locc/EntanglementDistillation_DEJMPS_CN.ipynb) - 4. [纠缠蒸馏 -- LOCCNet 设计协议](./tutorial/locc/EntanglementDistillation_LOCCNET_CN.ipynb) - 5. [量子隐态传输](./tutorial/locc/QuantumTeleportation_CN.ipynb) - 6. [量子态分辨](./tutorial/locc/StateDiscrimination_CN.ipynb) - -- [量子神经网络研究](./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) - 4. [量子神经网络的表达能力](./tutorial/qnn_research/Expressibility_CN.ipynb) - 5. [变分量子电路编译](./tutorial/qnn_research/VQCC_CN.ipynb) - 6. [量子费舍信息](./tutorial/qnn_research/Fisher_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)。 - -在最近的更新中，量桨还加入了基于测量的量子计算（measurement-based quantum computation, MBQC）模块。与传统的量子电路模型不同，MBQC 具有其独特的运行方式，感兴趣的读者请参见我们提供的[多篇教程](./tutorial/mbqc)以了解量桨 MBQC 模块的使用方法和应用案例。 +- [量子模拟](./tutorials/quantum_simulation) + 1. [哈密顿量的构造](./tutorials/quantum_simulation/BuildingMolecule_CN.ipynb) + 2. [变分量子特征求解器（VQE）](./tutorials/quantum_simulation/VQE_CN.ipynb) + 3. [子空间搜索 - 量子变分特征求解器（SSVQE）](./tutorials/quantum_simulation/SSVQE_CN.ipynb) + 4. [变分量子态对角化算法（VQSD）](./tutorials/quantum_simulation/VQSD_CN.ipynb) + 5. [吉布斯态的制备（Gibbs State Preparation）](./tutorials/quantum_simulation/GibbsState_CN.ipynb) + 6. [未知量子态的经典影子](./tutorials/quantum_simulation/ClassicalShadow_Intro_CN.ipynb) + 7. [基于经典影子的量子态性质估计](./tutorials/quantum_simulation/ClassicalShadow_Application_CN.ipynb) + 8. [利用 Product Formula 模拟时间演化](./tutorials/quantum_simulation/HamiltonianSimulation_CN.ipynb) + 9. [模拟一维海森堡链的自旋动力学](./tutorials/quantum_simulation/SimulateHeisenberg_CN.ipynb) + 10. [基于施密特分解的分布式变分量子本征求解器](./tutorials/quantum_simulation/DistributedVQE_CN.ipynb) + +- [机器学习](./tutorials/machine_learning) + 1. [量子态编码经典数据](./tutorials/machine_learning/DataEncoding_CN.ipynb) + 2. [量子分类器（Quantum Classifier）](./tutorials/machine_learning/QClassifier_CN.ipynb) + 3. [变分影子量子学习（VSQL）](./tutorials/machine_learning/VSQL_CN.ipynb) + 4. [量子核方法（Quantum Kernel）](./tutorials/machine_learning/QKernel_CN.ipynb) + 5. [量子变分自编码器（Quantum Autoencoder）](./tutorials/machine_learning/QAutoencoder_CN.ipynb) + 6. [量子生成对抗网络（Quantum GAN）](./tutorials/machine_learning/QGAN_CN.ipynb) + 7. [变分量子奇异值分解（VQSVD）](./tutorials/machine_learning/VQSVD_CN.ipynb) + +- [组合优化](./tutorials/combinatorial_optimization) + 1. [量子近似优化算法（QAOA）](./tutorials/combinatorial_optimization/QAOA_CN.ipynb) + 2. [QAOA 求解最大割问题](./tutorials/combinatorial_optimization/MAXCUT_CN.ipynb) + 3. [大规模量子近似优化分治算法（DC-QAOA）](./tutorials/combinatorial_optimization/DC-QAOA_CN.ipynb) + 4. [旅行商问题](./tutorials/combinatorial_optimization/TSP_CN.ipynb) + 5. [量子金融应用：最佳套利机会](./tutorials/combinatorial_optimization/ArbitrageOpportunityOptimation_CN.ipynb) + 6. [量子金融应用：投资组合优化](./tutorials/combinatorial_optimization/PortfolioOptimization_CN.ipynb) + 7. [量子金融应用：投资组合分散化](./tutorials/combinatorial_optimization/PortfolioDiversification_CN.ipynb) + +- [LOCC 量子神经网络（LOCCNet）](./tutorials/locc) + 1. [LOCC 量子神经网络](./tutorials/locc/LOCCNET_Tutorial_CN.ipynb) + 2. [纠缠蒸馏 -- BBPSSW 协议](./tutorials/locc/EntanglementDistillation_BBPSSW_CN.ipynb) + 3. [纠缠蒸馏 -- DEJMPS 协议](./tutorials/locc/EntanglementDistillation_DEJMPS_CN.ipynb) + 4. [纠缠蒸馏 -- LOCCNet 设计协议](./tutorials/locc/EntanglementDistillation_LOCCNET_CN.ipynb) + 5. [量子隐态传输](./tutorials/locc/QuantumTeleportation_CN.ipynb) + 6. [量子态分辨](./tutorials/locc/StateDiscrimination_CN.ipynb) + +- [量子神经网络研究](./tutorials/qnn_research) + 1. [量子神经网络的贫瘠高原效应（Barren Plateaus）](./tutorials/qnn_research/BarrenPlateaus_CN.ipynb) + 2. [噪声模型与量子信道](./tutorials/qnn_research/Noise_CN.ipynb) + 3. [量子神经网络的表达能力](./tutorials/qnn_research/Expressibility_CN.ipynb) + 4. [变分量子电路编译](./tutorials/qnn_research/VQCC_CN.ipynb) + 5. [量子费舍信息](./tutorials/qnn_research/Fisher_CN.ipynb) + 6. [VAns-可变电路结构](./tutorials/qnn_research/VAns_CN.ipynb) + +随着 LOCCNet 模组的推出，量桨现已支持分布式量子信息处理任务的高效模拟和开发。感兴趣的读者请参见[教程](./tutorials/locc/LOCCNET_Tutorial_CN.ipynb)。Paddle Quantum 也支持在 GPU 上进行量子机器学习的训练，具体的方法请参考案例：[在 GPU 上使用 Paddle Quantum](./introduction/PaddleQuantum_GPU_CN.ipynb)。此外，量桨可以基于噪声模块进行含噪算法的开发以及研究，详情请见[噪声模块教程](./tutorials/qnn_research/Noise_CN.ipynb)。 + +在最近的更新中，量桨还加入了基于测量的量子计算（measurement-based quantum computation, MBQC）模块。与传统的量子电路模型不同，MBQC 具有其独特的运行方式，感兴趣的读者请参见我们提供的[多篇教程](./tutorials/mbqc)以了解量桨 MBQC 模块的使用方法和应用案例。 ### API 文档 @@ -238,11 +242,11 @@ Paddle Quantum 使用 setuptools 的 develop 模式进行安装，相关代码 1. 问：**研究量子机器学习有什么意义？它有哪些应用场景？** - 答：量子机器学习是将量子计算与机器学习相结合的一门学科，它一方面可以利用现有人工智能技术突破量子计算的研发瓶颈，另一方面也能利用量子计算的信息处理优势促进传统人工智能的发展。量子机器学习不仅适用于量子化学模拟（如[变分量子特征求解器 (VQE)](./tutorial/VQE)）等量子问题，也可以用来解决一些经典问题（如[量子近似优化算法 (QAOA)](./tutorial/QAOA)）。 + 答：量子机器学习是将量子计算与机器学习相结合的一门学科，它一方面可以利用现有人工智能技术突破量子计算的研发瓶颈，另一方面也能利用量子计算的信息处理优势促进传统人工智能的发展。量子机器学习不仅适用于量子化学模拟（如[变分量子特征求解器 (VQE)](./tutorials/VQE)）等量子问题，也可以用来解决一些经典问题（如[量子近似优化算法 (QAOA)](./tutorials/QAOA)）。 2. 问：**想做量子机器学习，但对量子计算不是很了解，该如何入门？** - 答：Nielsen 和 Chuang 所著的《量子计算与量子信息》是量子计算领域公认的经典入门教材。建议读者首先学习这本书的第一、二、四章，介绍了量子计算中的基本概念、数学和物理基础、以及量子电路模型。读者也可以阅读量桨的[入门手册](./introduction)，其中包含了对量子计算的简单介绍，并有互动性的例子供读者尝试。对量子计算有了大致了解后，读者可以尝试学习量桨提供的一些前沿[量子机器学习案例](./tutorial)。 + 答：Nielsen 和 Chuang 所著的《量子计算与量子信息》是量子计算领域公认的经典入门教材。建议读者首先学习这本书的第一、二、四章，介绍了量子计算中的基本概念、数学和物理基础、以及量子电路模型。读者也可以阅读量桨的[入门手册](./introduction)，其中包含了对量子计算的简单介绍，并有互动性的例子供读者尝试。对量子计算有了大致了解后，读者可以尝试学习量桨提供的一些前沿[量子机器学习案例](./tutorials)。 3. 问：**现阶段没有规模化的量子硬件，怎么开发量子应用？** @@ -250,7 +254,7 @@ Paddle Quantum 使用 setuptools 的 develop 模式进行安装，相关代码 4. 问：**量桨有哪些优势？** - 答：量桨是基于百度飞桨开发的量子机器学习工具集。飞桨作为国内首个开源开放的产业级深度学习平台，技术领先且功能完备。拥有飞桨的技术支持，特别是其强大的动态图机制，量桨可以方便地进行机器学习的优化以及 GPU 的加速。同时，基于百度量子计算研究所研发的高性能量子模拟器，量桨在个人笔记本电脑上也能支持20多个量子比特的运算。另外，量桨还有丰富的[量子机器学习案例](./tutorial)供大家参考和学习。 + 答：量桨是基于百度飞桨开发的量子机器学习工具集。飞桨作为国内首个开源开放的产业级深度学习平台，技术领先且功能完备。拥有飞桨的技术支持，特别是其强大的动态图机制，量桨可以方便地进行机器学习的优化以及 GPU 的加速。同时，基于百度量子计算研究所研发的高性能量子模拟器，量桨在个人笔记本电脑上也能支持20多个量子比特的运算。另外，量桨还有丰富的[量子机器学习案例](./tutorials)供大家参考和学习。 ## Copyright and License diff --git a/docs/Makefile b/docs/Makefile new file mode 100644 index 0000000..d0c3cbf --- /dev/null +++ b/docs/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = source +BUILDDIR = build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs/make.bat b/docs/make.bat new file mode 100644 index 0000000..747ffb7 --- /dev/null +++ b/docs/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=source +set BUILDDIR=build + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.https://www.sphinx-doc.org/ + exit /b 1 +) + +if "%1" == "" goto help + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/docs/source/conf.py b/docs/source/conf.py new file mode 100644 index 0000000..691f71f --- /dev/null +++ b/docs/source/conf.py @@ -0,0 +1,72 @@ +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +# import os +# import sys +# sys.path.insert(0, os.path.abspath('.')) + + +# -- Project information ----------------------------------------------------- + +project = 'paddle-quantum' +copyright = '2022, Baidu Inc' +author = 'Baidu Inc' + +# The full version, including alpha/beta/rc tags +release = '2.2.0' + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + 'sphinx.ext.autodoc', + 'sphinx.ext.napoleon', + 'sphinx.ext.mathjax', + 'sphinx.ext.todo', + 'sphinx_search.extension', +] + + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = [] + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = 'sphinx_rtd_theme' + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['_static'] + +master_doc = 'index' + +# Autodoc +napoleon_numpy_docstring = False +autodoc_member_order = 'bysource' +autodoc_typehints = 'description' +autodoc_warningiserror = False +autodoc_inherit_docstrings = False +autodoc_docstring_signature = False +autodoc_typehints_description_target = 'documented' +autodoc_typehints_format = 'short' diff --git a/docs/source/index.rst b/docs/source/index.rst new file mode 100644 index 0000000..80905f6 --- /dev/null +++ b/docs/source/index.rst @@ -0,0 +1,20 @@ +.. paddle-quantum documentation master file, created by + sphinx-quickstart on Tue May 10 13:46:49 2022. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +Welcome to Paddle Quantum's documentation! +========================================== + +.. toctree:: + :maxdepth: 2 + :caption: Getting Started with Paddle Quantum + + introduction + tutorial + +.. toctree:: + :maxdepth: 1 + :caption: API Documentation + + modules diff --git a/docs/source/introduction.rst b/docs/source/introduction.rst new file mode 100644 index 0000000..b413171 --- /dev/null +++ b/docs/source/introduction.rst @@ -0,0 +1,126 @@ +.. _header-n0: + +Paddle Quantum +======================= + +`Paddle Quantum `__\ is a quantum machine learning toolkit developed based on Baidu PaddlePaddle. It provides a platform to construct and train quantum neural networks (QNN) with easy-to-use QML development kits supporting combinatorial optimization, quantum chemistry and other cutting-edge quantum applications, making PaddlePaddle the first deep learning framework in China that supports quantum machine learning. + +.. figure:: https://release-data.cdn.bcebos.com/Paddle%20Quantum.png + :target: https://github.com/PaddlePaddle/Quantum + +Paddle Quantum has established a bridge between artificial intelligence and quantum computing. Through the Baidu PaddlePaddle deep learning platform to empower quantum computing, Paddle Quantum provides a powerful tool for people in the quantum AI industry and a feasible learning path for quantum computing enthusiasts. + + For more information about Paddle Quantum, please check the GitHub page: https://github.com/PaddlePaddle/Quantum + +.. _header-n6: + +Features +-------- + +- Easy-to-use + + - Many online learning resources (Nearly 40 tutorials) + - High efficiency in building QNN with various QNN templates + - Automatic differentiation + +- Versatile + + - Multiple optimization tools and GPU mode + - Simulation with 25+ qubits + - Flexible noise models + +- Featured Toolkits + + - Toolboxes for Chemistry & Optimization + - LOCCNet for distributed quantum information processing + - Self-developed quantum machine learning algorithms + +.. _header-n15: + +Install +-------- + +.. _header-n16: + +Install PaddlePaddle +~~~~~~~~~~~~~~~~~~~~ + +This dependency will be automatically satisfied when users install Paddle Quantum. Please refer to `PaddlePaddle `__ Install and configuration page. This project requires PaddlePaddle 2.2.0+. + +.. _header-n19: + +Install Paddle Quantum +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +We recommend installing Paddle Quantum with ``pip`` , + +.. code:: shell + + pip install paddle-quantum + +or download all the files and finish the installation locally, + +.. code:: shell + + git clone http://github.com/PaddlePaddle/quantum + +.. code:: shell + + cd quantum + pip install -e . + +.. _header-n25: + +Environment setup for Quantum Chemistry module +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +Our `qchem` module is based on `Psi4`, so before executing quantum chemistry, we have to install this Python package. + +.. note:: + + It is recommended that `Psi4` is installed in a Python 3.8 environment. + +We highly recommend you to install ``Psi4`` via conda. MacOS/Linux user can use the command + +.. code:: shell + + conda install psi4 -c psi4 + +For **Windows** user, the command is + +.. code:: shell + + conda install psi4 -c psi4 -c conda-forge + +**Note:** Please refer to `Psi4 `__\ for more download options. + +.. _header-n29: + +Run programs +~~~~~~~~~~~~ + +Now, you can try to run a program to verify whether the Paddle Quantum has been installed successfully. Here we take quantum approximate optimization algorithm (QAOA) as an example. + +.. code:: shell + + cd paddle_quantum/QAOA/example + python main.py + +.. + +.. note:: For the introduction of QAOA, please refer to our `QAOA tutorial `__. + +.. _header-n51: + +Feedbacks +---------- + +- Users are encouraged to report issues and submit suggestions on `Github Issues `__. +- QQ group: 1076223166 + +.. _header-n118: + +Copyright and License +--------------------- + +Paddle Quantum uses the `Apache-2.0 license `__ License. diff --git a/docs/source/locale/en/LC_MESSAGES/index.po b/docs/source/locale/en/LC_MESSAGES/index.po new file mode 100644 index 0000000..f0b95c5 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/index.po @@ -0,0 +1,32 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/index.rst:9 +msgid "Getting Started with Paddle Quantum" +msgstr "" + +#: ../../source/index.rst:16 +msgid "API Documentation" +msgstr "" + +#: ../../source/index.rst:7 +msgid "Welcome to Paddle Quantum's documentation!" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/introduction.po b/docs/source/locale/en/LC_MESSAGES/introduction.po new file mode 100644 index 0000000..36a1b8c --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/introduction.po @@ -0,0 +1,202 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/introduction.rst:4 +msgid "Paddle Quantum" +msgstr "" + +#: ../../source/introduction.rst:6 +msgid "" +"`Paddle Quantum `__\\ is a " +"quantum machine learning toolkit developed based on Baidu PaddlePaddle. " +"It provides a platform to construct and train quantum neural networks " +"(QNN) with easy-to-use QML development kits supporting combinatorial " +"optimization, quantum chemistry and other cutting-edge quantum " +"applications, making PaddlePaddle the first deep learning framework in " +"China that supports quantum machine learning." +msgstr "" + +#: ../../source/introduction.rst:11 +msgid "" +"Paddle Quantum has established a bridge between artificial intelligence " +"and quantum computing. Through the Baidu PaddlePaddle deep learning " +"platform to empower quantum computing, Paddle Quantum provides a powerful" +" tool for people in the quantum AI industry and a feasible learning path " +"for quantum computing enthusiasts." +msgstr "" + +#: ../../source/introduction.rst:13 +msgid "" +"For more information about Paddle Quantum, please check the GitHub page: " +"https://github.com/PaddlePaddle/Quantum" +msgstr "" + +#: ../../source/introduction.rst:18 +msgid "Features" +msgstr "" + +#: ../../source/introduction.rst:20 +msgid "Easy-to-use" +msgstr "" + +#: ../../source/introduction.rst:22 +msgid "Many online learning resources (Nearly 40 tutorials)" +msgstr "" + +#: ../../source/introduction.rst:23 +msgid "High efficiency in building QNN with various QNN templates" +msgstr "" + +#: ../../source/introduction.rst:24 +msgid "Automatic differentiation" +msgstr "" + +#: ../../source/introduction.rst:26 +msgid "Versatile" +msgstr "" + +#: ../../source/introduction.rst:28 +msgid "Multiple optimization tools and GPU mode" +msgstr "" + +#: ../../source/introduction.rst:29 +msgid "Simulation with 25+ qubits" +msgstr "" + +#: ../../source/introduction.rst:30 +msgid "Flexible noise models" +msgstr "" + +#: ../../source/introduction.rst:32 +msgid "Featured Toolkits" +msgstr "" + +#: ../../source/introduction.rst:34 +msgid "Toolboxes for Chemistry & Optimization" +msgstr "" + +#: ../../source/introduction.rst:35 +msgid "LOCCNet for distributed quantum information processing" +msgstr "" + +#: ../../source/introduction.rst:36 +msgid "Self-developed quantum machine learning algorithms" +msgstr "" + +#: ../../source/introduction.rst:41 +msgid "Install" +msgstr "" + +#: ../../source/introduction.rst:46 +msgid "Install PaddlePaddle" +msgstr "" + +#: ../../source/introduction.rst:48 +msgid "" +"This dependency will be automatically satisfied when users install Paddle" +" Quantum. Please refer to `PaddlePaddle " +"`__ Install and " +"configuration page. This project requires PaddlePaddle 2.2.0+." +msgstr "" + +#: ../../source/introduction.rst:53 +msgid "Install Paddle Quantum" +msgstr "" + +#: ../../source/introduction.rst:55 +msgid "We recommend installing Paddle Quantum with ``pip`` ," +msgstr "" + +#: ../../source/introduction.rst:61 +msgid "or download all the files and finish the installation locally," +msgstr "" + +#: ../../source/introduction.rst:75 +msgid "Environment setup for Quantum Chemistry module" +msgstr "" + +#: ../../source/introduction.rst:77 +msgid "" +"Our `qchem` module is based on `Psi4`, so before executing quantum " +"chemistry, we have to install this Python package." +msgstr "" + +#: ../../source/introduction.rst:81 +msgid "It is recommended that `Psi4` is installed in a Python 3.8 environment." +msgstr "" + +#: ../../source/introduction.rst:83 +msgid "" +"We highly recommend you to install ``Psi4`` via conda. MacOS/Linux user " +"can use the command" +msgstr "" + +#: ../../source/introduction.rst:89 +msgid "For **Windows** user, the command is" +msgstr "" + +#: ../../source/introduction.rst:95 +msgid "" +"**Note:** Please refer to `Psi4 `__\\" +" for more download options." +msgstr "" + +#: ../../source/introduction.rst:100 +msgid "Run programs" +msgstr "" + +#: ../../source/introduction.rst:102 +msgid "" +"Now, you can try to run a program to verify whether the Paddle Quantum " +"has been installed successfully. Here we take quantum approximate " +"optimization algorithm (QAOA) as an example." +msgstr "" + +#: ../../source/introduction.rst:111 +msgid "" +"For the introduction of QAOA, please refer to our `QAOA tutorial " +"`__." +msgstr "" + +#: ../../source/introduction.rst:116 +msgid "Feedbacks" +msgstr "" + +#: ../../source/introduction.rst:118 +msgid "" +"Users are encouraged to report issues and submit suggestions on `Github " +"Issues `__." +msgstr "" + +#: ../../source/introduction.rst:119 +msgid "QQ group: 1076223166" +msgstr "" + +#: ../../source/introduction.rst:124 +msgid "Copyright and License" +msgstr "" + +#: ../../source/introduction.rst:126 +msgid "" +"Paddle Quantum uses the `Apache-2.0 license " +"`__ License." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/modules.po b/docs/source/locale/en/LC_MESSAGES/modules.po new file mode 100644 index 0000000..e9a45b4 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/modules.po @@ -0,0 +1,20 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.ansatz.circuit.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.ansatz.circuit.po new file mode 100644 index 0000000..bacfec6 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.ansatz.circuit.po @@ -0,0 +1,1004 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.ansatz.circuit.rst:2 +msgid "paddle\\_quantum.ansatz.circuit" +msgstr "" + +#: of paddle_quantum.ansatz.circuit:1 +msgid "The source file of the Circuit class." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit:1 +msgid "Bases: :py:class:`~paddle_quantum.ansatz.container.Sequential`" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit:1 +msgid "Quantum circuit." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit +#: paddle_quantum.ansatz.circuit.Circuit.amplitude_damping +#: paddle_quantum.ansatz.circuit.Circuit.bit_flip +#: paddle_quantum.ansatz.circuit.Circuit.bit_phase_flip +#: paddle_quantum.ansatz.circuit.Circuit.ccx +#: paddle_quantum.ansatz.circuit.Circuit.cnot +#: paddle_quantum.ansatz.circuit.Circuit.complex_block_layer +#: paddle_quantum.ansatz.circuit.Circuit.complex_entangled_layer +#: paddle_quantum.ansatz.circuit.Circuit.control_oracle +#: paddle_quantum.ansatz.circuit.Circuit.cp +#: paddle_quantum.ansatz.circuit.Circuit.crx +#: paddle_quantum.ansatz.circuit.Circuit.cry +#: paddle_quantum.ansatz.circuit.Circuit.crz +#: paddle_quantum.ansatz.circuit.Circuit.cswap +#: paddle_quantum.ansatz.circuit.Circuit.cu +#: paddle_quantum.ansatz.circuit.Circuit.cx +#: paddle_quantum.ansatz.circuit.Circuit.cy +#: paddle_quantum.ansatz.circuit.Circuit.cz +#: paddle_quantum.ansatz.circuit.Circuit.depolarizing +#: paddle_quantum.ansatz.circuit.Circuit.forward +#: paddle_quantum.ansatz.circuit.Circuit.generalized_amplitude_damping +#: paddle_quantum.ansatz.circuit.Circuit.h +#: paddle_quantum.ansatz.circuit.Circuit.kraus_repr +#: paddle_quantum.ansatz.circuit.Circuit.linear_entangled_layer +#: paddle_quantum.ansatz.circuit.Circuit.ms +#: paddle_quantum.ansatz.circuit.Circuit.oracle +#: paddle_quantum.ansatz.circuit.Circuit.p +#: paddle_quantum.ansatz.circuit.Circuit.pauli_channel +#: paddle_quantum.ansatz.circuit.Circuit.phase_damping +#: paddle_quantum.ansatz.circuit.Circuit.phase_flip +#: paddle_quantum.ansatz.circuit.Circuit.randomize_param +#: paddle_quantum.ansatz.circuit.Circuit.real_block_layer +#: paddle_quantum.ansatz.circuit.Circuit.real_entangled_layer +#: paddle_quantum.ansatz.circuit.Circuit.reset_channel +#: paddle_quantum.ansatz.circuit.Circuit.rx +#: paddle_quantum.ansatz.circuit.Circuit.rxx +#: paddle_quantum.ansatz.circuit.Circuit.ry +#: paddle_quantum.ansatz.circuit.Circuit.ryy +#: paddle_quantum.ansatz.circuit.Circuit.rz +#: paddle_quantum.ansatz.circuit.Circuit.rzz +#: paddle_quantum.ansatz.circuit.Circuit.s +#: paddle_quantum.ansatz.circuit.Circuit.superposition_layer +#: paddle_quantum.ansatz.circuit.Circuit.swap +#: paddle_quantum.ansatz.circuit.Circuit.t +#: paddle_quantum.ansatz.circuit.Circuit.thermal_relaxation +#: paddle_quantum.ansatz.circuit.Circuit.u3 +#: paddle_quantum.ansatz.circuit.Circuit.unitary_matrix +#: paddle_quantum.ansatz.circuit.Circuit.universal_three_qubits +#: paddle_quantum.ansatz.circuit.Circuit.universal_two_qubits +#: paddle_quantum.ansatz.circuit.Circuit.update_param +#: paddle_quantum.ansatz.circuit.Circuit.weak_superposition_layer +#: paddle_quantum.ansatz.circuit.Circuit.x +#: paddle_quantum.ansatz.circuit.Circuit.y +#: paddle_quantum.ansatz.circuit.Circuit.z +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit:3 +msgid "Number of qubits. Defaults to None." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.isdynamic:1 +msgid "Whether the circuit is dynamic" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.num_qubits:1 +msgid "Number of qubits." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.param:1 +msgid "Flattened parameters in the circuit." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.grad:1 +msgid "Gradients with respect to the flattened parameters." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.update_param:1 +msgid "Replace parameters of all/one layer(s) by ``theta``." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.update_param:3 +msgid "New parameters" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.update_param:4 +msgid "Index of replacement. Defaults to None, refering to all layers." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.randomize_param:1 +msgid "Randomize parameters of the circuit in a range from low to high." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.randomize_param:3 +msgid "Lower bound." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.randomize_param:4 +msgid "Upper bound." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.h:1 +msgid "Add single-qubit Hadamard gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.ccx:3 +#: paddle_quantum.ansatz.circuit.Circuit.cswap:3 +#: paddle_quantum.ansatz.circuit.Circuit.h:3 +#: paddle_quantum.ansatz.circuit.Circuit.ms:3 +#: paddle_quantum.ansatz.circuit.Circuit.p:3 +#: paddle_quantum.ansatz.circuit.Circuit.rx:3 +#: paddle_quantum.ansatz.circuit.Circuit.rxx:3 +#: paddle_quantum.ansatz.circuit.Circuit.ry:3 +#: paddle_quantum.ansatz.circuit.Circuit.ryy:3 +#: paddle_quantum.ansatz.circuit.Circuit.rz:3 +#: paddle_quantum.ansatz.circuit.Circuit.rzz:3 +#: paddle_quantum.ansatz.circuit.Circuit.s:3 +#: paddle_quantum.ansatz.circuit.Circuit.swap:3 +#: paddle_quantum.ansatz.circuit.Circuit.t:3 +#: paddle_quantum.ansatz.circuit.Circuit.u3:3 +#: paddle_quantum.ansatz.circuit.Circuit.x:3 +#: paddle_quantum.ansatz.circuit.Circuit.y:3 +#: paddle_quantum.ansatz.circuit.Circuit.z:3 +msgid "The matrix form of such a gate is:" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.h:5 +msgid "" +"H = \\frac{1}{\\sqrt{2}}\n" +" \\begin{bmatrix}\n" +" 1&1\\\\\n" +" 1&-1\n" +" \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.complex_block_layer:3 +#: paddle_quantum.ansatz.circuit.Circuit.complex_entangled_layer:3 +#: paddle_quantum.ansatz.circuit.Circuit.h:13 +#: paddle_quantum.ansatz.circuit.Circuit.linear_entangled_layer:3 +#: paddle_quantum.ansatz.circuit.Circuit.p:12 +#: paddle_quantum.ansatz.circuit.Circuit.real_block_layer:3 +#: paddle_quantum.ansatz.circuit.Circuit.real_entangled_layer:3 +#: paddle_quantum.ansatz.circuit.Circuit.rx:12 +#: paddle_quantum.ansatz.circuit.Circuit.ry:12 +#: paddle_quantum.ansatz.circuit.Circuit.rz:12 +#: paddle_quantum.ansatz.circuit.Circuit.s:13 +#: paddle_quantum.ansatz.circuit.Circuit.superposition_layer:3 +#: paddle_quantum.ansatz.circuit.Circuit.t:13 +#: paddle_quantum.ansatz.circuit.Circuit.u3:15 +#: paddle_quantum.ansatz.circuit.Circuit.weak_superposition_layer:3 +#: paddle_quantum.ansatz.circuit.Circuit.x:12 +#: paddle_quantum.ansatz.circuit.Circuit.y:12 +#: paddle_quantum.ansatz.circuit.Circuit.z:12 +msgid "Indices of the qubits on which the gates are applied. Defaults to 'full'." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.amplitude_damping:5 +#: paddle_quantum.ansatz.circuit.Circuit.bit_flip:5 +#: paddle_quantum.ansatz.circuit.Circuit.bit_phase_flip:5 +#: paddle_quantum.ansatz.circuit.Circuit.ccx:21 +#: paddle_quantum.ansatz.circuit.Circuit.cnot:19 +#: paddle_quantum.ansatz.circuit.Circuit.complex_block_layer:4 +#: paddle_quantum.ansatz.circuit.Circuit.complex_entangled_layer:4 +#: paddle_quantum.ansatz.circuit.Circuit.control_oracle:5 +#: paddle_quantum.ansatz.circuit.Circuit.cp:18 +#: paddle_quantum.ansatz.circuit.Circuit.crx:19 +#: paddle_quantum.ansatz.circuit.Circuit.cry:19 +#: paddle_quantum.ansatz.circuit.Circuit.crz:19 +#: paddle_quantum.ansatz.circuit.Circuit.cswap:22 +#: paddle_quantum.ansatz.circuit.Circuit.cu:19 +#: paddle_quantum.ansatz.circuit.Circuit.cx:4 +#: paddle_quantum.ansatz.circuit.Circuit.cy:19 +#: paddle_quantum.ansatz.circuit.Circuit.cz:19 +#: paddle_quantum.ansatz.circuit.Circuit.depolarizing:5 +#: paddle_quantum.ansatz.circuit.Circuit.generalized_amplitude_damping:6 +#: paddle_quantum.ansatz.circuit.Circuit.h:14 +#: paddle_quantum.ansatz.circuit.Circuit.kraus_repr:5 +#: paddle_quantum.ansatz.circuit.Circuit.linear_entangled_layer:4 +#: paddle_quantum.ansatz.circuit.Circuit.ms:18 +#: paddle_quantum.ansatz.circuit.Circuit.oracle:5 +#: paddle_quantum.ansatz.circuit.Circuit.p:13 +#: paddle_quantum.ansatz.circuit.Circuit.pauli_channel:5 +#: paddle_quantum.ansatz.circuit.Circuit.phase_damping:5 +#: paddle_quantum.ansatz.circuit.Circuit.phase_flip:5 +#: paddle_quantum.ansatz.circuit.Circuit.real_block_layer:4 +#: paddle_quantum.ansatz.circuit.Circuit.real_entangled_layer:4 +#: paddle_quantum.ansatz.circuit.Circuit.reset_channel:5 +#: paddle_quantum.ansatz.circuit.Circuit.rx:13 +#: paddle_quantum.ansatz.circuit.Circuit.rxx:18 +#: paddle_quantum.ansatz.circuit.Circuit.ry:13 +#: paddle_quantum.ansatz.circuit.Circuit.ryy:18 +#: paddle_quantum.ansatz.circuit.Circuit.rz:13 +#: paddle_quantum.ansatz.circuit.Circuit.rzz:18 +#: paddle_quantum.ansatz.circuit.Circuit.s:14 +#: paddle_quantum.ansatz.circuit.Circuit.superposition_layer:4 +#: paddle_quantum.ansatz.circuit.Circuit.swap:18 +#: paddle_quantum.ansatz.circuit.Circuit.t:14 +#: paddle_quantum.ansatz.circuit.Circuit.thermal_relaxation:6 +#: paddle_quantum.ansatz.circuit.Circuit.u3:16 +#: paddle_quantum.ansatz.circuit.Circuit.unitary_matrix:3 +#: paddle_quantum.ansatz.circuit.Circuit.universal_three_qubits:4 +#: paddle_quantum.ansatz.circuit.Circuit.universal_two_qubits:4 +#: paddle_quantum.ansatz.circuit.Circuit.weak_superposition_layer:4 +#: paddle_quantum.ansatz.circuit.Circuit.x:13 +#: paddle_quantum.ansatz.circuit.Circuit.y:13 +#: paddle_quantum.ansatz.circuit.Circuit.z:13 +msgid "Total number of qubits. Defaults to None." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.ccx:22 +#: paddle_quantum.ansatz.circuit.Circuit.cnot:20 +#: paddle_quantum.ansatz.circuit.Circuit.complex_block_layer:5 +#: paddle_quantum.ansatz.circuit.Circuit.complex_entangled_layer:5 +#: paddle_quantum.ansatz.circuit.Circuit.control_oracle:6 +#: paddle_quantum.ansatz.circuit.Circuit.cp:19 +#: paddle_quantum.ansatz.circuit.Circuit.crx:20 +#: paddle_quantum.ansatz.circuit.Circuit.cry:20 +#: paddle_quantum.ansatz.circuit.Circuit.crz:20 +#: paddle_quantum.ansatz.circuit.Circuit.cswap:23 +#: paddle_quantum.ansatz.circuit.Circuit.cu:20 +#: paddle_quantum.ansatz.circuit.Circuit.cx:5 +#: paddle_quantum.ansatz.circuit.Circuit.cy:20 +#: paddle_quantum.ansatz.circuit.Circuit.cz:20 +#: paddle_quantum.ansatz.circuit.Circuit.h:15 +#: paddle_quantum.ansatz.circuit.Circuit.linear_entangled_layer:5 +#: paddle_quantum.ansatz.circuit.Circuit.ms:19 +#: paddle_quantum.ansatz.circuit.Circuit.oracle:6 +#: paddle_quantum.ansatz.circuit.Circuit.p:14 +#: paddle_quantum.ansatz.circuit.Circuit.real_block_layer:5 +#: paddle_quantum.ansatz.circuit.Circuit.real_entangled_layer:5 +#: paddle_quantum.ansatz.circuit.Circuit.rx:14 +#: paddle_quantum.ansatz.circuit.Circuit.rxx:19 +#: paddle_quantum.ansatz.circuit.Circuit.ry:14 +#: paddle_quantum.ansatz.circuit.Circuit.ryy:19 +#: paddle_quantum.ansatz.circuit.Circuit.rz:14 +#: paddle_quantum.ansatz.circuit.Circuit.rzz:19 +#: paddle_quantum.ansatz.circuit.Circuit.s:15 +#: paddle_quantum.ansatz.circuit.Circuit.superposition_layer:5 +#: paddle_quantum.ansatz.circuit.Circuit.swap:19 +#: paddle_quantum.ansatz.circuit.Circuit.t:15 +#: paddle_quantum.ansatz.circuit.Circuit.u3:17 +#: paddle_quantum.ansatz.circuit.Circuit.universal_three_qubits:5 +#: paddle_quantum.ansatz.circuit.Circuit.universal_two_qubits:5 +#: paddle_quantum.ansatz.circuit.Circuit.weak_superposition_layer:5 +#: paddle_quantum.ansatz.circuit.Circuit.x:14 +#: paddle_quantum.ansatz.circuit.Circuit.y:14 +#: paddle_quantum.ansatz.circuit.Circuit.z:14 +msgid "Number of layers. Defaults to 1." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.s:1 +msgid "Add single-qubit S gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.s:5 +msgid "" +"S =\n" +" \\begin{bmatrix}\n" +" 1&0\\\\\n" +" 0&i\n" +" \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.t:1 +msgid "Add single-qubit T gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.t:5 +msgid "" +"T =\n" +" \\begin{bmatrix}\n" +" 1&0\\\\\n" +" 0&e^\\frac{i\\pi}{4}\n" +" \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.x:1 +msgid "Add single-qubit X gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.x:5 +msgid "" +"\\begin{bmatrix}\n" +" 0 & 1 \\\\\n" +" 1 & 0\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.y:1 +msgid "Add single-qubit Y gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.y:5 +msgid "" +"\\begin{bmatrix}\n" +" 0 & -i \\\\\n" +" i & 0\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.z:1 +msgid "Add single-qubit Z gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.z:5 +msgid "" +"\\begin{bmatrix}\n" +" 1 & 0 \\\\\n" +" 0 & -1\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.p:1 +msgid "Add single-qubit P gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.p:5 +msgid "" +"\\begin{bmatrix}\n" +" 1 & 0 \\\\\n" +" 0 & e^{i\\theta}\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cp:20 +#: paddle_quantum.ansatz.circuit.Circuit.crx:21 +#: paddle_quantum.ansatz.circuit.Circuit.cry:21 +#: paddle_quantum.ansatz.circuit.Circuit.crz:21 +#: paddle_quantum.ansatz.circuit.Circuit.cu:21 +#: paddle_quantum.ansatz.circuit.Circuit.p:15 +#: paddle_quantum.ansatz.circuit.Circuit.rx:15 +#: paddle_quantum.ansatz.circuit.Circuit.rxx:20 +#: paddle_quantum.ansatz.circuit.Circuit.ry:15 +#: paddle_quantum.ansatz.circuit.Circuit.ryy:20 +#: paddle_quantum.ansatz.circuit.Circuit.rz:15 +#: paddle_quantum.ansatz.circuit.Circuit.rzz:20 +#: paddle_quantum.ansatz.circuit.Circuit.u3:18 +#: paddle_quantum.ansatz.circuit.Circuit.universal_three_qubits:6 +#: paddle_quantum.ansatz.circuit.Circuit.universal_two_qubits:6 +msgid "Parameters of the gates. Defaults to None." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cp:21 +#: paddle_quantum.ansatz.circuit.Circuit.crx:22 +#: paddle_quantum.ansatz.circuit.Circuit.cry:22 +#: paddle_quantum.ansatz.circuit.Circuit.crz:22 +#: paddle_quantum.ansatz.circuit.Circuit.cu:22 +#: paddle_quantum.ansatz.circuit.Circuit.p:16 +#: paddle_quantum.ansatz.circuit.Circuit.rx:16 +#: paddle_quantum.ansatz.circuit.Circuit.rxx:21 +#: paddle_quantum.ansatz.circuit.Circuit.ry:16 +#: paddle_quantum.ansatz.circuit.Circuit.ryy:21 +#: paddle_quantum.ansatz.circuit.Circuit.rz:16 +#: paddle_quantum.ansatz.circuit.Circuit.rzz:21 +#: paddle_quantum.ansatz.circuit.Circuit.u3:19 +#: paddle_quantum.ansatz.circuit.Circuit.universal_three_qubits:7 +#: paddle_quantum.ansatz.circuit.Circuit.universal_two_qubits:7 +msgid "Whether gates in the same layer share a parameter. Defaults to False." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.rx:1 +msgid "Add single-qubit rotation gates about the x-axis." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.rx:5 +msgid "" +"\\begin{bmatrix}\n" +" \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\\n" +" -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2}\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.ry:1 +msgid "Add single-qubit rotation gates about the y-axis." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.ry:5 +msgid "" +"\\begin{bmatrix}\n" +" \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\\n" +" \\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2}\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.rz:1 +msgid "Add single-qubit rotation gates about the z-axis." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.rz:5 +msgid "" +"\\begin{bmatrix}\n" +" e^{-i\\frac{\\theta}{2}} & 0 \\\\\n" +" 0 & e^{i\\frac{\\theta}{2}}\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.u3:1 +msgid "Add single-qubit rotation gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.u3:5 +msgid "" +"\\begin{align}\n" +" U3(\\theta, \\phi, \\lambda) =\n" +" \\begin{bmatrix}\n" +" \\cos\\frac\\theta2&-e^{i\\lambda}\\sin\\frac\\theta2\\\\\n" +" " +"e^{i\\phi}\\sin\\frac\\theta2&e^{i(\\phi+\\lambda)}\\cos\\frac\\theta2\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cnot:1 +msgid "Add CNOT gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cnot:3 +#: paddle_quantum.ansatz.circuit.Circuit.cp:3 +#: paddle_quantum.ansatz.circuit.Circuit.crx:3 +#: paddle_quantum.ansatz.circuit.Circuit.cry:3 +#: paddle_quantum.ansatz.circuit.Circuit.crz:3 +#: paddle_quantum.ansatz.circuit.Circuit.cu:3 +#: paddle_quantum.ansatz.circuit.Circuit.cy:3 +#: paddle_quantum.ansatz.circuit.Circuit.cz:3 +msgid "" +"For a 2-qubit quantum circuit, when `qubits_idx` is `[0, 1]`, the matrix " +"form of such a gate is:" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cnot:5 +msgid "" +"\\begin{align}\n" +" CNOT &=|0\\rangle \\langle 0|\\otimes I + |1 \\rangle \\langle " +"1|\\otimes X\\\\\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 1 \\\\\n" +" 0 & 0 & 1 & 0\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.ccx:20 +#: paddle_quantum.ansatz.circuit.Circuit.cnot:18 +#: paddle_quantum.ansatz.circuit.Circuit.cp:17 +#: paddle_quantum.ansatz.circuit.Circuit.crx:18 +#: paddle_quantum.ansatz.circuit.Circuit.cry:18 +#: paddle_quantum.ansatz.circuit.Circuit.crz:18 +#: paddle_quantum.ansatz.circuit.Circuit.cswap:21 +#: paddle_quantum.ansatz.circuit.Circuit.cu:18 +#: paddle_quantum.ansatz.circuit.Circuit.cx:3 +#: paddle_quantum.ansatz.circuit.Circuit.cy:18 +#: paddle_quantum.ansatz.circuit.Circuit.cz:18 +#: paddle_quantum.ansatz.circuit.Circuit.ms:17 +#: paddle_quantum.ansatz.circuit.Circuit.rxx:17 +#: paddle_quantum.ansatz.circuit.Circuit.ryy:17 +#: paddle_quantum.ansatz.circuit.Circuit.rzz:17 +#: paddle_quantum.ansatz.circuit.Circuit.swap:17 +#: paddle_quantum.ansatz.circuit.Circuit.universal_three_qubits:3 +#: paddle_quantum.ansatz.circuit.Circuit.universal_two_qubits:3 +msgid "Indices of the qubits on which the gates are applied. Defaults to 'cycle'." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cx:1 +msgid "Same as cnot." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cy:1 +msgid "Add controlled Y gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cy:5 +msgid "" +"\\begin{align}\n" +" CY &=|0\\rangle \\langle 0|\\otimes I + |1 \\rangle \\langle " +"1|\\otimes Y\\\\\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & -1j \\\\\n" +" 0 & 0 & 1j & 0\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cz:1 +msgid "Add controlled Z gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cz:5 +msgid "" +"\\begin{align}\n" +" CZ &=|0\\rangle \\langle 0|\\otimes I + |1 \\rangle \\langle " +"1|\\otimes Z\\\\\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 1 & 0 \\\\\n" +" 0 & 0 & 0 & -1\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.swap:1 +msgid "Add SWAP gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.swap:5 +msgid "" +"\\begin{align}\n" +" SWAP =\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 1 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 1\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cp:1 +msgid "Add controlled P gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cp:5 +msgid "" +"\\begin{align}\n" +" SWAP =\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 1 & 0 \\\\\n" +" 0 & 0 & 0 & e^{i\\theta}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.crx:1 +msgid "Add controlled rotation gates about the x-axis." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.crx:5 +msgid "" +"\\begin{align}\n" +" CRx &=|0\\rangle \\langle 0|\\otimes I + |1 \\rangle \\langle " +"1|\\otimes Rx\\\\\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\\n" +" 0 & 0 & -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cry:1 +msgid "Add controlled rotation gates about the y-axis." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cry:5 +msgid "" +"\\begin{align}\n" +" CRy &=|0\\rangle \\langle 0|\\otimes I + |1 \\rangle \\langle " +"1|\\otimes Ry\\\\\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\\n" +" 0 & 0 & \\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.crz:1 +msgid "Add controlled rotation gates about the z-axis." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.crz:5 +msgid "" +"\\begin{align}\n" +" CRz &=|0\\rangle \\langle 0|\\otimes I + |1 \\rangle \\langle " +"1|\\otimes Rz\\\\\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 1 & 0 \\\\\n" +" 0 & 0 & 0 & e^{i\\theta}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cu:1 +msgid "Add controlled single-qubit rotation gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cu:5 +msgid "" +"\\begin{align}\n" +" CU\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & \\cos\\frac\\theta2 &-e^{i\\lambda}\\sin\\frac\\theta2 " +"\\\\\n" +" 0 & 0 & " +"e^{i\\phi}\\sin\\frac\\theta2&e^{i(\\phi+\\lambda)}\\cos\\frac\\theta2\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.rxx:1 +msgid "Add RXX gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.rxx:5 +msgid "" +"\\begin{align}\n" +" RXX(\\theta) =\n" +" \\begin{bmatrix}\n" +" \\cos\\frac{\\theta}{2} & 0 & 0 & -i\\sin\\frac{\\theta}{2} " +"\\\\\n" +" 0 & \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} & 0 " +"\\\\\n" +" 0 & -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} & 0 " +"\\\\\n" +" -i\\sin\\frac{\\theta}{2} & 0 & 0 & \\cos\\frac{\\theta}{2}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.ryy:1 +msgid "Add RYY gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.ryy:5 +msgid "" +"\\begin{align}\n" +" RYY(\\theta) =\n" +" \\begin{bmatrix}\n" +" \\cos\\frac{\\theta}{2} & 0 & 0 & i\\sin\\frac{\\theta}{2} " +"\\\\\n" +" 0 & \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} & 0 " +"\\\\\n" +" 0 & -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} & 0 " +"\\\\\n" +" i\\sin\\frac{\\theta}{2} & 0 & 0 & cos\\frac{\\theta}{2}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.rzz:1 +msgid "Add RZZ gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.rzz:5 +msgid "" +"\\begin{align}\n" +" RZZ(\\theta) =\n" +" \\begin{bmatrix}\n" +" e^{-i\\frac{\\theta}{2}} & 0 & 0 & 0 \\\\\n" +" 0 & e^{i\\frac{\\theta}{2}} & 0 & 0 \\\\\n" +" 0 & 0 & e^{i\\frac{\\theta}{2}} & 0 \\\\\n" +" 0 & 0 & 0 & e^{-i\\frac{\\theta}{2}}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.ms:1 +msgid "Add Mølmer-Sørensen (MS) gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.ms:5 +msgid "" +"\\begin{align}\n" +" MS = RXX(-\\frac{\\pi}{2}) = \\frac{1}{\\sqrt{2}}\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & i \\\\\n" +" 0 & 1 & i & 0 \\\\\n" +" 0 & i & 1 & 0 \\\\\n" +" i & 0 & 0 & 1\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cswap:1 +msgid "Add CSWAP (Fredkin) gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.cswap:5 +msgid "" +"\\begin{align}\n" +" CSWAP =\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.ccx:1 +msgid "Add Toffoli gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.ccx:5 +msgid "" +"\\begin{align}\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\\\\n" +" 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\n" +" \\end{bmatrix}\n" +" \\end{align}" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.universal_two_qubits:1 +msgid "Add universal two-qubit gates. One of such a gate requires 15 parameters." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.universal_three_qubits:1 +msgid "" +"Add universal three-qubit gates. One of such a gate requires 81 " +"parameters." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.universal_three_qubits +msgid "Raises" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.universal_three_qubits:9 +msgid "The ``param`` must be paddle.Tensor or float." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.oracle:1 +msgid "Add an oracle gate." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.control_oracle:3 +#: paddle_quantum.ansatz.circuit.Circuit.oracle:3 +msgid "Unitary oracle to be implemented." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.control_oracle:4 +#: paddle_quantum.ansatz.circuit.Circuit.oracle:4 +msgid "Indices of the qubits on which the gates are applied." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.control_oracle:1 +msgid "Add a controlled oracle gate." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.superposition_layer:1 +msgid "Add layers of Hadamard gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.weak_superposition_layer:1 +msgid "Add layers of Ry gates with a rotation angle :math:`\\pi/4`." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.linear_entangled_layer:1 +msgid "" +"Add linear entangled layers consisting of Ry gates, Rz gates, and CNOT " +"gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.real_entangled_layer:1 +msgid "Add strongly entangled layers consisting of Ry gates and CNOT gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.complex_entangled_layer:1 +msgid "" +"Add strongly entangled layers consisting of single-qubit rotation gates " +"and CNOT gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.real_block_layer:1 +msgid "Add weakly entangled layers consisting of Ry gates and CNOT gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.complex_block_layer:1 +msgid "" +"Add weakly entangled layers consisting of single-qubit rotation gates and" +" CNOT gates." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.bit_flip:1 +msgid "Add bit flip channels." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.bit_flip:3 +msgid "Probability of a bit flip." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.amplitude_damping:4 +#: paddle_quantum.ansatz.circuit.Circuit.bit_flip:4 +#: paddle_quantum.ansatz.circuit.Circuit.bit_phase_flip:4 +#: paddle_quantum.ansatz.circuit.Circuit.depolarizing:4 +#: paddle_quantum.ansatz.circuit.Circuit.generalized_amplitude_damping:5 +#: paddle_quantum.ansatz.circuit.Circuit.kraus_repr:4 +#: paddle_quantum.ansatz.circuit.Circuit.pauli_channel:4 +#: paddle_quantum.ansatz.circuit.Circuit.phase_damping:4 +#: paddle_quantum.ansatz.circuit.Circuit.phase_flip:4 +#: paddle_quantum.ansatz.circuit.Circuit.reset_channel:4 +#: paddle_quantum.ansatz.circuit.Circuit.thermal_relaxation:5 +msgid "" +"Indices of the qubits on which the channels are applied. Defaults to " +"'full'." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.phase_flip:1 +msgid "Add phase flip channels." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.phase_flip:3 +msgid "Probability of a phase flip." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.bit_phase_flip:1 +msgid "Add bit phase flip channels." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.bit_phase_flip:3 +msgid "Probability of a bit phase flip." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.amplitude_damping:1 +msgid "Add amplitude damping channels." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.amplitude_damping:3 +#: paddle_quantum.ansatz.circuit.Circuit.generalized_amplitude_damping:3 +msgid "Damping probability." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.generalized_amplitude_damping:1 +msgid "Add generalized amplitude damping channels." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.generalized_amplitude_damping:4 +msgid "Excitation probability." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.phase_damping:1 +msgid "Add phase damping channels." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.phase_damping:3 +msgid "Parameter of the phase damping channel." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.depolarizing:1 +msgid "Add depolarizing channels." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.depolarizing:3 +msgid "Parameter of the depolarizing channel." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.pauli_channel:1 +msgid "Add Pauli channels." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.pauli_channel:3 +msgid "Probabilities corresponding to the Pauli X, Y, and Z operators." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.reset_channel:1 +msgid "Add reset channels." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.reset_channel:3 +msgid "" +"Probabilities of resetting to :math:`|0\\rangle` and to " +":math:`|1\\rangle`." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.thermal_relaxation:1 +msgid "Add thermal relaxation channels." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.thermal_relaxation:3 +msgid ":math:`T_1` and :math:`T_2` relaxation time in microseconds." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.thermal_relaxation:4 +msgid "Quantum gate execution time in the process of relaxation in nanoseconds." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.kraus_repr:1 +msgid "Add custom channels in the Kraus representation." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.kraus_repr:3 +msgid "Kraus operators of this channel." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.unitary_matrix:1 +msgid "Get the unitary matrix form of the circuit." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.forward +#: paddle_quantum.ansatz.circuit.Circuit.gate_history +#: paddle_quantum.ansatz.circuit.Circuit.qubit_history +#: paddle_quantum.ansatz.circuit.Circuit.unitary_matrix +msgid "Returns" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.unitary_matrix:5 +msgid "Unitary matrix form of the circuit." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.forward +#: paddle_quantum.ansatz.circuit.Circuit.unitary_matrix +msgid "Return type" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.gate_history:1 +msgid "list of gates information of circuit" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.gate_history:3 +msgid "history of quantum gates of circuit" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.qubit_history:1 +msgid "gate information on each qubit" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.qubit_history:3 +msgid "list of gate history on each qubit" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.qubit_history:7 +msgid "" +"The entry ``qubit_history[i][j][0/1]`` returns the gate information / " +"gate index of the j-th gate applied on the i-th qubit." +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.forward:1 +msgid "forward the input" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.forward:3 +msgid "initial state" +msgstr "" + +#: of paddle_quantum.ansatz.circuit.Circuit.forward:5 +msgid "output quantum state" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.ansatz.container.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.ansatz.container.po new file mode 100644 index 0000000..22d0dce --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.ansatz.container.po @@ -0,0 +1,116 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.ansatz.container.rst:2 +msgid "paddle\\_quantum.ansatz.container" +msgstr "" + +#: of paddle_quantum.ansatz.container:1 +msgid "The source file of the Sequential class." +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential:1 +msgid "Bases: :py:class:`~paddle_quantum.base.Operator`" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential:1 +msgid "Sequential container." +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential +#: paddle_quantum.ansatz.container.Sequential.append +#: paddle_quantum.ansatz.container.Sequential.extend +#: paddle_quantum.ansatz.container.Sequential.forward +#: paddle_quantum.ansatz.container.Sequential.insert +#: paddle_quantum.ansatz.container.Sequential.pop +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential:3 +msgid "initial operators ready to be a sequential" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential:7 +msgid "" +"Sublayers will be added to this container in the order of argument in the" +" constructor. The argument passed to the constructor can be iterable " +"Layers or iterable name Layer pairs." +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.append:1 +msgid "append an operator" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.append:3 +msgid "operator with a name or just an operator" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.extend:1 +msgid "append a list of operators" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.extend:3 +msgid "list of operators" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.insert:1 +msgid "insert an operator at index ``index``" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.insert:3 +msgid "index to be inserted" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.insert:4 +msgid "an operator" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.pop:1 +msgid "remove the operator at index ``index`` or matched with ``operator``" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.pop:3 +msgid "at which the operator will be popped" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.pop:4 +msgid "matched with which the operator will be popped" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.forward:1 +msgid "forward the input" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.forward:3 +msgid "initial state" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.forward +msgid "Returns" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.forward:5 +msgid "output state" +msgstr "" + +#: of paddle_quantum.ansatz.container.Sequential.forward +msgid "Return type" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.ansatz.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.ansatz.po new file mode 100644 index 0000000..72b1617 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.ansatz.po @@ -0,0 +1,32 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.ansatz.rst:2 +msgid "paddle\\_quantum.ansatz" +msgstr "" + +#: of paddle_quantum.ansatz:1 +msgid "The module that contains the various ansatzes." +msgstr "" + +#: ../../source/paddle_quantum.ansatz.rst:9 +msgid "Submodules" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.ansatz.vans.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.ansatz.vans.po new file mode 100644 index 0000000..a2c39ae --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.ansatz.vans.po @@ -0,0 +1,215 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.ansatz.vans.rst:2 +msgid "paddle\\_quantum.ansatz.vans" +msgstr "" + +#: of paddle_quantum.ansatz.vans:1 +msgid "The source file of the variable ansatz." +msgstr "" + +#: of paddle_quantum.ansatz.vans.Inserter:1 +#: paddle_quantum.ansatz.vans.Simplifier:1 paddle_quantum.ansatz.vans.VAns:1 +msgid "Bases: :py:class:`object`" +msgstr "" + +#: of paddle_quantum.ansatz.vans.Inserter:1 +msgid "Class for block insertion for the circuit." +msgstr "" + +#: of paddle_quantum.ansatz.vans.Inserter.insert_identities:1 +msgid "" +"Insert identity blocks to the current circuit, according to the insert " +"rate." +msgstr "" + +#: of paddle_quantum.ansatz.vans.Inserter.insert_identities +#: paddle_quantum.ansatz.vans.Simplifier.simplify_circuit +#: paddle_quantum.ansatz.vans.VAns paddle_quantum.ansatz.vans.VAns.delete_gates +#: paddle_quantum.ansatz.vans.VAns.optimization +#: paddle_quantum.ansatz.vans.cir_decompose +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.ansatz.vans.Inserter.insert_identities:3 +#: paddle_quantum.ansatz.vans.Simplifier.simplify_circuit:3 +#: paddle_quantum.ansatz.vans.VAns.delete_gates:3 +#: paddle_quantum.ansatz.vans.VAns.optimization:3 +msgid "Quantum circuit." +msgstr "" + +#: of paddle_quantum.ansatz.vans.Inserter.insert_identities:4 +msgid "Rate of number of inserted blocks." +msgstr "" + +#: of paddle_quantum.ansatz.vans.Inserter.insert_identities:5 +msgid "Range of random initialization of parameters." +msgstr "" + +#: of paddle_quantum.ansatz.vans.Inserter.insert_identities +#: paddle_quantum.ansatz.vans.Simplifier.simplify_circuit +#: paddle_quantum.ansatz.vans.VAns.delete_gates +#: paddle_quantum.ansatz.vans.VAns.optimization +#: paddle_quantum.ansatz.vans.VAns.train +#: paddle_quantum.ansatz.vans.cir_decompose +msgid "Returns" +msgstr "" + +#: of paddle_quantum.ansatz.vans.Inserter.insert_identities:7 +msgid "Inserted circuit." +msgstr "" + +#: of paddle_quantum.ansatz.vans.Inserter.insert_identities +#: paddle_quantum.ansatz.vans.Simplifier.simplify_circuit +#: paddle_quantum.ansatz.vans.VAns.delete_gates +#: paddle_quantum.ansatz.vans.VAns.optimization +#: paddle_quantum.ansatz.vans.VAns.train +#: paddle_quantum.ansatz.vans.cir_decompose +msgid "Return type" +msgstr "" + +#: of paddle_quantum.ansatz.vans.Simplifier:1 +msgid "Class for circuit simplification." +msgstr "" + +#: of paddle_quantum.ansatz.vans.Simplifier.simplify_circuit:1 +msgid "Combine all simplifications together." +msgstr "" + +#: of paddle_quantum.ansatz.vans.Simplifier.simplify_circuit:4 +#: paddle_quantum.ansatz.vans.VAns:17 +msgid "Whether the initial state is :math:`|0\\rangle`. Defaults to ``True``." +msgstr "" + +#: of paddle_quantum.ansatz.vans.Simplifier.simplify_circuit:6 +msgid "Simplified circuit." +msgstr "" + +#: of paddle_quantum.ansatz.vans.cir_decompose:1 +msgid "Decompose all layers of circuit into gates." +msgstr "" + +#: of paddle_quantum.ansatz.vans.cir_decompose:3 +msgid "Target quantum circuit." +msgstr "" + +#: of paddle_quantum.ansatz.vans.cir_decompose:5 +msgid "" +"A quantum circuit with same structure and parameters but all layers are " +"decomposed into Gates." +msgstr "" + +#: of paddle_quantum.ansatz.vans.cir_decompose:7 +msgid "" +"This function does not support customized gates, such as oracle and " +"control-oracle." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:1 +msgid "Class of Variable Ansatz." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:3 +msgid "" +"User can initialize this class to find variational circuit to construct " +"QML model." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:5 +msgid "" +"The loss function passed in must have the quantum circuit as its first " +"parameter." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:7 +msgid "Number of qubits." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:8 +msgid "Loss function that evaluate the loss of circuit." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:9 +msgid "Parameters of loss function other than circuit." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:10 +msgid "Range of random initialization of parameters. Defaults to ``0.1``." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:11 +msgid "Rate of number of inserted blocks. Defaults to ``2``." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:12 +msgid "Number of iterations of optimizer. Defaults to ``100``." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:13 +msgid "Number of insert-simplify cycles. Defaults to ``10``." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:14 +msgid "Learning rate. Defaults to ``0.1``." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:15 +msgid "" +"Tolerance of incread loss after deleting one qubit gate. Defaults to " +"``0.002``." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns:16 +msgid "" +"Percentage of probability of accepting the circuit in current insert-" +"simplify cycle. Defaults to ``100``." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns.train:1 +msgid "Train the quantum circuit." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns.train:3 +msgid "The quantum circuit with the lowest loss." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns.optimization:1 +msgid "Optimize circuit parameters with loss function." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns.optimization:5 +msgid "Optimized loss." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns.delete_gates:1 +msgid "" +"Remove single qubit gates if the loss decreases or increases within a " +"threshold." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns.delete_gates:4 +msgid "Current loss." +msgstr "" + +#: of paddle_quantum.ansatz.vans.VAns.delete_gates:6 +msgid "Circuit after deleting unnecessary gates." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.density_matrix.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.density_matrix.po new file mode 100644 index 0000000..dfdfd3d --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.density_matrix.po @@ -0,0 +1,64 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.backend.density_matrix.rst:2 +msgid "paddle\\_quantum.backend.density\\_matrix" +msgstr "" + +#: of paddle_quantum.backend.density_matrix:1 +msgid "The source file of the density_matrix backend." +msgstr "" + +#: of paddle_quantum.backend.density_matrix.unitary_transformation:1 +msgid "The function of unitary transformation in the mode of density matrix." +msgstr "" + +#: of paddle_quantum.backend.density_matrix.unitary_transformation +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.backend.density_matrix.unitary_transformation:3 +msgid "The input quantum state." +msgstr "" + +#: of paddle_quantum.backend.density_matrix.unitary_transformation:4 +msgid "The gate that represents the unitary transformation." +msgstr "" + +#: of paddle_quantum.backend.density_matrix.unitary_transformation:5 +msgid "The indices of the qubits on which the gate is acted." +msgstr "" + +#: of paddle_quantum.backend.density_matrix.unitary_transformation:6 +msgid "The number of the qubits in the input quantum state." +msgstr "" + +#: of paddle_quantum.backend.density_matrix.unitary_transformation +msgid "Returns" +msgstr "" + +#: of paddle_quantum.backend.density_matrix.unitary_transformation:8 +msgid "The transformed quantum state." +msgstr "" + +#: of paddle_quantum.backend.density_matrix.unitary_transformation +msgid "Return type" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.po new file mode 100644 index 0000000..af99d55 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.po @@ -0,0 +1,40 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.backend.rst:2 +msgid "paddle\\_quantum.backend" +msgstr "" + +#: of paddle_quantum.backend:1 +msgid "The module that contains various backends." +msgstr "" + +#: of paddle_quantum.backend.Backend:1 +msgid "Bases: :py:class:`~enum.Enum`" +msgstr "" + +#: of paddle_quantum.backend.Backend:1 +msgid "An enumeration." +msgstr "" + +#: ../../source/paddle_quantum.backend.rst:10 +msgid "Submodules" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.quleaf.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.quleaf.po new file mode 100644 index 0000000..3afa8a5 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.quleaf.po @@ -0,0 +1,137 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.backend.quleaf.rst:2 +msgid "paddle\\_quantum.backend.quleaf" +msgstr "" + +#: of paddle_quantum.backend.quleaf:1 +msgid "The source file of the quleaf backend." +msgstr "" + +#: of paddle_quantum.backend.quleaf.set_quleaf_backend:1 +msgid "Set the backend of the QuLeaf." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.backward +#: paddle_quantum.backend.quleaf.ExpecValOp.forward +#: paddle_quantum.backend.quleaf.set_quleaf_backend +#: paddle_quantum.backend.quleaf.set_quleaf_token +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.backend.quleaf.set_quleaf_backend:3 +msgid "The backend you want to set." +msgstr "" + +#: of paddle_quantum.backend.quleaf.get_quleaf_backend:1 +msgid "Get the current backend of the QuLeaf." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.backward +#: paddle_quantum.backend.quleaf.ExpecValOp.forward +#: paddle_quantum.backend.quleaf.get_quleaf_backend +#: paddle_quantum.backend.quleaf.get_quleaf_token +msgid "Returns" +msgstr "" + +#: of paddle_quantum.backend.quleaf.get_quleaf_backend:3 +msgid "Current backend of the QuLeaf." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.backward +#: paddle_quantum.backend.quleaf.ExpecValOp.forward +#: paddle_quantum.backend.quleaf.get_quleaf_backend +#: paddle_quantum.backend.quleaf.get_quleaf_token +msgid "Return type" +msgstr "" + +#: of paddle_quantum.backend.quleaf.set_quleaf_token:1 +msgid "Set the token of the QuLeaf." +msgstr "" + +#: of paddle_quantum.backend.quleaf.set_quleaf_token:3 +msgid "You need to input your token if you want tu use the cloud server." +msgstr "" + +#: of paddle_quantum.backend.quleaf.set_quleaf_token:5 +msgid "Your token." +msgstr "" + +#: of paddle_quantum.backend.quleaf.get_quleaf_token:1 +msgid "Get the token you set." +msgstr "" + +#: of paddle_quantum.backend.quleaf.get_quleaf_token:3 +msgid "The token you set." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp:1 +msgid "Bases: :py:class:`~paddle.autograd.py_layer.PyLayer`" +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.forward:1 +msgid "" +"The forward function to compute the expectation value of the observable " +"in the QuLeaf Backend." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.forward:3 +msgid "To save some variables so that they can be used in the backward function." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.forward:4 +msgid "The parameters in the previous quantum gates." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.forward:5 +msgid "The quantum state to be measured." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.forward:6 +msgid "The observable." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.forward:7 +msgid "The number of measurement shots." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.forward:9 +msgid "The expectation value of the observable for the input state." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.backward:1 +msgid "" +"The backward function which is to compute the gradient of the input " +"parameters." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.backward:3 +msgid "To get the variables saved in the forward function." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.backward:4 +msgid "The gradient of the expectation value." +msgstr "" + +#: of paddle_quantum.backend.quleaf.ExpecValOp.backward:6 +msgid "The gradient of the parameters for the quantum gates." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.state_vector.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.state_vector.po new file mode 100644 index 0000000..dcce477 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.state_vector.po @@ -0,0 +1,64 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.backend.state_vector.rst:2 +msgid "paddle\\_quantum.backend.state\\_vector" +msgstr "" + +#: of paddle_quantum.backend.state_vector:1 +msgid "The source file of the state_vector backend." +msgstr "" + +#: of paddle_quantum.backend.state_vector.unitary_transformation:1 +msgid "The function of unitary transformation in the mode of state vector." +msgstr "" + +#: of paddle_quantum.backend.state_vector.unitary_transformation +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.backend.state_vector.unitary_transformation:3 +msgid "The input quantum state." +msgstr "" + +#: of paddle_quantum.backend.state_vector.unitary_transformation:4 +msgid "The gate that represents the unitary transformation." +msgstr "" + +#: of paddle_quantum.backend.state_vector.unitary_transformation:5 +msgid "The indices of the qubits on which the gate is acted." +msgstr "" + +#: of paddle_quantum.backend.state_vector.unitary_transformation:6 +msgid "The number of the qubits in the input quantum state." +msgstr "" + +#: of paddle_quantum.backend.state_vector.unitary_transformation +msgid "Returns" +msgstr "" + +#: of paddle_quantum.backend.state_vector.unitary_transformation:8 +msgid "The transformed quantum state." +msgstr "" + +#: of paddle_quantum.backend.state_vector.unitary_transformation +msgid "Return type" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.unitary_matrix.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.unitary_matrix.po new file mode 100644 index 0000000..fce80d9 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.backend.unitary_matrix.po @@ -0,0 +1,66 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.backend.unitary_matrix.rst:2 +msgid "paddle\\_quantum.backend.unitary\\_matrix" +msgstr "" + +#: of paddle_quantum.backend.unitary_matrix:1 +msgid "The source file of the unitary_matrix backend." +msgstr "" + +#: of paddle_quantum.backend.unitary_matrix.unitary_transformation:1 +msgid "" +"The function of unitary transformation in the mode of computing the " +"unitary matrix." +msgstr "" + +#: of paddle_quantum.backend.unitary_matrix.unitary_transformation +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.backend.unitary_matrix.unitary_transformation:3 +msgid "The input quantum state." +msgstr "" + +#: of paddle_quantum.backend.unitary_matrix.unitary_transformation:4 +msgid "The gate that represents the unitary transformation." +msgstr "" + +#: of paddle_quantum.backend.unitary_matrix.unitary_transformation:5 +msgid "The indices of the qubits on which the gate is acted." +msgstr "" + +#: of paddle_quantum.backend.unitary_matrix.unitary_transformation:6 +msgid "The number of the qubits in the input quantum state." +msgstr "" + +#: of paddle_quantum.backend.unitary_matrix.unitary_transformation +msgid "Returns" +msgstr "" + +#: of paddle_quantum.backend.unitary_matrix.unitary_transformation:8 +msgid "The transformed quantum state." +msgstr "" + +#: of paddle_quantum.backend.unitary_matrix.unitary_transformation +msgid "Return type" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.base.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.base.po new file mode 100644 index 0000000..47308ee --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.base.po @@ -0,0 +1,123 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.base.rst:2 +msgid "paddle\\_quantum.base" +msgstr "" + +#: of paddle_quantum.base:1 +msgid "The basic function of the paddle quantum." +msgstr "" + +#: of paddle_quantum.base.set_device:1 +msgid "Set the device to save the tensor." +msgstr "" + +#: of paddle_quantum.base.Operator paddle_quantum.base.set_backend +#: paddle_quantum.base.set_device paddle_quantum.base.set_dtype +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.base.set_device:3 +msgid "The name of the device." +msgstr "" + +#: of paddle_quantum.base.get_device:1 +msgid "Get the current device to save the tensor." +msgstr "" + +#: of paddle_quantum.base.get_backend paddle_quantum.base.get_device +#: paddle_quantum.base.get_dtype +msgid "Returns" +msgstr "" + +#: of paddle_quantum.base.get_device:3 +msgid "The name of the current device." +msgstr "" + +#: of paddle_quantum.base.get_backend paddle_quantum.base.get_device +#: paddle_quantum.base.get_dtype +msgid "Return type" +msgstr "" + +#: of paddle_quantum.base.set_backend:1 +msgid "Set the backend implementation of paddle quantum." +msgstr "" + +#: of paddle_quantum.base.set_backend:3 +msgid "The name of the backend." +msgstr "" + +#: of paddle_quantum.base.get_backend:1 +msgid "Get the current backend of paddle quantum." +msgstr "" + +#: of paddle_quantum.base.get_backend:3 +msgid "The name of currently used backend." +msgstr "" + +#: of paddle_quantum.base.set_dtype:1 +msgid "Set the data type ." +msgstr "" + +#: of paddle_quantum.base.set_dtype:3 +msgid "The dtype can be ``complex64`` and ``complex128``." +msgstr "" + +#: of paddle_quantum.base.set_dtype +msgid "Raises" +msgstr "" + +#: of paddle_quantum.base.set_dtype:5 +msgid "The dtype should be complex64 or complex128." +msgstr "" + +#: of paddle_quantum.base.get_dtype:1 +msgid "Return currently used data type." +msgstr "" + +#: of paddle_quantum.base.get_dtype:3 +msgid "Currently used data type." +msgstr "" + +#: of paddle_quantum.base.Operator:1 +msgid "Bases: :py:class:`~paddle.fluid.dygraph.layers.Layer`" +msgstr "" + +#: of paddle_quantum.base.Operator:1 +msgid "The basic class to implement the quantum operation." +msgstr "" + +#: of paddle_quantum.base.Operator:3 +msgid "" +"The backend implementation of the operator. Defaults to ``None``, which " +"means to use the default backend implementation." +msgstr "" + +#: of paddle_quantum.base.Operator:5 +msgid "" +"The data type of the operator. Defaults to ``None``, which means to use " +"the default data type." +msgstr "" + +#: of paddle_quantum.base.Operator:7 +msgid "Prefix name used by the operator to name parameters. Defaults to ``None``." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.base.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.base.po new file mode 100644 index 0000000..6a4e1b7 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.base.po @@ -0,0 +1,57 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.channel.base.rst:2 +msgid "paddle\\_quantum.channel.base" +msgstr "" + +#: of paddle_quantum.channel.base:1 +msgid "The source file of the basic class for the quantum channels." +msgstr "" + +#: of paddle_quantum.channel.base.Channel:1 +msgid "Bases: :py:class:`~paddle_quantum.base.Operator`" +msgstr "" + +#: of paddle_quantum.channel.base.Channel:1 +msgid "Basic class for quantum channels." +msgstr "" + +#: of paddle_quantum.channel.base.Channel +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.channel.base.Channel:3 +msgid "Backend on which the channel is executed. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.channel.base.Channel:4 +msgid "Type of data. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.channel.base.Channel:5 +msgid "" +"Prefix name used by the layer to name parameters. If prefix is " +"\"my_layer\", parameter name in MyLayer can be \"my_layer_0.w_n\", where " +"\"w\" is the parameter base name and \"n\" is an unique suffix auto-" +"generated. If ``None``, prefix name will be snake cased class name. " +"Defaults to ``None``." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.common.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.common.po new file mode 100644 index 0000000..df1051a --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.common.po @@ -0,0 +1,310 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.channel.common.rst:2 +msgid "paddle\\_quantum.channel.common" +msgstr "" + +#: of paddle_quantum.channel.common:1 +msgid "The source file of the classes for several quantum channel." +msgstr "" + +#: of paddle_quantum.channel.common.AmplitudeDamping:1 +#: paddle_quantum.channel.common.BitFlip:1 +#: paddle_quantum.channel.common.BitPhaseFlip:1 +#: paddle_quantum.channel.common.Depolarizing:1 +#: paddle_quantum.channel.common.GeneralizedAmplitudeDamping:1 +#: paddle_quantum.channel.common.PauliChannel:1 +#: paddle_quantum.channel.common.PhaseDamping:1 +#: paddle_quantum.channel.common.PhaseFlip:1 +#: paddle_quantum.channel.common.ResetChannel:1 +#: paddle_quantum.channel.common.ThermalRelaxation:1 +msgid "Bases: :py:class:`~paddle_quantum.channel.base.Channel`" +msgstr "" + +#: of paddle_quantum.channel.common.BitFlip:1 +msgid "A collection of bit flip channels." +msgstr "" + +#: of paddle_quantum.channel.common.AmplitudeDamping:3 +#: paddle_quantum.channel.common.BitFlip:3 +#: paddle_quantum.channel.common.BitPhaseFlip:3 +#: paddle_quantum.channel.common.Depolarizing:3 +#: paddle_quantum.channel.common.GeneralizedAmplitudeDamping:3 +#: paddle_quantum.channel.common.PhaseDamping:3 +#: paddle_quantum.channel.common.PhaseFlip:3 +msgid "Such a channel's Kraus operators are" +msgstr "" + +#: of paddle_quantum.channel.common.BitFlip:5 +msgid "" +"E_0 = \\sqrt{1-p} I,\n" +"E_1 = \\sqrt{p} X." +msgstr "" + +#: of paddle_quantum.channel.common.AmplitudeDamping +#: paddle_quantum.channel.common.BitFlip +#: paddle_quantum.channel.common.BitPhaseFlip +#: paddle_quantum.channel.common.Depolarizing +#: paddle_quantum.channel.common.GeneralizedAmplitudeDamping +#: paddle_quantum.channel.common.PauliChannel +#: paddle_quantum.channel.common.PhaseDamping +#: paddle_quantum.channel.common.PhaseFlip +#: paddle_quantum.channel.common.ResetChannel +#: paddle_quantum.channel.common.ThermalRelaxation +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.channel.common.BitFlip:10 +msgid "" +"Probability of a bit flip. Its value should be in the range :math:`[0, " +"1]`." +msgstr "" + +#: of paddle_quantum.channel.common.AmplitudeDamping:19 +#: paddle_quantum.channel.common.BitFlip:11 +#: paddle_quantum.channel.common.BitPhaseFlip:11 +#: paddle_quantum.channel.common.Depolarizing:13 +#: paddle_quantum.channel.common.GeneralizedAmplitudeDamping:18 +#: paddle_quantum.channel.common.PauliChannel:5 +#: paddle_quantum.channel.common.PhaseDamping:19 +#: paddle_quantum.channel.common.PhaseFlip:11 +#: paddle_quantum.channel.common.ResetChannel:32 +#: paddle_quantum.channel.common.ThermalRelaxation:7 +msgid "Indices of the qubits on which the channels act. Defaults to ``'full'``." +msgstr "" + +#: of paddle_quantum.channel.common.AmplitudeDamping:20 +#: paddle_quantum.channel.common.BitFlip:12 +#: paddle_quantum.channel.common.BitPhaseFlip:12 +#: paddle_quantum.channel.common.Depolarizing:14 +#: paddle_quantum.channel.common.GeneralizedAmplitudeDamping:19 +#: paddle_quantum.channel.common.PauliChannel:6 +#: paddle_quantum.channel.common.PhaseDamping:20 +#: paddle_quantum.channel.common.PhaseFlip:12 +#: paddle_quantum.channel.common.ResetChannel:33 +#: paddle_quantum.channel.common.ThermalRelaxation:8 +msgid "Total number of qubits. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.channel.common.PhaseFlip:1 +msgid "A collection of phase flip channels." +msgstr "" + +#: of paddle_quantum.channel.common.PhaseFlip:5 +msgid "" +"E_0 = \\sqrt{1 - p} I,\n" +"E_1 = \\sqrt{p} Z." +msgstr "" + +#: of paddle_quantum.channel.common.PhaseFlip:10 +msgid "" +"Probability of a phase flip. Its value should be in the range :math:`[0, " +"1]`." +msgstr "" + +#: of paddle_quantum.channel.common.BitPhaseFlip:1 +msgid "A collection of bit phase flip channels." +msgstr "" + +#: of paddle_quantum.channel.common.BitPhaseFlip:5 +msgid "" +"E_0 = \\sqrt{1 - p} I,\n" +"E_1 = \\sqrt{p} Y." +msgstr "" + +#: of paddle_quantum.channel.common.BitPhaseFlip:10 +msgid "" +"Probability of a bit phase flip. Its value should be in the range " +":math:`[0, 1]`." +msgstr "" + +#: of paddle_quantum.channel.common.AmplitudeDamping:1 +msgid "A collection of amplitude damping channels." +msgstr "" + +#: of paddle_quantum.channel.common.AmplitudeDamping:5 +msgid "" +"E_0 =\n" +"\\begin{bmatrix}\n" +" 1 & 0 \\\\\n" +" 0 & \\sqrt{1-\\gamma}\n" +"\\end{bmatrix},\n" +"E_1 =\n" +"\\begin{bmatrix}\n" +" 0 & \\sqrt{\\gamma} \\\\\n" +" 0 & 0\n" +"\\end{bmatrix}." +msgstr "" + +#: of paddle_quantum.channel.common.AmplitudeDamping:18 +#: paddle_quantum.channel.common.GeneralizedAmplitudeDamping:16 +msgid "Damping probability. Its value should be in the range :math:`[0, 1]`." +msgstr "" + +#: of paddle_quantum.channel.common.GeneralizedAmplitudeDamping:1 +msgid "A collection of generalized amplitude damping channels." +msgstr "" + +#: of paddle_quantum.channel.common.GeneralizedAmplitudeDamping:5 +msgid "" +"E_0 = \\sqrt{p}\n" +"\\begin{bmatrix}\n" +" 1 & 0 \\\\\n" +" 0 & \\sqrt{1-\\gamma}\n" +"\\end{bmatrix},\n" +"E_1 = \\sqrt{p} \\begin{bmatrix} 0 & \\sqrt{\\gamma} \\\\ 0 & 0 " +"\\end{bmatrix},\\\\\n" +"E_2 = \\sqrt{1-p} \\begin{bmatrix} \\sqrt{1-\\gamma} & 0 \\\\ 0 & 1 " +"\\end{bmatrix},\n" +"E_3 = \\sqrt{1-p} \\begin{bmatrix} 0 & 0 \\\\ \\sqrt{\\gamma} & 0 " +"\\end{bmatrix}." +msgstr "" + +#: of paddle_quantum.channel.common.GeneralizedAmplitudeDamping:17 +msgid "Excitation probability. Its value should be in the range :math:`[0, 1]`." +msgstr "" + +#: of paddle_quantum.channel.common.PhaseDamping:1 +msgid "A collection of phase damping channels." +msgstr "" + +#: of paddle_quantum.channel.common.PhaseDamping:5 +msgid "" +"E_0 =\n" +"\\begin{bmatrix}\n" +" 1 & 0 \\\\\n" +" 0 & \\sqrt{1-\\gamma}\n" +"\\end{bmatrix},\n" +"E_1 =\n" +"\\begin{bmatrix}\n" +" 0 & 0 \\\\\n" +" 0 & \\sqrt{\\gamma}\n" +"\\end{bmatrix}." +msgstr "" + +#: of paddle_quantum.channel.common.PhaseDamping:18 +msgid "" +"Parameter of the phase damping channels. Its value should be in the range" +" :math:`[0, 1]`." +msgstr "" + +#: of paddle_quantum.channel.common.Depolarizing:1 +msgid "A collection of depolarizing channels." +msgstr "" + +#: of paddle_quantum.channel.common.Depolarizing:5 +msgid "" +"E_0 = \\sqrt{1-p} I,\n" +"E_1 = \\sqrt{p/3} X,\n" +"E_2 = \\sqrt{p/3} Y,\n" +"E_3 = \\sqrt{p/3} Z." +msgstr "" + +#: of paddle_quantum.channel.common.Depolarizing:12 +msgid "" +"Parameter of the depolarizing channels. Its value should be in the range " +":math:`[0, 1]`." +msgstr "" + +#: of paddle_quantum.channel.common.PauliChannel:1 +msgid "A collection of Pauli channels." +msgstr "" + +#: of paddle_quantum.channel.common.PauliChannel:3 +msgid "" +"Probabilities corresponding to the Pauli X, Y, and Z operators. Each " +"value should be in the range :math:`[0, 1]`." +msgstr "" + +#: of paddle_quantum.channel.common.PauliChannel:8 +msgid "The sum of three input probabilities should be less than or equal to 1." +msgstr "" + +#: of paddle_quantum.channel.common.ResetChannel:1 +msgid "A collection of reset channels." +msgstr "" + +#: of paddle_quantum.channel.common.ResetChannel:3 +msgid "" +"Such a channel reset the state to :math:`|0\\rangle` with a probability " +"of p and to :math:`|1\\rangle` with a probability of q. Its Kraus " +"operators are" +msgstr "" + +#: of paddle_quantum.channel.common.ResetChannel:6 +msgid "" +"E_0 =\n" +"\\begin{bmatrix}\n" +" \\sqrt{p} & 0 \\\\\n" +" 0 & 0\n" +"\\end{bmatrix},\n" +"E_1 =\n" +"\\begin{bmatrix}\n" +" 0 & \\sqrt{p} \\\\\n" +" 0 & 0\n" +"\\end{bmatrix},\\\\\n" +"E_2 =\n" +"\\begin{bmatrix}\n" +" 0 & 0 \\\\\n" +" \\sqrt{q} & 0\n" +"\\end{bmatrix},\n" +"E_3 =\n" +"\\begin{bmatrix}\n" +" 0 & 0 \\\\\n" +" 0 & \\sqrt{q}\n" +"\\end{bmatrix},\\\\\n" +"E_4 = \\sqrt{1-p-q} I." +msgstr "" + +#: of paddle_quantum.channel.common.ResetChannel:30 +msgid "" +"Probabilities of resetting to :math:`|0\\rangle` and to " +":math:`|1\\rangle`. Each value should be in the range :math:`[0, 1]`." +msgstr "" + +#: of paddle_quantum.channel.common.ResetChannel:35 +msgid "The sum of two input probabilities should be less than or equal to 1." +msgstr "" + +#: of paddle_quantum.channel.common.ThermalRelaxation:1 +msgid "A collection of thermal relaxation channels." +msgstr "" + +#: of paddle_quantum.channel.common.ThermalRelaxation:3 +msgid "" +"Such a channel simulates the mixture of the :math:`T_1` and the " +":math:`T_2` processes on superconducting devices." +msgstr "" + +#: of paddle_quantum.channel.common.ThermalRelaxation:5 +msgid ":math:`T_1` and :math:`T_2` relaxation time in microseconds." +msgstr "" + +#: of paddle_quantum.channel.common.ThermalRelaxation:6 +msgid "Quantum gate execution time in the process of relaxation in nanoseconds." +msgstr "" + +#: of paddle_quantum.channel.common.ThermalRelaxation:10 +msgid "" +"Relaxation time must satisfy :math:`T_2 \\le T_1`. For reference please " +"see https://arxiv.org/abs/2101.02109." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.custom.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.custom.po new file mode 100644 index 0000000..b51a14b --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.custom.po @@ -0,0 +1,52 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.channel.custom.rst:2 +msgid "paddle\\_quantum.channel.custom" +msgstr "" + +#: of paddle_quantum.channel.custom:1 +msgid "The source file of the classes for custom quantum channels." +msgstr "" + +#: of paddle_quantum.channel.custom.KrausRepr:1 +msgid "Bases: :py:class:`~paddle_quantum.channel.base.Channel`" +msgstr "" + +#: of paddle_quantum.channel.custom.KrausRepr:1 +msgid "A custom channel in Kraus representation." +msgstr "" + +#: of paddle_quantum.channel.custom.KrausRepr +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.channel.custom.KrausRepr:3 +msgid "Kraus operators of this channel." +msgstr "" + +#: of paddle_quantum.channel.custom.KrausRepr:4 +msgid "Indices of the qubits on which this channel acts." +msgstr "" + +#: of paddle_quantum.channel.custom.KrausRepr:5 +msgid "Total number of qubits. Defaults to ``None``." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.functional.common.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.functional.common.po new file mode 100644 index 0000000..a8999db --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.functional.common.po @@ -0,0 +1,263 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.channel.functional.common.rst:2 +msgid "paddle\\_quantum.channel.functional.common" +msgstr "" + +#: of paddle_quantum.channel.functional.common:1 +msgid "The source file of the various quantum channels." +msgstr "" + +#: of paddle_quantum.channel.functional.common.bit_flip:1 +msgid "Apply a bit flip channel on the input state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.amplitude_damping +#: paddle_quantum.channel.functional.common.bit_flip +#: paddle_quantum.channel.functional.common.bit_phase_flip +#: paddle_quantum.channel.functional.common.depolarizing +#: paddle_quantum.channel.functional.common.generalized_amplitude_damping +#: paddle_quantum.channel.functional.common.kraus_repr +#: paddle_quantum.channel.functional.common.pauli_channel +#: paddle_quantum.channel.functional.common.phase_damping +#: paddle_quantum.channel.functional.common.phase_flip +#: paddle_quantum.channel.functional.common.reset_channel +#: paddle_quantum.channel.functional.common.thermal_relaxation +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.channel.functional.common.amplitude_damping:3 +#: paddle_quantum.channel.functional.common.bit_flip:3 +#: paddle_quantum.channel.functional.common.bit_phase_flip:3 +#: paddle_quantum.channel.functional.common.depolarizing:3 +#: paddle_quantum.channel.functional.common.generalized_amplitude_damping:3 +#: paddle_quantum.channel.functional.common.kraus_repr:3 +#: paddle_quantum.channel.functional.common.pauli_channel:3 +#: paddle_quantum.channel.functional.common.phase_damping:3 +#: paddle_quantum.channel.functional.common.phase_flip:3 +#: paddle_quantum.channel.functional.common.reset_channel:3 +#: paddle_quantum.channel.functional.common.thermal_relaxation:3 +msgid "Input state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.bit_flip:4 +msgid "Probability of a bit flip." +msgstr "" + +#: of paddle_quantum.channel.functional.common.amplitude_damping:5 +#: paddle_quantum.channel.functional.common.bit_flip:5 +#: paddle_quantum.channel.functional.common.bit_phase_flip:5 +#: paddle_quantum.channel.functional.common.depolarizing:5 +#: paddle_quantum.channel.functional.common.generalized_amplitude_damping:6 +#: paddle_quantum.channel.functional.common.kraus_repr:5 +#: paddle_quantum.channel.functional.common.pauli_channel:5 +#: paddle_quantum.channel.functional.common.phase_damping:5 +#: paddle_quantum.channel.functional.common.phase_flip:5 +#: paddle_quantum.channel.functional.common.reset_channel:5 +#: paddle_quantum.channel.functional.common.thermal_relaxation:6 +msgid "Index of the qubit on which the channel acts." +msgstr "" + +#: of paddle_quantum.channel.functional.common.amplitude_damping:6 +#: paddle_quantum.channel.functional.common.bit_flip:6 +#: paddle_quantum.channel.functional.common.bit_phase_flip:6 +#: paddle_quantum.channel.functional.common.depolarizing:6 +#: paddle_quantum.channel.functional.common.generalized_amplitude_damping:7 +#: paddle_quantum.channel.functional.common.kraus_repr:6 +#: paddle_quantum.channel.functional.common.pauli_channel:6 +#: paddle_quantum.channel.functional.common.phase_damping:6 +#: paddle_quantum.channel.functional.common.phase_flip:6 +#: paddle_quantum.channel.functional.common.reset_channel:6 +#: paddle_quantum.channel.functional.common.thermal_relaxation:7 +msgid "Type of data." +msgstr "" + +#: of paddle_quantum.channel.functional.common.amplitude_damping:7 +#: paddle_quantum.channel.functional.common.bit_flip:7 +#: paddle_quantum.channel.functional.common.bit_phase_flip:7 +#: paddle_quantum.channel.functional.common.depolarizing:7 +#: paddle_quantum.channel.functional.common.generalized_amplitude_damping:8 +#: paddle_quantum.channel.functional.common.kraus_repr:7 +#: paddle_quantum.channel.functional.common.pauli_channel:7 +#: paddle_quantum.channel.functional.common.phase_damping:7 +#: paddle_quantum.channel.functional.common.phase_flip:7 +#: paddle_quantum.channel.functional.common.reset_channel:7 +#: paddle_quantum.channel.functional.common.thermal_relaxation:8 +msgid "Backend on which the simulation is run." +msgstr "" + +#: of paddle_quantum.channel.functional.common.amplitude_damping +#: paddle_quantum.channel.functional.common.bit_flip +#: paddle_quantum.channel.functional.common.bit_phase_flip +#: paddle_quantum.channel.functional.common.depolarizing +#: paddle_quantum.channel.functional.common.generalized_amplitude_damping +#: paddle_quantum.channel.functional.common.kraus_repr +#: paddle_quantum.channel.functional.common.pauli_channel +#: paddle_quantum.channel.functional.common.phase_damping +#: paddle_quantum.channel.functional.common.phase_flip +#: paddle_quantum.channel.functional.common.reset_channel +#: paddle_quantum.channel.functional.common.thermal_relaxation +msgid "Raises" +msgstr "" + +#: of paddle_quantum.channel.functional.common.amplitude_damping:9 +#: paddle_quantum.channel.functional.common.bit_flip:9 +#: paddle_quantum.channel.functional.common.bit_phase_flip:9 +#: paddle_quantum.channel.functional.common.depolarizing:9 +#: paddle_quantum.channel.functional.common.generalized_amplitude_damping:10 +#: paddle_quantum.channel.functional.common.kraus_repr:9 +#: paddle_quantum.channel.functional.common.pauli_channel:9 +#: paddle_quantum.channel.functional.common.phase_damping:9 +#: paddle_quantum.channel.functional.common.phase_flip:9 +#: paddle_quantum.channel.functional.common.reset_channel:9 +#: paddle_quantum.channel.functional.common.thermal_relaxation:10 +msgid "The noisy channel can only run in density matrix mode." +msgstr "" + +#: of paddle_quantum.channel.functional.common.amplitude_damping +#: paddle_quantum.channel.functional.common.bit_flip +#: paddle_quantum.channel.functional.common.bit_phase_flip +#: paddle_quantum.channel.functional.common.depolarizing +#: paddle_quantum.channel.functional.common.generalized_amplitude_damping +#: paddle_quantum.channel.functional.common.kraus_repr +#: paddle_quantum.channel.functional.common.pauli_channel +#: paddle_quantum.channel.functional.common.phase_damping +#: paddle_quantum.channel.functional.common.phase_flip +#: paddle_quantum.channel.functional.common.reset_channel +#: paddle_quantum.channel.functional.common.thermal_relaxation +msgid "Returns" +msgstr "" + +#: of paddle_quantum.channel.functional.common.amplitude_damping:11 +#: paddle_quantum.channel.functional.common.bit_flip:11 +#: paddle_quantum.channel.functional.common.bit_phase_flip:11 +#: paddle_quantum.channel.functional.common.depolarizing:11 +#: paddle_quantum.channel.functional.common.generalized_amplitude_damping:12 +#: paddle_quantum.channel.functional.common.kraus_repr:11 +#: paddle_quantum.channel.functional.common.pauli_channel:11 +#: paddle_quantum.channel.functional.common.phase_damping:11 +#: paddle_quantum.channel.functional.common.phase_flip:11 +#: paddle_quantum.channel.functional.common.reset_channel:11 +#: paddle_quantum.channel.functional.common.thermal_relaxation:12 +msgid "Output state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.amplitude_damping +#: paddle_quantum.channel.functional.common.bit_flip +#: paddle_quantum.channel.functional.common.bit_phase_flip +#: paddle_quantum.channel.functional.common.depolarizing +#: paddle_quantum.channel.functional.common.generalized_amplitude_damping +#: paddle_quantum.channel.functional.common.kraus_repr +#: paddle_quantum.channel.functional.common.pauli_channel +#: paddle_quantum.channel.functional.common.phase_damping +#: paddle_quantum.channel.functional.common.phase_flip +#: paddle_quantum.channel.functional.common.reset_channel +#: paddle_quantum.channel.functional.common.thermal_relaxation +msgid "Return type" +msgstr "" + +#: of paddle_quantum.channel.functional.common.phase_flip:1 +msgid "Apply a phase flip channel on the input state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.phase_flip:4 +msgid "Probability of a phase flip." +msgstr "" + +#: of paddle_quantum.channel.functional.common.bit_phase_flip:1 +msgid "Apply a bit phase flip channel on the input state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.bit_phase_flip:4 +msgid "Probability of a bit phase flip." +msgstr "" + +#: of paddle_quantum.channel.functional.common.amplitude_damping:1 +msgid "Apply an amplitude damping channel on the input state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.amplitude_damping:4 +#: paddle_quantum.channel.functional.common.generalized_amplitude_damping:4 +msgid "Damping probability." +msgstr "" + +#: of paddle_quantum.channel.functional.common.generalized_amplitude_damping:1 +msgid "Apply a generalized amplitude damping channel on the input state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.generalized_amplitude_damping:5 +msgid "Excitation probability." +msgstr "" + +#: of paddle_quantum.channel.functional.common.phase_damping:1 +msgid "Apply a phase damping channel on the input state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.phase_damping:4 +msgid "Parameter of the phase damping channel." +msgstr "" + +#: of paddle_quantum.channel.functional.common.depolarizing:1 +msgid "Apply a depolarizing channel on the input state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.depolarizing:4 +msgid "Parameter of the depolarizing channel." +msgstr "" + +#: of paddle_quantum.channel.functional.common.pauli_channel:1 +msgid "Apply a Pauli channel on the input state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.pauli_channel:4 +msgid "Probabilities corresponding to the Pauli X, Y, and Z operators." +msgstr "" + +#: of paddle_quantum.channel.functional.common.reset_channel:1 +msgid "Apply a reset channel on the input state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.reset_channel:4 +msgid "" +"Probabilities of resetting to :math:`|0\\rangle` and to " +":math:`|1\\rangle`." +msgstr "" + +#: of paddle_quantum.channel.functional.common.thermal_relaxation:1 +msgid "Apply a thermal relaxation channel on the input state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.thermal_relaxation:4 +msgid ":math:`T_1` and :math:`T_2` relaxation time in microseconds." +msgstr "" + +#: of paddle_quantum.channel.functional.common.thermal_relaxation:5 +msgid "Quantum gate execution time in the process of relaxation in nanoseconds." +msgstr "" + +#: of paddle_quantum.channel.functional.common.kraus_repr:1 +msgid "Apply a custom channel in the Kraus representation on the input state." +msgstr "" + +#: of paddle_quantum.channel.functional.common.kraus_repr:4 +msgid "Kraus operators of this channel." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.functional.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.functional.po new file mode 100644 index 0000000..a752fdf --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.functional.po @@ -0,0 +1,32 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.channel.functional.rst:2 +msgid "paddle\\_quantum.channel.functional" +msgstr "" + +#: of paddle_quantum.channel.functional:1 +msgid "The module that contains the functions of various quantum channels." +msgstr "" + +#: ../../source/paddle_quantum.channel.functional.rst:9 +msgid "Submodules" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.po new file mode 100644 index 0000000..7cbeaec --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.channel.po @@ -0,0 +1,36 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.channel.rst:2 +msgid "paddle\\_quantum.channel" +msgstr "" + +#: of paddle_quantum.channel:1 +msgid "The module of the quantum channels." +msgstr "" + +#: ../../source/paddle_quantum.channel.rst:9 +msgid "Subpackages" +msgstr "" + +#: ../../source/paddle_quantum.channel.rst:16 +msgid "Submodules" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.dataset.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.dataset.po new file mode 100644 index 0000000..d2a1c24 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.dataset.po @@ -0,0 +1,433 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.dataset.rst:2 +msgid "paddle\\_quantum.dataset" +msgstr "" + +#: of paddle_quantum.dataset:1 +msgid "The source file of the dataset." +msgstr "" + +#: of paddle_quantum.dataset.Dataset:1 +msgid "Bases: :py:class:`object`" +msgstr "" + +#: of paddle_quantum.dataset.Dataset:1 +msgid "" +"Basic class for all datasets, integrating multiple quantum encoding " +"methods." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.data2circuit:1 +msgid "" +"Encode vectors, which have been already truncated or filled with zero to " +"the length ``can_describe_dimension``" +msgstr "" + +#: of paddle_quantum.dataset.BreastCancer +#: paddle_quantum.dataset.Dataset.data2circuit +#: paddle_quantum.dataset.Dataset.filter_class +#: paddle_quantum.dataset.FashionMNIST paddle_quantum.dataset.Iris +#: paddle_quantum.dataset.MNIST paddle_quantum.dataset.SimpleDataset +#: paddle_quantum.dataset.SimpleDataset.encode +#: paddle_quantum.dataset.VisionDataset +#: paddle_quantum.dataset.VisionDataset.encode +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.dataset.Dataset.data2circuit:3 +msgid "" +"vectors needed to encode，which have been already truncated or filled with" +" zero to the length ``can_describe_dimension``" +msgstr "" + +#: of paddle_quantum.dataset.Dataset.data2circuit:6 +#: paddle_quantum.dataset.Dataset.data2circuit:7 +msgid "The encoding method." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.data2circuit:8 +msgid "the dimension which the circuit can describe by ``encoding``." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.data2circuit:9 +msgid "Whether to split the circuit." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.data2circuit:10 +msgid "Whether to return quantum state." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.data2circuit:11 +msgid "" +"Whether it is a picture, if it is a picture, the normalization method is " +"not quite the same. Defaults to ``False``." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.data2circuit +#: paddle_quantum.dataset.FashionMNIST paddle_quantum.dataset.MNIST +#: paddle_quantum.dataset.SimpleDataset.encode +#: paddle_quantum.dataset.VisionDataset.encode +msgid "Raises" +msgstr "" + +#: of paddle_quantum.dataset.Dataset.data2circuit:13 +msgid "Not support to return circuit in amplitude encoding." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.data2circuit +#: paddle_quantum.dataset.Dataset.filter_class +#: paddle_quantum.dataset.SimpleDataset.encode +#: paddle_quantum.dataset.VisionDataset.encode +msgid "Returns" +msgstr "" + +#: of paddle_quantum.dataset.Dataset.data2circuit:15 +msgid "" +"if ``return_state == True``, return encoded quantum state, otherwise " +"return encoding circuits." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.data2circuit +#: paddle_quantum.dataset.Dataset.filter_class +#: paddle_quantum.dataset.SimpleDataset.encode +#: paddle_quantum.dataset.VisionDataset.encode +msgid "Return type" +msgstr "" + +#: of paddle_quantum.dataset.Dataset.filter_class:1 +msgid "" +"Select ``data_num`` samples from ``x``, ``y``, whose label is in " +"``classes``." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.filter_class:3 +msgid "training features." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.filter_class:4 +msgid "training labels." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.filter_class:5 +msgid "classes needed to select." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.filter_class:6 +msgid "the number of data needed to select." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.filter_class:7 +msgid "" +"whether we need to relabel the labels to 0,1,2 for binary classification." +" For example ``[1,2]`` will be relabeled to ``[0,1]``." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.filter_class:8 +msgid "Random seed. Defaults to ``0``." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.filter_class:10 +msgid "" +"- new_x: selected features. - new_y: selected labels corresponded to " +"``new_x``." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.filter_class:10 +msgid "new_x: selected features." +msgstr "" + +#: of paddle_quantum.dataset.Dataset.filter_class:11 +msgid "new_y: selected labels corresponded to ``new_x``." +msgstr "" + +#: of paddle_quantum.dataset.SimpleDataset:1 +#: paddle_quantum.dataset.VisionDataset:1 +msgid "Bases: :py:class:`~paddle_quantum.dataset.Dataset`" +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset:1 +msgid "" +"``VisionDataset`` is the basic class of all image datasets. By inheriting" +" ``VisionDataset``, users can easily generate their own quantum data." +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset:3 +msgid "the size of the figure." +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:1 +msgid "" +"Encode ``feature`` into ``num_qubits`` qubits using ``encoding`` after " +"downscaling to ``target_dimension``. ``feature`` is one-dimension image " +"vectors." +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:3 +msgid "One-dimension image vectors which can be list or ndarray." +msgstr "" + +#: of paddle_quantum.dataset.BreastCancer:3 +#: paddle_quantum.dataset.FashionMNIST:4 paddle_quantum.dataset.Iris:3 +#: paddle_quantum.dataset.MNIST:4 paddle_quantum.dataset.VisionDataset.encode:4 +msgid "" +"``angle_encoding`` denotes angle encoding, and one qubit encodes one " +"number with a Ry gate. ``amplitude_encoding`` denotes amplitude encoding;" +" ``pauli_rotation_encoding`` denotes using SU(3) rotation gate. " +"``linear_entanglement_encoding``, ``real_entanglement_encoding`` , " +"``complex_entanglement_encoding`` and ``IQP_encoding`` encoding methods." +msgstr "" + +#: of paddle_quantum.dataset.BreastCancer:6 +#: paddle_quantum.dataset.FashionMNIST:7 paddle_quantum.dataset.Iris:6 +#: paddle_quantum.dataset.MNIST:7 paddle_quantum.dataset.SimpleDataset.encode:5 +#: paddle_quantum.dataset.VisionDataset.encode:7 +msgid "Qubit number." +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:8 +msgid "" +"whether to split the circuits. If true, every layer of the encoding " +"circuit will be split into a list. Defaults to ``False``." +msgstr "" + +#: of paddle_quantum.dataset.FashionMNIST:11 paddle_quantum.dataset.MNIST:11 +#: paddle_quantum.dataset.VisionDataset.encode:9 +msgid "Including ``PCA`` and ``resize``. Defaults to ``resize``." +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:10 +msgid "" +"The dimension after downscaling. ``target_dimension`` is not allowed to " +"surpass the figure size. Defaults to ``-1``." +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:11 +msgid "" +"Whether to return quantum states. If it is ``False``, return quantum " +"circuits. Defaults to True." +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:12 +msgid "" +"Whether to return ``quantum_image_states``, ``quantum_image_circuits``, " +"``original_images`` and ``classical_image_vectors``. Defaults to False." +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:14 +msgid "PCA dimension should be less than figure size" +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:15 +msgid "Resize dimension should be a square" +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:16 +msgid "Downscaling methods can only be resize and PCA." +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:17 +msgid "Invalid encoding methods" +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:19 +msgid "" +"- quantum_image_states: Quantum states, only ``full_return==True`` or " +"``return_state==True`` will return. - quantum_image_circuits: A list of " +"circuits generating quantum states, only ``full_return==True`` or " +"``return_state==True`` will return. - original_images: One-dimension " +"original vectors without any processing, only ``return_state==True`` will" +" return; - classical_image_vectors: One-dimension original vectors after " +"filling with zero, which are encoded to quantum states. only " +"``return_state==True`` will return;" +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:19 +msgid "" +"quantum_image_states: Quantum states, only ``full_return==True`` or " +"``return_state==True`` will return." +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:20 +msgid "" +"quantum_image_circuits: A list of circuits generating quantum states, " +"only ``full_return==True`` or ``return_state==True`` will return." +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:21 +msgid "" +"original_images: One-dimension original vectors without any processing, " +"only ``return_state==True`` will return;" +msgstr "" + +#: of paddle_quantum.dataset.VisionDataset.encode:22 +msgid "" +"classical_image_vectors: One-dimension original vectors after filling " +"with zero, which are encoded to quantum states. only " +"``return_state==True`` will return;" +msgstr "" + +#: of paddle_quantum.dataset.SimpleDataset:1 +msgid "" +"SimpleDataset is used for simple dataset and can't downscale the data. " +"You can inherit ``SimpleDataset`` to generate quantum states from your " +"classical datasets." +msgstr "" + +#: of paddle_quantum.dataset.SimpleDataset:3 +msgid "Dimension of encoding data" +msgstr "" + +#: of paddle_quantum.dataset.SimpleDataset.encode:1 +msgid "Encode ``feature`` with ``num_qubits`` qubits by ``encoding``." +msgstr "" + +#: of paddle_quantum.dataset.SimpleDataset.encode:3 +msgid "Features needed to encode." +msgstr "" + +#: of paddle_quantum.dataset.SimpleDataset.encode:4 +msgid "Encoding methods." +msgstr "" + +#: of paddle_quantum.dataset.BreastCancer:8 +#: paddle_quantum.dataset.FashionMNIST:15 paddle_quantum.dataset.Iris:10 +#: paddle_quantum.dataset.MNIST:15 +#: paddle_quantum.dataset.SimpleDataset.encode:6 +msgid "Whether to return quantum states. Defaults to ``True``." +msgstr "" + +#: of paddle_quantum.dataset.SimpleDataset.encode:7 +msgid "" +"Whether to return quantum_states, quantum_circuits, origin_feature and " +"feature. Defaults to ``False``." +msgstr "" + +#: of paddle_quantum.dataset.SimpleDataset.encode:9 +msgid "Invalid type of feature." +msgstr "" + +#: of paddle_quantum.dataset.SimpleDataset.encode:10 +msgid "Invalid encoding methods." +msgstr "" + +#: of paddle_quantum.dataset.SimpleDataset.encode:11 +msgid "The qubit number is not enough to encode the features." +msgstr "" + +#: of paddle_quantum.dataset.SimpleDataset.encode:13 +msgid "" +"TODO: not show up in docs - quantum_states: Quantum states, only " +"``full_return==True`` or ``return_state==True`` will return; - " +"quantum_circuits: A list of circuits generating quantum states, only " +"``full_return==True`` or ``return_state==True`` will return; - " +"origin_feature: One-dimension original vectors without any processing, " +"only ``return_state==True`` will return - feature: One-dimension original" +" vectors after filling with zero, which are encoded to quantum states. " +"only ``return_state==True`` will return." +msgstr "" + +#: of paddle_quantum.dataset.FashionMNIST:1 paddle_quantum.dataset.MNIST:1 +msgid "Bases: :py:class:`~paddle_quantum.dataset.VisionDataset`" +msgstr "" + +#: of paddle_quantum.dataset.MNIST:1 +msgid "MNIST quantum dataset. It inherits ``VisionDataset``." +msgstr "" + +#: of paddle_quantum.dataset.FashionMNIST:3 paddle_quantum.dataset.MNIST:3 +msgid "Data mode including ``train`` and ``test``." +msgstr "" + +#: of paddle_quantum.dataset.FashionMNIST:8 paddle_quantum.dataset.MNIST:8 +msgid "Classes needed to classify." +msgstr "" + +#: of paddle_quantum.dataset.FashionMNIST:9 paddle_quantum.dataset.MNIST:9 +msgid "Data number returned. Defaults to ``-1``." +msgstr "" + +#: of paddle_quantum.dataset.FashionMNIST:10 paddle_quantum.dataset.MNIST:10 +msgid "" +"Whether to split the circuits. If True, every layer of the encoding " +"circuit will be split into a list. Defaults to ``False``." +msgstr "" + +#: of paddle_quantum.dataset.FashionMNIST:12 paddle_quantum.dataset.MNIST:12 +msgid "" +"The dimension after downscaling, which is not allowed to surpass the " +"figure size. Defaults to ``-1``." +msgstr "" + +#: of paddle_quantum.dataset.FashionMNIST:13 paddle_quantum.dataset.MNIST:13 +msgid "" +"Whether needed to crop, If ``True``, ``image[0:27][0:27]`` will be " +"cropped to ``image[4:24][4:24]``. Defaults to ``True``." +msgstr "" + +#: of paddle_quantum.dataset.FashionMNIST:14 paddle_quantum.dataset.MNIST:14 +msgid "" +"Whether we need to relabel the labels to 0,1,2… for binary " +"classification.For example [1,2] will be relabeled to [0,1] Defaults to " +"``True``." +msgstr "" + +#: of paddle_quantum.dataset.BreastCancer:9 +#: paddle_quantum.dataset.FashionMNIST:16 paddle_quantum.dataset.Iris:11 +#: paddle_quantum.dataset.MNIST:16 +msgid "Select random seed. Defaults to ``0``." +msgstr "" + +#: of paddle_quantum.dataset.FashionMNIST:18 paddle_quantum.dataset.MNIST:18 +msgid "Data mode can only be train and test." +msgstr "" + +#: of paddle_quantum.dataset.FashionMNIST:1 +msgid "FashionMNIST quantum dataset. It inherits ``VisionDataset``." +msgstr "" + +#: of paddle_quantum.dataset.BreastCancer:1 paddle_quantum.dataset.Iris:1 +msgid "Bases: :py:class:`~paddle_quantum.dataset.SimpleDataset`" +msgstr "" + +#: of paddle_quantum.dataset.Iris:1 +msgid "Iris dataset" +msgstr "" + +#: of paddle_quantum.dataset.Iris:7 +msgid "Classes needed to classify" +msgstr "" + +#: of paddle_quantum.dataset.BreastCancer:7 paddle_quantum.dataset.Iris:8 +msgid "The proportion of the testing dataset. Defaults to ``0.2``." +msgstr "" + +#: of paddle_quantum.dataset.Iris:9 +msgid "" +"Whether we need to relabel the labels to 0,1,2… for binary " +"classification.For example [1,2] will be relabeled to [0,1]. Defaults to " +"``True``." +msgstr "" + +#: of paddle_quantum.dataset.BreastCancer:1 +msgid "BreastCancer quantum dataset." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.finance.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.finance.po new file mode 100644 index 0000000..b4f3407 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.finance.po @@ -0,0 +1,235 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.finance.rst:2 +msgid "paddle\\_quantum.finance" +msgstr "" + +#: of paddle_quantum.finance:1 +msgid "Functions and data simulator class of quantum finance." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator:1 +msgid "Bases: :py:class:`object`" +msgstr "" + +#: of paddle_quantum.finance.DataSimulator:1 +msgid "" +"Used to generate data and calculate relevant parameters for portfolio " +"optimization and portfolio diversification problems." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator +#: paddle_quantum.finance.DataSimulator.set_data +#: paddle_quantum.finance.arbitrage_opportunities_hamiltonian +#: paddle_quantum.finance.portfolio_diversification_hamiltonian +#: paddle_quantum.finance.portfolio_optimization_hamiltonian +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.finance.DataSimulator:3 +msgid "A list of names of investable stocks" +msgstr "" + +#: of paddle_quantum.finance.DataSimulator:4 +msgid "" +"The start date of the trading day when the stock data is randomly " +"generated. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator:5 +msgid "" +"The end date of the trading day when the stock data is randomly " +"generated. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.set_data:1 +msgid "Decide which data source to use: randomly generated or locally entered." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.set_data:3 +msgid "Stock data entered by the user." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.randomly_generate:1 +msgid "" +"Randomly generate stock data for experiments based on start date and end " +"date." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.randomly_generate:3 +msgid "" +"To generate random stock data, you need to specify the start date and end" +" date in the format of the ``datetime`` package, e.g. ``start = " +"datetime.datetime(2016, 1, 1)``." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.get_asset_return_mean_vector:1 +msgid "Calculate expected return of each stock." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.get_asset_return_covariance_matrix +#: paddle_quantum.finance.DataSimulator.get_asset_return_mean_vector +#: paddle_quantum.finance.DataSimulator.get_similarity_matrix +#: paddle_quantum.finance.arbitrage_opportunities_hamiltonian +#: paddle_quantum.finance.portfolio_diversification_hamiltonian +#: paddle_quantum.finance.portfolio_optimization_hamiltonian +msgid "Returns" +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.get_asset_return_mean_vector:3 +msgid "Expected return of all investable stocks." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.get_asset_return_covariance_matrix +#: paddle_quantum.finance.DataSimulator.get_asset_return_mean_vector +#: paddle_quantum.finance.DataSimulator.get_similarity_matrix +#: paddle_quantum.finance.arbitrage_opportunities_hamiltonian +#: paddle_quantum.finance.portfolio_diversification_hamiltonian +#: paddle_quantum.finance.portfolio_optimization_hamiltonian +msgid "Return type" +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.get_asset_return_covariance_matrix:1 +msgid "Calculate the covariance matrix between the returns of each stock." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.get_asset_return_covariance_matrix:3 +#: paddle_quantum.finance.portfolio_optimization_hamiltonian:5 +msgid "The covariance matrix between the returns of each stock." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.get_similarity_matrix:1 +msgid "Calculate the similarity matrix among stocks." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.get_similarity_matrix:3 +msgid "" +"The Dynamic Time Warping algorithm (DTW) is used to calculate the " +"similarity between two stocks." +msgstr "" + +#: of paddle_quantum.finance.DataSimulator.get_similarity_matrix:5 +#: paddle_quantum.finance.portfolio_diversification_hamiltonian:4 +msgid "The similarity matrix among stocks." +msgstr "" + +#: of paddle_quantum.finance.portfolio_optimization_hamiltonian:1 +msgid "Construct the hamiltonian of the portfolio optimization problem." +msgstr "" + +#: of paddle_quantum.finance.arbitrage_opportunities_hamiltonian:4 +#: paddle_quantum.finance.portfolio_diversification_hamiltonian:3 +#: paddle_quantum.finance.portfolio_optimization_hamiltonian:3 +msgid "Penalty parameter." +msgstr "" + +#: of paddle_quantum.finance.portfolio_optimization_hamiltonian:4 +msgid "Expected return of each stock." +msgstr "" + +#: of paddle_quantum.finance.portfolio_optimization_hamiltonian:6 +msgid "Risk appetite of the decision maker." +msgstr "" + +#: of paddle_quantum.finance.portfolio_optimization_hamiltonian:7 +msgid "Budget, i.e. the number of stocks to be invested." +msgstr "" + +#: of paddle_quantum.finance.portfolio_optimization_hamiltonian:9 +msgid "" +"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" +msgstr "" + +#: of paddle_quantum.finance.portfolio_optimization_hamiltonian:14 +msgid "" +"Mapping Boolean variables :math:`x_i` to Hamiltonian matrices under " +":math:`x_i \\mapsto \\frac{I-Z_i}{2}`." +msgstr "" + +#: of paddle_quantum.finance.portfolio_optimization_hamiltonian:16 +msgid "The hamiltonian of the portfolio optimization problem." +msgstr "" + +#: of paddle_quantum.finance.portfolio_diversification_hamiltonian:1 +msgid "Construct the hamiltonian of the portfolio diversification problem." +msgstr "" + +#: of paddle_quantum.finance.portfolio_diversification_hamiltonian:5 +msgid "Number of categories for stock clustering." +msgstr "" + +#: of paddle_quantum.finance.portfolio_diversification_hamiltonian:7 +msgid "" +"\\begin{aligned}\n" +"C_x &= -\\sum_{i=1}^{n}\\sum_{j=1}^{n}\\rho_{ij}x_{ij} + A\\left(q- " +"\\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}" +msgstr "" + +#: of paddle_quantum.finance.portfolio_diversification_hamiltonian:14 +msgid "" +"Mapping Boolean variables :math:`x_{ij}` to the Hamiltonian matrices " +"under :math:`x_{ij} \\mapsto \\frac{I-Z_{ij}}{2}`" +msgstr "" + +#: of paddle_quantum.finance.portfolio_diversification_hamiltonian:16 +msgid "The hamiltonian of the portfolio diversification problem." +msgstr "" + +#: of paddle_quantum.finance.arbitrage_opportunities_hamiltonian:1 +msgid "" +"Construct the hamiltonian of the arbitrage opportunity optimization " +"problem." +msgstr "" + +#: of paddle_quantum.finance.arbitrage_opportunities_hamiltonian:3 +msgid "Graphical representation of conversions between different markets." +msgstr "" + +#: of paddle_quantum.finance.arbitrage_opportunities_hamiltonian:5 +msgid "Number of currency types, i.e. number of vertices in the graph g." +msgstr "" + +#: of paddle_quantum.finance.arbitrage_opportunities_hamiltonian:6 +msgid "Number of vertices contained in the arbitrage loop." +msgstr "" + +#: of paddle_quantum.finance.arbitrage_opportunities_hamiltonian:8 +msgid "" +"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}" +msgstr "" + +#: of paddle_quantum.finance.arbitrage_opportunities_hamiltonian:12 +msgid "" +"Mapping Boolean variables :math:`x_{i,k}` to the Hamiltonian matrices " +"under :math:`x_{i,k} \\mapsto \\frac{I-Z_{i,k}}{2}`." +msgstr "" + +#: of paddle_quantum.finance.arbitrage_opportunities_hamiltonian:14 +msgid "The hamiltonian of the arbitrage opportunity optimization problem." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.fisher.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.fisher.po new file mode 100644 index 0000000..5b7cf1f --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.fisher.po @@ -0,0 +1,248 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.fisher.rst:2 +msgid "paddle\\_quantum.fisher" +msgstr "" + +#: of paddle_quantum.fisher:1 +msgid "The source file of the class for the fisher information." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher:1 +#: paddle_quantum.fisher.QuantumFisher:1 +msgid "Bases: :py:class:`object`" +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher:1 +msgid "Quantum fisher information (QFI) & related calculators." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher +#: paddle_quantum.fisher.ClassicalFisher.get_cfisher +#: paddle_quantum.fisher.ClassicalFisher.get_eff_dim +#: paddle_quantum.fisher.ClassicalFisher.get_gradient +#: paddle_quantum.fisher.QuantumFisher +#: paddle_quantum.fisher.QuantumFisher.get_eff_qdim +#: paddle_quantum.fisher.QuantumFisher.get_qfisher_norm +#: paddle_quantum.fisher.QuantumFisher.get_qfisher_rank +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher:3 +msgid "" +"Parameterized quantum circuits requiring calculation of quantum Fisher " +"information." +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher:5 +msgid "" +"This class does not fit the situation when parameters among gates are " +"correlated, such as control-gates." +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher.get_qfisher_matrix:1 +msgid "Use parameter shift rule of order 2 to calculate the matrix of QFI." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_cfisher +#: paddle_quantum.fisher.ClassicalFisher.get_eff_dim +#: paddle_quantum.fisher.ClassicalFisher.get_gradient +#: paddle_quantum.fisher.ClassicalFisher.get_normalized_cfisher +#: paddle_quantum.fisher.QuantumFisher.get_eff_qdim +#: paddle_quantum.fisher.QuantumFisher.get_qfisher_matrix +#: paddle_quantum.fisher.QuantumFisher.get_qfisher_norm +#: paddle_quantum.fisher.QuantumFisher.get_qfisher_rank +msgid "Returns" +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher.get_qfisher_matrix:3 +msgid "Matrix of QFI." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_cfisher +#: paddle_quantum.fisher.ClassicalFisher.get_eff_dim +#: paddle_quantum.fisher.ClassicalFisher.get_gradient +#: paddle_quantum.fisher.ClassicalFisher.get_normalized_cfisher +#: paddle_quantum.fisher.QuantumFisher.get_eff_qdim +#: paddle_quantum.fisher.QuantumFisher.get_qfisher_matrix +#: paddle_quantum.fisher.QuantumFisher.get_qfisher_norm +#: paddle_quantum.fisher.QuantumFisher.get_qfisher_rank +msgid "Return type" +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher.get_qfisher_norm:1 +msgid "" +"Use finite difference rule to calculate the projection norm of QFI along " +"particular direction." +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher.get_qfisher_norm:3 +msgid "A direction represented by a vector." +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher.get_qfisher_norm:4 +msgid "Step size of the finite difference rule. Defaults to ``0.01``。" +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher.get_qfisher_norm:6 +msgid "Projection norm." +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher.get_eff_qdim:1 +msgid "" +"Calculate the effective quantum dimension, i.e. the maximum rank of QFI " +"matrix in the whole parameter space." +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher.get_eff_qdim:3 +msgid "Number of samples to estimate the dimension. Defaults to ``4``." +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher.get_eff_qdim:4 +#: paddle_quantum.fisher.QuantumFisher.get_qfisher_rank:3 +msgid "" +"Minimum tolerance of the singular values to be 0. Defaults to ``None``, " +"with the same meaning as in ``numpy.linalg.matrix_rank()``." +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher.get_eff_qdim:7 +msgid "Effective quantum dimension of the quantum circuit." +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher.get_qfisher_rank:1 +msgid "Calculate the rank of the QIF matrix." +msgstr "" + +#: of paddle_quantum.fisher.QuantumFisher.get_qfisher_rank:6 +msgid "Rank of the QIF matrix." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher:1 +msgid "Classical fisher information (CFI) & related calculators." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher:3 +msgid "Instance of the classical or quantum neural network model." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher:4 +msgid "Number of the parameter sets." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher:5 +msgid "Number of the input samples." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher:6 +msgid "Model type is ``'classical'`` or ``'quantum'``. Defaults to ``'quantum'``." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher:7 +msgid "" +"including - size: list of sizes of classical NN units - num_qubits: " +"number of qubits of quantum NN - depth: depth of quantum NN - encoding: " +"``IQP`` or ``re-uploading`` encoding of quantum NN" +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher +msgid "Raises" +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher:13 +msgid "Unsupported encoding." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher:14 +msgid "Unsupported model type." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_gradient:1 +msgid "" +"Calculate the gradients with respect to the variational parameters of the" +" output layer." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_gradient:3 +msgid "Input samples." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_gradient:5 +msgid "" +"Gradient with respect to the variational parameters of the output layer " +"with shape [num_inputs, dimension of the output layer, num_thetas]." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_cfisher:1 +msgid "Use the Jacobian matrix to calculate the CFI matrix." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_cfisher:3 +msgid "Gradients with respect to the variational parameter of the output layer." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_cfisher:5 +msgid "" +"CFI matrix with shape [num_inputs, dimension of the output layer, " +"num_theta]." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_normalized_cfisher:1 +msgid "Calculate the normalized CFI matrix." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_normalized_cfisher:3 +msgid "" +"contains elements - CFI matrix with shape [num_inputs, num_theta, " +"num_theta] - its trace" +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_normalized_cfisher:3 +msgid "contains elements" +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_normalized_cfisher:5 +msgid "CFI matrix with shape [num_inputs, num_theta, num_theta]" +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_normalized_cfisher:6 +msgid "its trace" +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_eff_dim:1 +msgid "Calculate the classical effective dimension." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_eff_dim:3 +msgid "Normalized CFI matrix." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_eff_dim:4 +msgid "List of different numbers of samples." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_eff_dim:5 +msgid "A parameter in the effective dimension. Defaults to ``1``." +msgstr "" + +#: of paddle_quantum.fisher.ClassicalFisher.get_eff_dim:7 +msgid "Classical effective dimensions for different numbers of samples." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.base.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.base.po new file mode 100644 index 0000000..7eec16d --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.base.po @@ -0,0 +1,61 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gate.base.rst:2 +msgid "paddle\\_quantum.gate.base" +msgstr "" + +#: of paddle_quantum.gate.base:1 +msgid "The source file of the basic class for the quantum gates." +msgstr "" + +#: of paddle_quantum.gate.base.Gate:1 +msgid "Bases: :py:class:`~paddle_quantum.base.Operator`" +msgstr "" + +#: of paddle_quantum.gate.base.Gate:1 +msgid "Basis class for quantum gates." +msgstr "" + +#: of paddle_quantum.gate.base.Gate +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.gate.base.Gate:3 +msgid "Number of layers. Defaults to 1." +msgstr "" + +#: of paddle_quantum.gate.base.Gate:4 +msgid "Backend on which the gates are executed. Defaults to None." +msgstr "" + +#: of paddle_quantum.gate.base.Gate:5 +msgid "Type of data. Defaults to None." +msgstr "" + +#: of paddle_quantum.gate.base.Gate:6 +msgid "" +"Prefix name used by the layer to name parameters. If prefix is " +"\"my_layer\", parameter name in MyLayer can be \"my_layer_0.w_n\", where " +"\"w\" is the parameter base name and \"n\" is an unique suffix auto-" +"generated. If ``None``, prefix name will be snake cased class name. " +"Defaults to ``None``." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.clifford.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.clifford.po new file mode 100644 index 0000000..8a2b8ea --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.clifford.po @@ -0,0 +1,123 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gate.clifford.rst:2 +msgid "paddle\\_quantum.gate.clifford" +msgstr "" + +#: of paddle_quantum.gate.clifford:1 +msgid "Class for randomly generating a Clifford operator." +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford:1 +msgid "Bases: :py:class:`object`" +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford:1 +msgid "Users can instantiate this class to randomly generate a Clifford operator." +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford +#: paddle_quantum.gate.clifford.compose_clifford_circuit +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford:3 +msgid "Number of qubits on which this Clifford operator acts." +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford:6 +msgid "References" +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford:7 +msgid "" +"1. Bravyi, Sergey, and Dmitri Maslov. \"Hadamard-free circuits expose the" +" structure of the Clifford group.\" IEEE Transactions on Information " +"Theory 67.7 (2021): 4546-4563." +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford.print_clifford:1 +msgid "Print how the Clifford operator acts on the Pauli basis." +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford.sym:1 +msgid "Obtain the Clifford operator's symplectic matrix." +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford.circuit +#: paddle_quantum.gate.clifford.Clifford.sym +#: paddle_quantum.gate.clifford.Clifford.tableau +#: paddle_quantum.gate.clifford.compose_clifford_circuit +msgid "Returns" +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford.sym:3 +msgid "Symplectic matrix corresponding to this Clifford operator." +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford.circuit +#: paddle_quantum.gate.clifford.Clifford.sym +#: paddle_quantum.gate.clifford.Clifford.tableau +#: paddle_quantum.gate.clifford.compose_clifford_circuit +msgid "Return type" +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford.tableau:1 +msgid "Obtain the Clifford operator's table." +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford.tableau:3 +msgid "" +"For the number of qubits being ``num_qubits``, the first ``num_qubits`` " +"lines correspoding to results of X_i, and the last ``num_qubits`` lines " +"correspoding to results of Z_i." +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford.tableau:6 +msgid "Table corresponding to this Clifford operator." +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford.circuit:1 +msgid "Obtain the circuit corresponding to the Clifford operator." +msgstr "" + +#: of paddle_quantum.gate.clifford.Clifford.circuit:3 +msgid "Circuit corresponding to this Clifford operator." +msgstr "" + +#: of paddle_quantum.gate.clifford.compose_clifford_circuit:1 +msgid "" +"Compute the composition of two Clifford operators and obtain the " +"corresponding circuit." +msgstr "" + +#: of paddle_quantum.gate.clifford.compose_clifford_circuit:3 +msgid "The first Clifford operator to be composed." +msgstr "" + +#: of paddle_quantum.gate.clifford.compose_clifford_circuit:4 +msgid "The second Clifford operator to be composed." +msgstr "" + +#: of paddle_quantum.gate.clifford.compose_clifford_circuit:6 +msgid "Circuit corresponding to the composed Clifford operator." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.custom.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.custom.po new file mode 100644 index 0000000..3003112 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.custom.po @@ -0,0 +1,66 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gate.custom.rst:2 +msgid "paddle\\_quantum.gate.custom" +msgstr "" + +#: of paddle_quantum.gate.custom:1 +msgid "The source file of the oracle class and the control oracle class." +msgstr "" + +#: of paddle_quantum.gate.custom.ControlOracle:1 +#: paddle_quantum.gate.custom.Oracle:1 +msgid "Bases: :py:class:`~paddle_quantum.gate.base.Gate`" +msgstr "" + +#: of paddle_quantum.gate.custom.Oracle:1 +msgid "An oracle as a gate." +msgstr "" + +#: of paddle_quantum.gate.custom.ControlOracle +#: paddle_quantum.gate.custom.Oracle +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.gate.custom.ControlOracle:3 +#: paddle_quantum.gate.custom.Oracle:3 +msgid "Unitary oracle to be implemented." +msgstr "" + +#: of paddle_quantum.gate.custom.ControlOracle:4 +#: paddle_quantum.gate.custom.Oracle:4 +msgid "Indices of the qubits on which the gates are applied." +msgstr "" + +#: of paddle_quantum.gate.custom.ControlOracle:5 +#: paddle_quantum.gate.custom.Oracle:5 +msgid "Total number of qubits. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.gate.custom.ControlOracle:6 +#: paddle_quantum.gate.custom.Oracle:6 +msgid "Number of layers. Defaults to ``1``." +msgstr "" + +#: of paddle_quantum.gate.custom.ControlOracle:1 +msgid "A controlled oracle as a gate." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.encoding.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.encoding.po new file mode 100644 index 0000000..bfc0b24 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.encoding.po @@ -0,0 +1,106 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gate.encoding.rst:2 +msgid "paddle\\_quantum.gate.encoding" +msgstr "" + +#: of paddle_quantum.gate.encoding:1 +msgid "The source file of the classes for quantum encoding." +msgstr "" + +#: of paddle_quantum.gate.encoding.AmplitudeEncoding:1 +#: paddle_quantum.gate.encoding.AngleEncoding:1 +#: paddle_quantum.gate.encoding.BasisEncoding:1 +#: paddle_quantum.gate.encoding.IQPEncoding:1 +msgid "Bases: :py:class:`~paddle_quantum.gate.base.Gate`" +msgstr "" + +#: of paddle_quantum.gate.encoding.BasisEncoding:1 +msgid "Basis encoding gate for encoding input classical data into quantum states." +msgstr "" + +#: of paddle_quantum.gate.encoding.BasisEncoding:3 +msgid "" +"In basis encoding, the input classical data can only consist of 0's and " +"1's. If the input data are 1101, then the quantum state after encoding is" +" :math:`|1101\\rangle`. Note that the quantum state before encoding is " +"assumed to be :math:`|00\\ldots 0\\rangle`." +msgstr "" + +#: of paddle_quantum.gate.encoding.AmplitudeEncoding +#: paddle_quantum.gate.encoding.AngleEncoding +#: paddle_quantum.gate.encoding.BasisEncoding +#: paddle_quantum.gate.encoding.IQPEncoding +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.gate.encoding.AmplitudeEncoding:3 +#: paddle_quantum.gate.encoding.AngleEncoding:4 +#: paddle_quantum.gate.encoding.BasisEncoding:7 +msgid "" +"Indices of the qubits on which the gates are applied. Defaults to " +"``'full'``." +msgstr "" + +#: of paddle_quantum.gate.encoding.AmplitudeEncoding:4 +#: paddle_quantum.gate.encoding.AngleEncoding:5 +#: paddle_quantum.gate.encoding.BasisEncoding:8 +#: paddle_quantum.gate.encoding.IQPEncoding:5 +msgid "Total number of qubits. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.gate.encoding.AmplitudeEncoding:1 +msgid "" +"Amplitude encoding gate for encoding input classical data into quantum " +"states." +msgstr "" + +#: of paddle_quantum.gate.encoding.AngleEncoding:1 +msgid "Angle encoding gate for encoding input classical data into quantum states." +msgstr "" + +#: of paddle_quantum.gate.encoding.AngleEncoding:3 +#: paddle_quantum.gate.encoding.IQPEncoding:3 +msgid "Vector to be encoded." +msgstr "" + +#: of paddle_quantum.gate.encoding.AngleEncoding:6 +msgid "" +"The type of quantum gates used for encoding, which should be one of " +"``\"rx\"``, ``\"ry\"``, and ``\"rz\"``. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.gate.encoding.IQPEncoding:1 +msgid "" +"IQP style encoding gate for encoding input classical data into quantum " +"states." +msgstr "" + +#: of paddle_quantum.gate.encoding.IQPEncoding:4 +msgid "" +"Indices of the qubits on which the gates are applied. Defaults to " +"``None``." +msgstr "" + +#: of paddle_quantum.gate.encoding.IQPEncoding:6 +msgid "Number of encoding layers. Defaults to ``1``." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.functional.base.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.functional.base.po new file mode 100644 index 0000000..2cbc637 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.functional.base.po @@ -0,0 +1,68 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gate.functional.base.rst:2 +msgid "paddle\\_quantum.gate.functional.base" +msgstr "" + +#: of paddle_quantum.gate.functional.base:1 +msgid "The source file of the basic function for quantum gates." +msgstr "" + +#: of paddle_quantum.gate.functional.base.simulation:1 +msgid "Apply the gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.base.simulation +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.gate.functional.base.simulation:3 +msgid "Input state." +msgstr "" + +#: of paddle_quantum.gate.functional.base.simulation:4 +msgid "Gate to be executed." +msgstr "" + +#: of paddle_quantum.gate.functional.base.simulation:5 +msgid "Indices of the qubits on which the gate is applied." +msgstr "" + +#: of paddle_quantum.gate.functional.base.simulation:6 +msgid "Total number of qubits." +msgstr "" + +#: of paddle_quantum.gate.functional.base.simulation:7 +msgid "Backend on which the simulation is run." +msgstr "" + +#: of paddle_quantum.gate.functional.base.simulation +msgid "Returns" +msgstr "" + +#: of paddle_quantum.gate.functional.base.simulation:9 +msgid "Output state." +msgstr "" + +#: of paddle_quantum.gate.functional.base.simulation +msgid "Return type" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.functional.multi_qubit_gate.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.functional.multi_qubit_gate.po new file mode 100644 index 0000000..9f9d916 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.functional.multi_qubit_gate.po @@ -0,0 +1,287 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gate.functional.multi_qubit_gate.rst:2 +msgid "paddle\\_quantum.gate.functional.multi\\_qubit\\_gate" +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate:1 +msgid "The source file of the functions for multi-qubit quantum gates." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cnot:1 +msgid "Apply a CNOT gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cnot +#: paddle_quantum.gate.functional.multi_qubit_gate.cp +#: paddle_quantum.gate.functional.multi_qubit_gate.crx +#: paddle_quantum.gate.functional.multi_qubit_gate.cry +#: paddle_quantum.gate.functional.multi_qubit_gate.crz +#: paddle_quantum.gate.functional.multi_qubit_gate.cswap +#: paddle_quantum.gate.functional.multi_qubit_gate.cu +#: paddle_quantum.gate.functional.multi_qubit_gate.cy +#: paddle_quantum.gate.functional.multi_qubit_gate.cz +#: paddle_quantum.gate.functional.multi_qubit_gate.ms +#: paddle_quantum.gate.functional.multi_qubit_gate.oracle +#: paddle_quantum.gate.functional.multi_qubit_gate.rxx +#: paddle_quantum.gate.functional.multi_qubit_gate.ryy +#: paddle_quantum.gate.functional.multi_qubit_gate.rzz +#: paddle_quantum.gate.functional.multi_qubit_gate.swap +#: paddle_quantum.gate.functional.multi_qubit_gate.toffoli +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_three_qubits +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_two_qubits +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cnot:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.cp:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.crx:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.cry:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.crz:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.cswap:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.cu:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.cy:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.cz:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.ms:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.oracle:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.rxx:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.ryy:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.rzz:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.swap:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.toffoli:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_three_qubits:3 +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_two_qubits:3 +msgid "Input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cnot:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.cp:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.crx:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.cry:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.crz:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.cswap:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.cu:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.cy:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.cz:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.ms:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.oracle:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.rxx:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.ryy:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.rzz:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.swap:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.toffoli:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_three_qubits:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_two_qubits:5 +msgid "Indices of the qubits on which the gate is applied." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cnot:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.cp:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.crx:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.cry:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.crz:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.cswap:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.cu:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.cy:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.cz:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.ms:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.rxx:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.ryy:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.rzz:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.swap:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.toffoli:5 +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_three_qubits:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_two_qubits:6 +msgid "Type of data." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cnot:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.cp:7 +#: paddle_quantum.gate.functional.multi_qubit_gate.crx:7 +#: paddle_quantum.gate.functional.multi_qubit_gate.cry:7 +#: paddle_quantum.gate.functional.multi_qubit_gate.crz:7 +#: paddle_quantum.gate.functional.multi_qubit_gate.cswap:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.cu:7 +#: paddle_quantum.gate.functional.multi_qubit_gate.cy:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.cz:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.ms:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.oracle:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.rxx:7 +#: paddle_quantum.gate.functional.multi_qubit_gate.ryy:7 +#: paddle_quantum.gate.functional.multi_qubit_gate.rzz:7 +#: paddle_quantum.gate.functional.multi_qubit_gate.swap:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.toffoli:6 +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_three_qubits:7 +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_two_qubits:7 +msgid "Backend on which the simulation is run." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cnot +#: paddle_quantum.gate.functional.multi_qubit_gate.cp +#: paddle_quantum.gate.functional.multi_qubit_gate.crx +#: paddle_quantum.gate.functional.multi_qubit_gate.cry +#: paddle_quantum.gate.functional.multi_qubit_gate.crz +#: paddle_quantum.gate.functional.multi_qubit_gate.cswap +#: paddle_quantum.gate.functional.multi_qubit_gate.cu +#: paddle_quantum.gate.functional.multi_qubit_gate.cy +#: paddle_quantum.gate.functional.multi_qubit_gate.cz +#: paddle_quantum.gate.functional.multi_qubit_gate.ms +#: paddle_quantum.gate.functional.multi_qubit_gate.oracle +#: paddle_quantum.gate.functional.multi_qubit_gate.rxx +#: paddle_quantum.gate.functional.multi_qubit_gate.ryy +#: paddle_quantum.gate.functional.multi_qubit_gate.rzz +#: paddle_quantum.gate.functional.multi_qubit_gate.swap +#: paddle_quantum.gate.functional.multi_qubit_gate.toffoli +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_three_qubits +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_two_qubits +msgid "Returns" +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cnot:8 +#: paddle_quantum.gate.functional.multi_qubit_gate.cp:9 +#: paddle_quantum.gate.functional.multi_qubit_gate.crx:9 +#: paddle_quantum.gate.functional.multi_qubit_gate.cry:9 +#: paddle_quantum.gate.functional.multi_qubit_gate.crz:9 +#: paddle_quantum.gate.functional.multi_qubit_gate.cswap:8 +#: paddle_quantum.gate.functional.multi_qubit_gate.cu:9 +#: paddle_quantum.gate.functional.multi_qubit_gate.cy:8 +#: paddle_quantum.gate.functional.multi_qubit_gate.cz:8 +#: paddle_quantum.gate.functional.multi_qubit_gate.ms:8 +#: paddle_quantum.gate.functional.multi_qubit_gate.oracle:8 +#: paddle_quantum.gate.functional.multi_qubit_gate.rxx:9 +#: paddle_quantum.gate.functional.multi_qubit_gate.ryy:9 +#: paddle_quantum.gate.functional.multi_qubit_gate.rzz:9 +#: paddle_quantum.gate.functional.multi_qubit_gate.swap:8 +#: paddle_quantum.gate.functional.multi_qubit_gate.toffoli:8 +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_three_qubits:9 +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_two_qubits:9 +msgid "Output state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cnot +#: paddle_quantum.gate.functional.multi_qubit_gate.cp +#: paddle_quantum.gate.functional.multi_qubit_gate.crx +#: paddle_quantum.gate.functional.multi_qubit_gate.cry +#: paddle_quantum.gate.functional.multi_qubit_gate.crz +#: paddle_quantum.gate.functional.multi_qubit_gate.cswap +#: paddle_quantum.gate.functional.multi_qubit_gate.cu +#: paddle_quantum.gate.functional.multi_qubit_gate.cy +#: paddle_quantum.gate.functional.multi_qubit_gate.cz +#: paddle_quantum.gate.functional.multi_qubit_gate.ms +#: paddle_quantum.gate.functional.multi_qubit_gate.oracle +#: paddle_quantum.gate.functional.multi_qubit_gate.rxx +#: paddle_quantum.gate.functional.multi_qubit_gate.ryy +#: paddle_quantum.gate.functional.multi_qubit_gate.rzz +#: paddle_quantum.gate.functional.multi_qubit_gate.swap +#: paddle_quantum.gate.functional.multi_qubit_gate.toffoli +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_three_qubits +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_two_qubits +msgid "Return type" +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cy:1 +msgid "Apply a controlled Y gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cz:1 +msgid "Apply a controlled Z gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.swap:1 +msgid "Apply a SWAP gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cp:1 +msgid "Apply a controlled P gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cp:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.crx:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.cry:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.crz:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.rxx:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.ryy:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.rzz:4 +msgid "Parameter of the gate." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.crx:1 +msgid "Apply a controlled rotation gate about the x-axis on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cry:1 +msgid "Apply a controlled rotation gate about the y-axis on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.crz:1 +msgid "Apply a controlled rotation gate about the z-axis on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cu:1 +msgid "Apply a controlled single-qubit rotation gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cu:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_three_qubits:4 +#: paddle_quantum.gate.functional.multi_qubit_gate.universal_two_qubits:4 +msgid "Parameters of the gate." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.rxx:1 +msgid "Apply an RXX gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.ryy:1 +msgid "Apply an RYY gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.rzz:1 +msgid "Apply an RZZ gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.ms:1 +msgid "Apply a Mølmer-Sørensen (MS) gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.cswap:1 +msgid "Apply a CSWAP (Fredkin) gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.toffoli:1 +msgid "Apply a Toffoli gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.universal_two_qubits:1 +msgid "Apply a universal two-qubit gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.universal_three_qubits:1 +msgid "Apply a universal three-qubit gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.oracle:1 +msgid "Apply an oracle gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.multi_qubit_gate.oracle:4 +msgid "Oracle to be executed." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.functional.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.functional.po new file mode 100644 index 0000000..d508cd5 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.functional.po @@ -0,0 +1,32 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gate.functional.rst:2 +msgid "paddle\\_quantum.gate.functional" +msgstr "" + +#: of paddle_quantum.gate.functional:1 +msgid "The module that contains the functions of various quantum gates." +msgstr "" + +#: ../../source/paddle_quantum.gate.functional.rst:9 +msgid "Submodules" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.functional.single_qubit_gate.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.functional.single_qubit_gate.po new file mode 100644 index 0000000..62448fb --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.functional.single_qubit_gate.po @@ -0,0 +1,195 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gate.functional.single_qubit_gate.rst:2 +msgid "paddle\\_quantum.gate.functional.single\\_qubit\\_gate" +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate:1 +msgid "The source file of the functions for single-qubit quantum gates." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.h:1 +msgid "Apply a Hadamard gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.h +#: paddle_quantum.gate.functional.single_qubit_gate.p +#: paddle_quantum.gate.functional.single_qubit_gate.rx +#: paddle_quantum.gate.functional.single_qubit_gate.ry +#: paddle_quantum.gate.functional.single_qubit_gate.rz +#: paddle_quantum.gate.functional.single_qubit_gate.s +#: paddle_quantum.gate.functional.single_qubit_gate.t +#: paddle_quantum.gate.functional.single_qubit_gate.u3 +#: paddle_quantum.gate.functional.single_qubit_gate.x +#: paddle_quantum.gate.functional.single_qubit_gate.y +#: paddle_quantum.gate.functional.single_qubit_gate.z +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.h:3 +#: paddle_quantum.gate.functional.single_qubit_gate.p:3 +#: paddle_quantum.gate.functional.single_qubit_gate.rx:3 +#: paddle_quantum.gate.functional.single_qubit_gate.ry:3 +#: paddle_quantum.gate.functional.single_qubit_gate.rz:3 +#: paddle_quantum.gate.functional.single_qubit_gate.s:3 +#: paddle_quantum.gate.functional.single_qubit_gate.t:3 +#: paddle_quantum.gate.functional.single_qubit_gate.u3:3 +#: paddle_quantum.gate.functional.single_qubit_gate.x:3 +#: paddle_quantum.gate.functional.single_qubit_gate.y:3 +#: paddle_quantum.gate.functional.single_qubit_gate.z:3 +msgid "Input state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.h:4 +#: paddle_quantum.gate.functional.single_qubit_gate.p:5 +#: paddle_quantum.gate.functional.single_qubit_gate.rx:5 +#: paddle_quantum.gate.functional.single_qubit_gate.ry:5 +#: paddle_quantum.gate.functional.single_qubit_gate.rz:5 +#: paddle_quantum.gate.functional.single_qubit_gate.s:4 +#: paddle_quantum.gate.functional.single_qubit_gate.t:4 +#: paddle_quantum.gate.functional.single_qubit_gate.u3:5 +#: paddle_quantum.gate.functional.single_qubit_gate.x:4 +#: paddle_quantum.gate.functional.single_qubit_gate.y:4 +#: paddle_quantum.gate.functional.single_qubit_gate.z:4 +msgid "Index of the qubit on which the gate is applied." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.h:5 +#: paddle_quantum.gate.functional.single_qubit_gate.p:6 +#: paddle_quantum.gate.functional.single_qubit_gate.rx:6 +#: paddle_quantum.gate.functional.single_qubit_gate.ry:6 +#: paddle_quantum.gate.functional.single_qubit_gate.rz:6 +#: paddle_quantum.gate.functional.single_qubit_gate.s:5 +#: paddle_quantum.gate.functional.single_qubit_gate.t:5 +#: paddle_quantum.gate.functional.single_qubit_gate.u3:6 +#: paddle_quantum.gate.functional.single_qubit_gate.x:5 +#: paddle_quantum.gate.functional.single_qubit_gate.y:5 +#: paddle_quantum.gate.functional.single_qubit_gate.z:5 +msgid "Type of data." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.h:6 +#: paddle_quantum.gate.functional.single_qubit_gate.p:7 +#: paddle_quantum.gate.functional.single_qubit_gate.rx:7 +#: paddle_quantum.gate.functional.single_qubit_gate.ry:7 +#: paddle_quantum.gate.functional.single_qubit_gate.rz:7 +#: paddle_quantum.gate.functional.single_qubit_gate.s:6 +#: paddle_quantum.gate.functional.single_qubit_gate.t:6 +#: paddle_quantum.gate.functional.single_qubit_gate.u3:7 +#: paddle_quantum.gate.functional.single_qubit_gate.x:6 +#: paddle_quantum.gate.functional.single_qubit_gate.y:6 +#: paddle_quantum.gate.functional.single_qubit_gate.z:6 +msgid "Backend on which the simulation is run." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.h +#: paddle_quantum.gate.functional.single_qubit_gate.p +#: paddle_quantum.gate.functional.single_qubit_gate.rx +#: paddle_quantum.gate.functional.single_qubit_gate.ry +#: paddle_quantum.gate.functional.single_qubit_gate.rz +#: paddle_quantum.gate.functional.single_qubit_gate.s +#: paddle_quantum.gate.functional.single_qubit_gate.t +#: paddle_quantum.gate.functional.single_qubit_gate.u3 +#: paddle_quantum.gate.functional.single_qubit_gate.x +#: paddle_quantum.gate.functional.single_qubit_gate.y +#: paddle_quantum.gate.functional.single_qubit_gate.z +msgid "Returns" +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.h:8 +#: paddle_quantum.gate.functional.single_qubit_gate.p:9 +#: paddle_quantum.gate.functional.single_qubit_gate.rx:9 +#: paddle_quantum.gate.functional.single_qubit_gate.ry:9 +#: paddle_quantum.gate.functional.single_qubit_gate.rz:9 +#: paddle_quantum.gate.functional.single_qubit_gate.s:8 +#: paddle_quantum.gate.functional.single_qubit_gate.t:8 +#: paddle_quantum.gate.functional.single_qubit_gate.u3:9 +#: paddle_quantum.gate.functional.single_qubit_gate.x:8 +#: paddle_quantum.gate.functional.single_qubit_gate.y:8 +#: paddle_quantum.gate.functional.single_qubit_gate.z:8 +msgid "Output state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.h +#: paddle_quantum.gate.functional.single_qubit_gate.p +#: paddle_quantum.gate.functional.single_qubit_gate.rx +#: paddle_quantum.gate.functional.single_qubit_gate.ry +#: paddle_quantum.gate.functional.single_qubit_gate.rz +#: paddle_quantum.gate.functional.single_qubit_gate.s +#: paddle_quantum.gate.functional.single_qubit_gate.t +#: paddle_quantum.gate.functional.single_qubit_gate.u3 +#: paddle_quantum.gate.functional.single_qubit_gate.x +#: paddle_quantum.gate.functional.single_qubit_gate.y +#: paddle_quantum.gate.functional.single_qubit_gate.z +msgid "Return type" +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.s:1 +msgid "Apply an S gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.t:1 +msgid "Apply a T gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.x:1 +msgid "Apply an X gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.y:1 +msgid "Apply a Y gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.z:1 +msgid "Apply a Z gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.p:1 +msgid "Apply a P gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.p:4 +#: paddle_quantum.gate.functional.single_qubit_gate.rx:4 +#: paddle_quantum.gate.functional.single_qubit_gate.ry:4 +#: paddle_quantum.gate.functional.single_qubit_gate.rz:4 +msgid "Parameter of the gate." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.rx:1 +msgid "Apply a single-qubit rotation gate about the x-axis on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.ry:1 +msgid "Apply a single-qubit rotation gate about the y-axis on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.rz:1 +msgid "Apply a single-qubit rotation gate about the z-axis on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.u3:1 +msgid "Apply a single-qubit rotation gate on the input state." +msgstr "" + +#: of paddle_quantum.gate.functional.single_qubit_gate.u3:4 +msgid "Parameters of the gate." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.layer.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.layer.po new file mode 100644 index 0000000..06ee22b --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.layer.po @@ -0,0 +1,177 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gate.layer.rst:2 +msgid "paddle\\_quantum.gate.layer" +msgstr "" + +#: of paddle_quantum.gate.layer:1 +msgid "The source file of the class for quantum circuit templates." +msgstr "" + +#: of paddle_quantum.gate.layer.qubits_idx_filter:1 +msgid "Check the validity of ``qubits_idx`` and ``num_qubits``." +msgstr "" + +#: of paddle_quantum.gate.layer.ComplexBlockLayer +#: paddle_quantum.gate.layer.ComplexEntangledLayer +#: paddle_quantum.gate.layer.LinearEntangledLayer +#: paddle_quantum.gate.layer.RealBlockLayer +#: paddle_quantum.gate.layer.RealEntangledLayer +#: paddle_quantum.gate.layer.SuperpositionLayer +#: paddle_quantum.gate.layer.WeakSuperpositionLayer +#: paddle_quantum.gate.layer.qubits_idx_filter +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.gate.layer.qubits_idx_filter:3 +msgid "Indices of qubits." +msgstr "" + +#: of paddle_quantum.gate.layer.qubits_idx_filter:4 +msgid "Total number of qubits." +msgstr "" + +#: of paddle_quantum.gate.layer.qubits_idx_filter +msgid "Raises" +msgstr "" + +#: of paddle_quantum.gate.layer.qubits_idx_filter:6 +msgid "" +"You must specify ``qubits_idx`` or ``num_qubits`` to instantiate the " +"class." +msgstr "" + +#: of paddle_quantum.gate.layer.qubits_idx_filter:7 +msgid "The ``qubits_idx`` must be ``Iterable`` or ``'full'``." +msgstr "" + +#: of paddle_quantum.gate.layer.qubits_idx_filter +msgid "Returns" +msgstr "" + +#: of paddle_quantum.gate.layer.qubits_idx_filter:9 +msgid "Checked indices of qubits." +msgstr "" + +#: of paddle_quantum.gate.layer.qubits_idx_filter +msgid "Return type" +msgstr "" + +#: of paddle_quantum.gate.layer.ComplexBlockLayer:1 +#: paddle_quantum.gate.layer.ComplexEntangledLayer:1 +#: paddle_quantum.gate.layer.LinearEntangledLayer:1 +#: paddle_quantum.gate.layer.RealBlockLayer:1 +#: paddle_quantum.gate.layer.RealEntangledLayer:1 +#: paddle_quantum.gate.layer.SuperpositionLayer:1 +#: paddle_quantum.gate.layer.WeakSuperpositionLayer:1 +msgid "Bases: :py:class:`~paddle_quantum.gate.base.Gate`" +msgstr "" + +#: of paddle_quantum.gate.layer.SuperpositionLayer:1 +msgid "Layers of Hadamard gates." +msgstr "" + +#: of paddle_quantum.gate.layer.ComplexBlockLayer:5 +#: paddle_quantum.gate.layer.ComplexEntangledLayer:8 +#: paddle_quantum.gate.layer.LinearEntangledLayer:3 +#: paddle_quantum.gate.layer.RealBlockLayer:5 +#: paddle_quantum.gate.layer.RealEntangledLayer:8 +#: paddle_quantum.gate.layer.SuperpositionLayer:3 +#: paddle_quantum.gate.layer.WeakSuperpositionLayer:3 +msgid "" +"Indices of the qubits on which the gates are applied. Defaults to " +"``'full'``." +msgstr "" + +#: of paddle_quantum.gate.layer.ComplexBlockLayer:6 +#: paddle_quantum.gate.layer.ComplexEntangledLayer:9 +#: paddle_quantum.gate.layer.LinearEntangledLayer:4 +#: paddle_quantum.gate.layer.RealBlockLayer:6 +#: paddle_quantum.gate.layer.RealEntangledLayer:9 +#: paddle_quantum.gate.layer.SuperpositionLayer:4 +#: paddle_quantum.gate.layer.WeakSuperpositionLayer:4 +msgid "Total number of qubits. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.gate.layer.ComplexBlockLayer:7 +#: paddle_quantum.gate.layer.ComplexEntangledLayer:10 +#: paddle_quantum.gate.layer.LinearEntangledLayer:5 +#: paddle_quantum.gate.layer.RealBlockLayer:7 +#: paddle_quantum.gate.layer.RealEntangledLayer:10 +#: paddle_quantum.gate.layer.SuperpositionLayer:5 +#: paddle_quantum.gate.layer.WeakSuperpositionLayer:5 +msgid "Number of layers. Defaults to ``1``." +msgstr "" + +#: of paddle_quantum.gate.layer.WeakSuperpositionLayer:1 +msgid "Layers of Ry gates with a rotation angle :math:`\\pi/4`." +msgstr "" + +#: of paddle_quantum.gate.layer.LinearEntangledLayer:1 +msgid "Linear entangled layers consisting of Ry gates, Rz gates, and CNOT gates." +msgstr "" + +#: of paddle_quantum.gate.layer.RealEntangledLayer:1 +msgid "Strongly entangled layers consisting of Ry gates and CNOT gates." +msgstr "" + +#: of paddle_quantum.gate.layer.RealEntangledLayer:5 +msgid "" +"The mathematical representation of this layer of quantum gates is a real " +"unitary matrix. This ansatz is from the following paper: " +"https://arxiv.org/pdf/1905.10876.pdf." +msgstr "" + +#: of paddle_quantum.gate.layer.ComplexEntangledLayer:1 +msgid "" +"Strongly entangled layers consisting of single-qubit rotation gates and " +"CNOT gates." +msgstr "" + +#: of paddle_quantum.gate.layer.ComplexEntangledLayer:5 +msgid "" +"The mathematical representation of this layer of quantum gates is a " +"complex unitary matrix. This ansatz is from the following paper: " +"https://arxiv.org/abs/1804.00633." +msgstr "" + +#: of paddle_quantum.gate.layer.RealBlockLayer:1 +msgid "Weakly entangled layers consisting of Ry gates and CNOT gates." +msgstr "" + +#: of paddle_quantum.gate.layer.RealBlockLayer:3 +msgid "" +"The mathematical representation of this layer of quantum gates is a real " +"unitary matrix." +msgstr "" + +#: of paddle_quantum.gate.layer.ComplexBlockLayer:1 +msgid "" +"Weakly entangled layers consisting of single-qubit rotation gates and " +"CNOT gates." +msgstr "" + +#: of paddle_quantum.gate.layer.ComplexBlockLayer:3 +msgid "" +"The mathematical representation of this layer of quantum gates is a " +"complex unitary matrix." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.multi_qubit_gate.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.multi_qubit_gate.po new file mode 100644 index 0000000..a61dd34 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.multi_qubit_gate.po @@ -0,0 +1,506 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gate.multi_qubit_gate.rst:2 +msgid "paddle\\_quantum.gate.multi\\_qubit\\_gate" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate:1 +msgid "The source file of the classes for multi-qubit gates." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CNOT:1 +#: paddle_quantum.gate.multi_qubit_gate.CP:1 +#: paddle_quantum.gate.multi_qubit_gate.CRX:1 +#: paddle_quantum.gate.multi_qubit_gate.CRY:1 +#: paddle_quantum.gate.multi_qubit_gate.CRZ:1 +#: paddle_quantum.gate.multi_qubit_gate.CSWAP:1 +#: paddle_quantum.gate.multi_qubit_gate.CU:1 +#: paddle_quantum.gate.multi_qubit_gate.CX:1 +#: paddle_quantum.gate.multi_qubit_gate.CY:1 +#: paddle_quantum.gate.multi_qubit_gate.CZ:1 +#: paddle_quantum.gate.multi_qubit_gate.MS:1 +#: paddle_quantum.gate.multi_qubit_gate.RXX:1 +#: paddle_quantum.gate.multi_qubit_gate.RYY:1 +#: paddle_quantum.gate.multi_qubit_gate.RZZ:1 +#: paddle_quantum.gate.multi_qubit_gate.SWAP:1 +#: paddle_quantum.gate.multi_qubit_gate.Toffoli:1 +#: paddle_quantum.gate.multi_qubit_gate.UniversalThreeQubits:1 +#: paddle_quantum.gate.multi_qubit_gate.UniversalTwoQubits:1 +msgid "Bases: :py:class:`~paddle_quantum.gate.base.Gate`" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CNOT:1 +msgid "A collection of CNOT gates." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CNOT:3 +#: paddle_quantum.gate.multi_qubit_gate.CP:3 +#: paddle_quantum.gate.multi_qubit_gate.CRX:3 +#: paddle_quantum.gate.multi_qubit_gate.CRY:3 +#: paddle_quantum.gate.multi_qubit_gate.CRZ:3 +#: paddle_quantum.gate.multi_qubit_gate.CU:3 +#: paddle_quantum.gate.multi_qubit_gate.CY:3 +#: paddle_quantum.gate.multi_qubit_gate.CZ:3 +msgid "" +"For a 2-qubit quantum circuit, when ``qubits_idx`` is ``[0, 1]``, the " +"matrix form of such a gate is:" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CNOT:5 +msgid "" +"\\begin{align}\n" +" CNOT &=|0\\rangle \\langle 0|\\otimes I + |1 \\rangle \\langle " +"1|\\otimes X\\\\\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 1 \\\\\n" +" 0 & 0 & 1 & 0\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CNOT +#: paddle_quantum.gate.multi_qubit_gate.CP +#: paddle_quantum.gate.multi_qubit_gate.CRX +#: paddle_quantum.gate.multi_qubit_gate.CRY +#: paddle_quantum.gate.multi_qubit_gate.CRZ +#: paddle_quantum.gate.multi_qubit_gate.CSWAP +#: paddle_quantum.gate.multi_qubit_gate.CU +#: paddle_quantum.gate.multi_qubit_gate.CX +#: paddle_quantum.gate.multi_qubit_gate.CY +#: paddle_quantum.gate.multi_qubit_gate.CZ +#: paddle_quantum.gate.multi_qubit_gate.MS +#: paddle_quantum.gate.multi_qubit_gate.RXX +#: paddle_quantum.gate.multi_qubit_gate.RYY +#: paddle_quantum.gate.multi_qubit_gate.RZZ +#: paddle_quantum.gate.multi_qubit_gate.SWAP +#: paddle_quantum.gate.multi_qubit_gate.Toffoli +#: paddle_quantum.gate.multi_qubit_gate.UniversalThreeQubits +#: paddle_quantum.gate.multi_qubit_gate.UniversalTwoQubits +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CNOT:18 +#: paddle_quantum.gate.multi_qubit_gate.CP:14 +#: paddle_quantum.gate.multi_qubit_gate.CRX:18 +#: paddle_quantum.gate.multi_qubit_gate.CRY:18 +#: paddle_quantum.gate.multi_qubit_gate.CRZ:18 +#: paddle_quantum.gate.multi_qubit_gate.CSWAP:21 +#: paddle_quantum.gate.multi_qubit_gate.CU:18 +#: paddle_quantum.gate.multi_qubit_gate.CX:3 +#: paddle_quantum.gate.multi_qubit_gate.CY:18 +#: paddle_quantum.gate.multi_qubit_gate.CZ:18 +#: paddle_quantum.gate.multi_qubit_gate.MS:17 +#: paddle_quantum.gate.multi_qubit_gate.RXX:17 +#: paddle_quantum.gate.multi_qubit_gate.RYY:17 +#: paddle_quantum.gate.multi_qubit_gate.RZZ:17 +#: paddle_quantum.gate.multi_qubit_gate.SWAP:17 +#: paddle_quantum.gate.multi_qubit_gate.Toffoli:20 +#: paddle_quantum.gate.multi_qubit_gate.UniversalThreeQubits:3 +#: paddle_quantum.gate.multi_qubit_gate.UniversalTwoQubits:3 +msgid "" +"Indices of the qubits on which the gates are applied. Defaults to " +"``'cycle'``." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CNOT:19 +#: paddle_quantum.gate.multi_qubit_gate.CP:15 +#: paddle_quantum.gate.multi_qubit_gate.CRX:19 +#: paddle_quantum.gate.multi_qubit_gate.CRY:19 +#: paddle_quantum.gate.multi_qubit_gate.CRZ:19 +#: paddle_quantum.gate.multi_qubit_gate.CSWAP:22 +#: paddle_quantum.gate.multi_qubit_gate.CU:19 +#: paddle_quantum.gate.multi_qubit_gate.CX:4 +#: paddle_quantum.gate.multi_qubit_gate.CY:19 +#: paddle_quantum.gate.multi_qubit_gate.CZ:19 +#: paddle_quantum.gate.multi_qubit_gate.MS:18 +#: paddle_quantum.gate.multi_qubit_gate.RXX:18 +#: paddle_quantum.gate.multi_qubit_gate.RYY:18 +#: paddle_quantum.gate.multi_qubit_gate.RZZ:18 +#: paddle_quantum.gate.multi_qubit_gate.SWAP:18 +#: paddle_quantum.gate.multi_qubit_gate.Toffoli:21 +#: paddle_quantum.gate.multi_qubit_gate.UniversalThreeQubits:4 +#: paddle_quantum.gate.multi_qubit_gate.UniversalTwoQubits:4 +msgid "Total number of qubits. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CNOT:20 +#: paddle_quantum.gate.multi_qubit_gate.CP:16 +#: paddle_quantum.gate.multi_qubit_gate.CRX:20 +#: paddle_quantum.gate.multi_qubit_gate.CRY:20 +#: paddle_quantum.gate.multi_qubit_gate.CRZ:20 +#: paddle_quantum.gate.multi_qubit_gate.CSWAP:23 +#: paddle_quantum.gate.multi_qubit_gate.CU:20 +#: paddle_quantum.gate.multi_qubit_gate.CX:5 +#: paddle_quantum.gate.multi_qubit_gate.CY:20 +#: paddle_quantum.gate.multi_qubit_gate.CZ:20 +#: paddle_quantum.gate.multi_qubit_gate.MS:19 +#: paddle_quantum.gate.multi_qubit_gate.RXX:19 +#: paddle_quantum.gate.multi_qubit_gate.RYY:19 +#: paddle_quantum.gate.multi_qubit_gate.RZZ:19 +#: paddle_quantum.gate.multi_qubit_gate.SWAP:19 +#: paddle_quantum.gate.multi_qubit_gate.Toffoli:22 +#: paddle_quantum.gate.multi_qubit_gate.UniversalThreeQubits:5 +#: paddle_quantum.gate.multi_qubit_gate.UniversalTwoQubits:5 +msgid "Number of layers. Defaults to ``1``." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CX:1 +msgid "Same as CNOT." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CY:1 +msgid "A collection of controlled Y gates." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CY:5 +msgid "" +"\\begin{align}\n" +" CY &=|0\\rangle \\langle 0|\\otimes I + |1 \\rangle \\langle " +"1|\\otimes Y\\\\\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & -1j \\\\\n" +" 0 & 0 & 1j & 0\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CZ:1 +msgid "A collection of controlled Z gates." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CZ:5 +msgid "" +"\\begin{align}\n" +" CZ &=|0\\rangle \\langle 0|\\otimes I + |1 \\rangle \\langle " +"1|\\otimes Z\\\\\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 1 & 0 \\\\\n" +" 0 & 0 & 0 & -1\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.SWAP:1 +msgid "A collection of SWAP gates." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CSWAP:3 +#: paddle_quantum.gate.multi_qubit_gate.MS:3 +#: paddle_quantum.gate.multi_qubit_gate.RXX:3 +#: paddle_quantum.gate.multi_qubit_gate.RYY:3 +#: paddle_quantum.gate.multi_qubit_gate.RZZ:3 +#: paddle_quantum.gate.multi_qubit_gate.SWAP:3 +#: paddle_quantum.gate.multi_qubit_gate.Toffoli:3 +msgid "The matrix form of such a gate is:" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.SWAP:5 +msgid "" +"\\begin{align}\n" +" SWAP =\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 1 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 1\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CP:1 +msgid "A collection of controlled P gates." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CP:5 +msgid "" +"\\begin{bmatrix}\n" +" 1 & 0 & 0 & 0\\\\\n" +" 0 & 1 & 0 & 0\\\\\n" +" 0 & 0 & 1 & 0\\\\\n" +" 0 & 0 & 0 & e^{i\\theta}\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CP:17 +#: paddle_quantum.gate.multi_qubit_gate.CRX:21 +#: paddle_quantum.gate.multi_qubit_gate.CRY:21 +#: paddle_quantum.gate.multi_qubit_gate.CRZ:21 +#: paddle_quantum.gate.multi_qubit_gate.CU:21 +#: paddle_quantum.gate.multi_qubit_gate.RXX:20 +#: paddle_quantum.gate.multi_qubit_gate.RYY:20 +#: paddle_quantum.gate.multi_qubit_gate.RZZ:20 +#: paddle_quantum.gate.multi_qubit_gate.UniversalThreeQubits:6 +#: paddle_quantum.gate.multi_qubit_gate.UniversalTwoQubits:6 +msgid "Parameters of the gates. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CP:18 +#: paddle_quantum.gate.multi_qubit_gate.CRX:22 +#: paddle_quantum.gate.multi_qubit_gate.CRY:22 +#: paddle_quantum.gate.multi_qubit_gate.CRZ:22 +#: paddle_quantum.gate.multi_qubit_gate.CU:22 +#: paddle_quantum.gate.multi_qubit_gate.RXX:21 +#: paddle_quantum.gate.multi_qubit_gate.RYY:21 +#: paddle_quantum.gate.multi_qubit_gate.RZZ:21 +#: paddle_quantum.gate.multi_qubit_gate.UniversalThreeQubits:7 +#: paddle_quantum.gate.multi_qubit_gate.UniversalTwoQubits:7 +msgid "Whether gates in the same layer share a parameter. Defaults to ``False``." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CP +#: paddle_quantum.gate.multi_qubit_gate.CRX +#: paddle_quantum.gate.multi_qubit_gate.CRY +#: paddle_quantum.gate.multi_qubit_gate.CRZ +#: paddle_quantum.gate.multi_qubit_gate.CU +#: paddle_quantum.gate.multi_qubit_gate.RXX +#: paddle_quantum.gate.multi_qubit_gate.RYY +#: paddle_quantum.gate.multi_qubit_gate.RZZ +#: paddle_quantum.gate.multi_qubit_gate.UniversalThreeQubits +#: paddle_quantum.gate.multi_qubit_gate.UniversalTwoQubits +msgid "Raises" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CP:20 +#: paddle_quantum.gate.multi_qubit_gate.CRX:24 +#: paddle_quantum.gate.multi_qubit_gate.CRY:24 +#: paddle_quantum.gate.multi_qubit_gate.CRZ:24 +#: paddle_quantum.gate.multi_qubit_gate.CU:24 +#: paddle_quantum.gate.multi_qubit_gate.RXX:23 +#: paddle_quantum.gate.multi_qubit_gate.RYY:23 +#: paddle_quantum.gate.multi_qubit_gate.RZZ:23 +#: paddle_quantum.gate.multi_qubit_gate.UniversalThreeQubits:9 +#: paddle_quantum.gate.multi_qubit_gate.UniversalTwoQubits:9 +msgid "The ``param`` must be ``paddle.Tensor`` or ``float``." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CRX:1 +msgid "A collection of controlled rotation gates about the x-axis." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CRX:5 +msgid "" +"\\begin{align}\n" +" CRx &=|0\\rangle \\langle 0|\\otimes I + |1 \\rangle \\langle " +"1|\\otimes Rx\\\\\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\\n" +" 0 & 0 & -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CRY:1 +msgid "A collection of controlled rotation gates about the y-axis." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CRY:5 +msgid "" +"\\begin{align}\n" +" CRy &=|0\\rangle \\langle 0|\\otimes I + |1 \\rangle \\langle " +"1|\\otimes Ry\\\\\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\\n" +" 0 & 0 & \\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CRZ:1 +msgid "A collection of controlled rotation gates about the z-axis." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CRZ:5 +msgid "" +"\\begin{align}\n" +" CRz &=|0\\rangle \\langle 0|\\otimes I + |1 \\rangle \\langle " +"1|\\otimes Rz\\\\\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 1 & 0 \\\\\n" +" 0 & 0 & 0 & e^{i\\theta}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CU:1 +msgid "A collection of controlled single-qubit rotation gates." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CU:5 +msgid "" +"\\begin{align}\n" +" CU\n" +" &=\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & \\cos\\frac\\theta2 &-e^{i\\lambda}\\sin\\frac\\theta2 " +"\\\\\n" +" 0 & 0 & " +"e^{i\\phi}\\sin\\frac\\theta2&e^{i(\\phi+\\lambda)}\\cos\\frac\\theta2\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.RXX:1 +msgid "A collection of RXX gates." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.RXX:5 +msgid "" +"\\begin{align}\n" +" RXX(\\theta) =\n" +" \\begin{bmatrix}\n" +" \\cos\\frac{\\theta}{2} & 0 & 0 & -i\\sin\\frac{\\theta}{2} " +"\\\\\n" +" 0 & \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} & 0 " +"\\\\\n" +" 0 & -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} & 0 " +"\\\\\n" +" -i\\sin\\frac{\\theta}{2} & 0 & 0 & \\cos\\frac{\\theta}{2}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.RYY:1 +msgid "A collection of RYY gates." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.RYY:5 +msgid "" +"\\begin{align}\n" +" RYY(\\theta) =\n" +" \\begin{bmatrix}\n" +" \\cos\\frac{\\theta}{2} & 0 & 0 & i\\sin\\frac{\\theta}{2} " +"\\\\\n" +" 0 & \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} & 0 " +"\\\\\n" +" 0 & -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} & 0 " +"\\\\\n" +" i\\sin\\frac{\\theta}{2} & 0 & 0 & cos\\frac{\\theta}{2}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.RZZ:1 +msgid "A collection of RZZ gates." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.RZZ:5 +msgid "" +"\\begin{align}\n" +" RZZ(\\theta) =\n" +" \\begin{bmatrix}\n" +" e^{-i\\frac{\\theta}{2}} & 0 & 0 & 0 \\\\\n" +" 0 & e^{i\\frac{\\theta}{2}} & 0 & 0 \\\\\n" +" 0 & 0 & e^{i\\frac{\\theta}{2}} & 0 \\\\\n" +" 0 & 0 & 0 & e^{-i\\frac{\\theta}{2}}\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.MS:1 +msgid "A collection of Mølmer-Sørensen (MS) gates for trapped ion devices." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.MS:5 +msgid "" +"\\begin{align}\n" +" MS = RXX(-\\frac{\\pi}{2}) = \\frac{1}{\\sqrt{2}}\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & i \\\\\n" +" 0 & 1 & i & 0 \\\\\n" +" 0 & i & 1 & 0 \\\\\n" +" i & 0 & 0 & 1\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CSWAP:1 +msgid "A collection of CSWAP (Fredkin) gates." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.CSWAP:5 +msgid "" +"\\begin{align}\n" +" CSWAP =\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.Toffoli:1 +msgid "A collection of Toffoli gates." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.Toffoli:5 +msgid "" +"\\begin{align}\n" +" \\begin{bmatrix}\n" +" 1 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 1 & 0 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \\\\\n" +" 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 \\\\\n" +" 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.UniversalTwoQubits:1 +msgid "" +"A collection of universal two-qubit gates. One of such a gate requires 15" +" parameters." +msgstr "" + +#: of paddle_quantum.gate.multi_qubit_gate.UniversalThreeQubits:1 +msgid "" +"A collection of universal three-qubit gates. One of such a gate requires " +"81 parameters." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.po new file mode 100644 index 0000000..ea2a27d --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.po @@ -0,0 +1,36 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gate.rst:2 +msgid "paddle\\_quantum.gate" +msgstr "" + +#: of paddle_quantum.gate:1 +msgid "The module of the quantum gates." +msgstr "" + +#: ../../source/paddle_quantum.gate.rst:9 +msgid "Subpackages" +msgstr "" + +#: ../../source/paddle_quantum.gate.rst:16 +msgid "Submodules" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.single_qubit_gate.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.single_qubit_gate.po new file mode 100644 index 0000000..c6e73fe --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gate.single_qubit_gate.po @@ -0,0 +1,285 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gate.single_qubit_gate.rst:2 +msgid "paddle\\_quantum.gate.single\\_qubit\\_gate" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate:1 +msgid "The source file of the classes for single-qubit gates." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.H:1 +#: paddle_quantum.gate.single_qubit_gate.P:1 +#: paddle_quantum.gate.single_qubit_gate.RX:1 +#: paddle_quantum.gate.single_qubit_gate.RY:1 +#: paddle_quantum.gate.single_qubit_gate.RZ:1 +#: paddle_quantum.gate.single_qubit_gate.S:1 +#: paddle_quantum.gate.single_qubit_gate.T:1 +#: paddle_quantum.gate.single_qubit_gate.U3:1 +#: paddle_quantum.gate.single_qubit_gate.X:1 +#: paddle_quantum.gate.single_qubit_gate.Y:1 +#: paddle_quantum.gate.single_qubit_gate.Z:1 +msgid "Bases: :py:class:`~paddle_quantum.gate.base.Gate`" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.H:1 +msgid "A collection of single-qubit Hadamard gates." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.H:3 +#: paddle_quantum.gate.single_qubit_gate.P:3 +#: paddle_quantum.gate.single_qubit_gate.RX:3 +#: paddle_quantum.gate.single_qubit_gate.RY:3 +#: paddle_quantum.gate.single_qubit_gate.RZ:3 +#: paddle_quantum.gate.single_qubit_gate.S:3 +#: paddle_quantum.gate.single_qubit_gate.T:3 +#: paddle_quantum.gate.single_qubit_gate.U3:3 +#: paddle_quantum.gate.single_qubit_gate.X:3 +#: paddle_quantum.gate.single_qubit_gate.Y:3 +#: paddle_quantum.gate.single_qubit_gate.Z:3 +msgid "The matrix form of such a gate is:" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.H:5 +msgid "" +"H = \\frac{1}{\\sqrt{2}}\n" +" \\begin{bmatrix}\n" +" 1&1\\\\\n" +" 1&-1\n" +" \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.H +#: paddle_quantum.gate.single_qubit_gate.P +#: paddle_quantum.gate.single_qubit_gate.RX +#: paddle_quantum.gate.single_qubit_gate.RY +#: paddle_quantum.gate.single_qubit_gate.RZ +#: paddle_quantum.gate.single_qubit_gate.S +#: paddle_quantum.gate.single_qubit_gate.T +#: paddle_quantum.gate.single_qubit_gate.U3 +#: paddle_quantum.gate.single_qubit_gate.X +#: paddle_quantum.gate.single_qubit_gate.Y +#: paddle_quantum.gate.single_qubit_gate.Z +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.H:13 +#: paddle_quantum.gate.single_qubit_gate.P:12 +#: paddle_quantum.gate.single_qubit_gate.RX:12 +#: paddle_quantum.gate.single_qubit_gate.RY:12 +#: paddle_quantum.gate.single_qubit_gate.RZ:12 +#: paddle_quantum.gate.single_qubit_gate.S:13 +#: paddle_quantum.gate.single_qubit_gate.T:13 +#: paddle_quantum.gate.single_qubit_gate.U3:15 +#: paddle_quantum.gate.single_qubit_gate.X:12 +#: paddle_quantum.gate.single_qubit_gate.Y:12 +#: paddle_quantum.gate.single_qubit_gate.Z:12 +msgid "" +"Indices of the qubits on which the gates are applied. Defaults to " +"``'full'``." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.H:14 +#: paddle_quantum.gate.single_qubit_gate.P:13 +#: paddle_quantum.gate.single_qubit_gate.RX:13 +#: paddle_quantum.gate.single_qubit_gate.RY:13 +#: paddle_quantum.gate.single_qubit_gate.RZ:13 +#: paddle_quantum.gate.single_qubit_gate.S:14 +#: paddle_quantum.gate.single_qubit_gate.T:14 +#: paddle_quantum.gate.single_qubit_gate.U3:16 +#: paddle_quantum.gate.single_qubit_gate.X:13 +#: paddle_quantum.gate.single_qubit_gate.Y:13 +#: paddle_quantum.gate.single_qubit_gate.Z:13 +msgid "Total number of qubits. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.H:15 +#: paddle_quantum.gate.single_qubit_gate.P:14 +#: paddle_quantum.gate.single_qubit_gate.RX:14 +#: paddle_quantum.gate.single_qubit_gate.RY:14 +#: paddle_quantum.gate.single_qubit_gate.RZ:14 +#: paddle_quantum.gate.single_qubit_gate.S:15 +#: paddle_quantum.gate.single_qubit_gate.T:15 +#: paddle_quantum.gate.single_qubit_gate.U3:17 +#: paddle_quantum.gate.single_qubit_gate.X:14 +#: paddle_quantum.gate.single_qubit_gate.Y:14 +#: paddle_quantum.gate.single_qubit_gate.Z:14 +msgid "Number of layers. Defaults to ``1``." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.S:1 +msgid "A collection of single-qubit S gates." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.S:5 +msgid "" +"S =\n" +" \\begin{bmatrix}\n" +" 1&0\\\\\n" +" 0&i\n" +" \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.T:1 +msgid "A collection of single-qubit T gates." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.T:5 +msgid "" +"T =\n" +" \\begin{bmatrix}\n" +" 1&0\\\\\n" +" 0&e^\\frac{i\\pi}{4}\n" +" \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.X:1 +msgid "A collection of single-qubit X gates." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.X:5 +msgid "" +"\\begin{bmatrix}\n" +" 0 & 1 \\\\\n" +" 1 & 0\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.Y:1 +msgid "A collection of single-qubit Y gates." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.Y:5 +msgid "" +"\\begin{bmatrix}\n" +" 0 & -i \\\\\n" +" i & 0\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.Z:1 +msgid "A collection of single-qubit Z gates." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.Z:5 +msgid "" +"\\begin{bmatrix}\n" +" 1 & 0 \\\\\n" +" 0 & -1\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.P:1 +msgid "A collection of single-qubit P gates." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.P:5 +msgid "" +"\\begin{bmatrix}\n" +" 1 & 0 \\\\\n" +" 0 & e^{i\\theta}\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.P:15 +#: paddle_quantum.gate.single_qubit_gate.RX:15 +#: paddle_quantum.gate.single_qubit_gate.RY:15 +#: paddle_quantum.gate.single_qubit_gate.RZ:15 +#: paddle_quantum.gate.single_qubit_gate.U3:18 +msgid "Parameters of the gates. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.P:16 +#: paddle_quantum.gate.single_qubit_gate.RX:16 +#: paddle_quantum.gate.single_qubit_gate.RY:16 +#: paddle_quantum.gate.single_qubit_gate.RZ:16 +#: paddle_quantum.gate.single_qubit_gate.U3:19 +msgid "Whether gates in the same layer share a parameter. Defaults to ``False``." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.P +#: paddle_quantum.gate.single_qubit_gate.RX +#: paddle_quantum.gate.single_qubit_gate.RY +#: paddle_quantum.gate.single_qubit_gate.RZ +#: paddle_quantum.gate.single_qubit_gate.U3 +msgid "Raises" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.P:18 +#: paddle_quantum.gate.single_qubit_gate.RX:18 +#: paddle_quantum.gate.single_qubit_gate.RY:18 +#: paddle_quantum.gate.single_qubit_gate.RZ:18 +#: paddle_quantum.gate.single_qubit_gate.U3:21 +msgid "The ``param`` must be ``paddle.Tensor`` or ``float``." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.RX:1 +msgid "A collection of single-qubit rotation gates about the x-axis." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.RX:5 +msgid "" +"\\begin{bmatrix}\n" +" \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\\n" +" -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2}\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.RY:1 +msgid "A collection of single-qubit rotation gates about the y-axis." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.RY:5 +msgid "" +"\\begin{bmatrix}\n" +" \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\\n" +" \\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2}\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.RZ:1 +msgid "A collection of single-qubit rotation gates about the z-axis." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.RZ:5 +msgid "" +"\\begin{bmatrix}\n" +" e^{-i\\frac{\\theta}{2}} & 0 \\\\\n" +" 0 & e^{i\\frac{\\theta}{2}}\n" +"\\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.U3:1 +msgid "A collection of single-qubit rotation gates." +msgstr "" + +#: of paddle_quantum.gate.single_qubit_gate.U3:5 +msgid "" +"\\begin{align}\n" +" U3(\\theta, \\phi, \\lambda) =\n" +" \\begin{bmatrix}\n" +" \\cos\\frac\\theta2&-e^{i\\lambda}\\sin\\frac\\theta2\\\\\n" +" " +"e^{i\\phi}\\sin\\frac\\theta2&e^{i(\\phi+\\lambda)}\\cos\\frac\\theta2\n" +" \\end{bmatrix}\n" +"\\end{align}" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gradtool.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gradtool.po new file mode 100644 index 0000000..e104688 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.gradtool.po @@ -0,0 +1,191 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.gradtool.rst:2 +msgid "paddle\\_quantum.gradtool" +msgstr "" + +#: of paddle_quantum.gradtool:1 +msgid "The module of the gradient tool." +msgstr "" + +#: of paddle_quantum.gradtool.show_gradient:1 +msgid "calculate gradient and loss function for every paramters in QNN" +msgstr "" + +#: of paddle_quantum.gradtool.plot_distribution +#: paddle_quantum.gradtool.plot_loss_grad +#: paddle_quantum.gradtool.plot_supervised_loss_grad +#: paddle_quantum.gradtool.random_sample +#: paddle_quantum.gradtool.random_sample_supervised +#: paddle_quantum.gradtool.show_gradient +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.gradtool.plot_loss_grad:3 +#: paddle_quantum.gradtool.plot_supervised_loss_grad:3 +#: paddle_quantum.gradtool.random_sample:3 +#: paddle_quantum.gradtool.random_sample_supervised:3 +#: paddle_quantum.gradtool.show_gradient:3 +msgid "QNN ready to be trained" +msgstr "" + +#: of paddle_quantum.gradtool.plot_loss_grad:4 +#: paddle_quantum.gradtool.plot_supervised_loss_grad:4 +#: paddle_quantum.gradtool.random_sample:4 +#: paddle_quantum.gradtool.random_sample_supervised:4 +#: paddle_quantum.gradtool.show_gradient:4 +msgid "loss function that evaluate QNN" +msgstr "" + +#: of paddle_quantum.gradtool.plot_loss_grad:5 +#: paddle_quantum.gradtool.show_gradient:5 +msgid "number of iterations" +msgstr "" + +#: of paddle_quantum.gradtool.plot_loss_grad:6 +#: paddle_quantum.gradtool.plot_supervised_loss_grad:7 +#: paddle_quantum.gradtool.show_gradient:6 +msgid "learning rate" +msgstr "" + +#: of paddle_quantum.gradtool.plot_loss_grad:7 +#: paddle_quantum.gradtool.plot_supervised_loss_grad:11 +#: paddle_quantum.gradtool.random_sample:9 +#: paddle_quantum.gradtool.random_sample_supervised:13 +#: paddle_quantum.gradtool.show_gradient:7 +msgid "parameters for loss_func other than circuit" +msgstr "" + +#: of paddle_quantum.gradtool.plot_supervised_loss_grad +#: paddle_quantum.gradtool.random_sample +#: paddle_quantum.gradtool.random_sample_supervised +#: paddle_quantum.gradtool.show_gradient +msgid "Returns" +msgstr "" + +#: of paddle_quantum.gradtool.show_gradient:9 +msgid "" +"contain following two elements - loss_list: list of losses for each " +"iteration - grad_list: list of gradients for each iteration" +msgstr "" + +#: of paddle_quantum.gradtool.plot_supervised_loss_grad +#: paddle_quantum.gradtool.random_sample +#: paddle_quantum.gradtool.random_sample_supervised +#: paddle_quantum.gradtool.show_gradient +msgid "Return type" +msgstr "" + +#: of paddle_quantum.gradtool.random_sample:1 +msgid "" +"random sampling the model. Obtain mean and variance of gradients " +"according to different calculation modes" +msgstr "" + +#: of paddle_quantum.gradtool.random_sample:5 +#: paddle_quantum.gradtool.random_sample_supervised:6 +msgid "number of sampling" +msgstr "" + +#: of paddle_quantum.gradtool.random_sample:6 +#: paddle_quantum.gradtool.random_sample_supervised:10 +msgid "mode for calculation, default to be single" +msgstr "" + +#: of paddle_quantum.gradtool.random_sample:7 +#: paddle_quantum.gradtool.random_sample_supervised:11 +msgid "whether plot the calculation" +msgstr "" + +#: of paddle_quantum.gradtool.random_sample:8 +#: paddle_quantum.gradtool.random_sample_supervised:12 +msgid "which parameter to be plotted in single mode, default to be the first" +msgstr "" + +#: of paddle_quantum.gradtool.random_sample:14 +#: paddle_quantum.gradtool.random_sample_supervised:17 +msgid "" +"this function provides three calculation modes: single, max and random - " +"in single mode, we calculate the mean and variance of gradients of every " +"trainable parameters - in max mode, we calculate the mean and variance of" +" maximum gradients of for every trainable parameters - in random mode, we" +" calculate the mean and variance of data randomly extracted from " +"gradients of every trainable parameters" +msgstr "" + +#: of paddle_quantum.gradtool.plot_supervised_loss_grad:13 +#: paddle_quantum.gradtool.random_sample:19 +#: paddle_quantum.gradtool.random_sample_supervised:22 +msgid "" +"contain the following two elements - loss_list: list of losses for each " +"iteration - grad_list: list of gradients for each iteration" +msgstr "" + +#: of paddle_quantum.gradtool.random_sample_supervised:1 +msgid "" +"random sampling the supervised model. Obtain mean and variance of " +"gradients according to different calculation modes" +msgstr "" + +#: of paddle_quantum.gradtool.plot_supervised_loss_grad:5 +#: paddle_quantum.gradtool.random_sample_supervised:5 +msgid "number of qubits" +msgstr "" + +#: of paddle_quantum.gradtool.plot_supervised_loss_grad:8 +#: paddle_quantum.gradtool.random_sample_supervised:7 +msgid "size of batches" +msgstr "" + +#: of paddle_quantum.gradtool.plot_supervised_loss_grad:9 +#: paddle_quantum.gradtool.random_sample_supervised:8 +msgid "data set" +msgstr "" + +#: of paddle_quantum.gradtool.plot_supervised_loss_grad:10 +#: paddle_quantum.gradtool.random_sample_supervised:9 +msgid "label set" +msgstr "" + +#: of paddle_quantum.gradtool.plot_loss_grad:1 +msgid "" +"plot the distribution maps between loss values & gradients and number of " +"iterations" +msgstr "" + +#: of paddle_quantum.gradtool.plot_supervised_loss_grad:1 +msgid "" +"plot the distribution maps between loss values & gradients and number of " +"iterations in supervised training" +msgstr "" + +#: of paddle_quantum.gradtool.plot_supervised_loss_grad:6 +msgid "number of training iterations" +msgstr "" + +#: of paddle_quantum.gradtool.plot_distribution:1 +msgid "plot the distribution map according to input gradient" +msgstr "" + +#: of paddle_quantum.gradtool.plot_distribution:3 +msgid "list of gradients of a parameter" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.hamiltonian.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.hamiltonian.po new file mode 100644 index 0000000..4134a1e --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.hamiltonian.po @@ -0,0 +1,206 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.hamiltonian.rst:2 +msgid "paddle\\_quantum.hamiltonian" +msgstr "" + +#: of paddle_quantum.hamiltonian:1 +msgid "The module of the hamiltonian class." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian:1 +#: paddle_quantum.hamiltonian.SpinOps:1 +msgid "Bases: :py:class:`object`" +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian:1 +msgid "Hamiltonian ``class`` in Paddle Quantum." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian:3 +msgid "User can instantiate the ``class`` with a Pauli string." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian +#: paddle_quantum.hamiltonian.Hamiltonian.construct_h_matrix +#: paddle_quantum.hamiltonian.SpinOps +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian:5 +msgid "A list of Hamiltonian information, e.g. ``[(1, 'Z0, Z1'), (2, 'I')]``" +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian:6 +msgid "" +"Determines whether the input list will be automatically merged (e.g.``(1," +" 'Z0, Z1')`` and ``(2, 'Z1, Z0')``, these two items will be automatically" +" merged)." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian +#: paddle_quantum.hamiltonian.Hamiltonian.construct_h_matrix +#: paddle_quantum.hamiltonian.Hamiltonian.decompose_pauli_words +#: paddle_quantum.hamiltonian.Hamiltonian.decompose_with_sites +msgid "Returns" +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian:9 +msgid "Create a Hamiltonian class" +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian:11 +msgid "If ``compress=False``, the legitimacy of the input will not be checked." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.n_terms:1 +msgid "Number of terms of the hamiltonian." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.pauli_str:1 +msgid "The Pauli string corresponding to the hamiltonian." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.terms:1 +msgid "All items in hamiltonian, i.e. ``[['Z0, Z1'], ['I']]``." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.coefficients:1 +msgid "The coefficient of each term in the Hamiltonian，i.e. ``[1.0, 2.0]``." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.pauli_words:1 +msgid "The Pauli word of each term，i.e. ``['ZIZ', 'IIX']``." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.pauli_words_r:1 +msgid "A list of Pauli word (exclude I)，i.e. ``['ZXZZ', 'Z', 'X']``." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.pauli_words_matrix:1 +msgid "The list of matrices with respect to simplied Pauli words." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.sites:1 +msgid "A list of qubits index corresponding to the hamiltonian." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.n_qubits:1 +msgid "Number of qubits." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.decompose_with_sites:1 +msgid "" +"Decompose pauli_str into coefficients, a simplified form of Pauli " +"strings, and the indices of qubits on which the Pauli operators act on." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.decompose_with_sites:3 +msgid "" +"- coefficients: the coefficient for each term. - pauli_words_r: the " +"simplified form of the Pauli string for each item, e.g. the Pauli word of" +" 'Z0, Z1, X3' is 'ZZX'. - sites: a list of qubits index, e.g. the site of" +" 'Z0, Z1, X3' is [0, 1, 3]." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.decompose_pauli_words:3 +#: paddle_quantum.hamiltonian.Hamiltonian.decompose_with_sites:3 +msgid "coefficients: the coefficient for each term." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.decompose_with_sites:4 +msgid "" +"pauli_words_r: the simplified form of the Pauli string for each item, " +"e.g. the Pauli word of 'Z0, Z1, X3' is 'ZZX'." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.decompose_with_sites:5 +msgid "sites: a list of qubits index, e.g. the site of 'Z0, Z1, X3' is [0, 1, 3]." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.construct_h_matrix +#: paddle_quantum.hamiltonian.Hamiltonian.decompose_pauli_words +#: paddle_quantum.hamiltonian.Hamiltonian.decompose_with_sites +msgid "Return type" +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.decompose_pauli_words:1 +msgid "Decompose pauli_str into coefficients and Pauli strings." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.decompose_pauli_words:3 +msgid "" +"- coefficients: the coefficient for each term. - the Pauli string for " +"each item, e.g. the Pauli word of 'Z0, Z1, X3' is 'ZZIX'." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.decompose_pauli_words:4 +msgid "" +"the Pauli string for each item, e.g. the Pauli word of 'Z0, Z1, X3' is " +"'ZZIX'." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.construct_h_matrix:1 +msgid "Construct a matrix form of the Hamiltonian in Z-basis." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.construct_h_matrix:3 +msgid "The number of qubits. Defaults to 1." +msgstr "" + +#: of paddle_quantum.hamiltonian.Hamiltonian.construct_h_matrix:5 +msgid "The matrix form of the Hamiltonian in Z-basis." +msgstr "" + +#: of paddle_quantum.hamiltonian.SpinOps:1 +msgid "" +"The spin operators in matrix forms, could be used to construct " +"Hamiltonian matrix or spin observables." +msgstr "" + +#: of paddle_quantum.hamiltonian.SpinOps:3 +msgid "Size of the system (number of qubits)." +msgstr "" + +#: of paddle_quantum.hamiltonian.SpinOps:4 +msgid "" +"Decide whether to use the sparse matrix to calculate. Default is " +"``False``." +msgstr "" + +#: of paddle_quantum.hamiltonian.SpinOps.sigz_p:1 +msgid "" +"A list of :math:`S^z_i` operators, different elements correspond to " +"different indices :math:`i`." +msgstr "" + +#: of paddle_quantum.hamiltonian.SpinOps.sigy_p:1 +msgid "" +"A list of :math:`S^y_i` operators, different elements correspond to " +"different indices :math:`i`." +msgstr "" + +#: of paddle_quantum.hamiltonian.SpinOps.sigx_p:1 +msgid "" +"A list of :math:`S^x_i` operators, different elements correspond to " +"different indices :math:`i`." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.linalg.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.linalg.po new file mode 100644 index 0000000..f7627bf --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.linalg.po @@ -0,0 +1,254 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.linalg.rst:2 +msgid "paddle\\_quantum.linalg" +msgstr "" + +#: of paddle_quantum.linalg:1 +msgid "The common linear algorithm in paddle quantum." +msgstr "" + +#: of paddle_quantum.linalg.abs_norm:1 +msgid "tool for calculation of matrix norm" +msgstr "" + +#: of paddle_quantum.linalg.NKron paddle_quantum.linalg.abs_norm +#: paddle_quantum.linalg.dagger paddle_quantum.linalg.haar_density_operator +#: paddle_quantum.linalg.haar_orthogonal +#: paddle_quantum.linalg.haar_state_vector paddle_quantum.linalg.haar_unitary +#: paddle_quantum.linalg.hermitian_random paddle_quantum.linalg.is_hermitian +#: paddle_quantum.linalg.is_projector paddle_quantum.linalg.is_unitary +#: paddle_quantum.linalg.orthogonal_projection_random +#: paddle_quantum.linalg.unitary_hermitian_random +#: paddle_quantum.linalg.unitary_random +#: paddle_quantum.linalg.unitary_random_with_hermitian_block +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.linalg.abs_norm:3 paddle_quantum.linalg.dagger:3 +msgid "Tensor" +msgstr "" + +#: of paddle_quantum.linalg.NKron paddle_quantum.linalg.abs_norm +#: paddle_quantum.linalg.dagger paddle_quantum.linalg.haar_density_operator +#: paddle_quantum.linalg.haar_orthogonal +#: paddle_quantum.linalg.haar_state_vector paddle_quantum.linalg.haar_unitary +#: paddle_quantum.linalg.hermitian_random paddle_quantum.linalg.is_hermitian +#: paddle_quantum.linalg.is_projector paddle_quantum.linalg.is_unitary +#: paddle_quantum.linalg.orthogonal_projection_random +#: paddle_quantum.linalg.unitary_hermitian_random +#: paddle_quantum.linalg.unitary_random +#: paddle_quantum.linalg.unitary_random_with_hermitian_block +msgid "Returns" +msgstr "" + +#: of paddle_quantum.linalg.abs_norm:5 +msgid "norm of mat" +msgstr "" + +#: of paddle_quantum.linalg.NKron paddle_quantum.linalg.abs_norm +#: paddle_quantum.linalg.dagger paddle_quantum.linalg.haar_density_operator +#: paddle_quantum.linalg.haar_orthogonal +#: paddle_quantum.linalg.haar_state_vector paddle_quantum.linalg.haar_unitary +#: paddle_quantum.linalg.hermitian_random paddle_quantum.linalg.is_hermitian +#: paddle_quantum.linalg.is_projector paddle_quantum.linalg.is_unitary +#: paddle_quantum.linalg.orthogonal_projection_random +#: paddle_quantum.linalg.unitary_hermitian_random +#: paddle_quantum.linalg.unitary_random +#: paddle_quantum.linalg.unitary_random_with_hermitian_block +msgid "Return type" +msgstr "" + +#: of paddle_quantum.linalg.dagger:1 +msgid "tool for calculation of matrix dagger" +msgstr "" + +#: of paddle_quantum.linalg.dagger:5 +msgid "The dagger of matrix" +msgstr "" + +#: of paddle_quantum.linalg.is_hermitian:1 +msgid "verify whether P is Hermitian" +msgstr "" + +#: of paddle_quantum.linalg.is_hermitian:3 +msgid "hermitian candidate" +msgstr "" + +#: of paddle_quantum.linalg.is_hermitian:4 paddle_quantum.linalg.is_projector:4 +#: paddle_quantum.linalg.is_unitary:4 +msgid "tolerance of error" +msgstr "" + +#: of paddle_quantum.linalg.is_hermitian:6 +msgid "determine whether :math:`mat - mat^\\dagger = 0`" +msgstr "" + +#: of paddle_quantum.linalg.is_projector:1 +msgid "verify whether P is a projector" +msgstr "" + +#: of paddle_quantum.linalg.is_projector:3 +msgid "projector candidate" +msgstr "" + +#: of paddle_quantum.linalg.is_projector:6 +msgid "determine whether :math:`PP - P = 0`" +msgstr "" + +#: of paddle_quantum.linalg.is_unitary:1 +msgid "verify whether P is a unitary" +msgstr "" + +#: of paddle_quantum.linalg.is_unitary:3 +msgid "unitary candidate" +msgstr "" + +#: of paddle_quantum.linalg.is_unitary:6 +msgid "determine whether :math:`PP^\\dagger - I = 0`" +msgstr "" + +#: of paddle_quantum.linalg.hermitian_random:1 +msgid "randomly generate a :math:`2^n \\times 2^n` hermitian matrix" +msgstr "" + +#: of paddle_quantum.linalg.hermitian_random:3 +#: paddle_quantum.linalg.orthogonal_projection_random:3 +msgid "log2(dimension)" +msgstr "" + +#: of paddle_quantum.linalg.hermitian_random:5 +msgid "a :math:`2^n \\times 2^n` hermitian matrix" +msgstr "" + +#: of paddle_quantum.linalg.orthogonal_projection_random:1 +msgid "randomly generate a :math:`2^n \\times 2^n` rank-1 orthogonal projector" +msgstr "" + +#: of paddle_quantum.linalg.orthogonal_projection_random:5 +msgid "a :math:`2^n \\times 2^n` orthogonal projector and its eigenstate" +msgstr "" + +#: of paddle_quantum.linalg.unitary_hermitian_random:1 +msgid "randomly generate a :math:`2^n \\times 2^n` hermitian unitary" +msgstr "" + +#: of paddle_quantum.linalg.unitary_hermitian_random:3 +#: paddle_quantum.linalg.unitary_random:3 +#: paddle_quantum.linalg.unitary_random_with_hermitian_block:3 +msgid ":math:`\\log_{2}(dimension)`" +msgstr "" + +#: of paddle_quantum.linalg.unitary_hermitian_random:5 +msgid "a :math:`2^n \\times 2^n` hermitian unitary matrix" +msgstr "" + +#: of paddle_quantum.linalg.unitary_random_with_hermitian_block:1 +msgid "" +"randomly generate a unitary :math:`2^n \\times 2^n` matrix that is a " +"block encoding of a :math:`2^{n/2} \\times 2^{n/2}` Hermitian matrix" +msgstr "" + +#: of paddle_quantum.linalg.unitary_random_with_hermitian_block:5 +msgid "" +"a :math:`2^n \\times 2^n` unitary matrix that its upper-left block is a " +"Hermitian matrix" +msgstr "" + +#: of paddle_quantum.linalg.unitary_random:1 +msgid "randomly generate a :math:`2^n \\times 2^n` unitary" +msgstr "" + +#: of paddle_quantum.linalg.unitary_random:5 +msgid "a :math:`2^n \\times 2^n` unitary matrix" +msgstr "" + +#: of paddle_quantum.linalg.haar_orthogonal:1 +msgid "" +"randomly generate an orthogonal matrix following Haar random, referenced " +"by arXiv:math-ph/0609050v2" +msgstr "" + +#: of paddle_quantum.linalg.haar_density_operator:3 +#: paddle_quantum.linalg.haar_orthogonal:3 +#: paddle_quantum.linalg.haar_state_vector:3 +#: paddle_quantum.linalg.haar_unitary:3 +msgid "number of qubits" +msgstr "" + +#: of paddle_quantum.linalg.haar_orthogonal:5 +msgid "a :math:`2^n \\times 2^n` orthogonal matrix" +msgstr "" + +#: of paddle_quantum.linalg.haar_unitary:1 +msgid "" +"randomly generate a unitary following Haar random, referenced by arXiv" +":math-ph/0609050v2" +msgstr "" + +#: of paddle_quantum.linalg.haar_unitary:5 +msgid "a :math:`2^n \\times 2^n` unitary" +msgstr "" + +#: of paddle_quantum.linalg.haar_state_vector:1 +msgid "randomly generate a state vector following Haar random" +msgstr "" + +#: of paddle_quantum.linalg.haar_state_vector:4 +msgid "whether the vector is real, default to be False" +msgstr "" + +#: of paddle_quantum.linalg.haar_state_vector:6 +msgid "a :math:`2^n \\times 1` state vector" +msgstr "" + +#: of paddle_quantum.linalg.haar_density_operator:1 +msgid "randomly generate a density matrix following Haar random" +msgstr "" + +#: of paddle_quantum.linalg.haar_density_operator:4 +msgid "rank of density matrix, default to be False refering to full ranks" +msgstr "" + +#: of paddle_quantum.linalg.haar_density_operator:5 +msgid "whether the density matrix is real, default to be False" +msgstr "" + +#: of paddle_quantum.linalg.haar_density_operator:7 +msgid "a :math:`2^n \\times 2^n` density matrix" +msgstr "" + +#: of paddle_quantum.linalg.NKron:1 +msgid "calculate Kronecker product of at least two matrices" +msgstr "" + +#: of paddle_quantum.linalg.NKron:3 paddle_quantum.linalg.NKron:4 +msgid "matrix" +msgstr "" + +#: of paddle_quantum.linalg.NKron:5 +msgid "other matrices" +msgstr "" + +#: of paddle_quantum.linalg.NKron:7 +msgid "Kronecker product of matrices" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.locc_ansatz.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.locc_ansatz.po new file mode 100644 index 0000000..f0024bd --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.locc_ansatz.po @@ -0,0 +1,424 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.locc.locc_ansatz.rst:2 +msgid "paddle\\_quantum.locc.locc\\_ansatz" +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz:1 +msgid "The source file of the LoccAnsatz class." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz:1 +msgid "Bases: :py:class:`~paddle_quantum.ansatz.circuit.Circuit`" +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz:1 +msgid "" +"Inherit the ``Circuit`` class. The purpose is to build a circuit template" +" for an LOCC task." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz:3 +msgid "" +"In an LOCC task, each party can only perform quantum operations on their " +"own qubits. So we only allow local quantum gates to be added to each " +"party's qubits." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.append +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cnot +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.control_oracle +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cp +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.crx +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cry +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.crz +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cswap +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cu +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cx +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cy +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cz +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.extend +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.forward +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.h +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.insert +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ms +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.oracle +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.p +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.pop +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rx +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rxx +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ry +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ryy +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rz +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rzz +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.s +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.swap +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.t +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.toffoli +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.u3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_three_qubits +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_two_qubits +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.x +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.y +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.z +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz:5 +msgid "The owner of this circuit." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.append:1 +msgid "Append an operator." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.append:3 +msgid "operator with a name or just an operator." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.extend:1 +msgid "Append a list of operators." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.extend:3 +msgid "List of operators." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.insert:1 +msgid "Insert an operator at index ``index``." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.insert:3 +msgid "Index to be inserted." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.insert:4 +msgid "An operator." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.pop:1 +msgid "Remove the matched operator." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.pop:3 +msgid "Matched with which the operator will be popped." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.forward:1 +msgid "Forward the input." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.forward:3 +msgid "Initial state." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.forward +msgid "Returns" +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.forward:5 +msgid "Output state." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.forward +msgid "Return type" +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.h:1 +msgid "Add single-qubit Hadamard gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.h:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.p:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rx:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ry:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rz:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.s:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.t:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.u3:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.x:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.y:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.z:3 +msgid "" +"Indices of the qubits on which the gates are applied. Defaults to " +"``'full'``." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cnot:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.control_oracle:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cp:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.crx:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cry:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.crz:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cswap:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cu:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cx:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cy:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cz:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.h:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ms:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.oracle:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.p:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rx:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rxx:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ry:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ryy:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rz:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rzz:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.s:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.swap:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.t:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.toffoli:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.u3:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_three_qubits:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_two_qubits:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.x:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.y:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.z:4 +msgid "Total number of qubits. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cnot:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.control_oracle:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cp:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.crx:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cry:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.crz:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cswap:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cu:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cx:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cy:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cz:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.h:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ms:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.oracle:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.p:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rx:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rxx:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ry:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ryy:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rz:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rzz:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.s:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.swap:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.t:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.toffoli:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.u3:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_three_qubits:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_two_qubits:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.x:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.y:5 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.z:5 +msgid "Number of layers. Defaults to ``1``." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.s:1 +msgid "Add single-qubit S gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.t:1 +msgid "Add single-qubit T gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.x:1 +msgid "Add single-qubit X gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.y:1 +msgid "Add single-qubit Y gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.z:1 +msgid "Add single-qubit Z gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.p:1 +msgid "Add single-qubit P gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cp:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.crx:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cry:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.crz:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cu:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.p:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rx:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rxx:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ry:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ryy:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rz:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rzz:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.u3:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_three_qubits:6 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_two_qubits:6 +msgid "Parameters of the gates. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cp:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.crx:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cry:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.crz:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cu:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.p:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rx:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rxx:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ry:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ryy:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rz:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rzz:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.u3:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_three_qubits:7 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_two_qubits:7 +msgid "Whether gates in the same layer share a parameter. Defaults to ``False``." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.rx:1 +msgid "Add single-qubit rotation gates about the x-axis." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.ry:1 +msgid "Add single-qubit rotation gates about the y-axis." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.rz:1 +msgid "Add single-qubit rotation gates about the z-axis." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.u3:1 +msgid "Add single-qubit rotation gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cnot:1 +msgid "Add CNOT gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cnot:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cp:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.crx:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cry:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.crz:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cswap:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cu:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cx:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cy:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.cz:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ms:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rxx:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.ryy:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.rzz:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.swap:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.toffoli:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_three_qubits:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_two_qubits:3 +msgid "" +"Indices of the qubits on which the gates are applied. Defaults to " +"``'cycle'``." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cx:1 +msgid "Same as cnot." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cy:1 +msgid "Add controlled Y gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cz:1 +msgid "Add controlled Z gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.swap:1 +msgid "Add SWAP gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cp:1 +msgid "Add controlled P gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.crx:1 +msgid "Add controlled rotation gates about the x-axis." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cry:1 +msgid "Add controlled rotation gates about the y-axis." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.crz:1 +msgid "Add controlled rotation gates about the z-axis." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cu:1 +msgid "Add controlled single-qubit rotation gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.rxx:1 +msgid "Add RXX gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.ryy:1 +msgid "Add RYY gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.rzz:1 +msgid "Add RZZ gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.ms:1 +msgid "Add Mølmer-Sørensen (MS) gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.cswap:1 +msgid "Add CSWAP (Fredkin) gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.toffoli:1 +msgid "Add Toffoli gates." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_two_qubits:1 +msgid "Add universal two-qubit gates. One of such a gate requires 15 parameters." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.universal_three_qubits:1 +msgid "" +"Add universal three-qubit gates. One of such a gate requires 81 " +"parameters." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.oracle:1 +msgid "Add an oracle gate." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.control_oracle:3 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.oracle:3 +msgid "Unitary oracle to be implemented." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.control_oracle:4 +#: paddle_quantum.locc.locc_ansatz.LoccAnsatz.oracle:4 +msgid "Indices of the qubits on which the gates are applied." +msgstr "" + +#: of paddle_quantum.locc.locc_ansatz.LoccAnsatz.control_oracle:1 +msgid "Add a controlled oracle gate." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.locc_net.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.locc_net.po new file mode 100644 index 0000000..4edb738 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.locc_net.po @@ -0,0 +1,225 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.locc.locc_net.rst:2 +msgid "paddle\\_quantum.locc.locc\\_net" +msgstr "" + +#: of paddle_quantum.locc.locc_net:1 +msgid "The source file of the LoccNet class." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet:1 +msgid "Bases: :py:class:`~paddle.fluid.dygraph.layers.Layer`" +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet:1 +msgid "Used to design LOCC protocols and perform training or verification." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.set_init_state:1 +msgid "Initialize the LoccState of LoccNet." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.add_new_party +#: paddle_quantum.locc.locc_net.LoccNet.create_ansatz +#: paddle_quantum.locc.locc_net.LoccNet.measure +#: paddle_quantum.locc.locc_net.LoccNet.partial_state +#: paddle_quantum.locc.locc_net.LoccNet.reset_state +#: paddle_quantum.locc.locc_net.LoccNet.set_init_state +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.reset_state:4 +#: paddle_quantum.locc.locc_net.LoccNet.set_init_state:3 +msgid "Matrix form of the input quantum state." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.set_init_state:4 +msgid "" +"Indices of the qubits corresponding to the input quantum state. It should" +" be a ``tuple`` of ``(party_id, qubit_id)``, or a ``list`` of it." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.add_new_party +#: paddle_quantum.locc.locc_net.LoccNet.create_ansatz +#: paddle_quantum.locc.locc_net.LoccNet.measure +#: paddle_quantum.locc.locc_net.LoccNet.partial_state +#: paddle_quantum.locc.locc_net.LoccNet.reset_state +#: paddle_quantum.locc.locc_net.LoccNet.set_init_state +msgid "Raises" +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.create_ansatz:5 +#: paddle_quantum.locc.locc_net.LoccNet.measure:9 +#: paddle_quantum.locc.locc_net.LoccNet.partial_state:9 +#: paddle_quantum.locc.locc_net.LoccNet.reset_state:8 +#: paddle_quantum.locc.locc_net.LoccNet.set_init_state:7 +msgid "Party's ID should be ``str`` or ``int``." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.partial_state:1 +msgid "Get the quantum state of the qubits of interest." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.partial_state:3 +msgid "Input LOCC state." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.partial_state:4 +msgid "" +"Indices of the qubits of interest. It should be a ``tuple`` of " +"``(party_id, qubit_id)``, or a ``list`` of it." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.partial_state:6 +msgid "" +"If ``True``, return the partial quantum state of the given qubits; if " +"``False``, return the partial quantum state of the remaining qubits. " +"Defaults to ``True``." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.partial_state:10 +#: paddle_quantum.locc.locc_net.LoccNet.reset_state:9 +msgid "The ``state`` should be ``LoccState`` or a ``list`` of it." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.add_new_party +#: paddle_quantum.locc.locc_net.LoccNet.create_ansatz +#: paddle_quantum.locc.locc_net.LoccNet.get_num_qubits +#: paddle_quantum.locc.locc_net.LoccNet.measure +#: paddle_quantum.locc.locc_net.LoccNet.partial_state +#: paddle_quantum.locc.locc_net.LoccNet.reset_state +msgid "Returns" +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.partial_state:12 +msgid "LOCC state after obtaining partial quantum state." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.add_new_party +#: paddle_quantum.locc.locc_net.LoccNet.create_ansatz +#: paddle_quantum.locc.locc_net.LoccNet.get_num_qubits +#: paddle_quantum.locc.locc_net.LoccNet.measure +#: paddle_quantum.locc.locc_net.LoccNet.partial_state +#: paddle_quantum.locc.locc_net.LoccNet.reset_state +msgid "Return type" +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.reset_state:1 +msgid "Reset the quantum state of the qubits of interest." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.reset_state:3 +msgid "LOCC state before resetting." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.reset_state:5 +msgid "" +"Indices of the qubits to be reset. It should be a ``tuple`` of " +"``(party_id, qubit_id)``, or a ``list`` of it." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.reset_state:11 +msgid "LOCC state after resetting the state of part of the qubits." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.add_new_party:1 +msgid "Add a new LOCC party." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.add_new_party:3 +msgid "Number of qubits of the party." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.add_new_party:4 +msgid "Name of the party. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.add_new_party:8 +msgid "" +"You can use a string or a number as a party's ID. If a string is " +"preferred, you can set ``party_name``; if a number is preferred, then you" +" don't need to set ``party_name`` and the party's index number will be " +"automatically assigned." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.add_new_party:12 +msgid "The ``party_name`` should be ``str``." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.add_new_party:14 +msgid "ID of the party." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.create_ansatz:1 +msgid "Create a new local ansatz." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.create_ansatz:3 +msgid "Party's ID." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.create_ansatz:7 +msgid "Created local ansatz." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.measure:1 +msgid "Perform 0-1 measurement or parameterized measurement on an LOCC state." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.measure:3 +msgid "LOCC state to be measured." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.measure:4 +msgid "Indices of the qubits to be measured." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.measure:5 +msgid "Expected measurement outcomes." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.measure:6 +msgid "" +"Parameters of measurement. Defaults to ``None``, which means 0-1 " +"measurement." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.measure:8 +msgid "The ``results_desired`` should be ``str`` or a ``list`` of it." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.measure:10 +msgid "The ``status`` should be ``LoccState`` or a ``list`` of it." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.measure:12 +msgid "LOCC state after measurement." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.get_num_qubits:1 +msgid "Get the number of the qubits in this LOCCNet." +msgstr "" + +#: of paddle_quantum.locc.locc_net.LoccNet.get_num_qubits:3 +msgid "Number of qubits in LOCCNet." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.locc_party.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.locc_party.po new file mode 100644 index 0000000..7a04e0f --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.locc_party.po @@ -0,0 +1,44 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.locc.locc_party.rst:2 +msgid "paddle\\_quantum.locc.locc\\_party" +msgstr "" + +#: of paddle_quantum.locc.locc_party:1 +msgid "The source file of the LoccParty class." +msgstr "" + +#: of paddle_quantum.locc.locc_party.LoccParty:1 +msgid "Bases: :py:class:`object`" +msgstr "" + +#: of paddle_quantum.locc.locc_party.LoccParty:1 +msgid "An LOCC party." +msgstr "" + +#: of paddle_quantum.locc.locc_party.LoccParty +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.locc.locc_party.LoccParty:3 +msgid "Number of qubits of this party." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.locc_state.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.locc_state.po new file mode 100644 index 0000000..3345449 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.locc_state.po @@ -0,0 +1,91 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.locc.locc_state.rst:2 +msgid "paddle\\_quantum.locc.locc\\_state" +msgstr "" + +#: of paddle_quantum.locc.locc_state:1 +msgid "The source file of the LoccState class." +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState:1 +msgid "Bases: :py:class:`~paddle_quantum.state.state.State`" +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState:1 +msgid "An LOCC state in LOCCNet." +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState:3 +msgid "" +"We care not only about the quantum state in LOCC, but also about the " +"probability of getting it and the corresponding measurement result. " +"Therefore, this class contains three attributes: quantum state ``data``, " +"the probability of getting this state ``prob``, and the measurement " +"result leading to this state, namely ``measured_result``." +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState:8 +msgid "" +"Matrix form of the quantum state of this ``LoccState``. Defaults to " +"``None``." +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState:9 +msgid "Probability of getting this quantum state.. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState:10 +msgid "Measurement result leading to this quantum state. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState:11 +msgid "Total number of qubits. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState:12 +msgid "Backend of Paddle Quantum. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState:13 +msgid "Type of data. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState.clone:1 +msgid "Create a copy of the current object." +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState.clone +msgid "Returns" +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState.clone:3 +msgid "A copy of the current object." +msgstr "" + +#: of paddle_quantum.locc.locc_state.LoccState.clone +msgid "Return type" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.po new file mode 100644 index 0000000..697bfd9 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.locc.po @@ -0,0 +1,32 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.locc.rst:2 +msgid "paddle\\_quantum.locc" +msgstr "" + +#: of paddle_quantum.locc:1 +msgid "The module of the LOCCNet." +msgstr "" + +#: ../../source/paddle_quantum.locc.rst:10 +msgid "Submodules" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.loss.distance.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.loss.distance.po new file mode 100644 index 0000000..3d36edb --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.loss.distance.po @@ -0,0 +1,119 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.loss.distance.rst:2 +msgid "paddle\\_quantum.loss.distance" +msgstr "" + +#: of paddle_quantum.loss.distance:1 +msgid "The source file of the class for the distance." +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity:1 +#: paddle_quantum.loss.distance.TraceDistance:1 +msgid "Bases: :py:class:`~paddle_quantum.base.Operator`" +msgstr "" + +#: of paddle_quantum.loss.distance.TraceDistance:1 +msgid "The class of the loss function to compute the trace distance." +msgstr "" + +#: of paddle_quantum.loss.distance.TraceDistance:3 +msgid "This interface can make you using the trace distance as the loss function." +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity +#: paddle_quantum.loss.distance.StateFidelity.forward +#: paddle_quantum.loss.distance.TraceDistance +#: paddle_quantum.loss.distance.TraceDistance.forward +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.loss.distance.TraceDistance:5 +msgid "The target state to be used to compute the trace distance." +msgstr "" + +#: of paddle_quantum.loss.distance.TraceDistance.forward:1 +msgid "Compute the trace distance between the input state and the target state." +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity.forward:3 +#: paddle_quantum.loss.distance.TraceDistance.forward:3 +msgid "" +"The value computed by this function can be used as a loss function to " +"optimize." +msgstr "" + +#: of paddle_quantum.loss.distance.TraceDistance.forward:5 +msgid "" +"The input state which will be used to compute the trace distance with the" +" target state." +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity.forward +#: paddle_quantum.loss.distance.TraceDistance.forward +msgid "Raises" +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity.forward:7 +#: paddle_quantum.loss.distance.TraceDistance.forward:7 +msgid "The backend is wrong or not supported." +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity.forward +#: paddle_quantum.loss.distance.TraceDistance.forward +msgid "Returns" +msgstr "" + +#: of paddle_quantum.loss.distance.TraceDistance.forward:9 +msgid "The trace distance between the input state and the target state." +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity.forward +#: paddle_quantum.loss.distance.TraceDistance.forward +msgid "Return type" +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity:1 +msgid "The class of the loss function to compute the state fidelity." +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity:3 +msgid "This interface can make you using the state fidelity as the loss function." +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity:5 +msgid "The target state to be used to compute the state fidelity." +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity.forward:1 +msgid "Compute the state fidelity between the input state and the target state." +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity.forward:5 +msgid "" +"The input state which will be used to compute the state fidelity with the" +" target state." +msgstr "" + +#: of paddle_quantum.loss.distance.StateFidelity.forward:9 +msgid "The state fidelity between the input state and the target state." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.loss.measure.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.loss.measure.po new file mode 100644 index 0000000..97656d1 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.loss.measure.po @@ -0,0 +1,139 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.loss.measure.rst:2 +msgid "paddle\\_quantum.loss.measure" +msgstr "" + +#: of paddle_quantum.loss.measure:1 +msgid "The source file of the class for the measurement." +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal:1 +#: paddle_quantum.loss.measure.Measure:1 +msgid "Bases: :py:class:`~paddle_quantum.base.Operator`" +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal:1 +msgid "" +"The class of the loss function to compute the expectation value for the " +"observable." +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal:3 +msgid "" +"This interface can make you using the expectation value for the " +"observable as the loss function." +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal +#: paddle_quantum.loss.measure.ExpecVal.forward +#: paddle_quantum.loss.measure.Measure +#: paddle_quantum.loss.measure.Measure.forward +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal:5 +msgid "The information about the observable." +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal:6 +msgid "" +"The number of measurement shots. Now it just need to be input when the " +"backend is QuLeaf." +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal.forward:1 +msgid "" +"Compute the expectation value of the observable with respect to the input" +" state." +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal.forward:3 +msgid "" +"The value computed by this function can be used as a loss function to " +"optimize." +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal.forward:5 +msgid "The input state which will be used to compute the expectation value." +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal.forward +#: paddle_quantum.loss.measure.Measure +msgid "Raises" +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal.forward:7 +msgid "The backend is wrong or not supported." +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal.forward +#: paddle_quantum.loss.measure.Measure.forward +msgid "Returns" +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal.forward:9 +msgid "" +"The expectation value. If the backend is QuLeaf, it is computed by " +"sampling." +msgstr "" + +#: of paddle_quantum.loss.measure.ExpecVal.forward +#: paddle_quantum.loss.measure.Measure.forward +msgid "Return type" +msgstr "" + +#: of paddle_quantum.loss.measure.Measure:1 +msgid "Compute the probability of the specified measurement result." +msgstr "" + +#: of paddle_quantum.loss.measure.Measure:3 +msgid "Specify the basis of the measurement. Defaults to 'z'." +msgstr "" + +#: of paddle_quantum.loss.measure.Measure:5 +msgid "Currently we just support the z basis." +msgstr "" + +#: of paddle_quantum.loss.measure.Measure.forward:1 +msgid "Compute the probability of measurement to the input state." +msgstr "" + +#: of paddle_quantum.loss.measure.Measure.forward:3 +msgid "The quantum state to be measured." +msgstr "" + +#: of paddle_quantum.loss.measure.Measure.forward:4 +msgid "" +"The index of the qubits to be measured. Defaults to 'full' which means " +"measure all the qubits." +msgstr "" + +#: of paddle_quantum.loss.measure.Measure.forward:5 +msgid "" +"Specify the results of the measurement to return. Defaults to None which " +"means return the probability of all the results." +msgstr "" + +#: of paddle_quantum.loss.measure.Measure.forward:7 +msgid "The probability of the measurement." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.loss.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.loss.po new file mode 100644 index 0000000..5666393 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.loss.po @@ -0,0 +1,32 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.loss.rst:2 +msgid "paddle\\_quantum.loss" +msgstr "" + +#: of paddle_quantum.loss:1 +msgid "The module of the pre-provided loss." +msgstr "" + +#: ../../source/paddle_quantum.loss.rst:10 +msgid "Submodules" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.mcalculus.MCalculus.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.mcalculus.MCalculus.po new file mode 100644 index 0000000..ea110c1 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.mcalculus.MCalculus.po @@ -0,0 +1,186 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2021, Institute for Quantum Computing, Baidu Inc. +# This file is distributed under the same license as the Paddle Quantum +# package. +# FIRST AUTHOR , 2021. +# +msgid "" +msgstr "" +"Project-Id-Version: Paddle Quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2021-08-18 19:49+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.9.1\n" + +#: ../../source/_autosummary/paddle_quantum.mbqc.mcalculus.MCalculus.rst:2 +msgid "paddle\\_quantum.mbqc.mcalculus.MCalculus" +msgstr "paddle\\_quantum.mbqc.mcalculus.MCalculus" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus:1 +msgid "定义测量模式类。" +msgstr "Define ``MCalculus`` class." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus:3 +msgid "跟据文献 [The measurement calculus, arXiv: 0704.1263] 的测量语言，该类提供处理测量模式的各种基本操作。" +msgstr "" +"According to the measurement language in [The measurement calculus, " +"arXiv: 0704.1263], this class provides various basic operations for " +"measurement patterns." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.__init__:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "``MCalculus`` 的构造函数，用于实例化一个 ``MCalculus`` 对象。" +msgstr "``MCalculus`` constructor, used to instantiate a ``MCalculus`` object." + +#: ../../source/_autosummary/paddle_quantum.mbqc.mcalculus.MCalculus.rst:14 +msgid "Methods" +msgstr "Methods" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`__init__ `\\ " +"\\(\\)" +msgstr "" +":obj:`__init__ `\\ " +"\\(\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`get_pattern " +"`\\ \\(\\)" +msgstr "" +":obj:`get_pattern " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.get_pattern:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "返回测量模式。" +msgstr "Return pattern." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`optimize_by_row " +"`\\ \\(\\)" +msgstr "" +":obj:`optimize_by_row " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.optimize_by_row:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "按照行序优先的原则对测量模式中的测量顺序进行优化。" +msgstr "optimize measurements of the pattern by a row-major order algorithm." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`set_circuit " +"`\\ \\(circuit\\)" +msgstr "" +":obj:`set_circuit " +"`\\ \\(circuit\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.set_circuit:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "对 ``MCalculus`` 类设置量子电路。" +msgstr "Set quantum circuit to ``MCalculus`` class." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`shift_signals " +"`\\ \\(\\)" +msgstr "" +":obj:`shift_signals " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.shift_signals:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "信号转移操作。" +msgstr "Signal shifting operation." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`standardize " +"`\\ \\(\\)" +msgstr "" +":obj:`standardize " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.standardize:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "对测量模式进行标准化。" +msgstr "Standardize pattern." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`track_progress " +"`\\ " +"\\(\\[track\\]\\)" +msgstr "" +":obj:`track_progress " +"`\\ " +"\\(\\[track\\]\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "显示测量模式处理过程的进度条开关。" +msgstr "Switch to show the pattern processing progress bar." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.set_circuit +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress +msgid "Parameters" +msgstr "Parameters" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:3 +msgid "``True`` 为打开进度条显示，``False`` 为关闭进度条显示，默认为 ``True``" +msgstr "" +"``True`` for turning on the progress bar, ``False`` for turning off the " +"progress bar, the default value is ``True``." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.set_circuit:3 +msgid "量子电路" +msgstr "Quantum circuit." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.standardize:3 +msgid "" +"该方法对测量模式进行标准化操作，转化成等价的 EMC 模型。即将所有的 ``CommandE`` 交换到最前面，其次是 ``CommandM``，" +" ``CommandX`` 和 ``CommandZ``。为了简化测量模式，该方法在标准化各类命令之后还对 ``CommandM`` 进行 " +"Pauli 简化。" +msgstr "" +"This method is called to standardize a pattern to the EMC model, that is," +" to permute all ``CommandE`` to the front, and then ``CommandM``, and " +"then ``CommandX``, and finally the ``CommandZ``. To simplify the pattern, " +"this method automatically performs Pauli simplifications to ``CommandM``" +" after the standardization of all commands." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.shift_signals:3 +msgid "这是用户选择性调用的方法之一。" +msgstr "This is one method that the user optionally calls." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.get_pattern +msgid "Returns" +msgstr "Returns" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.get_pattern:3 +msgid "处理后的测量模式" +msgstr "The pattern after processing." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.get_pattern +msgid "Return type" +msgstr "Return type" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.optimize_by_row:5 +msgid "" +"这是一种启发式的优化算法，对于特定的测量模式可以起到优化测量顺序的作用，不排除存在更优的测量顺序。例如，对于浅层量子电路， " +"按照行序优先原则，测量完同一量子位上的量子门、测量对应的节点后，该量子位不再起作用，进而减少后续计算时可能涉及到的节点数目。" +msgstr "" +"This is a heuristic optimization algorithm, with good performance in " +"specific patterns. However, we do not exclude the existence of a better " +"measurement order. For quantum shallow circuits, once all qubits on the " +"same row are measured, they no longer play a role in the following " +"calculations. In this way, the number of qubits involved in subsequent " +"calculations can be reduced." + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.mcalculus.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.mcalculus.po new file mode 100644 index 0000000..13e53d9 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.mcalculus.po @@ -0,0 +1,202 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2021, Institute for Quantum Computing, Baidu Inc. +# This file is distributed under the same license as the Paddle Quantum +# package. +# FIRST AUTHOR , 2021. +# +msgid "" +msgstr "" +"Project-Id-Version: Paddle Quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2021-08-18 19:46+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.9.1\n" + +#: ../../source/_autosummary/paddle_quantum.mbqc.mcalculus.rst:2 +msgid "paddle\\_quantum.mbqc.mcalculus" +msgstr "paddle\\_quantum.mbqc.mcalculus" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus:1 +msgid "定义测量模式类。" +msgstr "Define ``MCalculus`` class." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus:3 +msgid "跟据文献 [The measurement calculus, arXiv: 0704.1263] 的测量语言，该类提供处理测量模式的各种基本操作。" +msgstr "" +"According to the measurement language in [The measurement calculus, " +"arXiv: 0704.1263], this class provides various basic operations for " +"measurement patterns." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.__init__:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "``MCalculus`` 的构造函数，用于实例化一个 ``MCalculus`` 对象。" +msgstr "``MCalculus`` constructor, used to instantiate a ``MCalculus`` object." + +#: ../../source/_autosummary/paddle_quantum.mbqc.mcalculus.MCalculus.rst:14 +msgid "Methods" +msgstr "Methods" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`__init__ `\\ " +"\\(\\)" +msgstr "" +":obj:`__init__ `\\ " +"\\(\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`get_pattern " +"`\\ \\(\\)" +msgstr "" +":obj:`get_pattern " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.get_pattern:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "返回测量模式。" +msgstr "Return pattern." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`optimize_by_row " +"`\\ \\(\\)" +msgstr "" +":obj:`optimize_by_row " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.optimize_by_row:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "按照行序优先的原则对测量模式中的测量顺序进行优化。" +msgstr "optimize measurements of the pattern by a row-major order algorithm." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`set_circuit " +"`\\ \\(circuit\\)" +msgstr "" +":obj:`set_circuit " +"`\\ \\(circuit\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.set_circuit:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "对 ``MCalculus`` 类设置量子电路。" +msgstr "Set quantum circuit to ``MCalculus`` class." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`shift_signals " +"`\\ \\(\\)" +msgstr "" +":obj:`shift_signals " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.shift_signals:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "信号转移操作。" +msgstr "Signal shifting operation." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`standardize " +"`\\ \\(\\)" +msgstr "" +":obj:`standardize " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.standardize:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "对测量模式进行标准化。" +msgstr "Standardize pattern." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "" +":obj:`track_progress " +"`\\ " +"\\(\\[track\\]\\)" +msgstr "" +":obj:`track_progress " +"`\\ " +"\\(\\[track\\]\\)" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1 +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:1::1 +msgid "显示测量模式处理过程的进度条开关。" +msgstr "Switch to show the pattern processing progress bar." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.set_circuit +#: paddle_quantum.mbqc.mcalculus.MCalculus.track_progress +msgid "Parameters" +msgstr "Parameters" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.track_progress:3 +msgid "``True`` 为打开进度条显示，``False`` 为关闭进度条显示，默认为 ``True``" +msgstr "" +"``True`` for turning on the progress bar, ``False`` for turning off the " +"progress bar, the default value is ``True``." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.set_circuit:3 +msgid "量子电路" +msgstr "Quantum circuit." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.standardize:3 +msgid "" +"该方法对测量模式进行标准化操作，转化成等价的 EMC 模型。即将所有的 ``CommandE`` 交换到最前面，其次是 ``CommandM``，" +" ``CommandX`` 和 ``CommandZ``。为了简化测量模式，该方法在标准化各类命令之后还对 ``CommandM`` 进行 " +"Pauli 简化。" +msgstr "" +"This method is called to standardize a pattern to the EMC model, that is," +" to permute all ``CommandE`` to the front, and then ``CommandM``, and " +"then ``CommandX``, and finally the ``CommandZ``. To simplify the pattern, " +"this method automatically performs Pauli simplifications to ``CommandM``" +" after the standardization of all commands." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.shift_signals:3 +msgid "这是用户选择性调用的方法之一。" +msgstr "This is one method that the user optionally calls." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.get_pattern +msgid "Returns" +msgstr "Returns" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.get_pattern:3 +msgid "处理后的测量模式" +msgstr "The pattern after processing." + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.get_pattern +msgid "Return type" +msgstr "Return type" + +#: of paddle_quantum.mbqc.mcalculus.MCalculus.optimize_by_row:5 +msgid "" +"这是一种启发式的优化算法，对于特定的测量模式可以起到优化测量顺序的作用，不排除存在更优的测量顺序。例如，对于浅层量子电路， " +"按照行序优先原则，测量完同一量子位上的量子门、测量对应的节点后，该量子位不再起作用，进而减少后续计算时可能涉及到的节点数目。" +msgstr "" +"This is a heuristic optimization algorithm, with good performance in " +"specific patterns. However, we do not exclude the existence of a better " +"measurement order. For quantum shallow circuits, once all qubits on the " +"same row are measured, they no longer play a role in the following " +"calculations. In this way, the number of qubits involved in subsequent " +"calculations can be reduced." + +#: of paddle_quantum.mbqc.mcalculus:1 +msgid "此模块包含处理 MBQC 测量模式的相关操作。" +msgstr "This module contains operations for the manipulation of measurement patterns." + +#: ../../source/_autosummary/paddle_quantum.mbqc.mcalculus.rst:20 +msgid "Classes" +msgstr "Classes" + +#: ../../source/_autosummary/paddle_quantum.mbqc.mcalculus.rst:25::1 +msgid ":obj:`MCalculus `\\ \\(\\)" +msgstr ":obj:`MCalculus `\\ \\(\\)" + +#: ../../source/_autosummary/paddle_quantum.mbqc.mcalculus.rst:25::1 +msgid "定义测量模式类。" +msgstr "Define ``MCalculus`` class." + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.po new file mode 100644 index 0000000..3b0f0f9 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.po @@ -0,0 +1,75 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2021, Institute for Quantum Computing, Baidu Inc. +# This file is distributed under the same license as the Paddle Quantum +# package. +# FIRST AUTHOR , 2021. +# +msgid "" +msgstr "" +"Project-Id-Version: Paddle Quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.mbqc.rst:2 +msgid "paddle\\_quantum.mbqc" +msgstr "paddle\\_quantum.mbqc" + +#: ../../source/paddle_quantum.mbqc.rst:10 +msgid "Submodules" +msgstr "Submodules" + +#~ msgid ":obj:`paddle_quantum.mbqc.mcalculus `\\" +#~ msgstr ":obj:`paddle_quantum.mbqc.mcalculus `\\" + +#~ msgid "此模块包含处理 MBQC 测量模式的相关操作。" +#~ msgstr "" +#~ "This module contains operations for the" +#~ " manipulation of measurement patterns." + +#~ msgid ":obj:`paddle_quantum.mbqc.qobject `\\" +#~ msgstr ":obj:`paddle_quantum.mbqc.qobject `\\" + +#~ msgid "此模块包含量子信息处理的常用对象，如量子态、量子电路、测量模式等。" +#~ msgstr "" +#~ "This module contains common objects for" +#~ " quantum information processing, such as" +#~ " quantum states, quantum circuits, " +#~ "measurement patterns, etc." + +#~ msgid ":obj:`paddle_quantum.mbqc.simulator `\\" +#~ msgstr ":obj:`paddle_quantum.mbqc.simulator `\\" + +#~ msgid "此模块包含构造 MBQC 模型的常用类和配套的运算模拟工具。" +#~ msgstr "" +#~ "This module contains a frequently used" +#~ " class and accompanying simulation tools" +#~ " for constructing MBQC models." + +#~ msgid "" +#~ ":obj:`paddle_quantum.mbqc.transpiler " +#~ "`\\" +#~ msgstr "" +#~ ":obj:`paddle_quantum.mbqc.transpiler " +#~ "`\\" + +#~ msgid "此模块包含电路模型和 MBQC 测量模式的转义工具。" +#~ msgstr "" +#~ "This module contains tools for " +#~ "transpiling circuits to measurement patterns." + +#~ msgid ":obj:`paddle_quantum.mbqc.utils `\\" +#~ msgstr ":obj:`paddle_quantum.mbqc.utils `\\" + +#~ msgid "此模块包含计算所需的各种常用类和函数。" +#~ msgstr "" +#~ "This module contains various common " +#~ "classes and functions used for " +#~ "computation." + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.qobject.Circuit.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.qobject.Circuit.po new file mode 100644 index 0000000..a0daf57 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.qobject.Circuit.po @@ -0,0 +1,530 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2021, Institute for Quantum Computing, Baidu Inc. +# This file is distributed under the same license as the Paddle Quantum +# package. +# FIRST AUTHOR , 2021. +# +msgid "" +msgstr "" +"Project-Id-Version: Paddle Quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2021-08-26 16:36+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.9.1\n" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.Circuit.rst:2 +msgid "paddle\\_quantum.mbqc.qobject.Circuit" +msgstr "paddle\\_quantum.mbqc.qobject.Circuit" + +#: of paddle_quantum.mbqc.qobject.Circuit:1 +msgid "定义量子电路。" +msgstr "Define quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit:3 +msgid "该类与 ``UAnsatz`` 类似，用户可以仿照 ``UAnsatz`` 电路的调用方式对此类进行实例化，完成电路图的构建。" +msgstr "" +"This class is similar to the class ``UAnsatz``. Users can similarly " +"instantiate this class to build quantum circuits." + +#: of paddle_quantum.mbqc.qobject.Circuit:5 +msgid "" +"当前版本仅支持 ``H, X, Y, Z, S, T, Rx, Ry, Rz, Rz_5, U, CNOT, CNOT_15, CZ`` " +"中的量子门以及测量操作。" +msgstr "" +"The current version only supports quantum measurements and quantum gates " +"in ``H, X, Y, Z, S, T, Rx, Ry, Rz, Rz_5, U, CNOT, CNOT_15, CZ``." + +#: of paddle_quantum.mbqc.qobject.Circuit:9 +#: paddle_quantum.mbqc.qobject.Circuit.__init__:3 +msgid "电路的宽度（比特数）" +msgstr "Circuit width (qubit number)." + +#: of paddle_quantum.mbqc.qobject.Circuit +msgid "type" +msgstr "type" + +#: of paddle_quantum.mbqc.qobject.Circuit:11 +msgid "int" +msgstr "int" + +#: of paddle_quantum.mbqc.qobject.Circuit.__init__:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "``Circuit`` 的构造函数，用于实例化一个 ``Circuit`` 对象。" +msgstr "``Circuit`` constructor, used to instantiate a ``Circuit`` object." + +#: of paddle_quantum.mbqc.qobject.Circuit.__init__ +#: paddle_quantum.mbqc.qobject.Circuit.cnot +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15 +#: paddle_quantum.mbqc.qobject.Circuit.cz paddle_quantum.mbqc.qobject.Circuit.h +#: paddle_quantum.mbqc.qobject.Circuit.measure +#: paddle_quantum.mbqc.qobject.Circuit.rx +#: paddle_quantum.mbqc.qobject.Circuit.ry +#: paddle_quantum.mbqc.qobject.Circuit.rz +#: paddle_quantum.mbqc.qobject.Circuit.rz_5 +#: paddle_quantum.mbqc.qobject.Circuit.s paddle_quantum.mbqc.qobject.Circuit.t +#: paddle_quantum.mbqc.qobject.Circuit.u paddle_quantum.mbqc.qobject.Circuit.x +#: paddle_quantum.mbqc.qobject.Circuit.y paddle_quantum.mbqc.qobject.Circuit.z +msgid "Parameters" +msgstr "Parameters" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.Circuit.rst:14 +msgid "Methods" +msgstr "Methods" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`__init__ `\\ " +"\\(width\\)" +msgstr "" +":obj:`__init__ `\\ " +"\\(width\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`cnot `\\ " +"\\(which\\_qubits\\)" +msgstr "" +":obj:`cnot `\\ " +"\\(which\\_qubits\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "添加控制非门。" +msgstr "Add a Control NOT gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`cnot_15 `\\ " +"\\(which\\_qubits\\)" +msgstr "" +":obj:`cnot_15 `\\ " +"\\(which\\_qubits\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot_15:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "添加控制非门 （该门对应的测量模式由十五个量子比特构成）。" +msgstr "Add a Control NOT gate (Corresponding to the pattern of 15 qubits)." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`cz `\\ \\(which\\_qubits\\)" +msgstr ":obj:`cz `\\ \\(which\\_qubits\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.cz:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "添加控制 Z 门。" +msgstr "Add a Control Z gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`get_circuit `\\ " +"\\(\\)" +msgstr "" +":obj:`get_circuit `\\ " +"\\(\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_circuit:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "返回量子电路列表。" +msgstr "Return a quantum circuit list." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`get_measured_qubits " +"`\\ \\(\\)" +msgstr "" +":obj:`get_measured_qubits " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_measured_qubits:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "返回量子电路中测量的比特位。" +msgstr "Return measurement qubit indices in the quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`get_width `\\ \\(\\)" +msgstr ":obj:`get_width `\\ \\(\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_width:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "返回量子电路的宽度。" +msgstr "Return quantum circuit width." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`h `\\ \\(which\\_qubit\\)" +msgstr ":obj:`h `\\ \\(which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "添加 ``Hadamard`` 门。" +msgstr "Add a ``Hadamard`` gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`is_valid `\\ \\(\\)" +msgstr ":obj:`is_valid `\\ \\(\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.is_valid:1 +msgid "检查输入的量子电路是否符合规定。" +msgstr "Check the validity of the quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`measure `\\ " +"\\(\\[which\\_qubit\\, basis\\_list\\]\\)" +msgstr "" +":obj:`measure `\\ " +"\\(\\[which\\_qubit\\, basis\\_list\\]\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.measure:1 +msgid "对量子电路输出的量子态进行测量。" +msgstr "Measure the output state of the quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`print_circuit_list " +"`\\ \\(\\)" +msgstr "" +":obj:`print_circuit_list " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.print_circuit_list:1 +msgid "打印电路图的列表。" +msgstr "Print quantum circuit list." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`rx `\\ \\(theta\\, " +"which\\_qubit\\)" +msgstr "" +":obj:`rx `\\ \\(theta\\, " +"which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.rx:1 +msgid "添加关于 x 轴的旋转门。" +msgstr "Add a rotation gate around x-axis." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`ry `\\ \\(theta\\, " +"which\\_qubit\\)" +msgstr "" +":obj:`ry `\\ \\(theta\\, " +"which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.ry:1 +msgid "添加关于 y 轴的旋转门。" +msgstr "Add a rotation gate around y-axis." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`rz `\\ \\(theta\\, " +"which\\_qubit\\)" +msgstr "" +":obj:`rz `\\ \\(theta\\, " +"which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.rz:1 +msgid "添加关于 z 轴的旋转门。" +msgstr "Add a rotation gate around z-axis." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`rz_5 `\\ \\(theta\\, " +"which\\_qubit\\)" +msgstr "" +":obj:`rz_5 `\\ \\(theta\\, " +"which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:1 +msgid "添加关于 z 轴的旋转门（该旋转门对应的测量模式由五个量子比特构成）。" +msgstr "" +"Add a rotation gate around z-axis (Corresponding to the pattern of 5 " +"qubits)." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`s `\\ \\(which\\_qubit\\)" +msgstr ":obj:`s `\\ \\(which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.s:1 +msgid "添加 ``S`` 门。" +msgstr "Add a ``S`` gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`t `\\ \\(which\\_qubit\\)" +msgstr ":obj:`t `\\ \\(which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.t:1 +msgid "添加 ``T`` 门。" +msgstr "Add a ``T`` gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`u `\\ \\(params\\, " +"which\\_qubit\\)" +msgstr "" +":obj:`u `\\ \\(params\\, " +"which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.u:1 +msgid "添加单量子比特的任意酉门。" +msgstr "Add a single qubit arbitrary unitary gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`x `\\ \\(which\\_qubit\\)" +msgstr ":obj:`x `\\ \\(which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.x:1 +msgid "添加 ``Pauli X`` 门。" +msgstr "Add a ``Pauli X`` gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`y `\\ \\(which\\_qubit\\)" +msgstr ":obj:`y `\\ \\(which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.y:1 +msgid "添加 ``Pauli Y`` 门。" +msgstr "Add a ``Pauli Y`` gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`z `\\ \\(which\\_qubit\\)" +msgstr ":obj:`z `\\ \\(which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.z:1 +msgid "添加 ``Pauli Z`` 门。" +msgstr "Add a ``Pauli Z`` gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:3 +#: paddle_quantum.mbqc.qobject.Circuit.rx:3 +#: paddle_quantum.mbqc.qobject.Circuit.ry:3 +#: paddle_quantum.mbqc.qobject.Circuit.rz:3 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:3 +#: paddle_quantum.mbqc.qobject.Circuit.s:3 +#: paddle_quantum.mbqc.qobject.Circuit.t:3 +#: paddle_quantum.mbqc.qobject.Circuit.x:3 +#: paddle_quantum.mbqc.qobject.Circuit.y:3 +#: paddle_quantum.mbqc.qobject.Circuit.z:3 +msgid "其矩阵形式为：" +msgstr "The matrix form is:" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:5 +msgid "\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1&1\\\\1&-1 \\end{bmatrix}" +msgstr "\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1&1\\\\1&-1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:9 +#: paddle_quantum.mbqc.qobject.Circuit.rx:11 +#: paddle_quantum.mbqc.qobject.Circuit.ry:11 +#: paddle_quantum.mbqc.qobject.Circuit.rz:11 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:11 +#: paddle_quantum.mbqc.qobject.Circuit.s:9 +#: paddle_quantum.mbqc.qobject.Circuit.t:9 +#: paddle_quantum.mbqc.qobject.Circuit.u:13 +#: paddle_quantum.mbqc.qobject.Circuit.x:9 +#: paddle_quantum.mbqc.qobject.Circuit.y:9 +#: paddle_quantum.mbqc.qobject.Circuit.z:9 +msgid "作用量子门的量子位编号" +msgstr "Qubit index to apply quantum gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:12 +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15:12 +#: paddle_quantum.mbqc.qobject.Circuit.cz:12 +#: paddle_quantum.mbqc.qobject.Circuit.h:12 +#: paddle_quantum.mbqc.qobject.Circuit.rx:14 +#: paddle_quantum.mbqc.qobject.Circuit.ry:14 +#: paddle_quantum.mbqc.qobject.Circuit.rz:14 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:14 +#: paddle_quantum.mbqc.qobject.Circuit.s:12 +#: paddle_quantum.mbqc.qobject.Circuit.t:12 +#: paddle_quantum.mbqc.qobject.Circuit.u:16 +#: paddle_quantum.mbqc.qobject.Circuit.x:12 +#: paddle_quantum.mbqc.qobject.Circuit.y:12 +#: paddle_quantum.mbqc.qobject.Circuit.z:12 +msgid "代码示例：" +msgstr "Code example:" + +#: of paddle_quantum.mbqc.qobject.Circuit.x:5 +msgid "\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}" +msgstr "\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.y:5 +msgid "\\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}" +msgstr "\\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.z:5 +msgid "\\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.s:5 +msgid "\\begin{bmatrix} 1&0\\\\0& i \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1&0\\\\0& i \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.t:5 +msgid "\\begin{bmatrix} 1&0\\\\0& e^{i\\pi/ 4} \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1&0\\\\0& e^{i\\pi/ 4} \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.rx:5 +msgid "" +"\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\" +" -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}" +msgstr "" +"\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\" +" -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.rx:9 +#: paddle_quantum.mbqc.qobject.Circuit.ry:9 +#: paddle_quantum.mbqc.qobject.Circuit.rz:9 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:9 +msgid "旋转角度" +msgstr "Rotation angle." + +#: of paddle_quantum.mbqc.qobject.Circuit.ry:5 +msgid "" +"\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\ " +"\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}" +msgstr "" +"\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\ " +"\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.rz:5 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:5 +msgid "\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\theta} \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\theta} \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.u:3 +msgid "与 ``UAnsatz`` 类中的 U3 的三个参数不同，这里的酉门采用 ``Rz Rx Rz`` 分解，" +msgstr "" +"Unlike the U3 gate in ``UAnsatz``, the decomposition of the unitary gate" +" here is ``Rz Rx Rz``." + +#: of paddle_quantum.mbqc.qobject.Circuit.u:5 +msgid "其分解形式为：" +msgstr "Its decomposition is:" + +#: of paddle_quantum.mbqc.qobject.Circuit.u:7 +msgid "U(\\alpha, \\beta, \\gamma) = Rz(\\gamma) Rx(\\beta) Rz(\\alpha)" +msgstr "U(\\alpha, \\beta, \\gamma) = Rz(\\gamma) Rx(\\beta) Rz(\\alpha)" + +#: of paddle_quantum.mbqc.qobject.Circuit.u:11 +msgid "单比特酉门的三个旋转角度" +msgstr "A list including three rotation angles in the ``Rz Rx Rz`` decomposition." + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:3 +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15:3 +#: paddle_quantum.mbqc.qobject.Circuit.cz:3 +msgid "当 ``which_qubits`` 为 ``[0, 1]`` 时，其矩阵形式为：" +msgstr "If ``which_qubits`` is set to be ``[0, 1]``, the matrix form is:" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:5 +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15:5 +msgid "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\" +" 0 & 0 & 1 & 0 \\end{bmatrix}" +msgstr "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\" +" 0 & 0 & 1 & 0 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:9 +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15:9 +#: paddle_quantum.mbqc.qobject.Circuit.cz:9 +msgid "作用量子门的量子位，其中列表第一个元素为控制位，第二个元素为受控位" +msgstr "" +"A list of qubit indexes to apply quantum gate, with the first element " +"being the control qubit and the second element being the target qubit." + +#: of paddle_quantum.mbqc.qobject.Circuit.cz:5 +msgid "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\" +" 0 & 0 & 0 & -1 \\end{bmatrix}" +msgstr "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\" +" 0 & 0 & 0 & -1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:3 +msgid "与 ``UAnsatz`` 类中的测量不同，除默认的 Z 测量外，此处的测量方式可以由用户自定义，但需要将测量方式与测量比特相对应。" +msgstr "" +"Unlike measurements in class ``UAnsatz``, measurements here can be " +"customized by users, but the input should be consistent with the " +"measurement qubits." + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:7 +msgid "" +"此方法只接受三种输入方式： 1. 不输入任何参数，表示对所有的量子位进行 Z 测量； 2. 输入量子位，但不输入测量基，表示对输入的量子位进行 Z" +" 测量； 3. 输入量子位和对应测量基，表示对输入量子位进行指定的测量。 如果用户希望自定义测量基参数，需要注意输入格式为 ``[angle, " +"plane, domain_s, domain_t]``， 且当前版本的测量平面 ``plane`` 只能支持 ``XY`` 或 ``YZ``。" +msgstr "" +"This method only supports three kinds of input: 1. Calling this method " +"without any argument means setting Z-measurements to all qubits in the " +"circuit model; 2. Inputting a qubit index with no measurement basis means" +" setting Z-measurement on the given qubit; 3. Inputting a qubit index " +"with a measurement basis means measuring the qubit in the given basis." + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:14 +msgid "被测量的量子位" +msgstr "Qubit index to be measured." + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:16 +msgid "测量方式" +msgstr "Measurement basis." + +#: of paddle_quantum.mbqc.qobject.Circuit.is_valid:3 +msgid "我们规定输入的量子电路中，每一个量子位上至少作用一个量子门。" +msgstr "" +"We require that at least one quantum gate acts on each qubit of the " +"circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit.get_circuit +#: paddle_quantum.mbqc.qobject.Circuit.get_measured_qubits +#: paddle_quantum.mbqc.qobject.Circuit.get_width +#: paddle_quantum.mbqc.qobject.Circuit.is_valid +#: paddle_quantum.mbqc.qobject.Circuit.print_circuit_list +msgid "Returns" +msgstr "Returns" + +#: of paddle_quantum.mbqc.qobject.Circuit.is_valid:5 +msgid "量子电路是否符合规定的布尔值" +msgstr "The boolean value of the validity of quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit.get_circuit +#: paddle_quantum.mbqc.qobject.Circuit.get_measured_qubits +#: paddle_quantum.mbqc.qobject.Circuit.get_width +#: paddle_quantum.mbqc.qobject.Circuit.is_valid +#: paddle_quantum.mbqc.qobject.Circuit.print_circuit_list +msgid "Return type" +msgstr "Return type" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_width:3 +msgid "量子电路的宽度" +msgstr "Quantum circuit width." + +#: of paddle_quantum.mbqc.qobject.Circuit.get_circuit:3 +msgid "量子电路列表" +msgstr "A quantum circuit list." + +#: of paddle_quantum.mbqc.qobject.Circuit.get_measured_qubits:3 +msgid "量子电路中测量的比特位列表" +msgstr "Measurement qubit indices in the quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit.print_circuit_list:3 +msgid "用来打印的字符串" +msgstr "String to print." + +#: of paddle_quantum.mbqc.qobject.Circuit.print_circuit_list:6 +msgid "代码示例:" +msgstr "Code example:" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.qobject.Pattern.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.qobject.Pattern.po new file mode 100644 index 0000000..70929d2 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.qobject.Pattern.po @@ -0,0 +1,239 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2021, Institute for Quantum Computing, Baidu Inc. +# This file is distributed under the same license as the Paddle Quantum +# package. +# FIRST AUTHOR , 2021. +# +msgid "" +msgstr "" +"Project-Id-Version: Paddle Quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2021-08-18 19:49+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.9.1\n" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.Pattern.rst:2 +msgid "paddle\\_quantum.mbqc.qobject.Pattern" +msgstr "paddle\\_quantum.mbqc.qobject.Pattern" + +#: of paddle_quantum.mbqc.qobject.Pattern:1 +msgid "定义测量模式。" +msgstr "Define measurement pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern:3 +msgid "该测量模式的结构依据文献 [The measurement calculus, arXiv: 0704.1263]。" +msgstr "" +"The construction of measurement pattern can be referred to [The " +"measurement calculus, arXiv: 0704.1263]." + +#: of paddle_quantum.mbqc.qobject.Pattern:7 +#: paddle_quantum.mbqc.qobject.Pattern.__init__:3 +msgid "测量模式的名称" +msgstr "Name of the measurement pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern +#: paddle_quantum.mbqc.qobject.Pattern.CommandE +#: paddle_quantum.mbqc.qobject.Pattern.CommandM +#: paddle_quantum.mbqc.qobject.Pattern.CommandS +#: paddle_quantum.mbqc.qobject.Pattern.CommandX +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ +msgid "type" +msgstr "type" + +#: of paddle_quantum.mbqc.qobject.Pattern:9 +#: paddle_quantum.mbqc.qobject.Pattern.CommandM:34 +msgid "str" +msgstr "str" + +#: of paddle_quantum.mbqc.qobject.Pattern:13 +#: paddle_quantum.mbqc.qobject.Pattern.__init__:5 +msgid "测量模式所有节点列表" +msgstr "A list of all vertices in the pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern:15 +#: paddle_quantum.mbqc.qobject.Pattern:21 +#: paddle_quantum.mbqc.qobject.Pattern:27 +#: paddle_quantum.mbqc.qobject.Pattern:33 +#: paddle_quantum.mbqc.qobject.Pattern.CommandE:9 +#: paddle_quantum.mbqc.qobject.Pattern.CommandM:40 +#: paddle_quantum.mbqc.qobject.Pattern.CommandM:46 +#: paddle_quantum.mbqc.qobject.Pattern.CommandS:15 +#: paddle_quantum.mbqc.qobject.Pattern.CommandX:13 +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ:13 +msgid "list" +msgstr "list" + +#: of paddle_quantum.mbqc.qobject.Pattern:19 +#: paddle_quantum.mbqc.qobject.Pattern.__init__:7 +msgid "测量模式的输入节点列表" +msgstr "A list of all input vertices in the pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern:25 +#: paddle_quantum.mbqc.qobject.Pattern.__init__:9 +msgid "测量模式的输出节点列表" +msgstr "A list of all output vertices in the pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern:31 +#: paddle_quantum.mbqc.qobject.Pattern.__init__:11 +msgid "测量模式的命令列表" +msgstr "A list of all commands in the pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:1::1 +#: paddle_quantum.mbqc.qobject.Pattern.__init__:1 +msgid "构造函数，用于实例化一个 ``Pattern`` 对象。" +msgstr "``Pattern`` constructor, used to instantiate a ``Pattern`` object." + +#: of paddle_quantum.mbqc.qobject.Pattern.__init__ +msgid "Parameters" +msgstr "Parameters" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.Pattern.rst:14 +msgid "Methods" +msgstr "Methods" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:1::1 +msgid "" +":obj:`__init__ `\\ " +"\\(name\\, space\\, input\\_\\, output\\_\\, commands\\)" +msgstr "" +":obj:`__init__ `\\ " +"\\(name\\, space\\, input\\_\\, output\\_\\, commands\\)" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:1::1 +msgid "" +":obj:`print_command_list " +"`\\ \\(\\)" +msgstr "" +":obj:`print_command_list " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:1::1 +#: paddle_quantum.mbqc.qobject.Pattern.print_command_list:1 +msgid "打印该 ``Pattern`` 类中的命令的信息，便于用户查看。" +msgstr "Print the information of commands in the ``Pattern`` class." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:1 +msgid "定义纠缠命令类。" +msgstr "Define entanglement command class." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:3 +msgid "此处纠缠命令对应作用控制 Z 门。" +msgstr "Here the entanglement commands correspond to applying Control Z gates." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:7 +msgid "作用纠缠命令的两个节点标签构成的列表" +msgstr "A list of vertex pairs to be entangled." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:1 +msgid "定义测量命令类。" +msgstr "Define the measurement command class." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:3 +msgid "" +"测量命令有五个属性，分别为测量比特的标签 ``which_qubit``，原始的测量角度 ``angle``， 测量平面 ``plane``，域 " +"s 对应的节点标签列表 ``domain_s``，域 t 对应的节点标签列表 ``domain_t``。 设原始角度为 " +":math:`\\alpha`，则考虑域中节点依赖关系后的测量角度 :math:`\\theta` 为：" +msgstr "" +"There are five attributes in a measurement command, including qubit label" +" ``which_qubit``, original measurement angle ``angle``, measurement plane" +" ``plane``, vertices list ``domain_s`` corresponding to s domain, " +"vertices list ``domain_t`` corresponding to t domain. If the original " +"angle is: math:`\\alpha`, the adaptive angle: math:`\theta` after " +"considering dependencies of vertices in the domains is:" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:7 +msgid "\\theta = (-1)^s \\times \\alpha + t \\times \\pi" +msgstr "\\theta = (-1)^s \\times \\alpha + t \\times \\pi" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:13 +msgid "" +"域 s 和域 t 是 MBQC 模型中的概念，分别记录了 Pauli X 算符和 Pauli Z 算符对测量角度产生的影响， " +"二者共同记录了该测量节点对其他节点的测量结果的依赖关系。" +msgstr "" +"Domain s and domain t are concepts in MBQC, recording the byproduct " +"effect of Pauli X and Pauli Z operators. Both record the dependencies of " +"this qubit on other measurement outcomes." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:16 +msgid "该命令当前只支持 XY 和 YZ 平面的测量。" +msgstr "" +"This command only supports measurements in the XY-plane and the YZ-plane " +"in this version." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:20 +msgid "作用测量命令的节点标签" +msgstr "Vertex label for the measurement command." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:22 +#: paddle_quantum.mbqc.qobject.Pattern.CommandS:9 +#: paddle_quantum.mbqc.qobject.Pattern.CommandX:7 +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ:7 +msgid "any" +msgstr "any" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:26 +msgid "原始的测量角度" +msgstr "Original measurement angle." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:28 +msgid "Tensor" +msgstr "Tensor" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:32 +msgid "测量平面" +msgstr "Measurement plane." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:38 +msgid "域 s 对应的节点标签列表" +msgstr "A list of vertices in the s domain." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:44 +msgid "域 t 对应的节点标签列表" +msgstr "A list of vertices in the t domain." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandX:1 +msgid "定义 Pauli X 副产品修正命令类。" +msgstr "Define Pauli X byproduct correction command class." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandX:5 +msgid "作用修正算符的节点标签" +msgstr "Vertex label to be executed Pauli X byproduct correction command on." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandS:13 +#: paddle_quantum.mbqc.qobject.Pattern.CommandX:11 +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ:11 +msgid "依赖关系列表" +msgstr "A list of vertices, denoting dependencies on other measurement outcomes." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandZ:1 +msgid "定义 Pauli Z 副产品修正命令。" +msgstr "Define Pauli Z byproduct correction command class." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandZ:5 +msgid "作用修正命令的节点标签" +msgstr "Vertex label for the Pauli Z byproduct correction command." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandS:1 +msgid "定义 \"信号转移\" 命令类。" +msgstr "Define \"signal shifting\" command class." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandS:3 +msgid "\"信号转移\" 是一类特殊的操作，用于消除测量命令对域 t 中节点的依赖关系，在某些情况下对测量模式进行简化。" +msgstr "" +"\"signal shifting\" is a special operation, used to remove dependencies " +"of a measurement command on outcomes of vertices in domain t. In some " +"cases, measurement patterns can be simplified in this way." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandS:7 +msgid "消除依赖关系的测量命令作用的节点标签" +msgstr "Vertex label to be executed simplified measurement command on." + +#: of paddle_quantum.mbqc.qobject.Pattern.print_command_list:3 +msgid "代码示例:" +msgstr "Code example:" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.qobject.State.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.qobject.State.po new file mode 100644 index 0000000..6881171 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.qobject.State.po @@ -0,0 +1,70 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2021, Institute for Quantum Computing, Baidu Inc. +# This file is distributed under the same license as the Paddle Quantum +# package. +# FIRST AUTHOR , 2021. +# +msgid "" +msgstr "" +"Project-Id-Version: Paddle Quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2021-08-18 19:49+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.9.1\n" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.State.rst:2 +msgid "paddle\\_quantum.mbqc.qobject.State" +msgstr "paddle\\_quantum.mbqc.qobject.State" + +#: of paddle_quantum.mbqc.qobject.State:1 +msgid "定义量子态。" +msgstr "Define quantum state." + +#: of paddle_quantum.mbqc.qobject.State:5 +#: paddle_quantum.mbqc.qobject.State.__init__:3 +msgid "量子态的列向量" +msgstr "Vector of a quantum state." + +#: of paddle_quantum.mbqc.qobject.State +msgid "type" +msgstr "type" + +#: of paddle_quantum.mbqc.qobject.State:7 +msgid "Tensor" +msgstr "Tensor" + +#: of paddle_quantum.mbqc.qobject.State:11 +#: paddle_quantum.mbqc.qobject.State.__init__:5 +msgid "量子态的系统标签列表" +msgstr "System labels of a quantum state." + +#: of paddle_quantum.mbqc.qobject.State:13 +msgid "list" +msgstr "list" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.State.rst:17::1 +#: of paddle_quantum.mbqc.qobject.State.__init__:1 +msgid "构造函数，用于实例化一个 ``\"State\"`` 量子态对象。" +msgstr "``State`` constructor, used to instantiate a ``\"State\"`` object." + +#: of paddle_quantum.mbqc.qobject.State.__init__ +msgid "Parameters" +msgstr "Parameters" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.State.rst:14 +msgid "Methods" +msgstr "Methods" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.State.rst:17::1 +msgid "" +":obj:`__init__ `\\ " +"\\(\\[vector\\, system\\]\\)" +msgstr "" +":obj:`__init__ `\\ " +"\\(\\[vector\\, system\\]\\)" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.qobject.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.qobject.po new file mode 100644 index 0000000..975ebfa --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.qobject.po @@ -0,0 +1,1321 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2021, Institute for Quantum Computing, Baidu Inc. +# This file is distributed under the same license as the Paddle Quantum +# package. +# FIRST AUTHOR , 2021. +# +msgid "" +msgstr "" +"Project-Id-Version: Paddle Quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: of paddle_quantum.mbqc.qobject.Pattern:1 +msgid "定义测量模式。" +msgstr "Define measurement pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern:3 +msgid "该测量模式的结构依据文献 [The measurement calculus, arXiv: 0704.1263]。" +msgstr "" +"The construction of measurement pattern can be referred to [The " +"measurement calculus, arXiv: 0704.1263]." + +#: of paddle_quantum.mbqc.qobject.Pattern:7 +#: paddle_quantum.mbqc.qobject.Pattern.__init__:3 +msgid "测量模式的名称" +msgstr "Name of the measurement pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern +#: paddle_quantum.mbqc.qobject.Pattern.CommandE +#: paddle_quantum.mbqc.qobject.Pattern.CommandM +#: paddle_quantum.mbqc.qobject.Pattern.CommandS +#: paddle_quantum.mbqc.qobject.Pattern.CommandX +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ +msgid "type" +msgstr "type" + +#: of paddle_quantum.mbqc.qobject.Pattern:9 +#: paddle_quantum.mbqc.qobject.Pattern.CommandM:34 +msgid "str" +msgstr "str" + +#: of paddle_quantum.mbqc.qobject.Pattern:13 +#: paddle_quantum.mbqc.qobject.Pattern.__init__:5 +msgid "测量模式所有节点列表" +msgstr "A list of all vertices in the pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern:15 +#: paddle_quantum.mbqc.qobject.Pattern:21 +#: paddle_quantum.mbqc.qobject.Pattern:27 +#: paddle_quantum.mbqc.qobject.Pattern:33 +#: paddle_quantum.mbqc.qobject.Pattern.CommandE:9 +#: paddle_quantum.mbqc.qobject.Pattern.CommandM:40 +#: paddle_quantum.mbqc.qobject.Pattern.CommandM:46 +#: paddle_quantum.mbqc.qobject.Pattern.CommandS:15 +#: paddle_quantum.mbqc.qobject.Pattern.CommandX:13 +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ:13 +msgid "list" +msgstr "list" + +#: of paddle_quantum.mbqc.qobject.Pattern:19 +#: paddle_quantum.mbqc.qobject.Pattern.__init__:7 +msgid "测量模式的输入节点列表" +msgstr "A list of all input vertices in the pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern:25 +#: paddle_quantum.mbqc.qobject.Pattern.__init__:9 +msgid "测量模式的输出节点列表" +msgstr "A list of all output vertices in the pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern:31 +#: paddle_quantum.mbqc.qobject.Pattern.__init__:11 +msgid "测量模式的命令列表" +msgstr "A list of all commands in the pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:1::1 +#: paddle_quantum.mbqc.qobject.Pattern.__init__:1 +msgid "构造函数，用于实例化一个 ``Pattern`` 对象。" +msgstr "``Pattern`` constructor, used to instantiate a ``Pattern`` object." + +#: of paddle_quantum.mbqc.qobject.Pattern.__init__ +msgid "Parameters" +msgstr "Parameters" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.Pattern.rst:14 +msgid "Methods" +msgstr "Methods" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:1::1 +msgid "" +":obj:`__init__ `\\ " +"\\(name\\, space\\, input\\_\\, output\\_\\, commands\\)" +msgstr "" +":obj:`__init__ `\\ " +"\\(name\\, space\\, input\\_\\, output\\_\\, commands\\)" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:1::1 +msgid "" +":obj:`print_command_list " +"`\\ \\(\\)" +msgstr "" +":obj:`print_command_list " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:1::1 +#: paddle_quantum.mbqc.qobject.Pattern.print_command_list:1 +msgid "打印该 ``Pattern`` 类中的命令的信息，便于用户查看。" +msgstr "Print the information of commands in the ``Pattern`` class." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:1 +msgid "定义纠缠命令类。" +msgstr "Define entanglement command class." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:3 +msgid "此处纠缠命令对应作用控制 Z 门。" +msgstr "Here the entanglement commands correspond to applying Control Z gates." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:7 +msgid "作用纠缠命令的两个节点标签构成的列表" +msgstr "A list of vertex pairs to be entangled." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:1 +msgid "定义测量命令类。" +msgstr "Define the measurement command class." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:3 +msgid "" +"测量命令有五个属性，分别为测量比特的标签 ``which_qubit``，原始的测量角度 ``angle``， 测量平面 ``plane``，域 " +"s 对应的节点标签列表 ``domain_s``，域 t 对应的节点标签列表 ``domain_t``。 设原始角度为 " +":math:`\\alpha`，则考虑域中节点依赖关系后的测量角度 :math:`\\theta` 为：" +msgstr "" +"There are five attributes in a measurement command, including qubit label" +" ``which_qubit``, original measurement angle ``angle``, measurement plane" +" ``plane``, vertices list ``domain_s`` corresponding to s domain, " +"vertices list ``domain_t`` corresponding to t domain. If the original " +"angle is: math:`\\alpha`, the adaptive angle: math:`\theta` after " +"considering dependencies of vertices in the domains is:" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:7 +msgid "\\theta = (-1)^s \\times \\alpha + t \\times \\pi" +msgstr "\\theta = (-1)^s \\times \\alpha + t \\times \\pi" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:13 +msgid "" +"域 s 和域 t 是 MBQC 模型中的概念，分别记录了 Pauli X 算符和 Pauli Z 算符对测量角度产生的影响， " +"二者共同记录了该测量节点对其他节点的测量结果的依赖关系。" +msgstr "" +"Domain s and domain t are concepts in MBQC, recording the byproduct " +"effect of Pauli X and Pauli Z operators. Both record the dependencies of " +"this qubit on other measurement outcomes." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:16 +msgid "该命令当前只支持 XY 和 YZ 平面的测量。" +msgstr "" +"This command only supports measurements in the XY-plane and the YZ-plane " +"in this version." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:20 +msgid "作用测量命令的节点标签" +msgstr "Vertex label for the measurement command." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:22 +#: paddle_quantum.mbqc.qobject.Pattern.CommandS:9 +#: paddle_quantum.mbqc.qobject.Pattern.CommandX:7 +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ:7 +msgid "any" +msgstr "any" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:26 +msgid "原始的测量角度" +msgstr "Original measurement angle." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:28 +msgid "Tensor" +msgstr "Tensor" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:32 +msgid "测量平面" +msgstr "Measurement plane." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:38 +msgid "域 s 对应的节点标签列表" +msgstr "A list of vertices in the s domain." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:44 +msgid "域 t 对应的节点标签列表" +msgstr "A list of vertices in the t domain." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandX:1 +msgid "定义 Pauli X 副产品修正命令类。" +msgstr "Define Pauli X byproduct correction command class." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandX:5 +msgid "作用修正算符的节点标签" +msgstr "Vertex label to be executed Pauli X byproduct correction command on." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandS:13 +#: paddle_quantum.mbqc.qobject.Pattern.CommandX:11 +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ:11 +msgid "依赖关系列表" +msgstr "A list of vertices, denoting dependencies on other measurement outcomes." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandZ:1 +msgid "定义 Pauli Z 副产品修正命令。" +msgstr "Define Pauli Z byproduct correction command class." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandZ:5 +msgid "作用修正命令的节点标签" +msgstr "Vertex label for the Pauli Z byproduct correction command." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandS:1 +msgid "定义 \"信号转移\" 命令类。" +msgstr "Define \"signal shifting\" command class." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandS:3 +msgid "\"信号转移\" 是一类特殊的操作，用于消除测量命令对域 t 中节点的依赖关系，在某些情况下对测量模式进行简化。" +msgstr "" +"\"signal shifting\" is a special operation, used to remove dependencies " +"of a measurement command on outcomes of vertices in domain t. In some " +"cases, measurement patterns can be simplified in this way." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandS:7 +msgid "消除依赖关系的测量命令作用的节点标签" +msgstr "Vertex label to be executed simplified measurement command on." + +#: of paddle_quantum.mbqc.qobject.Pattern.print_command_list:3 +msgid "代码示例:" +msgstr "Code example:" + +#: of paddle_quantum.mbqc.qobject.State:1 +msgid "定义量子态。" +msgstr "Define quantum state." + +#: of paddle_quantum.mbqc.qobject.State:5 +#: paddle_quantum.mbqc.qobject.State.__init__:3 +msgid "量子态的列向量" +msgstr "Vector of a quantum state." + +#: of paddle_quantum.mbqc.qobject.State +msgid "type" +msgstr "type" + +#: of paddle_quantum.mbqc.qobject.State:7 +msgid "Tensor" +msgstr "Tensor" + +#: of paddle_quantum.mbqc.qobject.State:11 +#: paddle_quantum.mbqc.qobject.State.__init__:5 +msgid "量子态的系统标签列表" +msgstr "System labels of a quantum state." + +#: of paddle_quantum.mbqc.qobject.State:13 +msgid "list" +msgstr "list" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.State.rst:17::1 +#: of paddle_quantum.mbqc.qobject.State.__init__:1 +msgid "构造函数，用于实例化一个 ``\"State\"`` 量子态对象。" +msgstr "``State`` constructor, used to instantiate a ``\"State\"`` object." + +#: of paddle_quantum.mbqc.qobject.State.__init__ +msgid "Parameters" +msgstr "Parameters" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.State.rst:14 +msgid "Methods" +msgstr "Methods" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.State.rst:17::1 +msgid "" +":obj:`__init__ `\\ " +"\\(\\[vector\\, system\\]\\)" +msgstr "" +":obj:`__init__ `\\ " +"\\(\\[vector\\, system\\]\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit:1 +msgid "定义量子电路。" +msgstr "Define quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit:3 +msgid "该类与 ``UAnsatz`` 类似，用户可以仿照 ``UAnsatz`` 电路的调用方式对此类进行实例化，完成电路图的构建。" +msgstr "" +"This class is similar to the class ``UAnsatz``. Users can similarly " +"instantiate this class to build quantum circuits." + +#: of paddle_quantum.mbqc.qobject.Circuit:5 +msgid "" +"当前版本仅支持 ``H, X, Y, Z, S, T, Rx, Ry, Rz, Rz_5, U, CNOT, CNOT_15, CZ`` " +"中的量子门以及测量操作。" +msgstr "" +"The current version only supports quantum measurements and quantum gates " +"in ``H, X, Y, Z, S, T, Rx, Ry, Rz, Rz_5, U, CNOT, CNOT_15, CZ``." + +#: of paddle_quantum.mbqc.qobject.Circuit:9 +#: paddle_quantum.mbqc.qobject.Circuit.__init__:3 +msgid "电路的宽度（比特数）" +msgstr "Circuit width (qubit number)." + +#: of paddle_quantum.mbqc.qobject.Circuit +msgid "type" +msgstr "type" + +#: of paddle_quantum.mbqc.qobject.Circuit:11 +msgid "int" +msgstr "int" + +#: of paddle_quantum.mbqc.qobject.Circuit.__init__:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "``Circuit`` 的构造函数，用于实例化一个 ``Circuit`` 对象。" +msgstr "``Circuit`` constructor, used to instantiate a ``Circuit`` object." + +#: of paddle_quantum.mbqc.qobject.Circuit.__init__ +#: paddle_quantum.mbqc.qobject.Circuit.cnot +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15 +#: paddle_quantum.mbqc.qobject.Circuit.cz paddle_quantum.mbqc.qobject.Circuit.h +#: paddle_quantum.mbqc.qobject.Circuit.measure +#: paddle_quantum.mbqc.qobject.Circuit.rx +#: paddle_quantum.mbqc.qobject.Circuit.ry +#: paddle_quantum.mbqc.qobject.Circuit.rz +#: paddle_quantum.mbqc.qobject.Circuit.rz_5 +#: paddle_quantum.mbqc.qobject.Circuit.s paddle_quantum.mbqc.qobject.Circuit.t +#: paddle_quantum.mbqc.qobject.Circuit.u paddle_quantum.mbqc.qobject.Circuit.x +#: paddle_quantum.mbqc.qobject.Circuit.y paddle_quantum.mbqc.qobject.Circuit.z +msgid "Parameters" +msgstr "Parameters" + +#: ../../source/_autosummary/paddle_quantum.mbqc.qobject.Circuit.rst:14 +msgid "Methods" +msgstr "Methods" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`__init__ `\\ " +"\\(width\\)" +msgstr "" +":obj:`__init__ `\\ " +"\\(width\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`cnot `\\ " +"\\(which\\_qubits\\)" +msgstr "" +":obj:`cnot `\\ " +"\\(which\\_qubits\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "添加控制非门。" +msgstr "Add a Control NOT gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`cnot_15 `\\ " +"\\(which\\_qubits\\)" +msgstr "" +":obj:`cnot_15 `\\ " +"\\(which\\_qubits\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot_15:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "添加控制非门 （该门对应的测量模式由十五个量子比特构成）。" +msgstr "Add a Control NOT gate (Corresponding to the pattern of 15 qubits)." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`cz `\\ \\(which\\_qubits\\)" +msgstr ":obj:`cz `\\ \\(which\\_qubits\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.cz:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "添加控制 Z 门。" +msgstr "Add a Control Z gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`get_circuit `\\ " +"\\(\\)" +msgstr "" +":obj:`get_circuit `\\ " +"\\(\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_circuit:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "返回量子电路列表。" +msgstr "Return a quantum circuit list." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`get_measured_qubits " +"`\\ \\(\\)" +msgstr "" +":obj:`get_measured_qubits " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_measured_qubits:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "返回量子电路中测量的比特位。" +msgstr "Return measurement qubit indices in the quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`get_width `\\ \\(\\)" +msgstr ":obj:`get_width `\\ \\(\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_width:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "返回量子电路的宽度。" +msgstr "Return quantum circuit width." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`h `\\ \\(which\\_qubit\\)" +msgstr ":obj:`h `\\ \\(which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1 +#: paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "添加 ``Hadamard`` 门。" +msgstr "Add a ``Hadamard`` gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`is_valid `\\ \\(\\)" +msgstr ":obj:`is_valid `\\ \\(\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.is_valid:1 +msgid "检查输入的量子电路是否符合规定。" +msgstr "Check the validity of the quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`measure `\\ " +"\\(\\[which\\_qubit\\, basis\\_list\\]\\)" +msgstr "" +":obj:`measure `\\ " +"\\(\\[which\\_qubit\\, basis\\_list\\]\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.measure:1 +msgid "对量子电路输出的量子态进行测量。" +msgstr "Measure the output state of the quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`print_circuit_list " +"`\\ \\(\\)" +msgstr "" +":obj:`print_circuit_list " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.print_circuit_list:1 +msgid "打印电路图的列表。" +msgstr "Print quantum circuit list." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`rx `\\ \\(theta\\, " +"which\\_qubit\\)" +msgstr "" +":obj:`rx `\\ \\(theta\\, " +"which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.rx:1 +msgid "添加关于 x 轴的旋转门。" +msgstr "Add a rotation gate around x-axis." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`ry `\\ \\(theta\\, " +"which\\_qubit\\)" +msgstr "" +":obj:`ry `\\ \\(theta\\, " +"which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.ry:1 +msgid "添加关于 y 轴的旋转门。" +msgstr "Add a rotation gate around y-axis." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`rz `\\ \\(theta\\, " +"which\\_qubit\\)" +msgstr "" +":obj:`rz `\\ \\(theta\\, " +"which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.rz:1 +msgid "添加关于 z 轴的旋转门。" +msgstr "Add a rotation gate around z-axis." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`rz_5 `\\ \\(theta\\, " +"which\\_qubit\\)" +msgstr "" +":obj:`rz_5 `\\ \\(theta\\, " +"which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:1 +msgid "添加关于 z 轴的旋转门（该旋转门对应的测量模式由五个量子比特构成）。" +msgstr "" +"Add a rotation gate around z-axis (Corresponding to the pattern of 5 " +"qubits)." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`s `\\ \\(which\\_qubit\\)" +msgstr ":obj:`s `\\ \\(which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.s:1 +msgid "添加 ``S`` 门。" +msgstr "Add a ``S`` gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`t `\\ \\(which\\_qubit\\)" +msgstr ":obj:`t `\\ \\(which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.t:1 +msgid "添加 ``T`` 门。" +msgstr "Add a ``T`` gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid "" +":obj:`u `\\ \\(params\\, " +"which\\_qubit\\)" +msgstr "" +":obj:`u `\\ \\(params\\, " +"which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.u:1 +msgid "添加单量子比特的任意酉门。" +msgstr "Add a single qubit arbitrary unitary gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`x `\\ \\(which\\_qubit\\)" +msgstr ":obj:`x `\\ \\(which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.x:1 +msgid "添加 ``Pauli X`` 门。" +msgstr "Add a ``Pauli X`` gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`y `\\ \\(which\\_qubit\\)" +msgstr ":obj:`y `\\ \\(which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.y:1 +msgid "添加 ``Pauli Y`` 门。" +msgstr "Add a ``Pauli Y`` gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +msgid ":obj:`z `\\ \\(which\\_qubit\\)" +msgstr ":obj:`z `\\ \\(which\\_qubit\\)" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1::1 +#: paddle_quantum.mbqc.qobject.Circuit.z:1 +msgid "添加 ``Pauli Z`` 门。" +msgstr "Add a ``Pauli Z`` gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.h:3 +#: paddle_quantum.mbqc.qobject.Circuit.rx:3 +#: paddle_quantum.mbqc.qobject.Circuit.ry:3 +#: paddle_quantum.mbqc.qobject.Circuit.rz:3 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:3 +#: paddle_quantum.mbqc.qobject.Circuit.s:3 +#: paddle_quantum.mbqc.qobject.Circuit.t:3 +#: paddle_quantum.mbqc.qobject.Circuit.x:3 +#: paddle_quantum.mbqc.qobject.Circuit.y:3 +#: paddle_quantum.mbqc.qobject.Circuit.z:3 +msgid "其矩阵形式为：" +msgstr "The matrix form is:" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:5 +msgid "\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1&1\\\\1&-1 \\end{bmatrix}" +msgstr "\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1&1\\\\1&-1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:9 +#: paddle_quantum.mbqc.qobject.Circuit.rx:11 +#: paddle_quantum.mbqc.qobject.Circuit.ry:11 +#: paddle_quantum.mbqc.qobject.Circuit.rz:11 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:11 +#: paddle_quantum.mbqc.qobject.Circuit.s:9 +#: paddle_quantum.mbqc.qobject.Circuit.t:9 +#: paddle_quantum.mbqc.qobject.Circuit.u:13 +#: paddle_quantum.mbqc.qobject.Circuit.x:9 +#: paddle_quantum.mbqc.qobject.Circuit.y:9 +#: paddle_quantum.mbqc.qobject.Circuit.z:9 +msgid "作用量子门的量子位编号" +msgstr "Qubit index to apply quantum gate." + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:12 +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15:12 +#: paddle_quantum.mbqc.qobject.Circuit.cz:12 +#: paddle_quantum.mbqc.qobject.Circuit.h:12 +#: paddle_quantum.mbqc.qobject.Circuit.rx:14 +#: paddle_quantum.mbqc.qobject.Circuit.ry:14 +#: paddle_quantum.mbqc.qobject.Circuit.rz:14 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:14 +#: paddle_quantum.mbqc.qobject.Circuit.s:12 +#: paddle_quantum.mbqc.qobject.Circuit.t:12 +#: paddle_quantum.mbqc.qobject.Circuit.u:16 +#: paddle_quantum.mbqc.qobject.Circuit.x:12 +#: paddle_quantum.mbqc.qobject.Circuit.y:12 +#: paddle_quantum.mbqc.qobject.Circuit.z:12 +msgid "代码示例：" +msgstr "Code example:" + +#: of paddle_quantum.mbqc.qobject.Circuit.x:5 +msgid "\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}" +msgstr "\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.y:5 +msgid "\\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}" +msgstr "\\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.z:5 +msgid "\\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.s:5 +msgid "\\begin{bmatrix} 1&0\\\\0& i \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1&0\\\\0& i \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.t:5 +msgid "\\begin{bmatrix} 1&0\\\\0& e^{i\\pi/ 4} \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1&0\\\\0& e^{i\\pi/ 4} \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.rx:5 +msgid "" +"\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\" +" -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}" +msgstr "" +"\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\" +" -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.rx:9 +#: paddle_quantum.mbqc.qobject.Circuit.ry:9 +#: paddle_quantum.mbqc.qobject.Circuit.rz:9 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:9 +msgid "旋转角度" +msgstr "Rotation angle." + +#: of paddle_quantum.mbqc.qobject.Circuit.ry:5 +msgid "" +"\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\ " +"\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}" +msgstr "" +"\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\ " +"\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.rz:5 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:5 +msgid "\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\theta} \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\theta} \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.u:3 +msgid "与 ``UAnsatz`` 类中的 U3 的三个参数不同，这里的酉门采用 ``Rz Rx Rz`` 分解，" +msgstr "" +"Unlike the U3 gate in ``UAnsatz``, the decomposition of the unitary gate" +" here is ``Rz Rx Rz``." + +#: of paddle_quantum.mbqc.qobject.Circuit.u:5 +msgid "其分解形式为：" +msgstr "Its decomposition is:" + +#: of paddle_quantum.mbqc.qobject.Circuit.u:7 +msgid "U(\\alpha, \\beta, \\gamma) = Rz(\\gamma) Rx(\\beta) Rz(\\alpha)" +msgstr "U(\\alpha, \\beta, \\gamma) = Rz(\\gamma) Rx(\\beta) Rz(\\alpha)" + +#: of paddle_quantum.mbqc.qobject.Circuit.u:11 +msgid "单比特酉门的三个旋转角度" +msgstr "A list including three rotation angles in the ``Rz Rx Rz`` decomposition." + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:3 +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15:3 +#: paddle_quantum.mbqc.qobject.Circuit.cz:3 +msgid "当 ``which_qubits`` 为 ``[0, 1]`` 时，其矩阵形式为：" +msgstr "If ``which_qubits`` is set to be ``[0, 1]``, the matrix form is:" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:5 +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15:5 +msgid "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\" +" 0 & 0 & 1 & 0 \\end{bmatrix}" +msgstr "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\" +" 0 & 0 & 1 & 0 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:9 +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15:9 +#: paddle_quantum.mbqc.qobject.Circuit.cz:9 +msgid "作用量子门的量子位，其中列表第一个元素为控制位，第二个元素为受控位" +msgstr "" +"A list of qubit indexes to apply quantum gate, with the first element " +"being the control qubit and the second element being the target qubit." + +#: of paddle_quantum.mbqc.qobject.Circuit.cz:5 +msgid "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\" +" 0 & 0 & 0 & -1 \\end{bmatrix}" +msgstr "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\" +" 0 & 0 & 0 & -1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:3 +msgid "与 ``UAnsatz`` 类中的测量不同，除默认的 Z 测量外，此处的测量方式可以由用户自定义，但需要将测量方式与测量比特相对应。" +msgstr "" +"Unlike measurements in class ``UAnsatz``, measurements here can be " +"customized by users, but the input should be consistent with the " +"measurement qubits." + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:7 +msgid "" +"此方法只接受三种输入方式： 1. 不输入任何参数，表示对所有的量子位进行 Z 测量； 2. 输入量子位，但不输入测量基，表示对输入的量子位进行 Z" +" 测量； 3. 输入量子位和对应测量基，表示对输入量子位进行指定的测量。 如果用户希望自定义测量基参数，需要注意输入格式为 ``[angle, " +"plane, domain_s, domain_t]``， 且当前版本的测量平面 ``plane`` 只能支持 ``XY`` 或 ``YZ``。" +msgstr "" +"This method only supports three kinds of input: 1. Calling this method " +"without any argument means setting Z-measurements to all qubits in the " +"circuit model; 2. Inputting a qubit index with no measurement basis means" +" setting Z-measurement on the given qubit; 3. Inputting a qubit index " +"with a measurement basis means measuring the qubit in the given basis." + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:14 +msgid "被测量的量子位" +msgstr "Qubit index to be measured." + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:16 +msgid "测量方式" +msgstr "Measurement basis." + +#: of paddle_quantum.mbqc.qobject.Circuit.is_valid:3 +msgid "我们规定输入的量子电路中，每一个量子位上至少作用一个量子门。" +msgstr "" +"We require that at least one quantum gate acts on each qubit of the " +"circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit.get_circuit +#: paddle_quantum.mbqc.qobject.Circuit.get_measured_qubits +#: paddle_quantum.mbqc.qobject.Circuit.get_width +#: paddle_quantum.mbqc.qobject.Circuit.is_valid +#: paddle_quantum.mbqc.qobject.Circuit.print_circuit_list +msgid "Returns" +msgstr "Returns" + +#: of paddle_quantum.mbqc.qobject.Circuit.is_valid:5 +msgid "量子电路是否符合规定的布尔值" +msgstr "The boolean value of the validity of quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit.get_circuit +#: paddle_quantum.mbqc.qobject.Circuit.get_measured_qubits +#: paddle_quantum.mbqc.qobject.Circuit.get_width +#: paddle_quantum.mbqc.qobject.Circuit.is_valid +#: paddle_quantum.mbqc.qobject.Circuit.print_circuit_list +msgid "Return type" +msgstr "Return type" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_width:3 +msgid "量子电路的宽度" +msgstr "Quantum circuit width." + +#: of paddle_quantum.mbqc.qobject.Circuit.get_circuit:3 +msgid "量子电路列表" +msgstr "A quantum circuit list." + +#: of paddle_quantum.mbqc.qobject.Circuit.get_measured_qubits:3 +msgid "量子电路中测量的比特位列表" +msgstr "Measurement qubit indices in the quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit.print_circuit_list:3 +msgid "用来打印的字符串" +msgstr "String to print." + +#: of paddle_quantum.mbqc.qobject.Circuit.print_circuit_list:6 +msgid "代码示例:" +msgstr "Code example:" + +#: ../../source/paddle_quantum.mbqc.qobject.rst:2 +msgid "paddle\\_quantum.mbqc.qobject" +msgstr "paddle\\_quantum.mbqc.qobject" + +#: of paddle_quantum.mbqc.qobject:1 +msgid "此模块包含量子信息处理的常用对象，如量子态、量子电路、测量模式等。" +msgstr "" +"This module contains common objects for quantum information processing, " +"such as quantum states, quantum circuits, measurement patterns, etc." + +#: of paddle_quantum.mbqc.qobject.Circuit:1 +#: paddle_quantum.mbqc.qobject.Pattern:1 +#: paddle_quantum.mbqc.qobject.Pattern.CommandE:1 +#: paddle_quantum.mbqc.qobject.Pattern.CommandM:1 +#: paddle_quantum.mbqc.qobject.Pattern.CommandS:1 +#: paddle_quantum.mbqc.qobject.Pattern.CommandX:1 +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ:1 +#: paddle_quantum.mbqc.qobject.State:1 +msgid "Bases: :py:class:`object`" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.State:1 +msgid "定义量子态。" +msgstr "Define quantum state." + +#: of paddle_quantum.mbqc.qobject.State:5 +msgid "量子态的列向量" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit paddle_quantum.mbqc.qobject.Pattern +#: paddle_quantum.mbqc.qobject.Pattern.CommandE +#: paddle_quantum.mbqc.qobject.Pattern.CommandM +#: paddle_quantum.mbqc.qobject.Pattern.CommandS +#: paddle_quantum.mbqc.qobject.Pattern.CommandX +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ +#: paddle_quantum.mbqc.qobject.State +msgid "type" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:28 +#: paddle_quantum.mbqc.qobject.State:7 +msgid "Tensor" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.State:11 +msgid "量子态的系统标签列表" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern:15 +#: paddle_quantum.mbqc.qobject.Pattern:21 +#: paddle_quantum.mbqc.qobject.Pattern:27 +#: paddle_quantum.mbqc.qobject.Pattern:33 +#: paddle_quantum.mbqc.qobject.Pattern.CommandE:9 +#: paddle_quantum.mbqc.qobject.Pattern.CommandM:40 +#: paddle_quantum.mbqc.qobject.Pattern.CommandM:46 +#: paddle_quantum.mbqc.qobject.Pattern.CommandS:15 +#: paddle_quantum.mbqc.qobject.Pattern.CommandX:13 +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ:13 +#: paddle_quantum.mbqc.qobject.State:13 +msgid "list" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit:1 +msgid "定义量子电路。" +msgstr "Define quantum circuit." + +#: of paddle_quantum.mbqc.qobject.Circuit:3 +msgid "该类与 ``UAnsatz`` 类似，用户可以仿照 ``UAnsatz`` 电路的调用方式对此类进行实例化，完成电路图的构建。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit:5 +msgid "" +"当前版本仅支持 ``H, X, Y, Z, S, T, Rx, Ry, Rz, Rz_5, U, CNOT, CNOT_15, CZ`` " +"中的量子门以及测量操作。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit:9 +msgid "电路的宽度（比特数）" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit:11 +msgid "int" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:1 +msgid "添加 ``Hadamard`` 门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:3 +#: paddle_quantum.mbqc.qobject.Circuit.rx:3 +#: paddle_quantum.mbqc.qobject.Circuit.ry:3 +#: paddle_quantum.mbqc.qobject.Circuit.rz:3 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:3 +#: paddle_quantum.mbqc.qobject.Circuit.s:3 +#: paddle_quantum.mbqc.qobject.Circuit.t:3 +#: paddle_quantum.mbqc.qobject.Circuit.x:3 +#: paddle_quantum.mbqc.qobject.Circuit.y:3 +#: paddle_quantum.mbqc.qobject.Circuit.z:3 +msgid "其矩阵形式为：" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:5 +msgid "\\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1&1\\\\1&-1 \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15 +#: paddle_quantum.mbqc.qobject.Circuit.cz paddle_quantum.mbqc.qobject.Circuit.h +#: paddle_quantum.mbqc.qobject.Circuit.measure +#: paddle_quantum.mbqc.qobject.Circuit.rx +#: paddle_quantum.mbqc.qobject.Circuit.ry +#: paddle_quantum.mbqc.qobject.Circuit.rz +#: paddle_quantum.mbqc.qobject.Circuit.rz_5 +#: paddle_quantum.mbqc.qobject.Circuit.s paddle_quantum.mbqc.qobject.Circuit.t +#: paddle_quantum.mbqc.qobject.Circuit.u paddle_quantum.mbqc.qobject.Circuit.x +#: paddle_quantum.mbqc.qobject.Circuit.y paddle_quantum.mbqc.qobject.Circuit.z +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.h:9 +#: paddle_quantum.mbqc.qobject.Circuit.rx:11 +#: paddle_quantum.mbqc.qobject.Circuit.ry:11 +#: paddle_quantum.mbqc.qobject.Circuit.rz:11 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:11 +#: paddle_quantum.mbqc.qobject.Circuit.s:9 +#: paddle_quantum.mbqc.qobject.Circuit.t:9 +#: paddle_quantum.mbqc.qobject.Circuit.u:13 +#: paddle_quantum.mbqc.qobject.Circuit.x:9 +#: paddle_quantum.mbqc.qobject.Circuit.y:9 +#: paddle_quantum.mbqc.qobject.Circuit.z:9 +msgid "作用量子门的量子位编号" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:12 +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15:12 +#: paddle_quantum.mbqc.qobject.Circuit.cz:12 +#: paddle_quantum.mbqc.qobject.Circuit.h:12 +#: paddle_quantum.mbqc.qobject.Circuit.rx:14 +#: paddle_quantum.mbqc.qobject.Circuit.ry:14 +#: paddle_quantum.mbqc.qobject.Circuit.rz:14 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:14 +#: paddle_quantum.mbqc.qobject.Circuit.s:12 +#: paddle_quantum.mbqc.qobject.Circuit.t:12 +#: paddle_quantum.mbqc.qobject.Circuit.u:16 +#: paddle_quantum.mbqc.qobject.Circuit.x:12 +#: paddle_quantum.mbqc.qobject.Circuit.y:12 +#: paddle_quantum.mbqc.qobject.Circuit.z:12 +msgid "代码示例：" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.x:1 +msgid "添加 ``Pauli X`` 门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.x:5 +msgid "\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.y:1 +msgid "添加 ``Pauli Y`` 门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.y:5 +msgid "\\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.z:1 +msgid "添加 ``Pauli Z`` 门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.z:5 +msgid "\\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.s:1 +msgid "添加 ``S`` 门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.s:5 +msgid "\\begin{bmatrix} 1&0\\\\0& i \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.t:1 +msgid "添加 ``T`` 门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.t:5 +msgid "\\begin{bmatrix} 1&0\\\\0& e^{i\\pi/ 4} \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.rx:1 +msgid "添加关于 x 轴的旋转门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.rx:5 +msgid "" +"\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -i\\sin\\frac{\\theta}{2} \\\\" +" -i\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.rx:9 +#: paddle_quantum.mbqc.qobject.Circuit.ry:9 +#: paddle_quantum.mbqc.qobject.Circuit.rz:9 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:9 +msgid "旋转角度" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.ry:1 +msgid "添加关于 y 轴的旋转门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.ry:5 +msgid "" +"\\begin{bmatrix} \\cos\\frac{\\theta}{2} & -\\sin\\frac{\\theta}{2} \\\\ " +"\\sin\\frac{\\theta}{2} & \\cos\\frac{\\theta}{2} \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.rz:1 +msgid "添加关于 z 轴的旋转门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.rz:5 +#: paddle_quantum.mbqc.qobject.Circuit.rz_5:5 +msgid "\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i\\theta} \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.rz_5:1 +msgid "添加关于 z 轴的旋转门（该旋转门对应的测量模式由五个量子比特构成）。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.u:1 +msgid "添加单量子比特的任意酉门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.u:3 +msgid "与 ``UAnsatz`` 类中的 U3 的三个参数不同，这里的酉门采用 ``Rz Rx Rz`` 分解，" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.u:5 +msgid "其分解形式为：" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.u:7 +msgid "U(\\alpha, \\beta, \\gamma) = Rz(\\gamma) Rx(\\beta) Rz(\\alpha)" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.u:11 +msgid "单比特酉门的三个旋转角度" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:1 +msgid "添加控制非门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:3 +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15:3 +#: paddle_quantum.mbqc.qobject.Circuit.cz:3 +msgid "当 ``which_qubits`` 为 ``[0, 1]`` 时，其矩阵形式为：" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:5 +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15:5 +msgid "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 \\\\" +" 0 & 0 & 1 & 0 \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot:9 +#: paddle_quantum.mbqc.qobject.Circuit.cnot_15:9 +#: paddle_quantum.mbqc.qobject.Circuit.cz:9 +msgid "作用量子门的量子位，其中列表第一个元素为控制位，第二个元素为受控位" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.cnot_15:1 +msgid "添加控制非门 （该门对应的测量模式由十五个量子比特构成）。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.cz:1 +msgid "添加控制 Z 门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.cz:5 +msgid "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\" +" 0 & 0 & 0 & -1 \\end{bmatrix}" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:1 +msgid "对量子电路输出的量子态进行测量。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:3 +msgid "与 ``UAnsatz`` 类中的测量不同，除默认的 Z 测量外，此处的测量方式可以由用户自定义，但需要将测量方式与测量比特相对应。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:7 +msgid "" +"此方法只接受三种输入方式： 1. 不输入任何参数，表示对所有的量子位进行 Z 测量； 2. 输入量子位，但不输入测量基，表示对输入的量子位进行 Z" +" 测量； 3. 输入量子位和对应测量基，表示对输入量子位进行指定的测量。 如果用户希望自定义测量基参数，需要注意输入格式为 ``[angle, " +"plane, domain_s, domain_t]``， 且当前版本的测量平面 ``plane`` 只能支持 ``XY`` 或 ``YZ``。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:14 +msgid "被测量的量子位" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.measure:16 +msgid "测量方式" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.is_valid:1 +msgid "检查输入的量子电路是否符合规定。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.is_valid:3 +msgid "我们规定输入的量子电路中，每一个量子位上至少作用一个量子门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_circuit +#: paddle_quantum.mbqc.qobject.Circuit.get_measured_qubits +#: paddle_quantum.mbqc.qobject.Circuit.get_width +#: paddle_quantum.mbqc.qobject.Circuit.is_valid +#: paddle_quantum.mbqc.qobject.Circuit.print_circuit_list +msgid "Returns" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.is_valid:5 +msgid "量子电路是否符合规定的布尔值" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_circuit +#: paddle_quantum.mbqc.qobject.Circuit.get_measured_qubits +#: paddle_quantum.mbqc.qobject.Circuit.get_width +#: paddle_quantum.mbqc.qobject.Circuit.is_valid +#: paddle_quantum.mbqc.qobject.Circuit.print_circuit_list +msgid "Return type" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_width:1 +msgid "返回量子电路的宽度。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_width:3 +msgid "量子电路的宽度" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_circuit:1 +msgid "返回量子电路列表。" +msgstr "Return a list of quantum circuits." + +#: of paddle_quantum.mbqc.qobject.Circuit.get_circuit:3 +msgid "量子电路列表" +msgstr "List of quantum circuits." + +#: of paddle_quantum.mbqc.qobject.Circuit.get_measured_qubits:1 +msgid "返回量子电路中测量的比特位。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.get_measured_qubits:3 +msgid "量子电路中测量的比特位列表" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.print_circuit_list:1 +msgid "打印电路图的列表。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.print_circuit_list:3 +msgid "用来打印的字符串" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Circuit.print_circuit_list:6 +#: paddle_quantum.mbqc.qobject.Pattern.print_command_list:3 +msgid "代码示例:" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern:1 +msgid "定义测量模式。" +msgstr "Define measurement pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern:3 +msgid "该测量模式的结构依据文献 [The measurement calculus, arXiv: 0704.1263]。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern:7 +msgid "测量模式的名称" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern:9 +#: paddle_quantum.mbqc.qobject.Pattern.CommandM:34 +msgid "str" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern:13 +msgid "测量模式所有节点列表" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern:19 +msgid "测量模式的输入节点列表" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern:25 +msgid "测量模式的输出节点列表" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern:31 +msgid "测量模式的命令列表" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:1 +msgid "定义纠缠命令类。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:3 +msgid "此处纠缠命令对应作用控制 Z 门。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandE:7 +msgid "作用纠缠命令的两个节点标签构成的列表" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:1 +msgid "定义测量命令类。" +msgstr "Define measurement pattern." + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:3 +msgid "" +"测量命令有五个属性，分别为测量比特的标签 ``which_qubit``，原始的测量角度 ``angle``， 测量平面 ``plane``，域 " +"s 对应的节点标签列表 ``domain_s``，域 t 对应的节点标签列表 ``domain_t``。 设原始角度为 " +":math:`\\alpha`，则考虑域中节点依赖关系后的测量角度 :math:`\\theta` 为：" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:7 +msgid "\\theta = (-1)^s \\times \\alpha + t \\times \\pi" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:13 +msgid "" +"域 s 和域 t 是 MBQC 模型中的概念，分别记录了 Pauli X 算符和 Pauli Z 算符对测量角度产生的影响， " +"二者共同记录了该测量节点对其他节点的测量结果的依赖关系。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:16 +msgid "该命令当前只支持 XY 和 YZ 平面的测量。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:20 +msgid "作用测量命令的节点标签" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:22 +#: paddle_quantum.mbqc.qobject.Pattern.CommandS:9 +#: paddle_quantum.mbqc.qobject.Pattern.CommandX:7 +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ:7 +msgid "any" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:26 +msgid "原始的测量角度" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:32 +msgid "测量平面" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:38 +msgid "域 s 对应的节点标签列表" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandM:44 +msgid "域 t 对应的节点标签列表" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandX:1 +msgid "定义 Pauli X 副产品修正命令类。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandX:5 +msgid "作用修正算符的节点标签" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandS:13 +#: paddle_quantum.mbqc.qobject.Pattern.CommandX:11 +#: paddle_quantum.mbqc.qobject.Pattern.CommandZ:11 +msgid "依赖关系列表" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandZ:1 +msgid "定义 Pauli Z 副产品修正命令。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandZ:5 +msgid "作用修正命令的节点标签" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandS:1 +msgid "定义 \"信号转移\" 命令类。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandS:3 +msgid "\"信号转移\" 是一类特殊的操作，用于消除测量命令对域 t 中节点的依赖关系，在某些情况下对测量模式进行简化。" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.CommandS:7 +msgid "消除依赖关系的测量命令作用的节点标签" +msgstr "" + +#: of paddle_quantum.mbqc.qobject.Pattern.print_command_list:1 +msgid "打印该 ``Pattern`` 类中的命令的信息，便于用户查看。" +msgstr "" + +#~ msgid "Classes" +#~ msgstr "Classes" + +#~ msgid ":obj:`Circuit `\\ \\(width\\)" +#~ msgstr ":obj:`Circuit `\\ \\(width\\)" + +#~ msgid "" +#~ ":obj:`Pattern `\\ " +#~ "\\(name\\, space\\, input\\_\\, output\\_\\, " +#~ "commands\\)" +#~ msgstr "" +#~ ":obj:`Pattern `\\ " +#~ "\\(name\\, space\\, input\\_\\, output\\_\\, " +#~ "commands\\)" + +#~ msgid "" +#~ ":obj:`State `\\ " +#~ "\\(\\[vector\\, system\\]\\)" +#~ msgstr "" +#~ ":obj:`State `\\ " +#~ "\\(\\[vector\\, system\\]\\)" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.simulator.MBQC.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.simulator.MBQC.po new file mode 100644 index 0000000..3a4c1c6 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.simulator.MBQC.po @@ -0,0 +1,482 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2021, Institute for Quantum Computing, Baidu Inc. +# This file is distributed under the same license as the Paddle Quantum +# package. +# FIRST AUTHOR , 2021. +# +msgid "" +msgstr "" +"Project-Id-Version: Paddle Quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2021-08-26 17:14+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.9.1\n" + +#: ../../source/_autosummary/paddle_quantum.mbqc.simulator.MBQC.rst:2 +msgid "paddle\\_quantum.mbqc.simulator.MBQC" +msgstr "paddle\\_quantum.mbqc.simulator.MBQC" + +#: of paddle_quantum.mbqc.simulator.MBQC:1 +msgid "定义基于测量的量子计算模型 ``MBQC`` 类。" +msgstr "" +"Define ``MBQC`` class to implement a measurement-based quantum " +"computation model." + +#: of paddle_quantum.mbqc.simulator.MBQC:3 +msgid "用户可以通过实例化该类来定义自己的 MBQC 模型。" +msgstr "Users can construct an MBQC model by instantiating this class." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.__init__:1 +msgid "MBQC 类的构造函数，用于实例化一个 ``MBQC`` 对象。" +msgstr "MBQC constructor, used to instantiate an ``MBQC`` object." + +#: ../../source/_autosummary/paddle_quantum.mbqc.simulator.MBQC.rst:14 +msgid "Methods" +msgstr "Methods" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid ":obj:`__init__ `\\ \\(\\)" +msgstr ":obj:`__init__ `\\ \\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`correct_byproduct " +"`\\ \\(gate\\, " +"which\\_qubit\\, power\\)" +msgstr "" +":obj:`correct_byproduct " +"`\\ \\(gate\\, " +"which\\_qubit\\, power\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:1 +msgid "对测量后的量子态进行副产品纠正。" +msgstr "Correct byproducts to the quantum state after measurements." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`draw_process `\\ " +"\\(\\[draw\\, pos\\, pause\\_time\\]\\)" +msgstr "" +":obj:`draw_process `\\ " +"\\(\\[draw\\, pos\\, pause\\_time\\]\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.draw_process:1 +msgid "动态过程图绘制，用以实时展示 MBQC 模型的模拟计算过程。" +msgstr "Draw dynamic figures to show the MBQC computation process in real-time." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`get_classical_output " +"`\\ \\(\\)" +msgstr "" +":obj:`get_classical_output " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.get_classical_output:1 +msgid "获取 MBQC 模型运行后的经典输出结果。" +msgstr "Get the classical output of MBQC." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid ":obj:`get_graph `\\ \\(\\)" +msgstr ":obj:`get_graph `\\ \\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.get_graph:1 +msgid "获取图的信息。" +msgstr "Get MBQC graph." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`get_history `\\ " +"\\(\\)" +msgstr "" +":obj:`get_history `\\ " +"\\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.get_history:1 +msgid "获取 MBQC 计算模拟时的中间步骤信息。" +msgstr "Get information about intermediate steps in MBQC." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`get_pattern `\\ " +"\\(\\)" +msgstr "" +":obj:`get_pattern `\\ " +"\\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.get_pattern:1 +msgid "获取测量模式的信息。" +msgstr "Get MBQC pattern." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`get_quantum_output " +"`\\ \\(\\)" +msgstr "" +":obj:`get_quantum_output " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.get_quantum_output:1 +msgid "获取 MBQC 模型运行后的量子态输出结果。" +msgstr "Get the quantum output of MBQC." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`measure `\\ " +"\\(which\\_qubit\\, basis\\_list\\)" +msgstr "" +":obj:`measure `\\ " +"\\(which\\_qubit\\, basis\\_list\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.measure:1 +msgid "以待测量的比特和测量基为输入参数，对该比特进行测量。" +msgstr "Measure the qubit with the given measurement basis." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`run_pattern `\\ " +"\\(\\)" +msgstr "" +":obj:`run_pattern `\\ " +"\\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.run_pattern:1 +msgid "按照设置的测量模式对 MBQC 模型进行模拟。" +msgstr "Run MBQC by the given measurement pattern." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`set_graph `\\ " +"\\(graph\\)" +msgstr "" +":obj:`set_graph `\\ " +"\\(graph\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.set_graph:1 +msgid "设置 MBQC 模型中的图。" +msgstr "Set the underlying graph of MBQC." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`set_input_state " +"`\\ \\(\\[state\\]\\)" +msgstr "" +":obj:`set_input_state " +"`\\ \\(\\[state\\]\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.set_input_state:1 +msgid "设置需要替换的输入量子态。" +msgstr "Set the initial input state." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`set_pattern `\\ " +"\\(pattern\\)" +msgstr "" +":obj:`set_pattern `\\ " +"\\(pattern\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.set_pattern:1 +msgid "设置 MBQC 模型的测量模式。" +msgstr "Set MBQC pattern." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`sum_outcomes `\\ " +"\\(which\\_qubits\\[\\, start\\]\\)" +msgstr "" +":obj:`sum_outcomes `\\ " +"\\(which\\_qubits\\[\\, start\\]\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:1 +msgid "根据输入的量子系统标签，在存储测量结果的字典中找到对应的测量结果，并进行求和。" +msgstr "Find the corresponding qubits' outcomes in the dictionary and sum them up." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`track_progress " +"`\\ \\(\\[track\\]\\)" +msgstr "" +":obj:`track_progress " +"`\\ \\(\\[track\\]\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.track_progress:1 +msgid "显示 MBQC 模型运行进度的开关。" +msgstr "Switch to track the progress bar of MBQC." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1 +msgid "定义维护点列表，用于实例化一个 ``Vertex`` 对象。" +msgstr "Define the vertex class, used to instantiate a ``Vertex`` object." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:3 +msgid "将 MBQC 算法中图的节点分为三类，并进行动态维护。" +msgstr "" +"Divide the vertices of the MBQC graph into three groups and maintain them" +" dynamically." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:5 +msgid "这是内部类，用户不需要直接调用到该类。" +msgstr "This is an internal class, not callable to users." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:9 +msgid "MBQC 算法中图上的全部节点，不随运算而改变" +msgstr "" +"Total vertices in an MBQC graph, the length of this list will not change " +"during calculations." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex +msgid "type" +msgstr "type" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:11 +#: paddle_quantum.mbqc.simulator.MBQC.Vertex:17 +#: paddle_quantum.mbqc.simulator.MBQC.Vertex:23 +#: paddle_quantum.mbqc.simulator.MBQC.Vertex:29 +msgid "list" +msgstr "list" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:15 +msgid "待激活的节点，随着运算的执行而逐渐减少" +msgstr "" +"Vertices to be activated, the length of this list is decreasing during " +"calculations." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:21 +msgid "激活的节点，与当前测量步骤直接相关的节点" +msgstr "Active vertices relevant to the current measurement step." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:27 +msgid "已被测量过的节点，随着运算的执行而逐渐增加" +msgstr "" +"Measured vertices, the length of this list is increasing during " +"calculations." + +#: of paddle_quantum.mbqc.simulator.MBQC.set_graph:3 +msgid "该函数用于将用户自己构造的图传递给 ``MBQC`` 实例。" +msgstr "This function is called to pass the user's graph to an ``MBQC`` instance." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct +#: paddle_quantum.mbqc.simulator.MBQC.draw_process +#: paddle_quantum.mbqc.simulator.MBQC.measure +#: paddle_quantum.mbqc.simulator.MBQC.set_graph +#: paddle_quantum.mbqc.simulator.MBQC.set_input_state +#: paddle_quantum.mbqc.simulator.MBQC.set_pattern +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes +#: paddle_quantum.mbqc.simulator.MBQC.track_progress +msgid "Parameters" +msgstr "Parameters" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_graph:5 +msgid "MBQC 模型中的图，由列表 ``[V, E]`` 给出， 其中 ``V`` 为节点列表，``E`` 为边列表" +msgstr "" +"MBQC graph, denoted by a list ``[V, E]``, where ``V`` is a list of " +"vertices and ``E`` is a list of edges." + +#: of paddle_quantum.mbqc.simulator.MBQC.get_classical_output +#: paddle_quantum.mbqc.simulator.MBQC.get_graph +#: paddle_quantum.mbqc.simulator.MBQC.get_history +#: paddle_quantum.mbqc.simulator.MBQC.get_pattern +#: paddle_quantum.mbqc.simulator.MBQC.get_quantum_output +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes +msgid "Returns" +msgstr "Returns" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_graph:3 +msgid "图" +msgstr "MBQC graph" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_classical_output +#: paddle_quantum.mbqc.simulator.MBQC.get_graph +#: paddle_quantum.mbqc.simulator.MBQC.get_history +#: paddle_quantum.mbqc.simulator.MBQC.get_pattern +#: paddle_quantum.mbqc.simulator.MBQC.get_quantum_output +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes +msgid "Return type" +msgstr "Return type" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_pattern:3 +msgid "该函数用于将用户由电路图翻译得到或自己构造的测量模式传递给 ``MBQC`` 实例。" +msgstr "This function is called to pass the pattern to an ``MBQC`` instance." + +#: of paddle_quantum.mbqc.simulator.MBQC.set_pattern:5 +msgid "输入的 pattern 参数是 ``Pattern`` 类型，其中命令列表为标准 ``EMC`` 命令。" +msgstr "" +"The type of parameter pattern is ``Pattern``, whose commands are in a " +"standard ``EMC`` form." + +#: of paddle_quantum.mbqc.simulator.MBQC.set_pattern:7 +msgid "MBQC 算法对应的测量模式" +msgstr "MBQC pattern." + +#: of paddle_quantum.mbqc.simulator.MBQC.get_pattern:3 +msgid "测量模式" +msgstr "MBQC pattern" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_input_state:5 +msgid "" +"与电路模型不同，MBQC 模型通常默认初始态为加态。如果用户不调用此方法设置初始量子态，则默认为加态。 如果用户以测量模式运行 " +"MBQC，则此处输入量子态的系统标签会被限制为从零开始的自然数，类型为整型。" +msgstr "" +"Unlike the circuit model, the MBQC model usually sets the initial state " +"as a plus state by default. If the user does not call this function to " +"set the initial quantum state, it would be a plus state by default. If " +"the user runs MBQC by a pattern, the system label of the input state will" +" be limited to natural numbers starting from zero and with type 'int'." + +#: of paddle_quantum.mbqc.simulator.MBQC.set_input_state:8 +msgid "需要替换的量子态，默认为加态" +msgstr "Input state (plus state by default)." + +#: of paddle_quantum.mbqc.simulator.MBQC.draw_process:3 +msgid "是否绘制动态过程图的布尔开关" +msgstr "Boolean switch to drawing dynamic figures" + +#: of paddle_quantum.mbqc.simulator.MBQC.draw_process:5 +msgid "" +"节点坐标的字典数据或者内置的坐标选择，内置的坐标选择有： ``True`` 为测量模式自带的坐标，``False`` 为 " +"`spring_layout` 坐标" +msgstr "" +"Dictionary of vertices positions or to use build-in methods to generate " +"positions. The build-in methods are: ``True`` for the self-contained " +"positions in the pattern and ``False`` for the ``spring_layout`` method " +"in ``networkx``." + +#: of paddle_quantum.mbqc.simulator.MBQC.draw_process:8 +msgid "绘制动态过程图时每次更新的停顿时间" +msgstr "Pause time for each update of dynamic figures." + +#: of paddle_quantum.mbqc.simulator.MBQC.track_progress:3 +msgid "``True`` 打开进度条显示功能， ``False`` 关闭进度条显示功能" +msgstr "" +"``True`` means to open the progress bar, and ``False`` means to close the" +" progress bare." + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:5 +msgid "" +"这是用户在实例化 MBQC 类之后最常调用的方法之一，此处我们对单比特测量模拟进行了最大程度的优化， 随着用户对该函数的调用，MBQC " +"类将自动完成激活相关节点、生成所需的图态以及对特定比特进行测量的全过程， " +"并记录测量结果和对应测量后的量子态。用户每调用一次该函数，就完成一次对单比特的测量操作。" +msgstr "" +"This is the most frequently called method after the instantiation of " +"MBQC. Here we optimize simulation of single-qubit measurement to the " +"greatest extent. Once this function is called, MBQC class will " +"automatically complete the whole process of vertices activation, graph " +"state creation, and single-qubit measurement. It will record the outcome " +"and the post-measurement quantum state. Each call of this function will " +"complete one single-qubit measurement operation." + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:9 +msgid "当且仅当用户调用 ``measure`` 类方法时，MBQC 模型才真正进行运算。" +msgstr "" +"MBQC will start the computation process if and only if the user calls the" +" ``measure`` method." + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:11 +msgid "待测量量子比特的系统标签， 可以是 ``str``, ``tuple`` 等任意数据类型，但需要和 MBQC 模型的图上标签匹配" +msgstr "" +"A system label of qubit to be measured, it can be any type of ``str``, " +"``tuple``, etc. (but should be consistent with those in the graph)." + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:14 +msgid "测量基向量构成的列表，列表元素为 ``Tensor`` 类型的列向量" +msgstr "" +"A measurement basis list, with each element being a vector of type " +"``Tensor``." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:12 +#: paddle_quantum.mbqc.simulator.MBQC.measure:17 +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:13 +msgid "代码示例：" +msgstr "Code example:" + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:3 +msgid "在进行副产品纠正操作和定义适应性测量角度时，用户可以调用该方法对特定比特的测量结果求和。" +msgstr "" +"When calculating the adaptive measurements' angles and correcting " +"byproducts, users can call this method to sum measurement outcomes of " +"specific qubits." + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:5 +msgid "需要查找测量结果并求和的比特的系统标签列表" +msgstr "" +"A list of qubit systems labels, of which the outcomes are required to sum" +" up." + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:7 +msgid "对结果进行求和后需要额外相加的整数" +msgstr "An additional integer to sum up." + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:10 +msgid "指定比特的测量结果的和" +msgstr "Summation of specific qubits' outcomes." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:3 +msgid "这是用户在实例化 MBQC 类并完成测量后，经常需要调用的一个方法。" +msgstr "" +"This method is usually called after the instantiation of MBQC class and " +"measurements." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:5 +msgid "``'X'`` 或者 ``'Z'``，分别表示 Pauli X 或 Z 门修正" +msgstr "" +"``'X'`` or ``'Z'``, denoting correction of Pauli X or Pauli Z gate " +"respectively." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:7 +msgid "待操作的量子比特的系统标签，可以是 ``str``, ``tuple`` 等任意数据类型，但需要和 MBQC 中图的标签类型匹配" +msgstr "" +"System label of the qubit to operate, it can be type of ``str``, " +"``tuple``, etc. (be should be consistent with those in the graph)." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:9 +msgid "副产品纠正算符的指数" +msgstr "Exponent of byproduct operator." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:14 +msgid "此处展示的是 MBQC 模型下实现隐形传态的一个例子。" +msgstr "Here is an example of quantum teleportation in MBQC." + +#: of paddle_quantum.mbqc.simulator.MBQC.run_pattern:3 +msgid "该方法必须在 ``set_pattern`` 调用后调用。" +msgstr "This method must be called after ``set_pattern``." + +#: of paddle_quantum.mbqc.simulator.MBQC.get_classical_output:3 +msgid "" +"如果用户输入是测量模式，则返回测量输出节点得到的比特串，与原电路的测量结果相一致，没有被测量的比特位填充 " +"\"？\"，如果用户输入是图，则返回所有节点的测量结果" +msgstr "" +"If the user inputs a pattern, it returns with a bit string obtained from " +"outcomes of output labels, consistent with the result in the circuit " +"model, with those unmeasured filling with \"?\". If the user sets a " +"graph, it returns with all vertices outcomes." + +#: of paddle_quantum.mbqc.simulator.MBQC.get_history:3 +msgid "生成图态、进行测量、纠正副产品后运算结果构成的列表" +msgstr "" +"A list of quantum results obtained after graph state preparation, " +"measurements, and byproduct correction." + +#: of paddle_quantum.mbqc.simulator.MBQC.get_quantum_output:3 +msgid "MBQC 模型运行后的量子态" +msgstr "A quantum state after running MBQC." + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.simulator.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.simulator.po new file mode 100644 index 0000000..5fffc95 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.simulator.po @@ -0,0 +1,840 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2021, Institute for Quantum Computing, Baidu Inc. +# This file is distributed under the same license as the Paddle Quantum +# package. +# FIRST AUTHOR , 2021. +# +msgid "" +msgstr "" +"Project-Id-Version: Paddle Quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.mbqc.simulator.rst:2 +msgid "paddle\\_quantum.mbqc.simulator" +msgstr "paddle\\_quantum.mbqc.simulator" + +#: of paddle_quantum.mbqc.simulator.MBQC:1 +msgid "定义基于测量的量子计算模型 ``MBQC`` 类。" +msgstr "" +"Define ``MBQC`` class to implement a measurement-based quantum " +"computation model." + +#: of paddle_quantum.mbqc.simulator.MBQC:3 +msgid "用户可以通过实例化该类来定义自己的 MBQC 模型。" +msgstr "Users can construct an MBQC model by instantiating this class." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.__init__:1 +msgid "MBQC 类的构造函数，用于实例化一个 ``MBQC`` 对象。" +msgstr "MBQC constructor, used to instantiate an ``MBQC`` object." + +#: ../../source/_autosummary/paddle_quantum.mbqc.simulator.MBQC.rst:14 +msgid "Methods" +msgstr "Methods" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid ":obj:`__init__ `\\ \\(\\)" +msgstr ":obj:`__init__ `\\ \\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`correct_byproduct " +"`\\ \\(gate\\, " +"which\\_qubit\\, power\\)" +msgstr "" +":obj:`correct_byproduct " +"`\\ \\(gate\\, " +"which\\_qubit\\, power\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:1 +msgid "对测量后的量子态进行副产品纠正。" +msgstr "Correct byproducts to the quantum state after measurements." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`draw_process `\\ " +"\\(\\[draw\\, pos\\, pause\\_time\\]\\)" +msgstr "" +":obj:`draw_process `\\ " +"\\(\\[draw\\, pos\\, pause\\_time\\]\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.draw_process:1 +msgid "动态过程图绘制，用以实时展示 MBQC 模型的模拟计算过程。" +msgstr "Draw dynamic figures to show the MBQC computation process in real-time." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`get_classical_output " +"`\\ \\(\\)" +msgstr "" +":obj:`get_classical_output " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.get_classical_output:1 +msgid "获取 MBQC 模型运行后的经典输出结果。" +msgstr "Get the classical output of MBQC." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid ":obj:`get_graph `\\ \\(\\)" +msgstr ":obj:`get_graph `\\ \\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.get_graph:1 +msgid "获取图的信息。" +msgstr "Get MBQC graph." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`get_history `\\ " +"\\(\\)" +msgstr "" +":obj:`get_history `\\ " +"\\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.get_history:1 +msgid "获取 MBQC 计算模拟时的中间步骤信息。" +msgstr "Get information about intermediate steps in MBQC." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`get_pattern `\\ " +"\\(\\)" +msgstr "" +":obj:`get_pattern `\\ " +"\\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.get_pattern:1 +msgid "获取测量模式的信息。" +msgstr "Get MBQC pattern." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`get_quantum_output " +"`\\ \\(\\)" +msgstr "" +":obj:`get_quantum_output " +"`\\ \\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.get_quantum_output:1 +msgid "获取 MBQC 模型运行后的量子态输出结果。" +msgstr "Get the quantum output of MBQC." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`measure `\\ " +"\\(which\\_qubit\\, basis\\_list\\)" +msgstr "" +":obj:`measure `\\ " +"\\(which\\_qubit\\, basis\\_list\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.measure:1 +msgid "以待测量的比特和测量基为输入参数，对该比特进行测量。" +msgstr "Measure the qubit with the given measurement basis." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`run_pattern `\\ " +"\\(\\)" +msgstr "" +":obj:`run_pattern `\\ " +"\\(\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.run_pattern:1 +msgid "按照设置的测量模式对 MBQC 模型进行模拟。" +msgstr "Run MBQC by the given measurement pattern." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`set_graph `\\ " +"\\(graph\\)" +msgstr "" +":obj:`set_graph `\\ " +"\\(graph\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.set_graph:1 +msgid "设置 MBQC 模型中的图。" +msgstr "Set the underlying graph of MBQC." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`set_input_state " +"`\\ \\(\\[state\\]\\)" +msgstr "" +":obj:`set_input_state " +"`\\ \\(\\[state\\]\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.set_input_state:1 +msgid "设置需要替换的输入量子态。" +msgstr "Set the initial input state." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`set_pattern `\\ " +"\\(pattern\\)" +msgstr "" +":obj:`set_pattern `\\ " +"\\(pattern\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.set_pattern:1 +msgid "设置 MBQC 模型的测量模式。" +msgstr "Set MBQC pattern." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`sum_outcomes `\\ " +"\\(which\\_qubits\\[\\, start\\]\\)" +msgstr "" +":obj:`sum_outcomes `\\ " +"\\(which\\_qubits\\[\\, start\\]\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:1 +msgid "根据输入的量子系统标签，在存储测量结果的字典中找到对应的测量结果，并进行求和。" +msgstr "Find the corresponding qubits' outcomes in the dictionary and sum them up." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +msgid "" +":obj:`track_progress " +"`\\ \\(\\[track\\]\\)" +msgstr "" +":obj:`track_progress " +"`\\ \\(\\[track\\]\\)" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1::1 +#: paddle_quantum.mbqc.simulator.MBQC.track_progress:1 +msgid "显示 MBQC 模型运行进度的开关。" +msgstr "Switch to track the progress bar of MBQC." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1 +msgid "定义维护点列表，用于实例化一个 ``Vertex`` 对象。" +msgstr "Define the vertex class, used to instantiate a ``Vertex`` object." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:3 +msgid "将 MBQC 算法中图的节点分为三类，并进行动态维护。" +msgstr "" +"Divide the vertices of the MBQC graph into three groups and maintain them" +" dynamically." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:5 +msgid "这是内部类，用户不需要直接调用到该类。" +msgstr "This is an internal class, not callable to users." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:9 +msgid "MBQC 算法中图上的全部节点，不随运算而改变" +msgstr "" +"Total vertices in an MBQC graph, the length of this list will not change " +"during calculations." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex +msgid "type" +msgstr "type" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:11 +#: paddle_quantum.mbqc.simulator.MBQC.Vertex:17 +#: paddle_quantum.mbqc.simulator.MBQC.Vertex:23 +#: paddle_quantum.mbqc.simulator.MBQC.Vertex:29 +msgid "list" +msgstr "list" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:15 +msgid "待激活的节点，随着运算的执行而逐渐减少" +msgstr "" +"Vertices to be activated, the length of this list is decreasing during " +"calculations." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:21 +msgid "激活的节点，与当前测量步骤直接相关的节点" +msgstr "Active vertices relevant to the current measurement step." + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:27 +msgid "已被测量过的节点，随着运算的执行而逐渐增加" +msgstr "" +"Measured vertices, the length of this list is increasing during " +"calculations." + +#: of paddle_quantum.mbqc.simulator.MBQC.set_graph:3 +msgid "该函数用于将用户自己构造的图传递给 ``MBQC`` 实例。" +msgstr "This function is called to pass the user's graph to an ``MBQC`` instance." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct +#: paddle_quantum.mbqc.simulator.MBQC.draw_process +#: paddle_quantum.mbqc.simulator.MBQC.measure +#: paddle_quantum.mbqc.simulator.MBQC.set_graph +#: paddle_quantum.mbqc.simulator.MBQC.set_input_state +#: paddle_quantum.mbqc.simulator.MBQC.set_pattern +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes +#: paddle_quantum.mbqc.simulator.MBQC.track_progress +msgid "Parameters" +msgstr "Parameters" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_graph:5 +msgid "MBQC 模型中的图，由列表 ``[V, E]`` 给出， 其中 ``V`` 为节点列表，``E`` 为边列表" +msgstr "" +"MBQC graph, denoted by a list ``[V, E]``, where ``V`` is a list of " +"vertices and ``E`` is a list of edges." + +#: of paddle_quantum.mbqc.simulator.MBQC.get_classical_output +#: paddle_quantum.mbqc.simulator.MBQC.get_graph +#: paddle_quantum.mbqc.simulator.MBQC.get_history +#: paddle_quantum.mbqc.simulator.MBQC.get_pattern +#: paddle_quantum.mbqc.simulator.MBQC.get_quantum_output +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes +msgid "Returns" +msgstr "Returns" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_graph:3 +msgid "图" +msgstr "MBQC graph" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_classical_output +#: paddle_quantum.mbqc.simulator.MBQC.get_graph +#: paddle_quantum.mbqc.simulator.MBQC.get_history +#: paddle_quantum.mbqc.simulator.MBQC.get_pattern +#: paddle_quantum.mbqc.simulator.MBQC.get_quantum_output +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes +msgid "Return type" +msgstr "Return type" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_pattern:3 +msgid "该函数用于将用户由电路图翻译得到或自己构造的测量模式传递给 ``MBQC`` 实例。" +msgstr "This function is called to pass the pattern to an ``MBQC`` instance." + +#: of paddle_quantum.mbqc.simulator.MBQC.set_pattern:5 +msgid "输入的 pattern 参数是 ``Pattern`` 类型，其中命令列表为标准 ``EMC`` 命令。" +msgstr "" +"The type of parameter pattern is ``Pattern``, whose commands are in a " +"standard ``EMC`` form." + +#: of paddle_quantum.mbqc.simulator.MBQC.set_pattern:7 +msgid "MBQC 算法对应的测量模式" +msgstr "MBQC pattern." + +#: of paddle_quantum.mbqc.simulator.MBQC.get_pattern:3 +msgid "测量模式" +msgstr "MBQC pattern" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_input_state:5 +msgid "" +"与电路模型不同，MBQC 模型通常默认初始态为加态。如果用户不调用此方法设置初始量子态，则默认为加态。 如果用户以测量模式运行 " +"MBQC，则此处输入量子态的系统标签会被限制为从零开始的自然数，类型为整型。" +msgstr "" +"Unlike the circuit model, the MBQC model usually sets the initial state " +"as a plus state by default. If the user does not call this function to " +"set the initial quantum state, it would be a plus state by default. If " +"the user runs MBQC by a pattern, the system label of the input state will" +" be limited to natural numbers starting from zero and with type 'int'." + +#: of paddle_quantum.mbqc.simulator.MBQC.set_input_state:8 +msgid "需要替换的量子态，默认为加态" +msgstr "Input state (plus state by default)." + +#: of paddle_quantum.mbqc.simulator.MBQC.draw_process:3 +msgid "是否绘制动态过程图的布尔开关" +msgstr "Boolean switch to drawing dynamic figures" + +#: of paddle_quantum.mbqc.simulator.MBQC.draw_process:5 +msgid "" +"节点坐标的字典数据或者内置的坐标选择，内置的坐标选择有： ``True`` 为测量模式自带的坐标，``False`` 为 " +"`spring_layout` 坐标" +msgstr "" +"Dictionary of vertices positions or to use build-in methods to generate " +"positions. The build-in methods are: ``True`` for the self-contained " +"positions in the pattern and ``False`` for the ``spring_layout`` method " +"in ``networkx``." + +#: of paddle_quantum.mbqc.simulator.MBQC.draw_process:8 +msgid "绘制动态过程图时每次更新的停顿时间" +msgstr "Pause time for each update of dynamic figures." + +#: of paddle_quantum.mbqc.simulator.MBQC.track_progress:3 +msgid "``True`` 打开进度条显示功能， ``False`` 关闭进度条显示功能" +msgstr "" +"``True`` means to open the progress bar, and ``False`` means to close the" +" progress bare." + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:5 +msgid "" +"这是用户在实例化 MBQC 类之后最常调用的方法之一，此处我们对单比特测量模拟进行了最大程度的优化， 随着用户对该函数的调用，MBQC " +"类将自动完成激活相关节点、生成所需的图态以及对特定比特进行测量的全过程， " +"并记录测量结果和对应测量后的量子态。用户每调用一次该函数，就完成一次对单比特的测量操作。" +msgstr "" +"This is the most frequently called method after the instantiation of " +"MBQC. Here we optimize simulation of single-qubit measurement to the " +"greatest extent. Once this function is called, MBQC class will " +"automatically complete the whole process of vertices activation, graph " +"state creation, and single-qubit measurement. It will record the outcome " +"and the post-measurement quantum state. Each call of this function will " +"complete one single-qubit measurement operation." + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:9 +msgid "当且仅当用户调用 ``measure`` 类方法时，MBQC 模型才真正进行运算。" +msgstr "" +"MBQC will start the computation process if and only if the user calls the" +" ``measure`` method." + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:11 +msgid "待测量量子比特的系统标签， 可以是 ``str``, ``tuple`` 等任意数据类型，但需要和 MBQC 模型的图上标签匹配" +msgstr "" +"A system label of qubit to be measured, it can be any type of ``str``, " +"``tuple``, etc. (but should be consistent with those in the graph)." + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:14 +msgid "测量基向量构成的列表，列表元素为 ``Tensor`` 类型的列向量" +msgstr "" +"A measurement basis list, with each element being a vector of type " +"``Tensor``." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:12 +#: paddle_quantum.mbqc.simulator.MBQC.measure:17 +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:13 +msgid "代码示例：" +msgstr "Code example:" + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:3 +msgid "在进行副产品纠正操作和定义适应性测量角度时，用户可以调用该方法对特定比特的测量结果求和。" +msgstr "" +"When calculating the adaptive measurements' angles and correcting " +"byproducts, users can call this method to sum measurement outcomes of " +"specific qubits." + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:5 +msgid "需要查找测量结果并求和的比特的系统标签列表" +msgstr "" +"A list of qubit systems labels, of which the outcomes are required to sum" +" up." + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:7 +msgid "对结果进行求和后需要额外相加的整数" +msgstr "An additional integer to sum up." + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:10 +msgid "指定比特的测量结果的和" +msgstr "Summation of specific qubits' outcomes." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:3 +msgid "这是用户在实例化 MBQC 类并完成测量后，经常需要调用的一个方法。" +msgstr "" +"This method is usually called after the instantiation of MBQC class and " +"measurements." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:5 +msgid "``'X'`` 或者 ``'Z'``，分别表示 Pauli X 或 Z 门修正" +msgstr "" +"``'X'`` or ``'Z'``, denoting correction of Pauli X or Pauli Z gate " +"respectively." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:7 +msgid "待操作的量子比特的系统标签，可以是 ``str``, ``tuple`` 等任意数据类型，但需要和 MBQC 中图的标签类型匹配" +msgstr "" +"System label of the qubit to operate, it can be type of ``str``, " +"``tuple``, etc. (be should be consistent with those in the graph)." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:9 +msgid "副产品纠正算符的指数" +msgstr "Exponent of byproduct operator." + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:14 +msgid "此处展示的是 MBQC 模型下实现隐形传态的一个例子。" +msgstr "Here is an example of quantum teleportation in MBQC." + +#: of paddle_quantum.mbqc.simulator.MBQC.run_pattern:3 +msgid "该方法必须在 ``set_pattern`` 调用后调用。" +msgstr "This method must be called after ``set_pattern``." + +#: of paddle_quantum.mbqc.simulator.MBQC.get_classical_output:3 +msgid "" +"如果用户输入是测量模式，则返回测量输出节点得到的比特串，与原电路的测量结果相一致，没有被测量的比特位填充 " +"\"？\"，如果用户输入是图，则返回所有节点的测量结果" +msgstr "" +"If the user inputs a pattern, it returns with a bit string obtained from " +"outcomes of output labels, consistent with the result in the circuit " +"model, with those unmeasured filling with \"?\". If the user sets a " +"graph, it returns with all vertices outcomes." + +#: of paddle_quantum.mbqc.simulator.MBQC.get_history:3 +msgid "生成图态、进行测量、纠正副产品后运算结果构成的列表" +msgstr "" +"A list of quantum results obtained after graph state preparation, " +"measurements, and byproduct correction." + +#: of paddle_quantum.mbqc.simulator.MBQC.get_quantum_output:3 +msgid "MBQC 模型运行后的量子态" +msgstr "A quantum state after running MBQC." + +#: of paddle_quantum.mbqc.simulator:1 +msgid "此模块包含构造 MBQC 模型的常用类和配套的运算模拟工具。" +msgstr "" +"This module contains a frequently used class and accompanying simulation " +"tools for constructing MBQC models." + +#: of paddle_quantum.mbqc.simulator.MBQC:1 +#: paddle_quantum.mbqc.simulator.MBQC.Vertex:1 +msgid "Bases: :py:class:`object`" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC:1 +msgid "定义基于测量的量子计算模型 ``MBQC`` 类。" +msgstr "" +"Define ``MBQC`` class to implement a measurement-based quantum " +"computation model." + +#: of paddle_quantum.mbqc.simulator.MBQC:3 +msgid "用户可以通过实例化该类来定义自己的 MBQC 模型。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:1 +msgid "定义维护点列表，用于实例化一个 ``Vertex`` 对象。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:3 +msgid "将 MBQC 算法中图的节点分为三类，并进行动态维护。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:5 +msgid "这是内部类，用户不需要直接调用到该类。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:9 +msgid "MBQC 算法中图上的全部节点，不随运算而改变" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex +msgid "type" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:11 +#: paddle_quantum.mbqc.simulator.MBQC.Vertex:17 +#: paddle_quantum.mbqc.simulator.MBQC.Vertex:23 +#: paddle_quantum.mbqc.simulator.MBQC.Vertex:29 +msgid "list" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:15 +msgid "待激活的节点，随着运算的执行而逐渐减少" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:21 +msgid "激活的节点，与当前测量步骤直接相关的节点" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.Vertex:27 +msgid "已被测量过的节点，随着运算的执行而逐渐增加" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_graph:1 +msgid "设置 MBQC 模型中的图。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_graph:3 +msgid "该函数用于将用户自己构造的图传递给 ``MBQC`` 实例。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct +#: paddle_quantum.mbqc.simulator.MBQC.draw_process +#: paddle_quantum.mbqc.simulator.MBQC.measure +#: paddle_quantum.mbqc.simulator.MBQC.set_graph +#: paddle_quantum.mbqc.simulator.MBQC.set_input_state +#: paddle_quantum.mbqc.simulator.MBQC.set_pattern +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes +#: paddle_quantum.mbqc.simulator.MBQC.track_progress +#: paddle_quantum.mbqc.simulator.simulate_by_mbqc +msgid "Parameters" +msgstr "Parameters" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_graph:5 +msgid "MBQC 模型中的图，由列表 ``[V, E]`` 给出， 其中 ``V`` 为节点列表，``E`` 为边列表" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_graph:1 +msgid "获取图的信息。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_classical_output +#: paddle_quantum.mbqc.simulator.MBQC.get_graph +#: paddle_quantum.mbqc.simulator.MBQC.get_history +#: paddle_quantum.mbqc.simulator.MBQC.get_pattern +#: paddle_quantum.mbqc.simulator.MBQC.get_quantum_output +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes +#: paddle_quantum.mbqc.simulator.simulate_by_mbqc +msgid "Returns" +msgstr "Returns" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_graph:3 +msgid "图" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_classical_output +#: paddle_quantum.mbqc.simulator.MBQC.get_graph +#: paddle_quantum.mbqc.simulator.MBQC.get_history +#: paddle_quantum.mbqc.simulator.MBQC.get_pattern +#: paddle_quantum.mbqc.simulator.MBQC.get_quantum_output +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes +#: paddle_quantum.mbqc.simulator.simulate_by_mbqc +msgid "Return type" +msgstr "Return type" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_pattern:1 +msgid "设置 MBQC 模型的测量模式。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_pattern:3 +msgid "该函数用于将用户由电路图翻译得到或自己构造的测量模式传递给 ``MBQC`` 实例。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_pattern:5 +msgid "输入的 pattern 参数是 ``Pattern`` 类型，其中命令列表为标准 ``EMC`` 命令。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_pattern:7 +msgid "MBQC 算法对应的测量模式" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_pattern:1 +msgid "获取测量模式的信息。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_pattern:3 +msgid "测量模式" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_input_state:1 +msgid "设置需要替换的输入量子态。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_input_state:5 +msgid "" +"与电路模型不同，MBQC 模型通常默认初始态为加态。如果用户不调用此方法设置初始量子态，则默认为加态。 如果用户以测量模式运行 " +"MBQC，则此处输入量子态的系统标签会被限制为从零开始的自然数，类型为整型。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.set_input_state:8 +msgid "需要替换的量子态，默认为加态" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.draw_process:1 +msgid "动态过程图绘制，用以实时展示 MBQC 模型的模拟计算过程。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.draw_process:3 +msgid "是否绘制动态过程图的布尔开关" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.draw_process:5 +msgid "" +"节点坐标的字典数据或者内置的坐标选择，内置的坐标选择有： ``True`` 为测量模式自带的坐标，``False`` 为 " +"`spring_layout` 坐标" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.draw_process:8 +msgid "绘制动态过程图时每次更新的停顿时间" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.track_progress:1 +msgid "显示 MBQC 模型运行进度的开关。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.track_progress:3 +msgid "``True`` 打开进度条显示功能， ``False`` 关闭进度条显示功能" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:1 +msgid "以待测量的比特和测量基为输入参数，对该比特进行测量。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:5 +msgid "" +"这是用户在实例化 MBQC 类之后最常调用的方法之一，此处我们对单比特测量模拟进行了最大程度的优化， 随着用户对该函数的调用，MBQC " +"类将自动完成激活相关节点、生成所需的图态以及对特定比特进行测量的全过程， " +"并记录测量结果和对应测量后的量子态。用户每调用一次该函数，就完成一次对单比特的测量操作。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:9 +msgid "当且仅当用户调用 ``measure`` 类方法时，MBQC 模型才真正进行运算。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:11 +msgid "待测量量子比特的系统标签， 可以是 ``str``, ``tuple`` 等任意数据类型，但需要和 MBQC 模型的图上标签匹配" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.measure:14 +msgid "测量基向量构成的列表，列表元素为 ``Tensor`` 类型的列向量" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:12 +#: paddle_quantum.mbqc.simulator.MBQC.measure:17 +#: paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:13 +msgid "代码示例：" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:1 +msgid "根据输入的量子系统标签，在存储测量结果的字典中找到对应的测量结果，并进行求和。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:3 +msgid "在进行副产品纠正操作和定义适应性测量角度时，用户可以调用该方法对特定比特的测量结果求和。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:5 +msgid "需要查找测量结果并求和的比特的系统标签列表" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:7 +msgid "对结果进行求和后需要额外相加的整数" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.sum_outcomes:10 +msgid "指定比特的测量结果的和" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:1 +msgid "对测量后的量子态进行副产品纠正。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:3 +msgid "这是用户在实例化 MBQC 类并完成测量后，经常需要调用的一个方法。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:5 +msgid "``'X'`` 或者 ``'Z'``，分别表示 Pauli X 或 Z 门修正" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:7 +msgid "待操作的量子比特的系统标签，可以是 ``str``, ``tuple`` 等任意数据类型，但需要和 MBQC 中图的标签类型匹配" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:9 +msgid "副产品纠正算符的指数" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.correct_byproduct:14 +msgid "此处展示的是 MBQC 模型下实现隐形传态的一个例子。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.run_pattern:1 +msgid "按照设置的测量模式对 MBQC 模型进行模拟。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.run_pattern:3 +msgid "该方法必须在 ``set_pattern`` 调用后调用。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_classical_output:1 +msgid "获取 MBQC 模型运行后的经典输出结果。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_classical_output:3 +msgid "" +"如果用户输入是测量模式，则返回测量输出节点得到的比特串，与原电路的测量结果相一致，没有被测量的比特位填充 " +"\"？\"，如果用户输入是图，则返回所有节点的测量结果" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_history:1 +msgid "获取 MBQC 计算模拟时的中间步骤信息。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_history:3 +msgid "生成图态、进行测量、纠正副产品后运算结果构成的列表" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_quantum_output:1 +msgid "获取 MBQC 模型运行后的量子态输出结果。" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.MBQC.get_quantum_output:3 +msgid "MBQC 模型运行后的量子态" +msgstr "" + +#: of paddle_quantum.mbqc.simulator.simulate_by_mbqc:1 +msgid "使用等价的 MBQC 模型模拟量子电路。" +msgstr "Simulate quantum circuit model with its MBQC equivalent." + +#: of paddle_quantum.mbqc.simulator.simulate_by_mbqc:3 +msgid "该函数通过将量子电路转化为等价的 MBQC 模型并运行，从而获得等价于原始量子电路的输出结果。" +msgstr "" +"This function translates a quantum circuit to its MBQC equivalent and " +"runs it to obtain results." + +#: of paddle_quantum.mbqc.simulator.simulate_by_mbqc:7 +msgid "" +"与 ``UAnsatz`` 不同，此处输入的 ``circuit`` 参数包含了测量操作。 另，MBQC " +"模型默认初始态为加态，因此，如果用户不输入参数 ``input_state`` 设置初始量子态，则默认为加态。" +msgstr "" +"Unlike the ``UAnsatz``, the ``circuit`` parameter includes measurements " +"here.In addition, the initial state of MBQC model is plus state by " +"default" + +#: of paddle_quantum.mbqc.simulator.simulate_by_mbqc:10 +msgid "量子电路图" +msgstr "Quantum circuit." + +#: of paddle_quantum.mbqc.simulator.simulate_by_mbqc:12 +msgid "量子电路的初始量子态，默认为 :math:`|+\\rangle` 态" +msgstr "Initial quantum state, :math:`|+\\rangle` by default" + +#: of paddle_quantum.mbqc.simulator.simulate_by_mbqc:15 +msgid "包含如下两个元素: - str: 经典输出 - State: 量子输出" +msgstr "" +"Contains two elements: - str: Classical output. - State: Quantum " +"output." + +#~ msgid "包含如下两个元素:" +#~ msgstr "Contains two elements: " + +#~ msgid "str: 经典输出" +#~ msgstr "- str: Classical output." + +#~ msgid "State: 量子输出" +#~ msgstr "State: Quantum output" + +#~ msgid "Functions" +#~ msgstr "Functions" + +#~ msgid "" +#~ ":obj:`sample_by_mbqc " +#~ "`\\ " +#~ "\\(circuit\\[\\, input\\_state\\, plot\\, ...\\]\\)" +#~ msgstr "" +#~ ":obj:`sample_by_mbqc " +#~ "`\\ " +#~ "\\(circuit\\[\\, input\\_state\\, plot\\, ...\\]\\)" + +#~ msgid "将 MBQC 模型重复运行多次，获得经典结果的统计分布。" +#~ msgstr "" +#~ "Repeatedly running several times to " +#~ "obtain a statistical distribution of " +#~ "classical results." + +#~ msgid "" +#~ ":obj:`simulate_by_mbqc " +#~ "`\\ " +#~ "\\(circuit\\[\\, input\\_state\\]\\)" +#~ msgstr "" +#~ ":obj:`simulate_by_mbqc " +#~ "`\\ " +#~ "\\(circuit\\[\\, input\\_state\\]\\)" + +#~ msgid "Classes" +#~ msgstr "Classes" + +#~ msgid ":obj:`MBQC `\\ \\(\\)" +#~ msgstr ":obj:`MBQC `\\ \\(\\)" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.transpiler.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.transpiler.po new file mode 100644 index 0000000..3ea10ad --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.transpiler.po @@ -0,0 +1,67 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2021, Institute for Quantum Computing, Baidu Inc. +# This file is distributed under the same license as the Paddle Quantum +# package. +# FIRST AUTHOR , 2021. +# +msgid "" +msgstr "" +"Project-Id-Version: Paddle Quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.mbqc.transpiler.rst:2 +msgid "paddle\\_quantum.mbqc.transpiler" +msgstr "paddle\\_quantum.mbqc.transpiler" + +#: of paddle_quantum.mbqc.transpiler:1 +msgid "此模块包含电路模型和 MBQC 测量模式的转义工具。" +msgstr "" +"This module ontains tools for transpiling circuits to measurement " +"patterns." + +#: of paddle_quantum.mbqc.transpiler.transpile:1 +msgid "将输入的量子电路翻译为等价的测量模式。" +msgstr "Translate quantum circuit to its MBQC equivalent." + +#: of paddle_quantum.mbqc.transpiler.transpile +msgid "Parameters" +msgstr "Parameters" + +#: of paddle_quantum.mbqc.transpiler.transpile:3 +msgid "量子电路，包含可能的测量部分" +msgstr "Quantum circuit, including measurements." + +#: of paddle_quantum.mbqc.transpiler.transpile:5 +msgid "是否显示翻译进度条的开关" +msgstr "Switch to show the translation progress bar." + +#: of paddle_quantum.mbqc.transpiler.transpile +msgid "Returns" +msgstr "Returns" + +#: of paddle_quantum.mbqc.transpiler.transpile:8 +msgid "等价的测量模式" +msgstr "Equivalent pattern in MBQC." + +#: of paddle_quantum.mbqc.transpiler.transpile +msgid "Return type" +msgstr "Return type" + +#~ msgid "Functions" +#~ msgstr "Functions" + +#~ msgid "" +#~ ":obj:`transpile `\\" +#~ " \\(circuit\\[\\, track\\]\\)" +#~ msgstr "" +#~ ":obj:`transpile `\\" +#~ " \\(circuit\\[\\, track\\]\\)" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.utils.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.utils.po new file mode 100644 index 0000000..65e0f09 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.mbqc.utils.po @@ -0,0 +1,853 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2021, Institute for Quantum Computing, Baidu Inc. +# This file is distributed under the same license as the Paddle Quantum +# package. +# FIRST AUTHOR , 2021. +# +msgid "" +msgstr "" +"Project-Id-Version: Paddle Quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.mbqc.utils.rst:2 +msgid "paddle\\_quantum.mbqc.utils" +msgstr "paddle\\_quantum.mbqc.utils" + +#: of paddle_quantum.mbqc.utils:1 +msgid "此模块包含计算所需的各种常用类和函数。" +msgstr "" +"This module contains various common classes and functions used for " +"computation." + +#: of paddle_quantum.mbqc.utils.plus_state:1 +msgid "定义加态。" +msgstr "Define plus state." + +#: of paddle_quantum.mbqc.utils.cnot_gate:3 paddle_quantum.mbqc.utils.cz_gate:3 +#: paddle_quantum.mbqc.utils.h_gate:3 paddle_quantum.mbqc.utils.minus_state:3 +#: paddle_quantum.mbqc.utils.one_state:3 paddle_quantum.mbqc.utils.plus_state:3 +#: paddle_quantum.mbqc.utils.s_gate:3 paddle_quantum.mbqc.utils.swap_gate:3 +#: paddle_quantum.mbqc.utils.t_gate:3 paddle_quantum.mbqc.utils.zero_state:3 +msgid "其矩阵形式为：" +msgstr "The matrix form is:" + +#: of paddle_quantum.mbqc.utils.plus_state:5 +msgid "\\frac{1}{\\sqrt{2}} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix}" +msgstr "\\frac{1}{\\sqrt{2}} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.basis paddle_quantum.mbqc.utils.cnot_gate +#: paddle_quantum.mbqc.utils.cz_gate paddle_quantum.mbqc.utils.div_str_to_float +#: paddle_quantum.mbqc.utils.h_gate paddle_quantum.mbqc.utils.int_to_div_str +#: paddle_quantum.mbqc.utils.kron paddle_quantum.mbqc.utils.minus_state +#: paddle_quantum.mbqc.utils.one_state paddle_quantum.mbqc.utils.pauli_gate +#: paddle_quantum.mbqc.utils.permute_systems +#: paddle_quantum.mbqc.utils.permute_to_front +#: paddle_quantum.mbqc.utils.plus_state +#: paddle_quantum.mbqc.utils.random_state_vector +#: paddle_quantum.mbqc.utils.read_running_data +#: paddle_quantum.mbqc.utils.rotation_gate paddle_quantum.mbqc.utils.s_gate +#: paddle_quantum.mbqc.utils.swap_gate paddle_quantum.mbqc.utils.t_gate +#: paddle_quantum.mbqc.utils.to_projector paddle_quantum.mbqc.utils.zero_state +msgid "Returns" +msgstr "Returns" + +#: of paddle_quantum.mbqc.utils.plus_state:9 +msgid "加态对应的 ``Tensor`` 形式" +msgstr "The ``Tensor`` form of plus state." + +#: of paddle_quantum.mbqc.utils.basis paddle_quantum.mbqc.utils.cnot_gate +#: paddle_quantum.mbqc.utils.cz_gate paddle_quantum.mbqc.utils.div_str_to_float +#: paddle_quantum.mbqc.utils.h_gate paddle_quantum.mbqc.utils.int_to_div_str +#: paddle_quantum.mbqc.utils.kron paddle_quantum.mbqc.utils.minus_state +#: paddle_quantum.mbqc.utils.one_state paddle_quantum.mbqc.utils.pauli_gate +#: paddle_quantum.mbqc.utils.permute_systems +#: paddle_quantum.mbqc.utils.permute_to_front +#: paddle_quantum.mbqc.utils.plus_state +#: paddle_quantum.mbqc.utils.random_state_vector +#: paddle_quantum.mbqc.utils.read_running_data +#: paddle_quantum.mbqc.utils.rotation_gate paddle_quantum.mbqc.utils.s_gate +#: paddle_quantum.mbqc.utils.swap_gate paddle_quantum.mbqc.utils.t_gate +#: paddle_quantum.mbqc.utils.to_projector paddle_quantum.mbqc.utils.zero_state +msgid "Return type" +msgstr "Return type" + +#: of paddle_quantum.mbqc.utils.basis:22 paddle_quantum.mbqc.utils.cnot_gate:12 +#: paddle_quantum.mbqc.utils.cz_gate:12 +#: paddle_quantum.mbqc.utils.div_str_to_float:11 +#: paddle_quantum.mbqc.utils.h_gate:12 +#: paddle_quantum.mbqc.utils.int_to_div_str:11 +#: paddle_quantum.mbqc.utils.minus_state:12 +#: paddle_quantum.mbqc.utils.one_state:12 +#: paddle_quantum.mbqc.utils.pauli_gate:33 +#: paddle_quantum.mbqc.utils.plus_state:12 +#: paddle_quantum.mbqc.utils.print_progress:10 +#: paddle_quantum.mbqc.utils.random_state_vector:11 +#: paddle_quantum.mbqc.utils.rotation_gate:19 +#: paddle_quantum.mbqc.utils.s_gate:12 paddle_quantum.mbqc.utils.swap_gate:12 +#: paddle_quantum.mbqc.utils.t_gate:12 +#: paddle_quantum.mbqc.utils.to_projector:13 +#: paddle_quantum.mbqc.utils.zero_state:12 +msgid "代码示例：" +msgstr "Code example:" + +#: of paddle_quantum.mbqc.utils.minus_state:1 +msgid "定义减态。" +msgstr "Define minus state." + +#: of paddle_quantum.mbqc.utils.minus_state:5 +msgid "\\frac{1}{\\sqrt{2}} \\begin{bmatrix} 1 \\\\ -1 \\end{bmatrix}" +msgstr "\\frac{1}{\\sqrt{2}} \\begin{bmatrix} 1 \\\\ -1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.minus_state:9 +msgid "减态对应的 ``Tensor`` 形式" +msgstr "The ``Tensor`` form of minus state." + +#: of paddle_quantum.mbqc.utils.zero_state:1 +msgid "定义零态。" +msgstr "Define zero state." + +#: of paddle_quantum.mbqc.utils.zero_state:5 +msgid "\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.zero_state:9 +msgid "零态对应的 ``Tensor`` 形式" +msgstr "The ``Tensor`` form of zero state." + +#: of paddle_quantum.mbqc.utils.one_state:1 +msgid "定义一态。" +msgstr "Define one state." + +#: of paddle_quantum.mbqc.utils.one_state:5 +msgid "\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}" +msgstr "\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.one_state:9 +msgid "一态对应的 ``Tensor`` 形式" +msgstr "The ``Tensor`` form of one state." + +#: of paddle_quantum.mbqc.utils.h_gate:1 +msgid "定义 ``Hadamard`` 门。" +msgstr "Define ``Hadamard`` gate." + +#: of paddle_quantum.mbqc.utils.h_gate:5 +msgid "\\frac{1}{\\sqrt{2}} \\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix}" +msgstr "\\frac{1}{\\sqrt{2}} \\begin{bmatrix} 1 & 1 \\\\ 1 & -1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.h_gate:9 +msgid "``Hadamard`` 门对应矩阵的 ``Tensor`` 形式" +msgstr "The ``Tensor`` form of ``Hadamard`` gate." + +#: of paddle_quantum.mbqc.utils.s_gate:1 +msgid "定义 ``S`` 门。" +msgstr "Define ``S`` gate." + +#: of paddle_quantum.mbqc.utils.s_gate:5 +msgid "\\begin{bmatrix} 1 & 0 \\\\ 0 & i \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1 & 0 \\\\ 0 & i \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.s_gate:9 +msgid "``S`` 门矩阵对应的 ``Tensor`` 形式" +msgstr "The ``Tensor`` form of ``S`` gate." + +#: of paddle_quantum.mbqc.utils.t_gate:1 +msgid "定义 ``T`` 门。" +msgstr "Define ``T`` gate." + +#: of paddle_quantum.mbqc.utils.t_gate:5 +msgid "\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i \\pi / 4} \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1 & 0 \\\\ 0 & e^{i \\pi / 4} \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.t_gate:9 +msgid "``T`` 门矩阵对应的 ``Tensor`` 形式" +msgstr "The ``Tensor`` form of ``T`` gate." + +#: of paddle_quantum.mbqc.utils.cz_gate:1 +msgid "定义 ``Controlled-Z`` 门。" +msgstr "Define Controlled-Z gate." + +#: of paddle_quantum.mbqc.utils.cz_gate:5 +msgid "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 " +"\\\\ 0 & 0 & 0 & -1 \\end{bmatrix}" +msgstr "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 1 & 0 " +"\\\\ 0 & 0 & 0 & -1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.cz_gate:9 +msgid "``Controlled-Z`` 门矩阵对应的 ``Tensor`` 形式" +msgstr "The ``Tensor`` form of ``Controlled-Z`` gate." + +#: of paddle_quantum.mbqc.utils.cnot_gate:1 +msgid "定义 ``Controlled-NOT (CNOT)`` 门。" +msgstr "Define ``Controlled-NOT (CNOT)`` gate." + +#: of paddle_quantum.mbqc.utils.cnot_gate:5 +msgid "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 " +"\\\\ 0 & 0 & 1 & 0 \\end{bmatrix}" +msgstr "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 1 & 0 & 0 \\\\ 0 & 0 & 0 & 1 " +"\\\\ 0 & 0 & 1 & 0 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.cnot_gate:9 +msgid "``Controlled-NOT (CNOT)`` 门矩阵对应的 ``Tensor`` 形式" +msgstr "The ``Tensor`` form of ``Controlled-NOT (CNOT)`` gate." + +#: of paddle_quantum.mbqc.utils.swap_gate:1 +msgid "定义 ``SWAP`` 门。" +msgstr "Define ``SWAP`` gate." + +#: of paddle_quantum.mbqc.utils.swap_gate:5 +msgid "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 " +"\\\\ 0 & 0 & 0 & 1 \\end{bmatrix}" +msgstr "" +"\\begin{bmatrix} 1 & 0 & 0 & 0 \\\\ 0 & 0 & 1 & 0 \\\\ 0 & 1 & 0 & 0 " +"\\\\ 0 & 0 & 0 & 1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.swap_gate:9 +msgid "``SWAP`` 门矩阵对应的 ``Tensor`` 形式" +msgstr "The ``Tensor`` form of ``SWAP`` gate." + +#: of paddle_quantum.mbqc.utils.pauli_gate:1 +msgid "定义 ``Pauli`` 门。" +msgstr "Define ``Pauli`` gate." + +#: of paddle_quantum.mbqc.utils.pauli_gate:3 +msgid "单位阵 ``I`` 的矩阵形式为：" +msgstr "The matrix form of Identity gate ``I`` is:" + +#: of paddle_quantum.mbqc.utils.pauli_gate:5 +msgid "\\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.pauli_gate:9 +msgid "``Pauli X`` 门的矩阵形式为：" +msgstr "The matrix form of Pauli gate ``X`` is:" + +#: of paddle_quantum.mbqc.utils.pauli_gate:11 +msgid "\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}" +msgstr "\\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.pauli_gate:15 +msgid "``Pauli Y`` 门的矩阵形式为：" +msgstr "The matrix form of Pauli gate ``Y`` is:" + +#: of paddle_quantum.mbqc.utils.pauli_gate:17 +msgid "\\begin{bmatrix} 0 & - i \\\\ i & 0 \\end{bmatrix}" +msgstr "\\begin{bmatrix} 0 & - i \\\\ i & 0 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.pauli_gate:21 +msgid "``Pauli Z`` 门的矩阵形式为：" +msgstr "The matrix form of Pauli gate ``Z`` is:" + +#: of paddle_quantum.mbqc.utils.pauli_gate:23 +msgid "\\begin{bmatrix} 1 & 0 \\\\ 0 & - 1 \\end{bmatrix}" +msgstr "\\begin{bmatrix} 1 & 0 \\\\ 0 & - 1 \\end{bmatrix}" + +#: of paddle_quantum.mbqc.utils.basis +#: paddle_quantum.mbqc.utils.compare_by_density +#: paddle_quantum.mbqc.utils.compare_by_vector +#: paddle_quantum.mbqc.utils.div_str_to_float +#: paddle_quantum.mbqc.utils.int_to_div_str paddle_quantum.mbqc.utils.kron +#: paddle_quantum.mbqc.utils.pauli_gate +#: paddle_quantum.mbqc.utils.permute_systems +#: paddle_quantum.mbqc.utils.permute_to_front +#: paddle_quantum.mbqc.utils.plot_results +#: paddle_quantum.mbqc.utils.print_progress +#: paddle_quantum.mbqc.utils.random_state_vector +#: paddle_quantum.mbqc.utils.read_running_data +#: paddle_quantum.mbqc.utils.rotation_gate +#: paddle_quantum.mbqc.utils.to_projector +#: paddle_quantum.mbqc.utils.write_running_data +msgid "Parameters" +msgstr "Parameters" + +#: of paddle_quantum.mbqc.utils.pauli_gate:27 +msgid "Pauli 门的索引字符，\"I\", \"X\", \"Y\", \"Z\" 分别表示对应的门" +msgstr "" +"Index of Pauli gate. \"I\", \"X\", \"Y\", or \"Z\" denotes the " +"corresponding gate." + +#: of paddle_quantum.mbqc.utils.pauli_gate:30 +msgid "Pauli 门对应的矩阵" +msgstr "The matrix form of the Pauli gate." + +#: of paddle_quantum.mbqc.utils.rotation_gate:1 +msgid "定义旋转门矩阵。" +msgstr "Define Rotation gate." + +#: of paddle_quantum.mbqc.utils.rotation_gate:3 +msgid "" +"R_{x}(\\theta) = \\cos(\\theta / 2) I - i\\sin(\\theta / 2) X\n" +"\n" +"R_{y}(\\theta) = \\cos(\\theta / 2) I - i\\sin(\\theta / 2) Y\n" +"\n" +"R_{z}(\\theta) = \\cos(\\theta / 2) I - i\\sin(\\theta / 2) Z" +msgstr "" +"R_{x}(\\theta) = \\cos(\\theta / 2) I - i\\sin(\\theta / 2) X\n" +"\n" +"R_{y}(\\theta) = \\cos(\\theta / 2) I - i\\sin(\\theta / 2) Y\n" +"\n" +"R_{z}(\\theta) = \\cos(\\theta / 2) I - i\\sin(\\theta / 2) Z" + +#: of paddle_quantum.mbqc.utils.rotation_gate:11 +msgid "旋转轴，绕 ``X`` 轴旋转输入 'x'，绕 ``Y`` 轴旋转输入 'y'，绕 ``Z`` 轴旋转输入 'z'" +msgstr "Rotation axis. 'x', 'y' or 'z' denotes the corresponding axis." + +#: of paddle_quantum.mbqc.utils.rotation_gate:13 +msgid "旋转的角度" +msgstr "Rotation angle." + +#: of paddle_quantum.mbqc.utils.rotation_gate:16 +msgid "旋转门对应的矩阵" +msgstr "The matrix form of Rotation gate." + +#: of paddle_quantum.mbqc.utils.to_projector:1 +msgid "把列向量转化为密度矩阵（或测量基对应的投影算符）。" +msgstr "Transform a vector into its density matrix (or measurement projector)." + +#: of paddle_quantum.mbqc.utils.to_projector:3 +msgid "|\\psi\\rangle \\to |\\psi\\rangle\\langle\\psi|" +msgstr "|\\psi\\rangle \\to |\\psi\\rangle\\langle\\psi|" + +#: of paddle_quantum.mbqc.utils.to_projector:7 +msgid "量子态列向量（或投影测量中的测量基向量）" +msgstr "Vector of a quantum state or a measurement basis" + +#: of paddle_quantum.mbqc.utils.to_projector:10 +msgid "密度矩阵（或测量基对应的投影算符）" +msgstr "Density matrix (or measurement projector)" + +#: of paddle_quantum.mbqc.utils.basis:1 +msgid "测量基。" +msgstr "Measurement basis." + +#: of paddle_quantum.mbqc.utils.basis:3 +msgid "常用的测量方式有 XY-平面测量，YZ-平面测量，X 测量，Y 测量，Z 测量。" +msgstr "" +"Commonly used measurements are measurements in the XY and YZ planes, and " +"Pauli X, Y, Z measurements." + +#: of paddle_quantum.mbqc.utils.basis:5 +msgid "" +"\\begin{align*}\n" +"& M^{XY}(\\theta) = \\{R_{z}(\\theta)|+\\rangle, " +"R_{z}(\\theta)|-\\rangle\\}\\\\\n" +"& M^{YZ}(\\theta) = \\{R_{x}(\\theta)|0\\rangle, " +"R_{x}(\\theta)|1\\rangle\\}\\\\\n" +"& X = M^{XY}(0)\\\\\n" +"& Y = M^{YZ}(\\pi / 2) = M^{XY}(-\\pi / 2)\\\\\n" +"& Z = M_{YZ}(0)\n" +"\\end{align*}\n" +"\n" +msgstr "" +"\\begin{align*}\n" +"& M^{XY}(\\theta) = \\{R_{z}(\\theta)|+\\rangle, " +"R_{z}(\\theta)|-\\rangle\\}\\\\\n" +"& M^{YZ}(\\theta) = \\{R_{x}(\\theta)|0\\rangle, " +"R_{x}(\\theta)|1\\rangle\\}\\\\\n" +"& X = M^{XY}(0)\\\\\n" +"& Y = M^{YZ}(\\pi / 2) = M^{XY}(-\\pi / 2)\\\\\n" +"& Z = M_{YZ}(0)\n" +"\\end{align*}\n" +"\n" + +#: of paddle_quantum.mbqc.utils.basis:14 +msgid "" +"测量基索引字符，\"XY\" 表示 XY-平面测量，\"YZ\" 表示 YZ-平面测量，\"X\" 表示 X 测量，\"Y\" 表示 Y " +"测量，\"Z\" 表示 Z 测量" +msgstr "" +"Index of measurement basis. \"XY\" denotes measurement in the XY-plane, " +"\"YZ\" denotes measurement in the YZ-plane, \"X\" denotes X-measurement, " +"\"Y\" denotes Y-measurement, \"Z\" denotes Z-measurement." + +#: of paddle_quantum.mbqc.utils.basis:16 +msgid "测量角度，这里只有 XY-平面测量和 YZ-平面测量时需要" +msgstr "" +"Measurement angle, only required for measurements in the XY-plane and the" +" YZ-plane." + +#: of paddle_quantum.mbqc.utils.basis:19 +msgid "测量基向量构成的列表，列表元素为 ``Tensor`` 类型" +msgstr "List of measurement basis, each element is a ``Tensor``." + +#: of paddle_quantum.mbqc.utils.kron:1 +msgid "把列表中的所有元素做张量积。" +msgstr "Take the tensor product of all elements in the list." + +#: of paddle_quantum.mbqc.utils.kron:3 +msgid "[A, B, C, \\cdots] \\to A \\otimes B \\otimes C \\otimes \\cdots" +msgstr "[A, B, C, \\cdots] \\to A \\otimes B \\otimes C \\otimes \\cdots" + +#: of paddle_quantum.mbqc.utils.kron:7 +msgid "需要做张量积的元素组成的列表" +msgstr "A list of elements to take the tensor product." + +#: of paddle_quantum.mbqc.utils.kron:10 +msgid "所有元素做张量积运算得到的 ``Tensor``，当列表中只有一个 ``Tensor`` 时，返回该 ``Tensor`` 本身" +msgstr "Tensor product of all elements in the list." + +#: of paddle_quantum.mbqc.utils.kron:13 +msgid "代码示例 1：" +msgstr "Code example 1:" + +#: of paddle_quantum.mbqc.utils.kron:38 +msgid "代码示例 2：" +msgstr "Code example 2:" + +#: of paddle_quantum.mbqc.utils.permute_to_front:1 +msgid "将一个量子态中某个子系统的顺序变换到最前面。" +msgstr "Permute one subsystem of a quantum state to the front." + +#: of paddle_quantum.mbqc.utils.permute_to_front:3 +msgid "假设当前系统的量子态列向量 :math:`\\psi\\rangle` 可以分解成多个子系统列向量的 tensor product 形式：" +msgstr "" +"If the current state vector :math:`\\psi\\rangle` can be decomposed as a " +"tensor product of multiple state vectors:" + +#: of paddle_quantum.mbqc.utils.permute_systems:5 +#: paddle_quantum.mbqc.utils.permute_to_front:5 +msgid "" +"|\\psi\\rangle = |\\psi_1\\rangle \\otimes |\\psi_2\\rangle \\otimes " +"|\\psi_3\\rangle \\otimes \\cdots" +msgstr "" +"|\\psi\\rangle = |\\psi_1\\rangle \\otimes |\\psi_2\\rangle \\otimes " +"|\\psi_3\\rangle \\otimes \\cdots" + +#: of paddle_quantum.mbqc.utils.permute_to_front:10 +msgid "每个 :math:`|\\psi_i\\rangle` 的系统标签为 :math:`i` ，则当前总系统的标签为：" +msgstr "" +"For each :math:`|\\psi_i\\rangle` its corresponding system label is " +":math:`i`, then the current system label is:" + +#: of paddle_quantum.mbqc.utils.permute_systems:11 +#: paddle_quantum.mbqc.utils.permute_to_front:12 +msgid "\\text{label} = \\{1, 2, 3, \\cdots \\}" +msgstr "\\text{label} = \\{1, 2, 3, \\cdots \\}" + +#: of paddle_quantum.mbqc.utils.permute_to_front:16 +msgid "假设需要操作的子系统的标签为：i" +msgstr "If the subsystem to be permuted is i" + +#: of paddle_quantum.mbqc.utils.permute_systems:21 +#: paddle_quantum.mbqc.utils.permute_to_front:18 +msgid "输出新系统量子态的列向量为：" +msgstr "Resulting vector with the new system order:" + +#: of paddle_quantum.mbqc.utils.permute_to_front:20 +msgid "" +"|\\psi_i\\rangle \\otimes |\\psi_1\\rangle \\otimes \\cdots " +"|\\psi_{i-1}\\rangle \\otimes |\\psi_{i+1}\\rangle \\otimes \\cdots" +msgstr "" +"|\\psi_i\\rangle \\otimes |\\psi_1\\rangle \\otimes \\cdots " +"|\\psi_{i-1}\\rangle \\otimes |\\psi_{i+1}\\rangle \\otimes \\cdots" + +#: of paddle_quantum.mbqc.utils.permute_systems:27 +#: paddle_quantum.mbqc.utils.permute_to_front:24 +msgid "需要操作的量子态" +msgstr "Quantum state to be permuted." + +#: of paddle_quantum.mbqc.utils.permute_to_front:26 +msgid "要变换到最前面的子系统标签" +msgstr "Subsystem label to be permuted to the front." + +#: of paddle_quantum.mbqc.utils.permute_systems:32 +#: paddle_quantum.mbqc.utils.permute_to_front:29 +msgid "系统顺序变换后的量子态" +msgstr "Quantum state after the system permutation." + +#: of paddle_quantum.mbqc.utils.permute_systems:1 +msgid "变换量子态的系统到指定顺序。" +msgstr "Permute subsystems of a quantum state to a given order." + +#: of paddle_quantum.mbqc.utils.permute_systems:3 +msgid "假设当前系统的量子态列向量 :math:`|\\psi\\rangle` 可以分解成多个子系统列向量的 tensor product 形式：" +msgstr "" +"If the current state vector :math:`|\\psi\\rangle` can be decomposed as a" +" tensor product of multiple state vectors:" + +#: of paddle_quantum.mbqc.utils.permute_systems:9 +msgid "每个 :math:`\\psi_i\\rangle` 的系统标签为 :math:`i` ，则当前总系统的标签为：" +msgstr "" +"For each :math:`\\psi_i\\rangle`, its corresponding subsystem label is " +":math:`i` , then the current system label is:" + +#: of paddle_quantum.mbqc.utils.permute_systems:15 +msgid "给定新系统的标签顺序为：" +msgstr "Given the new system order:" + +#: of paddle_quantum.mbqc.utils.permute_systems:17 +msgid "\\{i_1, i_2, i_3, \\cdots \\}" +msgstr "\\{i_1, i_2, i_3, \\cdots \\}" + +#: of paddle_quantum.mbqc.utils.permute_systems:23 +msgid "" +"|\\psi_{i_1}\\rangle \\otimes |\\psi_{i_2}\\rangle \\otimes " +"|\\psi_{i_3}\\rangle \\otimes \\cdots" +msgstr "" +"|\\psi_{i_1}\\rangle \\otimes |\\psi_{i_2}\\rangle \\otimes " +"|\\psi_{i_3}\\rangle \\otimes \\cdots" + +#: of paddle_quantum.mbqc.utils.permute_systems:29 +msgid "目标系统顺序" +msgstr "Target system order." + +#: of paddle_quantum.mbqc.utils.compare_by_density:1 +msgid "通过密度矩阵形式比较两个量子态是否相同。" +msgstr "Compare two quantum states by their density matrices." + +#: of paddle_quantum.mbqc.utils.compare_by_density:3 +#: paddle_quantum.mbqc.utils.compare_by_vector:3 +msgid "第一个量子态" +msgstr "The first state to be compared." + +#: of paddle_quantum.mbqc.utils.compare_by_density:5 +#: paddle_quantum.mbqc.utils.compare_by_vector:5 +msgid "第二个量子态" +msgstr "The second state to be compared." + +#: of paddle_quantum.mbqc.utils.compare_by_vector:1 +msgid "通过列向量形式比较两个量子态是否相同。" +msgstr "Compare two quantum states by their vectors." + +#: of paddle_quantum.mbqc.utils.random_state_vector:1 +msgid "随机生成一个量子态列向量。" +msgstr "Generate a random quantum state vector." + +#: of paddle_quantum.mbqc.utils.random_state_vector:3 +msgid "随机生成的量子态的比特数" +msgstr "Qubit number of the randomly generated quantum state." + +#: of paddle_quantum.mbqc.utils.random_state_vector:5 +msgid "``True`` 表示实数量子态，``False`` 表示复数量子态，默认为 ``False``" +msgstr "" +"``True`` denotes a quantum state with real numbers while ``False`` " +"denotes a quantum state with complex numbers." + +#: of paddle_quantum.mbqc.utils.random_state_vector:8 +msgid "随机生成量子态的列向量" +msgstr "Vector of the randomly generated quantum state." + +#: of paddle_quantum.mbqc.utils.div_str_to_float:1 +msgid "将除式字符串转化为对应的浮点数。" +msgstr "Transform a division string into a corresponding float number." + +#: of paddle_quantum.mbqc.utils.div_str_to_float:3 +msgid "例如将字符串 '3/2' 转化为 1.5。" +msgstr "For example, transform a division string '3/2' into 1.5." + +#: of paddle_quantum.mbqc.utils.div_str_to_float:5 +msgid "除式字符串" +msgstr "A division string." + +#: of paddle_quantum.mbqc.utils.div_str_to_float:8 +msgid "除式对应的浮点数结果" +msgstr "A float number corresponding to the division string." + +#: of paddle_quantum.mbqc.utils.int_to_div_str:1 +msgid "将两个整数转化为除式字符串。" +msgstr "Transform two integers into a division string." + +#: of paddle_quantum.mbqc.utils.int_to_div_str:3 +msgid "第一个整数" +msgstr "The first integer." + +#: of paddle_quantum.mbqc.utils.int_to_div_str:5 +msgid "第二个整数" +msgstr "The second integer." + +#: of paddle_quantum.mbqc.utils.int_to_div_str:8 +msgid "对应的除式字符串" +msgstr "The corresponding division string." + +#: of paddle_quantum.mbqc.utils.print_progress:1 +msgid "画出当前步骤的进度条。" +msgstr "Print a progress bar of the current step." + +#: of paddle_quantum.mbqc.utils.print_progress:3 +msgid "当前的进度百分比" +msgstr "Percentage of current progress." + +#: of paddle_quantum.mbqc.utils.print_progress:5 +msgid "当前步骤的名称" +msgstr "Name of the current step." + +#: of paddle_quantum.mbqc.utils.print_progress:7 +msgid "是否绘图的布尔开关" +msgstr "Boolean switch to print the progress bar." + +#: of paddle_quantum.mbqc.utils.plot_results:1 +msgid "根据字典的键值对，以键为横坐标，对应的值为纵坐标，画出柱状图。" +msgstr "" +"Draw a histogram in the dictionary, with keys in the x-coordinate and " +"values in the y-coordinate." + +#: of paddle_quantum.mbqc.utils.plot_results:3 +msgid "该函数主要调用来画出采样分布或时间比较的柱状图。" +msgstr "" +"This function is called to draw a histogram of probability distribution " +"or time comparison." + +#: of paddle_quantum.mbqc.utils.plot_results:5 +msgid "待画图的字典列表" +msgstr "A list of dictionaries to be drawn." + +#: of paddle_quantum.mbqc.utils.plot_results:7 +msgid "每种柱状图对应的名称" +msgstr "Each bar's name." + +#: of paddle_quantum.mbqc.utils.plot_results:9 +msgid "整个图的标题" +msgstr "Title of figure." + +#: of paddle_quantum.mbqc.utils.plot_results:11 +msgid "横坐标的名称" +msgstr "Name of X-coordinate." + +#: of paddle_quantum.mbqc.utils.plot_results:13 +msgid "纵坐标的名称" +msgstr "Name of Y-coordinate" + +#: of paddle_quantum.mbqc.utils.plot_results:15 +msgid "柱状图中每个横坐标的名称" +msgstr "Tick labels for each abscissa in the histogram." + +#: of paddle_quantum.mbqc.utils.write_running_data:1 +msgid "写入电路模拟运行的时间。" +msgstr "Write the circuit running time into a file." + +#: of paddle_quantum.mbqc.utils.write_running_data:3 +msgid "" +"由于在许多电路模型模拟案例中，需要比较我们的 ``MBQC`` 模拟思路与 ``Qiskit`` 或量桨平台的 ``UAnsatz`` " +"电路模型模拟思路的运行时间。 因而单独定义了写入文件函数。" +msgstr "" +"We need to compare the circuit simulation time of our ``MBQC`` module to " +"``Qiskit`` or ``UAnsatz`` for various examples. So, we define this " +"``write_running_data`` function." + +#: of paddle_quantum.mbqc.utils.write_running_data:6 +msgid "该函数与 ``read_running_data`` 函数配套使用。" +msgstr "This function is called before ``read_running_data``." + +#: of paddle_quantum.mbqc.utils.write_running_data:8 +msgid "" +"在调用该函数之前，需要调用 ``open`` 打开 ``textfile``；在写入结束之后，需要调用 ``close`` 关闭 " +"``textfile``。" +msgstr "" +"Before we call this function, we need to call the ``open`` function to " +"open the ``textfile`` firstly and also need to call the '`close`' " +"function to close the ``textfile`` after writing it." + +#: of paddle_quantum.mbqc.utils.write_running_data:10 +msgid "待写入的文件" +msgstr "File to write." + +#: of paddle_quantum.mbqc.utils.write_running_data:12 +msgid "当前案例的名称" +msgstr "Name of the current example." + +#: of paddle_quantum.mbqc.utils.write_running_data:14 +msgid "电路宽度（比特数）" +msgstr "Circuit width (qubit number)." + +#: of paddle_quantum.mbqc.utils.write_running_data:16 +msgid "``MBQC`` 模拟电路运行时间" +msgstr "Circuit simulation time of ``MBQC``." + +#: of paddle_quantum.mbqc.utils.write_running_data:18 +msgid "``Qiskit`` 或量桨平台的 ``UAnsatz`` 电路模型运行时间" +msgstr "Circuit simulation time of ``Qiskit`` or ``UAnsatz``." + +#: of paddle_quantum.mbqc.utils.read_running_data:1 +msgid "读取电路模拟运行的时间。" +msgstr "Read circuit simulation time in a file." + +#: of paddle_quantum.mbqc.utils.read_running_data:3 +msgid "" +"由于在许多电路模型模拟案例中，需要比较我们的 ``MBQC`` 模拟思路与 ``Qiskit`` 或量桨平台的 ``UAnsatz`` " +"电路模型模拟思路的运行时间。 因而单独定义了读取文件函数读取运行时间，将其处理为一个列表， 列表中的两个元素分别为 ``Qiskit`` 或 " +"``UAnsatz`` 电路模型模拟思路运行时间的字典和 ``MBQC`` 模拟思路运行时间的字典。" +msgstr "" +"We need to compare the circuit simulation time of our ``MBQC`` module to " +"``Qiskit`` or``UAnsatz`` for various examples. So, we define this " +"``read_running_data`` function to read time and map it into a list. The " +"two list elements are dictionaries of circuit simulation time of " +"``Qiskit`` or ``UAnsatz`` and of our ``MBQC`` module." + +#: of paddle_quantum.mbqc.utils.read_running_data:7 +msgid "该函数与 ``write_running_data`` 函数配套使用。" +msgstr "This function is called after ``write_running_data``." + +#: of paddle_quantum.mbqc.utils.read_running_data:9 +msgid "待读取的文件名" +msgstr "Name of the file to read." + +#: of paddle_quantum.mbqc.utils.read_running_data:12 +msgid "运行时间列表" +msgstr "List of circuit simulation time." + +#~ msgid "Functions" +#~ msgstr "Functions" + +#~ msgid "" +#~ ":obj:`basis `\\ " +#~ "\\(label\\[\\, theta\\]\\)" +#~ msgstr "" +#~ ":obj:`basis `\\ " +#~ "\\(label\\[\\, theta\\]\\)" + +#~ msgid ":obj:`cnot_gate `\\ \\(\\)" +#~ msgstr ":obj:`cnot_gate `\\ \\(\\)" + +#~ msgid "" +#~ ":obj:`compare_by_density " +#~ "`\\ \\(state1\\," +#~ " state2\\)" +#~ msgstr "" +#~ ":obj:`compare_by_density " +#~ "`\\ \\(state1\\," +#~ " state2\\)" + +#~ msgid "" +#~ ":obj:`compare_by_vector " +#~ "`\\ \\(state1\\," +#~ " state2\\)" +#~ msgstr "" +#~ ":obj:`compare_by_vector " +#~ "`\\ \\(state1\\," +#~ " state2\\)" + +#~ msgid ":obj:`cz_gate `\\ \\(\\)" +#~ msgstr ":obj:`cz_gate `\\ \\(\\)" + +#~ msgid "" +#~ ":obj:`div_str_to_float " +#~ "`\\ \\(div\\_str\\)" +#~ msgstr "" +#~ ":obj:`div_str_to_float " +#~ "`\\ \\(div\\_str\\)" + +#~ msgid ":obj:`h_gate `\\ \\(\\)" +#~ msgstr ":obj:`h_gate `\\ \\(\\)" + +#~ msgid "" +#~ ":obj:`int_to_div_str " +#~ "`\\ \\(idx1\\[\\, " +#~ "idx2\\]\\)" +#~ msgstr "" +#~ ":obj:`int_to_div_str " +#~ "`\\ \\(idx1\\[\\, " +#~ "idx2\\]\\)" + +#~ msgid ":obj:`kron `\\ \\(tensor\\_list\\)" +#~ msgstr ":obj:`kron `\\ \\(tensor\\_list\\)" + +#~ msgid ":obj:`minus_state `\\ \\(\\)" +#~ msgstr ":obj:`minus_state `\\ \\(\\)" + +#~ msgid ":obj:`one_state `\\ \\(\\)" +#~ msgstr ":obj:`one_state `\\ \\(\\)" + +#~ msgid ":obj:`pauli_gate `\\ \\(gate\\)" +#~ msgstr ":obj:`pauli_gate `\\ \\(gate\\)" + +#~ msgid "" +#~ ":obj:`permute_systems " +#~ "`\\ \\(state\\, " +#~ "new\\_system\\)" +#~ msgstr "" +#~ ":obj:`permute_systems " +#~ "`\\ \\(state\\, " +#~ "new\\_system\\)" + +#~ msgid "" +#~ ":obj:`permute_to_front " +#~ "`\\ \\(state\\, " +#~ "which\\_system\\)" +#~ msgstr "" +#~ ":obj:`permute_to_front " +#~ "`\\ \\(state\\, " +#~ "which\\_system\\)" + +#~ msgid "" +#~ ":obj:`plot_results `\\" +#~ " \\(dict\\_lst\\, bar\\_label\\, title\\, ...\\)" +#~ msgstr "" +#~ ":obj:`plot_results `\\" +#~ " \\(dict\\_lst\\, bar\\_label\\, title\\, ...\\)" + +#~ msgid ":obj:`plus_state `\\ \\(\\)" +#~ msgstr ":obj:`plus_state `\\ \\(\\)" + +#~ msgid "" +#~ ":obj:`print_progress " +#~ "`\\ " +#~ "\\(current\\_progress\\, progress\\_name\\)" +#~ msgstr "" +#~ ":obj:`print_progress " +#~ "`\\ " +#~ "\\(current\\_progress\\, progress\\_name\\)" + +#~ msgid "" +#~ ":obj:`random_state_vector " +#~ "`\\ \\(n\\[\\," +#~ " is\\_real\\]\\)" +#~ msgstr "" +#~ ":obj:`random_state_vector " +#~ "`\\ \\(n\\[\\," +#~ " is\\_real\\]\\)" + +#~ msgid "" +#~ ":obj:`read_running_data " +#~ "`\\ " +#~ "\\(file\\_name\\)" +#~ msgstr "" +#~ ":obj:`read_running_data " +#~ "`\\ " +#~ "\\(file\\_name\\)" + +#~ msgid "" +#~ ":obj:`rotation_gate `\\" +#~ " \\(axis\\, theta\\)" +#~ msgstr "" +#~ ":obj:`rotation_gate `\\" +#~ " \\(axis\\, theta\\)" + +#~ msgid ":obj:`s_gate `\\ \\(\\)" +#~ msgstr ":obj:`s_gate `\\ \\(\\)" + +#~ msgid ":obj:`swap_gate `\\ \\(\\)" +#~ msgstr ":obj:`swap_gate `\\ \\(\\)" + +#~ msgid ":obj:`t_gate `\\ \\(\\)" +#~ msgstr ":obj:`t_gate `\\ \\(\\)" + +#~ msgid "" +#~ ":obj:`to_projector `\\" +#~ " \\(vector\\)" +#~ msgstr "" +#~ ":obj:`to_projector `\\" +#~ " \\(vector\\)" + +#~ msgid "" +#~ ":obj:`write_running_data " +#~ "`\\ \\(textfile\\," +#~ " eg\\, width\\, ...\\)" +#~ msgstr "" +#~ ":obj:`write_running_data " +#~ "`\\ \\(textfile\\," +#~ " eg\\, width\\, ...\\)" + +#~ msgid ":obj:`zero_state `\\ \\(\\)" +#~ msgstr ":obj:`zero_state `\\ \\(\\)" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.operator.operator.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.operator.operator.po new file mode 100644 index 0000000..1fe7b43 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.operator.operator.po @@ -0,0 +1,110 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.operator.operator.rst:2 +msgid "paddle\\_quantum.operator.operator" +msgstr "" + +#: of paddle_quantum.operator.operator:1 +msgid "The source file of the class for the special quantum operator." +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse:1 +#: paddle_quantum.operator.operator.PartialState:1 +#: paddle_quantum.operator.operator.ResetState:1 +msgid "Bases: :py:class:`~paddle_quantum.base.Operator`" +msgstr "" + +#: of paddle_quantum.operator.operator.ResetState:1 +msgid "The class to reset the quantum state. It will be implemented soon." +msgstr "" + +#: of paddle_quantum.operator.operator.PartialState.forward:1 +#: paddle_quantum.operator.operator.ResetState.forward:1 +msgid "The forward function." +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse.forward +#: paddle_quantum.operator.operator.PartialState.forward +#: paddle_quantum.operator.operator.ResetState.forward +msgid "Returns" +msgstr "" + +#: of paddle_quantum.operator.operator.PartialState.forward:3 +#: paddle_quantum.operator.operator.ResetState.forward:3 +msgid "NotImplemented." +msgstr "" + +#: of paddle_quantum.operator.operator.PartialState:1 +msgid "" +"The class to obtain the partial quantum state. It will be implemented " +"soon." +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse:1 +msgid "The class to compute the collapse of the quantum state." +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse +#: paddle_quantum.operator.operator.Collapse.forward +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse:3 +msgid "" +"The basis of the measurement. The quantum state will collapse to the " +"corresponding eigenstate." +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse +#: paddle_quantum.operator.operator.Collapse.forward +msgid "Raises" +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse:5 +msgid "" +"If the basis of measurement is not z. Other bases will be implemented " +"soon." +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse.forward:1 +msgid "Compute the collapse of the input state." +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse.forward:3 +msgid "The input state, which will be collapsed." +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse.forward:4 +msgid "The desired result you want to collapse." +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse.forward:6 +msgid "Currently we just support the z basis." +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse.forward:8 +msgid "The collapsed quantum state." +msgstr "" + +#: of paddle_quantum.operator.operator.Collapse.forward +msgid "Return type" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.operator.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.operator.po new file mode 100644 index 0000000..5852f83 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.operator.po @@ -0,0 +1,32 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.operator.rst:2 +msgid "paddle\\_quantum.operator" +msgstr "" + +#: of paddle_quantum.operator:1 +msgid "The module of the special quantum operator." +msgstr "" + +#: ../../source/paddle_quantum.operator.rst:10 +msgid "Submodules" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.complex_utils.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.complex_utils.po new file mode 100644 index 0000000..66a8c5a --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.complex_utils.po @@ -0,0 +1,30 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.qchem.complex_utils.rst:2 +msgid "paddle\\_quantum.qchem.complex\\_utils" +msgstr "" + +#: of paddle_quantum.qchem.complex_utils:1 +msgid "" +"Linear algebra functions which support complex data type (Complex64, " +"Complex128)." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.density_matrix.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.density_matrix.po new file mode 100644 index 0000000..3a4fdbb --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.density_matrix.po @@ -0,0 +1,58 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.qchem.density_matrix.rst:2 +msgid "paddle\\_quantum.qchem.density\\_matrix" +msgstr "" + +#: of paddle_quantum.qchem.density_matrix:1 +msgid "Measure onebody density matrix from quantum state." +msgstr "" + +#: of paddle_quantum.qchem.density_matrix.get_spinorb_onebody_dm:1 +msgid "" +"Get the onebody density matrix from a given state in which qubits are " +"label by spin orbital index." +msgstr "" + +#: of paddle_quantum.qchem.density_matrix.get_spinorb_onebody_dm +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.qchem.density_matrix.get_spinorb_onebody_dm:3 +msgid "number of qubits in the quantum circuit." +msgstr "" + +#: of paddle_quantum.qchem.density_matrix.get_spinorb_onebody_dm:4 +msgid "the given quantum state." +msgstr "" + +#: of paddle_quantum.qchem.density_matrix.get_spinorb_onebody_dm +msgid "Returns" +msgstr "" + +#: of paddle_quantum.qchem.density_matrix.get_spinorb_onebody_dm:6 +msgid "spin up and spin down onebody density matrix." +msgstr "" + +#: of paddle_quantum.qchem.density_matrix.get_spinorb_onebody_dm +msgid "Return type" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.hardware_efficient.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.hardware_efficient.po new file mode 100644 index 0000000..8a1621b --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.hardware_efficient.po @@ -0,0 +1,61 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.qchem.hardware_efficient.rst:2 +msgid "paddle\\_quantum.qchem.hardware\\_efficient" +msgstr "" + +#: of paddle_quantum.qchem.hardware_efficient:1 +msgid "Hardware Efficient ansatz." +msgstr "" + +#: of paddle_quantum.qchem.hardware_efficient.HardwareEfficientModel:1 +msgid "Bases: :py:class:`~paddle_quantum.gate.base.Gate`" +msgstr "" + +#: of paddle_quantum.qchem.hardware_efficient.HardwareEfficientModel:5 +msgid "Hardware Efficient Circuit model" +msgstr "" + +#: of paddle_quantum.qchem.hardware_efficient.HardwareEfficientModel:2 +msgid "" +"-- Ry -- Rz --.------ Ry -- Rz --.---- .... \\\\ -- Ry -- Rz --x--.-- Ry" +" -- Rz --x--.- .... \\\\ -- Ry -- Rz --.--x--- Ry -- Rz --.--x- .... \\\\" +" -- Ry -- Rz --x------ Ry -- Rz --x---- ...." +msgstr "" + +#: of paddle_quantum.qchem.hardware_efficient.HardwareEfficientModel +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.qchem.hardware_efficient.HardwareEfficientModel:7 +msgid "number of qubits." +msgstr "" + +#: of paddle_quantum.qchem.hardware_efficient.HardwareEfficientModel:8 +msgid "" +"depth of the circuit, a layer in Hardware efficient circuit contains [Ry," +" Rz, CNOT]." +msgstr "" + +#: of paddle_quantum.qchem.hardware_efficient.HardwareEfficientModel:9 +msgid "parameters for the Ry and Rz gates inside the circuit." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.loss.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.loss.po new file mode 100644 index 0000000..de9e817 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.loss.po @@ -0,0 +1,73 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.qchem.loss.rst:2 +msgid "paddle\\_quantum.qchem.loss" +msgstr "" + +#: of paddle_quantum.qchem.loss:1 +msgid "Loss functions for quantum chemistry calculation." +msgstr "" + +#: of paddle_quantum.qchem.loss.MolEnergyLoss:1 +msgid "Bases: :py:class:`~paddle_quantum.loss.measure.ExpecVal`" +msgstr "" + +#: of paddle_quantum.qchem.loss.MolEnergyLoss:1 +msgid "Loss function for molecular ground state calculation." +msgstr "" + +#: of paddle_quantum.qchem.loss.MolEnergyLoss +#: paddle_quantum.qchem.loss.RHFEnergyLoss +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.qchem.loss.MolEnergyLoss:3 +#: paddle_quantum.qchem.loss.RHFEnergyLoss:4 +msgid "e.g. \"H 0.0 0.0 0.0; H 0.0 0.0 0.74\"." +msgstr "" + +#: of paddle_quantum.qchem.loss.MolEnergyLoss:4 +#: paddle_quantum.qchem.loss.RHFEnergyLoss:5 +msgid "chemical basis, e.g. \"sto-3g\"." +msgstr "" + +#: of paddle_quantum.qchem.loss.MolEnergyLoss:5 +#: paddle_quantum.qchem.loss.RHFEnergyLoss:6 +msgid "spin multiplicity." +msgstr "" + +#: of paddle_quantum.qchem.loss.MolEnergyLoss:6 +#: paddle_quantum.qchem.loss.RHFEnergyLoss:7 +msgid "charge of the molecule." +msgstr "" + +#: of paddle_quantum.qchem.loss.RHFEnergyLoss:1 +msgid "Bases: :py:class:`~paddle_quantum.base.Operator`" +msgstr "" + +#: of paddle_quantum.qchem.loss.RHFEnergyLoss:2 +msgid "Loss function for Restricted Hartree Fock calculation." +msgstr "" + +#: of paddle_quantum.qchem.loss.RHFEnergyLoss:2 +msgid "NOTE: This function needs PySCF be installed!" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.po new file mode 100644 index 0000000..b191ca6 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.po @@ -0,0 +1,32 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.qchem.rst:2 +msgid "paddle\\_quantum.qchem" +msgstr "" + +#: of paddle_quantum.qchem:1 +msgid "The module of the quantum chemistry." +msgstr "" + +#: ../../source/paddle_quantum.qchem.rst:10 +msgid "Submodules" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.qchem.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.qchem.po new file mode 100644 index 0000000..6213145 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.qchem.po @@ -0,0 +1,216 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.qchem.qchem.rst:2 +msgid "paddle\\_quantum.qchem.qchem" +msgstr "" + +#: of paddle_quantum.qchem.qchem:1 +msgid "The function for quantum chemistry." +msgstr "" + +#: of paddle_quantum.qchem.qchem.qubitOperator_to_Hamiltonian:1 +msgid "Transfer openfermion form to Paddle Quantum Hamiltonian form." +msgstr "" + +#: of paddle_quantum.qchem.qchem.active_space +#: paddle_quantum.qchem.qchem.fermionic_hamiltonian +#: paddle_quantum.qchem.qchem.geometry +#: paddle_quantum.qchem.qchem.get_molecular_data +#: paddle_quantum.qchem.qchem.qubitOperator_to_Hamiltonian +#: paddle_quantum.qchem.qchem.spin_hamiltonian +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.qchem.qchem.fermionic_hamiltonian:9 +#: paddle_quantum.qchem.qchem.qubitOperator_to_Hamiltonian:3 +#: paddle_quantum.qchem.qchem.spin_hamiltonian:3 +msgid "Hamiltonian in openfermion form." +msgstr "" + +#: of paddle_quantum.qchem.qchem.qubitOperator_to_Hamiltonian:4 +msgid "Value less than tol will be ignored. Defaults to 1e-8." +msgstr "" + +#: of paddle_quantum.qchem.qchem.active_space +#: paddle_quantum.qchem.qchem.fermionic_hamiltonian +#: paddle_quantum.qchem.qchem.geometry +#: paddle_quantum.qchem.qchem.get_molecular_data +#: paddle_quantum.qchem.qchem.qubitOperator_to_Hamiltonian +#: paddle_quantum.qchem.qchem.spin_hamiltonian +msgid "Returns" +msgstr "" + +#: of paddle_quantum.qchem.qchem.qubitOperator_to_Hamiltonian:6 +msgid "Hamiltonian in Paddle Quantum form." +msgstr "" + +#: of paddle_quantum.qchem.qchem.active_space +#: paddle_quantum.qchem.qchem.fermionic_hamiltonian +#: paddle_quantum.qchem.qchem.geometry +#: paddle_quantum.qchem.qchem.get_molecular_data +#: paddle_quantum.qchem.qchem.qubitOperator_to_Hamiltonian +#: paddle_quantum.qchem.qchem.spin_hamiltonian +msgid "Return type" +msgstr "" + +#: of paddle_quantum.qchem.qchem.geometry:1 +msgid "Read molecular geometry information." +msgstr "" + +#: of paddle_quantum.qchem.qchem.geometry:3 +msgid "" +"Including molecular geometry information in string, take H2 as an example" +" ``[['H', [-1.68666, 1.79811, 0.0]], ['H', [-1.12017, 1.37343, 0.0]]]``. " +"Defaults to None." +msgstr "" + +#: of paddle_quantum.qchem.qchem.geometry:5 +msgid "The path of .xyz file. Defaults to None." +msgstr "" + +#: of paddle_quantum.qchem.qchem.geometry +msgid "Raises" +msgstr "" + +#: of paddle_quantum.qchem.qchem.geometry:7 +msgid "The two optional input cannot be None simultaneously." +msgstr "" + +#: of paddle_quantum.qchem.qchem.geometry:9 +#: paddle_quantum.qchem.qchem.get_molecular_data:3 +msgid "Molecular geometry information." +msgstr "" + +#: of paddle_quantum.qchem.qchem.get_molecular_data:1 +msgid "" +"Calculate necessary values of molecule, including one-body integrations, " +"two-body integrations, and the ground state energy calculated by a chosen" +" method" +msgstr "" + +#: of paddle_quantum.qchem.qchem.get_molecular_data:4 +msgid "Molecular charge. Defaults to 0." +msgstr "" + +#: of paddle_quantum.qchem.qchem.get_molecular_data:5 +msgid "Molecular multiplicity. Defaults to 1." +msgstr "" + +#: of paddle_quantum.qchem.qchem.get_molecular_data:6 +msgid "" +"Most common used basis are ‘sto-3g’, ‘6-31g’. For more basis options, " +"please refer to " +"https://psicode.org/psi4manual/master/basissets_byelement.html#apdx-" +"basiselement. Defaults to 'sto-3g'." +msgstr "" + +#: of paddle_quantum.qchem.qchem.get_molecular_data:8 +msgid "" +"Method to calculate ground state energy, including ``scf``, ``fci``. " +"Defaults to ``scf``." +msgstr "" + +#: of paddle_quantum.qchem.qchem.get_molecular_data:9 +msgid "If need to save molecule information as .hdf5 file. Defaults to True." +msgstr "" + +#: of paddle_quantum.qchem.qchem.get_molecular_data:10 +msgid "" +"If need to print ground state energy calculated by chosen method. " +"Defaults to True." +msgstr "" + +#: of paddle_quantum.qchem.qchem.get_molecular_data:11 +msgid "The name of the file to save. Defaults to \"\"." +msgstr "" + +#: of paddle_quantum.qchem.qchem.get_molecular_data:12 +msgid "The path of the file to save. Defaults to \".\"." +msgstr "" + +#: of paddle_quantum.qchem.qchem.fermionic_hamiltonian:3 +#: paddle_quantum.qchem.qchem.get_molecular_data:14 +msgid "A class contains information of the molecule." +msgstr "" + +#: of paddle_quantum.qchem.qchem.active_space:1 +msgid "" +"Calculate active space by nominating the number of active electrons and " +"active orbitals." +msgstr "" + +#: of paddle_quantum.qchem.qchem.active_space:3 +msgid "Number of total electrons." +msgstr "" + +#: of paddle_quantum.qchem.qchem.active_space:4 +msgid "Number of total orbitals." +msgstr "" + +#: of paddle_quantum.qchem.qchem.active_space:5 +#: paddle_quantum.qchem.qchem.fermionic_hamiltonian:5 +#: paddle_quantum.qchem.qchem.spin_hamiltonian:5 +msgid "Spin multiplicity. Defaults to 1." +msgstr "" + +#: of paddle_quantum.qchem.qchem.active_space:6 +#: paddle_quantum.qchem.qchem.fermionic_hamiltonian:6 +#: paddle_quantum.qchem.qchem.spin_hamiltonian:7 +msgid "" +"Number of active electrons, default to the case that all electrons are " +"active." +msgstr "" + +#: of paddle_quantum.qchem.qchem.active_space:7 +#: paddle_quantum.qchem.qchem.fermionic_hamiltonian:7 +#: paddle_quantum.qchem.qchem.spin_hamiltonian:8 +msgid "" +"Number of active orbitals, default to the case that all orbitals are " +"active." +msgstr "" + +#: of paddle_quantum.qchem.qchem.active_space:9 +msgid "Index for core orbitals and active orbitals." +msgstr "" + +#: of paddle_quantum.qchem.qchem.fermionic_hamiltonian:1 +msgid "Calculate the fermionic hamiltonian of the given molecule." +msgstr "" + +#: of paddle_quantum.qchem.qchem.fermionic_hamiltonian:4 +#: paddle_quantum.qchem.qchem.spin_hamiltonian:4 +msgid "Path of .hdf5 file of molecule. Defaults to None." +msgstr "" + +#: of paddle_quantum.qchem.qchem.spin_hamiltonian:1 +msgid "Generate Hamiltonian in Paddle Quantum form." +msgstr "" + +#: of paddle_quantum.qchem.qchem.spin_hamiltonian:6 +msgid "" +"Transformation method, default to ``jordan_wigner``, besides, " +"``bravyi_kitaev`` is supported. Defaults to ``jordan_wigner``." +msgstr "" + +#: of paddle_quantum.qchem.qchem.spin_hamiltonian:10 +msgid "Hamiltonian in Paddle Quantum form" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.slater_determinant.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.slater_determinant.po new file mode 100644 index 0000000..1a18712 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.slater_determinant.po @@ -0,0 +1,52 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.qchem.slater_determinant.rst:2 +msgid "paddle\\_quantum.qchem.slater\\_determinant" +msgstr "" + +#: of paddle_quantum.qchem.slater_determinant:1 +msgid "Slater determinant ansatz used in restricted Hartree Fock method." +msgstr "" + +#: of paddle_quantum.qchem.slater_determinant.RHFSlaterDeterminantModel:1 +msgid "Bases: :py:class:`~paddle_quantum.gate.base.Gate`" +msgstr "" + +#: of paddle_quantum.qchem.slater_determinant.RHFSlaterDeterminantModel:1 +msgid "Slater determinant ansatz used in Restricted Hartree Fock calculation." +msgstr "" + +#: of paddle_quantum.qchem.slater_determinant.RHFSlaterDeterminantModel +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.qchem.slater_determinant.RHFSlaterDeterminantModel:3 +msgid "number of qubits used to encode the Slater determinant state." +msgstr "" + +#: of paddle_quantum.qchem.slater_determinant.RHFSlaterDeterminantModel:4 +msgid "number of electrons inside the molecule." +msgstr "" + +#: of paddle_quantum.qchem.slater_determinant.RHFSlaterDeterminantModel:5 +msgid "parameters used to initialize Slater determinant state." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.uccsd.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.uccsd.po new file mode 100644 index 0000000..e849432 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qchem.uccsd.po @@ -0,0 +1,83 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.qchem.uccsd.rst:2 +msgid "paddle\\_quantum.qchem.uccsd" +msgstr "" + +#: of paddle_quantum.qchem.uccsd:1 +msgid "" +"Unitary coupled cluster with singles and doubles for molecular ground " +"state calculation." +msgstr "" + +#: of paddle_quantum.qchem.uccsd.UCCSDModel:1 +msgid "Bases: :py:class:`~paddle_quantum.gate.base.Gate`" +msgstr "" + +#: of paddle_quantum.qchem.uccsd.UCCSDModel:1 +msgid "Unitary Coupled Cluster ansatz for quantum chemistry calculation." +msgstr "" + +#: of paddle_quantum.qchem.uccsd.UCCSDModel:4 +msgid "" +"UCCSD model typically results in REALLY deep quantum circuit. Training " +"UCCSD ansatz for molecules beyond H2 is time consuming and demands better" +" hardware." +msgstr "" + +#: of paddle_quantum.qchem.uccsd.UCCSDModel:6 +msgid "" +"\\begin{align}\n" +" U(\\theta)&=e^{\\hat{T}-\\hat{T}^{\\dagger}}\\\\\n" +" \\hat{T}&=\\hat{T}_1+\\hat{T}_2\\\\\n" +" " +"\\hat{T}_1&=\\sum_{a\\in{\\text{virt}}}\\sum_{i\\in\\text{occ}}t_{ai}\\sum_{\\sigma}\\hat{c}^{\\dagger}_{a\\sigma}\\hat{c}_{i\\sigma}-h.c.\\\\" +"\n" +" " +"\\hat{T}_2&=\\frac{1}{2}\\sum_{a,b\\in\\text{virt}}\\sum_{i,j\\in\\text{occ}}t_{aibj}\\sum_{\\sigma\\tau}\\hat{c}^{\\dagger}_{a\\sigma}\\hat{c}^{\\dagger}_{b\\tau}\\hat{c}_{j\\tau}\\hat{c}_{i\\sigma}-h.c." +"\n" +"\\end{align}" +msgstr "" + +#: of paddle_quantum.qchem.uccsd.UCCSDModel +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.qchem.uccsd.UCCSDModel:15 +msgid "number of qubits used to represent the quantum system." +msgstr "" + +#: of paddle_quantum.qchem.uccsd.UCCSDModel:16 +msgid "number of electrons inside the system." +msgstr "" + +#: of paddle_quantum.qchem.uccsd.UCCSDModel:17 +msgid "number of Trotter steps required to build the UCCSD circuit." +msgstr "" + +#: of paddle_quantum.qchem.uccsd.UCCSDModel:18 +msgid ":math:`t_{ai}` in the definition of :math:`\\hat{T}_1`." +msgstr "" + +#: of paddle_quantum.qchem.uccsd.UCCSDModel:19 +msgid ":math:`t_{aibj}` in the definition of :math:`\\hat{T}_2`." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qinfo.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qinfo.po new file mode 100644 index 0000000..b518e24 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.qinfo.po @@ -0,0 +1,397 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.qinfo.rst:2 +msgid "paddle\\_quantum.qinfo" +msgstr "" + +#: of paddle_quantum.qinfo:1 +msgid "The function for quantum information." +msgstr "" + +#: of paddle_quantum.qinfo.partial_trace:1 +msgid "Calculate the partial trace of the quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.gate_fidelity +#: paddle_quantum.qinfo.image_to_density_matrix paddle_quantum.qinfo.is_ppt +#: paddle_quantum.qinfo.logarithmic_negativity paddle_quantum.qinfo.negativity +#: paddle_quantum.qinfo.partial_trace +#: paddle_quantum.qinfo.partial_trace_discontiguous +#: paddle_quantum.qinfo.partial_transpose +#: paddle_quantum.qinfo.partial_transpose_2 +#: paddle_quantum.qinfo.pauli_str_to_matrix paddle_quantum.qinfo.purity +#: paddle_quantum.qinfo.random_pauli_str_generator +#: paddle_quantum.qinfo.relative_entropy paddle_quantum.qinfo.schmidt_decompose +#: paddle_quantum.qinfo.shadow_trace paddle_quantum.qinfo.state_fidelity +#: paddle_quantum.qinfo.trace_distance paddle_quantum.qinfo.von_neumann_entropy +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.qinfo.partial_trace:3 +#: paddle_quantum.qinfo.partial_trace_discontiguous:3 +msgid "Input quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.partial_trace:4 +msgid "The dimension of system A." +msgstr "" + +#: of paddle_quantum.qinfo.partial_trace:5 +msgid "The dimension of system B." +msgstr "" + +#: of paddle_quantum.qinfo.partial_trace:6 +msgid "" +"1 or 2. 1 means to calculate partial trace on system A; 2 means to " +"calculate partial trace on system B." +msgstr "" + +#: of paddle_quantum.qinfo.gate_fidelity +#: paddle_quantum.qinfo.image_to_density_matrix paddle_quantum.qinfo.is_ppt +#: paddle_quantum.qinfo.logarithmic_negativity paddle_quantum.qinfo.negativity +#: paddle_quantum.qinfo.partial_trace +#: paddle_quantum.qinfo.partial_trace_discontiguous +#: paddle_quantum.qinfo.partial_transpose +#: paddle_quantum.qinfo.partial_transpose_2 +#: paddle_quantum.qinfo.pauli_str_to_matrix paddle_quantum.qinfo.purity +#: paddle_quantum.qinfo.random_pauli_str_generator +#: paddle_quantum.qinfo.relative_entropy paddle_quantum.qinfo.schmidt_decompose +#: paddle_quantum.qinfo.shadow_trace paddle_quantum.qinfo.state_fidelity +#: paddle_quantum.qinfo.trace_distance paddle_quantum.qinfo.von_neumann_entropy +msgid "Returns" +msgstr "" + +#: of paddle_quantum.qinfo.partial_trace:8 +msgid "Partial trace of the input quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.gate_fidelity +#: paddle_quantum.qinfo.image_to_density_matrix paddle_quantum.qinfo.is_ppt +#: paddle_quantum.qinfo.logarithmic_negativity paddle_quantum.qinfo.negativity +#: paddle_quantum.qinfo.partial_trace +#: paddle_quantum.qinfo.partial_trace_discontiguous +#: paddle_quantum.qinfo.partial_transpose +#: paddle_quantum.qinfo.partial_transpose_2 +#: paddle_quantum.qinfo.pauli_str_to_matrix paddle_quantum.qinfo.purity +#: paddle_quantum.qinfo.random_pauli_str_generator +#: paddle_quantum.qinfo.relative_entropy paddle_quantum.qinfo.schmidt_decompose +#: paddle_quantum.qinfo.shadow_trace paddle_quantum.qinfo.state_fidelity +#: paddle_quantum.qinfo.trace_distance paddle_quantum.qinfo.von_neumann_entropy +msgid "Return type" +msgstr "" + +#: of paddle_quantum.qinfo.partial_trace_discontiguous:1 +msgid "" +"Calculate the partial trace of the quantum state with arbitrarily " +"selected subsystem" +msgstr "" + +#: of paddle_quantum.qinfo.partial_trace_discontiguous:4 +msgid "Remaining qubits, default is None, indicate all qubits remain." +msgstr "" + +#: of paddle_quantum.qinfo.partial_trace_discontiguous:6 +msgid "Partial trace of the quantum state with arbitrarily selected subsystem." +msgstr "" + +#: of paddle_quantum.qinfo.state_fidelity:1 +#: paddle_quantum.qinfo.trace_distance:1 +msgid "Calculate the fidelity of two quantum states." +msgstr "" + +#: of paddle_quantum.qinfo.trace_distance:3 +msgid "D(\\rho, \\sigma) = 1 / 2 * \\text{tr}|\\rho-\\sigma|" +msgstr "" + +#: of paddle_quantum.qinfo.is_ppt:3 +#: paddle_quantum.qinfo.logarithmic_negativity:3 +#: paddle_quantum.qinfo.negativity:3 paddle_quantum.qinfo.partial_transpose:3 +#: paddle_quantum.qinfo.partial_transpose_2:3 paddle_quantum.qinfo.purity:7 +#: paddle_quantum.qinfo.relative_entropy:8 +#: paddle_quantum.qinfo.relative_entropy:9 +#: paddle_quantum.qinfo.state_fidelity:6 paddle_quantum.qinfo.state_fidelity:7 +#: paddle_quantum.qinfo.trace_distance:7 paddle_quantum.qinfo.trace_distance:8 +#: paddle_quantum.qinfo.von_neumann_entropy:7 +msgid "Density matrix form of the quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.state_fidelity:9 +#: paddle_quantum.qinfo.trace_distance:10 +msgid "The fidelity between the input quantum states." +msgstr "" + +#: of paddle_quantum.qinfo.state_fidelity:3 +msgid "" +"F(\\rho, \\sigma) = \\text{tr}(\\sqrt{\\sqrt{\\rho}\\sigma\\sqrt{\\rho}})" +"\n" +"\n" +msgstr "" + +#: of paddle_quantum.qinfo.gate_fidelity:1 +msgid "calculate the fidelity between gates" +msgstr "" + +#: of paddle_quantum.qinfo.gate_fidelity:3 +msgid "F(U, V) = |\\text{tr}(UV^\\dagger)|/2^n" +msgstr "" + +#: of paddle_quantum.qinfo.gate_fidelity:7 +msgid ":math:`U` is a :math:`2^n\\times 2^n` unitary gate" +msgstr "" + +#: of paddle_quantum.qinfo.gate_fidelity:9 +msgid "quantum gate :math:`U` in matrix form" +msgstr "" + +#: of paddle_quantum.qinfo.gate_fidelity:10 +msgid "quantum gate :math:`V` in matrix form" +msgstr "" + +#: of paddle_quantum.qinfo.gate_fidelity:12 +msgid "fidelity between gates" +msgstr "" + +#: of paddle_quantum.qinfo.purity:1 +msgid "Calculate the purity of a quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.purity:3 +msgid "P = \\text{tr}(\\rho^2)" +msgstr "" + +#: of paddle_quantum.qinfo.purity:9 +msgid "The purity of the input quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.von_neumann_entropy:1 +msgid "Calculate the von Neumann entropy of a quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.von_neumann_entropy:3 +msgid "S = -\\text{tr}(\\rho \\log(\\rho))" +msgstr "" + +#: of paddle_quantum.qinfo.von_neumann_entropy:9 +msgid "The von Neumann entropy of the input quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.relative_entropy:1 +msgid "Calculate the relative entropy of two quantum states." +msgstr "" + +#: of paddle_quantum.qinfo.relative_entropy:3 +msgid "S(\\rho \\| \\sigma)=\\text{tr} \\rho(\\log \\rho-\\log \\sigma)" +msgstr "" + +#: of paddle_quantum.qinfo.relative_entropy:11 +msgid "Relative entropy between input quantum states." +msgstr "" + +#: of paddle_quantum.qinfo.random_pauli_str_generator:1 +msgid "Generate a random observable in list form." +msgstr "" + +#: of paddle_quantum.qinfo.random_pauli_str_generator:3 +msgid "" +"An observable :math:`O=0.3X\\otimes I\\otimes I+0.5Y\\otimes I\\otimes " +"Z`'s list form is ``[[0.3, 'x0'], [0.5, 'y0,z2']]``. Such an observable " +"is generated by ``random_pauli_str_generator(3, terms=2)``" +msgstr "" + +#: of paddle_quantum.qinfo.pauli_str_to_matrix:8 +#: paddle_quantum.qinfo.random_pauli_str_generator:7 +msgid "Number of qubits." +msgstr "" + +#: of paddle_quantum.qinfo.random_pauli_str_generator:8 +msgid "Number of terms in the observable. Defaults to 3." +msgstr "" + +#: of paddle_quantum.qinfo.random_pauli_str_generator:10 +msgid "The randomly generated observable’s list form." +msgstr "" + +#: of paddle_quantum.qinfo.pauli_str_to_matrix:1 +msgid "Convert the input list form of an observable to its matrix form." +msgstr "" + +#: of paddle_quantum.qinfo.pauli_str_to_matrix:3 +msgid "" +"For example, if the input ``pauli_str`` is ``[[0.7, 'z0,x1'], [0.2, " +"'z1']]`` and ``n=3``, then this function returns the observable " +":math:`0.7Z\\otimes X\\otimes I+0.2I\\otimes Z\\otimes I` in matrix form." +msgstr "" + +#: of paddle_quantum.qinfo.pauli_str_to_matrix:7 +msgid "A list form of an observable." +msgstr "" + +#: of paddle_quantum.qinfo.pauli_str_to_matrix +msgid "Raises" +msgstr "" + +#: of paddle_quantum.qinfo.pauli_str_to_matrix:10 +msgid "Only Pauli operator \"I\" can be accepted without specifying its position." +msgstr "" + +#: of paddle_quantum.qinfo.pauli_str_to_matrix:12 +msgid "The matrix form of the input observable." +msgstr "" + +#: of paddle_quantum.qinfo.partial_transpose:1 +#: paddle_quantum.qinfo.partial_transpose_2:1 +msgid "" +"Calculate the partial transpose :math:`\\rho^{T_A}` of the input quantum " +"state." +msgstr "" + +#: of paddle_quantum.qinfo.partial_transpose_2:4 +msgid "" +"1 or 2. 1 means to perform partial transpose on system A; 2 means to " +"perform partial trace on system B. Default is 2." +msgstr "" + +#: of paddle_quantum.qinfo.partial_transpose:6 +#: paddle_quantum.qinfo.partial_transpose_2:6 +msgid "The partial transpose of the input quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.partial_transpose:4 +msgid "Number of qubits of the system to be transposed." +msgstr "" + +#: of paddle_quantum.qinfo.negativity:1 +msgid "" +"Compute the Negativity :math:`N = ||\\frac{\\rho^{T_A}-1}{2}||` of the " +"input quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.negativity:5 +msgid "The Negativity of the input quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.logarithmic_negativity:1 +msgid "" +"Calculate the Logarithmic Negativity :math:`E_N = ||\\rho^{T_A}||` of the" +" input quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.logarithmic_negativity:5 +msgid "The Logarithmic Negativity of the input quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.is_ppt:1 +msgid "Check if the input quantum state is PPT." +msgstr "" + +#: of paddle_quantum.qinfo.is_ppt:5 +msgid "Whether the input quantum state is PPT." +msgstr "" + +#: of paddle_quantum.qinfo.schmidt_decompose:1 +msgid "" +"Calculate the Schmidt decomposition of a quantum state " +":math:`\\lvert\\psi\\rangle=\\sum_ic_i\\lvert i_A\\rangle\\otimes\\lvert " +"i_B \\rangle`." +msgstr "" + +#: of paddle_quantum.qinfo.schmidt_decompose:3 +msgid "State vector form of the quantum state, with shape（2**n）" +msgstr "" + +#: of paddle_quantum.qinfo.schmidt_decompose:4 +msgid "" +"Qubit indices to be included in subsystem A (other qubits are included in" +" subsystem B), default are the first half qubits of :math:`\\lvert " +"\\psi\\rangle`" +msgstr "" + +#: of paddle_quantum.qinfo.schmidt_decompose:6 +msgid "" +"contains elements * A one dimensional array composed of Schmidt " +"coefficients, with shape ``(k)`` * A high dimensional array composed of " +"bases for subsystem A :math:`\\lvert i_A\\rangle`, with shape ``(k, 2**m," +" 1)`` * A high dimensional array composed of bases for subsystem B " +":math:`\\lvert i_B\\rangle` , with shape ``(k, 2**m, 1)``" +msgstr "" + +#: of paddle_quantum.qinfo.schmidt_decompose:6 +msgid "contains elements" +msgstr "" + +#: of paddle_quantum.qinfo.schmidt_decompose:8 +msgid "" +"A one dimensional array composed of Schmidt coefficients, with shape " +"``(k)``" +msgstr "" + +#: of paddle_quantum.qinfo.schmidt_decompose:9 +msgid "" +"A high dimensional array composed of bases for subsystem A :math:`\\lvert" +" i_A\\rangle`, with shape ``(k, 2**m, 1)``" +msgstr "" + +#: of paddle_quantum.qinfo.schmidt_decompose:10 +msgid "" +"A high dimensional array composed of bases for subsystem B :math:`\\lvert" +" i_B\\rangle` , with shape ``(k, 2**m, 1)``" +msgstr "" + +#: of paddle_quantum.qinfo.image_to_density_matrix:1 +msgid "Encode image to density matrix" +msgstr "" + +#: of paddle_quantum.qinfo.image_to_density_matrix:3 +msgid "Path to the image file." +msgstr "" + +#: of paddle_quantum.qinfo.image_to_density_matrix:5 +msgid "The density matrix obtained by encoding" +msgstr "" + +#: of paddle_quantum.qinfo.shadow_trace:1 +msgid "" +"Estimate the expectation value :math:`\\text{trace}(H\\rho)` of an " +"observable :math:`H`." +msgstr "" + +#: of paddle_quantum.qinfo.shadow_trace:3 +msgid "Quantum state." +msgstr "" + +#: of paddle_quantum.qinfo.shadow_trace:4 +msgid "Observable." +msgstr "" + +#: of paddle_quantum.qinfo.shadow_trace:5 +msgid "Number of samples." +msgstr "" + +#: of paddle_quantum.qinfo.shadow_trace:6 +msgid "" +"Method used to , which should be one of “CS”, “LBCS”, and “APS”. Default " +"is “CS”." +msgstr "" + +#: of paddle_quantum.qinfo.shadow_trace:8 +msgid "The estimated expectation value for the hamiltonian." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.shadow.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.shadow.po new file mode 100644 index 0000000..eb5d6e1 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.shadow.po @@ -0,0 +1,80 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.shadow.rst:2 +msgid "paddle\\_quantum.shadow" +msgstr "" + +#: of paddle_quantum.shadow:1 +msgid "shadow sample module." +msgstr "" + +#: of paddle_quantum.shadow.shadow_sample:1 +msgid "" +"Measure a given quantum state with random Pauli operators and return the " +"measurement results." +msgstr "" + +#: of paddle_quantum.shadow.shadow_sample +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.shadow.shadow_sample:3 +msgid "Input quantum state, which is either a state vector or a density matrix." +msgstr "" + +#: of paddle_quantum.shadow.shadow_sample:4 +msgid "The number of qubits." +msgstr "" + +#: of paddle_quantum.shadow.shadow_sample:5 +msgid "The number of random samples." +msgstr "" + +#: of paddle_quantum.shadow.shadow_sample:6 +msgid "Representation form of the input quantum state." +msgstr "" + +#: of paddle_quantum.shadow.shadow_sample:7 +msgid "" +"A Hamiltonian object representing the observable to be measured. Default " +"to None." +msgstr "" + +#: of paddle_quantum.shadow.shadow_sample:8 +msgid "" +"Method for sampling random Pauli operators, which should be one of 'CS', " +"'LBCS', and 'APS'. Default to 'CS'." +msgstr "" + +#: of paddle_quantum.shadow.shadow_sample +msgid "Returns" +msgstr "" + +#: of paddle_quantum.shadow.shadow_sample:10 +msgid "" +"Randomly chosen Pauli operators and their corresponding measurement " +"result in a list of shape (sample_shots, 2)." +msgstr "" + +#: of paddle_quantum.shadow.shadow_sample +msgid "Return type" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.state.common.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.state.common.po new file mode 100644 index 0000000..41ea69b --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.state.common.po @@ -0,0 +1,268 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.state.common.rst:2 +msgid "paddle\\_quantum.state.common" +msgstr "" + +#: of paddle_quantum.state.common:1 +msgid "The common function of the quantum state." +msgstr "" + +#: of paddle_quantum.state.common.to_state:1 +msgid "The function to generate a specified state instance." +msgstr "" + +#: of paddle_quantum.state.common.bell_diagonal_state +#: paddle_quantum.state.common.bell_state +#: paddle_quantum.state.common.completely_mixed_computational +#: paddle_quantum.state.common.computational_basis +#: paddle_quantum.state.common.ghz_state +#: paddle_quantum.state.common.isotropic_state +#: paddle_quantum.state.common.r_state paddle_quantum.state.common.random_state +#: paddle_quantum.state.common.s_state paddle_quantum.state.common.to_state +#: paddle_quantum.state.common.w_state paddle_quantum.state.common.zero_state +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.state.common.to_state:3 +msgid "The mathematical analysis of quantum state." +msgstr "" + +#: of paddle_quantum.state.common.to_state:4 +msgid "" +"The number of qubits contained in the quantum state. Defaults to None, " +"which means it will be inferred by the data." +msgstr "" + +#: of paddle_quantum.state.common.bell_state:10 +#: paddle_quantum.state.common.computational_basis:5 +#: paddle_quantum.state.common.to_state:5 +#: paddle_quantum.state.common.zero_state:4 +msgid "" +"Used to specify the backend used. Defaults to None, which means to use " +"the default backend." +msgstr "" + +#: of paddle_quantum.state.common.computational_basis:6 +#: paddle_quantum.state.common.to_state:6 +#: paddle_quantum.state.common.zero_state:5 +msgid "" +"Used to specify the data dtype of the data. Defaults to None, which means" +" to use the default data type." +msgstr "" + +#: of paddle_quantum.state.common.bell_diagonal_state +#: paddle_quantum.state.common.bell_state +#: paddle_quantum.state.common.completely_mixed_computational +#: paddle_quantum.state.common.computational_basis +#: paddle_quantum.state.common.ghz_state +#: paddle_quantum.state.common.isotropic_state +#: paddle_quantum.state.common.r_state paddle_quantum.state.common.random_state +#: paddle_quantum.state.common.s_state paddle_quantum.state.common.to_state +#: paddle_quantum.state.common.w_state paddle_quantum.state.common.zero_state +msgid "Returns" +msgstr "" + +#: of paddle_quantum.state.common.bell_diagonal_state:15 +#: paddle_quantum.state.common.bell_state:14 +#: paddle_quantum.state.common.completely_mixed_computational:8 +#: paddle_quantum.state.common.computational_basis:10 +#: paddle_quantum.state.common.ghz_state:7 +#: paddle_quantum.state.common.isotropic_state:15 +#: paddle_quantum.state.common.r_state:14 +#: paddle_quantum.state.common.random_state:9 +#: paddle_quantum.state.common.s_state:14 +#: paddle_quantum.state.common.to_state:8 paddle_quantum.state.common.w_state:7 +#: paddle_quantum.state.common.zero_state:9 +msgid "The generated quantum state." +msgstr "" + +#: of paddle_quantum.state.common.bell_diagonal_state +#: paddle_quantum.state.common.bell_state +#: paddle_quantum.state.common.completely_mixed_computational +#: paddle_quantum.state.common.computational_basis +#: paddle_quantum.state.common.ghz_state +#: paddle_quantum.state.common.isotropic_state +#: paddle_quantum.state.common.r_state paddle_quantum.state.common.random_state +#: paddle_quantum.state.common.s_state paddle_quantum.state.common.to_state +#: paddle_quantum.state.common.w_state paddle_quantum.state.common.zero_state +msgid "Return type" +msgstr "" + +#: of paddle_quantum.state.common.zero_state:1 +msgid "The function to generate a zero state." +msgstr "" + +#: of paddle_quantum.state.common.bell_state:9 +#: paddle_quantum.state.common.completely_mixed_computational:3 +#: paddle_quantum.state.common.computational_basis:3 +#: paddle_quantum.state.common.ghz_state:3 +#: paddle_quantum.state.common.isotropic_state:9 +#: paddle_quantum.state.common.random_state:3 +#: paddle_quantum.state.common.w_state:3 +#: paddle_quantum.state.common.zero_state:3 +msgid "The number of qubits contained in the quantum state." +msgstr "" + +#: of paddle_quantum.state.common.bell_diagonal_state +#: paddle_quantum.state.common.bell_state +#: paddle_quantum.state.common.completely_mixed_computational +#: paddle_quantum.state.common.computational_basis +#: paddle_quantum.state.common.ghz_state +#: paddle_quantum.state.common.isotropic_state +#: paddle_quantum.state.common.r_state paddle_quantum.state.common.random_state +#: paddle_quantum.state.common.s_state paddle_quantum.state.common.w_state +#: paddle_quantum.state.common.zero_state +msgid "Raises" +msgstr "" + +#: of paddle_quantum.state.common.bell_diagonal_state:13 +#: paddle_quantum.state.common.bell_state:12 +#: paddle_quantum.state.common.completely_mixed_computational:6 +#: paddle_quantum.state.common.computational_basis:8 +#: paddle_quantum.state.common.ghz_state:5 +#: paddle_quantum.state.common.isotropic_state:13 +#: paddle_quantum.state.common.r_state:12 +#: paddle_quantum.state.common.random_state:7 +#: paddle_quantum.state.common.s_state:12 paddle_quantum.state.common.w_state:5 +#: paddle_quantum.state.common.zero_state:7 +msgid "If the backend is wrong or not implemented." +msgstr "" + +#: of paddle_quantum.state.common.computational_basis:1 +msgid "" +"Generate a computational basis state :math:`|e_{i}\\rangle` , whose i-th " +"element is 1 and all the other elements are 0." +msgstr "" + +#: of paddle_quantum.state.common.computational_basis:4 +msgid "Index :math:`i` of the computational basis state :math`|e_{i}rangle` ." +msgstr "" + +#: of paddle_quantum.state.common.bell_state:1 +msgid "Generate a bell state." +msgstr "" + +#: of paddle_quantum.state.common.bell_diagonal_state:3 +#: paddle_quantum.state.common.bell_state:3 +#: paddle_quantum.state.common.isotropic_state:3 +#: paddle_quantum.state.common.r_state:3 paddle_quantum.state.common.s_state:3 +msgid "Its matrix form is:" +msgstr "" + +#: of paddle_quantum.state.common.bell_state:5 +msgid "" +"|\\Phi_{D}\\rangle=\\frac{1}{\\sqrt{D}} " +"\\sum_{j=0}^{D-1}|j\\rangle_{A}|j\\rangle_{B}" +msgstr "" + +#: of paddle_quantum.state.common.bell_diagonal_state:1 +msgid "Generate a bell diagonal state." +msgstr "" + +#: of paddle_quantum.state.common.bell_diagonal_state:5 +msgid "" +"p_{1}|\\Phi^{+}\\rangle\\langle\\Phi^{+}|+p_{2}| " +"\\Psi^{+}\\rangle\\langle\\Psi^{+}|+p_{3}| " +"\\Phi^{-}\\rangle\\langle\\Phi^{-}| +\n" +"p4|\\Psi^{-}\\rangle\\langle\\Psi^{-}|" +msgstr "" + +#: of paddle_quantum.state.common.bell_diagonal_state:10 +msgid "The prob of each bell state." +msgstr "" + +#: of paddle_quantum.state.common.bell_diagonal_state:12 +#: paddle_quantum.state.common.completely_mixed_computational:5 +#: paddle_quantum.state.common.isotropic_state:12 +#: paddle_quantum.state.common.r_state:11 +#: paddle_quantum.state.common.s_state:11 +msgid "The state should bu a pure state if the backend is state_vector." +msgstr "" + +#: of paddle_quantum.state.common.random_state:1 +msgid "Generate a random quantum state." +msgstr "" + +#: of paddle_quantum.state.common.random_state:4 +msgid "If the quantum state only contains the real number. Defaults to False." +msgstr "" + +#: of paddle_quantum.state.common.random_state:5 +msgid "The rank of the density matrix. Defaults to None which means full rank." +msgstr "" + +#: of paddle_quantum.state.common.w_state:1 +msgid "Generate a W-state." +msgstr "" + +#: of paddle_quantum.state.common.ghz_state:1 +msgid "Generate a GHZ-state." +msgstr "" + +#: of paddle_quantum.state.common.completely_mixed_computational:1 +msgid "Generate the density matrix of the completely mixed state." +msgstr "" + +#: of paddle_quantum.state.common.r_state:1 +msgid "Generate an R-state." +msgstr "" + +#: of paddle_quantum.state.common.r_state:5 +msgid "p|\\Psi^{+}\\rangle\\langle\\Psi^{+}| + (1 - p)|11\\rangle\\langle11|" +msgstr "" + +#: of paddle_quantum.state.common.r_state:9 +msgid "" +"The parameter of the R-state to be generated. It should be in " +":math:`[0,1]` ." +msgstr "" + +#: of paddle_quantum.state.common.s_state:1 +msgid "Generate the S-state." +msgstr "" + +#: of paddle_quantum.state.common.s_state:5 +msgid "p|\\Phi^{+}\\rangle\\langle\\Phi^{+}| + (1 - p)|00\\rangle\\langle00|" +msgstr "" + +#: of paddle_quantum.state.common.s_state:9 +msgid "" +"The parameter of the S-state to be generated. It should be in " +":math:`[0,1]` ." +msgstr "" + +#: of paddle_quantum.state.common.isotropic_state:1 +msgid "Generate the isotropic state." +msgstr "" + +#: of paddle_quantum.state.common.isotropic_state:5 +msgid "" +"p(\\frac{1}{\\sqrt{D}} \\sum_{j=0}^{D-1}|j\\rangle_{A}|j\\rangle_{B}) + " +"(1 - p)\\frac{I}{2^n}" +msgstr "" + +#: of paddle_quantum.state.common.isotropic_state:10 +msgid "" +"The parameter of the isotropic state to be generated. It should be in " +":math:`[0,1]` ." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.state.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.state.po new file mode 100644 index 0000000..e6d2264 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.state.po @@ -0,0 +1,32 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.state.rst:2 +msgid "paddle\\_quantum.state" +msgstr "" + +#: of paddle_quantum.state:1 +msgid "The module of the quantum state." +msgstr "" + +#: ../../source/paddle_quantum.state.rst:10 +msgid "Submodules" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.state.state.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.state.state.po new file mode 100644 index 0000000..77bf9f1 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.state.state.po @@ -0,0 +1,161 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.state.state.rst:2 +msgid "paddle\\_quantum.state.state" +msgstr "" + +#: of paddle_quantum.state.state:1 +msgid "The basic class of the quantum state." +msgstr "" + +#: of paddle_quantum.state.state.State:1 +msgid "Bases: :py:class:`object`" +msgstr "" + +#: of paddle_quantum.state.state.State:1 +msgid "The quantum state class." +msgstr "" + +#: of paddle_quantum.state.state.State +#: paddle_quantum.state.state.State.expec_val +#: paddle_quantum.state.state.State.measure paddle_quantum.state.state.State.to +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.state.state.State:3 +msgid "The mathematical analysis of quantum state." +msgstr "" + +#: of paddle_quantum.state.state.State:4 +msgid "" +"The number of qubits contained in the quantum state. Defaults to None, " +"which means it will be inferred by the data." +msgstr "" + +#: of paddle_quantum.state.state.State:5 +msgid "" +"Used to specify the backend used. Defaults to None, which means to use " +"the default backend." +msgstr "" + +#: of paddle_quantum.state.state.State:6 +msgid "" +"Used to specify the data dtype of the data. Defaults to None, which means" +" to use the default data type." +msgstr "" + +#: of paddle_quantum.state.state.State.numpy:1 +msgid "get the data in numpy." +msgstr "" + +#: of paddle_quantum.state.state.State.clone +#: paddle_quantum.state.state.State.expec_val +#: paddle_quantum.state.state.State.measure +#: paddle_quantum.state.state.State.numpy paddle_quantum.state.state.State.to +msgid "Returns" +msgstr "" + +#: of paddle_quantum.state.state.State.numpy:3 +msgid "The numpy array of the data for the quantum state." +msgstr "" + +#: of paddle_quantum.state.state.State.clone +#: paddle_quantum.state.state.State.expec_val +#: paddle_quantum.state.state.State.measure +#: paddle_quantum.state.state.State.numpy +msgid "Return type" +msgstr "" + +#: of paddle_quantum.state.state.State.to:1 +msgid "Change the property of the state." +msgstr "" + +#: of paddle_quantum.state.state.State.to:3 +msgid "Specify the new backend of the state." +msgstr "" + +#: of paddle_quantum.state.state.State.to:4 +msgid "Specify the new data type of the state." +msgstr "" + +#: of paddle_quantum.state.state.State.to:5 +msgid "Specify the new device of the state." +msgstr "" + +#: of paddle_quantum.state.state.State.to:6 +msgid "Specify the new blocking of the state." +msgstr "" + +#: of paddle_quantum.state.state.State.to:8 +msgid "Return a error because this function is not implemented." +msgstr "" + +#: of paddle_quantum.state.state.State.clone:1 +msgid "Return a copy of the quantum state." +msgstr "" + +#: of paddle_quantum.state.state.State.clone:3 +msgid "A new state which is identical to this state." +msgstr "" + +#: of paddle_quantum.state.state.State.expec_val:1 +msgid "The expectation value of the observable with respect to the quantum state." +msgstr "" + +#: of paddle_quantum.state.state.State.expec_val:3 +msgid "Information about the observable." +msgstr "" + +#: of paddle_quantum.state.state.State.expec_val:4 +msgid "Number of measurement shots." +msgstr "" + +#: of paddle_quantum.state.state.State.expec_val:6 +msgid "The expectation value of the input observable for the quantum state." +msgstr "" + +#: of paddle_quantum.state.state.State.measure:1 +msgid "Measure the quantum state" +msgstr "" + +#: of paddle_quantum.state.state.State.measure:3 +msgid "" +"the number of measurements on the quantum state output by the quantum " +"circuit. Default is 0, which means the exact probability distribution of " +"measurement results are returned." +msgstr "" + +#: of paddle_quantum.state.state.State.measure:5 +msgid "" +"The index of the qubit to be measured. Defaults to None, which means all " +"qubits are measured." +msgstr "" + +#: of paddle_quantum.state.state.State.measure:6 +msgid "" +"Whether to draw the measurement result plot. Defaults to False which " +"means no plot." +msgstr "" + +#: of paddle_quantum.state.state.State.measure:8 +msgid "Measurement results" +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.trotter.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.trotter.po new file mode 100644 index 0000000..50c1ab0 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.trotter.po @@ -0,0 +1,238 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.trotter.rst:2 +msgid "paddle\\_quantum.trotter" +msgstr "" + +#: of paddle_quantum.trotter:1 +msgid "Trotter Hamiltonian time evolution circuit module." +msgstr "" + +#: of paddle_quantum.trotter.construct_trotter_circuit:1 +msgid "Add time-evolving circuits to a user-specified circuit." +msgstr "" + +#: of paddle_quantum.trotter.construct_trotter_circuit:3 +msgid "" +"This circuit could approximate the time-evolving operator of a system " +"given its Hamiltonian H, i.e., :math:`U_{\\rm cir}~ e^{-iHt}`." +msgstr "" + +#: of paddle_quantum.trotter.add_n_pauli_gate +#: paddle_quantum.trotter.construct_trotter_circuit +#: paddle_quantum.trotter.get_1d_heisenberg_hamiltonian +#: paddle_quantum.trotter.get_suzuki_coefficients +#: paddle_quantum.trotter.get_suzuki_p_values +#: paddle_quantum.trotter.get_suzuki_permutation +#: paddle_quantum.trotter.optimal_circuit +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.trotter.construct_trotter_circuit:6 +msgid "Circuit object to which a time evolution circuit will be added." +msgstr "" + +#: of paddle_quantum.trotter.construct_trotter_circuit:7 +msgid "Hamiltonian of the system whose time evolution is to be simulated." +msgstr "" + +#: of paddle_quantum.trotter.construct_trotter_circuit:8 +msgid "Evolution time of each trotter block." +msgstr "" + +#: of paddle_quantum.trotter.construct_trotter_circuit:9 +msgid "" +"Number of trotter blocks that will be added in total. (Hint: ``steps * " +"tau`` should be the total evolution time.)" +msgstr "" + +#: of paddle_quantum.trotter.construct_trotter_circuit:11 +msgid "" +"How the time evolution circuit will be constructed. Defaults to " +"``'suzuki'``, i.e., using Trotter-Suzuki decomposition. Set to " +"``'custom'`` to use a customized simulation strategy. (Needs to be " +"specified with arguments permutation and coefficient.)" +msgstr "" + +#: of paddle_quantum.trotter.construct_trotter_circuit:14 +msgid "" +"Order of the Trotter-Suzuki decomposition. Only works when " +"``method='suzuki'``. Defaults to 1." +msgstr "" + +#: of paddle_quantum.trotter.construct_trotter_circuit:15 +msgid "" +"Whether the Hamiltonian's ordering will be rearranged in a user-specified" +" way. Supports ``'xyz'`` and ``'even_odd'`` grouping methods. Defaults to" +" None." +msgstr "" + +#: of paddle_quantum.trotter.construct_trotter_circuit:17 +msgid "" +"Custom coefficients corresponding to terms of the Hamiltonian. Only works" +" for ``method='custom'``. Defaults to None." +msgstr "" + +#: of paddle_quantum.trotter.construct_trotter_circuit:18 +msgid "" +"Custom permutation of the Hamiltonian. Only works for " +"``method='custom'``. Defaults to None." +msgstr "" + +#: of paddle_quantum.trotter.construct_trotter_circuit:20 +msgid "" +"For a more detailed explanation of how this function works, users may " +"refer to the tutorials on Paddle Quantum's website: " +"https://qml.baidu.com/tutorials/overview.html." +msgstr "" + +#: of paddle_quantum.trotter.optimal_circuit:1 +msgid "Add an optimized circuit with the Hamiltonian 'XXYYZZ'." +msgstr "" + +#: of paddle_quantum.trotter.add_n_pauli_gate:3 +#: paddle_quantum.trotter.optimal_circuit:3 +msgid "Circuit where the gates are to be added." +msgstr "" + +#: of paddle_quantum.trotter.optimal_circuit:4 +msgid "Three rotation angles." +msgstr "" + +#: of paddle_quantum.trotter.optimal_circuit:5 +msgid "List of the index of the qubit that each Pauli operator acts on." +msgstr "" + +#: of paddle_quantum.trotter.add_n_pauli_gate:1 +msgid "" +"Add a rotation gate for a tensor product of Pauli operators, for example " +":math:`e^{-\\theta/2 * X \\otimes I \\otimes X \\otimes Y}`." +msgstr "" + +#: of paddle_quantum.trotter.add_n_pauli_gate:4 +msgid "Rotation angle." +msgstr "" + +#: of paddle_quantum.trotter.add_n_pauli_gate:5 +msgid "Pauli operators in a string format, e.g., ``\"XXZ\"``." +msgstr "" + +#: of paddle_quantum.trotter.add_n_pauli_gate:6 +msgid "" +"List of the index of the qubit that each Pauli operator in the " +"``pauli_word`` acts on." +msgstr "" + +#: of paddle_quantum.trotter.add_n_pauli_gate +msgid "Raises" +msgstr "" + +#: of paddle_quantum.trotter.add_n_pauli_gate:8 +msgid "" +"The ``which_qubits`` should be either ``list``, ``tuple``, or " +"``np.ndarray``." +msgstr "" + +#: of paddle_quantum.trotter.get_suzuki_permutation:1 +msgid "Calculate the permutation array corresponding to the Suzuki decomposition." +msgstr "" + +#: of paddle_quantum.trotter.get_suzuki_coefficients:3 +#: paddle_quantum.trotter.get_suzuki_permutation:3 +msgid "Number of terms in the Hamiltonian, i.e., how many terms to be permuted." +msgstr "" + +#: of paddle_quantum.trotter.get_suzuki_coefficients:4 +#: paddle_quantum.trotter.get_suzuki_p_values:3 +#: paddle_quantum.trotter.get_suzuki_permutation:4 +msgid "Order of the Suzuki decomposition." +msgstr "" + +#: of paddle_quantum.trotter.get_1d_heisenberg_hamiltonian +#: paddle_quantum.trotter.get_suzuki_coefficients +#: paddle_quantum.trotter.get_suzuki_p_values +#: paddle_quantum.trotter.get_suzuki_permutation +msgid "Returns" +msgstr "" + +#: of paddle_quantum.trotter.get_suzuki_permutation:6 +msgid "Permutation array." +msgstr "" + +#: of paddle_quantum.trotter.get_1d_heisenberg_hamiltonian +#: paddle_quantum.trotter.get_suzuki_coefficients +#: paddle_quantum.trotter.get_suzuki_p_values +#: paddle_quantum.trotter.get_suzuki_permutation +msgid "Return type" +msgstr "" + +#: of paddle_quantum.trotter.get_suzuki_p_values:1 +msgid "Calculate the parameter p(k) in the Suzuki recurrence relationship." +msgstr "" + +#: of paddle_quantum.trotter.get_suzuki_p_values:5 +msgid "A list of length five of form [p, p, (1 - 4 * p), p, p]." +msgstr "" + +#: of paddle_quantum.trotter.get_suzuki_coefficients:1 +msgid "Calculate the coefficient array corresponding to the Suzuki decomposition." +msgstr "" + +#: of paddle_quantum.trotter.get_suzuki_coefficients:6 +msgid "Coefficient array." +msgstr "" + +#: of paddle_quantum.trotter.get_1d_heisenberg_hamiltonian:1 +msgid "Generate the Hamiltonian of a one-dimensional Heisenberg chain." +msgstr "" + +#: of paddle_quantum.trotter.get_1d_heisenberg_hamiltonian:3 +msgid "Chain length." +msgstr "" + +#: of paddle_quantum.trotter.get_1d_heisenberg_hamiltonian:4 +msgid "Coupling strength Jx on the x direction. Defaults to ``1.``." +msgstr "" + +#: of paddle_quantum.trotter.get_1d_heisenberg_hamiltonian:5 +msgid "Coupling strength Jy on the y direction. Defaults to ``1.``." +msgstr "" + +#: of paddle_quantum.trotter.get_1d_heisenberg_hamiltonian:6 +msgid "Coupling strength Jz on the z direction. Defaults to ``1.``." +msgstr "" + +#: of paddle_quantum.trotter.get_1d_heisenberg_hamiltonian:7 +msgid "" +"Magnet field along z-axis. A uniform field will be added for single float" +" input. Defaults to ``0.``." +msgstr "" + +#: of paddle_quantum.trotter.get_1d_heisenberg_hamiltonian:8 +msgid "" +"Whether to consider the periodic boundary, i.e., l + 1 = 0. Defaults to " +"``True``." +msgstr "" + +#: of paddle_quantum.trotter.get_1d_heisenberg_hamiltonian:10 +msgid "Hamiltonian of this Heisenberg chain." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.utils.SpinOps.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.utils.SpinOps.po new file mode 100644 index 0000000..04b06dd --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.utils.SpinOps.po @@ -0,0 +1,110 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2021, Institute for Quantum Computing, Baidu Inc. +# This file is distributed under the same license as the Paddle Quantum +# package. +# FIRST AUTHOR , 2021. +# +msgid "" +msgstr "" +"Project-Id-Version: Paddle Quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2021-08-19 14:04+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.9.1\n" + +#: ../../source/_autosummary/paddle_quantum.utils.SpinOps.rst:2 +msgid "paddle\\_quantum.utils.SpinOps" +msgstr "paddle\\_quantum.utils.SpinOps" + +#: of paddle_quantum.utils.SpinOps:1 +msgid "矩阵表示下的自旋算符，可以用来构建哈密顿量矩阵或者自旋可观测量。" +msgstr "The spin operators in matrix forms, could be used to construct Hamiltonian matrix or spin observables." + + +#: ../../source/_autosummary/paddle_quantum.utils.SpinOps.rst:23::1 +#: of paddle_quantum.utils.SpinOps.__init__:1 +msgid "SpinOps 的构造函数，用于实例化一个 SpinOps 对象。" +msgstr "Constructor, used to instantiate a `SpinOps` object." + +#: of paddle_quantum.utils.SpinOps.__init__ +msgid "Parameters" +msgstr "Parameters" + +#: of paddle_quantum.utils.SpinOps.__init__:3 +msgid "系统的大小（有几个量子比特）" +msgstr "Size of the system (number of qubits)." + +#: of paddle_quantum.utils.SpinOps.__init__:5 +msgid "是否使用 sparse matrix 计算，默认为 ``False``" +msgstr "Decide whether to use the sparse matrix to calculate. Default is ``False``." + +#: ../../source/_autosummary/paddle_quantum.utils.SpinOps.rst:14 +msgid "Methods" +msgstr "Methods" + +#: ../../source/_autosummary/paddle_quantum.utils.SpinOps.rst:23::1 +msgid "" +":obj:`__init__ `\\ \\(size\\[\\, " +"use\\_sparse\\]\\)" +msgstr "" +":obj:`__init__ `\\ \\(size\\[\\, " +"use\\_sparse\\]\\)" + +#: ../../source/_autosummary/paddle_quantum.utils.SpinOps.rst:25 +msgid "Attributes" +msgstr "Attributes" + +#: of paddle_quantum.utils.SpinOps.sigz_p:1::1 +msgid ":obj:`sigx_p `\\" +msgstr ":obj:`sigx_p `\\" + +#: of paddle_quantum.utils.SpinOps.sigx_p:1 +#: paddle_quantum.utils.SpinOps.sigz_p:1::1 +msgid ":math:`Z` 基底下的 :math:`S^x_i` 算符。" +msgstr ":math:`S^x_i` operators under the :math:`Z` basis." + +#: of paddle_quantum.utils.SpinOps.sigz_p:1::1 +msgid ":obj:`sigy_p `\\" +msgstr ":obj:`sigy_p `\\" + +#: of paddle_quantum.utils.SpinOps.sigy_p:1 +#: paddle_quantum.utils.SpinOps.sigz_p:1::1 +msgid ":math:`Z` 基底下的 :math:`S^y_i` 算符。" +msgstr ":math:`S^y_i` operators under the :math:`Z` basis." + +#: of paddle_quantum.utils.SpinOps.sigz_p:1::1 +msgid ":obj:`sigz_p `\\" +msgstr ":obj:`sigz_p `\\" + +#: of paddle_quantum.utils.SpinOps.sigz_p:1 +#: paddle_quantum.utils.SpinOps.sigz_p:1::1 +msgid ":math:`Z` 基底下的 :math:`S^z_i` 算符。" +msgstr ":math:`S^z_i` operators under the :math:`Z` basis." + +#: of paddle_quantum.utils.SpinOps.sigx_p paddle_quantum.utils.SpinOps.sigy_p +#: paddle_quantum.utils.SpinOps.sigz_p +msgid "Returns" +msgstr "Returns" + +#: of paddle_quantum.utils.SpinOps.sigz_p:3 +msgid ":math:`S^z_i` 算符组成的列表，其中每一项对应不同的 :math:`i`" +msgstr "a list of :math:`S^z_i` operators, different elements correspond to different indices :math:`i`." + +#: of paddle_quantum.utils.SpinOps.sigx_p paddle_quantum.utils.SpinOps.sigy_p +#: paddle_quantum.utils.SpinOps.sigz_p +msgid "Return type" +msgstr "Return type" + +#: of paddle_quantum.utils.SpinOps.sigy_p:3 +msgid ":math:`S^y_i` 算符组成的列表，其中每一项对应不同的 :math:`i`" +msgstr "a list of :math:`S^y_i` operators, different elements correspond to different indices :math:`i`." + +#: of paddle_quantum.utils.SpinOps.sigx_p:3 +msgid ":math:`S^x_i` 算符组成的列表，其中每一项对应不同的 :math:`i`" +msgstr "a list of :math:`S^x_i` operators, different elements correspond to different indices :math:`i`." + diff --git a/docs/source/locale/en/LC_MESSAGES/paddle_quantum.visual.po b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.visual.po new file mode 100644 index 0000000..8a01e1a --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/paddle_quantum.visual.po @@ -0,0 +1,154 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/paddle_quantum.visual.rst:2 +msgid "paddle\\_quantum.visual" +msgstr "" + +#: of paddle_quantum.visual:1 +msgid "The visualization function in paddle quantum." +msgstr "" + +#: of paddle_quantum.visual.plot_state_in_bloch_sphere:1 +msgid "Plot the input quantum state on the Bloch sphere." +msgstr "" + +#: of paddle_quantum.visual.plot_density_matrix_graph +#: paddle_quantum.visual.plot_multi_qubits_state_in_bloch_sphere +#: paddle_quantum.visual.plot_rotation_in_bloch_sphere +#: paddle_quantum.visual.plot_state_in_bloch_sphere +msgid "Parameters" +msgstr "" + +#: of paddle_quantum.visual.plot_multi_qubits_state_in_bloch_sphere:3 +#: paddle_quantum.visual.plot_state_in_bloch_sphere:3 +msgid "" +"List of the input quantum states in the state vector form or the density " +"matrix form." +msgstr "" + +#: of paddle_quantum.visual.plot_rotation_in_bloch_sphere:5 +#: paddle_quantum.visual.plot_state_in_bloch_sphere:4 +msgid "Whether to show an arrow for each vector. Defaults to ``False``." +msgstr "" + +#: of paddle_quantum.visual.plot_rotation_in_bloch_sphere:6 +#: paddle_quantum.visual.plot_state_in_bloch_sphere:5 +msgid "Whether to store the gif. Defaults to ``False``." +msgstr "" + +#: of paddle_quantum.visual.plot_rotation_in_bloch_sphere:7 +#: paddle_quantum.visual.plot_state_in_bloch_sphere:6 +msgid "The name of the gif file to be stored. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.visual.plot_multi_qubits_state_in_bloch_sphere:9 +#: paddle_quantum.visual.plot_state_in_bloch_sphere:7 +msgid "" +"View angle. The first element is the angle [0-360] to the x-y plane, and " +"the second element is the angle [0-360] to the x-z plane. Defaults to " +"``(30, 45)``." +msgstr "" + +#: of paddle_quantum.visual.plot_state_in_bloch_sphere:8 +msgid "View distance. Defaults to ``7``." +msgstr "" + +#: of paddle_quantum.visual.plot_state_in_bloch_sphere:9 +msgid "" +"To set the specified color, consult the ``cmap`` table. Defaults to " +"``\"red to black gradient\"``." +msgstr "" + +#: of paddle_quantum.visual.plot_multi_qubits_state_in_bloch_sphere:1 +msgid "Displaying the quantum state on the Bloch sphere which has multi qubits." +msgstr "" + +#: of paddle_quantum.visual.plot_multi_qubits_state_in_bloch_sphere:4 +msgid "Index of qubits to display, default is ``\"full display\"``." +msgstr "" + +#: of paddle_quantum.visual.plot_multi_qubits_state_in_bloch_sphere:5 +msgid "Whether to show an arrow for each vector. Default is ``False``." +msgstr "" + +#: of paddle_quantum.visual.plot_multi_qubits_state_in_bloch_sphere:6 +msgid "Whether to store the gif. Default is ``False``." +msgstr "" + +#: of paddle_quantum.visual.plot_multi_qubits_state_in_bloch_sphere:7 +msgid "Whether to store the picture. Default is ``True``." +msgstr "" + +#: of paddle_quantum.visual.plot_multi_qubits_state_in_bloch_sphere:8 +msgid "The name of the picture to be stored. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.visual.plot_multi_qubits_state_in_bloch_sphere:10 +#: paddle_quantum.visual.plot_rotation_in_bloch_sphere:9 +msgid "View distance. Default is ``7``." +msgstr "" + +#: of paddle_quantum.visual.plot_multi_qubits_state_in_bloch_sphere:11 +msgid "" +"To set the specified color, consult the ``cmap`` table. Default is " +"``\"blue\"``." +msgstr "" + +#: of paddle_quantum.visual.plot_rotation_in_bloch_sphere:1 +msgid "" +"Plot the rotation starting from the initial quantum state on the Bloch " +"sphere." +msgstr "" + +#: of paddle_quantum.visual.plot_rotation_in_bloch_sphere:3 +msgid "Initial quantum state in the state vector form or the density matrix form." +msgstr "" + +#: of paddle_quantum.visual.plot_rotation_in_bloch_sphere:4 +msgid "Rotation angle ``[theta, phi, lam]``." +msgstr "" + +#: of paddle_quantum.visual.plot_rotation_in_bloch_sphere:8 +msgid "" +"The first element is the angle [0-360] to the x-y plane, and the second " +"element is the angle [0-360] to the x-z plane. Defaults to ``None``." +msgstr "" + +#: of paddle_quantum.visual.plot_rotation_in_bloch_sphere:10 +msgid "" +"initial color, trace color, and end color, respectively. To set the " +"specified color, consult the ``cmap`` table. Default is ``“red”``." +msgstr "" + +#: of paddle_quantum.visual.plot_density_matrix_graph:1 +msgid "Density matrix visualization tools" +msgstr "" + +#: of paddle_quantum.visual.plot_density_matrix_graph:3 +msgid "" +"The state vector or density matrix of quantum state with multi qubits, " +"requiring the number of qubits greater than 1" +msgstr "" + +#: of paddle_quantum.visual.plot_density_matrix_graph:4 +msgid "Bar width, between 0 and 1, default is ``0.3``." +msgstr "" + diff --git a/docs/source/locale/en/LC_MESSAGES/tutorial.po b/docs/source/locale/en/LC_MESSAGES/tutorial.po new file mode 100644 index 0000000..a73a8b8 --- /dev/null +++ b/docs/source/locale/en/LC_MESSAGES/tutorial.po @@ -0,0 +1,142 @@ +# SOME DESCRIPTIVE TITLE. +# Copyright (C) 2022, Baidu Inc +# This file is distributed under the same license as the paddle-quantum +# package. +# FIRST AUTHOR , 2022. +# +#, fuzzy +msgid "" +msgstr "" +"Project-Id-Version: paddle-quantum \n" +"Report-Msgid-Bugs-To: \n" +"POT-Creation-Date: 2022-05-17 11:08+0800\n" +"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" +"Last-Translator: FULL NAME \n" +"Language-Team: LANGUAGE \n" +"MIME-Version: 1.0\n" +"Content-Type: text/plain; charset=utf-8\n" +"Content-Transfer-Encoding: 8bit\n" +"Generated-By: Babel 2.10.1\n" + +#: ../../source/tutorial.rst:2 +msgid "Quick Start and Tutorials" +msgstr "" + +#: ../../source/tutorial.rst:4 +msgid "" +"We have prepared a quick start guide and several tutorials to help users " +"quickly learn how to use Paddle Quantum." +msgstr "" + +#: ../../source/tutorial.rst:9 +msgid "Quick start" +msgstr "" + +#: ../../source/tutorial.rst:11 +msgid "" +"We provide a `quick start guide `__\\ to " +"help users get started with Paddle Quantum. You can read it online on " +"this website or download and run it with `Jupyter Notebook " +"`__. " +"This guide covers the following contents:" +msgstr "" + +#: ../../source/tutorial.rst:13 +msgid "Introduction to quantum computing and quantum neural networks (QNNs)" +msgstr "" + +#: ../../source/tutorial.rst:14 +msgid "Introduction to Variational Quantum Algorithms (VQAs)" +msgstr "" + +#: ../../source/tutorial.rst:15 +msgid "Introduction to Paddle Quantum" +msgstr "" + +#: ../../source/tutorial.rst:16 +msgid "PaddlePaddle optimizer tutorial" +msgstr "" + +#: ../../source/tutorial.rst:17 +msgid "Introduction to the quantum chemistry module in Paddle Quantum" +msgstr "" + +#: ../../source/tutorial.rst:18 +msgid "How to train QNN with GPU" +msgstr "" + +#: ../../source/tutorial.rst:19 +msgid "Some frequently used functions in Paddle Quantum" +msgstr "" + +#: ../../source/tutorial.rst:22 +msgid "Tutorials" +msgstr "" + +#: ../../source/tutorial.rst:24 +msgid "" +"We provide use cases covering quantum simulation, machine learning, " +"combinatorial optimization, local operations and classical communication " +"(LOCC), and other popular quantum machine learning research topics. " +"Similar to the \\ `quick start guide `__\\ , " +"you can read each tutorial `online `__ or " +"download and run `Jupyter Notebooks " +"`__\\ " +"locally. For interested developers, we recommend them to download Jupyter" +" Notebooks and play around with it. Here are the tutorial categories:" +msgstr "" + +#: ../../source/tutorial.rst:28 +msgid "" +"`Quantum Simulation " +"`__" +msgstr "" + +#: ../../source/tutorial.rst:29 +msgid "" +"`Machine Learning " +"`__" +msgstr "" + +#: ../../source/tutorial.rst:30 +msgid "" +"`Combinatorial Optimization " +"`__" +msgstr "" + +#: ../../source/tutorial.rst:31 +msgid "" +"`LOCCNet " +"`__" +msgstr "" + +#: ../../source/tutorial.rst:32 +msgid "" +"`QNN Research " +"`__" +msgstr "" + +#: ../../source/tutorial.rst:34 +msgid "" +"With the latest LOCCNet module, Paddle Quantum can efficiently simulate " +"distributed quantum information processing tasks. Interested readers can " +"start with this `tutorial on LOCCNet `__. In addition, Paddle Quantum supports quantum neural " +"network training on GPU. For users who want to get into more details, " +"please check out the tutorial: `Use Paddle Quantum on GPU `__. Moreover, Paddle Quantum could " +"design robust quantum algorithms under noise. For more information, " +"please see `Noise tutorial `__。" +msgstr "" + +#: ../../source/tutorial.rst:40 +msgid "" +"In a recent update, the measurement-based quantum computation (MBQC) " +"module has been added to Paddle Quantum. Unlike the conventional quantum " +"circuit model, MBQC has its unique way of computing. Interested readers " +"are welcomed to read our `tutorials `__\\ on how to usethe MBQC module and its use cases." +msgstr "" + diff --git a/docs/source/modules.rst b/docs/source/modules.rst new file mode 100644 index 0000000..a81010d --- /dev/null +++ b/docs/source/modules.rst @@ -0,0 +1,24 @@ +.. toctree:: + :maxdepth: 1 + + paddle_quantum.ansatz + paddle_quantum.backend + paddle_quantum.channel + paddle_quantum.gate + paddle_quantum.locc + paddle_quantum.loss + paddle_quantum.mbqc + paddle_quantum.operator + paddle_quantum.qchem + paddle_quantum.state + paddle_quantum.base + paddle_quantum.dataset + paddle_quantum.finance + paddle_quantum.fisher + paddle_quantum.gradtool + paddle_quantum.hamiltonian + paddle_quantum.linalg + paddle_quantum.qinfo + paddle_quantum.shadow + paddle_quantum.trotter + paddle_quantum.visual diff --git a/docs/source/paddle_quantum.ansatz.circuit.rst b/docs/source/paddle_quantum.ansatz.circuit.rst new file mode 100644 index 0000000..f673eeb --- /dev/null +++ b/docs/source/paddle_quantum.ansatz.circuit.rst @@ -0,0 +1,6 @@ +paddle\_quantum.ansatz.circuit +===================================== + +.. automodule:: paddle_quantum.ansatz.circuit + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.ansatz.container.rst b/docs/source/paddle_quantum.ansatz.container.rst new file mode 100644 index 0000000..16f5365 --- /dev/null +++ b/docs/source/paddle_quantum.ansatz.container.rst @@ -0,0 +1,6 @@ +paddle\_quantum.ansatz.container +======================================= + +.. automodule:: paddle_quantum.ansatz.container + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.ansatz.rst b/docs/source/paddle_quantum.ansatz.rst new file mode 100644 index 0000000..d51d56e --- /dev/null +++ b/docs/source/paddle_quantum.ansatz.rst @@ -0,0 +1,15 @@ +paddle\_quantum.ansatz +============================== + +.. automodule:: paddle_quantum.ansatz + :members: + :show-inheritance: + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.ansatz.circuit + paddle_quantum.ansatz.container + paddle_quantum.ansatz.vans diff --git a/docs/source/paddle_quantum.ansatz.vans.rst b/docs/source/paddle_quantum.ansatz.vans.rst new file mode 100644 index 0000000..1596e02 --- /dev/null +++ b/docs/source/paddle_quantum.ansatz.vans.rst @@ -0,0 +1,6 @@ +paddle\_quantum.ansatz.vans +================================== + +.. automodule:: paddle_quantum.ansatz.vans + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.backend.density_matrix.rst b/docs/source/paddle_quantum.backend.density_matrix.rst new file mode 100644 index 0000000..a9adfa3 --- /dev/null +++ b/docs/source/paddle_quantum.backend.density_matrix.rst @@ -0,0 +1,7 @@ +paddle\_quantum.backend.density\_matrix +============================================== + +.. automodule:: paddle_quantum.backend.density_matrix + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.backend.quleaf.rst b/docs/source/paddle_quantum.backend.quleaf.rst new file mode 100644 index 0000000..b65c4f4 --- /dev/null +++ b/docs/source/paddle_quantum.backend.quleaf.rst @@ -0,0 +1,7 @@ +paddle\_quantum.backend.quleaf +===================================== + +.. automodule:: paddle_quantum.backend.quleaf + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.backend.rst b/docs/source/paddle_quantum.backend.rst new file mode 100644 index 0000000..2447388 --- /dev/null +++ b/docs/source/paddle_quantum.backend.rst @@ -0,0 +1,17 @@ +paddle\_quantum.backend +=============================== + +.. automodule:: paddle_quantum.backend + :members: + :undoc-members: + :show-inheritance: + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.backend.density_matrix + paddle_quantum.backend.quleaf + paddle_quantum.backend.state_vector + paddle_quantum.backend.unitary_matrix diff --git a/docs/source/paddle_quantum.backend.state_vector.rst b/docs/source/paddle_quantum.backend.state_vector.rst new file mode 100644 index 0000000..e370f5f --- /dev/null +++ b/docs/source/paddle_quantum.backend.state_vector.rst @@ -0,0 +1,7 @@ +paddle\_quantum.backend.state\_vector +============================================ + +.. automodule:: paddle_quantum.backend.state_vector + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.backend.unitary_matrix.rst b/docs/source/paddle_quantum.backend.unitary_matrix.rst new file mode 100644 index 0000000..3217d59 --- /dev/null +++ b/docs/source/paddle_quantum.backend.unitary_matrix.rst @@ -0,0 +1,7 @@ +paddle\_quantum.backend.unitary\_matrix +============================================== + +.. automodule:: paddle_quantum.backend.unitary_matrix + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.base.rst b/docs/source/paddle_quantum.base.rst new file mode 100644 index 0000000..0e30245 --- /dev/null +++ b/docs/source/paddle_quantum.base.rst @@ -0,0 +1,7 @@ +paddle\_quantum.base +=========================== + +.. automodule:: paddle_quantum.base + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.channel.base.rst b/docs/source/paddle_quantum.channel.base.rst new file mode 100644 index 0000000..8c93c37 --- /dev/null +++ b/docs/source/paddle_quantum.channel.base.rst @@ -0,0 +1,6 @@ +paddle\_quantum.channel.base +=================================== + +.. automodule:: paddle_quantum.channel.base + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.channel.common.rst b/docs/source/paddle_quantum.channel.common.rst new file mode 100644 index 0000000..76f188f --- /dev/null +++ b/docs/source/paddle_quantum.channel.common.rst @@ -0,0 +1,6 @@ +paddle\_quantum.channel.common +===================================== + +.. automodule:: paddle_quantum.channel.common + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.channel.custom.rst b/docs/source/paddle_quantum.channel.custom.rst new file mode 100644 index 0000000..b40f410 --- /dev/null +++ b/docs/source/paddle_quantum.channel.custom.rst @@ -0,0 +1,6 @@ +paddle\_quantum.channel.custom +===================================== + +.. automodule:: paddle_quantum.channel.custom + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.channel.functional.common.rst b/docs/source/paddle_quantum.channel.functional.common.rst new file mode 100644 index 0000000..cb1c5a4 --- /dev/null +++ b/docs/source/paddle_quantum.channel.functional.common.rst @@ -0,0 +1,6 @@ +paddle\_quantum.channel.functional.common +================================================ + +.. automodule:: paddle_quantum.channel.functional.common + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.channel.functional.rst b/docs/source/paddle_quantum.channel.functional.rst new file mode 100644 index 0000000..847e0de --- /dev/null +++ b/docs/source/paddle_quantum.channel.functional.rst @@ -0,0 +1,13 @@ +paddle\_quantum.channel.functional +========================================== + +.. automodule:: paddle_quantum.channel.functional + :members: + :show-inheritance: + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.channel.functional.common diff --git a/docs/source/paddle_quantum.channel.rst b/docs/source/paddle_quantum.channel.rst new file mode 100644 index 0000000..6c75824 --- /dev/null +++ b/docs/source/paddle_quantum.channel.rst @@ -0,0 +1,22 @@ +paddle\_quantum.channel +=============================== + +.. automodule:: paddle_quantum.channel + :members: + :show-inheritance: + +.. rubric:: Subpackages + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.channel.functional + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.channel.base + paddle_quantum.channel.common + paddle_quantum.channel.custom diff --git a/docs/source/paddle_quantum.dataset.rst b/docs/source/paddle_quantum.dataset.rst new file mode 100644 index 0000000..7343e14 --- /dev/null +++ b/docs/source/paddle_quantum.dataset.rst @@ -0,0 +1,7 @@ +paddle\_quantum.dataset +============================== + +.. automodule:: paddle_quantum.dataset + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.finance.rst b/docs/source/paddle_quantum.finance.rst new file mode 100644 index 0000000..c2aef5c --- /dev/null +++ b/docs/source/paddle_quantum.finance.rst @@ -0,0 +1,7 @@ +paddle\_quantum.finance +============================== + +.. automodule:: paddle_quantum.finance + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.fisher.rst b/docs/source/paddle_quantum.fisher.rst new file mode 100644 index 0000000..92652fb --- /dev/null +++ b/docs/source/paddle_quantum.fisher.rst @@ -0,0 +1,7 @@ +paddle\_quantum.fisher +============================= + +.. automodule:: paddle_quantum.fisher + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.gate.base.rst b/docs/source/paddle_quantum.gate.base.rst new file mode 100644 index 0000000..d48305c --- /dev/null +++ b/docs/source/paddle_quantum.gate.base.rst @@ -0,0 +1,6 @@ +paddle\_quantum.gate.base +================================ + +.. automodule:: paddle_quantum.gate.base + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.gate.clifford.rst b/docs/source/paddle_quantum.gate.clifford.rst new file mode 100644 index 0000000..0bbb142 --- /dev/null +++ b/docs/source/paddle_quantum.gate.clifford.rst @@ -0,0 +1,6 @@ +paddle\_quantum.gate.clifford +==================================== + +.. automodule:: paddle_quantum.gate.clifford + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.gate.custom.rst b/docs/source/paddle_quantum.gate.custom.rst new file mode 100644 index 0000000..d2b079a --- /dev/null +++ b/docs/source/paddle_quantum.gate.custom.rst @@ -0,0 +1,6 @@ +paddle\_quantum.gate.custom +================================== + +.. automodule:: paddle_quantum.gate.custom + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.gate.encoding.rst b/docs/source/paddle_quantum.gate.encoding.rst new file mode 100644 index 0000000..5629303 --- /dev/null +++ b/docs/source/paddle_quantum.gate.encoding.rst @@ -0,0 +1,6 @@ +paddle\_quantum.gate.encoding +==================================== + +.. automodule:: paddle_quantum.gate.encoding + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.gate.functional.base.rst b/docs/source/paddle_quantum.gate.functional.base.rst new file mode 100644 index 0000000..6c5dcb3 --- /dev/null +++ b/docs/source/paddle_quantum.gate.functional.base.rst @@ -0,0 +1,6 @@ +paddle\_quantum.gate.functional.base +=========================================== + +.. automodule:: paddle_quantum.gate.functional.base + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.gate.functional.multi_qubit_gate.rst b/docs/source/paddle_quantum.gate.functional.multi_qubit_gate.rst new file mode 100644 index 0000000..e8418d8 --- /dev/null +++ b/docs/source/paddle_quantum.gate.functional.multi_qubit_gate.rst @@ -0,0 +1,6 @@ +paddle\_quantum.gate.functional.multi\_qubit\_gate +========================================================= + +.. automodule:: paddle_quantum.gate.functional.multi_qubit_gate + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.gate.functional.rst b/docs/source/paddle_quantum.gate.functional.rst new file mode 100644 index 0000000..0516b4e --- /dev/null +++ b/docs/source/paddle_quantum.gate.functional.rst @@ -0,0 +1,15 @@ +paddle\_quantum.gate.functional +======================================= + +.. automodule:: paddle_quantum.gate.functional + :members: + :show-inheritance: + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.gate.functional.base + paddle_quantum.gate.functional.multi_qubit_gate + paddle_quantum.gate.functional.single_qubit_gate diff --git a/docs/source/paddle_quantum.gate.functional.single_qubit_gate.rst b/docs/source/paddle_quantum.gate.functional.single_qubit_gate.rst new file mode 100644 index 0000000..7d95b5b --- /dev/null +++ b/docs/source/paddle_quantum.gate.functional.single_qubit_gate.rst @@ -0,0 +1,6 @@ +paddle\_quantum.gate.functional.single\_qubit\_gate +========================================================== + +.. automodule:: paddle_quantum.gate.functional.single_qubit_gate + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.gate.layer.rst b/docs/source/paddle_quantum.gate.layer.rst new file mode 100644 index 0000000..ead3a3f --- /dev/null +++ b/docs/source/paddle_quantum.gate.layer.rst @@ -0,0 +1,6 @@ +paddle\_quantum.gate.layer +================================= + +.. automodule:: paddle_quantum.gate.layer + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.gate.multi_qubit_gate.rst b/docs/source/paddle_quantum.gate.multi_qubit_gate.rst new file mode 100644 index 0000000..939f807 --- /dev/null +++ b/docs/source/paddle_quantum.gate.multi_qubit_gate.rst @@ -0,0 +1,6 @@ +paddle\_quantum.gate.multi\_qubit\_gate +============================================== + +.. automodule:: paddle_quantum.gate.multi_qubit_gate + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.gate.rst b/docs/source/paddle_quantum.gate.rst new file mode 100644 index 0000000..e3860db --- /dev/null +++ b/docs/source/paddle_quantum.gate.rst @@ -0,0 +1,26 @@ +paddle\_quantum.gate +============================ + +.. automodule:: paddle_quantum.gate + :members: + :show-inheritance: + +.. rubric:: Subpackages + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.gate.functional + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.gate.base + paddle_quantum.gate.clifford + paddle_quantum.gate.custom + paddle_quantum.gate.encoding + paddle_quantum.gate.layer + paddle_quantum.gate.multi_qubit_gate + paddle_quantum.gate.single_qubit_gate diff --git a/docs/source/paddle_quantum.gate.single_qubit_gate.rst b/docs/source/paddle_quantum.gate.single_qubit_gate.rst new file mode 100644 index 0000000..6412127 --- /dev/null +++ b/docs/source/paddle_quantum.gate.single_qubit_gate.rst @@ -0,0 +1,6 @@ +paddle\_quantum.gate.single\_qubit\_gate +=============================================== + +.. automodule:: paddle_quantum.gate.single_qubit_gate + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.gradtool.rst b/docs/source/paddle_quantum.gradtool.rst new file mode 100644 index 0000000..5143db7 --- /dev/null +++ b/docs/source/paddle_quantum.gradtool.rst @@ -0,0 +1,7 @@ +paddle\_quantum.gradtool +=============================== + +.. automodule:: paddle_quantum.gradtool + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.hamiltonian.rst b/docs/source/paddle_quantum.hamiltonian.rst new file mode 100644 index 0000000..956da9f --- /dev/null +++ b/docs/source/paddle_quantum.hamiltonian.rst @@ -0,0 +1,7 @@ +paddle\_quantum.hamiltonian +================================== + +.. automodule:: paddle_quantum.hamiltonian + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.linalg.rst b/docs/source/paddle_quantum.linalg.rst new file mode 100644 index 0000000..37f900c --- /dev/null +++ b/docs/source/paddle_quantum.linalg.rst @@ -0,0 +1,7 @@ +paddle\_quantum.linalg +============================= + +.. automodule:: paddle_quantum.linalg + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.locc.locc_ansatz.rst b/docs/source/paddle_quantum.locc.locc_ansatz.rst new file mode 100644 index 0000000..b2e9d86 --- /dev/null +++ b/docs/source/paddle_quantum.locc.locc_ansatz.rst @@ -0,0 +1,7 @@ +paddle\_quantum.locc.locc\_ansatz +======================================== + +.. automodule:: paddle_quantum.locc.locc_ansatz + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.locc.locc_net.rst b/docs/source/paddle_quantum.locc.locc_net.rst new file mode 100644 index 0000000..4753c4a --- /dev/null +++ b/docs/source/paddle_quantum.locc.locc_net.rst @@ -0,0 +1,7 @@ +paddle\_quantum.locc.locc\_net +===================================== + +.. automodule:: paddle_quantum.locc.locc_net + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.locc.locc_party.rst b/docs/source/paddle_quantum.locc.locc_party.rst new file mode 100644 index 0000000..e3f85ff --- /dev/null +++ b/docs/source/paddle_quantum.locc.locc_party.rst @@ -0,0 +1,7 @@ +paddle\_quantum.locc.locc\_party +======================================= + +.. automodule:: paddle_quantum.locc.locc_party + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.locc.locc_state.rst b/docs/source/paddle_quantum.locc.locc_state.rst new file mode 100644 index 0000000..6f43386 --- /dev/null +++ b/docs/source/paddle_quantum.locc.locc_state.rst @@ -0,0 +1,7 @@ +paddle\_quantum.locc.locc\_state +======================================= + +.. automodule:: paddle_quantum.locc.locc_state + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.locc.rst b/docs/source/paddle_quantum.locc.rst new file mode 100644 index 0000000..de0fa91 --- /dev/null +++ b/docs/source/paddle_quantum.locc.rst @@ -0,0 +1,17 @@ +paddle\_quantum.locc +============================ + +.. automodule:: paddle_quantum.locc + :members: + :undoc-members: + :show-inheritance: + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.locc.locc_ansatz + paddle_quantum.locc.locc_net + paddle_quantum.locc.locc_party + paddle_quantum.locc.locc_state diff --git a/docs/source/paddle_quantum.loss.distance.rst b/docs/source/paddle_quantum.loss.distance.rst new file mode 100644 index 0000000..7e32ea5 --- /dev/null +++ b/docs/source/paddle_quantum.loss.distance.rst @@ -0,0 +1,7 @@ +paddle\_quantum.loss.distance +==================================== + +.. automodule:: paddle_quantum.loss.distance + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.loss.measure.rst b/docs/source/paddle_quantum.loss.measure.rst new file mode 100644 index 0000000..699201c --- /dev/null +++ b/docs/source/paddle_quantum.loss.measure.rst @@ -0,0 +1,7 @@ +paddle\_quantum.loss.measure +=================================== + +.. automodule:: paddle_quantum.loss.measure + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.loss.rst b/docs/source/paddle_quantum.loss.rst new file mode 100644 index 0000000..fff1958 --- /dev/null +++ b/docs/source/paddle_quantum.loss.rst @@ -0,0 +1,15 @@ +paddle\_quantum.loss +============================ + +.. automodule:: paddle_quantum.loss + :members: + :undoc-members: + :show-inheritance: + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.loss.distance + paddle_quantum.loss.measure diff --git a/docs/source/paddle_quantum.mbqc.qobject.rst b/docs/source/paddle_quantum.mbqc.qobject.rst new file mode 100644 index 0000000..75ee8cf --- /dev/null +++ b/docs/source/paddle_quantum.mbqc.qobject.rst @@ -0,0 +1,6 @@ +paddle\_quantum.mbqc.qobject +============================ + +.. automodule:: paddle_quantum.mbqc.qobject + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.mbqc.rst b/docs/source/paddle_quantum.mbqc.rst new file mode 100644 index 0000000..7005921 --- /dev/null +++ b/docs/source/paddle_quantum.mbqc.rst @@ -0,0 +1,17 @@ +paddle\_quantum.mbqc +==================== + +.. automodule:: paddle_quantum.mbqc + :members: + :undoc-members: + :show-inheritance: + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.mbqc.qobject + paddle_quantum.mbqc.simulator + paddle_quantum.mbqc.transpiler + paddle_quantum.mbqc.utils diff --git a/docs/source/paddle_quantum.mbqc.simulator.rst b/docs/source/paddle_quantum.mbqc.simulator.rst new file mode 100644 index 0000000..6c00649 --- /dev/null +++ b/docs/source/paddle_quantum.mbqc.simulator.rst @@ -0,0 +1,6 @@ +paddle\_quantum.mbqc.simulator +============================== + +.. automodule:: paddle_quantum.mbqc.simulator + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.mbqc.transpiler.rst b/docs/source/paddle_quantum.mbqc.transpiler.rst new file mode 100644 index 0000000..e25eb4b --- /dev/null +++ b/docs/source/paddle_quantum.mbqc.transpiler.rst @@ -0,0 +1,6 @@ +paddle\_quantum.mbqc.transpiler +=============================== + +.. automodule:: paddle_quantum.mbqc.transpiler + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.mbqc.utils.rst b/docs/source/paddle_quantum.mbqc.utils.rst new file mode 100644 index 0000000..3321d26 --- /dev/null +++ b/docs/source/paddle_quantum.mbqc.utils.rst @@ -0,0 +1,6 @@ +paddle\_quantum.mbqc.utils +========================== + +.. automodule:: paddle_quantum.mbqc.utils + :members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.operator.operator.rst b/docs/source/paddle_quantum.operator.operator.rst new file mode 100644 index 0000000..bc443f4 --- /dev/null +++ b/docs/source/paddle_quantum.operator.operator.rst @@ -0,0 +1,7 @@ +paddle\_quantum.operator.operator +======================================== + +.. automodule:: paddle_quantum.operator.operator + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.operator.rst b/docs/source/paddle_quantum.operator.rst new file mode 100644 index 0000000..90215cb --- /dev/null +++ b/docs/source/paddle_quantum.operator.rst @@ -0,0 +1,14 @@ +paddle\_quantum.operator +================================ + +.. automodule:: paddle_quantum.operator + :members: + :undoc-members: + :show-inheritance: + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.operator.operator diff --git a/docs/source/paddle_quantum.qchem.complex_utils.rst b/docs/source/paddle_quantum.qchem.complex_utils.rst new file mode 100644 index 0000000..9847560 --- /dev/null +++ b/docs/source/paddle_quantum.qchem.complex_utils.rst @@ -0,0 +1,7 @@ +paddle\_quantum.qchem.complex\_utils +=========================================== + +.. automodule:: paddle_quantum.qchem.complex_utils + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.qchem.density_matrix.rst b/docs/source/paddle_quantum.qchem.density_matrix.rst new file mode 100644 index 0000000..e134afb --- /dev/null +++ b/docs/source/paddle_quantum.qchem.density_matrix.rst @@ -0,0 +1,7 @@ +paddle\_quantum.qchem.density\_matrix +============================================ + +.. automodule:: paddle_quantum.qchem.density_matrix + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.qchem.hardware_efficient.rst b/docs/source/paddle_quantum.qchem.hardware_efficient.rst new file mode 100644 index 0000000..3939418 --- /dev/null +++ b/docs/source/paddle_quantum.qchem.hardware_efficient.rst @@ -0,0 +1,7 @@ +paddle\_quantum.qchem.hardware\_efficient +================================================ + +.. automodule:: paddle_quantum.qchem.hardware_efficient + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.qchem.loss.rst b/docs/source/paddle_quantum.qchem.loss.rst new file mode 100644 index 0000000..5fda443 --- /dev/null +++ b/docs/source/paddle_quantum.qchem.loss.rst @@ -0,0 +1,7 @@ +paddle\_quantum.qchem.loss +================================= + +.. automodule:: paddle_quantum.qchem.loss + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.qchem.qchem.rst b/docs/source/paddle_quantum.qchem.qchem.rst new file mode 100644 index 0000000..eb0e565 --- /dev/null +++ b/docs/source/paddle_quantum.qchem.qchem.rst @@ -0,0 +1,7 @@ +paddle\_quantum.qchem.qchem +================================== + +.. automodule:: paddle_quantum.qchem.qchem + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.qchem.rst b/docs/source/paddle_quantum.qchem.rst new file mode 100644 index 0000000..f2beea7 --- /dev/null +++ b/docs/source/paddle_quantum.qchem.rst @@ -0,0 +1,20 @@ +paddle\_quantum.qchem +============================= + +.. automodule:: paddle_quantum.qchem + :members: + :undoc-members: + :show-inheritance: + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.qchem.complex_utils + paddle_quantum.qchem.density_matrix + paddle_quantum.qchem.hardware_efficient + paddle_quantum.qchem.loss + paddle_quantum.qchem.qchem + paddle_quantum.qchem.slater_determinant + paddle_quantum.qchem.uccsd diff --git a/docs/source/paddle_quantum.qchem.slater_determinant.rst b/docs/source/paddle_quantum.qchem.slater_determinant.rst new file mode 100644 index 0000000..8fb5f3d --- /dev/null +++ b/docs/source/paddle_quantum.qchem.slater_determinant.rst @@ -0,0 +1,7 @@ +paddle\_quantum.qchem.slater\_determinant +================================================ + +.. automodule:: paddle_quantum.qchem.slater_determinant + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.qchem.uccsd.rst b/docs/source/paddle_quantum.qchem.uccsd.rst new file mode 100644 index 0000000..68a4aee --- /dev/null +++ b/docs/source/paddle_quantum.qchem.uccsd.rst @@ -0,0 +1,7 @@ +paddle\_quantum.qchem.uccsd +================================== + +.. automodule:: paddle_quantum.qchem.uccsd + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.qinfo.rst b/docs/source/paddle_quantum.qinfo.rst new file mode 100644 index 0000000..68175f7 --- /dev/null +++ b/docs/source/paddle_quantum.qinfo.rst @@ -0,0 +1,7 @@ +paddle\_quantum.qinfo +============================ + +.. automodule:: paddle_quantum.qinfo + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.shadow.rst b/docs/source/paddle_quantum.shadow.rst new file mode 100644 index 0000000..aff4e1d --- /dev/null +++ b/docs/source/paddle_quantum.shadow.rst @@ -0,0 +1,7 @@ +paddle\_quantum.shadow +============================= + +.. automodule:: paddle_quantum.shadow + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.state.common.rst b/docs/source/paddle_quantum.state.common.rst new file mode 100644 index 0000000..f14398a --- /dev/null +++ b/docs/source/paddle_quantum.state.common.rst @@ -0,0 +1,7 @@ +paddle\_quantum.state.common +=================================== + +.. automodule:: paddle_quantum.state.common + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.state.rst b/docs/source/paddle_quantum.state.rst new file mode 100644 index 0000000..348e0eb --- /dev/null +++ b/docs/source/paddle_quantum.state.rst @@ -0,0 +1,15 @@ +paddle\_quantum.state +============================= + +.. automodule:: paddle_quantum.state + :members: + :undoc-members: + :show-inheritance: + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.state.common + paddle_quantum.state.state diff --git a/docs/source/paddle_quantum.state.state.rst b/docs/source/paddle_quantum.state.state.rst new file mode 100644 index 0000000..7d251eb --- /dev/null +++ b/docs/source/paddle_quantum.state.state.rst @@ -0,0 +1,7 @@ +paddle\_quantum.state.state +================================== + +.. automodule:: paddle_quantum.state.state + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.trotter.rst b/docs/source/paddle_quantum.trotter.rst new file mode 100644 index 0000000..f170fed --- /dev/null +++ b/docs/source/paddle_quantum.trotter.rst @@ -0,0 +1,7 @@ +paddle\_quantum.trotter +============================== + +.. automodule:: paddle_quantum.trotter + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/paddle_quantum.visual.rst b/docs/source/paddle_quantum.visual.rst new file mode 100644 index 0000000..74ead4a --- /dev/null +++ b/docs/source/paddle_quantum.visual.rst @@ -0,0 +1,7 @@ +paddle\_quantum.visual +============================= + +.. automodule:: paddle_quantum.visual + :members: + :undoc-members: + :show-inheritance: diff --git a/docs/source/tutorial.rst b/docs/source/tutorial.rst new file mode 100644 index 0000000..219901d --- /dev/null +++ b/docs/source/tutorial.rst @@ -0,0 +1,40 @@ +Quick Start and Tutorials +========================= + +We have prepared a quick start guide and several tutorials to help users quickly learn how to use Paddle Quantum. + +.. _header-n33: + +Quick start +----------- + +We provide a `quick start guide `__\ to help users get started with Paddle Quantum. You can read it online on this website or download and run it with `Jupyter Notebook `__. This guide covers the following contents: + +- Introduction to quantum computing and quantum neural networks (QNNs) +- Introduction to Variational Quantum Algorithms (VQAs) +- Introduction to Paddle Quantum +- PaddlePaddle optimizer tutorial +- Introduction to the quantum chemistry module in Paddle Quantum +- How to train QNN with GPU + +Tutorials +--------- + +We provide use cases covering quantum simulation, machine learning, combinatorial optimization, local operations and classical communication (LOCC), and other popular quantum machine learning research topics. +Similar to the \ `quick start guide `__\ , you can read each tutorial `online `__ or download and run `Jupyter Notebooks `__\ locally. +For interested developers, we recommend them to download Jupyter Notebooks and play around with it. Here are the tutorial categories: + +- `Quantum Simulation `__ +- `Machine Learning `__ +- `Combinatorial Optimization `__ +- `LOCCNet `__ +- `QNN Research `__ + +With the latest LOCCNet module, Paddle Quantum can efficiently simulate distributed quantum information processing tasks. Interested readers can +start with this `tutorial on LOCCNet `__. In addition, Paddle Quantum supports quantum neural +network training on GPU. For users who want to get into more details, please check out the tutorial: `Use Paddle Quantum on GPU `__. +Moreover, Paddle Quantum could design robust quantum algorithms under noise. +For more information, please see `Noise tutorial `__。 + +In a recent update, the measurement-based quantum computation (MBQC) module has been added to Paddle Quantum. Unlike the conventional quantum circuit model, MBQC has its unique way of computing. +Interested readers are welcomed to read our `tutorials `__\ on how to usethe MBQC module and its use cases. diff --git a/docs_zh_CN/Makefile b/docs_zh_CN/Makefile new file mode 100644 index 0000000..d0c3cbf --- /dev/null +++ b/docs_zh_CN/Makefile @@ -0,0 +1,20 @@ +# Minimal makefile for Sphinx documentation +# + +# You can set these variables from the command line, and also +# from the environment for the first two. +SPHINXOPTS ?= +SPHINXBUILD ?= sphinx-build +SOURCEDIR = source +BUILDDIR = build + +# Put it first so that "make" without argument is like "make help". +help: + @$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) + +.PHONY: help Makefile + +# Catch-all target: route all unknown targets to Sphinx using the new +# "make mode" option. $(O) is meant as a shortcut for $(SPHINXOPTS). +%: Makefile + @$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O) diff --git a/docs_zh_CN/make.bat b/docs_zh_CN/make.bat new file mode 100644 index 0000000..747ffb7 --- /dev/null +++ b/docs_zh_CN/make.bat @@ -0,0 +1,35 @@ +@ECHO OFF + +pushd %~dp0 + +REM Command file for Sphinx documentation + +if "%SPHINXBUILD%" == "" ( + set SPHINXBUILD=sphinx-build +) +set SOURCEDIR=source +set BUILDDIR=build + +%SPHINXBUILD% >NUL 2>NUL +if errorlevel 9009 ( + echo. + echo.The 'sphinx-build' command was not found. Make sure you have Sphinx + echo.installed, then set the SPHINXBUILD environment variable to point + echo.to the full path of the 'sphinx-build' executable. Alternatively you + echo.may add the Sphinx directory to PATH. + echo. + echo.If you don't have Sphinx installed, grab it from + echo.https://www.sphinx-doc.org/ + exit /b 1 +) + +if "%1" == "" goto help + +%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% +goto end + +:help +%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS% %O% + +:end +popd diff --git a/docs_zh_CN/source/conf.py b/docs_zh_CN/source/conf.py new file mode 100644 index 0000000..7697801 --- /dev/null +++ b/docs_zh_CN/source/conf.py @@ -0,0 +1,70 @@ +# Configuration file for the Sphinx documentation builder. +# +# This file only contains a selection of the most common options. For a full +# list see the documentation: +# https://www.sphinx-doc.org/en/master/usage/configuration.html + +# -- Path setup -------------------------------------------------------------- + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# +# import os +# import sys +# sys.path.insert(0, os.path.abspath('.')) + + +# -- Project information ----------------------------------------------------- + +project = 'paddle-quantum' +copyright = '2022, Baidu Inc' +author = 'Baidu Inc' + +# The full version, including alpha/beta/rc tags +release = '2.2.0' + + +# -- General configuration --------------------------------------------------- + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + 'sphinx.ext.autodoc', + 'sphinx.ext.napoleon', + 'sphinx.ext.mathjax', + 'sphinx.ext.todo', + 'sphinx_search.extension', +] + + +# Add any paths that contain templates here, relative to this directory. +templates_path = ['_templates'] + +# The language for content autogenerated by Sphinx. Refer to documentation +# for a list of supported languages. +# +# This is also used if you do content translation via gettext catalogs. +# Usually you set "language" from the command line for these cases. +language = 'zh_CN' + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +# This pattern also affects html_static_path and html_extra_path. +exclude_patterns = [] + + +# -- Options for HTML output ------------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. +# +html_theme = 'sphinx_rtd_theme' + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ['_static'] + +master_doc = 'index' diff --git a/docs_zh_CN/source/index.rst b/docs_zh_CN/source/index.rst new file mode 100644 index 0000000..f3da02e --- /dev/null +++ b/docs_zh_CN/source/index.rst @@ -0,0 +1,20 @@ +.. paddle-quantum documentation master file, created by + sphinx-quickstart on Tue May 10 13:46:49 2022. + You can adapt this file completely to your liking, but it should at least + contain the root `toctree` directive. + +欢迎来到 Paddle Quantum 的文档！ +========================================== + +.. toctree:: + :maxdepth: 2 + :caption: Paddle Quantum 入门 + + introduction + tutorial + +.. toctree:: + :maxdepth: 1 + :caption: API 文档 + + modules diff --git a/docs_zh_CN/source/introduction.rst b/docs_zh_CN/source/introduction.rst new file mode 100644 index 0000000..5e6f534 --- /dev/null +++ b/docs_zh_CN/source/introduction.rst @@ -0,0 +1,133 @@ +.. _header-n0: + +Paddle Quantum（量桨） +======================= + +`Paddle Quantum（量桨） `__\ 是基于百度飞桨开发的量子机器学习工具集，支持量子神经网络的搭建与训练，提供易用的量子机器学习开发套件与量子优化、量子化学等前沿量子应用工具集，使得百度飞桨也因此成为国内首个支持量子机器学习的深度学习框架。 + +.. figure:: https://release-data.cdn.bcebos.com/Paddle%20Quantum.png + :target: https://github.com/PaddlePaddle/Quantum + +量桨建立起了人工智能与量子计算的桥梁，通过百度飞桨深度学习平台赋能量子计算，为领域内的科研人员以及开发者便捷地开发量子人工智能的应用提供了强有力的支撑，同时也为广大量子计算爱好者提供了一条可行的学习途径。 + + 关于量桨的更多内容可以查看 GitHub 页面：https://github.com/PaddlePaddle/Quantum + +.. _header-n6: + +特色 +---- + +- 轻松上手 + + - 丰富的在线学习资源（近 40 篇教程案例） + - 通过模板高效搭建量子神经网络 + - 自动微分框架 + +- 功能丰富 + + - 提供多种优化工具和 GPU 模式 + - 高性能模拟器支持25+量子比特的模拟运算 + - 支持多种噪声模型的模拟 + +- 特色工具集 + + - 提供组合优化和量子化学等前沿领域的计算工具箱 + - 分布式量子信息处理模组 LOCCNet + - 自研多种量子机器学习算法 + +.. _header-n15: + +安装步骤 +-------- + +.. _header-n16: + +安装 PaddlePaddle +~~~~~~~~~~~~~~~~~ + +当用户安装 Paddle Quantum 时会自动下载安装这个关键依赖包。关于 PaddlePaddle 更全面的安装信息请参考 +`PaddlePaddle `__ +安装配置页面。此项目需求 PaddlePaddle 2.2.0+。 + +.. _header-n19: + +安装 Paddle Quantum +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +我们推荐通过 ``pip`` 完成安装, + +.. code:: shell + + pip install paddle-quantum + +用户也可以选择下载全部文件后进行本地安装， + +.. code:: shell + + git clone http://github.com/PaddlePaddle/quantum + +.. code:: shell + + cd quantum + pip install -e . + +.. _header-n25: + +量子化学模块的环境设置 +~~~~~~~~~~~~~~~~~~~~~~ + +我们的量子化学模块是基于 ``Psi4`` +进行开发的，所以在运行量子化学模块之前需要先行安装该 Python 包。 + +.. note:: + + 推荐在 Python3.8 环境中安装。 + +在安装 ``psi4`` 时，我们建议您使用 conda。对于 **MacOS/Linux** +的用户，可以使用如下指令。 + +.. code:: shell + + conda install psi4 -c psi4 + +对于 **Windows** 用户，请使用 + +.. code:: shell + + conda install psi4 -c psi4 -c conda-forge + +**注意：** 更多的下载方法请参考 +`Psi4 `__\ 。 + +.. _header-n29: + +运行 +~~~~ + +现在，可以试着运行一段程序来验证量桨是否已安装成功。这里我们运行量桨提供的量子近似优化算法（QAOA）的例子。 + +.. code:: shell + + cd paddle_quantum/QAOA/example + python main.py + +.. + +.. note:: 关于 QAOA 的介绍可以参考我们的 `QAOA 教程 `__。 + +.. _header-n51: + +交流与反馈 +---------- + +- 我们非常欢迎您通过 `Github + Issues `__ + 来提交问题、报告与建议。 +- 技术交流QQ群：1076223166 + +.. _header-n118: + +Copyright and License +--------------------- + +Paddle Quantum 使用 `Apache-2.0 license `__ 许可证。 diff --git a/docs_zh_CN/source/modules.rst b/docs_zh_CN/source/modules.rst new file mode 100644 index 0000000..a81010d --- /dev/null +++ b/docs_zh_CN/source/modules.rst @@ -0,0 +1,24 @@ +.. toctree:: + :maxdepth: 1 + + paddle_quantum.ansatz + paddle_quantum.backend + paddle_quantum.channel + paddle_quantum.gate + paddle_quantum.locc + paddle_quantum.loss + paddle_quantum.mbqc + paddle_quantum.operator + paddle_quantum.qchem + paddle_quantum.state + paddle_quantum.base + paddle_quantum.dataset + paddle_quantum.finance + paddle_quantum.fisher + paddle_quantum.gradtool + paddle_quantum.hamiltonian + paddle_quantum.linalg + paddle_quantum.qinfo + paddle_quantum.shadow + paddle_quantum.trotter + paddle_quantum.visual diff --git a/docs_zh_CN/source/paddle_quantum.ansatz.circuit.rst b/docs_zh_CN/source/paddle_quantum.ansatz.circuit.rst new file mode 100644 index 0000000..8da5b5e --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.ansatz.circuit.rst @@ -0,0 +1,1012 @@ +paddle\_quantum.ansatz.circuit +===================================== + +量子电路类的功能实现。 + +.. py:class:: Circuit(num_qubits = None) + + 基类: :py:class:`paddle_quantum.ansatz.container.Sequential` + + 量子电路。 + + :param num_qubits: 量子比特数量, 默认为 ``None``。 + :type num_qubits: int, optional + + .. py:property:: num_qubits() + + 该电路的量子比特数量。 + + .. py:property:: isdynamic() + + 是否电路为动态电路。 + + .. py:property:: param() + + 展平后的电路参数。 + + .. py:property:: grad() + + 展平后的电路参数梯度。 + + .. py:method:: update_param(theta, idx = None) + + 替换单层或所有的电路参数。 + + :param theta: 新的参数。 + :type theta: Union[paddle.Tensor, np.ndarray, float] + :param idx: 量子层的索引, 默认为替换所有。 + :type idx: int, optional + + :raises ValueError: 索引必须是整数或者 None。 + + .. py:method:: randomize_param(self, low = 0, high = 2 * pi) + + 在 ``[low, high)`` 的范围内随机化电路参数 + + :param low: 随机参数的下界, 默认为 ``0``。 + :type low: float, optional + :param high: 随机参数的上界, 默认为 ``2*pi``。 + :type high: float, optional + + .. py:method:: h(qubits_idx = 'full', num_qubits = None, depth = 1) + + 添加一个单量子比特的 Hadamard 门。 + + 其矩阵形式为： + + .. math:: + + H = \frac{1}{\sqrt{2}} + \begin{bmatrix} + 1&1\\ + 1&-1 + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: s(qubits_idx = 'full', num_qubits = None, depth = 1) + + 添加单量子比特 S 门。 + + 其矩阵形式为： + + .. math:: + + S = + \begin{bmatrix} + 1&0\\ + 0&i + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: t(qubits_idx = 'full', num_qubits = None, depth = 1) + + 添加单量子比特 T 门。 + + 其矩阵形式为： + + .. math:: + + T = + \begin{bmatrix} + 1&0\\ + 0&e^\frac{i\pi}{4} + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: x(qubits_idx = 'full', num_qubits = None, depth = 1) + + 添加单量子比特 X 门。 + + 其矩阵形式为： + + .. math:: + + X = \begin{bmatrix} + 0 & 1 \\ + 1 & 0 + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: y(qubits_idx='full', num_qubits=None, depth=1) + + 添加单量子比特 Y 门。 + + 其矩阵形式为： + + .. math:: + + Y = \begin{bmatrix} + 0 & -i \\ + i & 0 + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: z(qubits_idx='full', num_qubits=None, depth=1) + + 添加单量子比特 Z 门。 + + 其矩阵形式为： + + .. math:: + + Z = \begin{bmatrix} + 1 & 0 \\ + 0 & -1 + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: p(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加单量子比特 P 门。 + + 其矩阵形式为： + + .. math:: + + P(\theta) = \begin{bmatrix} + 1 & 0 \\ + 0 & e^{i\theta} + \end{bmatrix} + + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: rx(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加关于 x 轴的单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + R_X(\theta) = \begin{bmatrix} + \cos\frac{\theta}{2} & -i\sin\frac{\theta}{2} \\ + -i\sin\frac{\theta}{2} & \cos\frac{\theta}{2} + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: ry(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加关于 y 轴的单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + R_Y(\theta) = \begin{bmatrix} + \cos\frac{\theta}{2} & -\sin\frac{\theta}{2} \\ + \sin\frac{\theta}{2} & \cos\frac{\theta}{2} + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: rz(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加关于 z 轴的单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + R_Z(\theta) = \begin{bmatrix} + e^{-i\frac{\theta}{2}} & 0 \\ + 0 & e^{i\frac{\theta}{2}} + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: u3(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + U_3(\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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: cnot(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加 CNOT 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: cx(qubits_idx='cycle', num_qubits=None, depth=1) + + 与 cnot 相同。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: cy(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加受控 Y 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{CY} &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Y\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & -1j \\ + 0 & 0 & 1j & 0 + \end{bmatrix} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: cz(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加受控 Z 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{CZ} &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Z\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & -1 + \end{bmatrix} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: swap(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加 SWAP 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{SWAP} = + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & 1 + \end{bmatrix} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: cp(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加受控 P 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{CP}(\theta) = + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & e^{i\theta} + \end{bmatrix} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: crx(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加关于 x 轴的受控单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{CR_X} &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes R_X\\ + &= + \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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: cry(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加关于 y 轴的受控单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{CR_Y} &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes R_Y\\ + &= + \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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: crz(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加关于 z 轴的受控单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{CR_Z} &= |0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes R_Z\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & e^{i\theta} + \end{bmatrix} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + + .. py:method:: cu(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加受控单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{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} + + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: rxx(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加 RXX 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{R_{XX}}(\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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: ryy(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加 RYY 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{R_{YY}}(\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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: rzz(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加 RZZ 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{R_{ZZ}}(\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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: ms(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加 Mølmer-Sørensen (MS) 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{MS} = \mathit{R_{XX}}(-\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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: cswap(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加 CSWAP (Fredkin) 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{CSWAP} = + \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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: ccx(qubits_idx = 'cycle', num_qubits = None, depth = 1) + + 添加 CCX 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \mathit{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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: universal_two_qubits(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加两量子比特通用门，该通用门需要 15 个参数。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: universal_three_qubits(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加三量子比特通用门，该通用门需要 81 个参数。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: oracle(oracle, qubits_idx, num_qubits=None, depth=1) + + 添加一个 oracle 门。 + + :param oracle: 要实现的 oracle。 + :type oracle: paddle.tensor + :param qubits_idx: 作用在的量子比特的编号。 + :type qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int] + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: control_oracle(oracle, qubits_idx, num_qubits=None, depth=1) + + 添加一个受控 oracle 门。 + + :param oracle: 要实现的 oracle。 + :type oracle: paddle.tensor + :param qubits_idx: 作用在的量子比特的编号。 + :type qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int] + :param num_qubits: 总共的量子比特数量，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: superposition_layer(qubits_idx = 'full', num_qubits = None, depth = 1) + + 添加一个 Hadamard 门组成的层。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: weak_superposition_layer(qubits_idx = 'full', num_qubits = None, depth = 1) + + 转角度为 :math:`\pi/4` 的 Ry 门组成的层。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: linear_entangled_layer(qubits_idx = 'full', num_qubits = None, depth = 1) + + 包含 Ry 门、Rz 门，和 CNOT 门的线性纠缠层。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: real_entangled_layer(qubits_idx = 'full', num_qubits = None, depth = 1) + + 包含 Ry 门和 CNOT 门的强纠缠层。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: complex_entangled_layer(qubits_idx = 'full', num_qubits = None, depth = 1) + + 包含 U3 门和 CNOT 门的强纠缠层。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: real_block_layer(qubits_idx = 'full', num_qubits = None, depth = 1) + + 包含 Ry 门和 CNOT 门的弱纠缠层。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: complex_block_layer(qubits_idx = 'full', num_qubits = None, depth = 1) + + 包含 U3 门和 CNOT 门的弱纠缠层。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: bit_flip(prob, qubits_idx = 'full', num_qubits = None) + + 添加比特反转信道。 + + :param prob: 发生比特反转的概率。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号, 默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. py:method:: phase_flip(prob, qubits_idx = 'full', num_qubits = None) + + 添加相位反转信道。 + + :param prob: 发生相位反转的概率。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号, 默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. py:method:: bit_phase_flip(prob, qubits_idx = 'full', num_qubits = None) + + 添加比特相位反转信道。 + + :param prob: 发生比特相位反转的概率。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号, 默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. py:method:: amplitude_damping(gamma, qubits_idx = 'full', num_qubits = None) + + 添加振幅阻尼信道。 + + :param gamma: 减振概率。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号, 默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. py:method:: generalized_amplitude_damping(gamma, qubits_idx = 'full', num_qubits = None) + + 添加广义振幅阻尼信道。 + + :param gamma: 减振概率。 + :type prob: Union[paddle.Tensor, float] + :param prob: 激发概率。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号, 默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. py:method:: phase_damping(gamma, qubits_idx = 'full', num_qubits = None) + + 添加相位阻尼信道。 + + :param gamma: 该信道的参数。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号, 默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. py:method:: depolarizing(prob, qubits_idx = 'full', num_qubits = None) + + 添加去极化信道。 + + :param prob: 该信道的参数。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号, 默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. py:method:: pauli_channel(prob, qubits_idx = 'full', num_qubits = None) + + 添加泡利信道。 + + :param prob: 该信道的参数。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号, 默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. py:method:: reset_channel(prob, qubits_idx = 'full', num_qubits = None) + + 添加重置信道。 + + :param prob: 重置为 :math:`|0\rangle` 和重置为 :math:`|1\rangle` 的概率。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号, 默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. py:method:: thermal_relaxation(const_t, exec_time, qubits_idx = 'full', num_qubits = None) + + 添加热弛豫信道。 + + :param const_t: :math:`T_1` 和 :math:`T_2` 过程的弛豫时间常数，单位是微秒。 + :type const_t: Union[paddle.Tensor, Iterable[float]] + :param exec_time: 弛豫过程中量子门的执行时间，单位是纳秒。 + :type exec_time: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号, 默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. py:method:: kraus_repr(kraus_oper, qubits_idx, num_qubits = None) + + 添加一个 Kraus 表示的自定义量子信道。 + + :param kraus_oper: 该信道的 Kraus 算符。 + :type kraus_oper: Iterable[paddle.Tensor] + :param qubits_idx: 作用在的量子比特的编号。 + :type qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int] + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. py:method:: unitary_matrix(num_qubits = None) + + 电路的酉矩阵形式 + + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + :return: 返回电路的酉矩阵形式 + :rtype: paddle.Tensor + + .. py:property:: gate_history() + + 量子门的插入信息 + + :return: 量子门的插入历史 + :rtype: List[Dict[str, Union[str, List[int], paddle.Tensor]]] + + .. py:property:: qubit_history() + + 每个比特上的量子门的插入信息 + + :return: 每个比特上的量子门的插入历史 + :rtype: List[List[Tuple[Dict[str, Union[str, List[int], paddle.Tensor]], int]]] diff --git a/docs_zh_CN/source/paddle_quantum.ansatz.container.rst b/docs_zh_CN/source/paddle_quantum.ansatz.container.rst new file mode 100644 index 0000000..9ba6499 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.ansatz.container.rst @@ -0,0 +1,59 @@ +paddle\_quantum.ansatz.container +======================================= + +顺序电路类的功能实现。 + +.. py:class:: Sequential(*operators) + + 基类：:py:class:`paddle_quantum.base.Operator` + + 顺序容器。 + + :param \*operators: 准备组建 Sequential 的 Operator类 + :type \*operators: Operator + + .. Note:: + + 子 Layer 将按构造函数参数的顺序添加到此容器中。传递给构造函数的参数可以 Layers 或可迭代的 (name, Layer) 元组。 + + .. py:method:: append(operator) + + 增加一个 Operator 类 + + :param operator: 一个（附带名字的）Operator 类 + :type operator: Union[Iterable, Operator] + + .. py:method:: extend(operator) + + 增加一组 Operator 类 + + :param operators: 一组 Operator 类 + :type operators: List[Operator] + + .. py:method:: insert(index, operator) + + 在指定位置插入一个 Operator 类 + + :param index: 插入的位置 + :type index: int + :param operator: 一个 Operator + :type operator: Operator + + .. py:method:: pop(index, operator) + + 在指定位置或者指定 Operator 下删除一个 Operator 类 + + :param index: 指定删除的 Operator 的索引位置 + :type index: int + :param operator: 指定删除的 Operator + :type operator: Operator, optional + + .. py:method:: forward(state) + + 前向传播输入数据 + + :param state: 输入数据 + :type state: Any + + :return: 输出数据 + :rtype: Any diff --git a/docs_zh_CN/source/paddle_quantum.ansatz.rst b/docs_zh_CN/source/paddle_quantum.ansatz.rst new file mode 100644 index 0000000..b326a1a --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.ansatz.rst @@ -0,0 +1,13 @@ +paddle\_quantum.ansatz +============================== + +各种电路拟设的功能实现。 + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.ansatz.circuit + paddle_quantum.ansatz.container + paddle_quantum.ansatz.vans diff --git a/docs_zh_CN/source/paddle_quantum.ansatz.vans.rst b/docs_zh_CN/source/paddle_quantum.ansatz.vans.rst new file mode 100644 index 0000000..18d3b80 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.ansatz.vans.rst @@ -0,0 +1,113 @@ +paddle\_quantum.ansatz.vans +================================== + +可变结构电路的功能实现。 + +.. py:class:: Inserter + + 基类: :py:class:`object` + + 用于向电路中加入模块的插入器类。 + + .. py:classmethod:: insert_identities(cir, insert_rate, epsilon) + + 根据插入比例，向当前量子电路中添加电路模块。 + + :param cir: 输入量子电路。 + :type cir: Circuit + :param insert_rate: 添加速率。 + :type insert_rate: float + :param epsilon: 添加模块初始化参数的浮动范围。 + :type epsilon: float + :return: 插入后的电路。 + :rtype: Circuit + +.. py:class:: Simplifier + + 基类: :py:class:`object` + + 用于电路简化的简化器类。 + + .. py:classmethod:: simplify_circuit(cir, zero_init_state=True) + + 根据简化规则删除电路中的量子门。 + + :param cir: 待简化电路。 + :type cir: Circuit + :param zero_init_state: 量子电路作用的初始态是否为 :math:`|0\rangle`，默认为 ``True``。 + :type zero_init_state: bool, optional + :return: 简化后的电路。 + :rtype: Circuit + +.. py:function:: cir_decompose(cir) + + 将电路中的 Layer 分解成量子门。 + + :param cir: 待分解电路。 + :type cir: Circuit + :return: 分解后的电路。 + :rtype: Circuit + + .. note:: + + 该函数不支持自定义门，如 oracle 和 control-oracle。 + +.. py:class:: VAns(n, loss_func, *loss_func_args, epsilon=0.1, insert_rate=2, iter=100, iter_out=10, LR =0.1, threshold=0.002, accept_wall=100, zero_init_state=True) + + 基类: :py:class:`object` + + 自动优化电路结构的 VAns 类。 + + .. note:: + + 输入的损失函数的第一个参数必须为量子电路。 + + :param n: 量子比特数量。 + :type n: int + :param loss_func: 损失函数。 + :type loss_func: Callable[[Circuit, Any], paddle.Tensor] + :param \*loss_func_args: 损失函数除了电路以外的所有参数。 + :type \*loss_func_args: Any + :param epsilon: 添加模块的初始化参数浮动范围，默认为 ``0.1``。 + :type epsilon: float, optional + :param insert_rate: 添加率，控制一次添加模块的数量，默认为 ``2``。 + :type insert_rate: float, optional + :param iter: 优化参数迭代次数，默认为 ``100``。 + :type iter: int, optional + :param iter_out: 优化结构的迭代次数，默认为 ``10``。 + :type iter_out: int, optional + :param LR: 学习率，默认为 ``0.1``。 + :type LR: float, optional + :param threshold: 删除量子门时允许损失上升的阈值，默认为 ``0.002``。 + :type threshold: float, optional + :param accept_wall: 完成一轮结构优化后的电路采纳率，默认为 ``100``。 + :type accept_wall: float, optional + :param zero_init_state: 电路作用的初始态是否为 :math:`|0\rangle`，默认为 ``True``。 + :type zero_init_state: bool, optional + + .. py:method:: train() + + 使用 VAns 方法进行训练。 + + :return: 优化过程中损失最低的电路。 + :rtype: Circuit + + .. py:method:: optimization(cir) + + 对电路参数进行优化。 + + :param cir: 当前电路。 + :type cir: Circuit + :return: 优化后的损失值。 + :rtype: float + + .. py:method:: delete_gates(cir, loss) + + 在损失增加小于一定阈值的情况下，删除电路中的参数化量子门以进一步简化电路。 + + :param cir: 目标量子电路。 + :type cir: Circuit + :param loss: 当前损失值。 + :type loss: float + :return: 删除多余量子门后的电路。 + :rtype: Circuit diff --git a/docs_zh_CN/source/paddle_quantum.backend.density_matrix.rst b/docs_zh_CN/source/paddle_quantum.backend.density_matrix.rst new file mode 100644 index 0000000..97d9ace --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.backend.density_matrix.rst @@ -0,0 +1,19 @@ +paddle\_quantum.backend.density\_matrix +============================================== + +密度矩阵后端的功能实现。 + +.. py:function:: paddle_quantum.backend.density_matrix.unitary_transformation(state, gate, qubit_idx, num_qubits) + + 在密度矩阵模式下实现酉变换的函数。 + + :param state: 输入的量子态。 + :type state: paddle.Tensor + :param gate: 输入量子门，表示要进行的酉变换。 + :type gate: paddle.Tensor + :param qubit_idx: 量子门要作用到的量子比特的下标。 + :type qubit_idx: Union[List[int], int] + :param num_qubits: 输入的量子态所拥有的量子比特的数量。 + :type num_qubits: int + :return: 变换后的量子态。 + :rtype: paddle.Tensor diff --git a/docs_zh_CN/source/paddle_quantum.backend.quleaf.rst b/docs_zh_CN/source/paddle_quantum.backend.quleaf.rst new file mode 100644 index 0000000..8d54597 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.backend.quleaf.rst @@ -0,0 +1,66 @@ +paddle\_quantum.backend.quleaf +===================================== + +量易伏后端的功能实现。 + +.. py:function:: set_quleaf_backend(backend) + + 设置量易伏的后端实现。 + + :param backend: 你想要设置的后端名称。 + :type backend: str + +.. py:function:: get_quleaf_backend() + + 得到量易伏的当前后端。 + + :return: 量易伏当前的后端名称。 + :rtype: QCompute.BackendName + +.. py:function:: set_quleaf_token(token) + + 设置量易伏的 token。 + + 当使用云端服务器的时候，需要输入 token 才能使用。 + + :param token: 你的 token。 + :type token: str + +.. py:function:: get_quleaf_token() + + 得到量易伏的当前 token。 + + :return: 你所设置的 token。 + :rtype: str + +.. py:class:: ExpecValOp(paddle.autograd.PyLayer) + + 基类：:py:class:`paddle.autograd.PyLayer` + + .. py:staticmethod:: forward(ctx, param, state, hamiltonian, shots) + + 前向函数，用于在量易伏后端中实现可观测量对于量子态的期望值的算子。 + + :param ctx: 用于保持在反向传播过程中可能用到的变量。 + :type ctx: paddle.autograd.PyLayerContext + :param param: 在先前的量子门中所包含的参数。 + :type param: paddle.Tensor + :param state: 要被测量的量子态。 + :type state: paddle_quantum.State + :param hamiltonian: 可观测量。 + :type hamiltonian: paddle_quantum.Hamiltonian + :param shots: 测量次数。 + :type shots: int + :return: 可观测量对量子态的期望值。 + :rtype: paddle.Tensor + + .. py:staticmethod:: backward(ctx, expec_val_grad) + + 反向传播函数，用于计算输入参数的梯度。 + + :param ctx: 得到前向函数中存储的变量。 + :type ctx: paddle.autograd.PyLayerContext + :param expec_val_grad: 期望值本身已有的梯度。 + :type expec_val_grad: paddle.Tensor + :return: 量子门的参数的梯度值。 + :rtype: paddle.Tensor diff --git a/docs_zh_CN/source/paddle_quantum.backend.rst b/docs_zh_CN/source/paddle_quantum.backend.rst new file mode 100644 index 0000000..ecef349 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.backend.rst @@ -0,0 +1,32 @@ +paddle\_quantum.backend +=============================== + +包含多种后端的模块。 + +.. py:class:: paddle_quantum.backend.Backend(value) + + 基类：:py:class:`enum.Enum` + + 一种枚举。 + + .. py:data:: StateVector + :value: 'state_vector' + + .. py:data:: DensityMatrix + :value: 'density_matrix' + + .. py:data:: QuLeaf + :value: 'quleaf' + + .. py:data:: UnitaryMatrix + :value: 'unitary_matrix' + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.backend.density_matrix + paddle_quantum.backend.quleaf + paddle_quantum.backend.state_vector + paddle_quantum.backend.unitary_matrix diff --git a/docs_zh_CN/source/paddle_quantum.backend.state_vector.rst b/docs_zh_CN/source/paddle_quantum.backend.state_vector.rst new file mode 100644 index 0000000..4611d94 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.backend.state_vector.rst @@ -0,0 +1,19 @@ +paddle\_quantum.backend.state\_vector +============================================ + +态矢量后端的功能实现。 + +.. py:function:: paddle_quantum.backend.state_vector.unitary_transformation(state, gate, qubit_idx, num_qubits) + + 在态矢量模式下实现酉变换的函数。 + + :param state: 输入的量子态。 + :type state: paddle.Tensor + :param gate: 输入量子门，表示要进行的酉变换。 + :type gate: paddle.Tensor + :param qubit_idx: 量子门要作用到的量子比特的下标。 + :type qubit_idx: Union[List[int], int] + :param num_qubits: 输入的量子态所拥有的量子比特的数量。 + :type num_qubits: int + :return: 变换后的量子态。 + :rtype: paddle.Tensor diff --git a/docs_zh_CN/source/paddle_quantum.backend.unitary_matrix.rst b/docs_zh_CN/source/paddle_quantum.backend.unitary_matrix.rst new file mode 100644 index 0000000..805b413 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.backend.unitary_matrix.rst @@ -0,0 +1,19 @@ +paddle\_quantum.backend.unitary\_matrix +============================================== + +计算酉矩阵的后端的功能实现。 + +.. py:function:: paddle_quantum.backend.unitary_matrix.unitary_transformation(state, gate, qubit_idx, num_qubits) + + 在计算酉矩阵模式下实现酉变换的函数。 + + :param state: 输入的量子态。 + :type state: paddle.Tensor + :param gate: 输入量子门，表示要进行的酉变换。 + :type gate: paddle.Tensor + :param qubit_idx: 量子门要作用到的量子比特的下标。 + :type qubit_idx: Union[List[int], int] + :param num_qubits: 输入的量子态所拥有的量子比特的数量。 + :type num_qubits: int + :return: 变换后的量子态。 + :rtype: paddle.Tensor diff --git a/docs_zh_CN/source/paddle_quantum.base.rst b/docs_zh_CN/source/paddle_quantum.base.rst new file mode 100644 index 0000000..47b2559 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.base.rst @@ -0,0 +1,59 @@ +paddle\_quantum.base +=========================== + +量桨的基础函数的功能实现。 + +.. py:function:: set_device(device) + + 设置量桨的 tensor 的存储设备。 + + :param device: 要设置的设备名称。 + :type backend: str + +.. py:function:: get_device() + + 得到当前量桨的 tensor 的存储设备名称。 + + :return: 当前的设备名称。 + :rtype: str + +.. py:function:: set_backend(backend) + + 设置量桨的后端实现方式。 + + :param backend: 要设置的后端实现方式。 + :type backend: Union[str, paddle_quantum.Backend] + +.. py:function:: get_backend() + + 得到量桨的当前后端实现方式。 + + :return: 量桨当前的后端名称。 + :rtype: paddle_quantum.Backend + +.. py:function:: set_dtype(dtype) + + 设置量桨中变量的数据类型。 + + :param dtype: 你想要设置的数据类型，可以是 ``complex64`` 或 ``complex128``。 + :type dtype: str + +.. py:function:: get_dtype() + + 得到当前量桨中变量的数据类型。 + + :return: 当前的数据类型。 + :rtype: str + +.. py:class:: paddle_quantum.base.Operator(backend=None, dtype=None, name_scope=None) + + 基类：:py:class:`paddle.fluid.dygraph.layers.Layer` + + 用于实现量子操作的基类 + + :param backend: 量子操作的后端实现方式。默认为 ``None``，使用默认方式。 + :type backend: paddle_quantum.Backend, optional + :param dtype: 量子操作中的数据类型。默认为 ``None``，使用默认类型。 + :type dtype: str, optional + :param name_scope: 为 Operator 内部参数命名而采用的名称前缀。默认为 ``None``，没有前缀。 + :type name_scope: str, optional diff --git a/docs_zh_CN/source/paddle_quantum.channel.base.rst b/docs_zh_CN/source/paddle_quantum.channel.base.rst new file mode 100644 index 0000000..dc0d8ff --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.channel.base.rst @@ -0,0 +1,19 @@ +paddle\_quantum.channel.base +=================================== + +量子信道基类的功能实现。 + +.. py:class:: Channel(backend=None, dtype=None, name_scope=None) + + 基类：:py:class:`paddle_quantum.base.Operator` + + 量子信道的基类。 + + :param backend: 执行信道的后端，默认为 ``None``。 + :type backend: paddle_quantum.Backend, optional + :param dtype: 数据的类型, 默认为 ``None``。 + :type dtype: str, optional + :param name_scope: 为 Layer 内部参数命名而采用的名称前缀。如果前缀为 "my_layer"，在一个类名为MyLayer的Layer中， + 参数名为"my_layer_0.w_n"，其中 "w" 是参数的名称，"n" 为自动生成的具有唯一性的后缀。如果为 ``None``， + 前缀名将为小写的类名。默认为 ``None``。 + :type name_scope: str, optional diff --git a/docs_zh_CN/source/paddle_quantum.channel.common.rst b/docs_zh_CN/source/paddle_quantum.channel.common.rst new file mode 100644 index 0000000..6545f6d --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.channel.common.rst @@ -0,0 +1,251 @@ +paddle\_quantum.channel.common +===================================== + +常用的量子信道的功能实现。 + +.. py:class:: BitFlip(prob, qubits_idx='full', num_qubits) + + 基类：:py:class:`paddle_quantum.channel.base.Channel` + + 比特反转信道。 + + 其 Kraus 算符为： + + .. math:: + + E_0 = \sqrt{1-p} I, + E_1 = \sqrt{p} X. + + :param prob: 发生比特反转的概率，其值应该在 :math:`[0, 1]` 区间内。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + +.. py:class:: PhaseFlip(prob, qubits_idx='full', num_qubits) + + 基类：:py:class:`paddle_quantum.channel.base.Channel` + + 相位反转信道。 + + 其 Kraus 算符为： + + .. math:: + + E_0 = \sqrt{1 - p} I, + E_1 = \sqrt{p} Z. + + :param prob: 发生相位反转的概率，其值应该在 :math:`[0, 1]` 区间内。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + +.. py:class:: BitPhaseFlip(prob, qubits_idx='full', num_qubits) + + 基类：:py:class:`paddle_quantum.channel.base.Channel` + + 比特相位反转信道。 + + 其 Kraus 算符为： + + .. math:: + + E_0 = \sqrt{1 - p} I, + E_1 = \sqrt{p} Y. + + :param prob: 发生比特相位反转的概率，其值应该在 :math:`[0, 1]` 区间内。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + +.. py:class:: AmplitudeDamping(gamma, qubits_idx='full', num_qubits) + + 基类：:py:class:`paddle_quantum.channel.base.Channel` + + 振幅阻尼信道。 + + 其 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}. + + :param gamma: 减振概率，其值应该在 :math:`[0, 1]` 区间内。 + :type gamma: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + +.. py:class:: GeneralizedAmplitudeDamping(gamma, prob, qubits_idx='full', num_qubits) + + 基类：:py:class:`paddle_quantum.channel.base.Channel` + + 广义振幅阻尼信道。 + + 其 Kraus 算符为： + + .. math:: + + 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}. + + :param gamma: 减振概率，其值应该在 :math:`[0, 1]` 区间内。 + :type gamma: Union[paddle.Tensor, float] + :param prob: 激发概率，其值应该在 :math:`[0, 1]` 区间内。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + +.. py:class:: PhaseDamping(gamma, qubits_idx='full', num_qubits) + + 基类：:py:class:`paddle_quantum.channel.base.Channel` + + 相位阻尼信道。 + + 其 Kraus 算符为： + + .. math:: + + E_0 = + \begin{bmatrix} + 1 & 0 \\ + 0 & \sqrt{1-\gamma} + \end{bmatrix}, + E_1 = + \begin{bmatrix} + 0 & 0 \\ + 0 & \sqrt{\gamma} + \end{bmatrix}. + + :param gamma: 该信道的参数，其值应该在 :math:`[0, 1]` 区间内。 + :type gamma: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + +.. py:class:: Depolarizing(prob, qubits_idx='full', num_qubits) + + 基类：:py:class:`paddle_quantum.channel.base.Channel` + + 去极化信道。 + + 其 Kraus 算符为： + + .. math:: + + E_0 = \sqrt{1-p} I, + E_1 = \sqrt{p/3} X, + E_2 = \sqrt{p/3} Y, + E_3 = \sqrt{p/3} Z. + + :param prob: 该信道的参数，其值应该在 :math:`[0, 1]` 区间内。 + :type prob: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + +.. py:class:: PauliChannel(prob, qubits_idx='full', num_qubits) + + 基类：:py:class:`paddle_quantum.channel.base.Channel` + + 泡利信道。 + + :param prob: 泡利算符 X、Y、Z 对应的概率，各值均应在 :math:`[0, 1]` 区间内。 + :type prob: Union[paddle.Tensor, Iterable[float]] + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. note:: + + 三个输入的概率加起来需要小于等于 1。 + +.. py:class:: ResetChannel(prob, qubits_idx='full', num_qubits) + + 基类：:py:class:`paddle_quantum.channel.base.Channel` + + 重置信道。 + + 该信道以 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_4 = \sqrt{1-p-q} I. + + :param prob: 重置为 :math:`|0\rangle` 和重置为 :math:`|1\rangle` 的概率，各值均应在 :math:`[0, 1]` 区间内。 + :type prob: Union[paddle.Tensor, Iterable[float]] + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. note:: + + 两个输入的概率加起来需要小于等于 1。 + +.. py:class:: ThermalRelaxation(const_t, exec_time, qubits_idx='full', num_qubits=None) + + 基类：:py:class:`paddle_quantum.channel.base.Channel` + + 热弛豫信道。 + + 该信道模拟超导硬件上的 T1 和 T2 混合过程。 + + :param const_t: :math:`T_1` 和 :math:`T_2` 过程的弛豫时间常数，单位是微秒。 + :type const_t: Union[paddle.Tensor, Iterable[float]] + :param exec_time: 弛豫过程中量子门的执行时间，单位是纳秒。 + :type exec_time: Union[paddle.Tensor, float] + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + + .. note:: + + 时间常数必须满足 :math:`T_2 \le T_1`，见参考文献 https://arxiv.org/abs/2101.02109。 diff --git a/docs_zh_CN/source/paddle_quantum.channel.custom.rst b/docs_zh_CN/source/paddle_quantum.channel.custom.rst new file mode 100644 index 0000000..4c79d0c --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.channel.custom.rst @@ -0,0 +1,21 @@ +paddle\_quantum.channel.custom +===================================== + +自定义量子信道的类的功能实现。 + +.. py:class:: KrausRepr(kraus_oper, qubits_idx, num_qubits=None) + + 基类：:py:class:`paddle_quantum.channel.base.Channel` + + Kraus 表示的自定义量子信道。 + + :param kraus_oper: 该信道的 Kraus 算符。 + :type kraus_oper: Iterable[paddle.Tensor] + :param qubits_idx: 作用在的量子比特的编号。 + :type qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int] + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + +.. py:class:: ChoiRepr() + + 基类：:py:class:`paddle_quantum.channel.base.Channel` diff --git a/docs_zh_CN/source/paddle_quantum.channel.functional.common.rst b/docs_zh_CN/source/paddle_quantum.channel.functional.common.rst new file mode 100644 index 0000000..40e421c --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.channel.functional.common.rst @@ -0,0 +1,208 @@ +paddle\_quantum.channel.functional.common +================================================ + +常见量子信道的函数的功能实现。 + +.. py:function:: bit_flip(state, prob, qubit_idx, dtype, backend) + + 在输入态上作用一个比特反转信道。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param prob: 发生比特反转的概率。 + :type prob: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :raises RuntimeError: 噪声信道只能在密度矩阵模式下运行。 + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: phase_flip(state, prob, qubit_idx, dtype, backend) + + 在输入态上作用一个相位反转信道。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param prob: 发生相位反转的概率。 + :type prob: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :raises RuntimeError: 噪声信道只能在密度矩阵模式下运行。 + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: bit_phase_flip(state, prob, qubit_idx, dtype, backend) + + 在输入态上作用一个比特相位反转信道。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param prob: 发生比特相位反转的概率。 + :type prob: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :raises RuntimeError: 噪声信道只能在密度矩阵模式下运行。 + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: amplitude_damping(state, gamma, qubit_idx, dtype, backend) + + 在输入态上作用一个振幅阻尼信道。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param gamma: 减振概率。 + :type gamma: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :raises RuntimeError: 噪声信道只能在密度矩阵模式下运行。 + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: generalized_amplitude_damping(state, gamma, prob, qubit_idx, dtype, backend) + + 在输入态上作用一个广义振幅阻尼信道。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param gamma: 减振概率。 + :type gamma: paddle.Tensor + :param prob: 激发概率。 + :type prob: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :raises RuntimeError: 噪声信道只能在密度矩阵模式下运行。 + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: phase_damping(state, gamma, qubit_idx, dtype, backend) + + 在输入态上作用一个相位阻尼信道。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param gamma: 该信道的参数。 + :type gamma: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :raises RuntimeError: 噪声信道只能在密度矩阵模式下运行。 + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: depolarizing(state, prob, qubit_idx, dtype, backend) + + 在输入态上作用一个去极化信道。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param prob: 该信道的参数。 + :type prob: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :raises RuntimeError: 噪声信道只能在密度矩阵模式下运行。 + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: pauli_channel(state, prob, qubit_idx, dtype, backend) + + 在输入态上作用一个泡利信道。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param prob: 泡利算符 X、Y、Z 对应的概率。 + :type prob: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :raises RuntimeError: 噪声信道只能在密度矩阵模式下运行。 + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: reset_channel(state, prob, qubit_idx, dtype, backend) + + 在输入态上作用一个重置信道。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param prob: 重置为 :math:`|0\rangle` 和重置为 :math:`|1\rangle` 的概率。 + :type prob: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :raises RuntimeError: 噪声信道只能在密度矩阵模式下运行。 + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: thermal_relaxation(state, const_t, exec_time, qubit_idx, dtype, backend) + + 在输入态上作用一个热弛豫信道。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param const_t: :math:`T_1` 和 :math:`T_2` 过程的弛豫时间常数，单位是微秒。 + :type const_t: paddle.Tensor + :param exec_time: 弛豫过程中量子门的执行时间，单位是纳秒。 + :type exec_time: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :raises RuntimeError: 噪声信道只能在密度矩阵模式下运行。 + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: kraus_repr(state, kraus_oper, qubit_idx:, dtype, backend) + + 在输入态上作用一个 Kraus 表示的自定义量子信道。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param kraus_oper: 该信道的 Kraus 算符。 + :type kraus_oper: Iterable[paddle.Tensor] + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :raises RuntimeError: 噪声信道只能在密度矩阵模式下运行。 + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: choi_repr() diff --git a/docs_zh_CN/source/paddle_quantum.channel.functional.rst b/docs_zh_CN/source/paddle_quantum.channel.functional.rst new file mode 100644 index 0000000..38a968f --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.channel.functional.rst @@ -0,0 +1,12 @@ +paddle\_quantum.channel.functional +========================================== + +各种量子信道的函数的功能实现。 + +Submodules +---------- + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.channel.functional.common diff --git a/docs_zh_CN/source/paddle_quantum.channel.rst b/docs_zh_CN/source/paddle_quantum.channel.rst new file mode 100644 index 0000000..caf396f --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.channel.rst @@ -0,0 +1,25 @@ +paddle\_quantum.channel +=============================== + +量子信道的功能实现。 + +.. automodule:: paddle_quantum.channel + :members: + :undoc-members: + :show-inheritance: + +.. rubric:: Subpackages + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.channel.functional + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.channel.base + paddle_quantum.channel.common + paddle_quantum.channel.custom diff --git a/docs_zh_CN/source/paddle_quantum.dataset.rst b/docs_zh_CN/source/paddle_quantum.dataset.rst new file mode 100644 index 0000000..1e3cedf --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.dataset.rst @@ -0,0 +1,242 @@ +paddle\_quantum.dataset +============================== + +数据集的功能实现。 + +.. py:class:: Dataset() + + 基类: :py:class:`object` + + 所有数据集的基类，集成了多种量子编码方法。 + + .. py:method:: data2circuit(classical_data, encoding, num_qubits, can_describe_dimension, split_circuit,return_state: bool, is_image=False) + + 将输入的经典数据 ``classical_data`` 用编码方式 ``encoding`` 编码成量子态，这里的经典数据经过了截断或者补零，因而可以正好被编码。 + + :param classical_data: 待编码的向量，经过了截断或者补零，刚好可以被编码。 + :type classical_data: list + :param encoding: 编码方式，参见 MNIST 编码注释。 + :type encoding: str + :param num_qubits: 量子比特数目。 + :type num_qubits: int + :param can_describe_dimension: ``encoding`` 编码方式可以编码的数目。 + :type can_describe_dimension: int + :param split_circuit: 是否切分电路。 + :type split_circuit: bool + :param return_state: 是否返回量子态。 + :type return_state: bool + :param is_image: 是否是图片，如果是图片，归一化方法不同。 + :type is_image: bool, optional + + :raises Exception: 暂不支持返回 amplitude encoding 的电路。 + + :return: 如果 ``return_state == True`` ，返回编码后的量子态，否则返回编码的电路。 + :rtype: list + + .. py:method:: filter_class(x, y, classes, data_num, need_relabel, seed=0) + + 将输入的 ``x`` , ``y`` 按照 ``classes`` 给出的类别进行筛选，数目为 ``data_num``。 + + :param x: 样本的特征。 + :type x: Union[list, np.ndarray] + :param y: 样本标签。 + :type y: Union[list, np.ndarray] + :param classes: 需要筛选的类别。 + :type classes: list + :param data_num: 筛选出来的样本数目。 + :type data_num: int + :param need_relabel: 将原有类别按照顺序重新标记为 0、1、2 等新的名字，比如传入 ``[1,2]`` ， 重新标记之后变为 ``[0,1]`` 主要用于二分类。 + :type need_relabel: bool + :param seed: 随机种子，默认为 ``0``。 + :type seed: int, optional + + :return: + 包含如下元素: + + - new_x: 筛选出的特征 + - new_y: 对应于 new_x 的标签 + :rtype: Tuple[list] + + +.. py:class:: VisionDataset(figure_size) + + 基类: :py:class:`paddle_quantum.dataset.Dataset` + + 图片数据集类，通过继承 VisionDataset 类，用户可以快速生成自己的图片量子数据。 + + :param figure_size: 图片大小，也就是长和高的数值。 + :type figure_size: int + + .. py:method:: encode(feature, encoding, num_qubits, split_circuit, downscaling_method='resize', target_dimension=-1, return_state=True, full_return=False) + + 将 ``feature`` 编码到 ``num_qubits`` 量子比特中，再降维到 ``target_dimension`` 后使用 ``encoding``。 ``feature`` 是一维的图像向量。 + + :param feature: 一维图片向量组成的list/ndarray。 + :type feature: Union[list, np.ndarray] + :param encoding: ``angle_encoding`` 表示角度编码，一个量子比特编码一个旋转门； ``amplitude_encoding`` 表示振幅编码； ``pauli_rotation_encoding`` 表示SU(3)的角度编码; 还有 ``linear_entangled_encoding`` , ``real_entangled_encoding`` , ``complex_entangled_encoding`` 和 ``IQP_encoding`` 编码。 + :type encoding: str + :param num_qubits: 编码后的量子比特数目。 + :type num_qubits: int + :param split_circuit: 是否需要切分电路。除了振幅之外的所有电路都会存在堆叠的情况，如果选择 ``True`` 就将块与块分开，默认为 ``False``。 + :type split_circuit: bool, optional + :param downscaling_method: 包括 ``PCA`` 和 ``resize``, 默认为 ``resize``。 + :type downscaling_method: str, optional + :param target_dimension: 降维之后的尺度大小，如果是 ``PCA`` ，不能超过图片大小；如果是 ``resize`` ，不能超过原图大小，默认为 ``-1``。 + :type target_dimension: int, optional + :param return_state: 是否返回量子态，如果是 ``False`` 返回量子电路，默认为 ``True``。 + :type return_state: bool, optional + :param full_return: 是否返回原始图像, 经典图像矢量, 量子态和量子电路, 默认为 ``False``。 + :type full_return: bool, optional + + :raises Exception: PCA维度应小于图片大小。 + :raises Exception: 调整大小的尺寸应该是一个平方数。 + :raises Exception: 缩小尺寸的方法只能是 resize 和 PCA。 + :raises Exception: 无效的编码方法。 + + :return: + 包含如下元素: + + - quantum_image_states: 量子态，只有 ``full_return==True`` 或者 ``return_state==True`` 的时候会返回。 + - quantum_image_circuits: 所有特征编码的电路，只有 ``full_return==False`` 或者 ``return_state==True`` 的时候会返回。 + - 图片经过类别过滤，但是还没有降维、补零的特征，是一个一维向量（可以 reshape 成图片），只有 ``return_state==True`` 的时候会返回。 + - 经过类别过滤和降维、补零等操作之后的特征，并未编码为量子态，只有 ``return_state==True`` 的时候会返回。 + :rtype: Tuple[paddle.Tensor, list, np.ndarray, np.ndarray] + +.. py:class:: MNIST(mode, encoding, num_qubits, classes, data_num=-1, split_circuit=False, downscaling_method='resize', target_dimension=-1, need_cropping=True, need_relabel=True, return_state=True, seed=0) + + 基类: :py:class:`paddle_quantum.dataset.VisionDataset` + + MNIST 数据集，它继承了 VisionDataset 图片数据集类。 + + :param mode: 数据模式，包括 ``train`` 和 ``test``。 + :type mode: str + :param encoding: ``angle_encoding`` 表示角度编码，一个量子比特编码一个旋转门； ``amplitude_encoding`` 表示振幅编码； ``pauli_rotation_encoding`` 表示SU(3)的角度编码; 还有 ``linear_entangled_encoding`` , ``real_entangled_encoding`` , ``complex_entangled_encoding`` 和 ``IQP_encoding`` 编码。 + :type encoding: str + :param num_qubits: 编码后的量子比特数目。 + :type num_qubits: int + :param classes: 用列表给出需要的类别，类别用数字标签表示。 + :type classes: list + :param data_num: 使用的数据量大小, 默认为 ``-1``。 + :type data_num: int, optional + :param split_circuit: 是否需要切分电路。除了振幅之外的所有电路都会存在堆叠的情况，如果选择 ``True`` 就将块与块分开。 + :type split_circuit: bool, optional + :param downscaling_method: 包括 ``PCA`` 和 ``resize``。默认为 ``resize``。 + :type downscaling_method: str, optional + :param target_dimension: 降维之后的尺度大小，如果是 ``PCA`` ，不能超过图片大小；如果是 ``resize`` ，不能超过原图大小。 + :type target_dimension: int, optional + :param need_cropping: 是否需要裁边，如果为 ``True`` ，则从 ``image[0:27][0:27]`` 裁剪为 ``image[4:24][4:24]``。 + :type need_cropping: bool, optional + :param need_relabel: 将原有类别按照顺序重新标记为 0, 1, 2 等新的名字，比如传入 ``[1,2]`` ，重新标记之后变为 ``[0,1]`` ，主要用于二分类。 + :type need_relabel: bool, optional + :param return_state: 是否返回量子态，如果是 ``False`` 返回量子电路。 + :type return_state: bool, optional + :param seed: 筛选样本的随机种子，默认为 ``0``。 + :type seed: int, optional + + :raises Exception: 数据模式只能为训练和测试。 + +.. py:class:: FashionMNIST(mode, encoding, num_qubits, classes, data_num=-1, split_circuit=False, downscaling_method, target_dimension=-1, need_relabel=True, return_state=True, seed=0) + + 基类: :py:class:`paddle_quantum.dataset.VisionDataset` + + FashionMNIST 数据集，它继承了 ``VisionDataset`` 图片数据集类。 + + :param mode: 数据模式，包括 ``train`` 和 ``test``。 + :type mode: str + :param encoding: ``angle_encoding`` 表示角度编码，一个量子比特编码一个旋转门； ``amplitude_encoding`` 表示振幅编码； ``pauli_rotation_encoding`` 表示SU(3)的角度编码; 还有 ``linear_entangled_encoding`` , ``real_entangled_encoding`` , ``complex_entangled_encoding`` 和 ``IQP_encoding`` 编码。 + :type encoding: str + :param num_qubits: 编码后的量子比特数目。 + :type num_qubits: int + :param classes: 用列表给出需要的类别，类别用数字标签表示。 + :type classes: list + :param data_num: 使用的数据量大小，默认为 ``-1``。 + :type data_num: int, optional + :param split_circuit: 是否需要切分电路。除了振幅之外的所有电路都会存在堆叠的情况，如果选择 ``True`` 就将块与块分开， 默认为 ``False``。 + :type split_circuit: bool, optional + :param downscaling_method: 包括 ``PCA`` 和 ``resize``，默认为 ``resize``。 + :type downscaling_method: str, optional + :param target_dimension: 降维之后的尺度大小，如果是 ``PCA`` ，不能超过图片大小；如果是 ``resize`` ，不能超过原图大小， 默认为 ``-1``。 + :type target_dimension: int, optional + :param need_relabel: 将原有类别按照顺序重新标记为 0, 1, 2 等新的名字，比如传入 ``[1,2]`` ，重新标记之后变为 ``[0,1]`` ，主要用于二分类， 默认为 ``True``。 + :type need_relabel: bool, optional + :param return_state: 是否返回量子态，如果是 ``False`` 返回量子电路， 默认为 ``True``。 + :type return_state: bool, optional + :param seed: 筛选样本的随机种子，默认为 ``0``。 + :type seed: int, optional + + :raises Exception: 数据模式只能为训练和测试。 + +.. py:class:: SimpleDataset(dimension) + + 基类: :py:class:`paddle_quantum.dataset.Dataset` + + 用于不需要降维的简单分类数据。用户可以通过继承 ``SimpleDataset`` ，将自己的分类数据变为量子态。下面的几个属性也会被继承。 + + :param dimension: 编码数据的维度。 + :type dimension: int + + .. py:method:: encode(feature, encoding, num_qubits, return_state = True, full_return = False) + + 用 ``num_qubits`` 的量子比特对 ``feature`` 进行编码 ``encoding``。 + + :param feature: 编码的特征，每一个分量都是一个 ndarray 的特征向量。 + :type feature: Union[list, np.ndarray] + :param encoding: 编码方法。 + :type encoding: str + :param num_qubits: 编码的量子比特数目。 + :type num_qubits: int + :param return_state: 是否返回量子态，默认为 ``True``。 + :type return_state: bool, optional + :param full_return: 是否返回原始图像, 经典图像矢量, 量子态和量子电路, 默认为 ``False``。 + :type full_return: bool, optional + + :raises Exception: 无效特征类型。 + :raises Exception: 无效编码方式。 + :raises Exception: 量子比特数不足。 + + :return: + 包含如下元素: + + - quantum_states: 量子态，只有 ``full_return==True`` 或者 ``return_state==True`` 的时候会返回。 + - quantum_circuits: 所有特征编码的电路，只有 ``full_return==False`` 或者 ``return_state==True`` 的时候会返回。 + - origin_feature: 经过类别过滤之后的所有特征，并未编码为量子态，只有 ``return_state==True`` 的时候会返回。 + - feature: ``origin_feature`` 经过了补零之后的特征， ``quantum_states`` 就是将 ``feature`` 编码之后的结果。 只有 ``return_state==True`` 的时候会返回。 + :rtype: Tuple[np.ndarray, list, np.ndarray, np.ndarray] + +.. py:class:: Iris(encoding: str, num_qubits: int, classes: list, test_rate: float=0.2, need_relabel=True, return_state=True, seed=0) + + 基类: :py:class:`paddle_quantum.dataset.SimpleDataset` + + Iris 数据集。 + + :param encoding: ``angle_encoding`` 表示角度编码，一个量子比特编码一个旋转门； ``amplitude_encoding`` 表示振幅编码； ``pauli_rotation_encoding`` 表示SU(3)的角度编码; 还有 ``linear_entangled_encoding`` , ``real_entangled_encoding`` , ``complex_entangled_encoding`` 和 ``IQP_encoding`` 编码。 + :type encoding: str + :param num_qubits: 量子比特数目。 + :type num_qubits: int + :param classes: 用列表给出需要的类别，类别用数字标签表示。 + :type classes: list + :param test_rate: 测试集的占比, 默认为 ``0.2``。 + :type test_rate: float, optional + :param need_relabel: 将原有类别按照顺序重标记为 0、1、2 等新的名字，比如传入 [1,2] ，重标记之后变为 [0,1] ，主要用于二分类。默认为 ``True``。 + :type need_relabel: bool, optional + :param return_state: 是否返回量子态，默认为 ``True``。 + :type return_state: bool, optional + :param seed: 筛选样本的随机种子，默认为 ``0``。 + :type seed: int, optional + +.. py:class:: BreastCancer(encoding, num_qubits, test_rate=0.2, return_state=True, seed=0) + + 基类: :py:class:`paddle_quantum.dataset.SimpleDataset` + + BreastCancer 数据集。 + + :param encoding: ``angle_encoding`` 表示角度编码，一个量子比特编码一个旋转门； ``amplitude_encoding`` 表示振幅编码； ``pauli_rotation_encoding`` 表示SU(3)的角度编码; 还有 ``linear_entangled_encoding`` , ``real_entangled_encoding`` , ``complex_entangled_encoding`` 和 ``IQP_encoding`` 编码。 + :type encoding: _type_ + :param num_qubits: 量子比特数目。 + :type num_qubits: _type_ + :param test_rate: 测试集的占比, 默认为 ``0.2``。 + :type test_rate: float, optional + :param return_state: 是否返回量子态，默认为 ``True``。 + :type return_state: bool, optional + :param seed: 筛选样本的随机种子，默认为 ``0``。 + :type seed: int, optional diff --git a/docs_zh_CN/source/paddle_quantum.finance.rst b/docs_zh_CN/source/paddle_quantum.finance.rst new file mode 100644 index 0000000..2fef78c --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.finance.rst @@ -0,0 +1,130 @@ +paddle\_quantum.finance +======================= + +量子金融的相关函数和模拟器类。 + +.. py:class:: DataSimulator(stocks, start=None, end=None) + + 基类: :py:class:`object` + + 用于生成和计算投资组合优化和投资分散化问题要用的数据和相关参数。 + + :param stocks: 表示所有可投资股票的名字。 + :type stocks: list + :param start: 表示随机生成股票数据时交易日的起始日期, 默认为 ``None``。 + :type start: datetime, optional + :param end: 表示随机生成股票数据时交易日的结束日期, 默认为 ``None``。 + :type end: datetime, optional + + .. py:method:: set_data(data) + + 决定实验使用的数据是随机生成的还是用户本地输入。 + + :param data: 用户输入的股票数据。 + :type data: list + + .. py:method:: randomly_generate() + + 根据开始日期和结束日期随机生成用于实验的股票数据。 + + .. Note:: + + 若要随机生成股票数据，需要以 ``datetime`` 包中的格式指定开始日期和结束日期，如 ``start = datetime.datetime(2016, 1, 1)``。 + + .. py:method:: get_asset_return_mean_vector() + + 用于计算所有可投资股票的平均投资回报率。 + + :return: 所有可投资的股票的平均投资回报率。 + :rtype: list + + .. py:method:: get_asset_return_covariance_matrix() + + 用于计算所有可投资股票回报率之间的协方差矩阵。 + + :return: 所有可投资股票回报率之间的协方差矩阵。 + :rtype: list + + .. py:method:: get_similarity_matrix() + + 计算各股票之间的相似矩阵。 + + 通过动态时间规整算法（Dynamic Time Warping, DTW）计算两股票之间的相似性。 + + :return: 各股票间的相似矩阵。 + :rtype: list + +.. py:function:: portfolio_optimization_hamiltonian(penalty, mu, sigma, q, budget) + + 构建投资组合优化问题的哈密顿量。 + + :param penalty: 惩罚参数。 + :type penalty: int + :param mu: 各股票的预期回报率。 + :type mu: list + :param sigma: 各股票回报率间的协方差矩阵。 + :type sigma: list + :param q: 投资股票的风险。 + :type q: float + :param budget: 投资预算, 即要投资的股票数量。 + :type 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}`。 + + :return: 投资组合优化问题的哈密顿量。 + :rtype: paddle_quantum.Hamiltonian + +.. py:function:: portfolio_diversification_hamiltonian(penalty, rho, q) + + 构建投资组合分散化问题的哈密顿量。 + + :param penalty: 惩罚参数。 + :type penalty: int + :param rho: 各股票间的相似矩阵。 + :type rho: list + :param q: 股票聚类的类别数。 + :type q: int + + .. math:: + + \begin{aligned} + C_x &= -\sum_{i=1}^{n}\sum_{j=1}^{n}\rho_{ij}x_{ij} + A\left(q- \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}`。 + + :return: 投资组合分散化问题的哈密顿量。 + :rtype: paddle_quantum.Hamiltonian + +.. py:function:: arbitrage_opportunities_hamiltonian(g, penalty, n, k) + + 构建最佳套利机会问题的哈密顿量。 + + :param g: 不同货币市场间转换的图形化表示。 + :type g: networkx.DiGraph + :param penalty: 惩罚参数。 + :type penalty: int + :param n: 货币种类的数量，即图 g 中的顶点数量。 + :type n: int + :param k: 套利回路中包含的顶点数。 + :type 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}`。 + + :return: 最佳套利机会问题的哈密顿量。 + :rtype: paddle_quantum.Hamiltonian diff --git a/docs_zh_CN/source/paddle_quantum.fisher.rst b/docs_zh_CN/source/paddle_quantum.fisher.rst new file mode 100644 index 0000000..361e207 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.fisher.rst @@ -0,0 +1,180 @@ +paddle\_quantum.fisher +============================= + +Fisher 信息的功能实现。 + +.. py:class:: QuantumFisher(cir) + + 量子费舍信息及相关量的计算器。 + + :param cir: 需要计算量子费舍信息的参数化量子电路。 + :type cir: Circuit + + .. note:: + + 该类利用了二阶参数平移规则计算量子费舍信息矩阵，因此不能直接适用于单比特旋转门的参数间有依赖关系的情况，例如受控旋转门等。 + + .. py:method:: get_qfisher_matrix() + + :return: 量子费舍信息矩阵 + :rtype: np.ndarray + + .. code-block:: python + + import paddle + from paddle_quantum.ansatz import Circuit + from paddle_quantum.fisher import QuantumFisher + + cir = Circuit(1) + zero = paddle.zeros([1], dtype="float64") + cir.ry(param=zero) + cir.rz(param=zero) + + qf = QuantumFisher(cir) + qfim = qf.get_qfisher_matrix() + print(f'The QFIM at {cir.param.tolist()} is \n {qfim}.') + + :: + + The QFIM at [0.0, 0.0] is + [[1. 0.] + [0. 0.]]. + + .. py:method:: get_qfisher_norm(direction, step_size = 0.01) + + :param direction: 要计算量子费舍信息投影的方向。 + :type direction: np.ndarray + :param step_size: 有限差分的步长，默认为 ``0.01``。 + :type step_size: float + + :return: 沿给定方向的量子费舍信息的投影 + :rtype: float + + .. code-block:: python + + import paddle + from paddle_quantum.ansatz import Circuit + from paddle_quantum.fisher import QuantumFisher + + cir = Circuit(2) + zero = paddle.zeros([1], dtype="float64") + cir.ry(0, param=zero) + cir.ry(1, param=zero) + cir.cnot(qubits_idx=[0, 1]) + cir.ry(0, param=zero) + cir.ry(1, param=zero) + + qf = QuantumFisher(cir) + v = [1,1,1,1] + qfi_norm = qf.get_qfisher_norm(direction=v) + print(f'The QFI norm along {v} at {cir.param.tolist()} is {qfi_norm:.7f}') + + :: + + The QFI norm along [1, 1, 1, 1] at [0.0, 0.0, 0.0, 0.0] is 6.0031546 + + .. py:method:: get_eff_qdim(num_param_samples = 4, tol = None) + + :param num_param_samples: 用来估计有效量子维数时所用的参数样本量，默认为 4。 + :type num_param_samples: int + :param tol: 奇异值的最小容差，低于此容差的奇异值认为是 0, 默认为 None, 其含义同 ``numpy.linalg.matrix_rank()`` + :type tol: float + + :return: 给定量子电路对应的有效量子维数。 + :rtype: int + + .. code-block:: python + + import paddle + from paddle_quantum.ansatz import Circuit + from paddle_quantum.fisher import QuantumFisher + + cir = Circuit(1) + cir.rz(theta=paddle.to_tensor(0., dtype="float64", stop_gradient=False), which_qubit=0) + cir.ry(theta=paddle.to_tensor(0., dtype="float64", stop_gradient=False), which_qubit=0) + + qf = QuantumFisher(cir) + print(cir) + print(f'The number of parameters of -Rz-Ry- is {len(cir.get_param().tolist())}') + print(f'The effective quantum dimension -Rz-Ry- is {qf.get_eff_qdim()}') + + :: + + --Rz(0.000)----Ry(0.000)-- + + The number of parameters of -Rz-Ry- is 2 + The effective quantum dimension -Rz-Ry- is 1 + + .. py:method:: get_qfisher_rank(tol) + + :param tol: 奇异值的最小容差，低于此容差的奇异值认为是 0, 默认为 None, 其含义同 ``numpy.linalg.matrix_rank()`` + :type tol: float + + :return: 量子费舍信息矩阵的秩 + :rtype: int + +.. py:class:: ClassicalFisher(model, num_thetas, num_inputs, model_type = 'quantum', **kwargs) + + :param model: 经典或量子神经网络模型的实例 + :type model: paddle.nn.Layer + :param num_thetas: 参数集合的数量 + :type num_thetas: int + :param num_inputs: 输入的样本数量 + :type num_inputs: int + :param model_type: 模型是经典 ``classical`` 的还是量子 ``quantum`` 的，默认是量子的 + :type model_type: str + :param \*\*kwargs: 神经网络参数, 包含如下选项: + + - size (list): 经典神经网络各层神经元的数量 \\ + - num_qubits (int): 量子神经网络量子比特的数量 \\ + - depth (int): 量子神经网络的深度 \\ + - encoding (str): 量子神经网络中经典数据的编码方式，目前支持 ``IQP`` 和 ``re-uploading`` + + :type \*\*kwargs: Union[List[int], int, str] + + .. py:method:: get_gradient(x) + + 计算输出层关于变分参数的梯度 + + :param x: 输入样本 + :type x: Union[np.ndarray, paddle.Tensor] + + :return: 输出层关于变分参数的梯度，数组形状为（输入样本数量, 输出层维数, 变分参数数量） + :rtype: np.ndarray + + .. py:method:: get_cfisher(gradients) + + 利用雅可比矩阵计算经典费舍信息矩阵 + + :param gradients: 输出层关于变分参数的梯度, 数组形状为（输入样本数量, 输出层维数, 变分参数数量） + :type gradients: np.ndarray + + :return: 经典费舍信息矩阵，数组形状为（输入样本数量, 变分参数数量, 变分参数数量） + :rtype: np.ndarray + + .. py:method:: get_normalized_cfisher() + + 计算归一化的经典费舍信息矩阵 + + :return: + 包含如下元素： + + - 归一化的经典费舍信息矩阵，数组形状为（输入样本数量, 变分参数数量, 变分参数数量） + - 其迹 + + :rtype: Tuple[np.ndarray, float] + + .. py:method:: get_eff_dim(normalized_cfisher, list_num_samples, gamma = 1) + + 计算经典的有效维数 + + :param normalized_cfisher: 归一化的经典费舍信息矩阵 + :type normalized_cfisher: np.ndarray + :param list_num_samples: 不同样本量构成的列表 + :type list_num_samples: List[int] + :param gamma: 有效维数定义中包含的一个人为可调参数，默认为 ``1``. + :type gamma: int + + :return: 对于不同样本量的有效维数构成的列表 + :rtype: List[int] + \ No newline at end of file diff --git a/docs_zh_CN/source/paddle_quantum.gate.base.rst b/docs_zh_CN/source/paddle_quantum.gate.base.rst new file mode 100644 index 0000000..c2bfc56 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gate.base.rst @@ -0,0 +1,21 @@ +paddle\_quantum.gate.base +================================ + +量子门的基类的功能实现。 + +.. py:class:: Gate(depth=1, backend=None, dtype=None, name_scope=None) + + 基类：:py:class:`paddle_quantum.base.Operator` + + 量子门的基类。 + + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param backend: 执行门的后端，默认为 ``None``。 + :type backend: paddle_quantum.Backend, optional + :param dtype: 数据的类型，默认为 ``None``。 + :type dtype: str, optional + :param name_scope: 为 Layer 内部参数命名而采用的名称前缀。如果前缀为 "mylayer"，在一个类名为MyLayer的Layer中， + 参数名为"mylayer_0.w_n"，其中 "w" 是参数的名称，"n" 为自动生成的具有唯一性的后缀。如果为 ``None``， + 前缀名将为小写的类名。默认为 ``None``。 + :type name_scope: str, optional diff --git a/docs_zh_CN/source/paddle_quantum.gate.clifford.rst b/docs_zh_CN/source/paddle_quantum.gate.clifford.rst new file mode 100644 index 0000000..eff7c5c --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gate.clifford.rst @@ -0,0 +1,53 @@ +paddle\_quantum.gate.clifford +==================================== + +随机生成 Clifford 算子的功能实现。 + +.. py:function:: compose_clifford_circuit(clifd1, clifd2) + + 计算两个指定的 Clifford 的复合，得到复合后的电路。 + + :param clifd1: 需要复合的第 1 个 Clifford。 + :type clifd1: Clifford + :param clifd2: 需要复合的第 2 个 Clifford。 + :type clifd2: Clifford + :return: 复合后的 Clifford 所对应的电路，作用的顺序为 clif1、clif2。 + :rtype: paddle_quantum.ansatz.Circuit + +.. py:class:: Clifford(num_qubits) + + 用户可以通过实例化该 ``class`` 来随机生成一个 Clifford operator。 + + :param num_qubits: 该 Clifford operator 作用的量子比特数目。 + :type num_qubits: int + + :参考文献: + 1. Bravyi, Sergey, and Dmitri Maslov. "Hadamard-free circuits expose the structure of the Clifford group." + IEEE Transactions on Information Theory 67.7 (2021): 4546-4563. + + .. py:method:: print_clifford() + + 输出该 Clifford 在 Pauli 基上的作用关系来描述这个 Clifford。 + + .. py:method:: sym() + + 获取该 Clifford operator 所对应的辛矩阵。 + + :return: 该 Clifford 对应的辛矩阵。 + :rtype: np.ndarray + + .. py:method:: tableau() + + 获取该 Clifford operator 所对应的 table。 + + 对 ``num_qubits`` 个 qubits 的情况，前 ``num_qubits`` 行对应 :math:`X_i` 的结果，后 ``num_qubits`` 行对应 :math:`Z_i` 的结果。 + + :return: 该 Clifford 的 table。 + :rtype: np.ndarray + + .. py:method:: circuit() + + 获取该 Clifford operator 所对应的电路。 + + :return: 该 Clifford 对应的电路。 + :rtype: paddle_quantum.ansatz.Circuit diff --git a/docs_zh_CN/source/paddle_quantum.gate.custom.rst b/docs_zh_CN/source/paddle_quantum.gate.custom.rst new file mode 100644 index 0000000..135b061 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gate.custom.rst @@ -0,0 +1,34 @@ +paddle\_quantum.gate.custom +================================== + +自定义量子门和受控量子门的功能实现。 + +.. py:class:: Oracle(oracle, qubits_idx, num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 一个 oracle 门。 + + :param oracle: 要实现的 oracle。 + :type oracle: paddle.Tensor + :param qubits_idx: 作用在的量子比特的编号。 + :type qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int] + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: ControlOracle(oracle, qubits_idx, num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 一个受控 oracle 门。 + + :param oracle: 要实现的 oracle。 + :type oracle: paddle.Tensor + :param qubits_idx: 作用在的量子比特的编号。 + :type qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int] + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional diff --git a/docs_zh_CN/source/paddle_quantum.gate.encoding.rst b/docs_zh_CN/source/paddle_quantum.gate.encoding.rst new file mode 100644 index 0000000..b5710b4 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gate.encoding.rst @@ -0,0 +1,59 @@ +paddle\_quantum.gate.encoding +==================================== + +量子编码的功能实现。 + +.. py:class:: BasisEncoding(qubits_idx='full', num_qubits=None) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 将输入的经典数据编码成量子态的基态编码门。 + + 在基态编码中，输入的经典数据只能包括 0 和 1。如输入数据为 1101，则编码后的量子态为 :math:`|1101\rangle`。 + 这里假设量子态在编码前为全 0 的态，即 :math:`|00\ldots 0\rangle`。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + +.. py:class:: AmplitudeEncoding(qubits_idx='full', num_qubits=None) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 将输入的经典数据编码成量子态的振幅编码门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + +.. py:class:: AngleEncoding(feature, qubits_idx='full', num_qubits=None, encoding_gate=None) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 将输入的经典数据编码成量子态的角度编码门。 + + :param feature: 待编码的向量。 + :type feature: paddle.Tensor + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param encoding_gate: 编码用的量子门，应是 ``"rx"``、``"ry"``，和 ``"rz"`` 中的一种。默认为 ``None``。 + :type encoding_gate: str, optional + +.. py:class:: IQPEncoding(feature, qubits_idx=None, num_qubits=None, num_repeat=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 将输入的经典数据编码成量子态的 IQP 编码门。 + + :param feature: 待编码的向量。 + :type feature: paddle.Tensor + :param qubits_idx: 作用在的量子比特的编号，默认为 ``None``。 + :type qubits_idx: Iterable[Iterable[int]], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param num_repeat: 编码层的层数，默认为 ``1``。 + :type num_repeat: int, optional diff --git a/docs_zh_CN/source/paddle_quantum.gate.functional.base.rst b/docs_zh_CN/source/paddle_quantum.gate.functional.base.rst new file mode 100644 index 0000000..1ea2b95 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gate.functional.base.rst @@ -0,0 +1,21 @@ +paddle\_quantum.gate.functional.base +=========================================== + +量子门的基础函数的功能实现。 + +.. py:function:: simulation(state, gate, qubit_idx, num_qubits, backend) + + 在输入态上作用一个量子门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param gate: 要执行的门。 + :type gate: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: Union[int, List[int]] + :param num_qubits: 总的量子比特个数。 + :type num_qubits: int + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle.Tensor diff --git a/docs_zh_CN/source/paddle_quantum.gate.functional.multi_qubit_gate.rst b/docs_zh_CN/source/paddle_quantum.gate.functional.multi_qubit_gate.rst new file mode 100644 index 0000000..32a9c07 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gate.functional.multi_qubit_gate.rst @@ -0,0 +1,309 @@ +paddle\_quantum.gate.functional.multi\_qubit\_gate +========================================================= + +多量子比特量子门的函数的功能实现。 + +.. py:function:: cnot(state, qubit_idx, dtype, backend) + + 在输入态上作用一个 CNOT 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: cx(state, qubit_idx, dtype, backend) + + 在输入态上作用一个 CNOT 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: cy(state, qubit_idx, dtype, backend) + + 在输入态上作用一个受控 Y 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: cz(state, qubit_idx, dtype, backend) + + 在输入态上作用一个受控 Z 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: swap(state, qubit_idx, dtype, backend) + + 在输入态上作用一个 SWAP 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: cp(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个受控 P 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: crx(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个关于 x 轴的受控单量子比特旋转门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: cry(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个关于 y 轴的受控单量子比特旋转门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: crz(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个关于 z 轴的受控单量子比特旋转门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: cu(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个受控单量子比特旋转门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: rxx(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个 RXX 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: ryy(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个 RYY 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: rzz(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个 RZZ 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: ms(state, qubit_idx, dtype, backend) + + 在输入态上作用一个 Mølmer-Sørensen (MS) 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: cswap(state, qubit_idx, dtype, backend) + + 在输入态上作用一个 CSWAP (Fredkin) 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: toffoli(state, qubit_idx, dtype, backend) + + 在输入态上作用一个 Toffoli 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: universal_two_qubits(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个两量子比特通用门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: universal_three_qubits(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个三量子比特通用门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: oracle(state, oracle, qubit_idx, backend) + + 在输入态上作用一个 oracle 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param oracle: 要执行的 oracle。 + :type oracle: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: list + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State diff --git a/docs_zh_CN/source/paddle_quantum.gate.functional.rst b/docs_zh_CN/source/paddle_quantum.gate.functional.rst new file mode 100644 index 0000000..03d32ca --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gate.functional.rst @@ -0,0 +1,13 @@ +paddle\_quantum.gate.functional +======================================= + +不同量子门的函数的功能实现。 + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.gate.functional.base + paddle_quantum.gate.functional.multi_qubit_gate + paddle_quantum.gate.functional.single_qubit_gate diff --git a/docs_zh_CN/source/paddle_quantum.gate.functional.single_qubit_gate.rst b/docs_zh_CN/source/paddle_quantum.gate.functional.single_qubit_gate.rst new file mode 100644 index 0000000..4a36743 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gate.functional.single_qubit_gate.rst @@ -0,0 +1,179 @@ +paddle\_quantum.gate.functional.single\_qubit\_gate +========================================================== + +单量子比特量子门的函数的功能实现。 + +.. py:function:: h(state, qubit_idx, dtype, backend) + + 在输入态上作用一个 Hadamard 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: s(state, qubit_idx, dtype, backend) + + 在输入态上作用一个 S 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: t(state, qubit_idx, dtype, backend) + + 在输入态上作用一个 T 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: x(state, qubit_idx, dtype, backend) + + 在输入态上作用一个 X 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: y(state, qubit_idx, dtype, backend) + + 在输入态上作用一个 Y 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: z(state, qubit_idx, dtype, backend) + + 在输入态上作用一个 Z 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: p(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个 P 门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: rx(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个关于 x 轴的单量子比特旋转门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: ry(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个关于 y 轴的单量子比特旋转门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: rz(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个关于 z 轴的单量子比特旋转门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State + +.. py:function:: u3(state, theta, qubit_idx, dtype, backend) + + 在输入态上作用一个单量子比特旋转门。 + + :param state: 输入态。 + :type state: paddle_quantum.State + :param theta: 量子门参数。 + :type theta: paddle.Tensor + :param qubit_idx: 作用在的量子比特的编号。 + :type qubit_idx: int + :param dtype: 数据的类型。 + :type dtype: str + :param backend: 运行模拟的后端。 + :type backend: paddle_quantum.Backend + :return: 输出态。 + :rtype: paddle_quantum.State diff --git a/docs_zh_CN/source/paddle_quantum.gate.layer.rst b/docs_zh_CN/source/paddle_quantum.gate.layer.rst new file mode 100644 index 0000000..c378e89 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gate.layer.rst @@ -0,0 +1,126 @@ +paddle\_quantum.gate.layer +================================= + +量子电路模板的功能实现。 + +.. py:function:: qubits_idx_filter(qubits_idx, num_qubits) + + 检查 ``qubits_idx`` 与 ``num_qubits`` 是否合法。 + + :param qubits_idx: 量子比特的编号。 + :type qubits_idx: Union[Iterable[int], str] + :param num_qubits: 总的量子比特个数。 + :type num_qubits: int + :raises RuntimeError: 须声明 ``qubits_idx`` 或 ``num_qubits`` 以实例化类。 + :raises ValueError: ``qubits_idx`` 须为 ``Iterable`` 或 ``'full'``。 + :return: 检查过的量子比特的编号。 + :rtype: List[Iterable[int]] + +.. py:class:: SuperpositionLayer(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + Hadamard 门组成的层。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: WeakSuperpositionLayer(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 转角度为 :math:`\pi/4` 的 Ry 门组成的层。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: LinearEntangledLayer(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 包含 Ry 门、Rz 门，和 CNOT 门的线性纠缠层。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: RealEntangledLayer(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 包含 Ry 门和 CNOT 门的强纠缠层。 + + .. note:: + + 这一层量子门的数学表示形式为实数酉矩阵。电路模板来自论文：https://arxiv.org/pdf/1905.10876.pdf。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: ComplexEntangledLayer(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 包含 U3 门和 CNOT 门的强纠缠层。 + + .. note:: + + 这一层量子门的数学表示形式为复数酉矩阵。电路模板来自论文：https://arxiv.org/abs/1804.00633。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: RealBlockLayer(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 包含 Ry 门和 CNOT 门的弱纠缠层。 + + .. note:: + + 这一层量子门的数学表示形式为实数酉矩阵。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: ComplexBlockLayer(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 包含 U3 门和 CNOT 门的弱纠缠层。 + + .. note:: + + 这一层量子门的数学表示形式为复数酉矩阵。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable[int], str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: QAOALayer(Gate) diff --git a/docs_zh_CN/source/paddle_quantum.gate.multi_qubit_gate.rst b/docs_zh_CN/source/paddle_quantum.gate.multi_qubit_gate.rst new file mode 100644 index 0000000..faca52e --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gate.multi_qubit_gate.rst @@ -0,0 +1,509 @@ +paddle\_quantum.gate.multi\_qubit\_gate +============================================== + +多量子比特门的类的功能实现。 + +.. py:class:: CNOT(qubits_idx='cycle', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + CNOT 门。 + + 对于两量子比特的量子电路，当 ``qubits_idx`` 为 ``[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} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: CX(qubits_idx='cycle', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 同 CNOT。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: CY(qubits_idx='cycle', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 受控 Y 门。 + + 对于两量子比特的量子电路，当 ``qubits_idx`` 为 ``[0, 1]`` 时，其矩阵形式为： + + .. math:: + + \begin{align} + CY &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Y\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & -1j \\ + 0 & 0 & 1j & 0 + \end{bmatrix} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: CZ(qubits_idx='cycle', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 受控 Z 门。 + + 对于两量子比特的量子电路，当 ``qubits_idx`` 为 ``[0, 1]`` 时，其矩阵形式为： + + .. math:: + + \begin{align} + CZ &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Z\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & -1 + \end{bmatrix} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: SWAP(qubits_idx='cycle', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + SWAP 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + SWAP = + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & 1 + \end{bmatrix} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: CP(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 受控 P 门。 + + 对于两量子比特的量子电路，当 ``qubits_idx`` 为 ``[0, 1]`` 时，其矩阵形式为： + + .. math:: + + \begin{bmatrix} + 1 & 0 & 0 & 0\\ + 0 & 1 & 0 & 0\\ + 0 & 0 & 1 & 0\\ + 0 & 0 & 0 & e^{i\theta} + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: CRX(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 关于 x 轴的受控单量子比特旋转门。 + + 对于两量子比特的量子电路，当 ``qubits_idx`` 为 ``[0, 1]`` 时，其矩阵形式为： + + .. math:: + + \begin{align} + CRx &=|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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: CRY(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 关于 y 轴的受控单量子比特旋转门。 + + 对于两量子比特的量子电路，当 ``qubits_idx`` 为 ``[0, 1]`` 时，其矩阵形式为： + + .. math:: + + \begin{align} + CRy &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Ry\\ + &= + \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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: CRZ(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 关于 z 轴的受控单量子比特旋转门。 + + 对于两量子比特的量子电路，当 ``qubits_idx`` 为 ``[0, 1]`` 时，其矩阵形式为： + + .. math:: + + \begin{align} + CRz &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Rz\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & e^{i\theta} + \end{bmatrix} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: CU(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 受控单量子比特旋转门。 + + 对于两量子比特的量子电路，当 ``qubits_idx`` 为 ``[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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: RXX(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + RXX 门。 + + 其矩阵形式为： + + .. 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} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: RYY(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + RYY 门。 + + 其矩阵形式为： + + .. 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} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: RZZ(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + RZZ 门。 + + 其矩阵形式为： + + .. 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} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: MS(qubits_idx='cycle', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 用于离子阱设备的 Mølmer-Sørensen (MS) 门。 + + 其矩阵形式为： + + .. 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} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: CSWAP(qubits_idx='cycle', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + CSWAP (Fredkin) 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + CSWAP = + \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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: Toffoli(qubits_idx='cycle', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + Toffoli 门。 + + 其矩阵形式为： + + .. math:: + + \begin{align} + \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} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: UniversalTwoQubits(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 两量子比特通用门，该通用门需要 15 个参数。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: UniversalThreeQubits(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 三量子比特通用门，该通用门需要 81 个参数。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 diff --git a/docs_zh_CN/source/paddle_quantum.gate.rst b/docs_zh_CN/source/paddle_quantum.gate.rst new file mode 100644 index 0000000..a198249 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gate.rst @@ -0,0 +1,24 @@ +paddle\_quantum.gate +============================ + +量子门的功能实现。 + +.. rubric:: Subpackages + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.gate.functional + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.gate.base + paddle_quantum.gate.clifford + paddle_quantum.gate.custom + paddle_quantum.gate.encoding + paddle_quantum.gate.layer + paddle_quantum.gate.multi_qubit_gate + paddle_quantum.gate.single_qubit_gate diff --git a/docs_zh_CN/source/paddle_quantum.gate.single_qubit_gate.rst b/docs_zh_CN/source/paddle_quantum.gate.single_qubit_gate.rst new file mode 100644 index 0000000..a560aa7 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gate.single_qubit_gate.rst @@ -0,0 +1,277 @@ +paddle\_quantum.gate.single\_qubit\_gate +=============================================== + +单量子比特门的类的功能实现。 + +.. py:class:: H(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 单量子比特 Hadamard 门。 + + 其矩阵形式为： + + .. math:: + + H = \frac{1}{\sqrt{2}} + \begin{bmatrix} + 1&1\\ + 1&-1 + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: S(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 单量子比特 S 门。 + + 其矩阵形式为： + + .. math:: + + S = + \begin{bmatrix} + 1&0\\ + 0&i + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: T(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 单量子比特 T 门。 + + 其矩阵形式为： + + .. math:: + + T = + \begin{bmatrix} + 1&0\\ + 0&e^\frac{i\pi}{4} + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: X(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 单量子比特 X 门。 + + 其矩阵形式为： + + .. math:: + + \begin{bmatrix} + 0 & 1 \\ + 1 & 0 + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: Y(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 单量子比特 Y 门。 + + 其矩阵形式为： + + .. math:: + + \begin{bmatrix} + 0 & -i \\ + i & 0 + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: Z(qubits_idx='full', num_qubits=None, depth=1) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 单量子比特 Z 门。 + + 其矩阵形式为： + + .. math:: + + \begin{bmatrix} + 1 & 0 \\ + 0 & -1 + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + +.. py:class:: P(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 单量子比特 P 门。 + + 其矩阵形式为： + + .. math:: + + \begin{bmatrix} + 1 & 0 \\ + 0 & e^{i\theta} + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: RX(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 关于 x 轴的单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + \begin{bmatrix} + \cos\frac{\theta}{2} & -i\sin\frac{\theta}{2} \\ + -i\sin\frac{\theta}{2} & \cos\frac{\theta}{2} + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: RY(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 关于 y 轴的单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + \begin{bmatrix} + \cos\frac{\theta}{2} & -\sin\frac{\theta}{2} \\ + \sin\frac{\theta}{2} & \cos\frac{\theta}{2} + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: RZ(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 关于 z 轴的单量子比特旋转门。 + + 其矩阵形式为： + + .. math:: + + \begin{bmatrix} + e^{-i\frac{\theta}{2}} & 0 \\ + 0 & e^{i\frac{\theta}{2}} + \end{bmatrix} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 + +.. py:class:: U3(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 基类：:py:class:`paddle_quantum.gate.base.Gate` + + 单量子比特旋转门。 + + 其矩阵形式为： + + .. 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} + \end{align} + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + :raises ValueError: ``param`` 须为 ``paddle.Tensor`` 或 ``float``。 diff --git a/docs_zh_CN/source/paddle_quantum.gradtool.rst b/docs_zh_CN/source/paddle_quantum.gradtool.rst new file mode 100644 index 0000000..bb4586a --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.gradtool.rst @@ -0,0 +1,142 @@ +paddle\_quantum.gradtool +=============================== + +梯度分析工具的功能实现。 + +.. py:function:: show_gradient(circuit, loss_func, ITR, LR, *args) + + 计算量子神经网络中各可变参数的梯度值和损失函数值。 + + :param circuit: 要训练的量子神经网络。 + :type circuit: Circuit + :param loss_func: 计算该量子神经网络损失值的函数。 + :type loss_func: Callable[[Circuit, Any], paddle.Tensor] + :param ITR: 训练的次数。 + :type ITR: int + :param LR: 学习训练的速率。 + :type LR: float + :param \*args: 用于损失函数计算的额外参数列表。 + :type \*args: Any + + :return: 包含如下两个元素： + - loss_list: 损失函数值随训练次数变化的列表。 + - grad_list: 各参数梯度随训练次变化的列表。 + :rtype: Tuple[List[float], List[float]] + +.. py:function:: plot_distribution(grad) + + 根据输入的梯度的列表，画出梯度的分布图。 + + :param grad: 量子神经网络某参数的梯度列表。 + :type grad: np.ndarray + +.. py:function:: random_sample(circuit, loss_func, sample_num, *args, mode, if_plot, param) + + 对模型进行随机采样，根据不同的计算模式，获得对应的平均值和方差。 + + :param circuit: 要训练的量子神经网络。 + :type circuit: Circuit + :param loss_func: 计算该量子神经网络损失值的函数。 + :type loss_func: Callable[[Circuit, Any], paddle.Tensor] + :param sample_num: 随机采样的次数 + :type sample_num: int + :param mode: 随机采样后的计算模式，默认为 ``'single'``。 + :type mode: string + :param if_plot: 是否对梯度进行画图，默认为 ``True``。 + :type if_plot: boolean + :param param: ``'single'`` 模式中对第几个参数进行画图，默认为 ``0``，即第一个参数。 + :type param: int + :param \*args: 用于损失函数计算的额外参数列表。 + :type \*args: Any + + .. note:: + 在本函数中提供了三种计算模式，``mode`` 分别可以选择 ``'single'``, ``'max'``, 以及 ``'random'``。 + - mode='single': 表示计算电路中的每个可变参数梯度的平均值和方差。 + - mode='max': 表示对电路中每轮采样的所有参数梯度的最大值求平均值和方差。 + - mode='random': 表示对电路中每轮采样的所有参数随机取一个梯度，求平均值和方差。 + + :return: 包含如下两个元素： + - loss_list: 损失函数值随训练次数变化的列表。 + - grad_list: 各参数梯度随训练次变化的列表。 + :rtype: Tuple[List[float], List[float]] + +.. py:function:: plot_loss_grad(circuit, loss_func, ITR, LR, *args) + + 绘制损失值和梯度随训练次数变化的图。 + + :param circuit: 传入的参数化量子电路，即要训练的量子神经网络。 + :type circuit: Circuit + :param loss_func: 计算该量子神经网络损失值的函数。 + :type loss_func: Callable[[Circuit, Any], paddle.Tensor] + :param ITR: 训练的次数。 + :type ITR: int + :param LR: 学习训练的速率。 + :type LR: float + :param \*args: 用于损失函数计算的额外参数列表。 + :type \*args: Any + +.. py:function:: plot_supervised_loss_grad(circuit, loss_func, N, EPOCH, LR, BATCH, TRAIN_X, TRAIN_Y, *args) + + 绘制监督学习中损失值和梯度随训练次数变化的图。 + + :param circuit: 要训练的量子神经网络。 + :type circuit: Circuit + :param loss_func: 计算该量子神经网络损失值的函数。 + :type loss_func: Callable[[Circuit, Any], paddle.Tensor] + :param N: 量子比特的数量。 + :type N: int + :param EPOCH: 训练的轮数。 + :type EPOCH: int + :param LR: 学习训练的速率。 + :type LR: float + :param BATCH: 训练时 batch 的大小。 + :type BATCH: int + :param TRAIN_X: 训练数据集。 + :type TRAIN_X: paddle.Tensor + :param TRAIN_Y: 训练数据集的标签。 + :type TRAIN_Y: list + :param \*args: 用于损失函数计算的额外参数列表。 + :type \*args: Any + + :return: 包含如下两个元素： + - loss_list: 损失函数值随训练次数变化的列表。 + - grad_list: 各参数梯度随训练次变化的列表。 + :rtype: Tuple[List[float], List[float]] + +.. py:function:: random_sample_supervised(circuit, loss_func, N, sample_num, BATCH, TRAIN_X, TRAIN_Y, *args: Any, mode:='single', if_plot:=True, param:=0) + + 对监督学习模型进行随机采样，根据不同的计算模式，获得对应的平均值和方差。 + + :param circuit: 要训练的量子神经网络。 + :type circuit: Circuit + :param loss_func: 计算该量子神经网络损失值的函数。 + :type loss_func: Callable[[Circuit, Any], paddle.Tensor] + :param N: 量子比特的数量。 + :type N: int + :param sample_num: 随机采样的次数。 + :type sample_num: int + :param BATCH: 训练时 batch 的大小。 + :type BATCH: int + :param TRAIN_X: 训练数据集。 + :type TRAIN_X: paddle.Tensor + :param TRAIN_Y: 训练数据集的标签。 + :type TRAIN_Y: list + :param mode: 随机采样后的计算模式，默认为 ``'single'``。 + :type mode: string + :param if_plot: 是否对梯度进行画图，默认为 ``True``。 + :type if_plot: boolean + :param param: ``Single`` 模式中对第几个参数进行画图，默认为 ``0``，即第一个参数。 + :type param: int + :param \*args: 用于损失函数计算的额外参数列表。 + :type \*args: Any + + .. note:: + 在本函数中提供了三种计算模式，``mode`` 分别可以选择 ``'single'``, ``'max'``, 以及 ``'random'``。 + - mode='single': 表示计算电路中的每个可变参数梯度的平均值和方差。 + - mode='max': 表示对电路中每轮采样的所有参数梯度的最大值求平均值和方差。 + - mode='random': 表示对电路中每轮采样的所有参数随机取一个梯度，求平均值和方差。 + + :return: 包含如下两个元素： + - loss_list: 损失函数值随训练次数变化的列表。 + - grad_list: 各参数梯度随训练次变化的列表。 + :rtype: Tuple[List[float], List[float]] diff --git a/docs_zh_CN/source/paddle_quantum.hamiltonian.rst b/docs_zh_CN/source/paddle_quantum.hamiltonian.rst new file mode 100644 index 0000000..daeb076 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.hamiltonian.rst @@ -0,0 +1,110 @@ +paddle\_quantum.hamiltonian +================================== + +哈密顿量的功能实现。 + +.. py:class:: Hamiltonian(pauli_str, compress=True) + + 基类: :py:class:`object` + + Paddle Quantum 中的 Hamiltonian ``class``。 + + 用户可以通过一个 Pauli string 来实例化该 ``class``。 + + :param pauli_str: 用列表定义的 Hamiltonian，如 ``[(1, 'Z0, Z1'), (2, 'I')]``。 + :type pauli_str: list + :param compress: 是否对输入的 list 进行自动合并（例如 ``(1, 'Z0, Z1')`` 和 ``(2, 'Z1, Z0')`` 这两项将被自动合并），默认为 ``True``。 + :type compress: bool, optional + + .. note:: + + 若 ``compress`` 为 ``False``, 则不会检查输入的合法性。 + + .. py:property:: n_terms() + + 该哈密顿量的项数。 + + .. py:property:: pauli_str() + + 该哈密顿量对应的 Pauli string。 + + .. py:property:: terms() + + 该哈密顿量中的每一项，i.e. ``[['Z0, Z1'], ['I']]``。 + + .. py:property:: coefficients() + + 该哈密顿量中每一项的系数，i.e. ``[1.0, 2.0]``。 + + .. py:property:: pauli_words() + + 该哈密顿量中每一项对应的 Pauli word 构成的列表，i.e. ``['ZIZ', 'IIX']``。 + + .. py:property:: pauli_words_r() + + 该哈密顿量中每一项对应的简化（不包含 I） Pauli word 组成的列表，i.e. ``['ZXZZ', 'Z', 'X']``。 + + .. py:property:: pauli_words_matrix() + + 该哈密顿量中每一项对应的简化（不包含 I） Pauli word 对应的 matrix 组成的列表。 + + .. py:property:: sites() + + 该哈密顿量中的每一项对应的量子比特编号组成的列表。 + + .. py:property:: n_qubits() + + 该哈密顿量对应的量子比特数。 + + .. py:method:: decompose_with_sites() + + 将 pauli_str 分解为系数、泡利字符串的简化形式以及它们分别作用的量子比特下标。 + + :return: 包含如下元素的 tuple: + - coefficients: 元素为每一项的系数。 + - pauli_words_r: 元素为每一项的泡利字符串的简化形式，例如 'Z0, Z1, X3' 这一项的泡利字符串为 'ZZX'。 + - sites: 元素为每一项作用的量子比特下标，例如 'Z0, Z1, X3' 这一项的 site 为 [0, 1, 3]。 + :rtype: Tuple[list] + + .. py:method:: decompose_pauli_words() + + 将 pauli_str 分解为系数和泡利字符串。 + + :return: 包含如下元素的 tuple: + - coefficients: 元素为每一项的系数。 + - pauli_words: 元素为每一项的泡利字符串，例如 'Z0, Z1, X3' 这一项的泡利字符串为 'ZZIX'。 + :rtype: Tuple[list] + + .. py:method:: construct_h_matrix(qubit_num = None) + + 构建 Hamiltonian 在 Z 基底下的矩阵。 + + :param qubit_num: 量子比特数量，默认值为 ``1``。 + :type qubit_num: int, optional + + :return: Z 基底下的哈密顿量矩阵形式。 + :rtype: np.ndarray + + +.. py:class:: SpinOps(size, use_sparse=False) + + 基类: :py:class:`object` + + 矩阵表示下的自旋算符，可以用来构建哈密顿量矩阵或者自旋可观测量。 + + :param size: 系统的大小 + :type size: int + :param use_sparse: 是否使用 sparse matrix 计算，默认为 ``False``。 + :type use_sparse: bool, optional + + .. py:property:: sigz_p() + + :math:`S^z_i` 算符组成的列表，其中每一项对应不同的 :math:`i`。 + + .. py:property:: sigy_p() + + :math:`S^y_i` 算符组成的列表，其中每一项对应不同的 :math:`i`。 + + .. py:property:: sigx_p() + + :math:`S^x_i` 算符组成的列表，其中每一项对应不同的 :math:`i`。 diff --git a/docs_zh_CN/source/paddle_quantum.linalg.rst b/docs_zh_CN/source/paddle_quantum.linalg.rst new file mode 100644 index 0000000..b18b0c0 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.linalg.rst @@ -0,0 +1,170 @@ +paddle\_quantum.linalg +============================= + +量桨中的线性代数的功能实现。 + +.. py:function:: abs_norm(mat) + + 计算矩阵范数 + + :param mat: 矩阵 + :type mat: paddle.Tensor + + :return: 范数 + :rtype: float + +.. py:function:: dagger(mat) + + 计算矩阵的转置共轭 + + :param mat: 矩阵 + :type mat: paddle.Tensor + + :return: 矩阵的转置共轭 + :rtype: paddle.Tensor + +.. py:function:: is_hermitian(mat, eps=1e-6) + + 验证矩阵 ``P`` 是否为厄密矩阵 + + :param mat: 矩阵 + :type mat: paddle.Tensor + :param eps: 容错率 + :type eps: float, optional + + :return: 决定是否 :math:`P - P^\dagger = 0` + :rtype: bool + +.. py:function:: is_projector(mat, eps=1e-6) + + 验证矩阵 ``P`` 是否为映射算子 + + :param mat: 矩阵 + :type mat: paddle.Tensor + :param eps: 容错率 + :type eps: float, optional + + :return: 决定是否 :math:`PP - P = 0` + :rtype: bool + +.. py:function:: is_unitary(mat, eps = 1e-5) + + 验证矩阵 ``P`` 是否为酉矩阵 + + :param mat: 矩阵 + :type mat: paddle.Tensor + :param eps: 容错率 + :type eps: float, optional + + :return: 决定是否 :math:`PP^\dagger - I = 0` + :rtype: bool + +.. py:function:: hermitian_random(num_qubits) + + 随机生成一个厄密矩阵 + + :param num_qubits: 量子比特数 n + :type num_qubits: int + + :return: 一个 :math:`2^n \times 2^n` 厄密矩阵 + :rtype: paddle.Tensor + +.. py:function:: orthogonal_projection_random(num_qubits) + + 随机生成一个秩是 1 的正交投影算子 + + :param num_qubits: 量子比特数 n + :type num_qubits: int + + :return: 一个 :math:`2^n \times 2^n` 正交投影算子 + :rtype: paddle.Tensor + +.. py:function:: unitary_hermitian_random(num_qubits) + + 随机生成一个厄密酉矩阵 + + :param num_qubits: 量子比特数 n + :type num_qubits: int + + :return: 一个 :math:`2^n \times 2^n` 厄密共轭酉矩阵 + :rtype: paddle.Tensor + +.. py:function:: unitary_random_with_hermitian_block(num_qubits) + + 随机生成一个左上半部分为厄密矩阵的酉矩阵 + + :param num_qubits: 量子比特数 n + :type num_qubits: int + + :return: 一个左上半部分为厄密矩阵的 :math:`2^n \times 2^n` 酉矩阵 + :rtype: paddle.Tensor + +.. py:function:: unitary_random(num_qubits) + + 随机生成一个酉矩阵 + + :param num_qubits: 量子比特数 n + :type num_qubits: int + + :return: 一个 :math:`2^n \times 2^n` 酉矩阵 + :rtype: paddle.Tensor + +.. py:function:: haar_orthogonal(num_qubits) + + 生成一个服从 Haar random 的正交矩阵。采样算法参考文献: arXiv:math-ph/0609050v2 + + :param num_qubits: 量子比特数 n + :type num_qubits: int + + :return: 一个 :math:`2^n \times 2^n` 正交矩阵 + :rtype: paddle.Tensor + +.. py:function:: haar_unitary(num_qubits) + + 生成一个服从 Haar random 的酉矩阵。采样算法参考文献: arXiv:math-ph/0609050v2 + + :param num_qubits: 量子比特数 n + :type num_qubits: int + + :return: 一个 :math:`2^n \times 2^n` 酉矩阵 + :rtype: paddle.Tensor + +.. py:function:: haar_state_vector(num_qubits, is_real=False) + + 生成一个服从 Haar random 的态矢量。采样算法参考文献: arXiv:math-ph/0609050v2 + + :param num_qubits: 量子比特数 n + :type num_qubits: int + :param is_real: 生成的态矢量是否为实数 + :type is_real: bool, optional + + :return: 一个 :math:`2^n \times 1` 态矢量 + :rtype: paddle.Tensor + +.. py:function:: haar_density_operator(num_qubits, rank=None, is_real=False) + + 生成一个服从 Haar random 的密度矩阵 + + :param num_qubits: 量子比特数 n + :type num_qubits: int + :param rank: 矩阵秩, 默认满秩 + :type rank: int, optional + :param is_real: 生成的态矢量是否为实数 + :type is_real: bool, optional + + :return: 一个 :math:`2^n x 2^n` 密度矩阵 + :rtype: paddle.Tensor + +.. py:function:: NKron(matrix_A, matrix_B, *args) + + 计算两个及以上的矩阵的克罗内克乘积 + + :param matrix_A: 矩阵 + :type num_qubits: np.ndarray + :param matrix_B: 矩阵 + :type matrix_B: np.ndarray + :param \*args: 更多矩阵 + :type \*args: np.ndarray + + :return: 克罗内克乘积 + :rtype: np.ndarray diff --git a/docs_zh_CN/source/paddle_quantum.locc.locc_ansatz.rst b/docs_zh_CN/source/paddle_quantum.locc.locc_ansatz.rst new file mode 100644 index 0000000..7ec9bdd --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.locc.locc_ansatz.rst @@ -0,0 +1,458 @@ +paddle\_quantum.locc.locc\_ansatz +======================================== + +LOCC的电路的功能实现。 + +.. py:class:: LoccAnsatz(party) + + 基类：:py:class:`paddle_quantum.ansatz.circuit.Circuit` + + 继承 ``Circuit`` 类，目的是建立在 LOCC 任务上的电路模板。 + + :param party: 参与方。 + :type party: LoccParty + + .. py:method:: append(operator) + + 增加一个 Operator 类。 + + :param operator: 一个（附带名字的）Operator 类。 + :type operator: Union[Iterable, paddle_quantum.Operator] + + .. py:method:: extend(operators) + + 增加一组 Operator 类。 + + :param operators: 一组 Operator 类。 + :type operators: List[Operator] + + .. py:method:: insert(index, operator) + + 在指定位置插入一个 Operator 类。 + + :param index: 插入的位置。 + :type index: int + :param operator: 一个 Operator。 + :type operator: Operator + + .. py:method:: pop(operator) + + 在指定 Operator 下删除一个 Operator 类。 + + :param operator: 指定删除的 Operator。 + :type operator: Operator + + .. py:method:: forward(state) + + 前向传播输入数据。 + + :param state: 输入数据。 + :type state: LoccState + + :return: 输出数据。 + :rtype: LoccState + + .. py:method:: h(qubits_idx='full', num_qubits=None, depth=1) + + 添加单量子比特 Hadamard 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: s(qubits_idx='full', num_qubits=None, depth=1) + + 添加单量子比特 S 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: t(qubits_idx='full', num_qubits=None, depth=1) + + 添加单量子比特 T 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: x(qubits_idx='full', num_qubits=None, depth=1) + + 添加单量子比特 X 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: y(qubits_idx='full', num_qubits=None, depth=1) + + 添加单量子比特 Y 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: z(qubits_idx='full', num_qubits=None, depth=1) + + 添加单量子比特 Z 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: p(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加单量子比特 P 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: rx(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加关于 x 轴的单量子比特旋转门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: ry(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加关于 y 轴的单量子比特旋转门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: rz(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加关于 z 轴的单量子比特旋转门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: u3(qubits_idx='full', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加单量子比特旋转门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'full'``。 + :type qubits_idx: Union[Iterable, int, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: cnot(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加 CNOT 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: cx(qubits_idx='cycle', num_qubits=None, depth=1) + + 同 cnot。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: cy(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加受控 Y 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: cz(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加受控 Z 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: swap(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加 SWAP 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: cp(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加受控 P 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: crx(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加关于 x 轴的受控单量子比特旋转门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: cry(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加关于 y 轴的受控单量子比特旋转门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: crz(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加关于 z 轴的受控单量子比特旋转门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: cu(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加受控单量子比特旋转门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: rxx(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加 RXX 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: ryy(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加 RYY 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: rzz(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加 RZZ 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: ms(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加 Mølmer-Sørensen (MS) 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: cswap(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加 CSWAP (Fredkin) 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: ccx(qubits_idx='cycle', num_qubits=None, depth=1) + + 添加 CCX 门。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: universal_two_qubits(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加两量子比特通用门，该通用门需要 15 个参数。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: universal_three_qubits(qubits_idx='cycle', num_qubits=None, depth=1, param=None, param_sharing=False) + + 添加三量子比特通用门，该通用门需要 81 个参数。 + + :param qubits_idx: 作用在的量子比特的编号，默认为 ``'cycle'``。 + :type qubits_idx: Union[Iterable, str], optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + :param param: 量子门参数，默认为 ``None``。 + :type param: Union[paddle.Tensor, float], optional + :param param_sharing: 同一层中的量子门是否共享参数，默认为 ``False``。 + :type param_sharing: bool, optional + + .. py:method:: oracle(oracle, qubits_idx, num_qubits=None, depth=1) + + 添加一个 oracle 门。 + + :param oracle: 要实现的 oracle。 + :type oracle: paddle.tensor + :param qubits_idx: 作用在的量子比特的编号。 + :type qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int] + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional + + .. py:method:: control_oracle(oracle, qubits_idx, num_qubits=None, depth=1) + + 添加一个受控 oracle 门。 + + :param oracle: 要实现的 oracle。 + :type oracle: paddle.tensor + :param qubits_idx: 作用在的量子比特的编号。 + :type qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int] + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param depth: 层数，默认为 ``1``。 + :type depth: int, optional diff --git a/docs_zh_CN/source/paddle_quantum.locc.locc_net.rst b/docs_zh_CN/source/paddle_quantum.locc.locc_net.rst new file mode 100644 index 0000000..7a2cc8f --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.locc.locc_net.rst @@ -0,0 +1,102 @@ +paddle\_quantum.locc.locc\_net +===================================== + +LOCCNet的功能实现。 + +.. py:class:: LoccNet(state, qubits_idx) + + 基类：:py:class:`paddle.fluid.dygraph.layers.Layer` + + 用于设计 LOCC 协议，并进行训练或验证。 + + .. py:method:: set_init_state(state, qubits_idx) + + 初始化 LoccNet 的 LoccState。 + + :param state: 输入的量子态的矩阵形式。 + :type state: paddle_quantum.State + :param qubits_idx: 输入的量子态对应的量子比特的编号，其形式为 ``(party_id, qubit_id)`` 的 ``tuple`` ，或者由其组成的 ``list``。 + :type qubits_idx: Iterable + :raises ValueError: 参与方的 ID 应为 ``str`` 或 ``int``。 + + .. py:method:: partial_state(state, qubits_idx, is_desired=True) + + 得到指定的量子比特的量子态。 + + :param state: 输入的 LOCC 态。 + :type state: Union[List[LoccState], LoccState] + :param qubits_idx: 指定的量子比特的编号，其形式为 ``(party_id, qubit_id)`` 的 ``tuple`` ，或者由其组成的 ``list``。 + :type qubits_idx: Iterable + :param is_desired: 若为 ``True``，返回指定的量子比特的量子态；若为 ``False``，返回剩下的量子比特的量子态。 默认为 ``True``。 + :type is_desired: bool, optional + :raises ValueError: 参与方的 ID 应为 ``str`` 或 ``int``。 + :raises ValueError: ``state`` 应为 ``LoccState`` 或者由其组成的 ``list``。 + :return: 得到部分量子态后的 LOCC 态。 + :rtype: Union[List[LoccState], LoccState] + + .. py:method:: reset_state(status, state, which_qubits) + + 将指定的量子比特重置为输入的量子态。 + + :param status: 重置前的 LOCC 态。 + :type status: Union[List[LoccState], LoccState] + :param state: 输入的量子态。 + :type state: paddle_quantum.State + :param which_qubits: 指定的量子比特的编号，其形式为 ``(party_id, qubit_id)`` 的 ``tuple`` ，或者由其组成的 ``list``。 + :type which_qubits: Iterable + :raises ValueError: 参与方的 ID 应为 ``str`` 或 ``int``。 + :raises ValueError: ``state`` 应为 ``LoccState`` 或者由其组成的 ``list``。 + :return: 重置部分量子比特后的 LOCC 态。 + :rtype: Union[List[LoccState], LoccState] + + .. py:method:: add_new_party(qubits_number, party_name=None) + + 添加一个新的 LOCC 的参与方。 + + :param qubits_number: 该参与方的量子比特个数。 + :type qubits_number: int + :param party_name: 该参与方的名字，默认为 ``None``。 + :type party_name: str, optional + + .. note:: + 可以使用字符串或者数字对参与方进行索引。如果想使用字符串索引，需要每次指定 ``party_name``； + 如果想使用数字索引，则不需要指定 ``party_name``，其索引数字会从 0 开始依次增长。 + + :raises ValueError: ``party_name`` 应为 ``str``。 + :return: 该参与方的 ID。 + :rtype: Union[int, str] + + .. py:method:: create_ansatz(party_id) + + 创建一个新的本地电路模板。 + + :param party_id: 参与方的 ID。 + :type party_id: Union[int, str] + :raises ValueError: 参与方的 ID 应为 ``str`` 或 ``int``。 + :return: 创建的本地电路模板。 + :rtype: LoccAnsatz + + .. py:method:: measure(status, which_qubits, results_desired, theta=None) + + 对 LOCC 态进行 0-1 测量或含参测量。 + + :param status: 待测量的 LOCC 态。 + :type status: Union[List[LoccState], LoccState] + :param which_qubits: 测量的量子比特的编号。 + :type which_qubits: Iterable + :param results_desired: 期望得到的测量结果。 + :type results_desired: Union[List[str], str] + :param theta: 测量运算的参数，默认为 ``None``，表示 0-1 测量。 + :type theta: paddle.Tensor, optional + :raises ValueError: ``results_desired`` 应为 ``str`` 或者由其组成的 ``list``。 + :raises ValueError: 参与方的 ID 应为 ``str`` 或 ``int``。 + :raises ValueError: ``status`` 应为 ``LoccState`` 或者由其组成的 ``list``。 + :return: 测量后的 LOCC 态。 + :rtype: Union[List[LoccState], LoccState] + + .. py:method:: get_num_qubits() + + 得到该 LoccNet 的量子比特个数。 + + :return: 该 LoccNet 的量子比特个数。 + :rtype: int diff --git a/docs_zh_CN/source/paddle_quantum.locc.locc_party.rst b/docs_zh_CN/source/paddle_quantum.locc.locc_party.rst new file mode 100644 index 0000000..9499930 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.locc.locc_party.rst @@ -0,0 +1,13 @@ +paddle\_quantum.locc.locc\_party +======================================= + +LOCC中设置某一方的功能实现。 + +.. py:class:: LoccParty(num_qubits) + + 基类：:py:class:`object` + + LOCC 的参与方。 + + :param num_qubits: 该参与方的量子比特数量。 + :type num_qubits: int diff --git a/docs_zh_CN/source/paddle_quantum.locc.locc_state.rst b/docs_zh_CN/source/paddle_quantum.locc.locc_state.rst new file mode 100644 index 0000000..36e9700 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.locc.locc_state.rst @@ -0,0 +1,34 @@ +paddle\_quantum.locc.locc\_state +======================================= + +LOCC中量子态的功能实现。 + +.. py:class:: LoccState(data=None, prob=None, measured_result=None, num_qubits=None, backend=None, dtype=None) + + 基类：:py:class:`paddle_quantum.state.state.State` + + LOCCNet 中的一个 LOCC 态。 + + 由于我们在 LOCC 中不仅关心量子态的解析形式，同时还关心得到它的概率，以及是经过怎样的测量而得到的。 + 因此该类包含三个成员变量：量子态 ``data``、得到这个态的概率 ``prob``，和得到这个态的测量的测量结果是什么， + 即 ``measured_result``。 + + :param data: 量子态的矩阵形式，默认为 ``None``。 + :type data: paddle.Tensor, optional + :param prob: 得到该量子态的概率，默认为 ``None``。 + :type prob: paddle.Tensor, optional + :param measured_result: 得到该量子态的测量的测量结果，默认为 ``None``。 + :type measured_result: str, optional + :param num_qubits: 总的量子比特个数，默认为 ``None``。 + :type num_qubits: int, optional + :param backend: 量桨的后端，默认为 ``None``。 + :type backend: paddle_quantum.Backend, optional + :param dtype: 数据的类型，默认为 ``None``。 + :type dtype: str, optional + + .. py:method:: clone() + + 创建一个当前对象的副本。 + + :return: 当前对象的副本。 + :rtype: LoccState diff --git a/docs_zh_CN/source/paddle_quantum.locc.rst b/docs_zh_CN/source/paddle_quantum.locc.rst new file mode 100644 index 0000000..dd79fa7 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.locc.rst @@ -0,0 +1,14 @@ +paddle\_quantum.locc +============================ + +LOCC的功能实现。 + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.locc.locc_ansatz + paddle_quantum.locc.locc_net + paddle_quantum.locc.locc_party + paddle_quantum.locc.locc_state diff --git a/docs_zh_CN/source/paddle_quantum.loss.distance.rst b/docs_zh_CN/source/paddle_quantum.loss.distance.rst new file mode 100644 index 0000000..7e8b234 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.loss.distance.rst @@ -0,0 +1,50 @@ +paddle\_quantum.loss.distance +==================================== + +距离度量的损失函数的功能实现。 + +.. py:class:: TraceDistance(target_state) + + 基类：:py:class:`paddle_quantum.Operator` + + 该类用于实现迹距离的损失函数。 + + 该类允许用户使用迹距离作为损失函数来训练量子神经网络。 + + :param target_state: 用于计算迹距离的目标量子态。 + :type target_state: paddle_quantum.State + + .. py:method:: forward(state) + + 计算输入量子态和目标量子态的迹距离。 + + 该函数计算的值可以作为损失函数进行优化。 + + :param state: 输入量子态，它将会和目标量子态计算迹距离。 + :type state: paddle_quantum.State + :raises NotImplementedError: 所指定的后端必须为量桨已经实现的后端。 + :return: 输入量子态和目标量子态之间的迹距离。 + :rtype: paddle.Tensor + +.. py:class:: StateFidelity(target_state) + + 基类：:py:class:`paddle_quantum.Operator` + + 该类用于实现量子态保真度的损失函数。 + + 该类允许用户使保真度作为损失函数来训练量子神经网络。 + + :param target_state: 用于计算保真度的目标量子态。 + :type target_state: paddle_quantum.State + + .. py:method:: forward(state) + + 计算输入量子态和目标量子态的保真度。 + + 该函数计算的值可以作为损失函数进行优化。 + + :param state: 输入量子态，它将会和目标量子态计算保真度。 + :type state: paddle_quantum.State + :raises NotImplementedError: 所指定的后端必须为量桨已经实现的后端。 + :return: 输入量子态和目标量子态之间的保真度。 + :rtype: paddle.Tensor diff --git a/docs_zh_CN/source/paddle_quantum.loss.measure.rst b/docs_zh_CN/source/paddle_quantum.loss.measure.rst new file mode 100644 index 0000000..f084e88 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.loss.measure.rst @@ -0,0 +1,53 @@ +paddle\_quantum.loss.measure +=================================== + +测量的损失函数的功能实现。 + +.. py:class:: ExpecVal(hamiltonian, shots) + + 基类：:py:class:`paddle_quantum.Operator` + + 该类用来计算可观测量的期望值。 + + 该类可以让你使用对可观测量的期望值作为损失函数。 + + :param hamiltonian: 输入的可观测量的信息。 + :type hamiltonian: paddle_quantum.Hamiltonian + :param shots: 测量的次数。默认是 ``0``，使用解析解。只有当后端为 QuLeaf 时，才需要指定该参数。 + :type shots: int, optional + + .. py:method:: forward(state) + + 计算可观测量对于输入的量子态的期望值。 + + 该函数计算的值可以作为损失函数进行优化。 + + :param state: 输入量子态，它将被用来计算期望值。 + :type state: paddle_quantum.State + :raises NotImplementedError: 所指定的后端必须为量桨已经实现的后端。 + :return: 计算得到的期望值，如果后端是 QuLeaf，则返回根据采样计算的到的结果。 + :rtype: paddle.Tensor + +.. py:class:: Measure(measure_basis='z') + + 基类：:py:class:`paddle_quantum.Operator` + + 该类用来计算可观测量的期望值。 + + 该类可以让你使用对可观测量的期望值作为损失函数。 + + :param measure_basis: 要观测的测量基底。默认为 ``'z'``，在 Z 方向上测量。 + :type measure_basis: Union[Iterable[paddle.Tensor], str] + + .. py:method:: forward(state, qubits_idx='full', desired_result=None) + + 计算对输入量子态进行测量得到的概率值。 + + :param state: 需要测量的量子态。 + :type state: paddle_quantum.State + :param qubits_idx: 要测量的量子比特的下标，默认为 ``'full'``，表示全都测量。 + :type qubits_idx: Union[Iterable[int], int, str], optional + :param desired_result: 指定要返回的测量结果的概率值。默认为 ``None``，返回所有测量结果的概率值。 + :type desired_result: Union[Iterable[str], str], optional + :return: 测量结果所对应的概率值。 + :rtype: paddle.Tensor diff --git a/docs_zh_CN/source/paddle_quantum.loss.rst b/docs_zh_CN/source/paddle_quantum.loss.rst new file mode 100644 index 0000000..d3f8e56 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.loss.rst @@ -0,0 +1,12 @@ +paddle\_quantum.loss +============================ + +量桨中损失函数的功能实现。 + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.loss.distance + paddle_quantum.loss.measure diff --git a/docs_zh_CN/source/paddle_quantum.mbqc.qobject.rst b/docs_zh_CN/source/paddle_quantum.mbqc.qobject.rst new file mode 100644 index 0000000..bb69cd7 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.mbqc.qobject.rst @@ -0,0 +1,2 @@ +paddle\_quantum.mbqc.qobject +============================ diff --git a/docs_zh_CN/source/paddle_quantum.mbqc.rst b/docs_zh_CN/source/paddle_quantum.mbqc.rst new file mode 100644 index 0000000..813af53 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.mbqc.rst @@ -0,0 +1,14 @@ +paddle\_quantum.mbqc +==================== + +量桨的 MBQC 模块。 + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.mbqc.qobject + paddle_quantum.mbqc.simulator + paddle_quantum.mbqc.transpiler + paddle_quantum.mbqc.utils diff --git a/docs_zh_CN/source/paddle_quantum.mbqc.simulator.rst b/docs_zh_CN/source/paddle_quantum.mbqc.simulator.rst new file mode 100644 index 0000000..5ab2eb1 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.mbqc.simulator.rst @@ -0,0 +1,2 @@ +paddle\_quantum.mbqc.simulator +============================== diff --git a/docs_zh_CN/source/paddle_quantum.mbqc.transpiler.rst b/docs_zh_CN/source/paddle_quantum.mbqc.transpiler.rst new file mode 100644 index 0000000..c51886a --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.mbqc.transpiler.rst @@ -0,0 +1,2 @@ +paddle\_quantum.mbqc.transpiler +=============================== diff --git a/docs_zh_CN/source/paddle_quantum.mbqc.utils.rst b/docs_zh_CN/source/paddle_quantum.mbqc.utils.rst new file mode 100644 index 0000000..cfa3bc8 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.mbqc.utils.rst @@ -0,0 +1,2 @@ +paddle\_quantum.mbqc.utils +========================== diff --git a/docs_zh_CN/source/paddle_quantum.operator.operator.rst b/docs_zh_CN/source/paddle_quantum.operator.operator.rst new file mode 100644 index 0000000..ae0c958 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.operator.operator.rst @@ -0,0 +1,52 @@ +paddle\_quantum.operator.operator +======================================== + +特殊量子操作的功能实现。 + +.. py:class:: ResetState() + + 基类：:py:class:`paddle_quantum.Operator` + + 重置量子态。该类目前还没有实现。 + + .. py:method:: forward() + + 前向函数，目前还没有实现。 + + :return: 还没有实现。 + :rtype: NotImplementedType + +.. py:class:: PartialState() + + 基类：:py:class:`paddle_quantum.Operator` + + 得到部分量子态。该类目前还没有实现。 + + .. py:method:: forward() + + 前向函数，目前还没有实现。 + + :return: 还没有实现。 + :rtype: NotImplementedType + +.. py:class:: Collapse(measure_basis) + + 基类：:py:class:`paddle_quantum.Operator` + + 该类可以让你使用对量子态进行坍缩，坍缩到某一本征态。 + + :param measure_basis: 测量基底。量子态会坍缩到对应的本征态上。 + :type measure_basis: Union[Iterable[paddle.Tensor], str] + :raises NotImplementedError: 所输入的测量基底还没有实现。 + + .. py:method:: forward(state, desired_result) + + 计算输入的量子态的坍缩。 + + :param state: 输入的量子态，其将会被坍缩。 + :type state: paddle_quantum.State + :param desired_result: 想要坍缩到的特定结果。 + :type desired_result: Union[int, str] + :raises NotImplementedError: 当前仅支持 z 基底。 + :return: 坍缩后的量子态。 + :rtype: paddle_quantum.State diff --git a/docs_zh_CN/source/paddle_quantum.operator.rst b/docs_zh_CN/source/paddle_quantum.operator.rst new file mode 100644 index 0000000..934c581 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.operator.rst @@ -0,0 +1,11 @@ +paddle\_quantum.operator +================================ + +特殊量子操作的功能库。 + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.operator.operator diff --git a/docs_zh_CN/source/paddle_quantum.qchem.density_matrix.rst b/docs_zh_CN/source/paddle_quantum.qchem.density_matrix.rst new file mode 100644 index 0000000..049c8a3 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.qchem.density_matrix.rst @@ -0,0 +1,22 @@ +paddle\_quantum.qchem.density\_matrix +============================================ + +对量子态测量单体密度矩阵。 + +.. py:class:: OneBodyDensityMatrix() + + 基类： :py:class:`paddle.autograd.PyLayer` + + 用于测量给定量子态的单体密度矩阵。 + +.. py:function:: get_spinorb_onebody_dm(n_qubits, state) + + 获取给定量子态的单体密度矩阵，并以自旋轨道数标注量子比特。 + + :param n_qubits: 量子态所包含的量子比特数。 + :type n_qubits: int + :param state: 给定量子态。 + :type state: paddle.Tensor + + :return: 自旋轨道数标注的单体密度矩阵。 + :rtype: Tuple[paddle.Tensor] \ No newline at end of file diff --git a/docs_zh_CN/source/paddle_quantum.qchem.hardware_efficient.rst b/docs_zh_CN/source/paddle_quantum.qchem.hardware_efficient.rst new file mode 100644 index 0000000..5817e62 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.qchem.hardware_efficient.rst @@ -0,0 +1,15 @@ +paddle\_quantum.qchem.hardware\_efficient +================================================ + +Hardware Efficient 电路模板。 + +.. py:class:: HardwareEfficientModel(n_qubits, depth, theta = None) + + 基类： :py:class:`paddle_quantum.gate.base.Gate` + + :param n_qubits: 量子态所包含的量子比特数。 + :type n_qubits: int + :param depth: 量子电话深度，单层 Hardware Efficient 量子电路包含 [Ry, Rz, CNOT] 门。 + :type depth: int + :param theta: 线路中 Ry, Rz 量子门的参数，默认值为 ``None``。 + :type theta: paddle.Tensor, optional diff --git a/docs_zh_CN/source/paddle_quantum.qchem.loss.rst b/docs_zh_CN/source/paddle_quantum.qchem.loss.rst new file mode 100644 index 0000000..adfdffe --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.qchem.loss.rst @@ -0,0 +1,36 @@ +paddle\_quantum.qchem.loss +================================= + +量子化学中的损失函数。 + +.. py:class:: MolEnergyLoss(geometry, basis, multiplicity = 1, charge = 0) + + 基类：:py:class:`paddle_quantum.loss.ExpecVal` + + 分子基态计算的损失函数。 + + :param geometry: 表示分子位置几何信息，例如 ``H 0.0 0.0 0.0; H 0.0 0.0 0.74``。 + :type geometry: str + :param basis: 化学基选取，例如 ``sto-3g``。 + :type basis: str + :param multiplicity: 自旋多重度, 默认值为 ``1``。 + :type multiplicity: int, optional + :param charge: 分子电荷量， 默认值为 ``0``。 + :type charge: int, optional + +.. py:class:: RHFEnergyLoss(geometry, basis, multiplicity = 1, charge = 0) + + 基类: :py:class:`paddle_quantum.Operator` + + Restricted Hartree Fock 计算的损失函数。 + + :param geometry: 表示分子位置几何信息，例如 ``H 0.0 0.0 0.0; H 0.0 0.0 0.74``。 + :type geometry: str + :param basis: 化学基选取，例如 ``sto-3g``。 + :type basis: str + :param multiplicity: 自旋多重度, 默认值为 ``1``。 + :type multiplicity: int, optional + :param charge: 分子电荷量， 默认值为 ``0``。 + :type charge: int, optional + + :raises ModuleNotFoundError: Hartree Fock 方法需要安装 ``pyscf`` 包。安装请运行 ``pip install -U pyscf``。 \ No newline at end of file diff --git a/docs_zh_CN/source/paddle_quantum.qchem.qchem.rst b/docs_zh_CN/source/paddle_quantum.qchem.qchem.rst new file mode 100644 index 0000000..7b68ba1 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.qchem.qchem.rst @@ -0,0 +1,101 @@ +paddle\_quantum.qchem.qchem +================================== + +量子化学中的功能函数。 + +.. py:function:: geometry(structure, file) + + 读取分子几何信息。 + + :param structure: 分子几何信息的字符串形式， 以 H2 分子为例 ``[['H', [-1.68666, 1.79811, 0.0]], ['H', [-1.12017, 1.37343, 0.0]]]``。 + :type structure: string, optional + :param file: xyz 文件的路径。 + :type file: str, optional + + :raises AssertionError: 两个输入参数不可以同时为 ``None``。 + + :return: 分子的几何信息。 + :rtype: str + +.. py:function:: get_molecular_data(geometry, charge, multiplicity, basis, method, if_save, if_print, name, file_path) + + 计算分子的必要信息，包括单体积分（one-body integrations）和双体积分（two-body integrations，以及用选定的方法计算基态的能量。 + + :param geometry: 分子的几何信息。 + :type geometry: str + :param charge: 分子电荷, 默认值为 ``0``。 + :type charge: int, optional + :param multiplicity: 分子的多重度, 默认值为 ``1``。 + :type multiplicity: int, optional + :param basis: 常用的基组是 ``sto-3g、6-31g``等, 默认的基组是 ``sto-3g``，更多的基组选择可以参考网站 + https://psicode.org/psi4manual/master/basissets_byelement.html#apdx-basiselement。 + :type basis: str, optional + :param method: 用于计算基态能量的方法, 包括 ``scf`` 和 ``fci``，默认的方法为 ``scf``。 + :type method: str, optional + :param if_save: 是否需要将分子信息存储成 .hdf5 文件，默认为 ``True``。 + :type if_save: bool, optional + :param if_print: 是否需要打印出选定方法 (method) 计算出的分子基态能量，默认为 ``True``。 + :type if_print: bool, optional + :param name: 命名储存的文件, 默认为 ``""``。 + :type name: str, optional + :param file_path: 文件的储存路径, 默认为 ``"."``。 + :type file_path: str, optional + + :return: 包含分子所有信息的类。 + :rtype: MolecularData + +.. py:function:: active_space(electrons, orbitals, multiplicity, active_electrons, active_orbitals) + + 对于给定的活跃电子和活跃轨道计算相应的活跃空间（active space）。 + + :param electrons: 电子数。 + :type electrons: int + :param orbitals: 轨道数。 + :type orbitals: int + :param multiplicity: 自旋多重度, 默认值为 ``1``。 + :type multiplicity: int, optional + :param active_electrons: 活跃 (active) 电子数，默认情况为所有电子均为活跃电子。 + :type active_electrons: int, optional + :param active_orbitals: 活跃 (active) 轨道数，默认情况为所有轨道均为活跃轨道。 + :type active_orbitals: int, optional + + :return: 核心轨道和活跃轨道的索引。 + :rtype: tuple + +.. py:function:: fermionic_hamiltonian(molecule, filename, multiplicity, active_electrons, active_orbitals) + + 计算给定分子的费米哈密顿量。 + + :param molecule: 包含分子所有信息的类。 + :type molecule: MolecularData + :param filename: 分子的 .hdf5 文件的路径。 + :type filename: str, optional + :param multiplicity: 自旋多重度, 默认值为 ``1``。 + :type multiplicity: int, optional + :param active_electrons: 活跃 (active) 电子数，默认情况为所有电子均为活跃电子。 + :type active_electrons: int, optional + :param active_orbitals: 活跃 (active) 轨道数，默认情况为所有轨道均为活跃轨道。 + :type active_orbitals: int, optional + + :return: openfermion 格式的哈密顿量。 + :rtype: openfermion.ops.operators.qubit_operator.QubitOperator + +.. py:function:: spin_hamiltonian(molecule, filename, multiplicity, mapping_method, active_electrons, active_orbitals) + + 生成 Paddle Quantum 格式的哈密顿量。 + + :param molecule: openfermion 格式的哈密顿量。 + :type molecule: openfermion.ops.operators.qubit_operator.QubitOperator + :param filename: 分子的 .hdf5 文件的路径。 + :type filename: str, optional + :param multiplicity: 自旋多重度, 默认值为 ``1``。 + :type multiplicity: int, optional + :param mapping_method: 映射方法，这里默认为 ``jordan_wigner``，此外还提供 ``bravyi_kitaev`` 方法。 + :type mapping_method: str, optional + :param active_electrons: 活跃 (active) 电子数，默认情况为所有电子均为活跃电子。 + :type active_electrons: int, optional + :param active_orbitals: 活跃 (active) 轨道数默认情况为所有轨道均为活跃轨道。 + :type active_orbitals: int, optional + + :return: Paddle Quantum 格式的哈密顿量。 + :rtype: Hamiltonian \ No newline at end of file diff --git a/docs_zh_CN/source/paddle_quantum.qchem.rst b/docs_zh_CN/source/paddle_quantum.qchem.rst new file mode 100644 index 0000000..4422905 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.qchem.rst @@ -0,0 +1,16 @@ +paddle\_quantum.qchem +============================= + +量子化学模块。 + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.qchem.density_matrix + paddle_quantum.qchem.hardware_efficient + paddle_quantum.qchem.loss + paddle_quantum.qchem.qchem + paddle_quantum.qchem.slater_determinant + paddle_quantum.qchem.uccsd diff --git a/docs_zh_CN/source/paddle_quantum.qchem.slater_determinant.rst b/docs_zh_CN/source/paddle_quantum.qchem.slater_determinant.rst new file mode 100644 index 0000000..3fc277a --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.qchem.slater_determinant.rst @@ -0,0 +1,36 @@ +paddle\_quantum.qchem.slater\_determinant +================================================ + +受限 Hartree Fock 下的 Slater 行列式电路模板。 + +.. py:class:: GivensRotationBlock(pindex, qindex, theta) + + 基类：:py:class:`paddle_quantum.gate.Gate` + + 双量子门，用于实现给定旋转。 + + .. math:: + + \begin{align} + U(\theta)=e^{-i\frac{\theta}{2}(Y\otimes X-X\otimes Y)} + \end{align} + + :param pindex: 第一个qubit的编号。 + :type pindex: int + :param qindex: 第二个qubit的编号。 + :type qindex: int + :param theta: 给定旋转角度。 + :type theta: float + +.. py:class:: RHFSlaterDeterminantModel(n_qubits, n_electrons, mo_coeff = None) + + 基类：:py:class:`paddle_quantum.gate.Gate` + + 在 Restricted Hartree Fock 计算中使用的 Slater 方阵拟设。 + + :param n_qubits: 量子态所包含的量子比特数。 + :type n_qubits: int + :param n_electrons: 分子中所包含的电子数。 + :type n_electrons: int + :param mo_coeff: 初始化Slater 方阵态的参数, 默认值为 ``None``。 + :type mo_coeff: Union[np.array, None], optional \ No newline at end of file diff --git a/docs_zh_CN/source/paddle_quantum.qchem.uccsd.rst b/docs_zh_CN/source/paddle_quantum.qchem.uccsd.rst new file mode 100644 index 0000000..088fbc3 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.qchem.uccsd.rst @@ -0,0 +1,36 @@ +paddle\_quantum.qchem.uccsd +================================== + +UCCSD 电路模板。 + +.. py:class:: UCCSDModel(n_qubits, n_electrons, n_trotter_steps, single_excitation_amplitude = None, double_excitation_amplitude = None) + + 基类：:py:class:`paddle_quantum.gate.Gate` + + 量子化学计算中的酉耦合簇拟设 (UCCSD)。 + + .. note:: + UCCSD 模型一般需要建立非常深的量子电路。因此，对于 H2 元素序列之后的分子结构，训练 UCCSD 拟设需要更好的设备及大量的运算时间。 + + .. math:: + + \begin{align} + U(\theta)&=e^{\hat{T}-\hat{T}^{\dagger}}\\ + \hat{T}&=\hat{T}_1+\hat{T}_2\\ + \hat{T}_1&=\sum_{a\in{\text{virt}}}\sum_{i\in\text{occ}}t_{ai}\sum_{\sigma}\hat{c}^{\dagger}_{a\sigma}\hat{c}_{i\sigma}-h.c.\\ + \hat{T}_2&=\frac{1}{2}\sum_{a,b\in\text{virt}}\sum_{i,j\in\text{occ}}t_{aibj}\sum_{\sigma\tau}\hat{c}^{\dagger}_{a\sigma}\hat{c}^{\dagger}_{b\tau}\hat{c}_{j\tau}\hat{c}_{i\sigma}-h.c. + \end{align} + + :param n_qubits: 量子态所包含的量子比特数。 + :type n_qubits: int + :param n_electrons: 分子中所包含的电子数。 + :type n_electrons: int + :param n_trotter_steps: 建立UCCSD电路所需的特罗特分解步数。 + :type n_trotter_steps: int + :param single_excitation_amplitude: :math:`\hat{T}_1` 定义中的 :math:`t_{ai}`, 默认值为 ``None``。 + :type single_excitation_amplitude: Union[np.array, None], optional + :param double_excitation_amplitude: :math:`\hat{T}_2` 定义中的 :math:`t_{aibj}`, 默认值为 ``None``。 + :type double_excitation_amplitude: Union[np.array, None], optional + + + diff --git a/docs_zh_CN/source/paddle_quantum.qinfo.rst b/docs_zh_CN/source/paddle_quantum.qinfo.rst new file mode 100644 index 0000000..7d7d447 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.qinfo.rst @@ -0,0 +1,257 @@ +paddle\_quantum.qinfo +============================ + +量子信息中的常用功能实现。 + +.. py:function:: partial_trace(rho_AB, dim1, dim2, A_or_B) + + 计算量子态的偏迹。 + + :param rho_AB: 输入的量子态。 + :type rho_AB: paddle_quantum.State + :param dim1: 系统A的维数。 + :type dim1: int + :param dim2: 系统B的维数。 + :type dim2: int + :param A_or_B: 1或者2，1表示计算系统A上的偏迹，2表示计算系统B上的偏迹。 + :type A_or_B: int + + :return: 输入的量子态的偏迹。 + :rtype: paddle.Tensor + +.. py:function:: partial_trace_discontiguous(rho, preserve_qubits = None) + + 计算量子态的偏迹，可选取任意子系统。 + + :param rho: 输入的量子态。 + :type rho: paddle_quantum.State + :param preserve_qubits: 要保留的量子比特，默认为 None，表示全保留。 + :type preserve_qubits: list, optional + + :return: 所选子系统的量子态偏迹。 + :rtype: paddle.Tensor + +.. py:function:: trace_distance(rho, sigma) + + 计算两个量子态的迹距离。 + + .. math:: + + D(\rho, \sigma) = 1 / 2 * \text{tr}|\rho-\sigma| + + :param rho: 量子态的密度矩阵形式。 + :type rho: paddle_quantum.State + :param sigma: 量子态的密度矩阵形式。 + :type sigma: paddle_quantum.State + + :return: 输入的量子态之间的迹距离。 + :rtype: paddle.Tensor + +.. py:function:: state_fidelity(rho, sigma) + + 计算两个量子态的保真度。 + + .. math:: + + F(\rho, \sigma) = \text{tr}(\sqrt{\sqrt{\rho}\sigma\sqrt{\rho}}) + + :param rho: 量子态的密度矩阵形式。 + :type rho: paddle_quantum.State + :param sigma: 量子态的密度矩阵形式。 + :type sigma: paddle_quantum.State + :return: 输入的量子态之间的保真度。 + :rtype: paddle.Tensor + +.. py:function:: gate_fidelity(U, V) + + 计算两个量子门的保真度。 + + .. math:: + + F(U, V) = |\text{tr}(UV^\dagger)|/2^n + + :math:`U` 是一个 :math:`2^n\times 2^n` 的 Unitary 矩阵。 + + :param U: 量子门 :math:`U` 的酉矩阵形式 + :type U: paddle.Tensor + :param V: 量子门 :math:`V` 的酉矩阵形式 + :type V: paddle.Tensor + + :return: 输入的量子门之间的保真度 + :rtype: paddle.Tensor + +.. py:function:: purity(rho) + + 计算量子态的纯度。 + + .. math:: + + P = \text{tr}(\rho^2) + + :param rho: 量子态的密度矩阵形式。 + :type rho: paddle_quantum.State + + :return: 输入的量子态的纯度。 + :rtype: paddle.Tensor + +.. py:function:: von_neumann_entropy(rho) + + 计算量子态的冯诺依曼熵。 + + .. math:: + + S = -\text{tr}(\rho \log(\rho)) + + :param rho: 量子态的密度矩阵形式。 + :type rho: paddle_quantum.State + + :return: 输入的量子态的冯诺依曼熵。 + :rtype: paddle.Tensor + +.. py:function:: relative_entropy(rho, sig) + + 计算两个量子态的相对熵。 + + .. math:: + + S(\rho \| \sigma)=\text{tr} \rho(\log \rho-\log \sigma) + + :param rho: 量子态的密度矩阵形式 + :type rho: paddle_quantum.State + :param sig: 量子态的密度矩阵形式 + :type sig: paddle_quantum.State + + :return: 输入的量子态之间的相对熵 + :rtype: paddle.Tensor + +.. py:function:: random_pauli_str_generator(n, terms = 3) + + 随机生成一个可观测量（observable）的列表（ ``list`` ）形式。 + + 一个可观测量 :math:`O=0.3X\otimes I\otimes I+0.5Y\otimes I\otimes Z` 的 + 列表形式为 ``[[0.3, 'x0'], [0.5, 'y0,z2']]`` 。这样一个可观测量是由 + 调用 ``random_pauli_str_generator(3, terms=2)`` 生成的。 + + :param n: 量子比特数量。 + :type n: int + :param terms: 可观测量的项数, 默认为 3。 + :type terms: int, optional + + :return: 随机生成的可观测量的列表形式。 + :rtype: List + +.. py:function:: pauli_str_to_matrix(pauli_str, n) + + 将输入的可观测量（observable）的列表（ ``list`` ）形式转换为其矩阵形式。 + + 如输入的 ``pauli_str`` 为 ``[[0.7, 'z0,x1'], [0.2, 'z1']]`` 且 ``n=3`` , + 则此函数返回可观测量 :math:`0.7Z\otimes X\otimes I+0.2I\otimes Z\otimes I` 的 + 矩阵形式。 + + :param pauli_str: 一个可观测量的列表形式。 + :type pauli_str: list + :param n: 量子比特数量。 + :type n: int + + :raises ValueError: 只有泡利算子 "I" 可以被接受，而不指定其位置。 + + :return: 输入列表对应的可观测量的矩阵形式。 + :rtype: paddle.Tensor + +.. py:function:: partial_transpose_2(density_op, sub_system = None) + + 计算输入量子态的 partial transpose :math:`\rho^{T_A}`。 + + :param density_op: 量子态的密度矩阵形式。 + :type density_op: paddle_quantum.State + :param sub_system: 1或2，表示关于哪个子系统进行 partial transpose，默认为第二个。 + :type sub_system: int, optional + + :return: 输入的量子态的 partial transpose + :rtype: paddle.Tensor + +.. py:function:: partial_transpose(density_op, n) + + 计算输入量子态的 partial transpose :math:`\rho^{T_A}`。 + + :param density_op: 量子态的密度矩阵形式。 + :type density_op: paddle_quantum.State + :param n: 需要转置系统的量子比特数量。 + :type n: int + + :return: 输入的量子态的 partial transpose。 + :rtype: paddle.Tensor + +.. py:function:: negativity(density_op) + + 计算输入量子态的 Negativity :math:`N = ||\frac{\rho^{T_A}-1}{2}||`。 + + :param density_op: 量子态的密度矩阵形式。 + :type density_op: paddle_quantum.State + + :return: 输入的量子态的 Negativity。 + :rtype: paddle.Tensor + +.. py:function:: logarithmic_negativity(density_op) + + 计算输入量子态的 Logarithmic Negativity :math:`E_N = ||\rho^{T_A}||`。 + + :param density_op: 量子态的密度矩阵形式。 + :type density_op: paddle_quantum.State + + :return: 输入的量子态的 Logarithmic Negativity。 + :rtype: paddle.Tensor + +.. py:function:: is_ppt(density_op: paddle_quantum.State) + + 计算输入量子态是否满足 PPT 条件。 + + :param density_op: 量子态的密度矩阵形式。 + :type density_op: paddle_quantum.State + + :return: 输入的量子态是否满足 PPT 条件。 + :rtype: bool + +.. py:function:: schmidt_decompose(psi, sys_A = None) + + 计算输入量子态的施密特分解 :math:`\lvert\psi\rangle=\sum_ic_i\lvert i_A\rangle\otimes\lvert i_B \rangle`。 + + :param psi: 量子态的向量形式，形状为（2**n）。 + :type psi: paddle_quantum.State + :param sys_A: 包含在子系统 A 中的 qubit 下标（其余 qubit 包含在子系统B中），默认为量子态 :math:`\lvert \psi\rangle` 的前半数 qubit。 + :type sys_A: List[int], optional + + :return: + 包含如下元素： + + - 由施密特系数组成的一维数组，形状为 ``(k)``。 + - 由子系统A的基 :math:`\lvert i_A\rangle` 组成的高维数组，形状为 ``(k, 2**m, 1)``。 + - 由子系统B的基 :math:`\lvert i_B\rangle` 组成的高维数组，形状为 ``(k, 2**l, 1)``。 + + :rtype: Tuple[paddle.Tensor] + +.. py:function:: image_to_density_matrix(image_filepath) + + 将图片编码为密度矩阵。 + + :param image_filepath: 图片文件的路径。 + :type image_filepath: str + + :return: 编码得到的密度矩阵。 + :rtype: paddle_quantum.State + +.. py:function:: shadow_trace(state, hamiltonian, sample_shots, method = 'CS') + + 估计可观测量 :math:`H` 的期望值 :math:`\text{trace}(H\rho)`。 + + :param state: 输入的量子态。 + :type state: paddle_quantum.State + :param hamiltonian: 可观测量。 + :type hamiltonian: paddle_quantum.Hamiltonian + :param sample_shots: 采样次数。 + :type sample_shots: int + :param method: 使用 shadow 来进行估计的方法，可选 "CS"、"LBCS"、"APS" 三种方法，默认为 ``CS``。 + :type method: str, optional + + :return: 估计可观测量 :math:`H` 的期望值。 + :rtype: float diff --git a/docs_zh_CN/source/paddle_quantum.shadow.rst b/docs_zh_CN/source/paddle_quantum.shadow.rst new file mode 100644 index 0000000..4648983 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.shadow.rst @@ -0,0 +1,24 @@ +paddle\_quantum.shadow +============================= + +量子态的经典影子的功能实现。 + +.. py:function:: shadow_sample(state, num_qubits, sample_shots, mode, hamiltonian=None, method='CS') + + 对给定的量子态进行随机的泡利测量并返回测量结果。 + + :param state: 输入量子态，支持态矢量和密度矩阵形式。 + :type state: paddle_quantum.State + :param num_qubits: 量子比特数量。 + :type num_qubits: int + :param sample_shots: 随机采样的次数。 + :type sample_shots: int + :param mode: 输入量子态的表示方式, ``'state_vector'`` 表示态矢量形式， ``'density_matrix'`` 表示密度矩阵形式。 + :type mode: paddle_quantum.Backend + :param hamiltonian: 可观测量的相关信息，输入形式为 ``Hamiltonian`` 类，默认为 ``None``。 + :type hamiltonian: paddle_quantum.Hamiltonian, optional + :param method: 进行随机采样的方法，有 ``'CS'`` 、 ``'LBCS'`` 、 ``'APS'`` 三种方法，默认为 ``'CS'``。 + :type method: str, optional + + :return: 随机选择的泡利测量基和测量结果，形状为 ``(sample_shots, 2)`` 的list。 + :rtype: list diff --git a/docs_zh_CN/source/paddle_quantum.state.common.rst b/docs_zh_CN/source/paddle_quantum.state.common.rst new file mode 100644 index 0000000..9c2731c --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.state.common.rst @@ -0,0 +1,182 @@ +paddle\_quantum.state.common +=================================== + +常见的量子态的实现。 + +.. py:function:: to_state(data, num_qubits=None, backend=None, dtype=None) + + 根据给定的输入，生成对应的量子态。 + + :param data: 量子态的数学解析形式。 + :type data: Union[paddle.Tensor, np.ndarray, QCompute.QEnv] + :param num_qubits: 量子态所包含的量子比特数。默认为 ``None``，会自动从 data 中推导出来。 + :type num_qubits: int, optional + :param backend: 指定量子态的后端实现形式。默认为 ``None``，使用全局的默认后端。 + :type backend: paddle_quantum.Backend, optional + :param dtype: 量子态的数据类型。默认为 ``None``，使用全局的默认数据类型。 + :type dtype: str, optional + :return: 生成的量子态。 + :rtype: paddle_quantum.State + +.. py:function:: zero_state(num_qubits, backend=None, dtype=None) + + 生成零态。 + + :param num_qubits: 量子态所包含的量子比特数。 + :type num_qubits: int + :param backend: 指定量子态的后端实现形式。默认为 None，使用全局的默认后端。 + :type backend: paddle_quantum.Backend, optional + :param dtype: 量子态的数据类型。默认为 None，使用全局的默认数据类型。 + :type dtype: str, optional + :raises NotImplementedError: 所指定的后端必须为量桨已实现的后端。 + :return: 所生成的零态。 + :rtype: paddle_quantum.State + +.. py:function:: computational_basis(num_qubits, index, backend, dtype=None) + + 生成计算基态 :math:`|e_{i}\rangle` ，其中 :math:`|e_{i}\rangle` 的第 :math:`i` 个元素为 1，其余元素为 0。 + + :param num_qubits: 量子态所包含的量子比特数。 + :type num_qubits: int + :param index: 计算基态 :math:`|e_{i}\rangle` 的下标 :math:`i` 。 + :type index: int + :param backend: 指定量子态的后端实现形式。默认为 ``None``，使用全局的默认后端。 + :type backend: paddle_quantum.Backend, optional + :param dtype: 量子态的数据类型。默认为 ``None``，使用全局的默认数据类型。 + :type dtype: str, optional + :raises NotImplementedError: 所指定的后端必须为量桨已实现的后端。 + :return: 所生成的计算基态。 + :rtype: paddle_quantum.State + +.. py:function:: bell_state(num_qubits, backend=None) + + 生成贝尔态。 + + 其数学表达形式为： + + .. math:: + + |\Phi_{D}\rangle=\frac{1}{\sqrt{D}} \sum_{j=0}^{D-1}|j\rangle_{A}|j\rangle_{B} + + :param num_qubits: 量子态所包含的量子比特数。 + :type num_qubits: int + :param backend: 指定量子态的后端实现形式。默认为 ``None``，使用全局的默认后端。 + :type backend: paddle_quantum.Backend, optional + :raises NotImplementedError: 所指定的后端必须为量桨已实现的后端。 + :return: 生成的贝尔态。 + :rtype: paddle_quantum.State + +.. py:function:: bell_diagonal_state(prob) + + 生成对角贝尔态。 + + 其数学表达形式为： + + .. math:: + + p_{1}|\Phi^{+}\rangle\langle\Phi^{+}|+p_{2}| \Psi^{+}\rangle\langle\Psi^{+}|+p_{3}| \Phi^{-}\rangle\langle\Phi^{-}| + + p_{4}|\Psi^{-}\rangle\langle\Psi^{-}| + + :raises Exception: 当后端为态矢量时，所输入量子态应该为纯态。 + :raises NotImplementedError: 所指定的后端必须为量桨已经实现的后端。 + + :returns: 生成的量子态。 + +.. py:function:: random_state(num_qubits, is_real=False, rank=None) + + 生成一个随机的量子态。 + + :param num_qubits: 量子态所包含的量子比特数。 + :type num_qubits: int + :param is_real: 是否为实数。默认为 ``False``，表示为复数。 + :type is_real: bool, optional + :param rank: 密度矩阵的秩。默认为 ``None``，表示使用满秩。 + :type rank: int, optional + :raises NotImplementedError: 所指定的后端必须为量桨已经实现的后端。 + :return: 随机生成的一个量子态。 + :rtype: paddle_quantum.State + +.. py:function:: w_state(num_qubits) + + 生成一个 W-state。 + + :param num_qubits: 量子态所包含的量子比特数。 + :type num_qubits: int + :raises NotImplementedError: 所指定的后端必须为量桨已经实现的后端。 + :returns: 生成的 W-state。 + :rtype: paddle_quantum.State + +.. py:function:: ghz_state(num_qubits) + + 生成一个 GHZ-state。 + + :param num_qubits: 量子态所包含的量子比特数。 + :type num_qubits: int + :raises NotImplementedError: 所指定的后端必须为量桨已经实现的后端。 + :returns: 生成的 GHZ-state。 + :rtype: paddle_quantum.State + +.. py:function:: completely_mixed_computational(num_qubits) + + 生成一个完全混合态。 + + + :param num_qubits: 量子态所包含的量子比特数。 + :type num_qubits: int + :raises Exception: 所指定的后端必须为态矢量。 + :raises NotImplementedError: 所指定的后端必须为量桨已经实现的后端。 + :returns: 生成的 GHZ-state。 + :rtype: paddle_quantum.State + +.. py:function:: r_state(prob) + + 生成一个 R-state。 + + 其数学表达形式为： + + .. math:: + + p|\Psi^{+}\rangle\langle\Psi^{+}| + (1 - p)|11\rangle\langle11| + + :param prob: 控制生成 R-state 的参数，它应该在 :math:`[0, 1]` 区间内。 + :type prob: float + :raises Exception: 当后端为态矢量时，所输入量子态应该为纯态。 + :raises NotImplementedError: 所指定的后端必须为量桨已经实现的后端。 + :returns: 生成的 R-state。 + :rtype: paddle_quantum.State + +.. py:function:: s_state(prob) + + 生成一个 S-state。 + + 其数学表达形式为： + + .. math:: + + p|\Phi^{+}\rangle\langle\Phi^{+}| + (1 - p)|00\rangle\langle00| + + :param prob: 控制生成 S-state 的参数，它应该在 :math:`[0, 1]` 区间内。 + :type prob: float + :raises Exception: 当后端为态矢量时，所输入量子态应该为纯态。 + :raises NotImplementedError: 所指定的后端必须为量桨已经实现的后端。 + :returns: 生成的 S-state。 + :rtype: paddle_quantum.State + +.. py:function:: isotropic_state(num_qubits, prob) + + 生成 isotropic state。 + + 其数学表达形式为： + + .. math:: + + p(\frac{1}{\sqrt{D}} \sum_{j=0}^{D-1}|j\rangle_{A}|j\rangle_{B}) + (1 - p)\frac{I}{2^n} + + :param num_qubits: 量子态所包含的量子比特数。 + :type num_qubits: int + :param prob: 控制生成 isotropic state 的参数，它应该在 :math:`[0, 1]` 区间内。 + :type prob: float + :raises Exception: 当后端为态矢量时，所输入量子态应该为纯态。 + :raises NotImplementedError: 所指定的后端必须为量桨已经实现的后端。 + :returns: 生成的 isotropic state。 + :rtype: paddle_quantum.State diff --git a/docs_zh_CN/source/paddle_quantum.state.rst b/docs_zh_CN/source/paddle_quantum.state.rst new file mode 100644 index 0000000..c9db7a6 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.state.rst @@ -0,0 +1,12 @@ +paddle\_quantum.state +============================= + +量子态的功能实现。 + +.. rubric:: Submodules + +.. toctree:: + :maxdepth: 4 + + paddle_quantum.state.common + paddle_quantum.state.state diff --git a/docs_zh_CN/source/paddle_quantum.state.state.rst b/docs_zh_CN/source/paddle_quantum.state.state.rst new file mode 100644 index 0000000..74bb0e6 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.state.state.rst @@ -0,0 +1,73 @@ +paddle\_quantum.state.state +================================== + +量子态类的功能实现。 + +.. py:class:: State(data, num_qubits=None, backend=None, dtype=None) + + 基类：:py:class:`object` + + 用于实现量子态的类。 + + :param data: 量子态的数学解析形式。 + :type data: Union[paddle.Tensor, np.ndarray, QCompute.QEnv] + :param num_qubits: 量子态所包含的量子比特数。默认为 None，会自动从 data 中推导出来。 + :type num_qubits: int, optional + :param backend: 指定量子态的后端实现形式。默认为 None，使用全局的默认后端。 + :type backend: paddle_quantum.Backend, optional + :param dtype: 量子态的数据类型。默认为 None，使用全局的默认数据类型。 + :type dtype: str, optional + + .. py:method:: numpy() + + 得到量子态的数据的 numpy 形式。 + + :return: 量子态的数据的 numpy.ndarray 形式。 + :rtype: np.ndarray + + .. py:method:: to(backend, dtype, device, blocking) + + 改变量子态的属性。 + + :param backend: 指定量子态的新的后端实现形式。 + :type backend: str + :param dtype: 指定量子态的新的数据类型。 + :type dtype: str + :param device: 指定量子态的新的存储设备。 + :type device: str + :param blocking: 如果为 False 并且当前 Tensor 处于固定内存上，将会发生主机到设备端的异步拷贝。否则会发生同步拷贝。如果为 None，blocking 会被设置为 True，默认 为False。 + :type blocking: str + :return: 返回 NotImplementedError，该函数会在后续实现。 + :rtype: Error + + .. py:method:: clone() + + 返回当前量子态的副本。 + + :return: 一个内容和当前量子态都相同的新的量子态。 + :rtype: paddle_quantum.State + + .. py:method:: expec_val(hamiltonian, shots: int) + + 量子态关于输入的可观测量的期望值。 + + :param hamiltonian: 输入的可观测量。 + :type hamiltonian: paddle_quantum.Hamiltonian + :param shots: 测量次数。 + :type shots: int + :return: 该量子态关于可观测量的期望值。 + :rtype: float + + + .. py:method:: measure(shots=0, qubits_idx=None, plot=False) + + 对量子态进行测量。 + + :param shots: 测量次数。默认为 0，即计算解析解。 + :type shots: int, optional + :param qubits_idx: 要测量的量子态下标。默认为 None，表示全部测量。 + :type qubits_idx: Union[Iterable[int], int], optional + :param plot: 是否画图。默认为 Flase，表示不画图。 + :type plot: bool, optional + :return: 测量结果。 + :rtype: dict diff --git a/docs_zh_CN/source/paddle_quantum.trotter.rst b/docs_zh_CN/source/paddle_quantum.trotter.rst new file mode 100644 index 0000000..b188203 --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.trotter.rst @@ -0,0 +1,112 @@ +paddle\_quantum.trotter +============================== + +Trotter 哈密顿量时间演化的功能实现。 + + +.. py:function:: construct_trotter_circuit(circuit, hamiltonian, tau, steps, method = 'suzuki', order = 1, grouping = None, coefficient = None, permutation = None) + + 向 circuit 的后面添加 trotter 时间演化电路，即给定一个系统的哈密顿量 H，该电路可以模拟系统的时间演化 :math:`U_{cir} e^{-iHt}`。 + + :param circuit: 需要添加时间演化电路的 Circuit 对象。 + :type circuit: Circuit + :param hamiltonian: 需要模拟时间演化的系统的哈密顿量 H。 + :type hamiltonian: Hamiltonian + :param tau: 每个 trotter 块的演化时间长度。 + :type tau: float + :param steps: 添加多少个 trotter 块。（提示： ``steps * tau`` 即演化的时间总长度 t） + :type steps: int + :param method: 搭建时间演化电路的方法，默认为 ``'suzuki'`` ，即使用 Trotter-Suzuki 分解。可以设置为 ``'custom'`` 来使用自定义的演化策略。（需要用 permutation 和 coefficient 来定义）。 + :type method: str, optional + :param order: Trotter-Suzuki decomposition 的阶数，默认为 ``1``，仅在使用 ``method='suzuki'`` 时有效。 + :type order: int, optional + :param grouping: 是否对哈密顿量进行指定策略的重新排列，默认为 ``None`` ，支持 ``'xyz'`` 和 ``'even_odd'`` 两种方法。 + :type grouping: str, optional + :param coefficient: 自定义时间演化电路的系数，对应哈密顿量中的各项，默认为 ``None`` ，仅在 ``method='custom'`` 时有效。 + :type coefficient: np.ndarrayorpaddle.Tensor, optional + :param permutation: 自定义哈密顿量的排列方式，默认为 ``None``，仅在 ``method='custom'`` 时有效。 + :type permutation: np.ndarray, optional + + .. Hint:: + + 想知道该函数是如何模拟的？更多信息请移步至量桨官网教程: https://qml.baidu.com/tutorials/overview.html. + +.. py:function:: optimal_circuit(circuit, theta, which_qubits) + + 添加一个优化电路，哈密顿量为’XXYYZZ’。 + + :param circuit: 需要添加门的电路。 + :type circuit: paddle_quantum.ansatz.Circuit + :param theta: 旋转角度需要传入三个参数。 + :type theta: Union[paddle.Tensor, float] + :param which_qubits: ``pauli_word`` 中的每个算符所作用的量子比特编号。 + :type which_qubits: Iterable + +.. py:function:: paddle_quantum.trotter.add_n_pauli_gate(circuit, theta, pauli_word, which_qubits) + + 添加一个对应着 N 个泡利算符张量积的旋转门，例如 :math:`e^{-\theta/2 \cdot X\otimes I\otimes X\otimes Y}`。 + + :param circuit: 需要添加门的电路。 + :type circuit: paddle_quantum.ansatz.Circuit + :param theta: 旋转角度。 + :type theta: Union[paddle.Tensor, float] + :param pauli_word: 泡利算符组成的字符串，例如 ``"XXZ"``。 + :type pauli_word: str + :param which_qubits: ``pauli_word`` 中的每个算符所作用的量子比特编号。 + :type which_qubits: Iterable + + :raises ValueError: The ``which_qubits`` 需要为 ``list``, ``tuple``, 或者 ``np.ndarray`` 格式。 + +.. py:function:: get_suzuki_permutation(length, order) + + 计算 Suzuki 分解对应的置换数组。 + + :param length: 对应哈密顿量中的项数，即需要置换的项数。 + :type length: int + :param order: Suzuki 分解的阶数。 + :type order: int + + :return: 置换数组。 + :rtype: np.ndarray + +.. py:function:: get_suzuki_p_values(k) + + 计算 Suzuki 分解中递推关系中的因数 p(k)。 + + :param k: Suzuki 分解的阶数。 + :type k: int + + :return: 一个长度为 5 的列表，其形式为 [p, p, (1 - 4 * p), p, p]。 + :rtype: list + +.. py:function:: get_suzuki_coefficients(length, order) + + 计算 Suzuki 分解对应的系数数组。 + + :param length: 对应哈密顿量中的项数，即需要置换的项数。 + :type length: int + :param order: Suzuki 分解的阶数。 + :type order: int + + :return: 系数数组。 + :rtype: np.ndarray + +.. py:function:: get_1d_heisenberg_hamiltonian(length, j_x = 1.0, j_y = 1.0, j_z = 1.0, h_z = 0.0, periodic_boundary_condition = True) + + 生成一个一维海森堡链的哈密顿量。 + + :param length: 链长。 + :type length: int + :param j_x: x 方向的自旋耦合强度 Jx，默认为 ``1``。 + :type j_x: float, optional + :param j_y: y 方向的自旋耦合强度 Jy，默认为 ``1``。 + :type j_y: float, optional + :param j_z: z 方向的自旋耦合强度 Jz，默认为 ``1``。 + :type j_z: float, optional + :param h_z: z 方向的磁场，默认为 ``0``，若输入为单个 float 则认为是均匀磁场。（施加在每一个格点上） + :type h_z: floatornp.ndarray, optional + :param periodic_boundary_condition: 是否考虑周期性边界条件，即 l + 1 = 0，默认为 ``True``。 + :type periodic_boundary_condition: bool, optional + + :return: 该海森堡链的哈密顿量。 + :rtype: Hamiltonian \ No newline at end of file diff --git a/docs_zh_CN/source/paddle_quantum.visual.rst b/docs_zh_CN/source/paddle_quantum.visual.rst new file mode 100644 index 0000000..75dd53a --- /dev/null +++ b/docs_zh_CN/source/paddle_quantum.visual.rst @@ -0,0 +1,76 @@ +paddle\_quantum.visual +============================= + +量桨中的可视化的功能实现。 + +.. py:function:: plot_state_in_bloch_sphere(state, show_arrow: bool=False, save_gif=False, filename=None, view_angle=None, view_dist=None, set_color=None) + + 将输入的量子态展示在 Bloch 球面上。 + + :param state: 输入的量子态列表，可以支持态矢量和密度矩阵。 + :type state: List[paddle_quantum.State] + :param show_arrow: 是否展示向量的箭头，默认为 ``False``。 + :type show_arrow: bool, optional + :param save_gif: 是否存储 gif 动图，默认为 ``False``。 + :type save_gif: bool, optional + :param filename: 存储的 gif 动图的名字。 + :type filename: str, optional + :param view_angle: 视图的角度，第一个元素为关于 xy 平面的夹角 [0-360]，第二个元素为关于 xz 平面的夹角 [0-360], 默认为 ``(30, 45)``。 + :type view_angle: Union[tuple, list], optional + :param view_dist: 视图的距离，默认为 ``7``。 + :type view_dist: int, optional + :param set_color: 若要设置指定的颜色，请查阅 ``cmap`` 表。默认为 ``"red to black gradient"``。 + :type set_color: str, optional + +.. py:function:: plot_multi_qubits_state_in_bloch_sphere(state, which_qubits=None, show_arrow=False, save_gif=False, save_pic=True, filename=None, view_angle=None, view_dist=None, set_color='#0000FF') + + 将输入的多量子比特的量子态展示在 Bloch 球面上。 + + :param state: 输入的量子态，可以支持态矢量和密度矩阵。 + :type state: paddle_quantum.State + :param which_qubits: 要展示的量子比特，默认为全展示。 + :type which_qubits: list, optional + :param show_arrow: 是否展示向量的箭头，默认为 ``False``。 + :type show_arrow: bool, optional + :param save_gif: 是否存储 gif 动图，默认为 ``False``。 + :type save_gif: bool, optional + :param save_pic: 是否存储静态图片，默认为 ``True``。 + :type save_pic: bool, optional + :param filename: 存储的图片的名字。 + :type filename: str, optional + :param view_angle: 视图的角度，第一个元素为关于 xy 平面的夹角 [0-360]，第二个元素为关于 xz 平面的夹角 [0-360], 默认为 ``(30, 45)``。 + :type view_angle: Union[tuple, list], optional + :param view_dist: 视图的距离，默认为 ``7``。 + :type view_dist: int, optional + :param set_color: 若要设置指定的颜色，请查阅 ``cmap`` 表。默认为 ``"blue"``。 + :type set_color: str, optional + +.. py:function:: plot_rotation_in_bloch_sphere(init_state, rotating_angle, show_arrow=False, save_gif=False, filename=None, view_angle=None, view_dist=None, color_scheme=None) + + 在 Bloch 球面上刻画从初始量子态开始的旋转轨迹。 + + :param init_state: 输入的初始量子态，可以支持态矢量和密度矩阵。 + :type init_state: paddle_quantum.State + :param rotating_angle: 旋转角度 ``[theta, phi, lam]``。 + :type rotating_angle: List[paddle.Tensor] + :param show_arrow: 是否展示向量的箭头，默认为 ``False``。 + :type show_arrow: bool, optional + :param save_gif: 是否存储 gif 动图，默认为 ``False``。 + :type save_gif: bool, optional + :param filename: 存储的 gif 动图的名字。 + :type filename: str, optional + :param view_angle: 视图的角度，第一个元素为关于 xy 平面的夹角 [0-360]，第二个元素为关于 xz 平面的夹角 [0-360], 默认为 ``(30, 45)``。 + :type view_angle: Union[list, tuple], optional + :param view_dist: 视图的距离，默认为 ``7``。 + :type view_dist: int, optional + :param color_scheme: 分别是初始颜色，轨迹颜色，结束颜色。若要设置指定的颜色，请查阅 ``cmap`` 表。默认为 ``"red"``。 + :type color_scheme: List[str], optional + +.. py:function:: plot_density_matrix_graph(density_matrix, size=0.3) + + 密度矩阵可视化工具。 + + :param density_matrix: 多量子比特的量子态的状态向量或者密度矩阵,要求量子数大于 1。 + :type density_matrix: paddle_quantum.State + :param size: 条宽度，在 0 到 1 之间，默认为 ``0.3``。 + :type size: float, optional \ No newline at end of file diff --git a/docs_zh_CN/source/tutorial.rst b/docs_zh_CN/source/tutorial.rst new file mode 100644 index 0000000..6113f30 --- /dev/null +++ b/docs_zh_CN/source/tutorial.rst @@ -0,0 +1,44 @@ +入门与教程 +======================= + +我们准备了入门手册和案例教程，来帮助用户快速学会如何使用量桨（Paddle Quantum）。 + +.. _header-n33: + +入门手册 +-------- + +我们提供了一份 `Paddle Quantum 入门手册 `__\ 来方便用户快速上手 +Paddle Quantum。目前支持网页阅览和\ `下载运行 Jupyter Notebook `__ +两种方式。内容上，该手册包括以下几个方面： + +- 量子计算和量子神经网络的基础知识介绍 +- 变分量子算法的基本思想与算法框架 +- 量桨（Paddle Quantum）的使用介绍 +- 飞桨（PaddlePaddle）优化器的使用教程 +- 量桨中量子化学模块的使用介绍 +- 如何基于 GPU 训练量子神经网络 + +案例教程 +-------- + +我们提供了涵盖量子模拟、机器学习、组合优化、本地操作与经典通讯（local operations and classical communication, LOCC）、量子神经网络等多个领域的案例供大家学习。与\ `入门手册 `__\ 类似，每个教程目前支持 +\ `网页阅览 `__\ 和\ `下载运行 Jupyter Notebook `__\ 两种方式。我们推荐用户下载 Notebook +后，本地运行进行实践。 + +- `量子模拟 `__ +- `机器学习 `__ +- `组合优化 `__ +- `LOCCNet `__ +- `量子神经网络研究 `__ + +随着 LOCCNet 模组的推出，量桨现已支持分布式量子信息处理任务的高效模拟和开发。感兴趣的读者请参见 `教程 `__。 +Paddle Quantum 也支持在 GPU +上进行量子机器学习的训练，具体的方法请参考案例：`在 GPU 上使用 Paddle +Quantum `__。 +此外，量桨可以基于噪声模块进行含噪算法的开发以及研究，详情请见 `噪声模块教程 `__。 + +在最近的更新中，量桨还加入了基于测量的量子计算（measurement-based +quantum computation, MBQC）模块。与传统的量子电路模型不同，MBQC +具有其独特的运行方式，感兴趣的读者请参见我们提供的\ `多篇教程 `__\ 以了解量桨 +MBQC 模块的使用方法和应用案例。 diff --git a/introduction/PaddleQuantum_Functions_CN.ipynb b/introduction/PaddleQuantum_Functions_CN.ipynb deleted file mode 100644 index 8b99d36..0000000 --- a/introduction/PaddleQuantum_Functions_CN.ipynb +++ /dev/null @@ -1,829 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 量桨中的常用函数\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 概览" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "此处我们列举量桨中常用的函数，对初学者来说已可以处理大多数问题。\n", - "\n", - "其他量桨函数以及具体细节可见 [API](https://qml.baidu.com/api/introduction.html).\n", - "\n", - "在本节末尾，给出制备量子纯态的量桨实现代码，介绍量桨实现量子神经网络算法的基本框架。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. 加入模块" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# 1.1 Numpy, Paddle\n", - "import numpy as np\n", - "import paddle\n", - "\n", - "# 1.2 量子电路\n", - "from paddle_quantum.circuit import UAnsatz \n", - "\n", - "# 1.3 量子态 —— np.ndarray 形式\n", - "from paddle_quantum.state import vec, vec_random # 向量\n", - "from paddle_quantum.state import density_op, density_op_random, completely_mixed_computational # 矩阵\n", - "\n", - "# 1.4 矩阵 —— np.ndarray 形式\n", - "from scipy.stats import unitary_group # 随机 U 矩阵\n", - "from paddle_quantum.utils import pauli_str_to_matrix # n 量子比特泡利矩阵\n", - "\n", - "# 1.5 矩阵运算 —— paddle.Tensor 形式\n", - "from paddle import matmul, trace # 计算內积与迹\n", - "from paddle_quantum.utils import dagger # 对 paddle.Tensor 计算复共轭 (注：对 numpy.ndarray 通过“.conj().T”)\n", - "\n", - "# 1.6 画图\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2. 常用参数" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# 2.1 用于构造量子电路\n", - "\n", - "N = 3 # 量子电路量子比特数\n", - "DEPTH = 2 # 量子电路深度 (层数)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# 2.2 迭代优化参数\n", - "\n", - "ITR = 200 # 迭代次数 \n", - "LR = 0.2 # 学习速率 \n", - "SEED = 1 # 随机种子 \n", - "paddle.seed(SEED) # paddle种子\n", - "np.random.seed(SEED) # numpy种子" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Numpy 矩阵相关" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# 3.1 随机幺正矩阵\n", - "V = unitary_group.rvs(2) # 随机 2*2 V" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# 3.2 对角矩阵\n", - "D = np.diag([0.2, 0.8])" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# 3.3 复共轭\n", - "V_dagger = V.conj().T" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# 3.4 矩阵乘法：@\n", - "H = (V @ D @ V_dagger)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.9999999999999998-8.239936510889834e-18j)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# 3.5 迹\n", - "H.trace()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.2, 0.8])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# 3.6 特征值\n", - "np.linalg.eigh(H)[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "# 3.7 张量积： A \\otimes B\n", - "A = np.eye(2)\n", - "B = H\n", - "T = np.kron(A, B)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- 注：在量桨中，可以通过字符串形式构建 $n$ 量子比特泡利矩阵。" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# 例: 0.4*I⊗Z+0.4*Z⊗I+0.2*X⊗X\n", - "# 文字形式: 0.4*kron(I, Z) + 0.4*kron(Z, I) + 0.2*kron(X, X)\n", - "H_info = [[0.4, 'z0'], [0.4, 'z1'], [0.2, 'x0,x1']]\n", - "H_matrix = pauli_str_to_matrix(H_info, 3) # 3 量子比特泡利矩阵" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 4. 量子态相关" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "# 4.1 得到纯态 (np.ndarray 形式的行向量)\n", - "\n", - "initial_state_pure1 = vec(0, N) # 得到 |00…0>, 2**N 维行向量\n", - "initial_state_pure2 = vec_random(N) # 得到随机纯态，行向量" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "# 4.2 得到混态(np.ndarray 形式）\n", - "\n", - "initial_state_mixed1 = density_op(N) # 得到 |00…0><00…0|\n", - "initial_state_mixed2 = density_op_random(N, real_or_complex=2, rank=4) # 得到随机密度矩阵，可选择为实数或复数，可选择秩\n", - "initial_state_mixed3 = completely_mixed_computational(N) # 得到最大混态 " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 5. 量子电路相关" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "# 5.1 创建 N 量子比特电路\n", - "cir = UAnsatz(N)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# 5.2 添加量子门 —— 具体见第7节\n", - "# 例：添加CNOT门到前两个量子比特\n", - "cir.cnot([0, 1])" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "# 5.3 输出量子态\n", - "# 输出向量形式量子态（paddle.Tensor）。\n", - "# 注：此处输出态shape并不是向量，可通过paddle.reshape(final_state, [2**N, 1])转化为列向量 —— 在后续版本中将进一步优化。\n", - "\n", - "# 初始态为 |00...0>\n", - "final_state = cir.run_state_vector()\n", - "# 初始态非 |00...0>\n", - "initial_state_pure = paddle.to_tensor(initial_state_pure2)\n", - "final_state_pure = cir.run_state_vector(initial_state_pure)\n", - "# 化为 numpy 列向量形式\n", - "final_state_pure_np = cir.run_state_vector().reshape([2**N, 1]).numpy()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "# 初始态为 |00…0><00…0|\n", - "cir.run_density_matrix()\n", - "# 初始态非 |00...0><00…0|\n", - "initial_state_mixed = paddle.to_tensor(initial_state_mixed2)\n", - "final_state_mixed = cir.run_density_matrix(initial_state_mixed)\n", - "# 改变为 numpy 矩阵形式\n", - "final_state_mixed_np = cir.run_density_matrix().numpy()" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1., 0., 0., 0., 0., 0., 0., 0.],\n", - " [0., 1., 0., 0., 0., 0., 0., 0.],\n", - " [0., 0., 1., 0., 0., 0., 0., 0.],\n", - " [0., 0., 0., 1., 0., 0., 0., 0.],\n", - " [0., 0., 0., 0., 0., 0., 1., 0.],\n", - " [0., 0., 0., 0., 0., 0., 0., 1.],\n", - " [0., 0., 0., 0., 1., 0., 0., 0.],\n", - " [0., 0., 0., 0., 0., 1., 0., 0.]])" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# 5.4 量子电路对应幺正矩阵 (paddle.Tensor)\n", - "cir.U\n", - "# 改变为 numpy 矩阵形式\n", - "cir.U.numpy()\n", - "# 仅保留实数部分\n", - "cir.U.real()\n", - "cir.U.numpy().real" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--*--\n", - " | \n", - "--x--\n", - " \n", - "-----\n", - " \n" - ] - } - ], - "source": [ - "# 5.5 打印量子电路\n", - "print(cir)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 5.6 测量结果\n", - "res = cir.measure(shots=0, plot=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 6. 量子门旋转角参数\n", - " 注： \n", - "- 单量子比特门总可以由绕轴旋转表示，由旋转轴与旋转角度决定。\n", - "- 量桨中旋转轴通常设置为 $x,y,z$-轴。\n", - "- 旋转角度是量子神经网络的可变参数，**需要设置为 paddle.Tensor 形式**." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "# 6.1 单个旋转角度\n", - "\n", - "phi, theta, omega = 2 * np.pi * np.random.uniform(size=3) # 随机旋转角度，服从均匀分布\n", - "# 变为 paddle.Tensor 形式\n", - "phi = paddle.to_tensor(phi, dtype='float64')" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "# 6.2 数组形式旋转角度\n", - "# 一维数组\n", - "\n", - "theta = np.array([np.pi, 2 ,3, 5]) # 4个角度均不相同\n", - "theta = np.full([4], np.pi) # 4个角度均等于pi\n", - "# 变为 paddle.Tensor 形式\n", - "phi = paddle.to_tensor(theta)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "# 高维数组\n", - "\n", - "theta = np.random.randn(DEPTH, N, 3) # 一个三维 np.ndarray" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "对于一种常用的量子神经网络: ‘cir.complex_entangled_layer(theta, DEPTH)’，具体见[这里](https://qml.baidu.com/quick-start/quantum-neural-network.html), theta 需要为(DEPTH, N, OTHER=3)形式。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 7. 添加量子门操作" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "# 7.1 添加单比特量子门 \n", - "# 注意旋转角度需要 paddle.Tensor 形式。\n", - "# 下标对于旋转轴，第一个参数为旋转角度，第二个参数为作用于第几个量子比特\n", - "\n", - "cir.rz(theta[0], 0)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "# 7.2 添加双量子比特门\n", - "\n", - "cir.cnot([0, 1])" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "# 7.3 一些常用的量子门\n", - "\n", - "# 对每一个量子比特添加 Hadamard 门\n", - "cir.superposition_layer()\n", - "# 对每一个量子比特添加 Ry(pi/4) 门\n", - "cir.weak_superposition_layer()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "广义旋转门，基于欧拉角表示，以及对于量子电路具体见[这里](https://qml.baidu.com/quick-start/quantum-neural-network.html)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 8. 变分量子算法基本框架（1）—— 构建量子电路（函数形式）\n", - "- 步骤1：构建 N 量子比特线路\n", - "- 步骤2：对每一层添加量子门" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "def circuit(N, DEPTH, theta):\n", - " \"\"\"\n", - " 输入数据:\n", - " N, 量子比特数\n", - " DEPTH, 电路层数\n", - " theta, [N, DEPTH, 2], 3维数组，数据类型：paddle.Tensor\n", - " 返回数据:\n", - " cir, 最终量子电路\n", - " \"\"\"\n", - " # 步骤1：构建N量子比特线路\n", - " cir = UAnsatz(N)\n", - " # 步骤1：对每一层添加量子门\n", - " for dep in range(DEPTH):\n", - " for n in range(N):\n", - " cir.rx(theta[n][dep][0], n) # 对第 n 个量子比特添加 Rx 门\n", - " cir.rz(theta[n][dep][1], n) # 对第 n 个量子比特添加 Rz 门\n", - " for n in range(N - 1):\n", - " cir.cnot([n, n + 1]) # 对每一对临近量子比特添加CNOT门\n", - "\n", - " return cir" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--Rx(0.069)----Rz(0.473)----*----Rx(-0.65)----Rz(-0.77)-----------------*-------\n", - " | | \n", - "--Rx(-0.77)----Rz(0.623)----x--------*--------Rx(0.428)----Rz(0.074)----x----*--\n", - " | | \n", - "--Rx(-0.45)----Rz(0.604)-------------x--------Rx(2.385)----Rz(-0.12)---------x--\n", - " \n" - ] - } - ], - "source": [ - "# 以下为一个例子，包含3量子比特，两层，可调参数随机产生：\n", - "theta = paddle.to_tensor(np.random.randn(N, DEPTH, 2))\n", - "cir = circuit(N, DEPTH, theta)\n", - "print(cir)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 9. 变分量子算法基本框架（2）—— 设置并计算损失函数\n", - "- 此处我们使用 “-fidelity” 作为损失函数。当输出态为我们想要的量子态时，损失函数达到最小。\n", - "- 注：量子神经网络优化在 Python 中总可以通过迭代器实现，要注意 theta 需要是 paddle.Tensor 形式" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "class StatePrepNet(paddle.nn.Layer):\n", - " # 步骤1：给出量子神经网络初始值: def __init__(…)\n", - " def __init__(self, N, DEPTH, psi, dtype='float64'):\n", - " # N, DEPTH: 电路参数\n", - " # psi: 目标量子态，数据类型：numpy行向量\n", - " super(StatePrepNet, self).__init__()\n", - " self.N = N\n", - " self.DEPTH = DEPTH\n", - " # 量子电路可调参数初始化随机产生\n", - " self.theta = self.create_parameter(shape=[self.N, self.DEPTH, 2],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0., high=2 * np.pi), \n", - " dtype=dtype, is_bias=False)\n", - " # 目标量子态，用于计算损失函数(需要 paddle.Tensor 类型)\n", - " self.psi = paddle.to_tensor(psi)\n", - " # 步骤2：计算损失函数L = - \n", - " # 注：由于需要最小化损失函数，取“-fidelity”\n", - " def forward(self):\n", - " # 构建量子电路，参数随迭代改变\n", - " cir = circuit(self.N, self.DEPTH, self.theta)\n", - " # 得到此量子电路输出量子态\n", - " psi_out = cir.run_state_vector()\n", - " psi_out = paddle.reshape(psi_out, [2 ** self.N, 1]) # reshape to ket\n", - " # 计算损失函数: L = - \n", - " inner = matmul(self.psi, psi_out)\n", - " loss = - paddle.real(matmul(inner, dagger(inner)))[0] # 改变shape为tensor([1])\n", - " \n", - " return loss, cir" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 10. 变分量子算法基本框架（3）—— 通过优化器优化参数\n", - "- 此处我们对制备3量子比特 $|01\\rangle\\otimes|+\\rangle$ 为例，使用的量子电路有上述 “8. 量子神经网络算法基本框架” 部分给出。\n", - "- 通常我们选 Adam 为优化器。\n", - "- 首先我们给出一些训练用的参数。" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "N = 3 # 目标量子比特数\n", - "DEPTH = 2 # 量子电路层数\n", - "ITR = 115 # 学习迭代次数\n", - "LR = 0.2 # 学习速率" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "# 目标量子态，取 numpy 行向量形式\n", - "psi_target = np.kron(np.kron(np.array([[1,0]]), np.array([[0,1]])), np.array([[1/np.sqrt(2), 1/np.sqrt(2)]])) # <01+|" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "# 10.1 记录迭代中间过程\n", - "loss_list = []\n", - "parameter_list = []" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "# 10.2 构造迭代器\n", - "# (N=3, DEPTH=2, ITR=110, LR=0.2)\n", - "myLayer = StatePrepNet(N, DEPTH, psi_target)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [], - "source": [ - "# 10.3 选择优化器\n", - "# 通常使用 Adam。\n", - "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = myLayer.parameters()) " - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 0 loss: -0.0176\n", - "iter: 10 loss: -0.8356\n", - "iter: 20 loss: -0.9503\n", - "iter: 30 loss: -0.9837\n", - "iter: 40 loss: -0.9971\n", - "iter: 50 loss: -0.9974\n", - "iter: 60 loss: -0.9995\n", - "iter: 70 loss: -0.9999\n", - "iter: 80 loss: -0.9999\n", - "iter: 90 loss: -1.0000\n", - "iter: 100 loss: -1.0000\n", - "iter: 110 loss: -1.0000\n" - ] - } - ], - "source": [ - "# 10.4 迭代优化\n", - "for itr in range(ITR):\n", - " # 计算损失函数\n", - " loss = myLayer()[0]\n", - " # 通过梯度下降算法优化\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - " # 记录学习曲线\n", - " loss_list.append(loss.numpy()[0])\n", - " parameter_list.append(myLayer.parameters()[0].numpy())\n", - " if itr % 10 == 0:\n", - " print('iter:', itr, ' loss: %.4f' % loss.numpy())" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum of the loss function: -0.9999873168488457\n", - "Parameters after optimizationL theta:\n", - " [[[-0.00816927 7.41571003]\n", - " [ 6.28197865 0.29031951]]\n", - "\n", - " [[ 3.14801248 6.1562368 ]\n", - " [ 6.2890315 4.08082862]]\n", - "\n", - " [[ 4.57489065 1.58064113]\n", - " [ 4.78145659 3.28051687]]]\n", - "--Rx(-0.00)----Rz(7.416)----*----Rx(6.282)----Rz(0.290)-----------------*-------\n", - " | | \n", - "--Rx(3.148)----Rz(6.156)----x--------*--------Rx(6.289)----Rz(4.081)----x----*--\n", - " | | \n", - "--Rx(4.575)----Rz(1.581)-------------x--------Rx(4.781)----Rz(3.281)---------x--\n", - " \n", - "state_final:\n", - " [-0.0001236 +1.65203739e-04j -0.00051346-3.22614883e-04j\n", - " 0.09637039-7.00598643e-01j 0.09558872-7.00513830e-01j\n", - " 0.00038931+1.78566178e-04j 0.0003892 +1.76713800e-04j\n", - " 0.00209719+1.98540264e-03j 0.0025603 +1.33735551e-03j]\n" - ] - } - ], - "source": [ - "# 10.5 输出结果\n", - "\n", - "# 输出最终损失函数值\n", - "print('The minimum of the loss function: ', loss_list[-1])\n", - "# 输出最终量子电路参数\n", - "theta_final = parameter_list[-1] # 得到self.theta\n", - "print(\"Parameters after optimizationL theta:\\n\", theta_final)\n", - "# 绘制最终电路与输出量子态\n", - "# 输入量子电路参数需要转化为 paddle.Tensor 类型\n", - "theta_final = paddle.to_tensor(theta_final)\n", - "# 绘制电路\n", - "cir_final = circuit(N, DEPTH, theta_final)\n", - "print(cir_final)\n", - "# 最终得到量子态\n", - "#state_final = cir_final.run_density_matrix()\n", - "state_final = cir_final.run_state_vector()\n", - "print(\"state_final:\\n\", state_final.numpy())" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEGCAYAAAB7DNKzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAlFklEQVR4nO3de3hU9b3v8feXJBiBcBWTGJAIaBVBIgbwUhUrWqtu0Wq9HFvBFmm3Z7d216rsYx+LnrabVnu628faHrzi1qIeWovba5W6C1qqBMUb1IJ4C9cAXriIhPA9f/zWQAyTYZLMZDEzn9fz5JnbmjXfycB88rus3zJ3R0REpDVd4i5ARET2bQoKERFJSUEhIiIpKShERCQlBYWIiKRUHHcBmXbAAQd4dXV13GWIiOSURYsWrXf3/skey7ugqK6upq6uLu4yRERyipm929pj6noSEZGUFBQiIpJSrEFhZmeY2ZtmttzMpiZ5fD8zezB6/AUzq46hTBGRghbbGIWZFQG/Bk4D6oGFZvaIuy9pttk3gA/cfaiZXQz8FLio86uVQtfY2Eh9fT3btm2LuxSRDiktLWXAgAGUlJSk/Zw4B7PHAMvdfQWAmT0ATACaB8UEYFp0fTZwq5mZa4Eq6WT19fWUlZVRXV2NmcVdjki7uDsbNmygvr6eQw45JO3nxdn1VAW83+x2fXRf0m3cfQfwEdCv5Y7MbIqZ1ZlZXUNDQ5bKlUK2bds2+vXrp5CQnGZm9OvXr80t47wYzHb3Ge5e6+61/fsnnQYs0mEKCckH7fl3HGdQrAQGNrs9ILov6TZmVgz0AjZkpZpNm+CBB2DFiqzsXkQkV8UZFAuBQ83sEDPrClwMPNJim0eAidH1C4A/Z218oksXmDULnn8+K7sX6agePXpkZb8NDQ2MHTuWo48+mvnz52dsv/fccw+rVq3adXvy5MksWbIkxTPap7q6mvXr17fpOb/97W+59957M/L6zd/XT37yk4zsM6Gzfod75e6x/QBnAv8A3gKuj+67CTgnul4K/D9gOfAiMHhv+zzmmGO83a65xv27323/8yVvLVmyJO4SvHv37lnZ76xZs/wb3/hGxvd78skn+8KFCzO+35YGDRrkDQ0NaW/f2NiYtVra8xnt2LGj1cey9TtM9u8ZqPNWvldjHaNw98fd/TB3H+LuP47uu8HdH4mub3P3r7j7UHcf49EMqaw55hhYvhw++iirLyPSEe7ONddcw/DhwxkxYgQPPvggAKtXr+akk06ipqaG4cOHM3/+fJqampg0adKubX/xi198Zl+LFy/m2muvZc6cOdTU1PDJJ598puUye/ZsJk2aBMCkSZP4zne+w/HHH8/gwYOZPXv2ru1++tOfMmLECEaOHMnUqVOZPXs2dXV1XHrppbv2O27cuF3L68yaNYsRI0YwfPhwrrvuul376dGjB9dffz0jR47k2GOPZe3atXu8/w0bNnD66adz5JFHMnny5MQfnbzzzjsMHz5813a33HIL06ZNA2DcuHF897vfpba2ll/+8pdMmzaNW265Zddj1113HWPGjOGwww7b1araunUrF154IcOGDeO8885j7NixSZcHSryvqVOn8sknn1BTU8Oll14KwH333ceYMWOoqanhm9/8Jk1NTbve59VXX83IkSNZsGABN910E6NHj2b48OFMmTIFd8/q77Ct8m6tpw4ZNQruuw9efhnGjYu7GtlX3X575seyBg+GK65Ia9M//OEPLF68mFdeeYX169czevRoTjrpJH73u9/xxS9+keuvv56mpia2bt3K4sWLWblyJa+//joAH3744Wf2VVNTw0033URdXR233nrrXl979erVPPfcc/z973/nnHPO4YILLuCJJ55gzpw5vPDCC3Tr1o2NGzfSt29fbr31Vm655RZqa2s/s49Vq1Zx3XXXsWjRIvr06cPpp5/OH//4R84991y2bNnCsccey49//GOuvfZabr/9dn7wgx985vk33ngjn//857nhhht47LHHuPPOO9P6vW3fvn3Xl2wiQBJ27NjBiy++yOOPP86NN97IM888w2233UafPn1YsmQJr7/+OjU1NSn3P336dG699VYWL14MwNKlS3nwwQd5/vnnKSkp4corr+T+++/nsssuY8uWLYwdO5af//znAAwbNowbbrgBgK997Ws8+uijXHDBBVn7HbZVXsx6ypihQ6FnT3jppbgrEWnVc889xyWXXEJRURHl5eWcfPLJLFy4kNGjR3P33Xczbdo0XnvtNcrKyhg8eDArVqzg29/+Nk8++SQ9e/bs0Gufe+65dOnShWHDhu36S/WZZ57h8ssvp1u3bgD07ds35T4WLlzIuHHj6N+/P8XFxVx66aXMmzcPgK5du3L22WcDcMwxx/DOO+/s8fx58+bx1a9+FYCzzjqLPn36pFX7RRe1fqzul7/85T1e87nnnuPiiy8GYPjw4Rx11FFpvU7C3LlzWbRoEaNHj6ampoa5c+eyIvoDo6ioiPPPP3/Xts8++yxjx45lxIgR/PnPf+aNN95Iue+O/g7bSi2K5szg6KNDULiH2yItpfmXf2c76aSTmDdvHo899hiTJk3ie9/7HpdddhmvvPIKTz31FL/97W956KGHuOuuu1Lup/n0yZbz7ffbb79d1xNdPplUUlKy6/WLiorYsWNH2s8tLi5m586du263rL179+6tPjfxvtr6mqm4OxMnTuTf//3f93istLSUoqKiXXVeeeWV1NXVMXDgQKZNm9ahFQA68jtsjVoULY0aFcYo3n477kpEkjrxxBN58MEHaWpqoqGhgXnz5jFmzBjeffddysvLueKKK5g8eTIvvfQS69evZ+fOnZx//vn86Ec/4qU0Wsvl5eUsXbqUnTt38vDDD+91+9NOO427776brVu3ArBx40YAysrK2LRp0x7bjxkzhr/85S+sX7+epqYmZs2axcknn5z2+090swE88cQTfPDBB7vqXrduHRs2bODTTz/l0UcfTXufyZxwwgk89NBDACxZsoTXXnttr88pKSmhsbERgFNPPZXZs2ezbt06IPxe3n13z5W8E6FwwAEHsHnz5s+M/WTrd9hWalG0dPTR4XLRotBvLLKPOe+881iwYAEjR47EzPjZz35GRUUFM2fO5Oabb6akpIQePXpw7733snLlSi6//PJdf2kn++u2penTp3P22WfTv39/amtr2bx5c8rtzzjjDBYvXkxtbS1du3blzDPP5Cc/+QmTJk3iW9/6Fvvvvz8LFizYtX1lZSXTp0/nlFNOwd0566yzmDBhQtrv/4c//CGXXHIJRx55JMcffzwHH3wwEL6kb7jhBsaMGUNVVRWHH3542vtM5sorr2TixIkMGzaMww8/nCOPPJJevXqlfM6UKVM46qijGDVqFPfffz8/+tGPOP3009m5cyclJSX8+te/ZtCgQZ95Tu/evbniiisYPnw4FRUVjB49etdj2fodtpVlo/kYp9raWu/wiYuuugq6dYM0/lNJYVi6dClHHHFE3GVIJ2pqaqKxsZHS0lLeeustxo8fz5tvvknXrl3jLq3Dkv17NrNF7l6bbHu1KJIZNQoefhi2bYPS0rirEZEYbN26lVNOOYXGxkbcndtuuy0vQqI9FBTJHH44NDXBO++E6yJScMrKynRa5YgGs5Oprg6XSQaepHDlWzetFKb2/DtWUCRz4IGhy0lBIZHS0lI2bNigsJCc5tH5KErb2KWurqdkzGDQoND1JAIMGDCA+vp6dL4TyXWJM9y1hYKiNYMGwYIFOvBOgDD1si1nBBPJJ+p6as2gQeEcFS3WxhERKTQKitZoQFtEBFBQtC5x9KSCQkQKnIKiNb16hR8NaItIgVNQpFJdrRaFiBQ8BUUqgwbBe++FmU8iIgVKQZFKdTV8+imsWRN3JSIisVFQpKIBbRERBUVK0Tr3GtAWkUKmoEiltBQqKtSiEJGCpqDYm4EDob4+7ipERGKjoNibigpYu1Yzn0SkYCko9qa8HD75BPZy3mARkXyloNib8vJwqSmyIlKgFBR7kwiKtWvjrUNEJCYKir1Ri0JECpyCYm+6dYOyMrUoRKRgKSjSkZj5JCJSgBQU6SgvV1CISMGKJSjMrK+ZPW1my6LLPkm2qTGzBWb2hpm9amYXxVErEIJi3TrYuTO2EkRE4hJXi2IqMNfdDwXmRrdb2gpc5u5HAmcA/2FmvTuvxGbKy2HHDti4MZaXFxGJU1xBMQGYGV2fCZzbcgN3/4e7L4uurwLWAf07q8DPqKgIl5r5JCIFKK6gKHf31dH1NUB5qo3NbAzQFXirlcenmFmdmdU1NDRktlLQsRQiUtCKs7VjM3sGqEjy0PXNb7i7m1mrCymZWSXwn8BEd086SODuM4AZALW1tZlflKl/fzBTUIhIQcpaULj7+NYeM7O1Zlbp7qujIFjXynY9gceA6939b1kqde9KSqBfP3U9iUhBiqvr6RFgYnR9IjCn5QZm1hV4GLjX3Wd3Ym3JaYqsiBSouIJiOnCamS0Dxke3MbNaM7sj2uZC4CRgkpktjn5qYqkWdNCdiBSsrHU9peLuG4BTk9xfB0yOrt8H3NfJpbWuvDxMj21sDF1RIiIFQkdmp6u8PJy8aF3S4RQRkbyloEiXVpEVkQKloEhX4qA7jVOISIFRUKSrb98wNqEWhYgUGAVFusw0RVZECpKCoi0qKtSiEJGCo6Boi4oKWL06zH4SESkQCoq2qKiATz6BTZvirkREpNMoKNpCy42LSAFSULSFgkJECpCCoi100J2IFCAFRVuUlkKfPgoKESkoCoq20hRZESkwCoq2SkyRFREpEAqKtqqogA0bwnLjIiIFQEHRVhUVWm5cRAqKgqKtNEVWRAqMgqKtFBQiUmAUFG3Vpw907aqgEJGCoaBoq8Ry4woKESkQCor20LEUIlJAFBTtkQgKLTcuIgVAQdEelZWwbRt88EHclYiIZJ2Coj2qq8Pl22/HWoaISGdQULTH4MHh8q234q1DRKQTKCjao3v30P2koBCRAqCgaK8hQ2D58rirEBHJOgVFew0ZEtZ70vmzRSTPKSjaa+jQcLliRbx1iIhkmYKivYYMCZfqfhKRPKegaK+yMjjwQA1oi0jeiyUozKyvmT1tZsuiyz4ptu1pZvVmdmtn1piWIUMUFCKS9+JqUUwF5rr7ocDc6HZr/jcwr1OqaqshQ2DVKti6Ne5KRESyJq6gmADMjK7PBM5NtpGZHQOUA3/qnLLaKDFOoQFtEcljcQVFubuvjq6vIYTBZ5hZF+DnwPf3tjMzm2JmdWZW19DQkNlKU0nMfFL3k4jkseJs7djMngEqkjx0ffMb7u5mlmwZ1iuBx9293sxSvpa7zwBmANTW1nbekq69e0PfvgoKEclrWQsKdx/f2mNmttbMKt19tZlVAuuSbHYccKKZXQn0ALqa2WZ3TzWe0fl0hLaI5Lm4up4eASZG1ycCc1pu4O6XuvvB7l5N6H66d58LCQhBUV8Pn34adyUiIlkRV1BMB04zs2XA+Og2ZlZrZnfEVFP7DB0aTmD0zjtxVyIikhVZ63pKxd03AKcmub8OmJzk/nuAe7JeWHskZj699RZ87nPx1iIikgU6Mruj+vWDnj01TiEieUtB0VFm4URGmvkkInlKQZEJQ4fCe+/Bjh1xVyIiknEKikwYMiSExHvvxV2JiEjGKSgyofmAtohInlFQZEJFBXTrpgFtEclLCopM0IC2iOQxBUWmDBkCb78NO3fGXYmISEYpKDJlyBDYvh1Wroy7EhGRjFJQZIrOoS0ieSqtoDCzq6JTkpqZ3WlmL5nZ6dkuLqdUVUFxMbz/ftyViIhkVLotiq+7+8fA6UAf4GtEC/lJpKgozH5S15OI5Jl0gyJx5qAzgf909zea3ScJVVUKChHJO+kGxSIz+xMhKJ4yszJA03taqqqCVas080lE8kq6y4x/A6gBVrj7VjPrC1yetapyVVUVNDbC+vVw4IFxVyMikhHptiiOA9509w/N7KvAD4CPsldWjjrooHBZXx9vHSIiGZRuUPwG2GpmI4GrgbeAe7NWVa4aMCBcapxCRPJIukGxw90dmADc6u6/BsqyV1aO6tUrrPmkoBCRPJLuGMUmM/s3wrTYE82sC1CSvbJylJlmPolI3km3RXER8CnheIo1wADg5qxVlcsUFCKSZ9IKiigc7gd6mdnZwDZ31xhFMlVV0NAQ1n0SEckD6S7hcSHwIvAV4ELgBTO7IJuF5ayqqnC5alW8dYiIZEi6YxTXA6PdfR2AmfUHngFmZ6uwnJUIipUrobo61lJERDIh3TGKLomQiGxow3MLS+JYCo1TiEieSLdF8aSZPQXMim5fBDyenZJyXGkp9OunoBCRvJFWULj7NWZ2PnBCdNcMd384e2XlOM18EpE8km6LAnf/PfD7LNaSP6qqYP58cA/HVoiI5LCUQWFmmwBP9hDg7t4zK1Xluqoq2LwZPv44HK0tIpLDUgaFu2uZjvZIDGivWaOgEJGcp5lL2VBZGS51LIWI5AEFRTaUl4exidWr465ERKTDYgkKM+trZk+b2bLosk8r2x1sZn8ys6VmtsTMqju51PYpKYH+/RUUIpIX4mpRTAXmuvuhwNzodjL3Aje7+xHAGGBdK9vteyorFRQikhfiCooJwMzo+kzg3JYbmNkwoNjdnwZw983uvrXTKuyoykqNUYhIXogrKMrdPfHn9hqgPMk2hwEfmtkfzOxlM7vZzIqS7czMpphZnZnVNTQ0ZKvmtjnoINi0CbZsibsSEZEOyVpQmNkzZvZ6kp8JzbeLzpyX7FiNYuBE4PvAaGAwMCnZa7n7DHevdffa/v37Z/aNtFdi5pO6n0Qkx6V9ZHZbufv41h4zs7VmVunuq82skuRjD/XAYndfET3nj8CxwJ3ZqDfjmgfF0KHx1iIi0gFxdT09AkyMrk8E5iTZZiHQO1rSHOALwJJOqC0zKirCpVoUIpLj4gqK6cBpZrYMGB/dxsxqzewOAHdvInQ7zTWz1wjLhtweU71tt99+0LevBrRFJOdlrespFXffAJya5P46YHKz208DR3ViaZl10EFqUYhIztOR2dmkYylEJA8oKLKpshI++AC2bYu7EhGRdlNQZJOmyIpIHlBQZFNiuXEFhYjkMAVFNmmKrIjkAQVFNnXrFk5cpKAQkRymoMg2LQ4oIjlOQZFtVVWwcmXcVYiItJuCItsOOgg2btQUWRHJWQqKbBswIFyqVSEiOUpBkW1VVeFSQSEiOUpBkW2VlWAG9fVxVyIi0i4Kimzr2hUOPFAtChHJWQqKzqCZTyKSwxQUnSERFJ7sjK8iIvs2BUVnGDAgTI/duDHuSkRE2kxB0Rk080lEcpiCojMoKEQkhykoOkO/fuEc2goKEclBCorOYBZaFTqWQkRykIKis2iKrIjkKAVFZ6mqgrVrobEx7kpERNpEQdFZBgwIx1GsWRN3JSIibaKg6CyJ82drnEJEcoyCorNouXERyVEKis6y//7Qt69aFCKScxQUnWnAALUoRCTnKCg6U+JYCi0OKCI5REHRmaqqYPNm+PjjuCsREUmbgqIzaUBbRHKQgqIzJRYH1IC2iOQQBUVnOvBAKClRUIhIToklKMysr5k9bWbLoss+rWz3MzN7w8yWmtmvzMw6u9aM6tIlHHinricRySFxtSimAnPd/VBgbnT7M8zseOAE4ChgODAaOLkzi8wKLQ4oIjkmrqCYAMyMrs8Ezk2yjQOlQFdgP6AEWNsZxWXVgAGwejXs2BF3JSIiaYkrKMrdfXV0fQ1Q3nIDd18APAusjn6ecvelyXZmZlPMrM7M6hoaGrJVc2ZUVcHOnVocUERyRtaCwsyeMbPXk/xMaL6duzuh9dDy+UOBI4ABQBXwBTM7MdlrufsMd69199r+/ftn4d1kkKbIikiOKc7Wjt19fGuPmdlaM6t099VmVgmsS7LZecDf3H1z9JwngOOA+VkpuLM0nyI7dmy8tYiIpCGurqdHgInR9YnAnCTbvAecbGbFZlZCGMhO2vWUU7p3h969NUVWRHJGXEExHTjNzJYB46PbmFmtmd0RbTMbeAt4DXgFeMXd/yuOYjNOiwOKSA7JWtdTKu6+ATg1yf11wOToehPwzU4urXNUVcFf/xp3FSIiadGR2XEYMAA2bdLigCKSExQUcUjMfNI4hYjkAAVFHA4+OFy+9168dYiIpEFBEYf+/WG//dSiEJGcoKCIg1noflKLQkRygIIiLgcfDO+/H3cVIiJ7Fcv0WCG0KJ59Fj75BPbfv23PXboUbrsNmprC+S3GjIFLL81OnSJS8NSiiEtiQLut4xQ7dsCvfhWm1g4aBF27wgMPwIIFma9RRAS1KOIzcGC4fO89OPTQ9J/3X/8VwuWGG2D06BAcV18dWhjDh0NZWXbqFZGCpRZFXCoqoLi4bS2KjRvhd78LATF6dLivuBiuuiocwDdjRnZqFZGCpqCIS1FROC1qW2Y+3XNPaEFcccVn7x88GC66CP77v2HhwkxWKSKioIhVW2Y+rVsXBr/PPRcqK/d8/CtfgfJy+P3vM1qiiIiCIk4DB4Yz3W3fvvdt50en4fjiF5M/XlwMZ50Fb7wB77yTsRJFRBQUcRo4ENxh1aq9bzt/fhj0rqhofZvx48MsqMcey1yNIlLwFBRxaj7zKZXVq+Gtt+DEpGeC3a2sDE4+OXRRbdmSmRpFpOApKOJUVRWW89jbOEWi22lvQQGh++nTT2Hu3I7XJyKCgiJeJSVhYDqdoDjiCDjggL3vc8gQOPzw0P3knpk6RaSgKSjiVl0Ny5a1/qVeXx8Gpz//+fT3edZZYdzjlVcyUaGIFDgFRdxGjgxTX1sb0H7uudA91ZagOOEE6NkTnngiMzWKSEFTUMRt1Khw+dJLez7mHg6iO/JI6Ns3/X2WlIQZUH/7WziaW0SkAxQUcauoCOMUL7+852NvvgkrV8Kpp7Z9v2ecATt3wtNPd7xGESloCop9wahR8Oqr0Nj42fvnzg1nwjvhhLbvs7ISamrgySdDYIiItJOCYl8walSY0rp06e77tm8Ps52OP77t56tI+NKXYP16WLQoM3WKSEFSUOwLRowIiwQ273564YVw0Fx7up0SxowJYxuPPtrxGkWkYCko9gX77x+Ok2g+oD13bjhu4qij2r/f4mL4p38K+3399Y7XKSIFSUGxrxg1ClasCF1Ff/97+HL/whfC1NiOOOecEDh33aUD8ESkXRQU+4rENNmvfx2uuWb3FNeO6toVvva1cFBfYikQEZE20KlQ9xWDB8OECdClCwwdGrqi+vfPzL5POQXmzIGZM+HYY0N4iIikSUGxrzCDyZOzt++vfx1+8AO4/Xb4538OgdRWW7bAhx/C1q3hTHsHHQS9emW8XBHZtygoCsXIkXD++eEMeB9/DFdfvfeWhTssXw4vvhjGTJKtSdWzZ2gNHXVUeI2hQ9sXQiKyz1JQFJJJk6B3b7jzTvjgAzj77PDlnmgVuId1p5YvhyVL4K9/DYPrZvC5z8HFF4dWRLduIQxWrgzn0njzTbj33rCPsjI4+mg45pgw7tK7d0xvVkQyxTyGmTBm9hVgGnAEMMbd61rZ7gzgl0ARcIe7T9/bvmtra72uLunuJGHePPjNb2Dz5nC7V6/QlbR9++6jw0tKwhf+8ceH4zHKylLv88MPw9HlixaFn48+CvcPHRr2c8QRYfnzve1HRGJhZovcvTbpYzEFxRHATuD/At9PFhRmVgT8AzgNqAcWApe4+5JU+1ZQpKmpKZw1b/FiaGgIwVBcHFoMQ4bAoEHtH/R2D1N9Fy2Cujr4xz/C60EIit69w+WOHeGI9E8+CeMeW7eG5xYVhVp69AjbNf/p0SMcd9KtG3TvHi733z8sdVJaGp6X6PrasSMEX2NjeJ3t28Nl4mfbtt3Xm5rC9l26hH2UlOz5Gt26hdfo2jW8XnHx7lqLisJzU01nNtv9I7KPSRUUsXQ9uftSAEv9H2YMsNzdV0TbPgBMAFIGhaSpqAgOOyz8ZJpZCJshQ+DCC8MX8bJl4fiQhobQ7bVpU/jS79cvfPkmvpC7dAlf2o2NocWzaVMYU3n33XB9y5bwhZ5JRUUhGIqKwrpYiYDJJrPdwdKlS/hJhE0ieBI/iXBJ/FHnvvsnsY5X4naq12seUi0Dq+Xtlvvb2x+ULf8vd0Ygtqy/LX/0tty2rb+/ZPtorbZk2zXfV3v/WE/2+62uhmuvbd/+UtiXxyiqgOanfqsHxibb0MymAFMADj744OxXJm2z334wfHj4yYTGxt0tkMRPonXQ1LT7yzPRMigpCa2AREsg8VNaGi6LivZ8DffdLZ0tW8L1LVt2t0y2bw+BsmNHeM3E6zb/Mk/2ZZH4ck/UmLi+c+fu/SRaN4n7mi/q2PwLK9Fyan5fa6+ZeK3mj7V8vGXNiX03f41kku0n2eMtpRskyZ6fiZ6QlkGT7BI++1kl20eqgE32WpnuxWn+uVVWZnbfkawFhZk9A1Qkeeh6d5+Tyddy9xnADAhdT5nct+yDSkrCuEo2p+aahRZOt27pnYJWJI9lLSjcvaOHFa8EBja7PSC6T0REOtG+POF9IXComR1iZl2Bi4FHYq5JRKTgxBIUZnaemdUDxwGPmdlT0f0HmdnjAO6+A/gX4ClgKfCQu78RR70iIoUsrllPDwMPJ7l/FXBms9uPA493YmkiItLCvtz1JCIi+wAFhYiIpKSgEBGRlBQUIiKSUixrPWWTmTUA73ZgFwcA6zNUzr5C7yl35OP7ysf3BPn3vga5e9KzpeVdUHSUmdW1tjBWrtJ7yh35+L7y8T1B/r6vZNT1JCIiKSkoREQkJQXFnmbEXUAW6D3ljnx8X/n4niB/39ceNEYhIiIpqUUhIiIpKShERCQlBUXEzM4wszfNbLmZTY27nvYys4Fm9qyZLTGzN8zsquj+vmb2tJktiy77xF1rW5lZkZm9bGaPRrcPMbMXos/swWg5+pxhZr3NbLaZ/d3MlprZcXnyOf1r9G/vdTObZWalufZZmdldZrbOzF5vdl/Sz8aCX0Xv7VUzGxVf5dmhoCB8AQG/Br4EDAMuMbNh8VbVbjuAq919GHAs8D+j9zIVmOvuhwJzo9u55irCkvMJPwV+4e5DgQ+Ab8RSVfv9EnjS3Q8HRhLeW05/TmZWBXwHqHX34UAR4VwyufZZ3QOc0eK+1j6bLwGHRj9TgN90Uo2dRkERjAGWu/sKd98OPABMiLmmdnH31e7+UnR9E+HLp4rwfmZGm80Ezo2lwHYyswHAWcAd0W0DvgDMjjbJqfdkZr2Ak4A7Adx9u7t/SI5/TpFiYH8zKwa6AavJsc/K3ecBG1vc3dpnMwG414O/Ab3NLDsnr46JgiKoAt5vdrs+ui+nmVk1cDTwAlDu7qujh9YA5XHV1U7/AVwLJM5w3w/4MDrBFeTeZ3YI0ADcHXWn3WFm3cnxz8ndVwK3AO8RAuIjYBG5/VkltPbZ5OX3R3MKijxlZj2A3wPfdfePmz/mYU50zsyLNrOzgXXuvijuWjKoGBgF/Mbdjwa20KKbKdc+J4Co334CIQgPArqzZxdOzsvFz6YjFBTBSmBgs9sDovtykpmVEELifnf/Q3T32kRzOLpcF1d97XACcI6ZvUPoFvwCoX+/d9S9Abn3mdUD9e7+QnR7NiE4cvlzAhgPvO3uDe7eCPyB8Pnl8meV0Npnk1ffH8koKIKFwKHRzIyuhMG3R2KuqV2ivvs7gaXu/n+aPfQIMDG6PhGY09m1tZe7/5u7D3D3asJn82d3vxR4Frgg2izX3tMa4H0z+1x016nAEnL4c4q8BxxrZt2if4uJ95Wzn1UzrX02jwCXRbOfjgU+atZFlRd0ZHbEzM4k9IMXAXe5+4/jrah9zOzzwHzgNXb35/8vwjjFQ8DBhGXYL3T3loN1+zwzGwd8393PNrPBhBZGX+Bl4Kvu/mmM5bWJmdUQBue7AiuAywl/vOX052RmNwIXEWbgvQxMJvTZ58xnZWazgHGEpcTXAj8E/kiSzyYKxFsJXWxbgcvdvS6GsrNGQSEiIimp60lERFJSUIiISEoKChERSUlBISIiKSkoREQkJQWFSAtm9tfostrM/keG9/2/kr2WyL5M02NFWtH8mI02PKe42ZpGyR7f7O49MlCeSKdRi0KkBTPbHF2dDpxoZoujcywUmdnNZrYwOu/AN6Ptx5nZfDN7hHAUMmb2RzNbFJ2XYUp033TCqqqLzez+5q8VHdV7c3QOh9fM7KJm+/7vZuetuD86wAszm27hvCOvmtktnfk7ksJSvPdNRArWVJq1KKIv/I/cfbSZ7Qc8b2Z/irYdBQx397ej21+PjtrdH1hoZr9396lm9i/uXpPktb4M1BDOS3FA9Jx50WNHA0cCq4DngRPMbClwHnC4u7uZ9c7sWxfZTS0KkfSdTljTZzFhSZR+hJPVALzYLCQAvmNmrwB/IywYdyipfR6Y5e5N7r4W+Aswutm+6919J7AYqCYs370NuNPMvkxYOkIkKxQUIukz4NvuXhP9HOLuiRbFll0bhbGN8cBx7j6SsLZRaQdet/maSE1AYhxkDGHV2bOBJzuwf5GUFBQirdsElDW7/RTwz9Ey7pjZYdHJhlrqBXzg7lvN7HDCKWkTGhPPb2E+cFE0DtKfcPa7F1srLDrfSC93fxz4V0KXlUhWaIxCpHWvAk1RF9I9hHNgVAMvRQPKDSQ/peeTwLeicYQ3Cd1PCTOAV83spWip9ISHgeOAVwgnxLnW3ddEQZNMGTDHzEoJLZ3vtesdiqRB02NFRCQldT2JiEhKCgoREUlJQSEiIikpKEREJCUFhYiIpKSgEBGRlBQUIiKS0v8HaZuxI0AZydEAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 绘制迭代过程中损失函数变化曲线\n", - "plt.figure(1)\n", - "ITR_list = []\n", - "for i in range(ITR):\n", - " ITR_list.append(i)\n", - "func = plt.plot(ITR_list, loss_list, alpha=0.7, marker='', linestyle='-', color='r')\n", - "plt.xlabel('iterations')\n", - "plt.ylabel('loss')\n", - "plt.legend(labels=[\"loss function during iteration\"], loc='best')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**可见，最终 “-fidelity” 变为 “-1”, 此时量子电路已学会如何制备目标量子态 “$|01\\rangle\\otimes|+\\rangle$”。**" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "b79f688f118b7eec4a7bc67db8fbcf9e8f165bc4247c9c8f9f9067a5de2aa71e" - }, - "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": 2 -} diff --git a/introduction/PaddleQuantum_Functions_EN.ipynb b/introduction/PaddleQuantum_Functions_EN.ipynb deleted file mode 100644 index 4fdb819..0000000 --- a/introduction/PaddleQuantum_Functions_EN.ipynb +++ /dev/null @@ -1,833 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Frequently Used Functions in Paddle Quantum\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Overview" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In this file, we list some frequently used functions in Paddle Quantum.\n", - "\n", - "You can see other functions in [API](https://qml.baidu.com/api/introduction.html)\n", - "\n", - "Here we will also use preparing a pure state as an example to see how to use Paddle Quantum to realize quantum neural network algorithms." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 1. Import Mudules " - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# 1.1 Import numpy and paddle\n", - "import numpy as np\n", - "import paddle\n", - "\n", - "# 1.2 Create quantum circuit\n", - "from paddle_quantum.circuit import UAnsatz \n", - "\n", - "# 1.3 Create quantum state - in np.ndarray form\n", - "from paddle_quantum.state import vec, vec_random # As vector\n", - "from paddle_quantum.state import density_op, density_op_random, completely_mixed_computational # As matrix\n", - "\n", - "# 1.4 Create Matrix - in np.ndarray form\n", - "from scipy.stats import unitary_group # Random U matrix\n", - "from paddle_quantum.utils import pauli_str_to_matrix # Pauli matrices for n qubits\n", - "\n", - "# 1.5 Matrix calculation with paddle.Tensor\n", - "from paddle import matmul, trace # Calculate the inner product and trace\n", - "from paddle_quantum.utils import dagger # Get dagger of a paddle.Tensor (note: for numpy.ndarray, you can use “.conj().T” to do dagger)\n", - "\n", - "# 1.6 Plot figure\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 2. Often Used Parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# 2.1 Parameters for quantum circuit\n", - "\n", - "N = 3 # Qubits number in Quantum circuit\n", - "DEPTH = 2 # Depth of the quantum circuit (Layers number)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "# 2.2 Parameters in the iteration \n", - "\n", - "ITR = 200 # Iteration number \n", - "LR = 0.2 # Learning rate \n", - "SEED = 1 # Random seed \n", - "paddle.seed(SEED) # seed for paddle\n", - "np.random.seed(SEED) # seed for numpy" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 3. Numpy Matrix" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "# 3.1 Random unitary gate\n", - "V = unitary_group.rvs(2) # Random 2*2 V" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "# 3.2 Diagonal matrix\n", - "D = np.diag([0.2, 0.8])" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# 3.3 Transpose complex conjugate\n", - "V_dagger = V.conj().T" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "# 3.4 Matrix multiplication: @\n", - "H = (V @ D @ V_dagger)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.9999999999999998-8.239936510889834e-18j)" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# 3.5 Trace\n", - "H.trace()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0.2, 0.8])" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# 3.6 Eigenvalues\n", - "np.linalg.eigh(H)[0]" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [], - "source": [ - "# 3.7 Tensor product: A \\otimes B\n", - "A = np.eye(2)\n", - "B = H\n", - "T = np.kron(A, B)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "- Note: in Paddle Quantum, you can use string to create matrix for Pauli matices with $n$ qubit." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# An example: 0.4*I⊗Z+0.4*Z⊗I+0.2*X⊗X\n", - "# In the string form: 0.4*kron(I, Z) + 0.4*kron(Z, I) + 0.2*kron(X, X)\n", - "H_info = [[0.4, 'z0'], [0.4, 'z1'], [0.2, 'x0,x1']]\n", - "H_matrix = pauli_str_to_matrix(H_info, 3) # pauli matices with 3 qubits" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 4. Quantum States" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "# 4.1 Get pure states (a row vector in np.ndarray form)\n", - "\n", - "initial_state_pure1 = vec(0, N) # Get |00…0>, 2**N dimension row vector\n", - "initial_state_pure2 = vec_random(N) # Get random pure state, row vector" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "# 4.2 Get mixed states (in np.ndarray form)\n", - "\n", - "initial_state_mixed1 = density_op(N) # Get |00…0><00…0|\n", - "# Get a random density matrix, can decide real or complex and its rank (rank = 1 means pure) \n", - "initial_state_mixed2 = density_op_random(N, real_or_complex=2, rank=4)\n", - "initial_state_mixed3 = completely_mixed_computational(N) # Get a maximally mixed state " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 5. Quantum Circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "# 5.1 Create an N qubits quantum circuit\n", - "cir = UAnsatz(N)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# 5.2 Add gates to the circuit - see Section 7\n", - "# An example: add a CNOT gate to the first two qubits:\n", - "cir.cnot([0, 1])" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "# 5.3 The output state of the circuit\n", - "# The output state of the circuit as a vector in paddle.Tensor form.\n", - "# Note: the shape of the output here is not a vector. It can be changed to a column vector \n", - " # via function \"paddle.reshape(final_state, [2**N, 1]) —— it will be made better in the next version\n", - "\n", - "# Initial state is |00...0>\n", - "final_state = cir.run_state_vector()\n", - "# Initial state is not |00...0>\n", - "initial_state_pure = paddle.to_tensor(initial_state_pure2)\n", - "final_state_pure = cir.run_state_vector(initial_state_pure)\n", - "# Change to np.array form\n", - "final_state_pure_np = cir.run_state_vector().reshape([2**N, 1]).numpy()" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "# Initial state is |00…0><00…0|\n", - "cir.run_density_matrix()\n", - "# Initial state is not |00...0><00...0|\n", - "initial_state_mixed = paddle.to_tensor(initial_state_mixed2)\n", - "final_state_mixed = cir.run_density_matrix(initial_state_mixed)\n", - "# Change to np.ndarray form\n", - "final_state_mixed_np = cir.run_density_matrix().numpy()" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1., 0., 0., 0., 0., 0., 0., 0.],\n", - " [0., 1., 0., 0., 0., 0., 0., 0.],\n", - " [0., 0., 1., 0., 0., 0., 0., 0.],\n", - " [0., 0., 0., 1., 0., 0., 0., 0.],\n", - " [0., 0., 0., 0., 0., 0., 1., 0.],\n", - " [0., 0., 0., 0., 0., 0., 0., 1.],\n", - " [0., 0., 0., 0., 1., 0., 0., 0.],\n", - " [0., 0., 0., 0., 0., 1., 0., 0.]])" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# 5.4 The unitary matrix of the circuit (in paddle.Tensor form)\n", - "cir.U\n", - "# Change to np.ndarray form\n", - "cir.U.numpy()\n", - "# Only keep the real part:\n", - "cir.U.real()\n", - "cir.U.numpy().real" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--*--\n", - " | \n", - "--x--\n", - " \n", - "-----\n", - " \n" - ] - } - ], - "source": [ - "# 5.5 Print the circuit\n", - "print(cir)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 5.6 Measure outcome\n", - "res = cir.measure(shots=0, plot=True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 6. Angles in Quantum Gate\n", - " Note: \n", - "- For qubits unitary gate, they can always be characterized by a rotation axis and a rotation angle. \n", - "- The rotation axis in Paddle Quantum is always chosen to be $x,y,z$-axis.\n", - "- The rotation angle will be the variable in QNN tasks, and **they should be given in paddle.Tensor form**." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "# 6.1 A Single Angle\n", - "\n", - "phi, theta, omega = 2 * np.pi * np.random.uniform(size=3) # Generate a random angle\n", - "# change to paddle.Tensor\n", - "phi = paddle.to_tensor(phi, dtype='float64')" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "# 6.2 Angles in Arrays\n", - "# 1D arrays\n", - "\n", - "theta = np.array([np.pi, 2 ,3, 5]) # 4 angles are different\n", - "theta = np.full([4], np.pi) # 4 angles all equal to pi\n", - "# change to be paddle.Tensor\n", - "theta = paddle.to_tensor(theta)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "# Multidimensional Arrays\n", - "\n", - "theta = np.random.randn(DEPTH, N, 3) # A 3D np.ndarray" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "For a frequently used quantum circuit: cir.complex_entangled_layer(theta, DEPTH), see \n", - "[here](https://qml.baidu.com/quick-start/quantum-neural-network.html), the shape of theta should be(DEPTH, N, OTHER=3)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 7. Add Quantum Gates to the Circuit" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "# 7.1 Single qubit gates \n", - "# Note: angles should be in paddle.Tensor form.\n", - "# Subscript is the rotating axis, the first parameter is the rotating angle, the second is which qubit it acts\n", - "\n", - "cir.rz(theta[0], 0)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "# # 7.2 Two-qubit gate\n", - "\n", - "cir.cnot([0, 1])" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "# 7.3 Some frequently used gates\n", - "\n", - "# Add Hadamard gates to each qubit\n", - "cir.superposition_layer()\n", - "# Add a Ry(pi/4) rotation to each qubit\n", - "cir.weak_superposition_layer()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "General rotation gate in Euler representation, and the corresponding circuit click [here](https://qml.baidu.com/quick-start/quantum-neural-network.html)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 8. VQA basic structure (1) -- Create your own quantum circuit as a function\n", - "- step 1: Create an N qubit circuit;\n", - "- step 2: Add gates to each layer" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "def circuit(N, DEPTH, theta):\n", - " \"\"\"\n", - " Input data:\n", - " N, qubits number\n", - " DEPTH, layers number\n", - " theta, [N, DEPTH, 2], 3D matrix in paddle.Tensor form\n", - " Return:\n", - " cir, the final circuit\n", - " \"\"\"\n", - " # step 1: Create an N qubit circuit\n", - " cir = UAnsatz(N)\n", - " # step 2: Add gates to each layer\n", - " for dep in range(DEPTH):\n", - " for n in range(N):\n", - " cir.rx(theta[n][dep][0], n) # add an Rx gate to the n-th qubit\n", - " cir.rz(theta[n][dep][1], n) # add an Rz gate to the n-th qubit\n", - " for n in range(N - 1):\n", - " cir.cnot([n, n + 1]) # add CNOT gate to every neighbor pair\n", - "\n", - " return cir" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--Rx(0.069)----Rz(0.473)----*----Rx(-0.65)----Rz(-0.77)-----------------*-------\n", - " | | \n", - "--Rx(-0.77)----Rz(0.623)----x--------*--------Rx(0.428)----Rz(0.074)----x----*--\n", - " | | \n", - "--Rx(-0.45)----Rz(0.604)-------------x--------Rx(2.385)----Rz(-0.12)---------x--\n", - " \n" - ] - } - ], - "source": [ - "# Here is the printed final circuit for (N=3, DEPTH=2, theta is randomly generated):\n", - "theta = paddle.to_tensor(np.random.randn(N, DEPTH, 2))\n", - "theta = paddle.to_tensor(theta)\n", - "cir = circuit(N, DEPTH, theta)\n", - "print(cir)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 9. VQA basic structure (2) -- forward part, calculate the loss function\n", - "- QNN optimization can be done with a Python Iterator, here is an example for preparing quantum state;\n", - "- In forward part, all variables should be always in paddle.Tensor form." - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "class StatePrepNet(paddle.nn.Layer):\n", - " # Step 1: Give the initial input: def __init__(…)\n", - " # Here you need to give the parameters for creating your quantum circuit and loss\n", - " def __init__(self, N, DEPTH, psi, dtype='float64'):\n", - " # N, DEPTH: circuit parameter\n", - " # psi: target output pure state, np.row_vector form\n", - " super(StatePrepNet, self).__init__()\n", - " self.N = N\n", - " self.DEPTH = DEPTH\n", - " # The initial circuit parameter theta is generated randomly\n", - " self.theta = self.create_parameter(shape=[self.N, self.DEPTH, 2],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0., high=2 * np.pi), \n", - " dtype=dtype, is_bias=False)\n", - " # Target output state, used for loss function\n", - " self.psi = paddle.to_tensor(psi)\n", - " # Step 2: Calculate the loss function: L = - \n", - " # note: here we want to minimize the loss function, so we use “-Fidelity”\n", - " def forward(self):\n", - " # Create the quantum circuit\n", - " cir = circuit(self.N, self.DEPTH, self.theta)\n", - " # Get the final state\n", - " psi_out = cir.run_state_vector()\n", - " psi_out = paddle.reshape(psi_out, [2 ** self.N, 1]) # reshape to ket\n", - " # Calculate the loss function: L = - \n", - " inner = matmul(self.psi, psi_out)\n", - " loss = - paddle.real(matmul(inner, dagger(inner)))[0] # change to shape tensor([1])\n", - "\n", - " return loss, cir" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 10. VQA basic structure (3) -- backward part, optimize over iteration\n", - "- Here we still use preparing a 3-qubit pure state $|01\\rangle\\otimes|+\\rangle$ as an example, and the circuit we use is given in section 8.\n", - "- Usually we use Adam as the optimizer." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "N = 3 # Qubits number in Quantum circuit\n", - "DEPTH = 2 # Depth of the quantum circuit (Layers number)\n", - "ITR = 115 # Iteration number \n", - "LR = 0.2 # Learning rate " - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [], - "source": [ - "# target output state, np.ndarray row vector\n", - "psi_target = np.kron(np.kron(np.array([[1,0]]), np.array([[0,1]])), np.array([[1/np.sqrt(2), 1/np.sqrt(2)]])) # <01+|" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [], - "source": [ - "# 10.1 Record the iteration\n", - "loss_list = []\n", - "parameter_list = []" - ] - }, - { - "cell_type": "code", - "execution_count": 33, - "metadata": {}, - "outputs": [], - "source": [ - "# 10.2 Use Iterator defined in section 9\n", - "# (N=3, DEPTH=2, ITR=110, LR=0.2)\n", - "myLayer = StatePrepNet(N, DEPTH, psi_target)" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "metadata": {}, - "outputs": [], - "source": [ - "# 10.3 Choose the optimizer\n", - "# Usually we use Adam.\n", - "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = myLayer.parameters()) " - ] - }, - { - "cell_type": "code", - "execution_count": 35, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 0 loss: -0.0176\n", - "iter: 10 loss: -0.8356\n", - "iter: 20 loss: -0.9503\n", - "iter: 30 loss: -0.9837\n", - "iter: 40 loss: -0.9971\n", - "iter: 50 loss: -0.9974\n", - "iter: 60 loss: -0.9995\n", - "iter: 70 loss: -0.9999\n", - "iter: 80 loss: -0.9999\n", - "iter: 90 loss: -1.0000\n", - "iter: 100 loss: -1.0000\n", - "iter: 110 loss: -1.0000\n" - ] - } - ], - "source": [ - "# 10.4 Optimize during iteration\n", - "for itr in range(ITR):\n", - " # Use forward part to calculate the loss function\n", - " loss = myLayer()[0]\n", - " # Backward optimize via Gradient descent algorithm\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - " # Record the learning curve\n", - " loss_list.append(loss.numpy()[0])\n", - " parameter_list.append(myLayer.parameters()[0].numpy())\n", - " if itr % 10 == 0:\n", - " print('iter:', itr, ' loss: %.4f' % loss.numpy())" - ] - }, - { - "cell_type": "code", - "execution_count": 36, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The minimum of the loss function: -0.9999873168488457\n", - "Parameters after optimizationL theta:\n", - " [[[-0.00816927 7.41571003]\n", - " [ 6.28197865 0.29031951]]\n", - "\n", - " [[ 3.14801248 6.1562368 ]\n", - " [ 6.2890315 4.08082862]]\n", - "\n", - " [[ 4.57489065 1.58064113]\n", - " [ 4.78145659 3.28051687]]]\n", - "--Rx(-0.00)----Rz(7.416)----*----Rx(6.282)----Rz(0.290)-----------------*-------\n", - " | | \n", - "--Rx(3.148)----Rz(6.156)----x--------*--------Rx(6.289)----Rz(4.081)----x----*--\n", - " | | \n", - "--Rx(4.575)----Rz(1.581)-------------x--------Rx(4.781)----Rz(3.281)---------x--\n", - " \n", - "state_final:\n", - " [-0.0001236 +1.65203739e-04j -0.00051346-3.22614883e-04j\n", - " 0.09637039-7.00598643e-01j 0.09558872-7.00513830e-01j\n", - " 0.00038931+1.78566178e-04j 0.0003892 +1.76713800e-04j\n", - " 0.00209719+1.98540264e-03j 0.0025603 +1.33735551e-03j]\n" - ] - } - ], - "source": [ - "# 10.5 Print the output\n", - "\n", - "print('The minimum of the loss function: ', loss_list[-1])\n", - "# The parameters after optimization\n", - "theta_opt = parameter_list[-1] # Get self.theta\n", - "print(\"Parameters after optimizationL theta:\\n\", theta_opt)\n", - "# Draw the circuit picture and the output state\n", - "# Get theta\n", - "theta_final = parameter_list[-1]\n", - "theta_final = paddle.to_tensor(theta_final)\n", - "# Print the circuit\n", - "cir_final = circuit(N, DEPTH, theta_final)\n", - "print(cir_final)\n", - "# Print the final state\n", - "#state_final = cir_final.run_density_matrix()\n", - "state_final = cir_final.run_state_vector()\n", - "print(\"state_final:\\n\", state_final.numpy())" - ] - }, - { - "cell_type": "code", - "execution_count": 37, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Print the loss function during iteration\n", - "plt.figure(1)\n", - "ITR_list = []\n", - "for i in range(ITR):\n", - " ITR_list.append(i)\n", - "func = plt.plot(ITR_list, loss_list, alpha=0.7, marker='', linestyle='-', color='r')\n", - "plt.xlabel('iterations')\n", - "plt.ylabel('loss')\n", - "plt.legend(labels=[\"loss function during iteration\"], loc='best')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**As the \"-Fidelity\" becomes \"-1\", this circuit learns to prepare the target state \"$|01\\rangle\\otimes|+\\rangle$\".**" - ] - } - ], - "metadata": { - "interpreter": { - "hash": "b79f688f118b7eec4a7bc67db8fbcf9e8f165bc4247c9c8f9f9067a5de2aa71e" - }, - "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": 2 -} diff --git a/introduction/PaddleQuantum_GPU_CN.ipynb b/introduction/PaddleQuantum_GPU_CN.ipynb index bd1f194..cb66b9c 100644 --- a/introduction/PaddleQuantum_GPU_CN.ipynb +++ b/introduction/PaddleQuantum_GPU_CN.ipynb @@ -146,20 +146,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "import os\n", - "import numpy\n", - "from numpy import concatenate\n", - "from numpy import pi as PI\n", - "from numpy import savez, zeros\n", - "from paddle import matmul, transpose\n", - "from paddle_quantum.circuit import UAnsatz\n", - "\n", - "import matplotlib.pyplot as plt\n", "import numpy\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.loss import ExpecVal\n", "\n", "\n", "def H2_generator():\n", @@ -187,54 +181,6 @@ "\n", "\n", "Hamiltonian, N = H2_generator()\n", - "\n", - "\n", - "def U_theta(theta, Hamiltonian, N, D):\n", - " \"\"\"\n", - " Quantum Neural Network\n", - " \"\"\"\n", - "\n", - " # 按照量子比特数量/网络宽度初始化量子神经网络\n", - " cir = UAnsatz(N)\n", - "\n", - " # 内置的 {R_y + CNOT} 电路模板\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", - " # 量子神经网络作用在默认的初始态 |0000>上\n", - " cir.run_state_vector()\n", - "\n", - " # 计算给定 Hamilton 量的期望值\n", - " expectation_val = cir.expecval(Hamiltonian)\n", - "\n", - " return expectation_val\n", - "\n", - "\n", - "class StateNet(paddle.nn.Layer):\n", - " \"\"\"\n", - " Construct the model net\n", - " \"\"\"\n", - "\n", - " def __init__(self, shape, dtype=\"float64\"):\n", - " super(StateNet, self).__init__()\n", - "\n", - " # 初始化 theta 参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " self.theta = self.create_parameter(\n", - " shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * PI), \n", - " dtype=dtype, \n", - " is_bias=False)\n", - "\n", - " # 定义损失函数和前向传播机制\n", - " def forward(self, Hamiltonian, N, D):\n", - " # 计算损失函数/期望值\n", - " loss = U_theta(self.theta, Hamiltonian, N, D)\n", - "\n", - " return loss\n", - "\n", "ITR = 80 # 设置训练的总迭代次数\n", "LR = 0.2 # 设置学习速率\n", "D = 2 # 设置量⼦神经⽹络中重复计算模块的深度 Depth" @@ -249,21 +195,21 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iter: 20 loss: -0.9686\n", - "iter: 20 Ground state energy: -0.9686 Ha\n", - "iter: 40 loss: -1.1056\n", - "iter: 40 Ground state energy: -1.1056 Ha\n", - "iter: 60 loss: -1.1235\n", - "iter: 60 Ground state energy: -1.1235 Ha\n", - "iter: 80 loss: -1.1317\n", - "iter: 80 Ground state energy: -1.1317 Ha\n" + "iter: 20 loss: -1.0541\n", + "iter: 20 Ground state energy: -1.0541 Ha\n", + "iter: 40 loss: -1.1256\n", + "iter: 40 Ground state energy: -1.1256 Ha\n", + "iter: 60 loss: -1.1330\n", + "iter: 60 Ground state energy: -1.1330 Ha\n", + "iter: 80 loss: -1.1361\n", + "iter: 80 Ground state energy: -1.1361 Ha\n" ] } ], @@ -272,7 +218,10 @@ "paddle.set_device(\"gpu:0\")\n", " \n", "# 确定网络的参数维度\n", - "net = StateNet(shape=[D + 1, N, 1])\n", + "net = Circuit(N)\n", + "net.real_entangled_layer(depth=D)\n", + "net.ry(qubits_idx='full')\n", + "loss_func = ExpecVal(paddle_quantum.Hamiltonian(Hamiltonian))\n", "\n", "# 一般来说，我们利用Adam优化器来获得相对好的收敛\n", "# 当然你可以改成SGD或者是RMSProp\n", @@ -285,7 +234,8 @@ "for itr in range(1, ITR + 1):\n", "\n", " # 前向传播计算损失函数\n", - " loss = net(Hamiltonian, N, D)\n", + " state = net()\n", + " loss = loss_func(state)\n", "\n", " # 在动态图机制下，反向传播极小化损失函数\n", " loss.backward()\n", @@ -312,21 +262,21 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iter: 20 loss: -1.1080\n", - "iter: 20 Ground state energy: -1.1080 Ha\n", - "iter: 40 loss: -1.1301\n", - "iter: 40 Ground state energy: -1.1301 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" + "iter: 20 loss: -1.1092\n", + "iter: 20 Ground state energy: -1.1092 Ha\n", + "iter: 40 loss: -1.1342\n", + "iter: 40 Ground state energy: -1.1342 Ha\n", + "iter: 60 loss: -1.1359\n", + "iter: 60 Ground state energy: -1.1359 Ha\n", + "iter: 80 loss: -1.1362\n", + "iter: 80 Ground state energy: -1.1362 Ha\n" ] } ], @@ -335,7 +285,10 @@ "paddle.set_device(\"cpu\")\n", " \n", "# 确定网络的参数维度\n", - "net = StateNet(shape=[D + 1, N, 1])\n", + "net = Circuit(N)\n", + "net.real_entangled_layer(depth=D)\n", + "net.ry(qubits_idx='full')\n", + "loss_func = ExpecVal(paddle_quantum.Hamiltonian(Hamiltonian))\n", "\n", "# 一般来说，我们利用Adam优化器来获得相对好的收敛\n", "# 当然你可以改成SGD或者是RMSProp\n", @@ -348,7 +301,8 @@ "for itr in range(1, ITR + 1):\n", "\n", " # 前向传播计算损失函数\n", - " loss = net(Hamiltonian, N, D)\n", + " state = net()\n", + " loss = loss_func(state)\n", "\n", " # 在动态图机制下，反向传播极小化损失函数\n", " loss.backward()\n", @@ -387,8 +341,11 @@ } ], "metadata": { + "interpreter": { + "hash": "e7e319cf09f871acf81082dc29b22c534722d9dd5de2504328a47dbcbf5ae00a" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.0 ('pq-gpu': conda)", "language": "python", "name": "python3" }, @@ -402,7 +359,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.0" }, "toc": { "base_numbering": 1, diff --git a/introduction/PaddleQuantum_GPU_EN.ipynb b/introduction/PaddleQuantum_GPU_EN.ipynb index 07a1c73..9edf632 100644 --- a/introduction/PaddleQuantum_GPU_EN.ipynb +++ b/introduction/PaddleQuantum_GPU_EN.ipynb @@ -152,20 +152,14 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "import os\n", - "import numpy\n", - "from numpy import concatenate\n", - "from numpy import pi as PI\n", - "from numpy import savez, zeros\n", - "from paddle import matmul, transpose\n", - "from paddle_quantum.circuit import UAnsatz\n", - "\n", - "import matplotlib.pyplot as plt\n", "import numpy\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.loss import ExpecVal\n", "\n", "\n", "def H2_generator():\n", @@ -194,54 +188,6 @@ "\n", "\n", "Hamiltonian, N = H2_generator()\n", - "\n", - "\n", - "def U_theta(theta, Hamiltonian, N, D):\n", - " \"\"\"\n", - " Quantum Neural Network\n", - " \"\"\"\n", - " \n", - " # Initialize the quantum neural network according to the number of qubits/network width\n", - " cir = UAnsatz(N)\n", - " \n", - " # Built-in {R_y + CNOT} circuit template\n", - " cir.real_entangled_layer(theta[:D], D)\n", - "\n", - " # Add in the last row a layer of R_y rotation gates\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 |0000>\n", - " cir.run_state_vector()\n", - "\n", - " # Calculate the expected value of a given Hamiltonian\n", - " expectation_val = cir.expecval(Hamiltonian)\n", - "\n", - " return expectation_val\n", - "\n", - "\n", - "class StateNet(paddle.nn.Layer):\n", - " \"\"\"\n", - " Construct the model net\n", - " \"\"\"\n", - "\n", - " def __init__(self, shape, dtype=\"float64\"):\n", - " super(StateNet, self).__init__()\n", - "\n", - " # Initialize the theta parameter list and fill the initial value with the uniform distribution of [0, 2*pi]\n", - " self.theta = self.create_parameter(\n", - " shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * PI), \n", - " dtype=dtype, \n", - " is_bias=False)\n", - "\n", - " # Define loss function and forward propagation mechanism\n", - " def forward(self, Hamiltonian, N, D):\n", - " # Calculate loss function/expected value\n", - " loss = U_theta(self.theta, Hamiltonian, N, D)\n", - "\n", - " return loss\n", - "\n", "ITR = 80 # Set the total number of training iterations\n", "LR = 0.2 # Set the learning rate\n", "D = 2 # Set the depth of the repeated calculation module in the neural network" @@ -256,21 +202,21 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iter: 20 loss: -1.0305\n", - "iter: 20 Ground state energy: -1.0305 Ha\n", - "iter: 40 loss: -1.1111\n", - "iter: 40 Ground state energy: -1.1111 Ha\n", - "iter: 60 loss: -1.1342\n", - "iter: 60 Ground state energy: -1.1342 Ha\n", - "iter: 80 loss: -1.1359\n", - "iter: 80 Ground state energy: -1.1359 Ha\n" + "iter: 20 loss: -1.0717\n", + "iter: 20 Ground state energy: -1.0717 Ha\n", + "iter: 40 loss: -1.1268\n", + "iter: 40 Ground state energy: -1.1268 Ha\n", + "iter: 60 loss: -1.1348\n", + "iter: 60 Ground state energy: -1.1348 Ha\n", + "iter: 80 loss: -1.1361\n", + "iter: 80 Ground state energy: -1.1361 Ha\n" ] } ], @@ -279,7 +225,10 @@ "paddle.set_device('gpu:0')\n", " \n", "# Determine the parameter dimension of the network\n", - "net = StateNet(shape=[D + 1, N, 1])\n", + "net = Circuit(N)\n", + "net.real_entangled_layer(depth=D)\n", + "net.ry(qubits_idx='full')\n", + "loss_func = ExpecVal(paddle_quantum.Hamiltonian(Hamiltonian))\n", "\n", "# Generally speaking, we use Adam optimizer to get relatively good convergence\n", "# Of course, you can change to SGD or RMSProp\n", @@ -292,7 +241,8 @@ "for itr in range(1, ITR + 1):\n", "\n", " # Forward propagation to calculate loss function\n", - " loss = net(Hamiltonian, N, D)\n", + " state = net()\n", + " loss = loss_func(state)\n", "\n", " # Under the dynamic graph mechanism, back propagation minimizes the loss function\n", " loss.backward()\n", @@ -319,21 +269,21 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iter: 20 loss: -1.0639\n", - "iter: 20 Ground state energy: -1.0639 Ha\n", - "iter: 40 loss: -1.1209\n", - "iter: 40 Ground state energy: -1.1209 Ha\n", - "iter: 60 loss: -1.1345\n", - "iter: 60 Ground state energy: -1.1345 Ha\n", - "iter: 80 loss: -1.1360\n", - "iter: 80 Ground state energy: -1.1360 Ha\n" + "iter: 20 loss: -1.0621\n", + "iter: 20 Ground state energy: -1.0621 Ha\n", + "iter: 40 loss: -1.1200\n", + "iter: 40 Ground state energy: -1.1200 Ha\n", + "iter: 60 loss: -1.1347\n", + "iter: 60 Ground state energy: -1.1347 Ha\n", + "iter: 80 loss: -1.1361\n", + "iter: 80 Ground state energy: -1.1361 Ha\n" ] } ], @@ -342,7 +292,10 @@ "paddle.set_device(\"cpu\")\n", "\n", "# Determine the parameter dimension of the network\n", - "net = StateNet(shape=[D + 1, N, 1])\n", + "net = Circuit(N)\n", + "net.real_entangled_layer(depth=D)\n", + "net.ry(qubits_idx='full')\n", + "loss_func = ExpecVal(paddle_quantum.Hamiltonian(Hamiltonian))\n", "\n", "# Generally speaking, we use Adam optimizer to get relatively good convergence\n", "# Of course you can change to SGD or RMSProp\n", @@ -355,7 +308,8 @@ "for itr in range(1, ITR + 1):\n", "\n", " # Forward propagation to calculate loss function\n", - " loss = net(Hamiltonian, N, D)\n", + " state = net()\n", + " loss = loss_func(state)\n", "\n", " # Under the dynamic graph mechanism, back propagation minimizes the loss function\n", " loss.backward()\n", @@ -395,8 +349,11 @@ } ], "metadata": { + "interpreter": { + "hash": "e7e319cf09f871acf81082dc29b22c534722d9dd5de2504328a47dbcbf5ae00a" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.0 ('pq-gpu': conda)", "language": "python", "name": "python3" }, @@ -410,7 +367,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.0" }, "toc": { "base_numbering": 1, diff --git a/introduction/PaddleQuantum_Qchem_Tutorial_CN.ipynb b/introduction/PaddleQuantum_Qchem_Tutorial_CN.ipynb index 0f1bf4a..b8da1e7 100644 --- a/introduction/PaddleQuantum_Qchem_Tutorial_CN.ipynb +++ b/introduction/PaddleQuantum_Qchem_Tutorial_CN.ipynb @@ -20,42 +20,51 @@ "metadata": {}, "source": [ "## 分子基态能量计算\n", - "qchem 提供了 `run_chem` 函数来计算给定分子的基态能量和基态波函数。让我们通过计算氢分子基态能量的例子来了解一下整个计算过程。首先，让我们导入需要用的函数。" + "qchem 为量子化学计算提供了很多便捷的工具。目前，qchem 模块支持下列分子波函数模版线路：\n", + "* Hardware Efficient ansatz[1](#refer-1),\n", + "* Slater determinant ansatz[2](#refer-2),\n", + "* Unitary Coupled Cluster singles and doubles (UCCSD) ansatz[3](#refer-3).\n", + "\n", + "让我们从具体的例子出发了解 qchem 的使用方法，下面我们演示了利用 qchem 求解氢分子基态的过程。" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "from paddle_quantum import qchem" + "import paddle_quantum as pq\n", + "from paddle_quantum import qchem as pq_qchem\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "接下来，让我们把与计算相关的信息输入到 `run_chem` 函数中，这些信息包括：分子的几何结构、分子的电荷、计算需要用到的量子化学基函数等。" + "接下来，我们需要提供量子化学计算需要用到的一些分子性质，包括：分子的几何结构、分子的电荷、计算需要用到的量子化学基函数等。" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "# define the geometry of hydrogen molecule, length unit use angstrom.\n", - "h2_geometry = [(\"H\", [0.0, 0.0, 0.0]), (\"H\", [0.0, 0.0, 0.74])]\n", - "charge = 0\n", - "basis_set = \"sto-3g\"" + "# 定义氢分子的几何结构，长度单位为埃\n", + "h2_geometry = \"H 0.0 0.0 0.0; H 0.0 0.0 0.74\"\n", + "basis_set = \"sto-3g\"\n", + "multiplicity = 1\n", + "charge = 0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "现在，我们需要选择一种多体波函数的量子线路模版来作为基态能量计算中的变分波函数。目前，qchem 提供了两种模式，分别是 \"hardware efficient\" [1](#refer-1) 和 \"hartree fock\" [2](#refer-2) ，更多的模式正在开发中，很快也会上线。" + "然后，我们需要为氢分子选择一种波函数模版线路。我们选择 `UCCSDModel` 作为模版线路并且用 `MolEnergyLoss` 作为损失函数。`UCCSDModel` 需要用 Trotter-Suzuki 方法构造其量子线路，关于 Trotter-Suzuki 方法，感兴趣的读者可以阅读这篇[教程](https://qml.baidu.com/tutorials/quantum-simulation/hamiltonian-simulation-with-product-formula.html)。" ] }, { @@ -64,124 +73,336 @@ "metadata": {}, "outputs": [], "source": [ - "# call run_chem function with \"hardware efficient\" ansatz.\n", - "h2_gs_en, h2_wf_model = qchem.run_chem(\n", - " h2_geometry,\n", - " \"hardware efficient\",\n", - " basis_set, \n", - " charge\n", - ")\n", + "# 构建 UCCSD 线路.\n", + "n_qubits = 4\n", + "n_electrons = 2\n", + "uccsd_ansatz = pq_qchem.UCCSDModel(n_qubits, n_electrons, n_trotter_steps=3)\n", "\n", - "# additional information for optimizer can be passed using `optimizer_option` keyword argument.\n", - "h2_gs_en, h2_wf_model = qchem.run_chem(\n", - " h2_geometry,\n", - " \"hardware efficient\",\n", - " basis_set, \n", - " charge,\n", - " optimizer_option={\"learning_rate\": 0.6, \"weight_decay\": 0.9}\n", - ")\n", - "\n", - "# additional information for ansatz can be passed using `ansatz_option` keyword argument, e.g.\n", - "# \"hardware efficient\" ansatz has a parameter \"cir_depth\", which can be used to specify the depth\n", - "# of quantum circuit.\n", - "h2_gs_en, h2_wf_model = qchem.run_chem(\n", - " h2_geometry,\n", - " \"hardware efficient\",\n", - " basis_set, \n", - " charge,\n", - " ansatz_option={\"cir_depth\": 5}\n", - ")" + "# 设置损失函数\n", + "loss_fn = pq_qchem.MolEnergyLoss(h2_geometry, basis_set)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "除了上面这些参数，我们也可以通过给定 `max_iters` 和 `a_tol` 来控制训练过程的迭代次数和收敛条件。如果想使用 \"hartree fock\" 量子线路，我们只需要把上面代码中的 \"hardware efficient\" 替换为 \"hartree fock\" 就可以了。我们也可以通过 `print(h2_wf_model.circuit)` 的方法来查看氢分子波函数的量子线路。" + "完成上面的步骤之后，我们可以按照[教程](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html)中的方法利用 paddlepaddle 中的优化器来训练参数化量子线路。" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 5, "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The iter is 0, loss is 0.71510.\n", + "The iter is 1, loss is 0.63558.\n", + "The iter is 2, loss is 0.13140.\n", + "The iter is 3, loss is -0.20547.\n", + "The iter is 4, loss is -0.59966.\n", + "The iter is 5, loss is -0.30310.\n", + "The iter is 6, loss is -0.69676.\n", + "The iter is 7, loss is -0.75225.\n", + "The iter is 8, loss is -0.75798.\n", + "The iter is 9, loss is -0.92072.\n", + "The iter is 10, loss is -0.89658.\n", + "The iter is 11, loss is -0.90863.\n", + "The iter is 12, loss is -0.96792.\n", + "The iter is 13, loss is -0.95464.\n", + "The iter is 14, loss is -0.96280.\n", + "The iter is 15, loss is -1.00236.\n", + "The iter is 16, loss is -1.02617.\n", + "The iter is 17, loss is -1.06962.\n", + "The iter is 18, loss is -1.06430.\n", + "The iter is 19, loss is -1.04589.\n", + "The iter is 20, loss is -1.06411.\n", + "The iter is 21, loss is -1.05254.\n", + "The iter is 22, loss is -1.04040.\n", + "The iter is 23, loss is -1.07904.\n", + "The iter is 24, loss is -1.10329.\n", + "The iter is 25, loss is -1.09534.\n", + "The iter is 26, loss is -1.10908.\n", + "The iter is 27, loss is -1.10671.\n", + "The iter is 28, loss is -1.09553.\n", + "The iter is 29, loss is -1.11231.\n", + "The iter is 30, loss is -1.11247.\n", + "The iter is 31, loss is -1.11016.\n", + "The iter is 32, loss is -1.12201.\n", + "The iter is 33, loss is -1.12010.\n", + "The iter is 34, loss is -1.11167.\n", + "The iter is 35, loss is -1.12422.\n", + "The iter is 36, loss is -1.12399.\n", + "The iter is 37, loss is -1.12124.\n", + "The iter is 38, loss is -1.12681.\n", + "The iter is 39, loss is -1.12666.\n", + "The iter is 40, loss is -1.12503.\n", + "The iter is 41, loss is -1.13086.\n", + "The iter is 42, loss is -1.13036.\n", + "The iter is 43, loss is -1.13068.\n", + "The iter is 44, loss is -1.13146.\n", + "The iter is 45, loss is -1.13127.\n", + "The iter is 46, loss is -1.13295.\n", + "The iter is 47, loss is -1.13266.\n", + "The iter is 48, loss is -1.13277.\n", + "The iter is 49, loss is -1.13409.\n", + "The iter is 50, loss is -1.13268.\n", + "The iter is 51, loss is -1.13372.\n", + "The iter is 52, loss is -1.13478.\n", + "The iter is 53, loss is -1.13374.\n", + "The iter is 54, loss is -1.13571.\n", + "The iter is 55, loss is -1.13538.\n", + "The iter is 56, loss is -1.13525.\n", + "The iter is 57, loss is -1.13623.\n", + "The iter is 58, loss is -1.13576.\n", + "The iter is 59, loss is -1.13595.\n", + "The iter is 60, loss is -1.13564.\n", + "The iter is 61, loss is -1.13593.\n", + "The iter is 62, loss is -1.13649.\n", + "The iter is 63, loss is -1.13643.\n", + "The iter is 64, loss is -1.13676.\n", + "The iter is 65, loss is -1.13627.\n", + "The iter is 66, loss is -1.13635.\n", + "The iter is 67, loss is -1.13670.\n", + "The iter is 68, loss is -1.13649.\n", + "The iter is 69, loss is -1.13696.\n", + "The iter is 70, loss is -1.13686.\n", + "The iter is 71, loss is -1.13687.\n", + "The iter is 72, loss is -1.13697.\n", + "The iter is 73, loss is -1.13685.\n", + "The iter is 74, loss is -1.13703.\n", + "The iter is 75, loss is -1.13698.\n", + "The iter is 76, loss is -1.13710.\n", + "The iter is 77, loss is -1.13706.\n", + "The iter is 78, loss is -1.13706.\n", + "The iter is 79, loss is -1.13706.\n", + "The iter is 80, loss is -1.13700.\n", + "The iter is 81, loss is -1.13716.\n", + "The iter is 82, loss is -1.13715.\n", + "The iter is 83, loss is -1.13721.\n", + "The iter is 84, loss is -1.13717.\n", + "The iter is 85, loss is -1.13714.\n", + "The iter is 86, loss is -1.13717.\n", + "The iter is 87, loss is -1.13719.\n", + "The iter is 88, loss is -1.13724.\n", + "The iter is 89, loss is -1.13723.\n", + "The iter is 90, loss is -1.13722.\n", + "The iter is 91, loss is -1.13721.\n", + "The iter is 92, loss is -1.13723.\n", + "The iter is 93, loss is -1.13721.\n", + "The iter is 94, loss is -1.13725.\n", + "The iter is 95, loss is -1.13724.\n", + "The iter is 96, loss is -1.13724.\n", + "The iter is 97, loss is -1.13725.\n", + "The iter is 98, loss is -1.13725.\n", + "The iter is 99, loss is -1.13725.\n", + "The theoretical value is -1.137283834485513.\n" + ] + } + ], "source": [ - "## 自定义量子线路\n", - "在 qchem 中，我们也为感兴趣的使用者提供了自定义量子线路的方法。我们只需要继承 qchem 中的 Qmodel 类就可以像在 paddlepaddle 中定义神经网络一样定义波函数对应的量子线路。" + "# 选择 paddlepaddle 中的 Adam 优化器\n", + "import paddle\n", + "\n", + "optimizer = paddle.optimizer.Adam(parameters=uccsd_ansatz.parameters(), learning_rate=0.1)\n", + "\n", + "# 制备初始量子态, e.g. |0000>\n", + "init_state = pq.state.computational_basis(n_qubits, 0)\n", + "\n", + "# 定义优化步数\n", + "num_itr = 100\n", + "for itr in range(0, num_itr):\n", + " # 运行量子线路得到末态\n", + " state = uccsd_ansatz(init_state)\n", + " # 计算损失函数，即期望值\n", + " loss = loss_fn(state)\n", + " # 反向传播梯度\n", + " loss.backward()\n", + " # 通过loss值更新参数\n", + " optimizer.minimize(loss)\n", + " # 清除当前梯度\n", + " optimizer.clear_grad()\n", + " print(f\"The iter is {itr:3d}, loss is {loss.item():3.5f}.\")\n", + "print(\"The theoretical value is -1.137283834485513.\")" ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum import qchem\n", - "from paddle_quantum.qchem.layers import CrossResonanceLayer, EulerRotationLayer\n", - "\n", - "\n", - "# Your own model should inherit from `Qmodel`.\n", - "## NOTE: THIS MODEL IS ONLY DEFINED FOR DEMONSTRATION PURPOSE! \n", - "class MyAnsatz(qchem.QModel):\n", - " def __init__(self, n_qubits):\n", - " super().__init__(n_qubits)\n", - "\n", - " self.entangle = CrossResonanceLayer(self._n_qubit)\n", - " self.rot = EulerRotationLayer(self._n_qubit)\n", - "\n", - " def forward(self, state):\n", - " self._circuit = UAnsatz(self.n_qubit)\n", - "\n", - " out = self.entangle(state)\n", - " self._circuit += self.entangle.circuit\n", - "\n", - " out = self.rot(out)\n", - " self._circuit += self.rot.circuit\n", - "\n", - " out = self.entangle(out)\n", - " self._circuit += self.entangle.circuit\n", - "\n", - " return out\n", - "\n", - "# instantiate your model\n", - "my_cir = MyAnsatz(5)" + "现在你可以把波函数模版替换为 `HardwareEfficientModel`，然后尝试比较一下使用两种方法计算出来的基态能量。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "在定义好线路之后，我们就可以利用 paddlepaddle 提供的多种优化器来优化线路中的参数以获得最佳结果。" + "## 利用Hatree Fock方法计算分子基态能量\n", + "Hartree Fock方法是量子化学中非常重要的方法。如果要利用qchem模块运行Hartree Fock方法的话，我们只需要把前面的波函数模版线路换成`RHFSlaterDeterminantModel`，并把损失函数换成`RHFEnergyLoss`（注意：使用Hartree Fock方法需要安装PySCF，`pip install -U pyscf`）。" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Overwritten attributes multiplicity of \n" + ] + } + ], "source": [ - "# use paddlepaddle's optimizer\n", - "import numpy as np \n", - "import paddle\n", - "\n", - "optimizer = paddle.optimizer.Adam(parameters=my_cir.parameters(), learning_rate=0.08)\n", + "# 构建Hartree Fock线路\n", + "n_qubits = 4\n", + "n_electrons = 2\n", + "hartreefock_ansatz = pq_qchem.RHFSlaterDeterminantModel(n_qubits, n_electrons)\n", "\n", - "# define the loss function\n", - "## NOTE: THIS LOSS FUNCTION IS ONLY DEFINED FOR DEMONSTRATION PURPOSE!\n", - "def loss_fn(state: paddle.Tensor) -> paddle.Tensor:\n", - " return paddle.norm(state.real())\n", + "# 设置Hartree Fock损失函数\n", + "loss_fn = pq_qchem.RHFEnergyLoss(h2_geometry, basis_set)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The iter is 0, loss is 0.37967.\n", + "The iter is 1, loss is 0.31168.\n", + "The iter is 2, loss is 0.22180.\n", + "The iter is 3, loss is 0.10975.\n", + "The iter is 4, loss is -0.02357.\n", + "The iter is 5, loss is -0.17552.\n", + "The iter is 6, loss is -0.34124.\n", + "The iter is 7, loss is -0.51346.\n", + "The iter is 8, loss is -0.68254.\n", + "The iter is 9, loss is -0.83712.\n", + "The iter is 10, loss is -0.96538.\n", + "The iter is 11, loss is -1.05717.\n", + "The iter is 12, loss is -1.10677.\n", + "The iter is 13, loss is -1.11545.\n", + "The iter is 14, loss is -1.09212.\n", + "The iter is 15, loss is -1.05087.\n", + "The iter is 16, loss is -1.00622.\n", + "The iter is 17, loss is -0.96914.\n", + "The iter is 18, loss is -0.94574.\n", + "The iter is 19, loss is -0.93791.\n", + "The iter is 20, loss is -0.94471.\n", + "The iter is 21, loss is -0.96343.\n", + "The iter is 22, loss is -0.99040.\n", + "The iter is 23, loss is -1.02149.\n", + "The iter is 24, loss is -1.05253.\n", + "The iter is 25, loss is -1.07977.\n", + "The iter is 26, loss is -1.10035.\n", + "The iter is 27, loss is -1.11271.\n", + "The iter is 28, loss is -1.11676.\n", + "The iter is 29, loss is -1.11378.\n", + "The iter is 30, loss is -1.10610.\n", + "The iter is 31, loss is -1.09642.\n", + "The iter is 32, loss is -1.08731.\n", + "The iter is 33, loss is -1.08072.\n", + "The iter is 34, loss is -1.07775.\n", + "The iter is 35, loss is -1.07866.\n", + "The iter is 36, loss is -1.08294.\n", + "The iter is 37, loss is -1.08958.\n", + "The iter is 38, loss is -1.09727.\n", + "The iter is 39, loss is -1.10472.\n", + "The iter is 40, loss is -1.11083.\n", + "The iter is 41, loss is -1.11488.\n", + "The iter is 42, loss is -1.11665.\n", + "The iter is 43, loss is -1.11636.\n", + "The iter is 44, loss is -1.11457.\n", + "The iter is 45, loss is -1.11207.\n", + "The iter is 46, loss is -1.10960.\n", + "The iter is 47, loss is -1.10780.\n", + "The iter is 48, loss is -1.10702.\n", + "The iter is 49, loss is -1.10736.\n", + "The iter is 50, loss is -1.10865.\n", + "The iter is 51, loss is -1.11056.\n", + "The iter is 52, loss is -1.11265.\n", + "The iter is 53, loss is -1.11454.\n", + "The iter is 54, loss is -1.11592.\n", + "The iter is 55, loss is -1.11664.\n", + "The iter is 56, loss is -1.11672.\n", + "The iter is 57, loss is -1.11630.\n", + "The iter is 58, loss is -1.11561.\n", + "The iter is 59, loss is -1.11489.\n", + "The iter is 60, loss is -1.11436.\n", + "The iter is 61, loss is -1.11412.\n", + "The iter is 62, loss is -1.11423.\n", + "The iter is 63, loss is -1.11462.\n", + "The iter is 64, loss is -1.11519.\n", + "The iter is 65, loss is -1.11579.\n", + "The iter is 66, loss is -1.11629.\n", + "The iter is 67, loss is -1.11663.\n", + "The iter is 68, loss is -1.11676.\n", + "The iter is 69, loss is -1.11670.\n", + "The iter is 70, loss is -1.11653.\n", + "The iter is 71, loss is -1.11631.\n", + "The iter is 72, loss is -1.11612.\n", + "The iter is 73, loss is -1.11601.\n", + "The iter is 74, loss is -1.11601.\n", + "The iter is 75, loss is -1.11611.\n", + "The iter is 76, loss is -1.11628.\n", + "The iter is 77, loss is -1.11646.\n", + "The iter is 78, loss is -1.11662.\n", + "The iter is 79, loss is -1.11672.\n", + "The iter is 80, loss is -1.11676.\n", + "The iter is 81, loss is -1.11674.\n", + "The iter is 82, loss is -1.11668.\n", + "The iter is 83, loss is -1.11661.\n", + "The iter is 84, loss is -1.11656.\n", + "The iter is 85, loss is -1.11653.\n", + "The iter is 86, loss is -1.11654.\n", + "The iter is 87, loss is -1.11658.\n", + "The iter is 88, loss is -1.11663.\n", + "The iter is 89, loss is -1.11669.\n", + "The iter is 90, loss is -1.11673.\n", + "The iter is 91, loss is -1.11676.\n", + "The iter is 92, loss is -1.11676.\n", + "The iter is 93, loss is -1.11674.\n", + "The iter is 94, loss is -1.11672.\n", + "The iter is 95, loss is -1.11670.\n", + "The iter is 96, loss is -1.11669.\n", + "The iter is 97, loss is -1.11669.\n", + "The iter is 98, loss is -1.11670.\n", + "The iter is 99, loss is -1.11671.\n", + "The theoretical value is -1.11675.\n" + ] + } + ], + "source": [ + "# 选择 paddlepaddle 中的 Adam 优化器\n", + "import paddle\n", "\n", - "# start learning\n", - "s0 = np.zeros((2**5,), dtype=np.complex128)\n", - "s0[0] = 1.0+0.0j\n", - "s0 = paddle.to_tensor(s0)\n", + "optimizer = paddle.optimizer.Adam(parameters=hartreefock_ansatz.parameters(), learning_rate=0.1)\n", "\n", - "for i in range(10):\n", - " loss = loss_fn(my_cir(s0))\n", - " print(f\"At {i:>d}th step: loss={loss.item():>.5f}.\")\n", + "# 制备初始量子态, e.g. |1100>\n", + "init_state = pq.state.computational_basis(n_qubits, 12)\n", "\n", - " optimizer.clear_grad()\n", + "# 定义优化步数\n", + "num_itr = 100\n", + "for itr in range(0, num_itr):\n", + " # 运行量子线路得到末态\n", + " state = hartreefock_ansatz(init_state)\n", + " # 计算损失函数，即期望值\n", + " loss = loss_fn(state)\n", + " # 反向传播梯度\n", " loss.backward()\n", - " optimizer.step()" + " # 通过loss值更新参数\n", + " optimizer.minimize(loss)\n", + " # 清除当前梯度\n", + " optimizer.clear_grad()\n", + " print(f\"The iter is {itr:3d}, loss is {loss.item():3.5f}.\")\n", + "print(\"The theoretical value is -1.11675.\")" ] }, { @@ -199,10 +420,10 @@ ], "metadata": { "interpreter": { - "hash": "385f93486cadd2f2140b6b583192a2daa18c8b591e699592075836b347373dd4" + "hash": "f7cfecff1ef1940b21a48efa1b88278bb096bd916f13c2df11af4810c38b47e1" }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.0 ('pq')", "language": "python", "name": "python3" }, @@ -216,7 +437,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.0" } }, "nbformat": 4, diff --git a/introduction/PaddleQuantum_Qchem_Tutorial_EN.ipynb b/introduction/PaddleQuantum_Qchem_Tutorial_EN.ipynb index 55af9cf..81800f5 100644 --- a/introduction/PaddleQuantum_Qchem_Tutorial_EN.ipynb +++ b/introduction/PaddleQuantum_Qchem_Tutorial_EN.ipynb @@ -14,43 +14,52 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Calculate ground state energy of a molecule\n", - "qchem provides `run_chem` function to calculate the ground state energy and ground state wave function. For example, let's try to calculate the ground state energy of hydrogen molecule. First, we need to import qchem." + "## Calculating ground state energy of a molecule\n", + "qchem provides various tools for you to do quantum chemistry calculation. Currently, qchem module supports the following molecular wave function ansatz:\n", + "* Hardware Efficient ansatz[1](#refer-1),\n", + "* Slater determinant ansatz[2](#refer-2),\n", + "* Unitary Coupled Cluster singles and doubles (UCCSD) ansatz[3](#refer-3).\n", + "\n", + "Let's start from example and try to calculate the ground state energy of hydrogen molecule. First, we need to import qchem." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ - "from paddle_quantum import qchem" + "import paddle_quantum as pq\n", + "from paddle_quantum import qchem as pq_qchem\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Then, we need to provide chemical information required by `run_chem` function, including geometry, charge, basis function etc." + "Then, we need to provide chemical information required by running quantum chemistry calculation, including geometry, charge, basis function etc." ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# define the geometry of hydrogen molecule, length unit use angstrom.\n", - "h2_geometry = [(\"H\", [0.0, 0.0, 0.0]), (\"H\", [0.0, 0.0, 0.74])]\n", - "charge = 0\n", - "basis_set = \"sto-3g\"" + "h2_geometry = \"H 0.0 0.0 0.0; H 0.0 0.0 0.74\"\n", + "basis_set = \"sto-3g\"\n", + "multiplicity = 1\n", + "charge = 0" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Next, let's choose an ansatz of many-electron wave function for our ground state energy calculation. Currently, you can choose to use \"hardware efficient\" [1](#refer-1) or \"hartree fock\" [2](#refer-2) ansatz, more functionalities will be released in the future. Let's choose \"hardware efficient\" ansatz." + "Next, we need to choose an wavefunction ansatz for our hydrogen molecule. Let's choose `UCCSDModel` as the ansatz and use `MolEnergyLoss` as the loss function. `UCCSDModel` use Trotter-Suzuki method to build its wavefunction ansatz, see [here](https://qml.baidu.com/tutorials/quantum-simulation/hamiltonian-simulation-with-product-formula.html) if you want to know more about Trotter-Suzuki method." ] }, { @@ -59,128 +68,336 @@ "metadata": {}, "outputs": [], "source": [ - "# call run_chem function with \"hardware efficient\" ansatz.\n", - "h2_gs_en, h2_wf_model = qchem.run_chem(\n", - " h2_geometry,\n", - " \"hardware efficient\",\n", - " basis_set, \n", - " charge\n", - ")\n", + "# Build UCCSD ansatz.\n", + "n_qubits = 4\n", + "n_electrons = 2\n", + "uccsd_ansatz = pq_qchem.UCCSDModel(n_qubits, n_electrons, n_trotter_steps=3)\n", "\n", - "# additional information for optimizer can be passed using `optimizer_option` keyword argument.\n", - "h2_gs_en, h2_wf_model = qchem.run_chem(\n", - " h2_geometry,\n", - " \"hardware efficient\",\n", - " basis_set, \n", - " charge,\n", - " optimizer_option={\"learning_rate\": 0.6, \"weight_decay\": 0.9}\n", - ")\n", - "\n", - "# additional information for ansatz can be passed using `ansatz_option` keyword argument, e.g.\n", - "# \"hardware efficient\" ansatz has a parameter \"cir_depth\", which can be used to specify the depth\n", - "# of quantum circuit.\n", - "h2_gs_en, h2_wf_model = qchem.run_chem(\n", - " h2_geometry,\n", - " \"hardware efficient\",\n", - " basis_set, \n", - " charge,\n", - " ansatz_option={\"cir_depth\": 5}\n", - ")" + "# Setup the loss function\n", + "loss_fn = pq_qchem.MolEnergyLoss(h2_geometry, basis_set)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "You can also specify `max_iters` and `a_tol` keyword arguments to control the maximum iteration cycles and convergence criteria of the optimization process. \n", + "Finally, you can follow the optimization procedure [here](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html) and use any paddlepaddle optimizer to train the ansatz you have built." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The iter is 0, loss is 0.71510.\n", + "The iter is 1, loss is 0.68522.\n", + "The iter is 2, loss is -0.33124.\n", + "The iter is 3, loss is -0.17871.\n", + "The iter is 4, loss is -0.46901.\n", + "The iter is 5, loss is -0.35388.\n", + "The iter is 6, loss is -0.49272.\n", + "The iter is 7, loss is -0.65490.\n", + "The iter is 8, loss is -0.74100.\n", + "The iter is 9, loss is -0.75261.\n", + "The iter is 10, loss is -0.91565.\n", + "The iter is 11, loss is -1.00675.\n", + "The iter is 12, loss is -0.86924.\n", + "The iter is 13, loss is -0.91493.\n", + "The iter is 14, loss is -1.00358.\n", + "The iter is 15, loss is -0.97359.\n", + "The iter is 16, loss is -0.99694.\n", + "The iter is 17, loss is -1.05768.\n", + "The iter is 18, loss is -1.07174.\n", + "The iter is 19, loss is -1.05568.\n", + "The iter is 20, loss is -1.05740.\n", + "The iter is 21, loss is -1.06293.\n", + "The iter is 22, loss is -1.06410.\n", + "The iter is 23, loss is -1.08027.\n", + "The iter is 24, loss is -1.07894.\n", + "The iter is 25, loss is -1.09911.\n", + "The iter is 26, loss is -1.09829.\n", + "The iter is 27, loss is -1.09884.\n", + "The iter is 28, loss is -1.10620.\n", + "The iter is 29, loss is -1.11663.\n", + "The iter is 30, loss is -1.10698.\n", + "The iter is 31, loss is -1.10733.\n", + "The iter is 32, loss is -1.11066.\n", + "The iter is 33, loss is -1.11710.\n", + "The iter is 34, loss is -1.11634.\n", + "The iter is 35, loss is -1.12369.\n", + "The iter is 36, loss is -1.12732.\n", + "The iter is 37, loss is -1.11927.\n", + "The iter is 38, loss is -1.12664.\n", + "The iter is 39, loss is -1.12917.\n", + "The iter is 40, loss is -1.12288.\n", + "The iter is 41, loss is -1.12396.\n", + "The iter is 42, loss is -1.13229.\n", + "The iter is 43, loss is -1.13172.\n", + "The iter is 44, loss is -1.12766.\n", + "The iter is 45, loss is -1.13348.\n", + "The iter is 46, loss is -1.13214.\n", + "The iter is 47, loss is -1.13093.\n", + "The iter is 48, loss is -1.13300.\n", + "The iter is 49, loss is -1.13404.\n", + "The iter is 50, loss is -1.13151.\n", + "The iter is 51, loss is -1.13338.\n", + "The iter is 52, loss is -1.13581.\n", + "The iter is 53, loss is -1.13447.\n", + "The iter is 54, loss is -1.13422.\n", + "The iter is 55, loss is -1.13551.\n", + "The iter is 56, loss is -1.13554.\n", + "The iter is 57, loss is -1.13492.\n", + "The iter is 58, loss is -1.13543.\n", + "The iter is 59, loss is -1.13569.\n", + "The iter is 60, loss is -1.13606.\n", + "The iter is 61, loss is -1.13590.\n", + "The iter is 62, loss is -1.13651.\n", + "The iter is 63, loss is -1.13620.\n", + "The iter is 64, loss is -1.13619.\n", + "The iter is 65, loss is -1.13652.\n", + "The iter is 66, loss is -1.13650.\n", + "The iter is 67, loss is -1.13633.\n", + "The iter is 68, loss is -1.13683.\n", + "The iter is 69, loss is -1.13688.\n", + "The iter is 70, loss is -1.13674.\n", + "The iter is 71, loss is -1.13682.\n", + "The iter is 72, loss is -1.13688.\n", + "The iter is 73, loss is -1.13673.\n", + "The iter is 74, loss is -1.13705.\n", + "The iter is 75, loss is -1.13694.\n", + "The iter is 76, loss is -1.13698.\n", + "The iter is 77, loss is -1.13711.\n", + "The iter is 78, loss is -1.13707.\n", + "The iter is 79, loss is -1.13706.\n", + "The iter is 80, loss is -1.13707.\n", + "The iter is 81, loss is -1.13709.\n", + "The iter is 82, loss is -1.13717.\n", + "The iter is 83, loss is -1.13711.\n", + "The iter is 84, loss is -1.13714.\n", + "The iter is 85, loss is -1.13723.\n", + "The iter is 86, loss is -1.13714.\n", + "The iter is 87, loss is -1.13719.\n", + "The iter is 88, loss is -1.13721.\n", + "The iter is 89, loss is -1.13718.\n", + "The iter is 90, loss is -1.13723.\n", + "The iter is 91, loss is -1.13721.\n", + "The iter is 92, loss is -1.13722.\n", + "The iter is 93, loss is -1.13725.\n", + "The iter is 94, loss is -1.13723.\n", + "The iter is 95, loss is -1.13722.\n", + "The iter is 96, loss is -1.13724.\n", + "The iter is 97, loss is -1.13725.\n", + "The iter is 98, loss is -1.13725.\n", + "The iter is 99, loss is -1.13726.\n", + "The theoretical value is -1.137283834485513.\n" + ] + } + ], + "source": [ + "# use paddlepaddle's optimizer\n", + "import paddle\n", + "\n", + "optimizer = paddle.optimizer.Adam(parameters=uccsd_ansatz.parameters(), learning_rate=0.1)\n", "\n", - "To try another ansatz, you just need to replace the ansatz argument to, e.g. \"hartree fock\", and run similar command.\n", + "# prepare the initial quantum state, e.g. |0000>\n", + "init_state = pq.state.computational_basis(n_qubits, 0)\n", "\n", - "To see the quantum circuit for hydrogen molecule's hardware efficient ansatz, you can run `print(h2_wf_model.circuit)`." + "# define the optimization steps\n", + "num_itr = 100\n", + "for itr in range(0, num_itr):\n", + " # run quantum circuit to arrive at the final state\n", + " state = uccsd_ansatz(init_state)\n", + " # calculate loss\n", + " loss = loss_fn(state)\n", + " # backpropagate the gradient\n", + " loss.backward()\n", + " # update the ansatz's parameter\n", + " optimizer.minimize(loss)\n", + " # clear current gradient\n", + " optimizer.clear_grad()\n", + " print(f\"The iter is {itr:3d}, loss is {loss.item():3.5f}.\")\n", + "print(\"The theoretical value is -1.137283834485513.\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Design your own ansatz\n", - "For those who want to try an ansatz that isn't currently included in qchem, we provide method to write your own ansatz. Writing your own ansatz is similar to defining an neural network in paddlepaddle, except that your ansatz should inherit from `Qmodel`." + "You can now change the ansatz to `HardwareEfficientModel` and compare its energy with the one you just obtained." ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum import qchem\n", - "from paddle_quantum.qchem.layers import CrossResonanceLayer, EulerRotationLayer\n", - "\n", - "\n", - "# Your own model should inherit from `Qmodel`.\n", - "## NOTE: THIS MODEL IS ONLY DEFINED FOR DEMONSTRATION PURPOSE! \n", - "class MyAnsatz(qchem.QModel):\n", - " def __init__(self, n_qubits):\n", - " super().__init__(n_qubits)\n", - "\n", - " self.entangle = CrossResonanceLayer(self._n_qubit)\n", - " self.rot = EulerRotationLayer(self._n_qubit)\n", - "\n", - " def forward(self, state):\n", - " self._circuit = UAnsatz(self.n_qubit)\n", - "\n", - " out = self.entangle(state)\n", - " self._circuit += self.entangle.circuit\n", - "\n", - " out = self.rot(out)\n", - " self._circuit += self.rot.circuit\n", - "\n", - " out = self.entangle(out)\n", - " self._circuit += self.entangle.circuit\n", - "\n", - " return out\n", - "\n", - "# instantiate your model\n", - "my_cir = MyAnsatz(5)" + "## Calculating the ground state energy using Hartree Fock method\n", + "Hartree Fock method is often considered as the starting point for more accurate quantum chemistry calculations. In order to run Hartree Fock calculation in qchem, you just need to replace the ansatz and the loss function to `RHFSlaterDeterminantModel` and `RHFEnergyLoss` (**NOTE: You need PySCF be installed before running Hartree Fock calculation**, `pip install -U pyscf`)." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 6, "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Overwritten attributes multiplicity of \n" + ] + } + ], "source": [ - "You can then follow the optimization procedure [here](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html) and use any paddlepaddle optimizer to train the ansatz you have built." + "# Build a Hartree Fock ansatz.\n", + "n_qubits = 4\n", + "n_electrons = 2\n", + "hartreefock_ansatz = pq_qchem.RHFSlaterDeterminantModel(n_qubits, n_electrons)\n", + "\n", + "# Setup the loss function\n", + "loss_fn = pq_qchem.RHFEnergyLoss(h2_geometry, basis_set)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The iter is 0, loss is 0.34341.\n", + "The iter is 1, loss is 0.26274.\n", + "The iter is 2, loss is 0.15970.\n", + "The iter is 3, loss is 0.03472.\n", + "The iter is 4, loss is -0.11024.\n", + "The iter is 5, loss is -0.27116.\n", + "The iter is 6, loss is -0.44170.\n", + "The iter is 7, loss is -0.61316.\n", + "The iter is 8, loss is -0.77486.\n", + "The iter is 9, loss is -0.91509.\n", + "The iter is 10, loss is -1.02291.\n", + "The iter is 11, loss is -1.09057.\n", + "The iter is 12, loss is -1.11626.\n", + "The iter is 13, loss is -1.10573.\n", + "The iter is 14, loss is -1.07116.\n", + "The iter is 15, loss is -1.02724.\n", + "The iter is 16, loss is -0.98662.\n", + "The iter is 17, loss is -0.95737.\n", + "The iter is 18, loss is -0.94303.\n", + "The iter is 19, loss is -0.94371.\n", + "The iter is 20, loss is -0.95742.\n", + "The iter is 21, loss is -0.98086.\n", + "The iter is 22, loss is -1.01012.\n", + "The iter is 23, loss is -1.04104.\n", + "The iter is 24, loss is -1.06973.\n", + "The iter is 25, loss is -1.09296.\n", + "The iter is 26, loss is -1.10862.\n", + "The iter is 27, loss is -1.11600.\n", + "The iter is 28, loss is -1.11581.\n", + "The iter is 29, loss is -1.10996.\n", + "The iter is 30, loss is -1.10099.\n", + "The iter is 31, loss is -1.09156.\n", + "The iter is 32, loss is -1.08386.\n", + "The iter is 33, loss is -1.07934.\n", + "The iter is 34, loss is -1.07862.\n", + "The iter is 35, loss is -1.08148.\n", + "The iter is 36, loss is -1.08713.\n", + "The iter is 37, loss is -1.09438.\n", + "The iter is 38, loss is -1.10193.\n", + "The iter is 39, loss is -1.10859.\n", + "The iter is 40, loss is -1.11348.\n", + "The iter is 41, loss is -1.11618.\n", + "The iter is 42, loss is -1.11671.\n", + "The iter is 43, loss is -1.11550.\n", + "The iter is 44, loss is -1.11325.\n", + "The iter is 45, loss is -1.11073.\n", + "The iter is 46, loss is -1.10863.\n", + "The iter is 47, loss is -1.10741.\n", + "The iter is 48, loss is -1.10728.\n", + "The iter is 49, loss is -1.10818.\n", + "The iter is 50, loss is -1.10983.\n", + "The iter is 51, loss is -1.11186.\n", + "The iter is 52, loss is -1.11384.\n", + "The iter is 53, loss is -1.11543.\n", + "The iter is 54, loss is -1.11642.\n", + "The iter is 55, loss is -1.11676.\n", + "The iter is 56, loss is -1.11653.\n", + "The iter is 57, loss is -1.11594.\n", + "The iter is 58, loss is -1.11521.\n", + "The iter is 59, loss is -1.11459.\n", + "The iter is 60, loss is -1.11423.\n", + "The iter is 61, loss is -1.11419.\n", + "The iter is 62, loss is -1.11447.\n", + "The iter is 63, loss is -1.11497.\n", + "The iter is 64, loss is -1.11556.\n", + "The iter is 65, loss is -1.11611.\n", + "The iter is 66, loss is -1.11652.\n", + "The iter is 67, loss is -1.11673.\n", + "The iter is 68, loss is -1.11674.\n", + "The iter is 69, loss is -1.11661.\n", + "The iter is 70, loss is -1.11640.\n", + "The iter is 71, loss is -1.11620.\n", + "The iter is 72, loss is -1.11605.\n", + "The iter is 73, loss is -1.11601.\n", + "The iter is 74, loss is -1.11608.\n", + "The iter is 75, loss is -1.11622.\n", + "The iter is 76, loss is -1.11639.\n", + "The iter is 77, loss is -1.11656.\n", + "The iter is 78, loss is -1.11669.\n", + "The iter is 79, loss is -1.11675.\n", + "The iter is 80, loss is -1.11675.\n", + "The iter is 81, loss is -1.11671.\n", + "The iter is 82, loss is -1.11664.\n", + "The iter is 83, loss is -1.11658.\n", + "The iter is 84, loss is -1.11654.\n", + "The iter is 85, loss is -1.11654.\n", + "The iter is 86, loss is -1.11656.\n", + "The iter is 87, loss is -1.11661.\n", + "The iter is 88, loss is -1.11667.\n", + "The iter is 89, loss is -1.11672.\n", + "The iter is 90, loss is -1.11675.\n", + "The iter is 91, loss is -1.11676.\n", + "The iter is 92, loss is -1.11675.\n", + "The iter is 93, loss is -1.11673.\n", + "The iter is 94, loss is -1.11671.\n", + "The iter is 95, loss is -1.11669.\n", + "The iter is 96, loss is -1.11669.\n", + "The iter is 97, loss is -1.11669.\n", + "The iter is 98, loss is -1.11671.\n", + "The iter is 99, loss is -1.11673.\n", + "The theoretical value is -1.11675.\n" + ] + } + ], "source": [ "# use paddlepaddle's optimizer\n", - "import numpy as np \n", "import paddle\n", "\n", - "optimizer = paddle.optimizer.Adam(parameters=my_cir.parameters(), learning_rate=0.08)\n", - "\n", - "# define the loss function\n", - "## NOTE: THIS LOSS FUNCTION IS ONLY DEFINED FOR DEMONSTRATION PURPOSE!\n", - "def loss_fn(state: paddle.Tensor) -> paddle.Tensor:\n", - " return paddle.norm(state.real())\n", + "optimizer = paddle.optimizer.Adam(parameters=hartreefock_ansatz.parameters(), learning_rate=0.1)\n", "\n", - "# start learning\n", - "s0 = np.zeros((2**5,), dtype=np.complex128)\n", - "s0[0] = 1.0+0.0j\n", - "s0 = paddle.to_tensor(s0)\n", + "# prepare the initial quantum state, e.g. |1100>\n", + "init_state = pq.state.computational_basis(n_qubits, 12)\n", "\n", - "for i in range(10):\n", - " loss = loss_fn(my_cir(s0))\n", - " print(f\"At {i:>d}th step: loss={loss.item():>.5f}.\")\n", - "\n", - " optimizer.clear_grad()\n", + "# define the optimization steps\n", + "num_itr = 100\n", + "for itr in range(0, num_itr):\n", + " # run quantum circuit to arrive at the final state\n", + " state = hartreefock_ansatz(init_state)\n", + " # calculate loss\n", + " loss = loss_fn(state)\n", + " # backpropagate the gradient\n", " loss.backward()\n", - " optimizer.step()" + " # update the ansatz's parameter\n", + " optimizer.minimize(loss)\n", + " # clear current gradient\n", + " optimizer.clear_grad()\n", + " print(f\"The iter is {itr:3d}, loss is {loss.item():3.5f}.\")\n", + "print(\"The theoretical value is -1.11675.\")" ] }, { @@ -192,16 +409,18 @@ "\n", "[1] Kandala, Abhinav, et al. \"Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets.\" [Nature 549.7671 (2017): 242-246.](https://www.nature.com/articles/nature23879)\n", "\n", - "[2] Arute, Frank, et al. \"Hartree-Fock on a superconducting qubit quantum computer.\" [Science 369.6507 (2020): 1084-1089.](https://www.science.org/doi/10.1126/science.abb9811)" + "[2] Arute, Frank, et al. \"Hartree-Fock on a superconducting qubit quantum computer.\" [Science 369.6507 (2020): 1084-1089.](https://www.science.org/doi/10.1126/science.abb9811)\n", + "\n", + "[3] Abhinav, Aspuru-Guzik, et al. \"A Quantum Computing View on Unitary Coupled Cluster Theory\" (https://arxiv.org/abs/2109.15176)" ] } ], "metadata": { "interpreter": { - "hash": "7b343e878babc25549085ff27e754b596ec1b81bbbd70d50b28da4f6023d5bd9" + "hash": "f7cfecff1ef1940b21a48efa1b88278bb096bd916f13c2df11af4810c38b47e1" }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.0 ('pq')", "language": "python", "name": "python3" }, @@ -215,7 +434,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.0" } }, "nbformat": 4, diff --git a/introduction/PaddleQuantum_Tutorial_CN.ipynb b/introduction/PaddleQuantum_Tutorial_CN.ipynb index 77baa63..45c5123 100644 --- a/introduction/PaddleQuantum_Tutorial_CN.ipynb +++ b/introduction/PaddleQuantum_Tutorial_CN.ipynb @@ -31,9 +31,9 @@ "- 飞桨（PaddlePaddle）优化器的使用教程\n", "- 具体的量子机器学习案例—— 变分量子本征求解器（VQE）\n", "\n", - "最后修改于: 2021年12月3日 由量桨 Paddle Quantum 开发小组共同完成。\n", + "最后修改于: 2022年5月16日 由量桨 Paddle Quantum 开发小组共同完成。\n", "\n", - "
" + "---" ] }, { @@ -70,7 +70,7 @@ " \n", "\n", "\n", - "
" + "---" ] }, { @@ -126,7 +126,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:18:51.118039Z", @@ -137,11 +137,15 @@ "source": [ "import numpy as np\n", "import paddle\n", + "import paddle_quantum\n", "from paddle import matmul, transpose, trace\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import dagger, random_pauli_str_generator, pauli_str_to_matrix\n", - "from paddle_quantum.utils import plot_state_in_bloch_sphere, plot_rotation_in_bloch_sphere\n", - "from paddle_quantum.state import vec, vec_random, density_op, density_op_random" + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.state import State\n", + "from paddle_quantum.linalg import dagger\n", + "from paddle_quantum.qinfo import random_pauli_str_generator, pauli_str_to_matrix\n", + "from paddle_quantum.visual import plot_state_in_bloch_sphere, plot_rotation_in_bloch_sphere\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" ] }, { @@ -265,19 +269,19 @@ "source": [ "### 示例: 如何在布洛赫球面上展示自己创造的单比特量子态？\n", "\n", - "我们以随机酉门的输出态为例，展示如何使用量桨内置函数绘制布洛赫球面。在这个例子中，我们使用随机的旋转角度来构造随机的酉算子，让初始化的量子线路通过这个酉算子，便可以得到量子线路的末态，这个末态就是一个随机的量子态。这样重复采样多次，生成一个量子态的列表，并采用量桨里 `utils` 包的函数将他们输入到布洛赫球面空间中，便可以实现对单比特量子态在布洛赫球面上的展示。\n", + "我们以随机酉门的输出态为例，展示如何使用量桨内置函数绘制布洛赫球面。在这个例子中，我们使用随机的旋转角度来构造随机的酉算子，让初始化的量子线路通过这个酉算子，便可以得到量子线路的末态，这个末态就是一个随机的量子态。这样重复采样多次，生成一个量子态的列表，并采用量桨里 `visual` 包的函数将他们输入到布洛赫球面空间中，便可以实现对单比特量子态在布洛赫球面上的展示。\n", "\n", "具体代码如下：" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -294,28 +298,29 @@ "# 采样的次数\n", "num_samples = 15\n", "# 存储采样得到的量子态\n", - "state = []\n", + "states = []\n", "\n", "for i in range(num_samples):\n", " \n", " # 创建单比特量子的线路\n", - " cir = UAnsatz(1)\n", + " cir = Circuit(1)\n", + "\n", " # 生成随机的旋转角度\n", " phi, theta, omega = 2 * np.pi * np.random.uniform(size=3)\n", - " phi = paddle.to_tensor(phi, dtype='float64')\n", - " theta = paddle.to_tensor(theta, dtype='float64')\n", - " omega = paddle.to_tensor(omega, dtype='float64')\n", " \n", " # 对单比特量子态做随机的旋转操作\n", - " cir.rz(phi, 0)\n", - " cir.ry(theta, 0)\n", - " cir.rz(omega, 0)\n", + " cir.rz(0, param=phi)\n", + " cir.ry(0, param=theta)\n", + " cir.rz(0, param=omega)\n", + " \n", + " # 运行电路\n", + " state = cir()\n", " \n", " # 将线路的末态存储起来\n", - " state.append(cir.run_state_vector())\n", + " states.append(state.data)\n", "\n", "# 调用布洛赫球面展示功能，输入state参数，并且展示向量\n", - "plot_state_in_bloch_sphere(state, show_arrow=True)" + "plot_state_in_bloch_sphere(states, show_arrow=True)" ] }, { @@ -331,7 +336,7 @@ "source": [ "量桨中对布洛赫球面的刻画有着丰富的功能，能够提供不同角度，不同视角距离的布洛赫球面展示。并且支持动态 gif 图的存储，方便学者们理解和学习。\n", "\n", - "调用更加丰富的布洛赫球面功能请参考 `utils.plot_state_in_bloch_sphere()` 函数 API。" + "调用更加丰富的布洛赫球面功能请参考 `visual.plot_state_in_bloch_sphere()` 函数 API。" ] }, { @@ -344,21 +349,21 @@ "\n", "假设我们把一个从 $|0\\rangle$ 态经过了 $R_y(\\frac{\\pi}{4})$ 旋转门、$R_z(\\frac{\\pi}{2})$ 旋转门之后得到状态作为量子态的初始状态，把 $U3(\\theta = \\frac{\\pi}{2}, \\phi = \\frac{7\\pi}{8}, \\lambda = 2\\pi)$ 旋转门作为即将要做的酉算子操作，想用布洛赫球面来清晰地刻画这个酉算子操作的过程，需要如何做呢？\n", "\n", - "在量桨中，我们可以把对单比特量子所做的酉算子操作，在布洛赫球面上通过生动形象的\"转动轨迹\"来展示。同样地，我们采用量桨里 `utils` 包的函数，通过输入量子态的初始状态 `init_state` 和 $U3$ 旋转门的角度，便可以实现这一效果。\n", + "在量桨中，我们可以把对单比特量子所做的酉算子操作，在布洛赫球面上通过生动形象的\"转动轨迹\"来展示。同样地，我们采用量桨里 `visual` 包的函数，通过输入量子态的初始状态 `init_state` 和 $U3$ 旋转门的角度，便可以实现这一效果。\n", "\n", "具体代码如下：" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "scrolled": false }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -371,12 +376,12 @@ ], "source": [ "# 创建单比特量子的线路\n", - "cir = UAnsatz(1)\n", + "cir = Circuit(1)\n", "\n", "# 设置量子态的初始状态\n", - "cir.ry(paddle.to_tensor(np.pi/4, dtype=\"float64\"), 0)\n", - "cir.rz(paddle.to_tensor(np.pi/2, dtype=\"float64\"), 0)\n", - "init_state = cir.run_density_matrix()\n", + "cir.ry(0, param=np.pi/4)\n", + "cir.rz(0, param=np.pi/2)\n", + "init_state = cir()\n", "\n", "# 将要进行的酉算子操作\n", "theta = np.pi/2\n", @@ -401,7 +406,7 @@ "source": [ "量桨中对布洛赫球面的\"轨迹\"刻画同样有着丰富的功能，能够提供不同角度，不同视角距离的布洛赫球面展示。并且支持动态 gif 图的存储，方便学者们理解和学习。\n", "\n", - "调用更加丰富的布洛赫球面功能请参考 `utils.plot_rotation_in_bloch_sphere()` 函数 API。" + "调用更加丰富的布洛赫球面功能请参考 `visual.plot_rotation_in_bloch_sphere()` 函数 API。" ] }, { @@ -606,7 +611,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:19:01.589007Z", @@ -619,32 +624,28 @@ "output_type": "stream", "text": [ "量子门的矩阵表达式为：\n", - "[[ 6.123234e-17+0.j -6.123234e-17-1.j]\n", - " [ 6.123234e-17-1.j 6.123234e-17+0.j]]\n" + "[[-4.371139e-08+0.j 0.000000e+00-1.j]\n", + " [ 0.000000e+00-1.j -4.371139e-08+0.j]]\n" ] } ], "source": [ "# 设置角度参数 theta = pi\n", - "theta = np.array([np.pi])\n", - " \n", - "# 我们需要将 Numpy array 转换成 Paddle 中的 Tensor\n", - "theta = paddle.to_tensor(theta)\n", + "theta = np.pi\n", "\n", "# 设置计算所需的量子比特数量\n", "num_qubits = 1\n", "\n", - "# 初始化我们的单比特量子电路\n", - "cir = UAnsatz(num_qubits)\n", + "# 初始化单比特量子电路\n", + "cir = Circuit(num_qubits)\n", "\n", "# 在第一个量子比特(第0号量子比特)的位置上施加一个 Rx 旋转门， 角度为 pi\n", - "which_qubit = 0\n", - "cir.rx(theta, which_qubit)\n", + "cir.rx(0, param=theta)\n", "\n", "# 打印出这个量子门\n", "# 转换成 numpy \n", "print('量子门的矩阵表达式为：')\n", - "print(cir.U.numpy())" + "print(cir.unitary_matrix().numpy())" ] }, { @@ -673,17 +674,16 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "theta = \"your code\"\n", " \n", - "theta = paddle.to_tensor(theta)\n", "num_qubits = 1\n", - "cir = UAnsatz(\"your code\")\n", + "cir = Circuit(\"your code\")\n", "cir.ry(\"your code\")\n", - "print(cir.U.numpy())" + "print(cir.unitary_matrix().numpy())" ] }, { @@ -740,7 +740,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:19:07.433031Z", @@ -753,37 +753,38 @@ "output_type": "stream", "text": [ "图中量子神经网络 U(theta=pi) 的矩阵表达式是:\n", - "[[ 0.0000000e+00 -1.0000000e+00 6.1232340e-17 -6.1232340e-17]\n", - " [-1.0000000e+00 0.0000000e+00 -6.1232340e-17 6.1232340e-17]\n", - " [-6.1232340e-17 6.1232340e-17 1.0000000e+00 1.2246468e-16]\n", - " [ 6.1232340e-17 -6.1232340e-17 -1.2246468e-16 1.0000000e+00]]\n" + "[[-3.5527137e-15 -1.0000000e+00 -4.3711388e-08 4.3711395e-08]\n", + " [-1.0000000e+00 -3.5527137e-15 4.3711381e-08 -4.3711388e-08]\n", + " [ 4.3711388e-08 -4.3711395e-08 1.0000000e+00 -8.7422777e-08]\n", + " [-4.3711381e-08 4.3711388e-08 8.7422777e-08 1.0000000e+00]]\n" ] } ], "source": [ + "import numpy as np\n", + "import paddle\n", + "from paddle_quantum.ansatz import Circuit\n", + "\n", "# 设置角度参数 theta \n", "theta = np.full([4], np.pi)\n", - " \n", - "# 我们需要将 Numpy array 转换成 Paddle 中的 Tensor\n", - "theta = paddle.to_tensor(theta)\n", "\n", "# 初始化量子电路\n", "num_qubits = 2\n", - "cir = UAnsatz(num_qubits)\n", + "cir = Circuit(num_qubits)\n", "\n", "# 添加单比特旋转门\n", - "cir.ry(theta[0], 0)\n", - "cir.ry(theta[1], 1)\n", + "cir.ry(0, param=theta[0])\n", + "cir.ry(1, param=theta[1])\n", "\n", "# 添加两比特门\n", "cir.cnot([0, 1])\n", "\n", "# 添加单比特旋转门\n", - "cir.ry(theta[2], 0)\n", - "cir.ry(theta[3], 1)\n", + "cir.ry(0, param=theta[2])\n", + "cir.ry(1, param=theta[3])\n", "\n", "print('图中量子神经网络 U(theta=pi) 的矩阵表达式是:')\n", - "print(cir.U.numpy().real)" + "print(cir.unitary_matrix().numpy().real)" ] }, { @@ -813,7 +814,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:19:17.518832Z", @@ -824,21 +825,19 @@ "source": [ "theta = np.full([6], np.pi)\n", " \n", - "theta = paddle.to_tensor(theta)\n", - "\n", "num_qubits = 3\n", - "cir = UAnsatz(num_qubits) \n", + "cir = Circuit(num_qubits) \n", "\n", - "cir.ry(theta[0], 0)\n", - "cir.ry(theta[1], 1)\n", - "cir.ry(theta[2], 2)\n", + "cir.ry(0, param=theta[0])\n", + "cir.ry(1, param=theta[1])\n", + "cir.ry(2, param=theta[2])\n", "\n", "cir.cnot([0, 1])\n", "cir.cnot([1, 2])\n", "\n", - "cir.ry(theta[3], 0)\n", - "cir.ry(theta[4], 1)\n", - "cir.ry(theta[5], 2)" + "cir.ry(0, param=theta[3])\n", + "cir.ry(1, param=theta[4])\n", + "cir.ry(2, param=theta[5])" ] }, { @@ -864,7 +863,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -900,7 +899,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:53:12.042782Z", @@ -910,7 +909,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEPCAYAAABY9lNGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAbyklEQVR4nO3de5wdZZ3n8c83CQTkJmBEJdEwEnWCCKMR2fEyCoLwGgUcgwZQwUHjrDLKS2ecMDoI6O6IN9QlOMZFRFwJiLesRNAFGXdQMAlyMUCkhQSCMjZ3kAUMfPePqoaT09Wnqzt9Th063/frdV459TxV53zTf/Sv63mqnpJtIiIi2k1pOkBERPSnFIiIiKiUAhEREZVSICIiolIKREREVJrWdICJ8oxnPMOzZ89uOkZExFPKqlWr7rQ9o6pv0hSI2bNns3LlyqZjREQ8pUhaN1JfhpgiIqJSCkRERFRKgYiIiEopEBERUSkFIiIiKqVAREREpRSIiIiolAIRERGVUiAiIqLSpLmTelPNXnRhY9+99lN/3bE/2aol2/gk2/g8lbONV84gIiKiUgpERERUSoGIiIhKKRAREVGpqwVC0kGS1kgakLSoov81kq6StEHS/Jb2vSX9QtJqSddKels3c0ZExHBdKxCSpgKLgYOBucARkua27XYrcAzwrbb2h4B32t4DOAj4gqSndytrREQM183LXPcBBmzfDCBpKXAocP3QDrbXln2Ptx5o+zct738n6Q/ADODeLuaNiIgW3Rxi2hW4rWV7fdk2JpL2AbYEflvRt1DSSkkrBwcHxx00IiKG6+tJaknPBs4B3mX78fZ+20tsz7M9b8aMykeqRkTEOHWzQNwOzGrZnlm21SJpe+BC4KO2r5jgbBERMYpuFogVwBxJu0naElgALKtzYLn/94Bv2L6gixkjImIEXSsQtjcAxwEXAzcA59teLekUSYcASHq5pPXA4cBXJK0uD38r8BrgGElXl6+9u5U1IiKG6+pifbaXA8vb2k5seb+CYuip/bhvAt/sZraIiOisryepIyKiOSkQERFRKQUiIiIqpUBERESlFIiIiKiUAhEREZVSICIiolIKREREVEqBiIiISikQERFRKQUiIiIqpUBERESlFIiIiKiUAhEREZVSICIiolIKREREVEqBiIiISikQERFRKQUiIiIqpUBERESlFIiIiKiUAhEREZVSICIiolIKREREVOpqgZB0kKQ1kgYkLarof42kqyRtkDS/re9oSTeVr6O7mTMiIobrWoGQNBVYDBwMzAWOkDS3bbdbgWOAb7UduxPwceAVwD7AxyXt2K2sERExXDfPIPYBBmzfbPtRYClwaOsOttfavhZ4vO3YNwA/sX237XuAnwAHdTFrRES06WaB2BW4rWV7fdk2YcdKWihppaSVg4OD4w4aERHDPaUnqW0vsT3P9rwZM2Y0HSciYlIZtUBIeqWkbcr3b5f0eUnPq/HZtwOzWrZnlm11bMqxERExAeqcQXwZeEjSXsCHgd8C36hx3ApgjqTdJG0JLACW1cx1MXCgpB3LyekDy7aIiOiROgVig21TTDCfbnsxsN1oB9neABxH8Yv9BuB826slnSLpEABJL5e0Hjgc+Iqk1eWxdwOfoCgyK4BTyraIiOiRaTX2eUDSCcA7gFdLmgJsUefDbS8Hlre1ndjyfgXF8FHVsV8DvlbneyIiYuLVOYN4G/AI8Le276D4hf6ZrqaKiIjGjVogyqLwHWB62XQn8L1uhoqIiObVuYrpPcAFwFfKpl2B73cxU0RE9IE6Q0zvB14J3A9g+ybgmd0MFRERzatTIB4pl8oAQNI0wN2LFBER/aBOgfh3Sf8MbC3pAODbwP/ubqyIiGhanQKxCBgErgPeS3HZ6se6GSoiIpo36n0Qth8Hvlq+IiJiMzFigZB0vu23SrqOijkH2y/parKIiGhUpzOID5b/vrEXQSIior+MOAdh+/fl2/fZXtf6At7Xm3gREdGUOpPUB1S0HTzRQSIior90moP4rxRnCn8m6dqWru2Ay7sdLCIimtVpDuJbwI+Af6W41HXIA1l6OyJi8utUIGx7raT3t3dI2ilFIiJichvtDOKNwCqKy1zV0mfgz7qYKyIiGjZigbD9xvLf3XoXJyIi+kWnSeqXdjrQ9lUTHyciIvpFpyGmz3XoM7DfBGeJiIg+0mmI6XW9DBIREf2l0xDTfrYvlfQ3Vf22v9u9WBER0bROQ0x/BVwKvKmiz0AKRETEJNZpiOnj5b/v6l2ciIjoF6OuxSRpZ0lfknSVpFWSvihp516Ei4iI5tRZrG8pxRPl3gLML9+fV+fDJR0kaY2kAUmLKvqnSzqv7L9S0uyyfQtJZ0u6TtINkk6o/T+KiIgJUadAPNv2J2zfUr4+Cewy2kGSpgKLKVZ+nQscIWlu227HAvfY3h04DTi1bD8cmG57T+BlwHuHikdERPRGnQLxY0kLJE0pX28FLq5x3D7AgO2bbT9KcSZyaNs+hwJnl+8vAPaXJIpJ8G0kTQO2Bh4F7q/xnRERMUFGLBCSHpB0P/AeinWZHi1fS4GFNT57V+C2lu31ZVvlPrY3APcBO1MUiz8CvwduBT5btTigpIWSVkpaOTg4WCNSRETU1emJctvZ3r78d4rtaeVriu3tu5xrH+Ax4DnAbsCHJQ1bHND2EtvzbM+bMWNGlyNFRGxeOt0H8QRJOwJzgK2G2mz/bJTDbgdmtWzPLNuq9llfDiftANwFHAlcZPtPwB8kXQ7MA26ukzciIjZdnctc3w38jGLe4eTy35NqfPYKYI6k3SRtCSwAlrXtsww4unw/H7jUtimGlfYrv38bYF/gxhrfGRERE6TOJPUHgZcD68r1mf4CuHe0g8o5heMoCsoNwPm2V0s6RdIh5W5nAjtLGgA+xJNPrlsMbCtpNUWhOcv2tURERM/UGWJ62PbDkpA03faNkl5Y58NtLweWt7Wd2PL+YYpLWtuPe7CqPSIieqdOgVgv6enA94GfSLoHWNfNUBER0bxRC4TtN5dvT5L0U4qJ5Iu6mioiIhpX9yqmlwKvoriB7fLyxreIiJjE6lzFdCLF3c47A88AzpL0sW4Hi4iIZtU5gzgK2KucUEbSp4CrgU92MVdERDSszmWuv6PlBjlgOsNveIuIiEmm0yNH/wfFnMN9wGpJPym3DwB+2Zt4ERHRlE5DTCvLf1cB32tpv6xraSIiom90euTo0DLclEtlvKDcXFOukRQREZPYqJPUkl5LcRXTWkDALElH11isLyIinsLqXMX0OeBA22sAJL0AOJfiSW8RETFJ1bmKaYuh4gBg+zfAFt2LFBER/aDOGcQqSf8T+Ga5fRRPTmBHRMQkVadA/B3wfuAD5fb/Bc7oWqKIiOgLHQuEpKnANbZfBHy+N5EiIqIfdJyDsP0YsEbSc3uUJyIi+kSdIaYdKe6k/iXwx6FG24eMfEhERDzV1SkQ/9L1FBER0Xc6rcW0FcUE9e7AdcCZ5XOmIyJiM9BpDuJsYB5FcTiY4oa5iIjYTHQaYppre08ASWeSFVwjIjYrnc4gnliQL0NLERGbn05nEHtJur98L2DrcluAbW/f9XQREdGYTst9T+1lkIiI6C91FusbN0kHSVojaUDSoor+6ZLOK/uvlDS7pe8lkn4habWk68qrqiIioke6ViDKZToWU1wBNRc4QtLctt2OBe6xvTtwGnBqeew0isUB/872HsBraZkTiYiI7uvmGcQ+wIDtm20/CiwFDm3b51CKy2kBLgD2lyTgQOBa29cA2L6rXPYjIiJ6pJsFYlfgtpbt9WVb5T7llVL3ATtTPN7Uki6WdJWkj1R9gaSFklZKWjk4ODjh/4GIiM1ZpzupHwA8Un+Xr2KaBrwKeDnwEHCJpFW2L2nLsARYAjBv3rwRs0ZExNh1uoppOwBJnwB+D5xDcYnrUcCza3z27cCslu2ZZVvVPuvLeYcdgLsozjZ+ZvvOMsNy4KXAJURERE/UGWI6xPYZth+wfb/tLzN8LqHKCmCOpN0kbQksAJa17bMMOLp8Px+41LaBi4E9JT2tLBx/BVxf5z8UERETo06B+KOkoyRNlTRF0lG0LPs9knJO4TiKX/Y3AOfbXi3pFElDS4WfCewsaQD4ELCoPPYeigcUrQCuBq6yfeEY/28REbEJ6iz3fSTwxfJl4PKybVS2lwPL29pObHn/MHD4CMd+kyefgx0RET02aoGwvZZ6Q0oRETGJjDrEJOkFki6R9Oty+yWSPtb9aBER0aQ6cxBfBU6gvJPZ9rUUE84RETGJ1SkQT7Pd/iyILP8dETHJ1SkQd0p6PuVNc5LmU9wXERERk1idq5jeT3G38osk3Q7cQnGzXERETGIdC0S5Iuv7bL9e0jbAFNsP9CZaREQ0qWOBsP2YpFeV70e9OS4iIiaPOkNMv5K0DPg2LXdQ2/5u11JFRETj6hSIrSgW0Nuvpc1ACkRExCRW507qd/UiSERE9JdRC4Sks6h4LoTtv+1KooiI6At1hph+2PJ+K+DNwO+6EyciIvpFnSGm77RuSzoX+I+uJYqIiL4wnmdSzwGeOdFBIiKiv9SZg2h/NvUdwD91LVFERPSFOkNM2/UiSERE9Jc6z4N4ZbnMBpLeLunzkp7X/WgREdGkOnMQXwYekrQX8GHgt8A3upoqIiIaV6dAbLBtiseOnm57MZBhp4iISa7OfRAPSDoBeDvwGklTgC26GysiIppW5wzibcAjwLG27wBmAp/paqqIiGhcnauY7gA+37J9K5mDiIiY9OpcxbSvpBWSHpT0qKTHJN3Xi3AREdGcOkNMpwNHADcBWwPvBs6o8+GSDpK0RtKApEUV/dMlnVf2Xylpdlv/c8vC9A91vi8iIiZOraU2bA8AU20/Zvss4KDRjikfV7oYOBiYCxwhaW7bbscC99jeHTgNOLWt//PAj+pkjIiIiVXnKqaHJG0JXC3p08DvqVdY9gEGbN8MIGkpxaWy17fscyhwUvn+AuB0SbJtSYcBt9DyFLuIiOidOr/o31HudxzFL+tZwFtqHLcrcFvL9vqyrXIf2xuA+4CdJW1Lsd7TyZ2+QNJCSSslrRwcHKwRKSIi6qpzFdM6SVsDz7bd8Rf2BDoJOM32g5I6ZVsCLAGYN2/esIcaRUTE+NW5iulNwNXAReX23pKW1fjs2ynONobMLNsq95E0DdiB4vnXrwA+LWktcDzwz5KOq/GdERExQerMQZxEMZ9wGYDtqyXtVuO4FcCcct/bgQXAkW37LAOOBn4BzAcuLZf1ePXQDpJOAh60fXqN74yIiAlSp0D8yfZ9bUM9ow7n2N5Q/tV/MTAV+Jrt1ZJOAVbaXgacCZwjaQC4m6KIREREH6hTIFZLOhKYKmkO8AHg53U+3PZyYHlb24kt7x8GDh/lM06q810RETGx6lzF9PfAHhTrMZ0L3E8xLxAREZNYnauYHgI+Wr4iImIzMWKBGO1KJduHTHyciIjoF53OIP4LxU1s5wJXAiPfkBAREZNOpwLxLOAAioX6jgQuBM61vboXwSIiolkjTlKXC/NdZPtoYF9gALgsN6xFRGweOk5SS5oO/DXFWcRs4EvA97ofKyIimtZpkvobwIsp7mM42fave5YqIiIa1+kM4u0Uq7d+EPhAy53UAmx7+y5ni4iIBo1YIGzXephQRERMTikCERFRKQUiIiIqpUBERESlFIiIiKiUAhEREZVSICIiolIKREREVEqBiIiISikQERFRKQUiIiIqpUBERESlFIiIiKiUAhEREZVSICIiolIKREREVOpqgZB0kKQ1kgYkLarony7pvLL/Skmzy/YDJK2SdF35737dzBkREcN1rUBImgosBg4G5gJHSJrbttuxwD22dwdOA04t2+8E3mR7T+Bo4Jxu5YyIiGrdPIPYBxiwfbPtR4GlwKFt+xwKnF2+vwDYX5Js/8r278r21cDWkqZ3MWtERLTpZoHYFbitZXt92Va5j+0NwH3Azm37vAW4yvYj7V8gaaGklZJWDg4OTljwiIjo80lqSXtQDDu9t6rf9hLb82zPmzFjRm/DRURMct0sELcDs1q2Z5ZtlftImgbsANxVbs8Evge80/Zvu5gzIiIqdLNArADmSNpN0pbAAmBZ2z7LKCahAeYDl9q2pKcDFwKLbF/exYwRETGCrhWIck7hOOBi4AbgfNurJZ0i6ZBytzOBnSUNAB8Chi6FPQ7YHThR0tXl65ndyhoREcNN6+aH214OLG9rO7Hl/cPA4RXHfRL4ZDezRUREZ309SR0REc1JgYiIiEopEBERUSkFIiIiKqVAREREpRSIiIiolAIRERGVUiAiIqJSCkRERFRKgYiIiEopEBERUSkFIiIiKqVAREREpRSIiIiolAIRERGVUiAiIqJSCkRERFRKgYiIiEopEBERUSkFIiIiKqVAREREpRSIiIiolAIRERGVUiAiIqJSVwuEpIMkrZE0IGlRRf90SeeV/VdKmt3Sd0LZvkbSG7qZMyIihutagZA0FVgMHAzMBY6QNLdtt2OBe2zvDpwGnFoeOxdYAOwBHAScUX5eRET0SDfPIPYBBmzfbPtRYClwaNs+hwJnl+8vAPaXpLJ9qe1HbN8CDJSfFxERPTKti5+9K3Bby/Z64BUj7WN7g6T7gJ3L9ivajt21/QskLQQWlpsPSlozMdHH7BnAneM9WKdOYJLhkm18km18km18msz2vJE6ulkgus72EmBJ0zkkrbQ9r+kcVZJtfJJtfJJtfPo1WzeHmG4HZrVszyzbKveRNA3YAbir5rEREdFF3SwQK4A5knaTtCXFpPOytn2WAUeX7+cDl9p22b6gvMppN2AO8MsuZo2IiDZdG2Iq5xSOAy4GpgJfs71a0inAStvLgDOBcyQNAHdTFBHK/c4Hrgc2AO+3/Vi3sk6Axoe5Oki28Um28Um28enLbCr+YI+IiNhY7qSOiIhKKRAREVEpBSIiIiqlQGwCSTtJ2qnpHBER3ZACMUaSnitpqaRB4Ergl5L+ULbNbjhe35O0i6SXlq9dms4zGknbNp0hoim5immMJP0C+AJwwdClt+VCgocDx9vet8F4I5J0ne09G/z+vYF/o7gZcuimx5nAvcD7bF/VTLLOJN1q+7l9kGMXnlxu5nbb/9lknjokbWv7wYYziGIdtyd+dsAv3ce/+CS9yPaNTeeAFIgxk3ST7Tlj7esFSX8zUhfwb7Zn9DLPRgGkq4H32r6yrX1f4Cu292okWJHhQyN1AR+13dgw4lO1sELzxVXSgcAZwE1s/LPbneJn9+OmsnXS9M+t1VN6LaaGrJJ0BsUqtEOLEc6iuCP8V42lKpwH/C+gqupv1eMs7bZpLw4Atq+QtE0TgVr8d+AzFDdltmt6GPbrjFxYzwIaK6xljk7FtenhuS8Cr7e9trWxXJ1hOfDnTYQqM3xppC7g6T2M0lEKxNi9k+I5Fiez8Wnr0J3hTboW+KztX7d3SHp9A3la/UjShcA32LiwvhO4qLFUhauA79te1d4h6d0N5GnVz4UV+ru4TqNYCbrd7cAWPc7S7l3Ah4FHKvqO6HGWEWWIaRKR9Gpgne1bK/rm2V7ZQKzWDAdTPOtjo8Jqe3lzqUDSC4G7bA9bblnSLk2O95d/aT6f6sJ6i+3jmsoGIOnnwN+PUFxvsz2r4rCekHQC8FaKZ9G0/uwWAOfb/tcGs10KfMz2zyv6brG9WwOxhkmBGKNy1dljgcPY+BfdD4Azbf+poWgxSfVrYYUniuvdtgcr+hotrmWGP6f6Z3d9c6mKS+SBh20/1GSO0aRAjJGkcykmCM/mydPXmRRzEDvZfltD0VqL15uB55TNfV+8JC2xvXD0PXuvn7NFdFsKxBhJ+o3tF4y1rxf6vHiNdCWQgGtsz+xlno0C9He2HYATKP4K3oXiAoQ/UBT9T9m+t6lssFG+w4Bn0mf5RiLpR7YPbjpHlX7Klknqsbtb0uHAd2w/DiBpCsV9EPc0mgxeVlGg1gNXSPpNE4FaDALrKH7pDnG5/cxGEj2pn7OdD1wKvM72HQCSngUcU/Yd2Fw04Ml8r23LdzQN55P00pG6gL17GGV4gD7O1ipnEGNU3i19KvA6ir/Wobgs7afAItu3NBIMkHQF8Dmqi9eHbLc/E7yX2W4C9h9hAr3pycx+zrbG9gvH2tcr/ZxP0mPAv7Nx4R+yr+2texzpCf2crVXOIMbI9lpJJ1Hc87DRJHWTxaG0gKJ4LZZ0b9n2dIritaChTEO+AOwIDPslDHy6t1GG+QL9m22dpI8AZw9N+JZ3VR/Dk1fmNKmf891AcQ/JTe0dkpKthpxBjJGkf6L4ZbuUje/OXAAstf2pprLBiFdt/MD2Dc2lKkh6EdVXlCTbCCTtCCyiyDY03PWfFPfdfMp2o8Oa/ZxP0nzgOttrKvoOs/393qd64vv7NlurFIgxKsfy92i/Iqh87vbqhpfa6NviVf6VeWSZrXUCPdnGSdK7bJ/VdI6R9HO+ZKsnBWKMJN0IvMH2urb25wE/bnjMtZ+LV7JNsH5as6dKP+dLtnoyBzF2xwOXlBObQ2OFz6VYAKzRu1qBxynuf1jX1v7ssq9JyTYOkq4dqYvistdG9XO+ZNt0KRBjZPsiSS9g+BLCK4aW/27Q8fRv8TqeZBuPXYA3MPwSagHDlmloQD/nS7ZNlAIxDuUlpFc0naNdPxevZBu3HwLb2r66vUPSZT1PM1w/50u2TZQ5iIiIqNT0crwREdGnUiAiIqJSCkRstiTNlPQDSTdJulnS6ZKm1ziu8jnLkk4ZejCTpOMlPW2E/d4o6VeSrpF0vaT3lu2HSZpb4/tr7RexqVIgYrMkScB3KZ4kNweYA2zNJiytYftE2/+n3DweGFYgJG0BLAHeVD6H+y+Ay8ruw4A6v/jr7hexSTJJHZslSfsDH7f9mpa27SnuhZgFzAfmDT2xTdIPKR7nell5BvFVipVK7wAW2B6U9HWKq1OeA3wWWAPcaft1Ld+xE3Aj8Dzb/6+l/S/LY+8rX28B9gMWAlsCA8A7KFb6bN8PYDEwA3gIeI/tGyfkBxWbtZxBxOZqD2Cjx2Tavh9YS3H/QyfbACtt70GxIufH2z7nS8DvKJbofl1b390U6xStk3SupKMkTSkfPbkM+Efbe9v+LfBd2y8vzzRuAI4dYb8lFI/9fBnwD8AZY/5pRFTIfRARY/c4cF75/psUQ1W12X63pD2B11P8Qj+AYvXTdi+W9EmKFXm3BS5u30HStsBfAt8uRs0AGHUeJaKOFIjYXF1PMYz0hHKI6VkUQ0MvZuMz7K06fNaYx2ltXwdcJ+kc4BaqC8TXgcNsXyPpGOC1FftMAe61vfdYM0SMJkNMsbm6BHiapHcCSJpK8bCl08u5gbXA3pKmSJpFcZf1kCk8WVyOBP6j4vMfALZrb5S0raTXtjTtzZNrQLUfsx3w+3Ji+6iqzy6HxW4pn3KICnt1+o9H1JUCEZslF1dnvBmYX67BdBfwuO3/Vu5yOcVf9tcDXwKuajn8j8A+kn5NMZF8SsVXLAEukvTTtnYBH5G0RtLVwMk8efawFPjH8hLY5wP/AlxZZmmddG7f7yjgWEnXAKspns0QsclyFVMET1xFdC7wZttXjbZ/xOYgBSIiIipliCkiIiqlQERERKUUiIiIqJQCERERlVIgIiKiUgpERERU+v//KZlY8h1AQAAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -925,22 +924,22 @@ "N = 3 # 设置量子比特数\n", " \n", "# 初始化量子电路\n", - "cir = UAnsatz(N)\n", + "cir = Circuit(N)\n", "\n", "# 给每一个量子比特施加哈达玛门 H\n", "cir.superposition_layer()\n", "\n", "# 制备输出态\n", "# 如果用户不输入初始量子态，默认初始为|00..0>\n", - "final_state = cir.run_state_vector()\n", + "final_state = cir()\n", "\n", "# 获取概率分布的理论值，令 shots = 0\n", - "res = cir.measure(shots = 0, plot = True)" + "res = final_state.measure(shots = 0, plot = True)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:53:12.698149Z", @@ -950,7 +949,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -965,24 +964,24 @@ "N = 3 # 设置量子比特数\n", " \n", "# 初始化量子电路\n", - "cir = UAnsatz(N)\n", + "cir = Circuit(N)\n", "\n", "# 给每一个量子比特施加 Ry(pi/4)旋转\n", "cir.weak_superposition_layer()\n", "\n", "# 制备输出态\n", "# 如果用户不输入初始量子态，默认初始为|00..0>\n", - "final_state = cir.run_state_vector()\n", + "final_state = cir()\n", "\n", "# 获取概率分布的理论值，令 shots = 0\n", - "res = cir.measure(shots = 0, plot = True)" + "res = final_state.measure(shots = 0, plot = True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "以下是一个使用频率较高的电路模板 `complex_entangled_layer(theta, DEPTH)`，用户可按照电路深度参数 `DEPTH` 快速拓展电路。其中涉及的广义旋转门 $U_3$ 的定义为\n", + "以下是一个使用频率较高的电路模板 `complex_entangled_layer(DEPTH)`，用户可按照电路深度参数 `DEPTH` 快速拓展电路。其中涉及的广义旋转门 $U_3$ 的定义为\n", "\n", "$$\n", "U_3(\\theta, \\phi, \\varphi) := \n", @@ -1017,12 +1016,12 @@ "\n", "\n", "\n", - "特别地，当我们处理的任务不涉及虚数时，使用电路模板 `real_entangled_layer(theta, DEPTH)` 会更加高效（$R_y$ 旋转门替代 $U_3$）。" + "特别地，当我们处理的任务不涉及虚数时，使用电路模板 `real_entangled_layer(DEPTH)` 会更加高效（$R_y$ 旋转门替代 $U_3$）。" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:53:14.040033Z", @@ -1033,7 +1032,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1047,23 +1046,20 @@ "source": [ "N = 4 # 设置量子比特数\n", "DEPTH = 6 # 设置量子电路深度\n", - "theta = np.random.randn(DEPTH, N, 3)\n", - " \n", - "# 我们需要将 Numpy array 转换成 Paddle 中的 Tensor\n", - "theta = paddle.to_tensor(theta)\n", + "paddle.seed(1)\n", "\n", "# 初始化量子电路\n", - "cir = UAnsatz(N)\n", + "cir = Circuit(N)\n", "\n", "# 添加深度为 D = 6 的复数强纠缠结构QNN {Rz+Ry+Rz/U3 + CNOT's}\n", - "cir.complex_entangled_layer(theta, DEPTH)\n", + "cir.complex_entangled_layer(depth=DEPTH)\n", "\n", "# 制备输出态\n", "# 如果用户不输入初始量子态，默认初始为|00..0>\n", - "final_state = cir.run_state_vector()\n", + "final_state = cir.forward()\n", "\n", - "# 测量输出态的[0，1，2]号量子比特2048次，统计测量结果的频率\n", - "res = cir.measure(shots = 2048, which_qubits = [0, 1, 2], plot = True)" + "# 测量输出态的[0, 1, 2]号量子比特2048次，统计测量结果的频率\n", + "res = final_state.measure(shots = 2048, qubits_idx = [0, 1, 2], plot = True)" ] }, { @@ -1225,36 +1221,39 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# 加入需要用到的包\n", + "import paddle\n", + "import numpy as np\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.state import State\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "def circuit(N, DEPTH, theta):\n", + "def circuit(N, DEPTH) -> Circuit:\n", " \"\"\"\n", " 输入数据:\n", " N, 量子比特数\n", " DEPTH, 电路层数\n", - " theta, [N, DEPTH, 2], 3维数组，数据类型：paddle.tensor\n", " 返回数据:\n", " cir, 最终量子电路\n", " \"\"\"\n", " # 步骤1.1：构建N量子比特线路\n", - " cir = UAnsatz(N)\n", + " cir = Circuit(N)\n", " # 步骤1.2：对每一层添加量子门\n", " for dep in range(DEPTH):\n", " for n in range(N):\n", - " cir.rx(theta[n][dep][0], n) # 对第n个量子比特添加Rx门\n", - " cir.rz(theta[n][dep][1], n) # 对第n个量子比特添加Rz门\n", + " cir.rx(n) # 对第n个量子比特添加Rx门\n", + " cir.rz(n) # 对第n个量子比特添加Rz门\n", " for n in range(N - 1):\n", " cir.cnot([n, n + 1]) # 对每一对临近量子比特添加CNOT门\n", "\n", @@ -1270,18 +1269,18 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "--Rx(0.273)----Rz(0.650)----*----Rx(-0.96)----Rz(0.150)-----------------*-------\n", + "--Rx(-1.26)----Rz(1.092)----*----Rx(2.778)----Rz(1.194)-----------------*-------\n", " | | \n", - "--Rx(-1.70)----Rz(-2.27)----x--------*--------Rx(0.141)----Rz(1.101)----x----*--\n", + "--Rx(0.219)----Rz(0.882)----x--------*--------Rx(-1.00)----Rz(-1.58)----x----*--\n", " | | \n", - "--Rx(0.253)----Rz(-0.06)-------------x--------Rx(-0.18)----Rz(-0.94)---------x--\n", + "--Rx(0.774)----Rz(-0.53)-------------x--------Rx(-1.34)----Rz(-0.88)---------x--\n", " \n" ] } @@ -1289,8 +1288,7 @@ "source": [ "N = 3\n", "DEPTH = 2\n", - "theta = paddle.to_tensor(np.random.randn(N, DEPTH, 2))\n", - "cir = circuit(N, DEPTH, theta)\n", + "cir = circuit(N, DEPTH)\n", "print(cir)" ] }, @@ -1306,44 +1304,21 @@ "metadata": {}, "source": [ "此处我们使用量子电路输出量子态与目标量子态间“-fidelity”作为损失函数。\n", - "当输出态为我们想要的量子态时，损失函数达到最小值 -1。\n", - "\n", - "- 注：为实现对量子神经网络优化，在 Python 中我们往往设计如下的类，以计算给定参数下的损失函数。后通过优化器迭代优化损失函数并更新量子神经网络中的参数：" + "当输出态为我们想要的量子态时，损失函数达到最小值 -1。" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "class StatePrepNet(paddle.nn.Layer):\n", - " # 步骤2.1：给出量子神经网络初始值: def __init__(…)\n", - " def __init__(self, N, DEPTH, psi, dtype='float64'):\n", - " # N, DEPTH: 电路参数\n", - " # psi: 目标量子态，数据类型：numpy行向量\n", - " super(StatePrepNet, self).__init__()\n", - " self.N = N\n", - " self.DEPTH = DEPTH\n", - " # 量子电路可调参数初始化随机产生\n", - " self.theta = self.create_parameter(shape=[self.N, self.DEPTH, 2],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0., high=2*np.pi), \n", - " dtype=dtype, is_bias=False)\n", - " # 目标量子态，用于计算损失函数(需要paddle.tensor类型)\n", - " self.psi = paddle.to_tensor(psi)\n", - " # 步骤2.2：计算损失函数L = - \n", - " # 注：由于需要最小化损失函数，取“-fidelity”\n", - " def forward(self):\n", - " # 构建量子电路，参数随迭代改变\n", - " cir = circuit(self.N, self.DEPTH, self.theta)\n", - " # 得到此量子电路输出量子态\n", - " psi_out = cir.run_state_vector()\n", - " psi_out = paddle.reshape(psi_out, [2**self.N,1]) # change to paddle.ket\n", - " # 计算损失函数: L = - \n", - " inner = matmul(self.psi, psi_out)\n", - " loss = - paddle.real(matmul(inner, dagger(inner)))[0] # 改变shape为tensor([1])\n", - " \n", - " return loss, cir" + "def loss_func(cir: Circuit, psi: State) -> paddle.Tensor:\n", + " final_state = cir().data\n", + " psi_target = psi.data\n", + " inner = paddle.matmul(dagger(final_state), psi_target)\n", + " loss = -paddle.real(paddle.matmul(dagger(inner), inner))\n", + " return loss" ] }, { @@ -1362,21 +1337,21 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iter: 0 loss: -0.1089\n", - "iter: 10 loss: -0.9760\n", - "iter: 20 loss: -0.9787\n", - "iter: 30 loss: -0.9953\n", - "iter: 40 loss: -0.9973\n", - "iter: 50 loss: -0.9991\n", - "iter: 60 loss: -0.9996\n", - "iter: 70 loss: -0.9998\n", + "iter: 0 loss: -0.0430\n", + "iter: 10 loss: -0.8984\n", + "iter: 20 loss: -0.9637\n", + "iter: 30 loss: -0.9835\n", + "iter: 40 loss: -0.9944\n", + "iter: 50 loss: -0.9975\n", + "iter: 60 loss: -0.9994\n", + "iter: 70 loss: -0.9999\n", "iter: 80 loss: -0.9999\n", "iter: 90 loss: -1.0000\n", "iter: 100 loss: -1.0000\n", @@ -1386,31 +1361,31 @@ ], "source": [ "# 首先，我们给出一些训练用参数\n", - "N = 3 # 目标量子比特数\n", - "DEPTH = 2 # 量子电路层数\n", "ITR = 115 # 学习迭代次数\n", "LR = 0.2 # 学习速率\n", "\n", - "# 目标量子态：与步骤2中计算一致，取numpy行向量形式\n", - "psi_target = np.kron(np.kron(np.array([[1,0]]), np.array([[0,1]])), np.array([[1/np.sqrt(2), 1/np.sqrt(2)]])) # <01+|\n", + "# 目标量子态：与步骤2中计算一致，取numpy列向量形式\n", + "psi_vec = np.kron(np.kron(np.array([[1],[0]]), np.array([[0], [1]])), np.array([[1/np.sqrt(2)], [1/np.sqrt(2)]]))\n", + "\n", + "# 将目标量子态实例化为一个 State 对象\n", + "psi_target = State(paddle.to_tensor(psi_vec).cast('complex64'))\n", + "\n", "# 记录迭代中间过程:\n", "loss_list = []\n", - "parameter_list = []\n", - "# 使用步骤2构建的类\n", - "myLayer = StatePrepNet(N, DEPTH, psi_target)\n", + "\n", "# 选择优化器，通常选用Adam\n", - "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = myLayer.parameters())\n", + "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = cir.parameters())\n", + "\n", "# 迭代优化\n", "for itr in range(ITR):\n", " # 计算损失函数\n", - " loss = myLayer()[0]\n", + " loss = loss_func(cir, psi_target)\n", " # 通过梯度下降算法优化\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", " # 记录学习曲线\n", - " loss_list.append(loss.numpy()[0])\n", - " parameter_list.append(myLayer.parameters()[0].numpy())\n", + " loss_list.append(loss.numpy())\n", " if itr % 10 == 0:\n", " print('iter:', itr, ' loss: %.4f' % loss.numpy())" ] @@ -1424,28 +1399,22 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The minimum of the loss function: -0.9999974221935995\n", + "The minimum of the loss function: [-0.99999565]\n", "Parameters after optimizationL theta:\n", - " [[[3.13994148 5.68493383]\n", - " [3.13958964 2.55176999]]\n", - "\n", - " [[3.64572207 3.1388695 ]\n", - " [3.64619227 1.03362772]]\n", + " [array([[-3.1392097]], dtype=float32), array([[3.3646517]], dtype=float32), array([[8.64552e-05]], dtype=float32), array([[-0.05600645]], dtype=float32), array([[1.7714778]], dtype=float32), array([[1.1910632]], dtype=float32), array([[3.141264]], dtype=float32), array([[-1.0635952]], dtype=float32), array([[-0.00058735]], dtype=float32), array([[-1.9210217]], dtype=float32), array([[-0.49833927]], dtype=float32), array([[-0.42850757]], dtype=float32)] \n", "\n", - " [[4.71460474 4.71223127]\n", - " [2.07036522 6.28474516]]]\n", - "--Rx(3.140)----Rz(5.685)----*----Rx(3.140)----Rz(2.552)-----------------*-------\n", + "--Rx(-3.13)----Rz(3.365)----*----Rx(3.141)----Rz(-1.06)-----------------*-------\n", " | | \n", - "--Rx(3.646)----Rz(3.139)----x--------*--------Rx(3.646)----Rz(1.034)----x----*--\n", + "--Rx(0.000)----Rz(-0.05)----x--------*--------Rx(-0.00)----Rz(-1.92)----x----*--\n", " | | \n", - "--Rx(4.715)----Rz(4.712)-------------x--------Rx(2.070)----Rz(6.285)---------x--\n", + "--Rx(1.771)----Rz(1.191)-------------x--------Rx(-0.49)----Rz(-0.42)---------x--\n", " \n" ] } @@ -1453,20 +1422,18 @@ "source": [ "# 输出最终损失函数值\n", "print('The minimum of the loss function: ', loss_list[-1])\n", + "\n", "# 输出最终量子电路参数\n", - "theta_final = parameter_list[-1] # 得到self.theta\n", - "print(\"Parameters after optimizationL theta:\\n\", theta_final)\n", - "# 绘制最终电路与输出量子态\n", - "# 输入量子电路参数需要转化为paddle.tensor类型\n", - "theta_final = paddle.to_tensor(theta_final)\n", + "theta_final = [param.numpy() for param in cir.parameters()]\n", + "print(\"Parameters after optimizationL theta:\\n\", theta_final, \"\\n\")\n", + "\n", "# 绘制电路\n", - "cir_final = circuit(N, DEPTH, theta_final)\n", - "print(cir_final)" + "print(cir)" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1474,15 +1441,15 @@ "output_type": "stream", "text": [ "state_final:\n", - " [ 4.77299449e-05+1.43585618e-04j -3.21796287e-04+8.06827711e-04j\n", - " 5.83227235e-01-4.00461864e-01j 5.82646107e-01-3.99996677e-01j\n", - " -6.57368745e-04-2.61403493e-04j -6.58093668e-04-2.62254400e-04j\n", - " -5.81755738e-04+3.15800197e-05j -5.83020960e-04+3.35396033e-05j]\n" + " [-9.4619114e-05-1.5272114e-04j -7.3144663e-05-1.6564086e-04j\n", + " 5.2861774e-01+4.6885246e-01j 5.2879083e-01+4.7023308e-01j\n", + " 3.8210783e-05+1.0977582e-04j 3.8404934e-05+1.0973777e-04j\n", + " -6.7721255e-04+5.0217507e-04j -8.2200416e-04-1.8180218e-04j]\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1495,9 +1462,8 @@ ], "source": [ "# 最终得到量子态\n", - "#state_final = cir_final.run_density_matrix()\n", - "state_final = cir_final.run_state_vector()\n", - "print(\"state_final:\\n\", state_final.numpy())\n", + "state_final = cir()\n", + "print(\"state_final:\\n\", state_final.data.numpy())\n", "\n", "# 绘制迭代过程中损失函数变化曲线\n", "plt.figure(1)\n", @@ -1558,12 +1524,12 @@ "\\tag{21}\n", "$$\n", "\n", - "代码中，具体体现在 UAnsatz的调用 `cir.run_state_vector(input_state = None)`。如果我们不输入任何初始量子态，就会默认所有的量子比特都处于 $\\lvert {0}\\rangle$ 态。接着来看个具体的例子：" + "代码中，具体体现在调用 `paddle_quantum.set_backend(\"state_vector\")` 来设置运行模式为向量模式。若不指定运行模式，默认的模式为向量模式。使用代码 `final_state = cir(input_state=initial_state)` 来运行一个电路 `cir`，其输入初始态为 `initial_state`，输入态保存为 `final_state`，这两个态均为向量形式。如果我们不输入任何初始量子态，就会默认所有的量子比特都处于 $\\lvert {0}\\rangle$ 态。接着来看个具体的例子：" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 19, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:53:27.327236Z", @@ -1575,37 +1541,37 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[ 5.21890277e-05+0.j -2.92638723e-04+0.j 5.14596730e-04+0.j ...\n", - " 2.02212900e-03+0.j -1.17159500e-03+0.j -5.82856577e-04+0.j]]\n" + "[-5.4838351e-04+0.j -2.7753570e-04+0.j 6.3722655e-05+0.j ...\n", + " -2.3885426e-04+0.j 1.8981205e-04+0.j -6.4218853e-05+0.j]\n" ] } ], "source": [ - "from paddle_quantum.state import vec, vec_random\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.state import zero_state, random_state\n", "\n", - "N = 20 # 设置量子比特数\n", + "N = 10 # 设置量子比特数\n", "DEPTH = 6 # 设置量子电路深度\n", - "theta = np.random.randn(DEPTH, N, 1)\n", "\n", - "# 调用内置的 |00..0> 初始态\n", - "initial_state1 = vec(0, N)\n", - "# 调用内置的随机量子态 |psi>\n", - "initial_state2 = vec_random(N)\n", - " \n", - "# 我们需要将 Numpy array 转换成 Paddle 中的 Tensor\n", - "theta = paddle.to_tensor(theta)\n", - "initial_state = paddle.to_tensor(initial_state1)\n", + "# 设置态向量模式\n", + "paddle_quantum.set_backend(\"state_vector\")\n", + "\n", + "# 调用内置的 |00..0> 态函数来创建一个初始态\n", + "initial_state1 = zero_state(num_qubits=N)\n", + "# 调用内置的随机态函数来生成一个随机态\n", + "initial_state2 = random_state(num_qubits=N)\n", "\n", "# 初始化量子电路\n", - "cir = UAnsatz(N)\n", + "cir = Circuit(N)\n", "\n", "# 添加深度为 Depth 的实数强纠缠结构QNN {Ry+CNOT's}\n", - "cir.real_entangled_layer(theta, DEPTH)\n", + "cir.real_entangled_layer(depth=DEPTH)\n", "\n", - "# 制备输出态\n", - "# 如果用户不输入初始量子态，默认初始为|00..0>\n", - "final_state = cir.run_state_vector(initial_state)\n", - "print(final_state.numpy())" + "# 运行电路\n", + "# 输入初始态为|00..0>，如果用户不输入初始量子态，默认的输入态也为|00..0>\n", + "final_state1 = cir(initial_state1)\n", + "print(final_state1.data.numpy())" ] }, { @@ -1621,12 +1587,12 @@ "\\tag{22}\n", "$$\n", "\n", - "代码中，具体体现在 UAnsatz的调用 `cir.run_density_matrix()`。接着来看个具体的例子：" + "代码中，具体体现在调用 `paddle_quantum.set_backend(\"density_matrix\")` 来设置运行模式为密度矩阵模式。运行电路的方式与态向量模式相同，唯一的区别在于输入和输出态均为密度矩阵。接着来看个具体的例子：" ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 20, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:53:27.433188Z", @@ -1638,45 +1604,45 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[ 6.96262776e-01+0.j -3.29640355e-01+0.j 2.06852686e-02+0.j\n", - " -3.19984811e-01+0.j]\n", - " [-3.29640355e-01+0.j 1.56065737e-01+0.j -9.79328424e-03+0.j\n", - " 1.51494393e-01+0.j]\n", - " [ 2.06852686e-02+0.j -9.79328424e-03+0.j 6.14538578e-04+0.j\n", - " -9.50642772e-03+0.j]\n", - " [-3.19984811e-01+0.j 1.51494393e-01+0.j -9.50642772e-03+0.j\n", - " 1.47056948e-01+0.j]]\n" + "[[ 0.5808575 -1.0710210e-08j -0.07621858-1.5724729e-01j\n", + " 0.3288467 +5.1938809e-02j 0.24451724-1.8499317e-03j]\n", + " [-0.07621857+1.5724732e-01j 0.08419196-5.5879354e-09j\n", + " -0.05945612+7.4587353e-02j -0.01910382+7.2627157e-02j]\n", + " [ 0.32884675-5.1938821e-02j -0.05945611-7.4587345e-02j\n", + " 0.2059458 +1.1175871e-08j 0.12963158-5.9516393e-03j]\n", + " [ 0.24451725+1.8499183e-03j -0.01910383-7.2627142e-02j\n", + " 0.12963158+5.9516374e-03j 0.12900479-5.1804818e-09j]]\n" ] } ], "source": [ - "from paddle_quantum.state import density_op, density_op_random, completely_mixed_computational\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.state import zero_state, random_state, completely_mixed_computational\n", "\n", "N = 2 # 设置量子比特数\n", "DEPTH = 6 # 设置量子电路深度\n", - "theta = np.random.randn(DEPTH, N, 1)\n", + "\n", + "# 设置密度矩阵模式\n", + "paddle_quantum.set_backend(\"density_matrix\")\n", "\n", "# 调用内置的 |00..0><00..0| 初始态\n", - "initial_state1 = density_op(N)\n", - "# 调用内置的随机量子态, 可以指定是否允许复数元素和矩阵秩 \n", - "initial_state2 = density_op_random(N, real_or_complex=2, rank=4)\n", + "initial_state1 = zero_state(N)\n", + "# 调用内置的随机量子态, 可以指定是否允许复数元素和矩阵秩\n", + "initial_state2 = random_state(N, is_real=False, rank=4)\n", "# 调用内置的计算基下的完全混合态 \n", "initial_state3 = completely_mixed_computational(N)\n", - " \n", - "# 我们需要将 Numpy array 转换成 Paddle 中的 Tensor\n", - "theta = paddle.to_tensor(theta)\n", - "initial_state = paddle.to_tensor(initial_state1)\n", "\n", "# 初始化量子电路\n", - "cir = UAnsatz(N)\n", + "cir = Circuit(N)\n", "\n", "# 添加深度为 Depth 的实数强纠缠结构QNN {Ry+CNOT's}\n", - "cir.real_entangled_layer(theta, DEPTH)\n", + "cir.real_entangled_layer(depth=DEPTH)\n", "\n", "# 制备输出态\n", "# 如果用户不输入初始量子态，默认初始为|00..0><00..0|\n", - "final_state = cir.run_density_matrix(initial_state)\n", - "print(final_state.numpy())" + "final_state = cir(initial_state2)\n", + "print(final_state.data.numpy())" ] }, { @@ -1711,7 +1677,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 21, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:53:27.924758Z", @@ -1721,7 +1687,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1736,28 +1702,31 @@ "output_type": "stream", "text": [ "我们制备出的贝尔态是:\n", - "[0.70710678+0.j 0. +0.j 0. +0.j 0.70710678+0.j]\n" + "[0.70710677+0.j 0. +0.j 0. +0.j 0.70710677+0.j]\n" ] } ], "source": [ + "# 设置态向量模式\n", + "paddle_quantum.set_backend(\"state_vector\")\n", + "\n", "# 初始化量子电路\n", - "cir = UAnsatz(2)\n", + "cir = Circuit(2)\n", "\n", "# 添加量子门\n", "cir.h(0)\n", - "cir.cnot([0, 1]) \n", + "cir.cnot([0, 1])\n", "\n", "# 制备输出态\n", "# 如果用户不输入初始量子态，默认初始为|00..0>\n", - "output_state = cir.run_state_vector()\n", + "output_state = cir()\n", "\n", "# 我们测量输出态2048次，获得测量结果频率分布\n", "# 如果用户想获取概率分布的理论值，可以令 shots = 0\n", - "cir.measure(shots = 2048, plot = True)\n", + "output_state.measure(shots = 2048, plot = True)\n", "\n", "print('我们制备出的贝尔态是:')\n", - "print(output_state.numpy())" + "print(output_state.data.numpy())" ] }, { @@ -1796,7 +1765,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 22, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:53:47.622260Z", @@ -1918,7 +1887,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 23, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:53:50.904606Z", @@ -1931,8 +1900,8 @@ "output_type": "stream", "text": [ "随机生成的矩阵 H 是:\n", - "[[ 0.4148327 -6.93889390e-18j -0.28540716-3.59066212e-02j]\n", - " [-0.28540716+3.59066212e-02j 0.5851673 +0.00000000e+00j]] \n", + "[[0.29312716+0.j 0.20572598-0.06986022j]\n", + " [0.20572598+0.06986022j 0.70687284+0.j ]] \n", "\n", "不出所料，H 的本征值是:\n", "[0.2 0.8]\n" @@ -1962,7 +1931,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 24, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:53:50.916504Z", @@ -1980,21 +1949,21 @@ "paddle.seed(SEED)\n", "\n", "# 单独设置电路模块\n", - "def U_theta(theta):\n", + "def U_theta() -> Circuit:\n", " \n", " # 初始化电路然后添加量子门\n", - " cir = UAnsatz(num_qubits)\n", - " cir.rz(theta[2], 0)\n", - " cir.ry(theta[1], 0)\n", - " cir.rz(theta[0], 0)\n", + " cir = Circuit(num_qubits)\n", + " cir.rz(0)\n", + " cir.ry(0)\n", + " cir.rz(0)\n", " \n", - " # 返回参数化矩阵\n", - " return cir.U" + " # 返回参数化电路\n", + " return cir" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:53:54.556150Z", @@ -2003,35 +1972,19 @@ }, "outputs": [], "source": [ - "class Optimization_ex2(paddle.nn.Layer):\n", - " \n", - " def __init__(self, shape, dtype='float64'):\n", - " super(Optimization_ex2, self).__init__()\n", - " \n", - " # 初始化一个长度为 theta_size的可学习参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0., high=2*np.pi), \n", - " dtype=dtype, is_bias=False)\n", - " self.H = paddle.to_tensor(H)\n", - " \n", - " # 定义损失函数和前向传播机制\n", - " def forward(self):\n", - " \n", - " # 获取量子神经网络的酉矩阵表示\n", - " U = U_theta(self.theta)\n", - " \n", - " # 埃尔米特转置运算\n", - " U_dagger = dagger(U)\n", - " \n", - " # 计算损失函数函数\n", - " loss = paddle.real(matmul(U_dagger, matmul(self.H, U)))[0][0]\n", - " \n", - " return loss" + "def loss_func(cir: Circuit, H: paddle.Tensor) -> paddle.Tensor:\n", + " # 获取量子神经网络的酉矩阵表示\n", + " U = cir.unitary_matrix().cast('complex64')\n", + " # 埃尔米特转置运算\n", + " U_dagger = dagger(U)\n", + " # 计算损失函数函数\n", + " loss = paddle.real(matmul(U_dagger, matmul(H, U)))[0][0]\n", + " return loss" ] }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 26, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:53:59.114893Z", @@ -2043,34 +1996,34 @@ "name": "stdout", "output_type": "stream", "text": [ - "iter: 0 loss: 0.7704\n", - "iter: 5 loss: 0.6964\n", - "iter: 10 loss: 0.5480\n", - "iter: 15 loss: 0.4297\n", - "iter: 20 loss: 0.3643\n", - "iter: 25 loss: 0.2958\n", - "iter: 30 loss: 0.2372\n", - "iter: 35 loss: 0.2104\n", - "iter: 40 loss: 0.2025\n", - "iter: 45 loss: 0.2006\n", - "损失函数的最小值是: 0.20016689983553002\n" + "iter: 0 loss: 0.2134\n", + "iter: 5 loss: 0.2055\n", + "iter: 10 loss: 0.2024\n", + "iter: 15 loss: 0.2011\n", + "iter: 20 loss: 0.2005\n", + "iter: 25 loss: 0.2002\n", + "iter: 30 loss: 0.2001\n", + "iter: 35 loss: 0.2000\n", + "iter: 40 loss: 0.2000\n", + "iter: 45 loss: 0.2000\n", + "损失函数的最小值是: 0.20000416\n" ] } ], "source": [ "loss_list = []\n", "parameter_list = []\n", - " \n", - "myLayer = Optimization_ex2([theta_size])\n", + "\n", + "cir = U_theta()\n", "\n", "# 这里采用 SGD 优化器\n", - "opt = paddle.optimizer.SGD(learning_rate = LR, parameters = myLayer.parameters()) \n", + "opt = paddle.optimizer.SGD(learning_rate = LR, parameters = cir.parameters()) \n", "\n", "# 优化循环\n", "for itr in range(ITR):\n", "\n", " # 前向传播计算损失函数\n", - " loss = myLayer()[0]\n", + " loss = loss_func(cir, paddle.to_tensor(H).cast('complex64'))\n", "\n", " # 反向传播极小化损失函数\n", " loss.backward()\n", @@ -2149,8 +2102,11 @@ "name": "QSD-Paddle.ipynb", "provenance": [] }, + "interpreter": { + "hash": "f7cfecff1ef1940b21a48efa1b88278bb096bd916f13c2df11af4810c38b47e1" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.0 ('pq')", "language": "python", "name": "python3" }, @@ -2164,7 +2120,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.0" }, "toc": { "base_numbering": 1, diff --git a/introduction/PaddleQuantum_Tutorial_EN.ipynb b/introduction/PaddleQuantum_Tutorial_EN.ipynb index 4150e6c..d5e31b7 100644 --- a/introduction/PaddleQuantum_Tutorial_EN.ipynb +++ b/introduction/PaddleQuantum_Tutorial_EN.ipynb @@ -127,19 +127,19 @@ "source": [ "### Example: how to display the single qubit quantum state on the Bloch sphere?\n", "\n", - "Taking the output state of random unitary gate as an example, we show how to use the built-in function of Paddle Quantum to draw Bloch sphere. In this example, we use random rotation angles to construct random unitary operators. Let the initialized quantum circuit pass through this unitary operator, we can get the final state of the quantum circuit. This final state is a random quantum state. In this way, the sampling is repeated many times to generate a list of quantum states. By inputting them into the Bloch sphere by using the function of `utils` package in the Paddle Quantum, the display of single qubit quantum state on the Bloch sphere can be realized.\n", + "Taking the output state of random unitary gate as an example, we show how to use the built-in function of Paddle Quantum to draw Bloch sphere. In this example, we use random rotation angles to construct random unitary operators. Let the initialized quantum circuit pass through this unitary operator, we can get the final state of the quantum circuit. This final state is a random quantum state. In this way, the sampling is repeated many times to generate a list of quantum states. By inputting them into the Bloch sphere by using the function of `visual` package in the Paddle Quantum, the display of single qubit quantum state on the Bloch sphere can be realized.\n", "\n", "The specific codes are as follows:" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -151,38 +151,46 @@ } ], "source": [ - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import plot_state_in_bloch_sphere, plot_rotation_in_bloch_sphere\n", "import numpy as np\n", "import paddle\n", + "import paddle_quantum\n", + "from paddle import matmul, transpose, trace\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.state import State\n", + "from paddle_quantum.linalg import dagger\n", + "from paddle_quantum.qinfo import random_pauli_str_generator, pauli_str_to_matrix\n", + "from paddle_quantum.visual import plot_state_in_bloch_sphere, plot_rotation_in_bloch_sphere\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", "\n", "# Set random seed\n", "np.random.seed(42)\n", "# Number of samples\n", "num_samples = 15\n", "# Store the sampled quantum states\n", - "state = []\n", + "states = []\n", "\n", "for i in range(num_samples):\n", " \n", " # Create a single qubit circuit\n", - " cir = UAnsatz(1)\n", + " cir = Circuit(1)\n", + "\n", " # Generate random rotation angles\n", " phi, theta, omega = 2 * np.pi * np.random.uniform(size=3)\n", - " phi = paddle.to_tensor(phi, dtype='float64')\n", - " theta = paddle.to_tensor(theta, dtype='float64')\n", - " omega = paddle.to_tensor(omega, dtype='float64')\n", " \n", " # Quantum gate operation\n", - " cir.rz(phi, 0)\n", - " cir.ry(theta, 0)\n", - " cir.rz(omega, 0)\n", + " cir.rz(0, param=phi)\n", + " cir.ry(0, param=theta)\n", + " cir.rz(0, param=omega)\n", + " \n", + " # Run the circuit\n", + " state = cir()\n", " \n", " # Store the sampled quantum states\n", - " state.append(cir.run_state_vector())\n", + " states.append(state.data)\n", "\n", "# Call the Bloch sphere display function, enter the state parameter, and display the vector.\n", - "plot_state_in_bloch_sphere(state, show_arrow=True)" + "plot_state_in_bloch_sphere(states, show_arrow=True)" ] }, { @@ -198,7 +206,7 @@ "source": [ "The description of Bloch sphere in the Paddle Quantum has rich functions, which can provide Bloch sphere display at different angles and different viewing distances. It also supports the storage of dynamic GIF graph, which is convenient for scholars to understand and learn.\n", "\n", - "For calling richer Bloch sphere functions, please refer to API of the function `utils.plot_state_in_bloch_sphere()`. " + "For calling richer Bloch sphere functions, please refer to API of the function `visual.plot_state_in_bloch_sphere()`. " ] }, { @@ -211,19 +219,19 @@ "\n", "Suppose we take the state from the $|0\\rangle$ state through the $R_y(\\frac{\\pi}{4})$ revolving gate and the $R_z(\\frac{\\pi}{2})$ revolving gate as the initial state of the quantum state. Take the $U3(\\theta = \\frac{\\pi}{2}, \\phi = \\frac{7\\pi}{8}, \\lambda = 2\\pi)$ revolving gate as the unitary operator to be done. How to use Bloch sphere to clearly describe the process of unitary operator operation? \n", "\n", - "In Paddle Quantum, we use the function of `utils` package by entering `init_state` and $U3$ revolving gate to achieve this effect. \n", + "In Paddle Quantum, we use the function in `visual` package by entering `init_state` and $U3$ revolving gate to achieve this effect. \n", "\n", "The specific codes are as follows:" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -235,18 +243,13 @@ } ], "source": [ - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import plot_state_in_bloch_sphere, plot_rotation_in_bloch_sphere\n", - "import numpy as np\n", - "import paddle\n", - "\n", "# Create a single qubit circuit\n", - "cir = UAnsatz(1)\n", + "cir = Circuit(1)\n", "\n", "# Set the initial state of the quantum state\n", - "cir.ry(paddle.to_tensor(np.pi/4, dtype=\"float64\"), 0)\n", - "cir.rz(paddle.to_tensor(np.pi/2, dtype=\"float64\"), 0)\n", - "init_state = cir.run_density_matrix()\n", + "cir.ry(0, param=np.pi/4)\n", + "cir.rz(0, param=np.pi/2)\n", + "init_state = cir()\n", "\n", "# Unitary operator operation to be performed\n", "theta = np.pi/2\n", @@ -271,7 +274,7 @@ "source": [ "The description of \"trajectory\" of Bloch sphere in Paddle Quantum also has rich functions, which can provide Bloch sphere display at different angles and different viewing distances. It also supports the storage of dynamic GIF graph, which is convenient for scholars to understand and learn.\n", "\n", - "For calling richer Bloch sphere functions, please refer to API of the function `utils.plot_rotation_in_bloch_sphere()`. " + "For calling richer Bloch sphere functions, please refer to API of the function `visual.plot_rotation_in_bloch_sphere()`. " ] }, { @@ -447,7 +450,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:20:08.888161Z", @@ -460,41 +463,28 @@ "output_type": "stream", "text": [ "The matrix representation of quantum gate is:\n", - "[[ 6.123234e-17+0.j -6.123234e-17-1.j]\n", - " [ 6.123234e-17-1.j 6.123234e-17+0.j]]\n" + "[[-4.371139e-08+0.j 0.000000e+00-1.j]\n", + " [ 0.000000e+00-1.j -4.371139e-08+0.j]]\n" ] } ], "source": [ - "import numpy as np\n", - "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import dagger, random_pauli_str_generator, pauli_str_to_matrix\n", - "from paddle_quantum.state import vec, vec_random, density_op, density_op_random, completely_mixed_computational\n", - "\n", - "from paddle import matmul, transpose, trace \n", - "\n", - "\n", "# Set the angle parameter theta = pi\n", - "theta = np.array([np.pi])\n", - " \n", - "# We need to convert numpy.ndarray to Tensor in PaddlePaddle\n", - "theta = paddle.to_tensor(theta)\n", + "theta = np.pi\n", "\n", "# Set the number of qubits required for calculation\n", "num_qubits = 1\n", "\n", - "# Initialize our single-bit quantum circuit\n", - "cir = UAnsatz(num_qubits)\n", + "# Initialize the single-bit quantum circuit\n", + "cir = Circuit(num_qubits)\n", "\n", "# Apply an Rx rotation gate to the first qubit (q0), the angle is pi\n", - "which_qubit = 0\n", - "cir.rx(theta, which_qubit)\n", + "cir.rx(0, param=theta)\n", "\n", "# Convert to numpy.ndarray\n", "# Print out this quantum gate\n", "print('The matrix representation of quantum gate is:')\n", - "print(cir.U.numpy())" + "print(cir.unitary_matrix().numpy())" ] }, { @@ -534,11 +524,10 @@ "source": [ "theta = \"your code\"\n", " \n", - "theta = paddle.to_tensor(theta)\n", "num_qubits = 1\n", - "cir = UAnsatz(\"your code\")\n", + "cir = Circuit(\"your code\")\n", "cir.ry(\"your code\")\n", - "print(cir.U.numpy())" + "print(cir.unitary_matrix().numpy())" ] }, { @@ -582,7 +571,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:20:13.355621Z", @@ -595,37 +584,38 @@ "output_type": "stream", "text": [ "The matrix representation of the quantum neural network U(theta=pi) in the figure is:\n", - "[[ 0.0000000e+00 -1.0000000e+00 6.1232340e-17 -6.1232340e-17]\n", - " [-1.0000000e+00 0.0000000e+00 -6.1232340e-17 6.1232340e-17]\n", - " [-6.1232340e-17 6.1232340e-17 1.0000000e+00 1.2246468e-16]\n", - " [ 6.1232340e-17 -6.1232340e-17 -1.2246468e-16 1.0000000e+00]]\n" + "[[-3.5527137e-15 -1.0000000e+00 -4.3711388e-08 4.3711395e-08]\n", + " [-1.0000000e+00 -3.5527137e-15 4.3711381e-08 -4.3711388e-08]\n", + " [ 4.3711388e-08 -4.3711395e-08 1.0000000e+00 -8.7422777e-08]\n", + " [-4.3711381e-08 4.3711388e-08 8.7422777e-08 1.0000000e+00]]\n" ] } ], "source": [ + "import numpy as np\n", + "import paddle\n", + "from paddle_quantum.ansatz import Circuit\n", + "\n", "# Set the angle parameter theta\n", "theta = np.full([4], np.pi)\n", - " \n", - "# We need to convert numpy.ndarray to Tensor in PaddlePaddle\n", - "theta = paddle.to_tensor(theta)\n", "\n", "# Initialize the quantum circuit\n", "num_qubits = 2\n", - "cir = UAnsatz(num_qubits)\n", + "cir = Circuit(num_qubits)\n", "\n", "# Add single-qubit rotation gates\n", - "cir.ry(theta[0], 0)\n", - "cir.ry(theta[1], 1)\n", + "cir.ry(0, param=theta[0])\n", + "cir.ry(1, param=theta[1])\n", "\n", "# Add two-qubit gate\n", "cir.cnot([0, 1])\n", "\n", "# Add single-qubit rotation gates\n", - "cir.ry(theta[2], 0)\n", - "cir.ry(theta[3], 1)\n", + "cir.ry(0, param=theta[2])\n", + "cir.ry(1, param=theta[3])\n", "\n", "print('The matrix representation of the quantum neural network U(theta=pi) in the figure is:')\n", - "print(cir.U.numpy().real)" + "print(cir.unitary_matrix().numpy().real)" ] }, { @@ -655,7 +645,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:20:15.796777Z", @@ -665,22 +655,20 @@ "outputs": [], "source": [ "theta = np.full([6], np.pi)\n", - "\n", - "theta = paddle.to_tensor(theta)\n", - "\n", + " \n", "num_qubits = 3\n", - "cir = UAnsatz(num_qubits)\n", + "cir = Circuit(num_qubits) \n", "\n", - "cir.ry(theta[0], 0)\n", - "cir.ry(theta[1], 1)\n", - "cir.ry(theta[2], 2)\n", + "cir.ry(0, param=theta[0])\n", + "cir.ry(1, param=theta[1])\n", + "cir.ry(2, param=theta[2])\n", "\n", "cir.cnot([0, 1])\n", "cir.cnot([1, 2])\n", "\n", - "cir.ry(theta[3], 0)\n", - "cir.ry(theta[4], 1)\n", - "cir.ry(theta[5], 2)" + "cir.ry(0, param=theta[3])\n", + "cir.ry(1, param=theta[4])\n", + "cir.ry(2, param=theta[5])" ] }, { @@ -701,7 +689,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:20:18.642677Z", @@ -737,7 +725,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:55:20.402902Z", @@ -748,7 +736,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -763,22 +751,22 @@ "N = 3 # Set the number of qubits\n", " \n", "# Initialize the quantum circuit\n", - "cir = UAnsatz(N)\n", + "cir = Circuit(N)\n", "\n", "# Apply Hadamard gate on each qubit\n", "cir.superposition_layer()\n", "\n", "# Prepare output state\n", "# If the user does not enter the initial quantum state, the default initial is |00..0>\n", - "final_state = cir.run_state_vector()\n", + "final_state = cir()\n", "\n", "# Get the theoretical value of the probability distribution, set shots = 0\n", - "res = cir.measure(shots = 0, plot = True)" + "res = final_state.measure(shots = 0, plot = True)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:55:21.071722Z", @@ -788,7 +776,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -803,24 +791,24 @@ "N = 3 # Set the number of qubits\n", " \n", "# Initialize the quantum circuit\n", - "cir = UAnsatz(N)\n", + "cir = Circuit(N)\n", "\n", "# Apply Ry(pi/4) rotation gate on each qubit\n", "cir.weak_superposition_layer()\n", "\n", "# Prepare output state\n", "# If the user does not enter the initial quantum state, the default initial state is |00..0>\n", - "final_state = cir.run_state_vector()\n", + "final_state = cir()\n", "\n", "# Get the theoretical value of the probability distribution, set shots = 0\n", - "res = cir.measure(shots = 0, plot = True)" + "res = final_state.measure(shots = 0, plot = True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The following figure depicts a handy circuit template `complex_entangled_layer(theta, DEPTH)` . Users can extend the circuit architecture by changing the circuit depth parameter `DEPTH`. Define generalized rotation gate $U_3$ as\n", + "The following figure depicts a handy circuit template `complex_entangled_layer(DEPTH)` . Users can extend the circuit architecture by changing the circuit depth parameter `DEPTH`. Define generalized rotation gate $U_3$ as\n", "\n", "$$\n", "U_3(\\theta, \\phi, \\varphi) :=\n", @@ -854,12 +842,12 @@ "\n", "![intro-fig-complex_entangled_layer2](./figures/intro-fig-complex_entangled_layer2.png)\n", "\n", - "When our task does not involve imaginary numbers, it is more efficient to use the circuit template `real_entangled_layer(theta, DEPTH)` ($R_y$ instead of $U_3$)." + "When our task does not involve imaginary numbers, it is more efficient to use the circuit template `real_entangled_layer(DEPTH)` ($R_y$ instead of $U_3$)." ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:55:24.555510Z", @@ -869,7 +857,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -883,23 +871,20 @@ "source": [ "N = 4 # Set the number of qubits\n", "DEPTH = 6 # Set the quantum circuit depth\n", - "theta = np.random.randn(DEPTH, N, 3)\n", - " \n", - "# We need to convert numpy.ndarray to Tensor in PaddlePaddle\n", - "theta = paddle.to_tensor(theta)\n", + "paddle.seed(1)\n", "\n", "# Initialize the quantum circuit\n", - "cir = UAnsatz(N)\n", + "cir = Circuit(N)\n", "\n", "# Add a complex strong entanglement structure QNN with depth D = 6 {Rz+Ry+Rz/U3 + CNOT's}\n", - "cir.complex_entangled_layer(theta, DEPTH)\n", + "cir.complex_entangled_layer(depth=DEPTH)\n", "\n", "# Prepare output state\n", "# If the user does not enter the initial quantum state, the default initial is |00..0>\n", - "final_state = cir.run_state_vector()\n", + "final_state = cir.forward()\n", "\n", "# Measure the output state [0, 1, 2] qubits 2048 times, and count the frequency of the measurement results\n", - "res = cir.measure(shots = 2048, which_qubits = [0, 1, 2], plot = True)" + "res = final_state.measure(shots = 2048, qubits_idx = [0, 1, 2], plot = True)" ] }, { @@ -1053,43 +1038,41 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "# import packages\n", "import paddle\n", "import numpy as np\n", - "from paddle import matmul\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import dagger\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.state import State\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "def circuit(N, DEPTH, theta):\n", + "def circuit(N, DEPTH):\n", " \"\"\"\n", " Input data:\n", " N, qubits number\n", " DEPTH, layers number\n", - " theta, [N, DEPTH, 2], 3D matrix in paddle.tensor form\n", " Return:\n", " cir, the final circuit\n", " \"\"\"\n", " # step 1.1: Create an N qubit circuit\n", - " cir = UAnsatz(N)\n", + " cir = Circuit(N)\n", " # step 1.2: Add gates to each layer\n", " for dep in range(DEPTH):\n", " for n in range(N):\n", - " cir.rx(theta[n][dep][0], n) # add an Rx gate to the n-th qubit\n", - " cir.rz(theta[n][dep][1], n) # add an Rz gate to the n-th qubit\n", + " cir.rx(n) # add an Rx gate to the n-th qubit\n", + " cir.rz(n) # add an Rz gate to the n-th qubit\n", " for n in range(N-1):\n", - " cir.cnot([n, n+1]) # add CNOT gate to every neighbor pair\n", + " cir.cnot([n, n + 1]) # add CNOT gate to every neighbor pair\n", " return cir" ] }, @@ -1102,18 +1085,18 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "--Rx(0.273)----Rz(0.650)----*----Rx(-0.96)----Rz(0.150)-----------------*-------\n", + "--Rx(-1.26)----Rz(1.092)----*----Rx(2.778)----Rz(1.194)-----------------*-------\n", " | | \n", - "--Rx(-1.70)----Rz(-2.27)----x--------*--------Rx(0.141)----Rz(1.101)----x----*--\n", + "--Rx(0.219)----Rz(0.882)----x--------*--------Rx(-1.00)----Rz(-1.58)----x----*--\n", " | | \n", - "--Rx(0.253)----Rz(-0.06)-------------x--------Rx(-0.18)----Rz(-0.94)---------x--\n", + "--Rx(0.774)----Rz(-0.53)-------------x--------Rx(-1.34)----Rz(-0.88)---------x--\n", " \n" ] } @@ -1121,8 +1104,7 @@ "source": [ "N = 3\n", "DEPTH = 2\n", - "theta = paddle.to_tensor(np.random.randn(N, DEPTH, 2))\n", - "cir = circuit(N, DEPTH, theta)\n", + "cir = circuit(N, DEPTH)\n", "print(cir)" ] }, @@ -1137,44 +1119,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Here we use “-fidelity” between the real output state and the target state to be the loss function. When the real output state is the target state, “-fidelity” will be “-1”, which is the minimum number.\n", - "\n", - "- Note: To update the parameters in QNN, we usually design the following class to calculate loss function with a given QNN. We will then use an optimizer to minimize the loss function and update the parameters." + "Here we use “-fidelity” between the real output state and the target state to be the loss function. When the real output state is the target state, “-fidelity” will be “-1”, which is the minimum number." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "class StatePrepNet(paddle.nn.Layer):\n", - " # Step 2.1: Give the initial input of the QNN: def __init__(…)\n", - " # Here you need to give the parameters for creating your quantum circuit and loss\n", - " def __init__(self, N, DEPTH, psi, dtype='float64'):\n", - " # N, DEPTH: circuit parameter\n", - " # psi: target output pure state, np.row_vector form\n", - " super(StatePrepNet, self).__init__()\n", - " self.N = N\n", - " self.DEPTH = DEPTH\n", - " # The initial circuit parameter theta is generated randomly\n", - " self.theta = self.create_parameter(shape=[self.N, self.DEPTH, 2],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0., high=2*np.pi), \n", - " dtype=dtype, is_bias=False)\n", - " # Target output state, used for loss function\n", - " self.psi = paddle.to_tensor(psi)\n", - " # Step 2.2: Calculate the loss function: L = - \n", - " # note: here we want to minimize the loss function, so we use “-fidelity”\n", - " def forward(self):\n", - " # Create the quantum circuit\n", - " cir = circuit(self.N, self.DEPTH, self.theta)\n", - " # Get the final state\n", - " psi_out = cir.run_state_vector()\n", - " psi_out = paddle.reshape(psi_out, [2**self.N,1]) # change to paddle.ket\n", - " # Calculate the loss function: L = - \n", - " inner = matmul(self.psi, psi_out)\n", - " loss = - paddle.real(matmul(inner, dagger(inner)))[0] # change to shape tensor([1])\n", - " return loss, cir" + "def loss_func(cir: Circuit, psi: State) -> paddle.Tensor:\n", + " final_state = cir().data\n", + " psi_target = psi.data\n", + " inner = paddle.matmul(dagger(final_state), psi_target)\n", + " loss = -paddle.real(paddle.matmul(dagger(inner), inner))\n", + " return loss" ] }, { @@ -1193,21 +1152,21 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iter: 0 loss: -0.0006\n", - "iter: 10 loss: -0.8561\n", - "iter: 20 loss: -0.9270\n", - "iter: 30 loss: -0.9783\n", - "iter: 40 loss: -0.9932\n", - "iter: 50 loss: -0.9977\n", - "iter: 60 loss: -0.9996\n", - "iter: 70 loss: -0.9997\n", + "iter: 0 loss: -0.0430\n", + "iter: 10 loss: -0.8984\n", + "iter: 20 loss: -0.9637\n", + "iter: 30 loss: -0.9835\n", + "iter: 40 loss: -0.9944\n", + "iter: 50 loss: -0.9975\n", + "iter: 60 loss: -0.9994\n", + "iter: 70 loss: -0.9999\n", "iter: 80 loss: -0.9999\n", "iter: 90 loss: -1.0000\n", "iter: 100 loss: -1.0000\n", @@ -1216,32 +1175,32 @@ } ], "source": [ - "# First, we give the parameters for the QNN circuit, and the parameters used for learning\n", - "N = 3 # qubits number\n", - "DEPTH = 2 # layers number\n", + "# First, we give the parameters used for learning\n", "ITR = 115 # iteration number\n", "LR = 0.2 # learning rate\n", "\n", "# The target state we want: as a row vector here\n", - "psi_target = np.kron(np.kron(np.array([[1,0]]), np.array([[0,1]])), np.array([[1/np.sqrt(2), 1/np.sqrt(2)]])) # <01+|\n", + "psi_vec = np.kron(np.kron(np.array([[1],[0]]), np.array([[0], [1]])), np.array([[1/np.sqrt(2)], [1/np.sqrt(2)]]))\n", + "\n", + "# Instantiate the target state as a State\n", + "psi_target = State(paddle.to_tensor(psi_vec).cast('complex64'))\n", + "\n", "# Record the iteration:\n", "loss_list = []\n", - "parameter_list = []\n", - "# Use Class defined in step 2\n", - "myLayer = StatePrepNet(N, DEPTH, psi_target)\n", + "\n", "# Choose the optimizer, usually we use Adam\n", - "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = myLayer.parameters())\n", + "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = cir.parameters())\n", + "\n", "# Optimize during iteration\n", "for itr in range(ITR):\n", - " # Use forward part to calculate the loss function\n", - " loss = myLayer()[0]\n", + " # Calculate the loss\n", + " loss = loss_func(cir, psi_target)\n", " # Backward optimize via Gradient descent algorithm\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", " # Record the learning curve\n", - " loss_list.append(loss.numpy()[0])\n", - " parameter_list.append(myLayer.parameters()[0].numpy())\n", + " loss_list.append(loss.numpy())\n", " if itr % 10 == 0:\n", " print('iter:', itr, ' loss: %.4f' % loss.numpy())" ] @@ -1255,28 +1214,22 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "The minimum of the loss function: -0.9999968501679325\n", + "The minimum of the loss function: [-0.99999565]\n", "Parameters after optimizationL theta:\n", - " [[[3.14315954e+00 4.69366501e+00]\n", - " [3.14114250e+00 3.76582580e+00]]\n", - "\n", - " [[3.13958514e+00 3.05953797e+00]\n", - " [3.14269637e+00 3.94608975e-01]]\n", + " [array([[-3.1392097]], dtype=float32), array([[3.3646517]], dtype=float32), array([[8.64552e-05]], dtype=float32), array([[-0.05600645]], dtype=float32), array([[1.7714778]], dtype=float32), array([[1.1910632]], dtype=float32), array([[3.141264]], dtype=float32), array([[-1.0635952]], dtype=float32), array([[-0.00058735]], dtype=float32), array([[-1.9210217]], dtype=float32), array([[-0.49833927]], dtype=float32), array([[-0.42850757]], dtype=float32)] \n", "\n", - " [[4.71171514e+00 9.01298259e-01]\n", - " [1.31037031e-03 3.81143977e+00]]]\n", - "--Rx(3.143)----Rz(4.694)----*----Rx(3.141)----Rz(3.766)-----------------*-------\n", + "--Rx(-3.13)----Rz(3.365)----*----Rx(3.141)----Rz(-1.06)-----------------*-------\n", " | | \n", - "--Rx(3.140)----Rz(3.060)----x--------*--------Rx(3.143)----Rz(0.395)----x----*--\n", + "--Rx(0.000)----Rz(-0.05)----x--------*--------Rx(-0.00)----Rz(-1.92)----x----*--\n", " | | \n", - "--Rx(4.712)----Rz(0.901)-------------x--------Rx(0.001)----Rz(3.811)---------x--\n", + "--Rx(1.771)----Rz(1.191)-------------x--------Rx(-0.49)----Rz(-0.42)---------x--\n", " \n" ] } @@ -1284,20 +1237,18 @@ "source": [ "# Print the output\n", "print('The minimum of the loss function: ', loss_list[-1])\n", + "\n", "# The parameters after optimization\n", - "theta_final = parameter_list[-1] # Get self.theta\n", - "print(\"Parameters after optimizationL theta:\\n\", theta_final)\n", + "theta_final = [param.numpy() for param in cir.parameters()]\n", + "print(\"Parameters after optimizationL theta:\\n\", theta_final, \"\\n\")\n", + "\n", "# Draw the circuit picture and the output state\n", - "# To create the circuit, “theta_final” should be changed to paddle.tensor form\n", - "theta_final = paddle.to_tensor(theta_final)\n", - "# Print the circuit\n", - "cir_final = circuit(N, DEPTH, theta_final)\n", - "print(cir_final)" + "print(cir)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -1305,15 +1256,15 @@ "output_type": "stream", "text": [ "state_final:\n", - " [ 1.60015226e-04-4.11355044e-04j 1.76011799e-04+4.69345541e-04j\n", - " 2.05362221e-01-6.76576746e-01j 2.05154372e-01-6.76742815e-01j\n", - " -9.66090886e-05-1.26102052e-04j -9.62457101e-05-1.26342776e-04j\n", - " 5.18950813e-04-1.94232290e-04j -7.01086260e-05-5.49575311e-04j]\n" + " [-9.4619114e-05-1.5272114e-04j -7.3144663e-05-1.6564086e-04j\n", + " 5.2861774e-01+4.6885246e-01j 5.2879083e-01+4.7023308e-01j\n", + " 3.8210783e-05+1.0977582e-04j 3.8404934e-05+1.0973777e-04j\n", + " -6.7721255e-04+5.0217507e-04j -8.2200416e-04-1.8180218e-04j]\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEJCAYAAACKWmBmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAj+0lEQVR4nO3deZxU5Z3v8c+PXkCkG7obwipBJ3gVG2lNA8YVIxK3CRodjaMRTJA4TnYTJTEvg15jMJrrmJcxXuKGkRgcEiPjGkFvUMcQGwMuEIeIGFD2RXahu3/3j+cUFE11dfVSfbqrvu/Xq15Vp+rUqd/p0vrynOc8zzF3R0REpDFd4i5AREQ6NgWFiIikpaAQEZG0FBQiIpKWgkJERNJSUIiISFqxBoWZnWVm75jZ381sSorXu5rZrOj1BWY2JIYyRUTyWmxBYWYFwC+As4FhwKVmNqzBal8BNrv7p4A7gdvat0oRESmM8bNHAX939+UAZvZbYDywJGmd8cDU6PFs4G4zM08zSrB3794+ZMiQrBQsIpKrFi5cuMHd+6R6Lc6gGAisTFpeBYxubB13rzWzj4AKYEPySmY2GZgMMHjwYGpqarJVs4hITjKz9xt7LSc6s919urtXu3t1nz4pA1FERFoozqD4ADgsaXlQ9FzKdcysEOgJbGyX6kREBIg3KF4DhprZ4WZWDHwRmNNgnTnAhOjxRcAL6fonRESk7cXWRxH1OXwNeA4oAB5w97fN7Gagxt3nAPcDvzazvwObCGEi0u727t3LqlWr2L17d9yliLRKt27dGDRoEEVFRRm/x3LtH+jV1dWuzmxpa++99x4lJSVUVFRgZnGXI9Ii7s7GjRvZtm0bhx9++AGvmdlCd69O9b6c6MwWybbdu3crJKTTMzMqKiqa3TJWUIhkSCEhuaAl/x0rKBK2b4ff/haWLYu7EhGRDkVBkWAGM2fCG2/EXYlISj169MjKdtevX8/o0aM57rjjeOmll9psuw899BAffvjhvuVJkyaxZMmSNO9omSFDhrBhw4amV0xy77338vDDD7fJ5yfv16233tom20xor79hU+Icmd2xHHoo9OwJq1fHXYlIu5o3bx7Dhw/nvvvua9PtPvTQQ1RWVjJgwACANt9+S9XW1nL11Ve32faS9+vWW2/lBz/4QbPeX1dXR0FBQcrXOsrfUC2KZP37Kyikw3N3vve971FZWcnw4cOZNWsWAKtXr+bUU0+lqqqKyspKXnrpJerq6pg4ceK+de+8884DtrVo0SKuu+46nnjiCaqqqti1a9cBLZfZs2czceJEACZOnMg3vvENTjzxRI444ghmz569b73bbruN4cOHM2LECKZMmcLs2bOpqanhsssu27fdMWPG7Jte59FHH2X48OFUVlZy/fXX79tOjx49uOGGGxgxYgQnnHACa9euPWj/N27cyLhx4zjmmGOYNGkSiTM3V6xYQWVl5b717rjjDqZOnQrAmDFj+Na3vkV1dTV33XUXU6dO5Y477tj32vXXX8+oUaM48sgj97Wqdu7cycUXX8ywYcO44IILGD16dMrpgRL7NWXKFHbt2kVVVRWXXXYZAI888gijRo2iqqqKr371q9TV1e3bz2uvvZYRI0bw6quvcvPNNzNy5EgqKyuZPHky7p7Vv2FzqUWRbMAAHXqSpv3qV7B8edtu84gj4KqrMlr197//PYsWLWLx4sVs2LCBkSNHcuqpp/Kb3/yGz33uc9xwww3U1dWxc+dOFi1axAcffMBbb70FwJYtWw7YVlVVFTfffDM1NTXcfffdTX726tWrefnll/nb3/7G5z//eS666CKeeeYZnnjiCRYsWED37t3ZtGkT5eXl3H333dxxxx1UVx94xuWHH37I9ddfz8KFCykrK2PcuHH84Q9/4Pzzz2fHjh2ccMIJ/PjHP+a6667jV7/6FT/84Q8PeP9NN93EySefzI033shTTz3F/fffn9Hfbc+ePft+ZBMBklBbW8tf/vIXnn76aW666Sbmzp3LPffcQ1lZGUuWLOGtt96iqqoq7fanTZvG3XffzaJFiwBYunQps2bN4pVXXqGoqIhrrrmGmTNncsUVV7Bjxw5Gjx7Nz372MwCGDRvGjTfeCMCXvvQlnnzySS666KKs/Q2bSy2KZP37w4YNsGdP3JWINOrll1/m0ksvpaCggL59+3Laaafx2muvMXLkSB588EGmTp3Km2++SUlJCUcccQTLly/n61//Os8++yylpaWt+uzzzz+fLl26MGzYsH3/Up07dy5XXnkl3bt3B6C8vDztNl577TXGjBlDnz59KCws5LLLLmP+/PkAFBcXc9555wHw6U9/mhUrVhz0/vnz53P55ZcDcO6551JWVpZR7Zdcckmjr33hC1846DNffvllvvjFMMa3srKSY489NqPPSZg3bx4LFy5k5MiRVFVVMW/ePJZH/8AoKCjgwgsv3Lfuiy++yOjRoxk+fDgvvPACb7/9dtptt/Zv2FxqUSSLjgOyZg0MHhxvLdJxZfgv//Z26qmnMn/+fJ566ikmTpzId77zHa644goWL17Mc889x7333stjjz3GAw88kHY7yadPNjzfvmvXrvseZ2OwblFR0b7PLygooLa2NuP3FhYWUl9fv2+5Ye2HHnpoo+9N7FdzPzMdd2fChAn85Cc/Oei1bt267euX2L17N9dccw01NTUcdthhTJ06tVUzALTmb9gYtSiS9e8f7tVPIR3YKaecwqxZs6irq2P9+vXMnz+fUaNG8f7779O3b1+uuuoqJk2axOuvv86GDRuor6/nwgsv5JZbbuH1119vcvt9+/Zl6dKl1NfX8/jjjze5/plnnsmDDz7Izp07Adi0aRMAJSUlbNu27aD1R40axZ/+9Cc2bNhAXV0djz76KKeddlrG+584zAbwzDPPsHnz5n11r1u3jo0bN/Lxxx/z5JNPZrzNVE466SQee+wxAJYsWcKbb77Z5HuKiorYu3cvAGeccQazZ89m3bp1QPi7vP/+wTN5J0Khd+/ebN++/YC+n2z9DZtLLYpkiaBIOh1NpKO54IILePXVVxkxYgRmxk9/+lP69evHjBkzuP322ykqKqJHjx48/PDDfPDBB1x55ZX7/qWd6l+3DU2bNo3zzjuPPn36UF1dzfbt29Ouf9ZZZ7Fo0SKqq6spLi7mnHPO4dZbb2XixIlcffXVHHLIIbz66qv71u/fvz/Tpk3j9NNPx90599xzGT9+fMb7/6Mf/YhLL72UY445hhNPPJHBUeu/qKiIG2+8kVGjRjFw4ECOOuqojLeZyjXXXMOECRMYNmwYRx11FMcccww9e/ZM+57Jkydz7LHHcvzxxzNz5kxuueUWxo0bR319PUVFRfziF7/gk5/85AHv6dWrF1dddRWVlZX069ePkSNH7nstW3/D5tJcTw3967/CSSfBv/972xUlnd7SpUs5+uij4y5D2lFdXR179+6lW7duvPvuu4wdO5Z33nmH4uLiuEtrtVT/Paeb60ktioYGDNChJxFh586dnH766ezduxd355577smJkGgJBUVDAwZAdCqhiOSvkpISXVY5os7shnSKrDQi1w7TSn5qyX/HCoqG+vcHd2iD0YySO7p168bGjRsVFtKpJa5H0a1bt2a9T4eeGko+Rfaww9KvK3lj0KBBrFq1ivXr18ddikirJK5w1xwKioYSg+50iqwkKSoqOuiKYCL5QoeeGiopgR49dOaTiEhEQZFK//5qUYiIRBQUqSgoRET2UVCkMmAArF8P0ZwtIiL5TEGRSr9+4RTZZl5eUUQkFykoUundO9wrKEREFBQpKShERPZRUKSioBAR2UdBkUrXrmE8hYJCRERB0aiKCgWFiAgKisb16aOgEBFBQdE4tShERAAFReP69IGtW3VdChHJewqKxujMJxERQEHROAWFiAgQU1CYWbmZPW9my6L7shTrVJnZq2b2tpm9YWaXtGuRCgoRESC+FsUUYJ67DwXmRcsN7QSucPdjgLOA/zCzXu1WYUVFuFdQiEieiysoxgMzosczgPMbruDu/+Puy6LHHwLrgD7tVaAG3YmIBHEFRV93T1xCbg3QN93KZjYKKAbebeT1yWZWY2Y1bXpNY42lEBHJ3jWzzWwu0C/FSzckL7i7m5mn2U5/4NfABHevT7WOu08HpgNUV1c3uq1m01gKEZHsBYW7j23sNTNba2b93X11FATrGlmvFHgKuMHd/5ylUhvXpw/87W/t/rEiIh1JXIee5gAToscTgCcarmBmxcDjwMPuPrsda9uvogK2bYOPP47l40VEOoK4gmIacKaZLQPGRsuYWbWZ3RetczFwKjDRzBZFt6p2rbJP1Heuw08ikseydugpHXffCJyR4vkaYFL0+BHgkXYu7UDJYykGDoy1FBGRuGhkdjoadCcioqBIS4PuREQUFGkVF0NpqYJCRPKagqIpvXsrKEQkrykomlJRARs3xl2FiEhsFBRNKS+HTZvirkJEJDYKiqaUl4cr3dXWxl2JiEgsFBRNKS8Hd9iyJe5KRERioaBoSll0TaXNm+OtQ0QkJgqKppSXh3v1U4hInlJQNEVBISJ5TkHRlF69wExBISJ5S0HRlIIC6NlTQSEieUtBkYnycnVmi0jeUlBkQoPuRCSPKSgyUVamoBCRvKWgyER5eRhwV18fdyUiIu1OQZEJjc4WkTymoMiExlKISB5TUGRC03iISB5TUGQicUlUtShEJA8pKDLRq1e4V1CISB5SUGSisDBcO1tBISJ5SEGRKQ26E5E8paDIlKbxEJE8paDIlEZni0ieUlBkqqIitCg0OltE8oyCIlNlZSEktm6NuxIRkXaloMiURmeLSJ5SUGRKQSEieUpBkalEUOjMJxHJMwqKTCVGZ2sGWRHJM7EEhZmVm9nzZrYsui9Ls26pma0ys7vbs8aDFBeH27ZtsZYhItLe4mpRTAHmuftQYF603Jj/Dcxvl6qaUlqqs55EJO/EFRTjgRnR4xnA+alWMrNPA32BP7ZPWU1QUIhIHoorKPq6++ro8RpCGBzAzLoAPwO+29TGzGyymdWYWc369evbttJkCgoRyUOF2dqwmc0F+qV46YbkBXd3M/MU610DPO3uq8ws7We5+3RgOkB1dXWqbbWN0lJYuzZrmxcR6YiyFhTuPrax18xsrZn1d/fVZtYfWJditc8Ap5jZNUAPoNjMtrt7uv6M7CopUWe2iOSdrAVFE+YAE4Bp0f0TDVdw98sSj81sIlAda0hAaFFs3w51dVBQEGspIiLtJa4+imnAmWa2DBgbLWNm1WZ2X0w1Na2kJNxv3x5vHSIi7SiWFoW7bwTOSPF8DTApxfMPAQ9lvbCm9OwZ7rdu3f9YRCTHaWR2c5SWhnv1U4hIHlFQNEfi0JNOkRWRPKKgaA61KEQkDykomiPRovjoo3jrEBFpRwqK5ujaVRMDikjeUVA0h5mm8RCRvKOgaK6SEgWFiOQVBUVzlZbq0JOI5BUFRXOpRSEieUZB0VzqoxCRPKOgaK7ExID19XFXIiLSLhQUzVVaCu6wY0fclYiItAsFRXMlRmfr8JOI5ImMgsLMvmlmpRbcb2avm9m4bBfXIWm+JxHJM5m2KL7s7luBcUAZ8CWia0jkHbUoRCTPZBoUiYtWnwP82t3fTnouv2hiQBHJM5kGxUIz+yMhKJ4zsxIgP0/7UYtCRPJMple4+wpQBSx3951mVg5cmbWqOrKuXaGoSEEhInkj0xbFZ4B33H2LmV0O/BDIz7m2zTQ6W0TySqZB8Utgp5mNAK4F3gUezlpVHZ1GZ4tIHsk0KGrd3YHxwN3u/gugJHtldXCaGFBE8kimQbHNzL5POC32KTPrAhRlr6wOTi0KEckjmQbFJcDHhPEUa4BBwO1Zq6qjU4tCRPJIRkERhcNMoKeZnQfsdvf87aNIdGa7x12JiEjWZTqFx8XAX4B/AS4GFpjZRdksrENLTAy4fXvclYiIZF2m4yhuAEa6+zoAM+sDzAVmZ6uwDi0x39P27fsfi4jkqEz7KLokQiKysRnvzT2JcFA/hYjkgUxbFM+a2XPAo9HyJcDT2SmpE1BQiEgeySgo3P17ZnYhcFL01HR3fzx7ZXVwCgoRySOZtihw998Bv8tiLZ2HgkJE8kjaoDCzbUCqc0ANcHcvzUpVHd2hh4Y5nxQUIpIH0gaFu+uUnlS6dAlhodNjRSQPxHLmkpmVm9nzZrYsui9rZL3BZvZHM1tqZkvMbEg7l9q4khK1KEQkL8R1iusUYJ67DwXmRcupPAzc7u5HA6OAdY2s1/569FBQiEheiCsoxgMzosczgPMbrmBmw4BCd38ewN23u/vOdquwKWpRiEieiCso+rr76ujxGqBvinWOBLaY2e/N7K9mdruZFaTamJlNNrMaM6tZv359tmo+kIJCRPJExqfHNpeZzQX6pXjphuQFd3czS3VmVSFwCnAc8A9gFjARuL/hiu4+HZgOUF1d3T4z9SkoRCRPZC0o3H1sY6+Z2Voz6+/uq82sP6n7HlYBi9x9efSePwAnkCIoYtGjB+zYAfX14SwoEZEcFdcv3BxgQvR4AvBEinVeA3pFExACfBZY0g61ZSYxg+yOHXFXIiKSVXEFxTTgTDNbBoyNljGzajO7D8Dd64DvAvPM7E3CIL9fxVTvwXr0CPc6/CQiOS5rh57ScfeNwBkpnq8BJiUtPw8c246lZU7TeIhIntDB9ZZSUIhInlBQtJSCQkTyhIKipZKvciciksMUFC2VmEF269a4KxERySoFRUtpBlkRyRMKitbQ6GwRyQMKitbQDLIikgcUFK1RWqqgEJGcp6BojR491EchIjlPQdEaJSU660lEcp6CojVKSvbPICsikqMUFK2RGHSnGWRFJIcpKFojMYOsDj+JSA5TULRGaWm4V4e2iOQwBUVr6JoUIpIHFBStoRlkRSQPKChaQ0EhInlAQdEaiRlkFRQiksMUFK2RmEFWQSEiOUxB0VqaQVZEcpyCorUUFCKS4xQUrdWzJ3z0UdxViIhkjYKitSoqYOPGuKsQEckaBUVrVVSEFsXevXFXIiKSFQqK1qqoCPebNsVbh4hIligoWqt373C/YUO8dYiIZImCorUSQaF+ChHJUQqK1iovD/cKChHJUQqK1ureHbp106EnEclZCorWMguHn9SiEJEcpaBoCxUValGISM5SULQFtShEJIfFEhRmVm5mz5vZsui+rJH1fmpmb5vZUjP7uZlZe9eakYqKMI6ivj7uSkRE2lxcLYopwDx3HwrMi5YPYGYnAicBxwKVwEjgtPYsMmMVFSEktmyJuxIRkTYXV1CMB2ZEj2cA56dYx4FuQDHQFSgC1rZHcc2msRQiksPiCoq+7r46erwG6NtwBXd/FXgRWB3dnnP3pe1XYjMkpvFQh7aI5KDCbG3YzOYC/VK8dEPygru7mXmK938KOBoYFD31vJmd4u4vpVh3MjAZYPDgwa0tvfk0jYeI5LCsBYW7j23sNTNba2b93X21mfUH1qVY7QLgz+6+PXrPM8BngIOCwt2nA9MBqqurDwqdrCsthcJCTQwoIjkprkNPc4AJ0eMJwBMp1vkHcJqZFZpZEaEju2MeejILU3moRSEiOSiuoJgGnGlmy4Cx0TJmVm1m90XrzAbeBd4EFgOL3f2/4ig2IxpLISI5KmuHntJx943AGSmerwEmRY/rgK+2c2kt17s3LFsWdxUiIm1OI7PbSuKSqN7+XSQiItmkoGgrFRWwZw9s3x53JSIibUpB0VYSYynUTyEiOUZB0VY0OltEcpSCoq0kgmJtx5xlRESkpRQUbaWiAvr3h+eeU4e2iOQUBUVbMYOLL4bly6GmJu5qRETajIKiLY0ZA5/4BMyapVaFiOQMBUVbKiyEiy6Cd96BxYth71548cVwOGrHjrirExFpEfMc+5dvdXW118R56GfvXrjqKiguhl279l/MqLgYTjwRJk7cfyqtiEgHYWYL3b061WuxTOGR04qK4JJL4J57oLoaxo+HHj3g+edh7twwIO9HP4q7ShGRjCkosuGss+CUU0JAJHzqU9CvHzzwALz+Ohx/fHz1iYg0g/oossHswJBIOO+8cArtffdBXV371yUi0gIKivZUVARf/jKsXBk6uEVEOgEFRXsbPRqOPRYeeUQTCIpIp6CgaG9m8JWvhJB47LHWb6++XmM2RCSr1JkdhyOOgLFj4b/+C84+O/RbZModnn0WZs+GrVth9+7QUX7jjVBWlr2aRSRvqUURl8svDwP0Hnoo8/fs3Am33x5Ove3TBz73uTDAb+VK+P73dc1uEckKtSjiUl4efuQfeQTefhuOOSb9+itXwi23wJo1MGECXHhhOIwFMGpUGJtx/fXwk5+EaURERNqIWhRxOv/8MD35XXfBunWNr7dgAVx7bWhR3HprCJhESAAcfTT8+Meh3+PnP1efhYi0KQVFnLp2heuuC30N3/serFhx4OtbtoQxF7fcAoMGwZ13Nt7yGDo0HM5avBj++7+zXbmI5BHN9dQRrFgRDh19/DGcfDL07BnC44UXwtxR48bB5Mlhvqh06urg29+Gbdvgl7+Ebt3apXwR6fzSzfWkFkVHMGRI6KQ+4gj485/hP/8zzAs1Zgzcey987WtNhwRAQQH827+FTu22OPVWRAR1Znccn/hE6H+A0MdQWxtGcjfX0UfDZz8Ljz8eTsEdMKBt6xSRvKMWRUdk1rKQSJg4MZx6+8ADbVaSiOQvBUUuKisLU50vWBA6t0VEWkFBkas+//lwOEsz1YpIKykoclVxcZipdsWKcNEkEZEWUlDkshNPhMrKME3I2rWt29bu3fDhh7BnT5uUJiKdh856ymVm8M1vhttPfwq33RY6uTO1Zg3MmAF//Svs2BGeKy4Og/4+/elw+m7PnlkpXUQ6Dg24ywevvALTpsEFF4TDUU3ZvRsefRTmzAljM04/PVzGtVcveO+9cCnXlSvDmVknnwznngtHHnngtCIi0qmkG3CnFkU+OOkkOOecMLZi8OAwvqIxy5eH1seHH4bxGF/6ElRUHLzeypXw1FMwbx68+GIYNHj22XDqqakvAysinZZaFPlizx6YOhXefDP8oE+adOBo79274emn4de/htJS+O53Yfjwpre7axf86U/wzDMhZAoLoaoqtDSGDQstEbU0RDq8dC2KWILCzP4FmAocDYxy95S/7GZ2FnAXUADc5+7Tmtq2giKNuroQBL/7HXzyk3D88TBwIHzwAfzxj6EfYtSo0KdRWtr87b/7LsyfDy+/vH823NJSOOwwOOSQMPdUfX2Y02rv3nBYq6gISkrCpIcDB4YWT79+4bV0amth8+YwXcmWLWFm3Z07w/YOPXT/55aVKahEMtARg+JooB74v8B3UwWFmRUA/wOcCawCXgMudfcl6batoMjAggUwcyasWhV+sLt0CWdI/fM/hylAWvvD6h5Oy33nnXBbsya0WHbtCgHQtWtozdTWhs/fsgU2bdr//qKiMPVIz54hRIqKQrjs3g0ffRTW/eijzKZTLymBww+Hf/qncCXAAQPC1O49ex64n+5h+4nA2bEj1LtrV2iN1deHW0FBaDUVFYV9KC4OjxO3wsJwS4Rg4taliwJLOrQO10fh7ksBLP3/OKOAv7v78mjd3wLjgbRBIRkYPTrc6uvDv8i7dm3bs5fMwo/z4YfDWWdl9p6dO0PL5h//gPffD30kW7eG5T17Qmuka9fQXzJ0aGgp9OkTlsvKoHv3cKutDT/ymzeH965YEQ6JPflkCKWELl3CD3qXLuHv0B6n/RYUhL9N4pZKU2GSeN394KBMbLegIOxXQcH+WyKouiSdEZ/YRuK664kwTLzWcLvJ708OvlT7k0mItzY4k9/fks9vapud0ZAh4dIFbawjd2YPBFYmLa8CRqda0cwmA5MBBg8enP3KckWXLh3nanjdu4cAGDq09dsqLw+HnY49dv9ztbWhBbVmTQjHzZvDc/X14cehW7dwSwTOoYeGw2WHHBJaDYkf3rq68L49e8Jt795wn2gd1dYe+Hjv3nCrqwu3xI9zqh+ylvy4JQcH7P+xr6vbf5/43OQR+u4H/vgnfvgTy8k/mMlBkrzc2H5kS/Jn5Vjf6kHS7V+6MOvfv+1rIYtBYWZzgX4pXrrB3Z9oy89y9+nAdAiHntpy25IjCgvDv7aGDIm7EpFOJ2tB4e5pzsHMyAfAYUnLg6LnRESkHXXkKTxeA4aa2eFmVgx8EZgTc00iInknlqAwswvMbBXwGeApM3suen6AmT0N4O61wNeA54ClwGPu/nYc9YqI5LO4znp6HHg8xfMfAuckLT8NPN2OpYmISAMd+dCTiIh0AAoKERFJS0EhIiJpKShERCStnJs91szWA++3YhO9gQ1tVE5HoX3qPHJxv3JxnyD39uuT7t4n1Qs5FxStZWY1jU2M1VlpnzqPXNyvXNwnyN39SkWHnkREJC0FhYiIpKWgONj0uAvIAu1T55GL+5WL+wS5u18HUR+FiIikpRaFiIikpaAQEZG0FBQRMzvLzN4xs7+b2ZS462kpMzvMzF40syVm9raZfTN6vtzMnjezZdF9Wdy1NpeZFZjZX83syWj5cDNbEH1ns6Lp6DsNM+tlZrPN7G9mttTMPpMj39O3o//23jKzR82sW2f7rszsATNbZ2ZvJT2X8rux4OfRvr1hZsfHV3l2KCgIP0DAL4CzgWHApWY2LN6qWqwWuNbdhwEnAP8e7csUYJ67DwXmRcudzTcJU84n3Abc6e6fAjYDX4mlqpa7C3jW3Y8CRhD2rVN/T2Y2EPgGUO3ulUAB4Voyne27eghoeMH3xr6bs4Gh0W0y8Mt2qrHdKCiCUcDf3X25u+8BfguMj7mmFnH31e7+evR4G+HHZyBhf2ZEq80Azo+lwBYys0HAucB90bIBnwVmR6t0qn0ys57AqcD9AO6+x9230Mm/p0ghcIiZFQLdgdV0su/K3ecDmxo83dh3Mx542IM/A73MLDsXr46JgiIYCKxMWl4VPdepmdkQ4DhgAdDX3VdHL60B+sZVVwv9B3AdUB8tVwBbogtcQef7zg4H1gMPRofT7jOzQ+nk35O7fwDcAfyDEBAfAQvp3N9VQmPfTU7+fiRTUOQoM+sB/A74lrtvTX7NwznRnea8aDM7D1jn7gvjrqUNFQLHA7909+OAHTQ4zNTZvieA6Lj9eEIQDgAO5eBDOJ1eZ/xuWkNBEXwAHJa0PCh6rlMysyJCSMx0999HT69NNIej+3Vx1dcCJwGfN7MVhMOCnyUc3+8VHd6AzvedrQJWufuCaHk2ITg68/cEMBZ4z93Xu/te4PeE768zf1cJjX03OfX7kYqCIngNGBqdmVFM6HybE3NNLRIdu78fWOru/yfppTnAhOjxBOCJ9q6tpdz9++4+yN2HEL6bF9z9MuBF4KJotc62T2uAlWb2v6KnzgCW0Im/p8g/gBPMrHv032Jivzrtd5Wkse9mDnBFdPbTCcBHSYeocoJGZkfM7BzCcfAC4AF3/3G8FbWMmZ0MvAS8yf7j+T8g9FM8BgwmTMN+sbs37Kzr8MxsDPBddz/PzI4gtDDKgb8Cl7v7xzGW1yxmVkXonC8GlgNXEv7x1qm/JzO7CbiEcAbeX4FJhGP2nea7MrNHgTGEqcTXAj8C/kCK7yYKxLsJh9h2Ale6e00MZWeNgkJERNLSoScREUlLQSEiImkpKEREJC0FhYiIpKWgEBGRtBQUIg2Y2X9H90PM7F/beNs/SPVZIh2ZTo8VaUTymI1mvKcwaU6jVK9vd/cebVCeSLtRi0KkATPbHj2cBpxiZouiaywUmNntZvZadN2Br0brjzGzl8xsDmEUMmb2BzNbGF2XYXL03DTCrKqLzGxm8mdFo3pvj67h8KaZXZK07f+XdN2KmdEAL8xsmoXrjrxhZne0599I8kth06uI5K0pJLUooh/8j9x9pJl1BV4xsz9G6x4PVLr7e9Hyl6NRu4cAr5nZ79x9ipl9zd2rUnzWF4AqwnUpekfvmR+9dhxwDPAh8ApwkpktBS4AjnJ3N7NebbvrIvupRSGSuXGEOX0WEaZEqSBcrAbgL0khAfANM1sM/JkwYdxQ0jsZeNTd69x9LfAnYGTStle5ez2wCBhCmL57N3C/mX2BMHWESFYoKEQyZ8DX3b0quh3u7okWxY59K4W+jbHAZ9x9BGFuo26t+NzkOZHqgEQ/yCjCrLPnAc+2YvsiaSkoRBq3DShJWn4O+LdoGnfM7MjoYkMN9QQ2u/tOMzuKcEnahL2J9zfwEnBJ1A/Sh3D1u780Vlh0vZGe7v408G3CISuRrFAfhUjj3gDqokNIDxGugTEEeD3qUF5P6kt6PgtcHfUjvEM4/JQwHXjDzF6PpkpPeBz4DLCYcEGc69x9TRQ0qZQAT5hZN0JL5zst2kORDOj0WBERSUuHnkREJC0FhYiIpKWgEBGRtBQUIiKSloJCRETSUlCIiEhaCgoREUnr/wMCXObsYL6wawAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -1326,9 +1277,8 @@ ], "source": [ "# Print the final state\n", - "#state_final = cir_final.run_density_matrix()\n", - "state_final = cir_final.run_state_vector()\n", - "print(\"state_final:\\n\", state_final.numpy())\n", + "state_final = cir()\n", + "print(\"state_final:\\n\", state_final.data.numpy())\n", "\n", "# Print the loss function during iteration\n", "plt.figure(1)\n", @@ -1377,12 +1327,12 @@ "\\tag{21}\n", "$$\n", "\n", - "A function `cir.run_state_vector(input_state = None)` will be used in the following code. If we don't enter any initial quantum state, all qubits will be set into the $\\lvert {0}\\rangle$ state by default. Let's take a specific example:" + "Calling the function `paddle_quantum.set_backend(\"state_vector\")` changes the mode to state vector mode. Note that the operating model is the state vector mode by default. One need to call the function `final_state = cir(input_state=initial_state)` to run a circuit `cir`, where the input state is `initial state` and the output state is `final_state`, both of which are state vectors. If we don't enter any input state, it will be set into the $\\lvert {0}\\rangle$ state by default. Let's take a specific example:" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:55:44.714297Z", @@ -1394,35 +1344,36 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[ 5.21890277e-05+0.j -2.92638723e-04+0.j 5.14596730e-04+0.j ...\n", - " 2.02212900e-03+0.j -1.17159500e-03+0.j -5.82856577e-04+0.j]]\n" + "[-5.4838351e-04+0.j -2.7753570e-04+0.j 6.3722655e-05+0.j ...\n", + " -2.3885426e-04+0.j 1.8981205e-04+0.j -6.4218853e-05+0.j]\n" ] } ], "source": [ - "N = 20 # Set the number of qubits\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.state import zero_state, random_state\n", + "\n", + "N = 10 # Set the number of qubits\n", "DEPTH = 6 # Set the quantum circuit depth\n", - "theta = np.random.randn(DEPTH, N, 1)\n", "\n", - "# Call the built-in |00..0> initial state\n", - "initial_state1 = vec(0, N)\n", - "# Call the built-in random quantum state |psi>\n", - "initial_state2 = vec_random(N)\n", - " \n", - "# We need to convert numpy.ndarray to Tensor in PaddlePaddle\n", - "theta = paddle.to_tensor(theta)\n", - "initial_state = paddle.to_tensor(initial_state1)\n", + "# Set state vector mode\n", + "paddle_quantum.set_backend(\"state_vector\")\n", + "\n", + "# Call the built-in zero state function to create a zero state\n", + "initial_state1 = zero_state(num_qubits=N)\n", + "# Call the built-in random state function to create a random state\n", + "initial_state2 = random_state(num_qubits=N)\n", "\n", "# Initialize the quantum circuit\n", - "cir = UAnsatz(N)\n", + "cir = Circuit(N)\n", "\n", "# Add a real entanglement structure QNN {Ry+CNOT's} with depth of DEPTH\n", - "cir.real_entangled_layer(theta, DEPTH)\n", + "cir.real_entangled_layer(depth=DEPTH)\n", "\n", - "# Prepare output state\n", - "# If the user does not enter the initial quantum state, the default initial state is |00..0>\n", - "final_state = cir.run_state_vector(initial_state)\n", - "print(final_state.numpy())" + "# Run the circuit on the initial state, If the user does not enter the initial quantum state, the default initial state is |00..0>\n", + "final_state1 = cir(initial_state1)\n", + "print(final_state1.data.numpy())" ] }, { @@ -1439,12 +1390,12 @@ "\\tag{22}\n", "$$\n", "\n", - "Function `cir.run_density_matrix()` will be used in the following code. Here is an example:" + "One need to call the function `paddle_quantum.set_backend(\"density_matrix\")` to set the density matrix mode. The way of running a circuit is almost the same as in the state vector mode, except that both of input and output states are density matrices. Here is an example:" ] }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:55:45.027724Z", @@ -1456,43 +1407,45 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[ 6.96262776e-01+0.j -3.29640355e-01+0.j 2.06852686e-02+0.j\n", - " -3.19984811e-01+0.j]\n", - " [-3.29640355e-01+0.j 1.56065737e-01+0.j -9.79328424e-03+0.j\n", - " 1.51494393e-01+0.j]\n", - " [ 2.06852686e-02+0.j -9.79328424e-03+0.j 6.14538578e-04+0.j\n", - " -9.50642772e-03+0.j]\n", - " [-3.19984811e-01+0.j 1.51494393e-01+0.j -9.50642772e-03+0.j\n", - " 1.47056948e-01+0.j]]\n" + "[[ 0.5808575 -1.0710210e-08j -0.07621858-1.5724729e-01j\n", + " 0.3288467 +5.1938809e-02j 0.24451724-1.8499317e-03j]\n", + " [-0.07621857+1.5724732e-01j 0.08419196-5.5879354e-09j\n", + " -0.05945612+7.4587353e-02j -0.01910382+7.2627157e-02j]\n", + " [ 0.32884675-5.1938821e-02j -0.05945611-7.4587345e-02j\n", + " 0.2059458 +1.1175871e-08j 0.12963158-5.9516393e-03j]\n", + " [ 0.24451725+1.8499183e-03j -0.01910383-7.2627142e-02j\n", + " 0.12963158+5.9516374e-03j 0.12900479-5.1804818e-09j]]\n" ] } ], "source": [ + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.state import zero_state, random_state, completely_mixed_computational\n", + "\n", "N = 2 # Set the number of qubits\n", "DEPTH = 6 # Set the quantum circuit depth\n", - "theta = np.random.randn(DEPTH, N, 1)\n", + "\n", + "# Set density matrix mode\n", + "paddle_quantum.set_backend(\"density_matrix\")\n", "\n", "# Call the built-in |00..0><00..0| initial state\n", - "initial_state1 = density_op(N)\n", + "initial_state1 = zero_state(N)\n", "# Call the built-in random quantum state, you can specify whether to allow complex number elements and matrix rank\n", - "initial_state2 = density_op_random(N, real_or_complex=2, rank=4)\n", + "initial_state2 = random_state(N, is_real=False, rank=4)\n", "# Call the complete mixed state under the built-in calculation base\n", "initial_state3 = completely_mixed_computational(N)\n", "\n", - "# We need to convert numpy.ndarray to Tensor in PaddlePaddle\n", - "theta = paddle.to_tensor(theta)\n", - "initial_state = paddle.to_tensor(initial_state1)\n", - "\n", "# Initialize the quantum circuit\n", - "cir = UAnsatz(N)\n", + "cir = Circuit(N)\n", "\n", "# Add a real number strong entanglement structure QNN {Ry+CNOT's} with depth of DEPTH\n", - "cir.real_entangled_layer(theta, DEPTH)\n", + "cir.real_entangled_layer(depth=DEPTH)\n", "\n", "# Prepare output state\n", "# If the user does not enter the initial quantum state, the default initial is |00..0><00..0|\n", - "final_state = cir.run_density_matrix(initial_state)\n", - "print(final_state.numpy())" + "final_state = cir(initial_state2)\n", + "print(final_state.data.numpy())" ] }, { @@ -1522,7 +1475,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:55:49.403917Z", @@ -1532,7 +1485,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -1547,25 +1500,28 @@ "output_type": "stream", "text": [ "The Bell state is:\n", - " [0.70710678+0.j 0. +0.j 0. +0.j 0.70710678+0.j]\n" + " [0.70710677+0.j 0. +0.j 0. +0.j 0.70710677+0.j]\n" ] } ], "source": [ - "# Initialize the quantum circuit\n", - "cir = UAnsatz(2)\n", + "# Set state vector mode\n", + "paddle_quantum.set_backend(\"state_vector\")\n", + "\n", + "# Create a circuit\n", + "cir = Circuit(2)\n", "\n", "# Add quantum gates\n", "cir.h(0)\n", "cir.cnot([0, 1])\n", "\n", "# If the user does not enter the initial quantum state, the default initial is |00..0>\n", - "output_state = cir.run_state_vector()\n", + "output_state = cir()\n", "\n", "# We measure the output state 2048 times and obtain the frequency distribution of the measurement results\n", - "cir.measure(shots = 2048, plot = True)\n", + "output_state.measure(shots = 2048, plot = True)\n", "\n", - "print('The Bell state is:\\n', output_state.numpy())" + "print('The Bell state is:\\n', output_state.data.numpy())" ] }, { @@ -1597,7 +1553,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 22, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:56:01.481603Z", @@ -1609,7 +1565,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "The minimum value of the loss function is: 10.000000010746223\n" + "The minimum value of the loss function is: 10.0\n" ] } ], @@ -1623,7 +1579,7 @@ "\n", "class Optimization_ex1(paddle.nn.Layer):\n", " \n", - " def __init__(self, shape, dtype='float64'):\n", + " def __init__(self, shape, dtype='float32'):\n", " super(Optimization_ex1, self).__init__()\n", " \n", " # Initialize a list of learnable parameters with length theta_size\n", @@ -1722,7 +1678,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 23, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:56:04.176637Z", @@ -1735,8 +1691,8 @@ "output_type": "stream", "text": [ "The randomly generated matrix H according to the spectral decomposition is:\n", - "[[ 0.4148327 -6.93889390e-18j -0.28540716-3.59066212e-02j]\n", - " [-0.28540716+3.59066212e-02j 0.5851673 +0.00000000e+00j]] \n", + "[[0.29312716+0.j 0.20572598-0.06986022j]\n", + " [0.20572598+0.06986022j 0.70687284+0.j ]] \n", "\n", "The eigenvalues of H are:\n", "[0.2 0.8]\n" @@ -1766,7 +1722,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 24, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:56:04.205868Z", @@ -1784,21 +1740,21 @@ "paddle.seed(SEED)\n", "\n", "# Set the circuit module separately\n", - "def U_theta(theta):\n", + "def U_theta() -> Circuit:\n", " \n", " # Initialize the circuit and add the quantum gates\n", - " cir = UAnsatz(num_qubits)\n", - " cir.rz(theta[2], 0)\n", - " cir.ry(theta[1], 0)\n", - " cir.rz(theta[0], 0)\n", + " cir = Circuit(num_qubits)\n", + " cir.rz(0)\n", + " cir.ry(0)\n", + " cir.rz(0)\n", " \n", - " # Return parameterized matrix\n", - " return cir.U" + " # Return circuit\n", + " return cir" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 25, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:56:04.793520Z", @@ -1807,36 +1763,19 @@ }, "outputs": [], "source": [ - "class Optimization_ex2(paddle.nn.Layer):\n", - " \n", - " def __init__(self, shape, dtype='float64'):\n", - " super(Optimization_ex2, self).__init__()\n", - " \n", - " # Initialize a list of trainable parameters with length theta_size\n", - " # And use the uniform distribution of [0, 2*pi] to fill the initial value\n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0., high=2*np.pi), \n", - " dtype=dtype, is_bias=False)\n", - " self.H = paddle.to_tensor(H)\n", - " \n", - " # Define loss function and forward propagation mechanism\n", - " def forward(self):\n", - " \n", + "def loss_func(cir: Circuit, H: paddle.Tensor) -> paddle.Tensor:\n", " # Get the unitary matrix representation of the quantum neural network\n", - " U = U_theta(self.theta)\n", - " \n", + " U = cir.unitary_matrix().cast('complex64')\n", " # Conjugate transpose operation\n", " U_dagger = dagger(U)\n", - " \n", " # Calculate the loss function\n", - " loss = paddle.real(matmul(U_dagger, matmul(self.H, U)))[0][0]\n", - " \n", + " loss = paddle.real(matmul(U_dagger, matmul(H, U)))[0][0]\n", " return loss" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 26, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T03:56:11.561432Z", @@ -1848,17 +1787,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "iter: 0 loss: 0.7704\n", - "iter: 5 loss: 0.6964\n", - "iter: 10 loss: 0.5480\n", - "iter: 15 loss: 0.4297\n", - "iter: 20 loss: 0.3643\n", - "iter: 25 loss: 0.2958\n", - "iter: 30 loss: 0.2372\n", - "iter: 35 loss: 0.2104\n", - "iter: 40 loss: 0.2025\n", - "iter: 45 loss: 0.2006\n", - "The minimum value of the loss function is: 0.20016689983553002\n" + "iter: 0 loss: 0.2134\n", + "iter: 5 loss: 0.2055\n", + "iter: 10 loss: 0.2024\n", + "iter: 15 loss: 0.2011\n", + "iter: 20 loss: 0.2005\n", + "iter: 25 loss: 0.2002\n", + "iter: 30 loss: 0.2001\n", + "iter: 35 loss: 0.2000\n", + "iter: 40 loss: 0.2000\n", + "iter: 45 loss: 0.2000\n", + "The minimum value of the loss function is: 0.20000416\n" ] } ], @@ -1866,16 +1805,16 @@ "loss_list = []\n", "parameter_list = []\n", "\n", - "myLayer = Optimization_ex2([theta_size])\n", + "cir = U_theta()\n", "\n", "# SGD optimizer\n", - "opt = paddle.optimizer.SGD(learning_rate = LR, parameters = myLayer.parameters())\n", + "opt = paddle.optimizer.SGD(learning_rate = LR, parameters = cir.parameters())\n", "\n", "# Optimization cycle\n", "for itr in range(ITR):\n", "\n", " # Forward propagation calculates loss function\n", - " loss = myLayer()[0]\n", + " loss = loss_func(cir, paddle.to_tensor(H).cast('complex64'))\n", "\n", " # Back propagation minimizes the loss function\n", " loss.backward()\n", @@ -1902,9 +1841,7 @@ "\\tag{29}\n", "$$\n", "\n", - "We still get the minimum eigenvalue of $\\lambda_{\\text{min}}(H)=0.8$. Can you find the reason behind it? Or is there any theory behind this?\n", - "\n", - "---" + "We still get the minimum eigenvalue of $\\lambda_{\\text{min}}(H)=0.8$. Can you find the reason behind it? Or is there any theory behind this?" ] }, { @@ -1936,8 +1873,11 @@ } ], "metadata": { + "interpreter": { + "hash": "f7cfecff1ef1940b21a48efa1b88278bb096bd916f13c2df11af4810c38b47e1" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.0 ('pq')", "language": "python", "name": "python3" }, @@ -1951,7 +1891,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.0" }, "toc": { "base_numbering": 1, diff --git a/paddle_quantum/GIBBS/HGenerator.py b/paddle_quantum/GIBBS/HGenerator.py index 7ea3857..61acbab 100644 --- a/paddle_quantum/GIBBS/HGenerator.py +++ b/paddle_quantum/GIBBS/HGenerator.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,13 +13,13 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" HGenerator """ import scipy from numpy import trace as np_trace -from paddle_quantum.utils import pauli_str_to_matrix +from paddle_quantum.qinfo import pauli_str_to_matrix __all__ = ["H_generator", ] @@ -33,13 +34,13 @@ def H_generator(): # Generate the matrix form of the Hamiltonian N_SYS_B = 3 # Number of qubits in subsystem B used to generate Gibbs state - hamiltonian = pauli_str_to_matrix(H, N_SYS_B) + hamiltonian = pauli_str_to_matrix(H, N_SYS_B).numpy() # Generate the target Gibbs state rho beta = 1.5 # Set inverse temperature beta rho_G = scipy.linalg.expm(-1 * beta * hamiltonian) / np_trace(scipy.linalg.expm(-1 * beta * hamiltonian)) # Convert to the data type supported by Paddle Quantum - hamiltonian = hamiltonian.astype("complex128") - rho_G = rho_G.astype("complex128") + hamiltonian = hamiltonian + rho_G = rho_G return hamiltonian, rho_G diff --git a/paddle_quantum/GIBBS/Paddle_GIBBS.py b/paddle_quantum/GIBBS/Paddle_GIBBS.py index 32035ad..3010f3b 100644 --- a/paddle_quantum/GIBBS/Paddle_GIBBS.py +++ b/paddle_quantum/GIBBS/Paddle_GIBBS.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,71 +13,34 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" Paddle_GIBBS """ from numpy import pi as PI import paddle from paddle import matmul, trace -from paddle_quantum.circuit import UAnsatz -from paddle_quantum.state import density_op -from paddle_quantum.utils import state_fidelity, partial_trace +import paddle_quantum +from paddle_quantum.ansatz import Circuit +from paddle_quantum.state import zero_state +from paddle_quantum.qinfo import state_fidelity, partial_trace from paddle_quantum.GIBBS.HGenerator import H_generator SEED = 14 # Choose the seed for random generator __all__ = [ - "U_theta", - "Net", + "loss_func", "Paddle_GIBBS", ] -def U_theta(initial_state, theta, N, D): - """ - Quantum Neural Network - """ - - # Initialize the quantum neural network by the number of qubits (width of the network) - cir = UAnsatz(N) - - # Use in-built template (R_y + CNOT) - cir.real_entangled_layer(theta[:D], D) - - # Add a layer of R_y rotation gate - for i in range(N): - cir.ry(theta=theta[D][i][0], which_qubit=i) - - # Act quantum neural network on initialized state - final_state = cir.run_density_matrix(initial_state) - - return final_state - - -class Net(paddle.nn.Layer): - """ - Construct the model net - """ - - def __init__(self, N, shape, param_attr=paddle.nn.initializer.Uniform(low=0.0, high=2 * PI), - dtype='float64'): - super(Net, self).__init__() - # Initialize theta by sampling from a uniform distribution [0, 2*pi] - self.theta = self.create_parameter(shape=shape, attr=param_attr, dtype=dtype, is_bias=False) - # Set the initial state as rho = |0..0><0..0| - self.initial_state = paddle.to_tensor(density_op(N)) - - # Define the loss function and forward propagation mechanism - def forward(self, H, N, N_SYS_B, beta, D): - # Apply quantum neural network onto the initial state - rho_AB = U_theta(self.initial_state, self.theta, N, D) - - # Calculate the partial trace to get the state rho_B of subsystem B +def loss_func(rho_AB, H, N, N_SYS_B, beta): + # Calculate the partial trace to get the state rho_B of subsystem B rho_B = partial_trace(rho_AB, 2 ** (N - N_SYS_B), 2 ** N_SYS_B, 1) # Calculate the three components of the loss function rho_B_squre = matmul(rho_B, rho_B) + loss1 = paddle.real(trace(matmul(rho_B, H))) loss2 = paddle.real(trace(rho_B_squre)) * 2 / beta loss3 = - (paddle.real(trace(matmul(rho_B_squre, rho_B))) + 3) / (2 * beta) @@ -99,27 +63,28 @@ def Paddle_GIBBS(hamiltonian, rho_G, N=4, N_SYS_B=3, beta=1.5, D=1, ITR=50, LR=0 :param LR: Learning rate :return: State prepared by optimized QNN """ + paddle_quantum.set_backend(paddle_quantum.Backend.DensityMatrix) # We need to convert Numpy array to variable supported in PaddlePaddle - H = paddle.to_tensor(hamiltonian) + H = paddle.to_tensor(hamiltonian, dtype = paddle_quantum.get_dtype()) # Fix the dimensions of network - net = Net(N, shape=[D + 1, N, 1]) - + net = Circuit(N) + net.real_entangled_layer(depth=D) + net.ry('full') # Usually, we recommend Adam optimizer for better results. If you wish, you could use SGD or RMS prop. opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters()) # Optimization iterations for itr in range(1, ITR + 1): # Run forward propagation to calculate loss function and obtain state rho_B - loss, rho_B = net(H, N, N_SYS_B, beta, D) - + rho_AB = net() + loss, rho_B = loss_func(rho_AB, H, N, N_SYS_B, beta) # In dynamic graph, run backward propagation to minimize loss function loss.backward() opt.minimize(loss) opt.clear_grad() # Convert variable to Numpy array to calculate fidelity F(rho_B, rho_G) - rho_B = rho_B.numpy() - fid = state_fidelity(rho_B, rho_G) + fid = state_fidelity(paddle_quantum.state.to_state(rho_B), paddle_quantum.state.to_state(rho_G)) # Print results if itr % 5 == 0: print('iter:', itr, 'loss:', '%.4f' % loss.numpy(), 'fid:', '%.4f' % fid) diff --git a/paddle_quantum/GIBBS/example/main.py b/paddle_quantum/GIBBS/example/main.py index 8fae5b0..1b87eef 100644 --- a/paddle_quantum/GIBBS/example/main.py +++ b/paddle_quantum/GIBBS/example/main.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,13 +13,14 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" main """ import scipy from numpy import trace as np_trace -from paddle_quantum.utils import pauli_str_to_matrix +import paddle_quantum +from paddle_quantum.qinfo import pauli_str_to_matrix from paddle_quantum.GIBBS.Paddle_GIBBS import Paddle_GIBBS @@ -28,15 +30,15 @@ def main(): # Generate the matrix form of the Hamiltonian N_SYS_B = 3 # Number of qubits in subsystem B used to generate Gibbs state - hamiltonian = pauli_str_to_matrix(H, N_SYS_B) + hamiltonian = pauli_str_to_matrix(H, N_SYS_B).numpy() # Generate the target Gibbs state rho beta = 1.5 # Set inverse temperature beta rho_G = scipy.linalg.expm(-1 * beta * hamiltonian) / np_trace(scipy.linalg.expm(-1 * beta * hamiltonian)) # Convert to the data type supported by Paddle Quantum - hamiltonian = hamiltonian.astype("complex128") - rho_G = rho_G.astype("complex128") + hamiltonian = hamiltonian + rho_G = rho_G rho_B = Paddle_GIBBS(hamiltonian, rho_G) print(rho_B) diff --git a/paddle_quantum/QAOA/example/main.py b/paddle_quantum/QAOA/example/main.py index 83e7207..36fc53d 100644 --- a/paddle_quantum/QAOA/example/main.py +++ b/paddle_quantum/QAOA/example/main.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,15 +13,16 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" main """ + import numpy as np import networkx as nx import matplotlib.pyplot as plt import paddle from paddle_quantum.QAOA.maxcut import maxcut_hamiltonian, find_cut -from paddle_quantum.utils import pauli_str_to_matrix +from paddle_quantum.qinfo import pauli_str_to_matrix SEED = 1024 options = { @@ -50,7 +52,7 @@ def main(n=4): ax.margins(0.20) plt.axis("off") plt.show() - + # construct the Hamiltonian H_D_list = maxcut_hamiltonian(E) H_D_matrix = pauli_str_to_matrix(H_D_list, n) @@ -66,7 +68,7 @@ def main(n=4): node_cut = ["blue" if cut_bitstring[v] == "1" else "red" for v in V] edge_cut = ["solid" if cut_bitstring[u] == cut_bitstring[v] else "dashed" for (u, v) in G.edges()] - nx.draw(G, pos, node_color = node_cut, style=edge_cut, **options) + nx.draw(G, pos, node_color=node_cut, style=edge_cut, **options) ax = plt.gca() ax.margins(0.20) plt.axis("off") diff --git a/paddle_quantum/QAOA/maxcut.py b/paddle_quantum/QAOA/maxcut.py index dc81740..4be9bc0 100644 --- a/paddle_quantum/QAOA/maxcut.py +++ b/paddle_quantum/QAOA/maxcut.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,21 +13,21 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" To learn more about the functions and properties of this application, you could check the corresponding Jupyter notebook under the Tutorial folder. """ -import paddle -from paddle_quantum.circuit import UAnsatz - import numpy as np import networkx as nx - +import paddle +import paddle_quantum +from paddle_quantum.ansatz import Circuit +from paddle_quantum.loss import ExpecVal +from paddle_quantum import Hamiltonian __all__ = [ "maxcut_hamiltonian", - "circuit_maxcut", "find_cut", ] @@ -47,65 +48,6 @@ def maxcut_hamiltonian(E): return H_D_list -def circuit_maxcut(E, V, p, gamma, beta): - r"""构建用于最大割问题的 QAOA 参数化电路。 - - Args: - E: 图的边 - V: 图的顶点 - p: QAOA 电路的层数 - gamma: 与最大割问题哈密顿量相关的电路参数 - beta: 与混合哈密顿量相关的电路参数 - - Returns: - UAnsatz: 构建好的 QAOA 电路 - """ - # Number of qubits needed - n = len(V) - cir = UAnsatz(n) - cir.superposition_layer() - for layer in range(p): - for (u, v) in E: - cir.cnot([u, v]) - cir.rz(gamma[layer], v) - cir.cnot([u, v]) - for i in V: - cir.rx(beta[layer], i) - - return cir - - -class _MaxcutNet(paddle.nn.Layer): - """ - It constructs the net for maxcut which combines the QAOA circuit with the classical optimizer that sets rules - to update parameters described by theta introduced in the QAOA circuit. - """ - def __init__( - self, - p, - dtype="float64", - ): - super(_MaxcutNet, self).__init__() - - self.p = p - self.gamma = self.create_parameter(shape=[self.p], - default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi), - dtype=dtype, is_bias=False) - self.beta = self.create_parameter(shape=[self.p], - default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi), - dtype=dtype, is_bias=False) - - def forward(self, E, V, H_D_list): - """ - Forward propagation - """ - cir = circuit_maxcut(E, V, self.p, self.gamma, self.beta) - cir.run_state_vector() - loss = -cir.expecval(H_D_list) - - return loss, cir - - def find_cut(G, p, ITR, LR, print_loss=False, shots=0, plot=False): r"""运行 QAOA 寻找最大割问题的近似解。 @@ -133,18 +75,24 @@ def find_cut(G, p, ITR, LR, print_loss=False, shots=0, plot=False): E = list(G_mapped.edges()) n = len(V) H_D_list = maxcut_hamiltonian(E) - net = _MaxcutNet(p) + net = Circuit(n) + net.superposition_layer() + net.qaoa_layer(E, V, p) + hamiltonian = Hamiltonian(H_D_list) + loss_func = ExpecVal(hamiltonian) opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters()) for itr in range(1, ITR + 1): - loss, cir = net(E, V, H_D_list) + state = net() + loss = -loss_func(state) loss.backward() opt.minimize(loss) opt.clear_grad() if print_loss and itr % 10 == 0: print("iter:", itr, " loss:", "%.4f" % loss.numpy()) - prob_measure = cir.measure(shots=shots, plot=plot) + state = net() + prob_measure = state.measure(shots=shots, plot=plot) cut_bitstring = max(prob_measure, key=prob_measure.get) return cut_bitstring, prob_measure diff --git a/paddle_quantum/QAOA/tsp.py b/paddle_quantum/QAOA/tsp.py index a89fff4..2ed5025 100644 --- a/paddle_quantum/QAOA/tsp.py +++ b/paddle_quantum/QAOA/tsp.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" Travelling Salesman Problem (TSP): To learn more about the functions and properties of this application, you could check the corresponding Jupyter notebook under the Tutorial folder. """ @@ -22,10 +23,8 @@ import numpy as np import networkx as nx import paddle -from paddle_quantum.circuit import UAnsatz -from paddle_quantum.utils import pauli_str_to_matrix - - +import paddle_quantum +from paddle_quantum.qinfo import pauli_str_to_matrix __all__ = [ "tsp_hamiltonian", @@ -93,32 +92,6 @@ def tsp_hamiltonian(g, A, n): return H_C_list -class _TSPNet(paddle.nn.Layer): - """ - It constructs the net for TSP which combines the complex entangled circuit with the classical optimizer that sets rules - to update parameters described by theta introduced in the circuit. - """ - def __init__(self, n, p, dtype="float64"): - super(_TSPNet, self).__init__() - - self.p = p - self.num_qubits = (n - 1) ** 2 - self.theta = self.create_parameter(shape=[self.p, self.num_qubits, 3], - default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi), - dtype=dtype, is_bias=False) - - def forward(self, H_C_ls): - """ - Forward propagation - """ - cir = UAnsatz(self.num_qubits) - cir.complex_entangled_layer(self.theta, self.p) - cir.run_state_vector() - loss = cir.expecval(H_C_ls) - - return loss, cir - - def solve_tsp(g, A, p=2, ITR=120, LR=0.4, print_loss=False, shots=0): """ This is the core function to solve the TSP. @@ -137,19 +110,22 @@ def solve_tsp(g, A, p=2, ITR=120, LR=0.4, print_loss=False, shots=0): n = len(v) H_C_list = tsp_hamiltonian(g, A, n) - - net = _TSPNet(n, p) + net = paddle_quantum.ansatz.Circuit((n - 1) ** 2) + net.complex_entangled_layer(depth=p) + loss_func = paddle_quantum.loss.ExpecVal(H_C_list) opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters()) for itr in range(1, ITR + 1): - loss, cir = net(H_C_list) + state = net() + loss = loss_func(state) loss.backward() opt.minimize(loss) opt.clear_grad() if print_loss and itr % 10 == 0: - print("iter:", itr, "loss:", "%.4f"% loss.numpy()) + print("iter:", itr, "loss:", "%.4f" % loss.numpy()) - prob_measure = cir.measure(shots=shots) + state = net() + prob_measure = state.measure(shots=shots) reduced_salesman_walk = max(prob_measure, key=prob_measure.get) str_by_vertex = [reduced_salesman_walk[i:i + n - 1] for i in range(0, len(reduced_salesman_walk) + 1, n - 1)] salesman_walk = '0'.join(str_by_vertex) + '0' * (n - 1) + '1' diff --git a/paddle_quantum/SSVQE/HGenerator.py b/paddle_quantum/SSVQE/HGenerator.py index 31d2efc..cbb3b9a 100644 --- a/paddle_quantum/SSVQE/HGenerator.py +++ b/paddle_quantum/SSVQE/HGenerator.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,11 +13,11 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" HGenerator """ -from paddle_quantum.utils import random_pauli_str_generator, pauli_str_to_matrix +from paddle_quantum.qinfo import random_pauli_str_generator, pauli_str_to_matrix __all__ = ["H_generator"] diff --git a/paddle_quantum/SSVQE/Paddle_SSVQE.py b/paddle_quantum/SSVQE/Paddle_SSVQE.py index 8195c68..9f780ce 100644 --- a/paddle_quantum/SSVQE/Paddle_SSVQE.py +++ b/paddle_quantum/SSVQE/Paddle_SSVQE.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" Paddle_SSVQE: To learn more about the functions and properties of this application, you could check the corresponding Jupyter notebook under the Tutorial folder. """ @@ -21,85 +22,52 @@ import paddle from paddle import matmul -from paddle_quantum.circuit import UAnsatz -from paddle_quantum.utils import dagger + +import paddle_quantum +from paddle_quantum.ansatz import Circuit +from paddle_quantum.linalg import dagger from paddle_quantum.SSVQE.HGenerator import H_generator SEED = 14 # Choose the seed for random generator __all__ = [ - "U_theta", - "Net", + "loss_func", "Paddle_SSVQE", ] -def U_theta(theta, N): - """ - Quantum Neural Network - """ - - # Initialize the quantum neural network by the number of qubits (width of the network) - cir = UAnsatz(N) - - # Use a built-in QNN template - cir.universal_2_qubit_gate(theta, [0, 1]) - - # Return the Unitary matrix simulated by QNN - return cir.U - - -class Net(paddle.nn.Layer): - """ - Construct the model net - """ - - def __init__(self, shape, param_attr=paddle.nn.initializer.Uniform(low=0.0, high=2 * numpy.pi), - dtype='float64'): - super(Net, self).__init__() - - # Initialize theta by sampling from a uniform distribution [0, 2*pi] - self.theta = self.create_parameter(shape=shape, attr=param_attr, dtype=dtype, is_bias=False) - - # Define the loss function and forward propagation mechanism - def forward(self, H, N): - # Apply QNN onto the initial state - U = U_theta(self.theta, N) - - # Calculate loss function - loss_struct = paddle.real(matmul(matmul(dagger(U), H), U)) +def loss_func(U, H): + # Calculate loss function + loss_struct = paddle.real(matmul(matmul(dagger(U), H), U)) + # Use computational basis to calculate each expectation value, which is the same + # as a diagonal element in U^dagger*H*U + loss_components = [] + for i in range(len(loss_struct)): + loss_components.append(loss_struct[i][i]) - # Use computational basis to calculate each expectation value, which is the same - # as a diagonal element in U^dagger*H*U - loss_components = [] - for i in range(len(loss_struct)): - loss_components.append(loss_struct[i][i]) - - # Calculate the weighted loss function - loss = 0 - for i in range(len(loss_components)): - weight = 4 - i - loss += weight * loss_components[i] + # Calculate the weighted loss function + loss = 0 + for i in range(len(loss_components)): + weight = 4 - i + loss += weight * loss_components[i] - return loss, loss_components + return loss, loss_components -def Paddle_SSVQE(H, N=2, THETA_SIZE=15, ITR=50, LR=0.3): +def Paddle_SSVQE(H, N=2, ITR=50, LR=0.3): r""" Paddle_SSVQE :param H: Hamiltonian :param N: Number of qubits/Width of QNN - :param THETA_SIZE: Number of paramaters in QNN :param ITR: Number of iterations :param LR: Learning rate :return: First several smallest eigenvalues of the Hamiltonian """ # We need to convert Numpy array to variable supported in PaddlePaddle - hamiltonian = paddle.to_tensor(H) - - # Fix the dimensions of network - net = Net(shape=[THETA_SIZE]) + hamiltonian = H + net = Circuit(N) + net.universal_two_qubits([0, 1]) # Use Adagrad optimizer opt = paddle.optimizer.Adagrad(learning_rate=LR, parameters=net.parameters()) @@ -108,8 +76,8 @@ def Paddle_SSVQE(H, N=2, THETA_SIZE=15, ITR=50, LR=0.3): for itr in range(1, ITR + 1): # Run forward propagation to calculate loss function and obtain energy spectrum - loss, loss_components = net(hamiltonian, N) - + U = net.unitary_matrix() + loss, loss_components = loss_func(U, hamiltonian) # In dynamic graph, run backward propagation to minimize loss function loss.backward() opt.minimize(loss) diff --git a/paddle_quantum/SSVQE/example/main.py b/paddle_quantum/SSVQE/example/main.py index d2efaff..f8c28da 100644 --- a/paddle_quantum/SSVQE/example/main.py +++ b/paddle_quantum/SSVQE/example/main.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" main """ diff --git a/paddle_quantum/VQE/Paddle_VQE.py b/paddle_quantum/VQE/Paddle_VQE.py index ba87fdd..5a893bf 100644 --- a/paddle_quantum/VQE/Paddle_VQE.py +++ b/paddle_quantum/VQE/Paddle_VQE.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" VQE: To learn more about the functions and properties of this application, you could check the corresponding Jupyter notebook under the Tutorial folder. """ @@ -21,62 +22,20 @@ import platform import paddle -from numpy import pi as PI from numpy import savez -from paddle_quantum.circuit import UAnsatz + +import paddle_quantum +from paddle_quantum.ansatz import Circuit +from paddle_quantum.loss import ExpecVal from paddle_quantum.VQE.benchmark import benchmark_result from paddle_quantum.VQE.chemistrysub import H2_generator __all__ = [ - "U_theta", - "StateNet", "Paddle_VQE", ] -def U_theta(theta, Hamiltonian, N, D): - """ - Quantum Neural Network - """ - # Initialize the quantum neural network by the number of qubits (width of the network) - cir = UAnsatz(N) - - # Use built-in template (R_y + CNOT) - cir.real_entangled_layer(theta[:D], D) - - # Add a layer of R_y rotation gates - for i in range(N): - cir.ry(theta=theta[D][i][0], which_qubit=i) - - # Act QNN on the default initial state |0000> - cir.run_state_vector() - - # Calculate the expectation value of the given Hamiltonian - expectation_val = cir.expecval(Hamiltonian) - - return expectation_val - - -class StateNet(paddle.nn.Layer): - """ - Construct the model net - """ - - def __init__(self, shape, param_attr=paddle.nn.initializer.Uniform(low=0.0, high=2 * PI), dtype="float64"): - super(StateNet, self).__init__() - - # Initialize theta by sampling from a uniform distribution [0, 2*pi] - self.theta = self.create_parameter(shape=shape, attr=param_attr, dtype=dtype, is_bias=False) - - # Define the loss function and forward propagation mechanism - def forward(self, Hamiltonian, N, D): - # Calculate loss function (expectation value) - loss = U_theta(self.theta, Hamiltonian, N, D) - - return loss - - def Paddle_VQE(Hamiltonian, N, D=2, ITR=80, LR=0.2): r""" Main Learning network using dynamic graph @@ -89,7 +48,11 @@ def Paddle_VQE(Hamiltonian, N, D=2, ITR=80, LR=0.2): """ # Determine the dimensions of network - net = StateNet(shape=[D + 1, N, 1]) + net = Circuit(N) + net.real_entangled_layer(depth=D) + net.ry(qubits_idx='full') + + loss_func = ExpecVal(paddle_quantum.Hamiltonian(Hamiltonian)) # Usually, we recommend Adam optimizer for better result. If you wish, you could use SGD or RMS prop. opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters()) @@ -101,7 +64,8 @@ def Paddle_VQE(Hamiltonian, N, D=2, ITR=80, LR=0.2): for itr in range(1, ITR + 1): # Run forward propagation to calculate loss function - loss = net(Hamiltonian, N, D) + state = net() + loss = loss_func(state) # In dynamic graph, run backward propagation to minimize loss function loss.backward() diff --git a/paddle_quantum/VQE/benchmark.py b/paddle_quantum/VQE/benchmark.py index 89b9106..89f0bfe 100644 --- a/paddle_quantum/VQE/benchmark.py +++ b/paddle_quantum/VQE/benchmark.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" benchmark the result """ @@ -20,7 +21,7 @@ import platform import matplotlib.pyplot as plt import numpy -from paddle_quantum.utils import pauli_str_to_matrix +from paddle_quantum.qinfo import pauli_str_to_matrix from paddle_quantum.VQE.chemistrysub import H2_generator __all__ = [ diff --git a/paddle_quantum/VQE/chemistrygen.py b/paddle_quantum/VQE/chemistrygen.py index 9c9a7d6..07b9787 100644 --- a/paddle_quantum/VQE/chemistrygen.py +++ b/paddle_quantum/VQE/chemistrygen.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" chemistry """ diff --git a/paddle_quantum/VQE/chemistrysub.py b/paddle_quantum/VQE/chemistrysub.py index 41bb179..ab7330e 100644 --- a/paddle_quantum/VQE/chemistrysub.py +++ b/paddle_quantum/VQE/chemistrysub.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -72,7 +73,7 @@ def H2_generator(): # + (0.12293305056183798) * kron(kron(kron(sigma_I, sigma_Z), sigma_I), sigma_Z) \ # + (0.17627640804319591) * kron(kron(kron(sigma_I, sigma_I), sigma_Z), sigma_Z) H = [ - [-0.04207897647782277, 'i0'], + [-0.04207897647782277, 'i'], [0.17771287465139946, 'z0'], [0.1777128746513994, 'z1'], [-0.2427428051314046, 'z2'], diff --git a/paddle_quantum/VQE/example/main.py b/paddle_quantum/VQE/example/main.py index 53eee45..b68e389 100644 --- a/paddle_quantum/VQE/example/main.py +++ b/paddle_quantum/VQE/example/main.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" main """ diff --git a/paddle_quantum/VQSD/HGenerator.py b/paddle_quantum/VQSD/HGenerator.py index 3d66f0c..9a8a8a5 100644 --- a/paddle_quantum/VQSD/HGenerator.py +++ b/paddle_quantum/VQSD/HGenerator.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" HGenerator """ @@ -34,5 +35,5 @@ def generate_rho_sigma(): # print(rho) # Print quantum state rho # Input the quantum state sigma - sigma = numpy.diag([0.1, 0.2, 0.3, 0.4]).astype('complex128') + sigma = numpy.diag([0.1, 0.2, 0.3, 0.4]) return rho, sigma diff --git a/paddle_quantum/VQSD/Paddle_VQSD.py b/paddle_quantum/VQSD/Paddle_VQSD.py index 4d66ab2..a9d6cd9 100644 --- a/paddle_quantum/VQSD/Paddle_VQSD.py +++ b/paddle_quantum/VQSD/Paddle_VQSD.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,94 +13,62 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" Paddle_VQSD: To learn more about the functions and properties of this application, you could check the corresponding Jupyter notebook under the Tutorial folder. """ import numpy import paddle -from paddle_quantum.circuit import UAnsatz -from paddle_quantum.utils import dagger + +import paddle_quantum +from paddle_quantum.ansatz import Circuit +from paddle_quantum.linalg import dagger from paddle import matmul, trace from paddle_quantum.VQSD.HGenerator import generate_rho_sigma SEED = 14 __all__ = [ - "U_theta", - "Net", + "loss_func", "Paddle_VQSD", ] -def U_theta(theta, N): - """ - Quantum Neural Network - """ - - # Initialize the quantum neural network by the number of qubits (width of the network) - cir = UAnsatz(N) - - # Use built-in template - cir.universal_2_qubit_gate(theta, [0, 1]) - - # Return the Unitary matrix simulated by QNN - return cir.U +def loss_func(U, rho, sigma): + # rho_tilda is the quantum state obtained by acting U on rho, which is U*rho*U^dagger + rho_tilde = matmul(matmul(U, rho), dagger(U)) + # Calculate loss function + loss = trace(matmul(sigma, rho_tilde)) -class Net(paddle.nn.Layer): - """ - Construct the model net - """ + return paddle.real(loss), rho_tilde - def __init__(self, shape, rho, sigma, param_attr=paddle.nn.initializer.Uniform(low=0.0, high=2 * numpy.pi), - dtype='float64'): - super(Net, self).__init__() - # Convert Numpy array to variable supported in PaddlePaddle - self.rho = paddle.to_tensor(rho) - self.sigma = paddle.to_tensor(sigma) - # Initialize theta by sampling from a uniform distribution [0, 2*pi] - self.theta = self.create_parameter(shape=shape, attr=param_attr, dtype=dtype, is_bias=False) - - # Define the loss function and forward propagation mechanism - def forward(self, N): - # Apply quantum neural network onto the initial state - U = U_theta(self.theta, N) - - # rho_tilda is the quantum state obtained by acting U on rho, which is U*rho*U^dagger - rho_tilde = matmul(matmul(U, self.rho), dagger(U)) - - # Calculate loss function - loss = trace(matmul(self.sigma, rho_tilde)) - - return paddle.real(loss), rho_tilde - - -def Paddle_VQSD(rho, sigma, N=2, THETA_SIZE=15, ITR=50, LR=0.2): +def Paddle_VQSD(rho, sigma, N=2, ITR=50, LR=0.2): r""" Paddle_VQSD - :param rho: Qauntum state to be diagonalized + :param rho: Quantum state to be diagonalized :param sigma: Quantum state sigma :param N: Width of QNN - :param THETA_SIZE: Number of parameters in QNN :param ITR: Number of iterations :param LR: Learning rate :return: Diagonalized quantum state after optimization """ - + rho = paddle.to_tensor(rho, dtype=paddle_quantum.get_dtype()) + sigma = paddle.to_tensor(sigma, dtype=paddle_quantum.get_dtype()) # Fix the dimensions of network - net = Net(shape=[THETA_SIZE], rho=rho, sigma=sigma) + net = Circuit(N) + net.universal_two_qubits([0, 1]) # Use Adagrad optimizer opt = paddle.optimizer.Adagrad(learning_rate=LR, parameters=net.parameters()) # Optimization iterations for itr in range(ITR): - + U = net.unitary_matrix() # Run forward propagation to calculate loss function and obtain energy spectrum - loss, rho_tilde = net(N) + loss, rho_tilde = loss_func(U, rho, sigma) rho_tilde_np = rho_tilde.numpy() # In dynamic graph, run backward propagation to minimize loss function diff --git a/paddle_quantum/VQSD/example/main.py b/paddle_quantum/VQSD/example/main.py index f4b7915..c05f6ad 100644 --- a/paddle_quantum/VQSD/example/main.py +++ b/paddle_quantum/VQSD/example/main.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" Main """ diff --git a/paddle_quantum/__init__.py b/paddle_quantum/__init__.py index 3b8bf65..07be7e4 100644 --- a/paddle_quantum/__init__.py +++ b/paddle_quantum/__init__.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -13,8 +14,36 @@ # limitations under the License. r""" -Paddle Quantum Library +Paddle Quantum Library. """ -name = "paddle_quantum" -__version__ = "2.1.3" +from .backend import Backend +from .state import State +from .base import Operator +from .base import set_device, get_device +from .base import set_dtype, get_dtype +from .base import set_backend, get_backend +from .hamiltonian import Hamiltonian +from . import ansatz +from . import channel +from . import gate +from . import linalg +from . import locc +from . import loss +from . import mbqc +from . import operator +from . import qchem +from . import base +from . import dataset +from . import finance +from . import fisher +from . import gradtool +from . import hamiltonian +from . import linalg +from . import qinfo +from . import shadow +from . import trotter +from . import visual + +name = 'paddle_quantum' +__version__ = '2.2.0' diff --git a/paddle_quantum/ansatz/__init__.py b/paddle_quantum/ansatz/__init__.py new file mode 100644 index 0000000..480ca9a --- /dev/null +++ b/paddle_quantum/ansatz/__init__.py @@ -0,0 +1,22 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The module that contains the various ansatzes. +""" + +from .container import Sequential +from .circuit import Circuit +from .vans import VAns diff --git a/paddle_quantum/ansatz/circuit.py b/paddle_quantum/ansatz/circuit.py new file mode 100644 index 0000000..ff41b4d --- /dev/null +++ b/paddle_quantum/ansatz/circuit.py @@ -0,0 +1,1691 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the Circuit class. +""" + +import paddle +from .container import Sequential +from ..gate import Gate, H, S, T, X, Y, Z, P, RX, RY, RZ, U3 +from ..gate import CNOT, CX, CY, CZ, SWAP +from ..gate import CP, CRX, CRY, CRZ, CU, RXX, RYY, RZZ +from ..gate import MS, CSWAP, Toffoli +from ..gate import UniversalTwoQubits, UniversalThreeQubits +from ..gate import Oracle, ControlOracle +from ..gate import SuperpositionLayer, WeakSuperpositionLayer, LinearEntangledLayer +from ..gate import RealBlockLayer, RealEntangledLayer, ComplexBlockLayer, ComplexEntangledLayer +from ..gate import QAOALayer +from ..gate import AmplitudeEncoding +from ..channel import BitFlip, PhaseFlip, BitPhaseFlip, AmplitudeDamping, GeneralizedAmplitudeDamping, PhaseDamping +from ..channel import Depolarizing, PauliChannel, ResetChannel, ThermalRelaxation, KrausRepr +from ..state import zero_state +from typing import Union, Iterable, Optional, Dict, List, Tuple +from paddle_quantum import State, get_backend, get_dtype, Backend +from math import pi +import numpy as np + + +class Circuit(Sequential): + r"""Quantum circuit. + + Args: + num_qubits: Number of qubits. Defaults to None. + """ + + def __init__(self, num_qubits: Optional[int] = None): + super().__init__() + self.__num_qubits = num_qubits + + # whether the circuit is a dynamic quantum circuit + self.__isdynamic = True if num_qubits is None else False + + # alias for ccx + self.toffoli = self.ccx + + @property + def num_qubits(self) -> int: + r"""Number of qubits. + """ + return self.__num_qubits + + @property + def isdynamic(self) -> bool: + r"""Whether the circuit is dynamic + """ + return self.__dynamic + + @num_qubits.setter + def num_qubits(self, value: int) -> None: + assert isinstance(value, int) + self.__num_qubits = value + + @property + def param(self) -> paddle.Tensor: + r"""Flattened parameters in the circuit. + """ + return paddle.concat([paddle.flatten(param) for param in self.parameters()]) + + @property + def grad(self) -> np.ndarray: + r"""Gradients with respect to the flattened parameters. + """ + grad_list = [] + for param in self.parameters(): + assert param.grad is not None, 'the gradient is None, run the backward first before calling this property,' + \ + ' otherwise check where the gradient chain is broken' + grad_list.append(paddle.flatten(param.grad)) + return paddle.concat(grad_list).numpy() + + def update_param(self, theta: Union[paddle.Tensor, np.ndarray, float], idx: Optional[int] = None) -> None: + r"""Replace parameters of all/one layer(s) by ``theta``. + + Args: + theta: New parameters + idx: Index of replacement. Defaults to None, refering to all layers. + """ + if not isinstance(theta, paddle.Tensor): + theta = paddle.to_tensor(theta, dtype='float32') + theta = paddle.flatten(theta) + + if idx is None: + assert self.param.shape == theta.shape, "the shapen of input paramters is not correct" + for layer in self.sublayers(): + for name, _ in layer.named_parameters(): + param = getattr(layer, name) + num_param = int(paddle.numel(param)) + + param = paddle.create_parameter( + shape=param.shape, + dtype=param.dtype, + default_initializer=paddle.nn.initializer.Assign( + theta[:num_param].reshape(param.shape)), + ) + + setattr(layer, 'theta', param) + if num_param == theta.shape[0]: + return + theta = theta[num_param:] + elif isinstance(idx, int): + assert idx < len(self.sublayers( + )), "the index is out of range, expect below " + str(len(self.sublayers())) + layer = self.sublayers()[idx] + assert theta.shape == paddle.concat([paddle.flatten(param) for param in layer.parameters()]).shape, \ + "the shape of input paramters is not correct," + + for name, _ in layer.named_parameters(): + param = getattr(layer, name) + num_param = int(paddle.numel(param)) + + param = paddle.create_parameter( + shape=param.shape, + dtype=param.dtype, + default_initializer=paddle.nn.initializer.Assign( + theta[:num_param].reshape(param.shape)), + ) + + setattr(layer, 'theta', param) + if num_param == theta.shape[0]: + return + theta = theta[num_param:] + else: + raise ValueError("idx must be an integer or None") + + def randomize_param(self, low: float = 0, high: Optional[float] = 2 * pi) -> None: + r"""Randomize parameters of the circuit in a range from low to high. + + Args: + low: Lower bound. + high: Upper bound. + """ + for layer in self.sublayers(): + for name, _ in layer.named_parameters(): + param = getattr(layer, name) + + param = paddle.create_parameter( + shape=param.shape, + dtype=param.dtype, + default_initializer=paddle.nn.initializer.Uniform( + low=low, high=high), + ) + setattr(layer, 'theta', param) + + def __num_qubits_update(self, qubits_idx: Union[Iterable[int], int, str]) -> None: + r"""Update ``self.num_qubits`` according to ``qubits_idx``, or report error. + + Args: + qubits_idx: Input qubit indices of a quantum gate. + """ + num_qubits = self.__num_qubits + if isinstance(qubits_idx, str): + assert num_qubits is not None, "The qubit idx cannot be full when the number of qubits is unknown" + return + + if isinstance(qubits_idx, Iterable): + max_idx = np.max(qubits_idx) + else: + max_idx = qubits_idx + + if num_qubits is None: + self.__num_qubits = max_idx + 1 + return + + assert max_idx + 1 <= num_qubits or self.__isdynamic, \ + "The circuit is not a dynamic quantum circuit. Invalid input qubit idx: " + \ + str(max_idx) + " num_qubit: " + str(self.__num_qubits) + self.__num_qubits = int(max(max_idx + 1, num_qubits)) + + def h( + self, qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1 + ) -> None: + r"""Add single-qubit Hadamard gates. + + The matrix form of such a gate is: + + .. math:: + + H = \frac{1}{\sqrt{2}} + \begin{bmatrix} + 1&1\\ + 1&-1 + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + H(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def s( + self, qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1 + ) -> None: + r"""Add single-qubit S gates. + + The matrix form of such a gate is: + + .. math:: + + S = + \begin{bmatrix} + 1&0\\ + 0&i + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + S(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def t( + self, qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1 + ) -> None: + r"""Add single-qubit T gates. + + The matrix form of such a gate is: + + .. math:: + + T = \begin{bmatrix} + 1&0\\ + 0&e^\frac{i\pi}{4} + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + T(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def x( + self, qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1 + ) -> None: + r"""Add single-qubit X gates. + + The matrix form of such a gate is: + + .. math:: + X = \begin{bmatrix} + 0 & 1 \\ + 1 & 0 + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + X(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def y( + self, qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1 + ) -> None: + r"""Add single-qubit Y gates. + + The matrix form of such a gate is: + + .. math:: + + Y = \begin{bmatrix} + 0 & -i \\ + i & 0 + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + Y(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def z( + self, qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1 + ) -> None: + r"""Add single-qubit Z gates. + + The matrix form of such a gate is: + + .. math:: + + Z = \begin{bmatrix} + 1 & 0 \\ + 0 & -1 + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + Z(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def p( + self, qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add single-qubit P gates. + + The matrix form of such a gate is: + + .. math:: + + P(\theta) = \begin{bmatrix} + 1 & 0 \\ + 0 & e^{i\theta} + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(P(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, + depth, param, param_sharing)) + + def rx( + self, qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add single-qubit rotation gates about the x-axis. + + The matrix form of such a gate is: + + .. math:: + + R_X(\theta) = \begin{bmatrix} + \cos\frac{\theta}{2} & -i\sin\frac{\theta}{2} \\ + -i\sin\frac{\theta}{2} & \cos\frac{\theta}{2} + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(RX(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, + depth, param, param_sharing)) + + def ry( + self, qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add single-qubit rotation gates about the y-axis. + + The matrix form of such a gate is: + + .. math:: + + R_Y(\theta) = \begin{bmatrix} + \cos\frac{\theta}{2} & -\sin\frac{\theta}{2} \\ + \sin\frac{\theta}{2} & \cos\frac{\theta}{2} + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(RY(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, + depth, param, param_sharing)) + + def rz( + self, qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add single-qubit rotation gates about the z-axis. + + The matrix form of such a gate is: + + .. math:: + + R_Z(\theta) = \begin{bmatrix} + e^{-i\frac{\theta}{2}} & 0 \\ + 0 & e^{i\frac{\theta}{2}} + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(RZ(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, + depth, param, param_sharing)) + + def u3( + self, qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, Iterable[float]] = None, param_sharing: bool = False + ) -> None: + r"""Add single-qubit rotation gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{align} + U_3(\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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(U3(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, + depth, param, param_sharing)) + + def cnot( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add CNOT gates. + + For a 2-qubit quantum circuit, when `qubits_idx` is `[0, 1]`, the matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + CNOT(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def cx( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Same as cnot. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + CX(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def cy( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add controlled Y gates. + + For a 2-qubit quantum circuit, when `qubits_idx` is `[0, 1]`, the matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{CY} &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Y\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & -1j \\ + 0 & 0 & 1j & 0 + \end{bmatrix} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + CY(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def cz( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add controlled Z gates. + + For a 2-qubit quantum circuit, when `qubits_idx` is `[0, 1]`, the matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{CZ} &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Z\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & -1 + \end{bmatrix} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + CZ(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def swap( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add SWAP gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{SWAP} = + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & 1 + \end{bmatrix} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + SWAP(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def cp( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add controlled P gates. + + For a 2-qubit quantum circuit, when `qubits_idx` is `[0, 1]`, the matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{CP}(\theta) = + \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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(CP(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, + depth, param, param_sharing)) + + def crx( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add controlled rotation gates about the x-axis. + + For a 2-qubit quantum circuit, when `qubits_idx` is `[0, 1]`, the matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{CR_X} &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes R_X\\ + &= + \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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(CRX( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth, param, param_sharing)) + + def cry( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add controlled rotation gates about the y-axis. + + For a 2-qubit quantum circuit, when `qubits_idx` is `[0, 1]`, the matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{CR_Y} &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes R_Y\\ + &= + \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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(CRY( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth, param, param_sharing)) + + def crz( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add controlled rotation gates about the z-axis. + + For a 2-qubit quantum circuit, when `qubits_idx` is `[0, 1]`, the matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{CR_Z} &= |0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes R_Z\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & e^{-i\frac{\theta}{2}} & 0 \\ + 0 & 0 & 0 & e^{i\frac{\theta}{2}} + \end{bmatrix} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(CRZ( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth, param, param_sharing)) + + def cu( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add controlled single-qubit rotation gates. + + For a 2-qubit quantum circuit, when `qubits_idx` is `[0, 1]`, the matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(CU(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, + depth, param, param_sharing)) + + def rxx( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add RXX gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{R_{XX}}(\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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(RXX( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth, param, param_sharing)) + + def ryy( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add RYY gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{R_{YY}}(\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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(RYY( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth, param, param_sharing)) + + def rzz( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add RZZ gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{R_{ZZ}}(\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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(RZZ( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth, param, param_sharing)) + + def ms( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add Mølmer-Sørensen (MS) gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{MS} = \mathit{R_{XX}}(-\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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + MS(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def cswap( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add CSWAP (Fredkin) gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{CSWAP} = + \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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append( + CSWAP(qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def ccx( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add CCX gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{align} + \mathit{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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append(Toffoli( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def universal_two_qubits( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add universal two-qubit gates. One of such a gate requires 15 parameters. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + """ + self.__num_qubits_update(qubits_idx) + self.append(UniversalTwoQubits( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth, param, param_sharing)) + + def universal_three_qubits( + self, qubits_idx: Union[Iterable[int], str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add universal three-qubit gates. One of such a gate requires 81 parameters. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'cycle'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + param: Parameters of the gates. Defaults to None. + param_sharing: Whether gates in the same layer share a parameter. Defaults to False. + + Raises: + ValueError: The ``param`` must be paddle.Tensor or float. + """ + self.__num_qubits_update(qubits_idx) + self.append(UniversalThreeQubits( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth, param, param_sharing)) + + def oracle( + self, oracle: paddle.tensor, qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int], + num_qubits: int = None, depth: int = 1 + ) -> None: + """Add an oracle gate. + + Args: + oracle: Unitary oracle to be implemented. + qubits_idx: Indices of the qubits on which the gates are applied. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append(Oracle(oracle, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits, depth)) + + def control_oracle( + self, oracle: paddle.Tensor, + # num_control_qubits: int, controlled_value: 'str', + qubits_idx: Union[Iterable[Iterable[int]], Iterable[int]], + num_qubits: int = None, depth: int = 1 + ) -> None: + """Add a controlled oracle gate. + + Args: + oracle: Unitary oracle to be implemented. + qubits_idx: Indices of the qubits on which the gates are applied. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append(ControlOracle(oracle, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits, depth)) + + def superposition_layer( + self, qubits_idx: Iterable[int] = 'full', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add layers of Hadamard gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append(SuperpositionLayer( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def weak_superposition_layer( + self, qubits_idx: Iterable[int] = 'full', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add layers of Ry gates with a rotation angle :math:`\pi/4`. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append(WeakSuperpositionLayer( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def linear_entangled_layer( + self, qubits_idx: Iterable[int] = 'full', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add linear entangled layers consisting of Ry gates, Rz gates, and CNOT gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append(LinearEntangledLayer( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def real_entangled_layer( + self, qubits_idx: Iterable[int] = 'full', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add strongly entangled layers consisting of Ry gates and CNOT gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append(RealEntangledLayer( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def complex_entangled_layer( + self, qubits_idx: Iterable[int] = 'full', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add strongly entangled layers consisting of single-qubit rotation gates and CNOT gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append(ComplexEntangledLayer( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def real_block_layer( + self, qubits_idx: Iterable[int] = 'full', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add weakly entangled layers consisting of Ry gates and CNOT gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append(RealBlockLayer( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def complex_block_layer( + self, qubits_idx: Iterable[int] = 'full', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add weakly entangled layers consisting of single-qubit rotation gates and CNOT gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + depth: Number of layers. Defaults to 1. + """ + self.__num_qubits_update(qubits_idx) + self.append(ComplexBlockLayer( + qubits_idx, self.num_qubits if num_qubits is None else num_qubits, depth)) + + def bit_flip( + self, prob: Union[paddle.Tensor, float], qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ) -> None: + r"""Add bit flip channels. + + Args: + prob: Probability of a bit flip. + qubits_idx: Indices of the qubits on which the channels are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + """ + self.__num_qubits_update(qubits_idx) + self.append(BitFlip(prob, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits)) + + def phase_flip( + self, prob: Union[paddle.Tensor, float], qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ) -> None: + r"""Add phase flip channels. + + Args: + prob: Probability of a phase flip. + qubits_idx: Indices of the qubits on which the channels are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + """ + self.__num_qubits_update(qubits_idx) + self.append(PhaseFlip(prob, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits)) + + def bit_phase_flip( + self, prob: Union[paddle.Tensor, float], qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ) -> None: + r"""Add bit phase flip channels. + + Args: + prob: Probability of a bit phase flip. + qubits_idx: Indices of the qubits on which the channels are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + """ + self.__num_qubits_update(qubits_idx) + self.append(BitPhaseFlip(prob, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits)) + + def amplitude_damping( + self, gamma: Union[paddle.Tensor, float], qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ) -> None: + r"""Add amplitude damping channels. + + Args: + gamma: Damping probability. + qubits_idx: Indices of the qubits on which the channels are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + """ + self.__num_qubits_update(qubits_idx) + self.append(AmplitudeDamping(gamma, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits)) + + def generalized_amplitude_damping( + self, gamma: Union[paddle.Tensor, float], prob: Union[paddle.Tensor, float], qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ) -> None: + r"""Add generalized amplitude damping channels. + + Args: + gamma: Damping probability. + prob: Excitation probability. + qubits_idx: Indices of the qubits on which the channels are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + """ + self.__num_qubits_update(qubits_idx) + self.append(GeneralizedAmplitudeDamping(gamma, prob, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits)) + + def phase_damping( + self, gamma: Union[paddle.Tensor, float], qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ) -> None: + r"""Add phase damping channels. + + Args: + gamma: Parameter of the phase damping channel. + qubits_idx: Indices of the qubits on which the channels are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + """ + self.__num_qubits_update(qubits_idx) + self.append(PhaseDamping(gamma, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits)) + + def depolarizing( + self, prob: Union[paddle.Tensor, float], qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ) -> None: + r"""Add depolarizing channels. + + Args: + prob: Parameter of the depolarizing channel. + qubits_idx: Indices of the qubits on which the channels are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + """ + self.__num_qubits_update(qubits_idx) + self.append(Depolarizing(prob, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits)) + + def pauli_channel( + self, prob: Union[paddle.Tensor, float], qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ) -> None: + r"""Add Pauli channels. + + Args: + prob: Probabilities corresponding to the Pauli X, Y, and Z operators. + qubits_idx: Indices of the qubits on which the channels are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + """ + self.__num_qubits_update(qubits_idx) + self.append(PauliChannel(prob, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits)) + + def reset_channel( + self, prob: Union[paddle.Tensor, float], qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ) -> None: + r"""Add reset channels. + + Args: + prob: Probabilities of resetting to :math:`|0\rangle` and to :math:`|1\rangle`. + qubits_idx: Indices of the qubits on which the channels are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + """ + self.__num_qubits_update(qubits_idx) + self.append(ResetChannel(prob, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits)) + + def thermal_relaxation( + self, const_t: Union[paddle.Tensor, Iterable[float]], exec_time: Union[paddle.Tensor, float], + qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ) -> None: + r"""Add thermal relaxation channels. + + Args: + const_t: :math:`T_1` and :math:`T_2` relaxation time in microseconds. + exec_time: Quantum gate execution time in the process of relaxation in nanoseconds. + qubits_idx: Indices of the qubits on which the channels are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + """ + self.__num_qubits_update(qubits_idx) + self.append(ThermalRelaxation(const_t, exec_time, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits)) + + def kraus_repr( + self, kraus_oper: Iterable[paddle.Tensor], + qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int], + num_qubits: int = None + ) -> None: + r"""Add custom channels in the Kraus representation. + + Args: + kraus_oper: Kraus operators of this channel. + qubits_idx: Indices of the qubits on which the channels are applied. Defaults to 'full'. + num_qubits: Total number of qubits. Defaults to None. + """ + self.__num_qubits_update(qubits_idx) + self.append(KrausRepr(kraus_oper, qubits_idx, + self.num_qubits if num_qubits is None else num_qubits)) + + def qaoa_layer(self, edges: Iterable, nodes: Iterable, depth: Optional[int] = 1) -> None: + # TODO: see qaoa layer in layer.py + self.__num_qubits_update(edges) + self.__num_qubits_update(nodes) + self.append(QAOALayer(edges, nodes, depth)) + + def unitary_matrix(self, num_qubits: Optional[int] = None) -> paddle.Tensor: + r"""Get the unitary matrix form of the circuit. + + Args: + num_qubits: Total number of qubits. Defaults to None. + + Returns: + Unitary matrix form of the circuit. + """ + if num_qubits is None: + num_qubits = self.__num_qubits + else: + assert num_qubits >= self.__num_qubits + + backend = get_backend() + self.to(backend=Backend.UnitaryMatrix) + unitary = State(paddle.eye( + 2 ** num_qubits).cast(get_dtype()), backend=Backend.UnitaryMatrix) + for layer in self._sub_layers.values(): + unitary = layer(unitary) + self.to(backend=backend) + return unitary.data + + @property + def gate_history(self) -> List[Dict[str, Union[str, List[int], paddle.Tensor]]]: + r""" list of gates information of circuit + + Returns: + history of quantum gates of circuit + + """ + def get_gate_name(gate: Gate) -> str: + r""" return the corresponding string of gate + + Returns: + gate name + + """ + if isinstance(gate, H): + return 'h' + if isinstance(gate, S): + return 's' + if isinstance(gate, T): + return 't' + if isinstance(gate, X): + return 'x' + if isinstance(gate, Y): + return 'y' + if isinstance(gate, Z): + return 'z' + if isinstance(gate, U3): + return 'u' + if isinstance(gate, P): + return 'p' + if isinstance(gate, RX): + return 'rx' + if isinstance(gate, RY): + return 'ry' + if isinstance(gate, RZ): + return 'rz' + if isinstance(gate, CNOT): + return 'cnot' + if isinstance(gate, SWAP): + return 'swap' + if isinstance(gate, CX): + return 'cnot' + if isinstance(gate, CY): + return 'cy' + if isinstance(gate, CZ): + return 'cz' + if isinstance(gate, RXX): + return 'rxx' + if isinstance(gate, RYY): + return 'ryy' + if isinstance(gate, RZZ): + return 'rzz' + if isinstance(gate, CP): + return 'cp' + if isinstance(gate, CRX): + return 'crx' + if isinstance(gate, CRY): + return 'cry' + if isinstance(gate, CRZ): + return 'crz' + if isinstance(gate, CU): + return 'cu' + if isinstance(gate, MS): + return 'ms' + if isinstance(gate, CSWAP): + return 'cswap' + if isinstance(gate, Toffoli): + return 'ccx' + raise ValueError("The gate is not a simple quantum gate.") + + not_implemented_gate = [ + AmplitudeEncoding, + Oracle, + ControlOracle, + UniversalTwoQubits, + UniversalThreeQubits, + RealBlockLayer, + ComplexBlockLayer, + ] + single_qubit_gate = {'h', 's', 't', 'x', + 'y', 'z', 'p', 'rx', 'ry', 'rz', 'u'} + gate_history = [] + qubit_max_idx = 0 + for gate in self.sublayers(): + if any((isinstance(gate, gate_class) for gate_class in not_implemented_gate)): + raise NotImplementedError( + f"Not support to print the {type(gate)}.") + if isinstance(gate, SuperpositionLayer): + for depth_idx in range(0, gate.depth): + for qubit_idx in gate.qubits_idx: + gate_info = { + 'gate': 'h', 'which_qubits': [qubit_idx], 'theta': None + } + gate_history.append(gate_info) + elif isinstance(gate, WeakSuperpositionLayer): + for depth_idx in range(0, gate.depth): + for qubit_idx in gate.qubits_idx: + gate_info = { + 'gate': 'ry', 'which_qubits': [qubit_idx], + 'theta': paddle.to_tensor([pi / 4]) + } + gate_history.append(gate_info) + elif isinstance(gate, LinearEntangledLayer): + for depth_idx in range(0, gate.depth): + for idx, qubit_idx in enumerate(gate.qubits_idx): + gate_info = { + 'gate': 'ry', 'which_qubits': [qubit_idx], + 'theta': gate.parameters()[0][depth_idx][idx][0] + } + gate_history.append(gate_info) + for idx in range(0, len(gate.qubits_idx) - 1): + gate_info = { + 'gate': 'cnot', 'which_qubits': [gate.qubits_idx[idx], gate.qubits_idx[idx + 1]], + 'theta': None + } + gate_history.append(gate_info) + for idx, qubit_idx in enumerate(gate.qubits_idx): + gate_info = { + 'gate': 'rz', 'which_qubits': [qubit_idx], + 'theta': gate.parameters()[0][depth_idx][idx][1] + } + gate_history.append(gate_info) + for idx in range(0, len(gate.qubits_idx) - 1): + gate_info = { + 'gate': 'cnot', 'which_qubits': [gate.qubits_idx[idx], gate.qubits_idx[idx + 1]], + 'theta': None + } + gate_history.append(gate_info) + elif isinstance(gate, RealEntangledLayer): + for depth_idx in range(0, gate.depth): + for idx, qubit_idx in enumerate(gate.qubits_idx): + gate_info = { + 'gate': 'ry', 'which_qubits': [qubit_idx], + 'theta': gate.parameters()[0][depth_idx][idx] + } + gate_history.append(gate_info) + for idx in range(0, len(gate.qubits_idx)): + gate_info = { + 'gate': 'cnot', + 'which_qubits': [ + gate.qubits_idx[idx], + gate.qubits_idx[(idx + 1) % + len(gate.qubits_idx)] + ], + 'theta': None + } + gate_history.append(gate_info) + elif isinstance(gate, ComplexEntangledLayer): + for depth_idx in range(0, gate.depth): + for idx, qubit_idx in enumerate(gate.qubits_idx): + gate_info = { + 'gate': 'u', 'which_qubits': [qubit_idx], 'theta': None + } + gate_history.append(gate_info) + for idx in range(0, len(gate.qubits_idx)): + gate_info = { + 'gate': 'cnot', + 'which_qubits': [ + gate.qubits_idx[idx], + gate.qubits_idx[(idx + 1) % + len(gate.qubits_idx)] + ], + 'theta': None + } + gate_history.append(gate_info) + else: + gate_name = get_gate_name(gate) + if gate_name in single_qubit_gate: + for depth_idx in range(0, gate.depth): + for idx, qubit_idx in enumerate(gate.qubits_idx): + gate_info = {'gate': gate_name, + 'which_qubits': [qubit_idx]} + param = None + if gate_name in {'rx', 'ry', 'rz'}: + param = gate.theta[depth_idx][idx] + gate_info['theta'] = param + gate_history.append(gate_info) + else: + for depth_idx in range(0, gate.depth): + for idx, qubit_idx in enumerate(gate.qubits_idx): + gate_info = {'gate': gate_name, + 'which_qubits': qubit_idx} + param = None + if gate_name in {'cp', 'crx', 'cry', 'crz', 'rxx', 'ryy', 'rzz'}: + param = gate.parameters()[0][depth_idx][idx] + gate_info['theta'] = param + gate_history.append(gate_info) + return gate_history + + def __count_history(self, history): + # Record length of each section + length = [5] + n = self.__num_qubits + # Record current section number for every qubit + qubit = [0] * n + # Number of sections + qubit_max = max(qubit) + # Record section number for each gate + gate = [] + + for current_gate in history: + # Single-qubit gates with no params to print + 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 + if qubit[curr_qubit] > qubit_max: + length.append(5) + qubit_max = qubit[curr_qubit] + # Gates with params to print + elif current_gate['gate'] in {'p', '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 + qubit[curr_qubit] = qubit[curr_qubit] + 1 + if qubit[curr_qubit] > qubit_max: + length.append(5) + qubit_max = qubit[curr_qubit] + # Two-qubit gates or Three-qubit gates + elif ( + current_gate['gate'] in { + 'cnot', 'swap', 'rxx', 'ryy', 'rzz', 'ms', + 'cy', 'cz', 'cu', 'cp', '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['gate'] in {'rxx', 'ryy', 'rzz', + 'cp', '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 + + @property + def qubit_history(self) -> List[List[Tuple[Dict[str, Union[str, List[int], paddle.Tensor]], int]]]: + r""" gate information on each qubit + + Returns: + list of gate history on each qubit + + Note: + The entry ``qubit_history[i][j][0/1]`` returns the gate information / gate index of the j-th gate + applied on the i-th qubit. + """ + history_qubit = [] + for i in range(self.num_qubits): + history_i = [] + history_qubit.append(history_i) + for idx, i in enumerate(self.gate_history): + qubits = i["which_qubits"] + for j in qubits: + history_qubit[j].append([i, idx]) + return history_qubit + + def __str__(self) -> str: + history = self.gate_history + num_qubits = self.__num_qubits + length, gate = self.__count_history(history) + # Ignore the unused section + total_length = sum(length) - 5 + + print_list = [['-' if i % 2 == 0 else ' '] * + total_length for i in range(num_qubits * 2)] + + for i, current_gate in enumerate(history): + 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['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 {'p', 'rx', 'ry', 'rz'}: + sec = gate[i] + ind = sum(length[:sec]) + line = current_gate['which_qubits'][0] * 2 + # param = self.__param[current_gate['theta'][2 if current_gate['gate'] == 'rz' else 0]] + param = current_gate['theta'] + if current_gate['gate'] == 'p': + print_list[line][ind + 2] = 'P' + print_list[line][ind + 3] = ' ' + else: + print_list[line][ind + 2] = 'R' + 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] = ')' + # Two-qubit gates + elif current_gate['gate'] in {'cnot', 'swap', 'rxx', 'ryy', 'rzz', 'ms', 'cz', 'cy', + 'cu', 'crx', 'cry', 'crz'}: + sec = gate[i] + ind = sum(length[:sec]) + 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': + 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['gate'] in {'rxx', 'ryy', 'rzz'}: + # param = self.__param[current_gate['theta'][0]] + param = current_gate['theta'] + for line in {cqubit * 2, tqubit * 2}: + print_list[line][ind + 2] = 'R' + 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]] + param = current_gate['theta'] + 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 forward(self, state: Optional[State] = None) -> State: + r""" forward the input + + Args: + state: initial state + + Returns: + output quantum state + + """ + if state is None: + assert self.__num_qubits is not None, "Information about num_qubits is required before running the circuit" + state = zero_state(self.__num_qubits, self.backend, self.dtype) + + return super().forward(state) diff --git a/paddle_quantum/ansatz/container.py b/paddle_quantum/ansatz/container.py new file mode 100644 index 0000000..172ac97 --- /dev/null +++ b/paddle_quantum/ansatz/container.py @@ -0,0 +1,184 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the Sequential class. +""" + +import collections +from sre_parse import State +from paddle_quantum import Operator +from typing import Optional, Union, Iterable, Any, List + + +class Sequential(Operator): + r"""Sequential container. + + Args: + *operators: initial operators ready to be a sequential + + Note: + Sublayers will be added to this container in the order of argument in the constructor. + The argument passed to the constructor can be iterable Layers or iterable name Layer pairs. + + """ + def __init__(self, *operators: Operator): + super().__init__() + self.index = 0 + if len(operators) > 0 and isinstance(operators[0], (list, tuple)): + for name, oper in operators: + self.add_sublayer(name, oper) + else: + for idx, oper in enumerate(operators): + self.add_sublayer(str(idx), oper) + + def __getitem__(self, name: Union[str, slice]) -> Operator: + if isinstance(name, slice): + return self.__class__(*(list(self._sub_layers.values())[name])) + if isinstance(name, str): + return self._sub_layers[name] + if name >= len(self._sub_layers): + raise IndexError(f'index {name:s} is out of range') + if 0 > name >= -len(self._sub_layers): + name += len(self._sub_layers) + elif name < -len(self._sub_layers): + raise IndexError(f'index {name:s} is out of range') + return self._sub_layers[str(name)] + + def __setitem__(self, name: Any, layer: Operator) -> None: + assert isinstance(layer, Operator) + setattr(self, str(name), layer) + + def __delitem__(self, name: Any) -> None: + name = str(name) + assert name in self._sub_layers + del self._sub_layers[name] + + def __iter__(self): + return self + + def __next__(self) -> Union[Operator, StopIteration]: + if self.index < len(self._sub_layers): + oper = self._sub_layers[str(self.index)] + self.index += 1 + return oper + self.index = 0 + raise StopIteration + + def __len__(self): + return len(self._sub_layers) + + def append(self, operator: Union[Iterable, Operator]) -> None: + r""" append an operator + + Args: + operator: operator with a name or just an operator + + """ + if isinstance(operator, Operator): + idx = len(self._sub_layers) + self.add_sublayer(str(idx), operator) + elif isinstance(operator, Iterable): + name, oper = operator + self.add_sublayer(name, oper) + + + def extend(self, operators: List[Operator]) -> None: + r""" append a list of operators + + Args: + operator: list of operators + + """ + if len(operators) > 0 and isinstance(operators[0], (list, tuple)): + for name, oper in operators: + self.add_sublayer(name, oper) + else: + origin_len = len(self._sub_layers) + for idx, oper in enumerate(operators): + self.add_sublayer(str(idx + origin_len), oper) + + def insert(self, index: int, operator: Operator) -> None: + r""" insert an operator at ``index`` + + Args: + index: index to be inserted + operator: an operator + + """ + new_operators = collections.OrderedDict() + assert index <= len(self._sub_layers), 'the index ' + str(index) + ' should be no more than ' + str(len(self._sub_layers)) + if index == len(self._sub_layers): + self.append(operator) + for idx, name in enumerate(self._sub_layers): + if idx < index: + new_operators[name] = self._sub_layers[name] + elif idx == index: + if isinstance(operator, (list, tuple)): + name, oper = operator + new_operators[name] = oper + elif isinstance(operator, Operator): + new_operators[str(index)] = operator + if name.isdigit(): + new_operators[str(int(name) + 1)] = self._sub_layers[name] + else: + new_operators[name] = self._sub_layers[name] + elif name.isdigit(): + new_operators[str(int(name) + 1)] = self._sub_layers[name] + else: + new_operators[name] = self._sub_layers[name] + self._sub_layers = new_operators + + def pop(self, index: int = None, operator: Optional[Operator] = None): + r""" remove the operator at ``index`` or matched with ``operator`` + + Args: + index: at which the operator will be popped + operator: matched with which the operator will be popped + + """ + if index is not None: + assert index < len(self._sub_layers), 'the index ' + str(index) + ' should be less than ' + str(len(self._sub_layers)) + if isinstance(index, int): + index = str(index) + operator = self._sub_layers[index] + if operator is None: + raise ValueError("The index or operator must be input.") + new_operators = collections.OrderedDict() + behind_operator = False + for name in self._sub_layers: + if operator is self._sub_layers[name]: + behind_operator = True + elif not behind_operator: + new_operators[name] = self._sub_layers[name] + elif name.isdigit(): + new_operators[str(int(name) - 1)] = self._sub_layers[name] + else: + new_operators[name] = self._sub_layers[name] + self._sub_layers = new_operators + + def forward(self, state: Any) -> Any: + r""" forward the input + + Args: + state: initial state + + Returns: + output state + + """ + for layer in self._sub_layers.values(): + state = layer(state) + return state diff --git a/paddle_quantum/ansatz/vans.py b/paddle_quantum/ansatz/vans.py new file mode 100644 index 0000000..ec5ebe0 --- /dev/null +++ b/paddle_quantum/ansatz/vans.py @@ -0,0 +1,968 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the variable ansatz. +""" + +import numpy as np +from sympy import * +import paddle +from paddle_quantum.ansatz import Circuit +from paddle_quantum.gate import RX, RZ, CNOT +from paddle_quantum.linalg import is_unitary +from typing import Callable, List, Any, Optional + + +class Inserter: + r"""Class for block insertion for the circuit. + """ + @classmethod + def insert_identities(cls, cir: Circuit, insert_rate: float, epsilon: float) -> Circuit: + r"""Insert identity blocks to the current circuit, according to the insert rate. + + Args: + cir: Quantum circuit to be simplified. + insert_rate: Rate of number of inserted blocks. + epsilon: Range of random initialization of parameters. + + Returns: + Inserted circuit. + """ + num_id = int(np.random.exponential(scale=insert_rate)) + 1 + theta = paddle.uniform( + shape=[num_id, 6], dtype="float32", min=-epsilon, max=epsilon,) + for i in range(num_id): + cir = cls.__place_identity_block(cir, theta[i]) + return cir + + @classmethod + def __place_identity_block(cls, cir: Circuit, theta: paddle.Tensor) -> Circuit: + r"""Insert a set of gates to the circuit. + + Args: + cir: Quantum circuit. + theta: Parameters for inserted gates. + + Returns: + Output circuit. + """ + # count the number of single- and two-qubit gates in the circuit + count_current = cls.__count_qubit_gates(cir) + # get the inverse, use it as the probability + inv_count_current = np.array( + [1 / i for i in count_current]) # as probability + total_num = (cir.num_qubits ** 2 + cir.num_qubits) // 2 + # get the int, which indicate which set to insert + p = inv_count_current / inv_count_current.sum() + index = np.random.choice(range(total_num), p=p.ravel()) + + qubit_history = cir.qubit_history + if index < cir.num_qubits: + # get the position to insert in the circuit + cir_qubit_history_i = qubit_history[index] + if len(cir_qubit_history_i) == 0: + idx_qubit = 0 + insert_ind = 0 + else: + idx_qubit = np.random.randint(0, len(cir_qubit_history_i)) + insert_ind = cir_qubit_history_i[idx_qubit][1] + # add one qubit gates rz_rx_rz to the circuit + cir.insert(insert_ind, RZ([index], param=theta[0])) + cir.insert(insert_ind + 1, RX([index], param=theta[1])) + cir.insert(insert_ind + 2, RX([index], param=theta[2])) + else: + # add two qubit gates to the circuit + # obtain which two qubits to insert + curr = cir.num_qubits + count = 0 + while index - curr >= 0: + index -= curr + curr -= 1 + count += 1 + qubit_i = count - 1 + qubit_j = qubit_i + index + 1 + + # get insertion position + cir_qubit_history_i = qubit_history[qubit_i] + cir_qubit_history_j = qubit_history[qubit_j] + if len(cir_qubit_history_i) + len(cir_qubit_history_j) == 0: + idx_qubit = 0 + insert_ind = 0 + elif len(cir_qubit_history_i) == 0 and len(cir_qubit_history_j) == 1: + idx_qubit = 0 + insert_ind = cir_qubit_history_j[0][1] + elif len(cir_qubit_history_i) == 1 and len(cir_qubit_history_j) == 0: + idx_qubit = 0 + insert_ind = cir_qubit_history_i[0][1] + else: + idx_qubit = np.random.randint( + 0, len(cir_qubit_history_i) + len(cir_qubit_history_j) - 1 + ) + if idx_qubit < len(cir_qubit_history_i): + insert_ind = cir_qubit_history_i[idx_qubit][1] + else: + insert_ind = cir_qubit_history_j[idx_qubit - + len(cir_qubit_history_i)][1] + # add gates + cir.insert(insert_ind, CNOT([qubit_i, qubit_j])) + cir.insert(insert_ind + 1, RZ([qubit_i], param=theta[0])) + cir.insert(insert_ind + 2, RX([qubit_i], param=theta[1])) + cir.insert(insert_ind + 3, RZ([qubit_i], param=theta[2])) + cir.insert(insert_ind + 4, RX([qubit_i], param=theta[3])) + cir.insert(insert_ind + 5, RZ([qubit_i], param=theta[4])) + cir.insert(insert_ind + 6, RX([qubit_i], param=theta[5])) + cir.insert(insert_ind + 7, CNOT([qubit_i, qubit_j])) + return cir + + @classmethod + def __count_qubit_gates(cls, cir: Circuit) -> np.ndarray: + r"""Count the number of single-qubit and two-qubit gates. + + Args: + cir: Quantum circuit. + + Returns: + List with information of number of different gates. + """ + # The previous n nums count rotation gates at each qubit, and the next (n^2-n)/2 nums count cnot gates. + count_gates = np.zeros((cir.num_qubits ** 2 + cir.num_qubits) // 2) + # initialize to 0.1 in case there's no gates, which will lead to divide by zero error + count_gates = [0.1 for _ in count_gates] + history = cir.gate_history + for gate_info in history: + qubits_idx = gate_info["which_qubits"] + if gate_info["gate"] == "rz" or gate_info["gate"] == "rx": + qubit_ind = qubits_idx[0] + count_gates[qubit_ind] += 1 + elif gate_info["gate"] == "cnot": + qubit_i = min(qubits_idx[0], qubits_idx[1]) + qubit_j = max(qubits_idx[0], qubits_idx[1]) + idx = (2 * cir.num_qubits - qubit_i) * \ + (qubit_i + 1) // 2 + qubit_j - qubit_i - 1 + count_gates[idx] += 1 + return count_gates + + +class Simplifier: + r"""Class for circuit simplification. + """ + @classmethod + def __check_cnot_init(cls, cir: Circuit) -> bool: + r"""For rule 1, check if there are CNOTs in the front of the circuit. + + Args: + cir: Quantum circuit. + + Returns: + Determine whether there are CNOTs in the front of the circuit. + """ + count = 0 + qubit_history = cir.qubit_history + for i in range(cir.num_qubits): + history_i = qubit_history[i] + if not history_i: + continue + if history_i[0][0]["gate"] == "cnot": + cnot_qubits = history_i[0][0]["which_qubits"] + # find the other qubit + for j in cnot_qubits: + if j != i: + # check the CNOT is also in the front for the other qubit + if ( + qubit_history[j][0][0]["gate"] == "cnot" + and qubit_history[j][0][0]["which_qubits"] + == cnot_qubits + ): + count += 1 + if count == 0: + return True + else: + return False + + @classmethod + def __check_consec_cnot(cls, cir: Circuit) -> bool: + r"""For rule 2, check if there are consecutive CNOTs on the same qubits. + + Args: + cir: Quantum circuit. + + Returns: + Determine whether there are consecutive CNOTs on the same qubits. + """ + count = 0 + qubit_history = cir.qubit_history + for i in range(cir.num_qubits): + history_i = qubit_history[i] + if not history_i: + continue + for j in range(len(history_i) - 1): + # find consecutive cnots on one qubit + if ( + history_i[j][0]["gate"] == "cnot" + and history_i[j + 1][0] == history_i[j][0] + ): + cnot_qubits = history_i[j][0]["which_qubits"] + # get the other qubit + k = list(set(cnot_qubits).difference(set([i])))[0] + # check if the found consecutive cnots are also consecutive on the other qubit + history_k = qubit_history[k] + idx_k = history_k.index(history_i[j]) + if history_k[idx_k + 1] == history_i[j + 1]: + count += 1 + if count == 0: + return True + else: + return False + + @classmethod + def __check_rz_init(cls, cir: Circuit) -> bool: + r"""For rule 3, check if there are rz in the front of the circuit. + + Args: + cir: Quantum circuit. + + Returns: + Determine whether there are rz in the front of the circuit. + """ + count = 0 + qubit_history = cir.qubit_history + for i in range(cir.num_qubits): + history_i = qubit_history[i] + if not history_i: + continue + if history_i[0][0]["gate"] == "z" or history_i[0][0]["gate"] == "rz": + count += 1 + if count == 0: + return True + else: + return False + + @classmethod + def __check_repeated_rotations(cls, cir: Circuit) -> bool: + r"""For rule 4, check if there are consecutive rx's or rz's. + + Args: + cir: Quantum circuit. + + Returns: + Determine whether there are consecutive rx's or rz's. + """ + count = 0 + cir_qubit_history = cir.qubit_history + for i in range(cir.num_qubits): + history_i = cir_qubit_history[i] + if not history_i: + continue + for j in range(len(history_i) - 1): + if ( + history_i[j][0]["gate"] == "rx" + and history_i[j + 1][0]["gate"] == "rx" + ) or ( + history_i[j][0]["gate"] == "rz" + and history_i[j + 1][0]["gate"] == "rz" + ): + count += 1 + if count == 0: + return True + else: + return False + + @classmethod + def __check_4_consec_rotations(cls, cir: Circuit) -> bool: + r"""For rule 5, check if there are consecutive rotations on one qubits. + + Args: + cir: Quantum circuit. + + Returns: + Determine whether there are consecutive rotations on one qubits e.g., rx_rz_rx_rz & rz_rx_rz_rx. + """ + count = 0 + cir_qubit_history = cir.qubit_history + for i in range(cir.num_qubits): + history_i = cir_qubit_history[i] + if not history_i: + continue + for j in range(len(history_i) - 3): + if ( + history_i[j][0]["gate"] == "rx" + and history_i[j + 1][0]["gate"] == "rz" + and history_i[j + 2][0]["gate"] == "rx" + and history_i[j + 3][0]["gate"] == "rz" + ) or ( + history_i[j][0]["gate"] == "rz" + and history_i[j + 1][0]["gate"] == "rx" + and history_i[j + 2][0]["gate"] == "rz" + and history_i[j + 3][0]["gate"] == "rx" + ): + count += 1 + if count == 0: + return True + else: + return False + + @classmethod + def __check_rz_cnot_rz_rx_cnot_rx(cls, cir: Circuit) -> bool: + r"""For rule 6, check if there are rz_cnot_rz or rx_cnot_rx. + + Args: + cir: Quantum circuit. + + Returns: + Determine whether there are rz_cnot_rz(control) or rx_cnot_rx(target). + """ + count = 0 + qubit_history = cir.qubit_history + for i in range(cir.num_qubits): + history_i = qubit_history[i] + if not history_i: + continue + for j in range(len(history_i) - 2): + # find rz_cnot_rz with rz on the control qubit or rx_cnot_rx with rx on the target qubit + if ( + history_i[j][0]["gate"] == "rz" + and history_i[j + 1][0]["gate"] == "cnot" + and history_i[j + 2][0]["gate"] == "rz" + and history_i[j + 1][0]["which_qubits"][0] == i + ) or ( + history_i[j][0]["gate"] == "rx" + and history_i[j + 1][0]["gate"] == "cnot" + and history_i[j + 2][0]["gate"] == "rx" + and history_i[j + 1][0]["which_qubits"][1] == i + ): + count += 1 + if count == 0: + return True + else: + return False + + @classmethod + def __rule_1(cls, cir: Circuit) -> Circuit: + r"""Simplify circuit when circuit has a CNOT just after :math:`|0\rangle` initialization. + + Args: + cir: Quantum circuit. + + Returns: + Simplified circuit. + """ + while not cls.__check_cnot_init(cir): + for i in range(cir.num_qubits): + qubit_history = cir.qubit_history + history_i = qubit_history[i] + if not history_i: + continue + if history_i[0][0]["gate"] == "cnot": + cnot_qubits = history_i[0][0]["which_qubits"] + # find the other qubit + for j in cnot_qubits: + if j != i: + # check the CNOT is also in the front for the other qubit + if ( + qubit_history[j][0][0]["gate"] == "cnot" + and qubit_history[j][0][0]["which_qubits"] + == cnot_qubits + ): + # delete the gate + cir.pop(qubit_history[j][0][1]) + qubit_history = cir.qubit_history + history_i = cir.qubit_history[i] + return cir + + @classmethod + def __rule_2(cls, cir: Circuit) -> Circuit: + r"""Simplify circuit when circuit has 2 consecutive and equal CNOTs compile to identity. + + Args: + cir: Quantum circuit. + + Returns: + Simplified circuit. + + """ + while not cls.__check_consec_cnot(cir): + for i in range(cir.num_qubits): + qubit_history = cir.qubit_history + history_i = qubit_history[i] + if not history_i: + continue + for j in range(len(history_i) - 1): + if j >= len(history_i) - 1: + break + # find consecutive cnots on one qubit + if ( + history_i[j][0]["gate"] == "cnot" + and history_i[j + 1][0] == history_i[j][0] + ): + cnot_qubits = history_i[j][0]["which_qubits"] + # get the other qubit + k = list(set(cnot_qubits).difference(set([i])))[0] + # check if the found consecutive cnots are also consecutive on the other qubit + history_k = qubit_history[k] + idx_k = history_k.index(history_i[j]) + if history_k[idx_k + 1] == history_i[j + 1]: + # delete found consecutive cnots from circuit history + cir.pop(history_i[j][1]) + cir.pop(history_i[j][1]) + qubit_history = cir.qubit_history + history_i = cir.qubit_history[i] + return cir + + @classmethod + def __rule_3(cls, cir: Circuit) -> Circuit: + r"""Simplify circuit when circuit has rotations around z axis after initialization, which leaves invariant . + + Args: + cir: Quantum circuit. + + Returns: + Simplified circuit. + + """ + while not cls.__check_rz_init(cir): + for i in range(cir.num_qubits): + history_i = cir.qubit_history[i] + if not history_i: + continue + if history_i[0][0]["gate"] == "z" or history_i[0][0]["gate"] == "rz": + # delete from history + cir.pop(history_i[0][1]) + return cir + + @classmethod + def __rule_4(cls, cir: Circuit) -> Circuit: + r"""Simplify circuit when circuit has repeated rotations (rz_rz -> r_z & rx_rx -> r_x). + + Args: + cir: Quantum circuit. + + Returns: + Simplified circuit. + """ + while not cls.__check_repeated_rotations(cir): + for i in range(cir.num_qubits): + history_i = cir.qubit_history[i] + if not history_i: + continue + for j in range(len(history_i) - 1): + if j == len(history_i) - 1: + break + # find consecutive rx/rz's + gates_name = [history_i[j + k][0]["gate"] + for k in range(2)] + if (gates_name[0] == "rx" and gates_name[1] == "rx") or \ + (gates_name[0] == "rz" and gates_name[1] == "rz"): + # get indexes of gates + idx = [history_i[j + k][1] - k for k in range(2)] + theta = history_i[j][0]["theta"] + \ + history_i[j + 1][0]["theta"] + + # delete two rx/rz + cir.pop(idx[0]) + cir.pop(idx[1]) + + # add values together for a new rx/rz + cir.insert(idx[0], RX( + i, param=theta) if gates_name[0] == "rx" else RZ(i, param=theta)) + + # update qubit_history of ith qubit + history_i = cir.qubit_history[i] + return cir + + @classmethod + def __calculate_new_angle(cls, theta: List[paddle.Tensor], xzxz: bool) -> paddle.Tensor: + r"""Calculate three new angles according to four old angles. + + Args: + theta: Four angles correspoding to rx, rz, rx, rz or rz, rx, rz, rx. + xzxz: Determine whether it is rx, rz, rx, rz or rz, rx, rz, rx. + + Returns: + Three new angles for rz_rx_rz given the unitary matrix. + """ + assert len(theta) == 4, str(len(theta)) + + if paddle.max(paddle.abs(theta - paddle.zeros([4]))).item() < 1e-5: + return np.array([0, 0, 0]) + + def rx(phi: paddle.Tensor) -> paddle.Tensor: + r"""A temporary function for rx generation. + + Args: + phi: Parameter input for rx. + + Returns: + Matrix representation for rx gate. + """ + gate = [paddle.cos(phi / 2).cast('complex64'), -1j * paddle.sin(phi / 2).cast('complex64'), + -1j * paddle.sin(phi / 2).cast('complex64'), paddle.cos(phi / 2).cast('complex64')] + return paddle.concat(gate).reshape([2, 2]) + + def rz(phi: paddle.Tensor) -> paddle.Tensor: + r"""A temporary function for rz generation. + + Args: + phi: Parameter input for rz. + + Returns: + Matrix representation for rz gate. + """ + gate = [paddle.cos(phi / 2).cast('complex128') - 1j * paddle.sin(phi / 2).cast('complex128'), paddle.to_tensor(0, dtype='complex128'), + paddle.to_tensor(0, dtype='complex128'), paddle.cos(phi / 2).cast('complex128') + 1j * paddle.sin(phi / 2).cast('complex128')] + return paddle.concat(gate).reshape([2, 2]) + + if xzxz: + unitary = rx(theta[0]) @ rz(theta[1]) @ rx(theta[2]) @ rz(theta[3]) + else: + unitary = rz(theta[0]) @ rx(theta[1]) @ rz(theta[2]) @ rx(theta[3]) + + x, y, z = symbols("x y z") + expr_list = [ + exp(-I * (x + z) / 2) * cos(y / 2), + -I * exp(-I * (x - z) / 2) * sin(y / 2), + exp(I * (z + x) / 2) * cos(y / 2), + ] + + element = np.reshape(unitary.numpy(), (4,)) + val_list = [] + for i, elem in enumerate(element): + if i != 2: + val_list.append(elem) + + eqs = [] + for expr, val in zip(expr_list, val_list): + eqs.append(expr - val) + + err = True + times = 0 + max_steps = 1000 + while err: + try: + solved_value_zxz = nsolve( + eqs, + [x, y, z], + 2 * np.pi * np.array([np.random.random(), + np.random.random(), np.random.random()]), + maxsteps=max_steps, + verify=True, + ) + res = np.array([complex(item) for item in solved_value_zxz]) + err = False + except: + max_steps += 20 + times = times + 1 + if times >= 10: + err = False + else: + res = 2 * np.pi * \ + np.array( + [np.random.random(), np.random.random(), np.random.random()]) + err = False + return res + + @classmethod + def __rule_5(cls, cir: Circuit) -> Circuit: + r"""Simplify circuit when circuit absorbs more than three consecutive rotations on one qubit into rz_rx_rz + we do rx_rz_rx_rz & rz_rx_rz_rx -> rz_rx_rz + + Args: + cir: Quantum circuit. + + Returns: + Simplified circuit. + """ + while not cls.__check_4_consec_rotations(cir): + for i in range(cir.num_qubits): + history_i = cir.qubit_history[i] + if not history_i: + continue + for j in range(len(history_i) - 3): + if j >= len(history_i) - 3: + break + + gates_name = [history_i[j + k][0]["gate"] + for k in range(4)] + # find 4 consecutive rotations rx_rz_rx_rz or rz_rx_rz_rx + if (gates_name[0] == "rx" + and gates_name[1] == "rz" + and gates_name[2] == "rx" + and gates_name[3] == "rz") or ( + gates_name[0] == "rz" + and gates_name[1] == "rx" + and gates_name[2] == "rz" + and gates_name[3] == "rx" + ): + # get the new angles for rz_rx_rz, assign the new angles to the last three rotations + theta = paddle.concat( + [history_i[j + k][0]["theta"] for k in range(4)]).cast('float64') + new_angles = np.real(cls.__calculate_new_angle( + theta, gates_name[0] == "rx")) + + # get indexes of gates + idx = [history_i[j + k][1] - k for k in range(4)] + + # remove the consecutive rotations + for k in range(4): + cir.pop(idx[k]) + # add rz_rx_rz rotations + cir.insert(idx[0], RZ(i, new_angles[2])) + cir.insert(idx[1] + 1, RX(i, new_angles[1])) + cir.insert(idx[2] + 2, RZ(i, new_angles[0])) + + # update qubit_history of ith qubit + history_i = cir.qubit_history[i] + return cir + + @classmethod + def __rule_6(cls, cir: Circuit) -> Circuit: + r"""Simplify circuit when circuit has Rz(control) and CNOT(control, target) Rz(control) or + Rx(target) and CNOT(control, target) Rx(target). We map these gates to Rz/x(control) CNOT. + + Args: + cir: Quantum circuit. + + Returns: + Simplified circuit. + """ + while not cls.__check_rz_cnot_rz_rx_cnot_rx(cir): + for i in range(cir.num_qubits): + history_i = cir.qubit_history[i] + if not history_i: + continue + for j in range(len(history_i) - 2): + if j == len(history_i) - 2: + break + if (history_i[j][0]["gate"] == "rz" + and history_i[j + 1][0]["gate"] == "cnot" + and history_i[j + 2][0]["gate"] == "rz" + and history_i[j + 1][0]["which_qubits"][0] == i) or ( + history_i[j][0]["gate"] == "rx" + and history_i[j + 1][0]["gate"] == "cnot" + and history_i[j + 2][0]["gate"] == "rx" + and history_i[j + 1][0]["which_qubits"][1] == i): + + idx = [history_i[j][1], history_i[j + 2][1]] + theta = history_i[j][0]["theta"] + \ + history_i[j + 2][0]["theta"] + + # delete two rx/z + cir.pop(idx[0]) + cir.pop(idx[1] - 1) + + # add values together for a new rx/z + cir.insert(idx[0], RX(i, param=theta) if history_i[j] + [0]["gate"] == "rx" else RZ(i, param=theta)) + + # update qubit_history of ith qubit + history_i = cir.qubit_history[i] + return cir + + @classmethod + def simplify_circuit(cls, cir: Circuit, zero_init_state: Optional[bool] = True) -> Circuit: + r"""Combine all simplifications together. + + Args: + cir: Quantum circuit. + zero_init_state: Whether the initial state is :math:`|0\rangle`. Defaults to ``True``. + + Returns: + Simplified circuit. + """ + # Check if the initial state is the zero state + if zero_init_state: + while not ( + cls.__check_cnot_init(cir) + and cls.__check_consec_cnot(cir) + and cls.__check_rz_init(cir) + and cls.__check_repeated_rotations(cir) + and cls.__check_4_consec_rotations(cir) + and cls.__check_rz_cnot_rz_rx_cnot_rx(cir) + ): + cir = cls.__rule_1(cir) + cir = cls.__rule_2(cir) + cir = cls.__rule_3(cir) + cir = cls.__rule_4(cir) + cir = cls.__rule_5(cir) + cir = cls.__rule_6(cir) + else: + while not ( + cls.__check_consec_cnot(cir) + and cls.__check_repeated_rotations(cir) + and cls.__check_4_consec_rotations(cir) + and cls.__check_rz_cnot_rz_rx_cnot_rx(cir) + ): + cir = cls.__rule_2(cir) + cir = cls.__rule_4(cir) + cir = cls.__rule_5(cir) + cir = cls.__rule_6(cir) + + return cir + + +def cir_decompose(cir: Circuit) -> Circuit: + r"""Decompose all layers of circuit into gates. + + Args: + cir: Target quantum circuit. + + Returns: + A quantum circuit with same structure and parameters but all layers are decomposed into Gates. + + Note: + This function does not support customized gates, such as oracle and control-oracle. + """ + gates_history = cir.gate_history + new_cir = Circuit() + for gate_info in gates_history: + gate_name = gate_info['gate'] + qubits_idx = gate_info['which_qubits'] + param = gate_info['theta'] + + # get gate function + if param is None: + getattr(new_cir, gate_name)(qubits_idx) + else: + getattr(new_cir, gate_name)(qubits_idx, param=param) + + return new_cir + + +class VAns: + r"""Class of Variable Ansatz. + + User can initialize this class to find variational circuit to construct QML model. + + Note: + The loss function passed in must have the quantum circuit as its first parameter. + + Args: + n: Number of qubits. + loss_func: Loss function that evaluate the loss of circuit. + loss_func_args: Parameters of loss function other than circuit. + epsilon: Range of random initialization of parameters. Defaults to ``0.1``. + insert_rate: Rate of number of inserted blocks. Defaults to ``2``. + iter: Number of iterations of optimizer. Defaults to ``100``. + iter_out: Number of insert-simplify cycles. Defaults to ``10``. + LR: Learning rate. Defaults to ``0.1``. + threshold: Tolerance of incread loss after deleting one qubit gate. Defaults to ``0.002``. + accpet_wall: Percentage of probability of accepting the circuit in current insert-simplify cycle. Defaults to ``100``. + zero_init_state: Whether the initial state is :math:`|0\rangle`. Defaults to ``True``. + """ + def __init__( + self, + n: int, + loss_func: Callable[[Circuit, Any], paddle.Tensor], + *loss_func_args: Any, + epsilon: float = 0.1, + insert_rate: float = 2, + iter: int = 100, + iter_out: int = 10, + LR: float = 0.1, + threshold: float = 0.002, + accept_wall: float = 100, + zero_init_state: bool = True + ): + self.n = n + self.loss_func = loss_func + self.loss_args = loss_func_args + self.epsilon = epsilon + self.insert_rate = insert_rate + self.cir = self.__init_cir(self.n) + self.iter = iter + self.iter_out = iter_out + self.loss = float("inf") + self.threshold = threshold + self.accept_wall = accept_wall + self.LR = LR + self.zero_init_state = zero_init_state + + def __init_cir(self, N: int) -> Circuit: + r"""Create a QNN circuit for VAns. + + Args: + N: Number of qubits. + + Return: + A quantum circuit. + """ + cir = Circuit(N) + + # simple version + # for i in range(N): + # cir.rx(i) + + # complicated version + for i in range(N): + cir.rx(i) + cir.rz(i) + if i % 2 == 0: + cir.cnot([i, (i + 1) % N]) + for i in range(N): + cir.rx(i) + cir.rz(i) + if i % 2 == 1: + cir.cnot([i, (i + 1) % N]) + + return cir + + def train(self) -> Circuit: + r"""Train the quantum circuit. + + Returns: + The quantum circuit with the lowest loss. + """ + for out_itr in range(1, self.iter_out + 1): + print("Out iteration", out_itr, "for structure optimization:") + if out_itr == 1: + itr_loss = self.optimization(self.cir) + self.loss = itr_loss + else: # insert + simplification + # Insert + new_cir = cir_decompose(self.cir) + new_cir = Inserter.insert_identities( + new_cir, self.insert_rate, self.epsilon) + + new_cir = Simplifier.simplify_circuit( + new_cir, self.zero_init_state) + + itr_loss = self.optimization(new_cir) + + relative_diff = (itr_loss - self.loss) / abs(itr_loss) + + if relative_diff <= 0 or np.random.random() <= np.exp(-relative_diff * self.accept_wall): + print(" accpet the new circuit!") + + # Remove gates that do not lower the loss + new_cir = self.delete_gates(new_cir, itr_loss) + new_cir = Simplifier.simplify_circuit( + new_cir, self.zero_init_state) + itr_loss = self.loss_func(new_cir, *self.loss_args).item() + self.cir = new_cir + self.loss = itr_loss + else: + print(" decline the new circuit!") + + print(" Current loss:", self.loss) + print(" Current cir:") + print(self.cir, '\n') + + # Output the results + print("\n") + print("The final loss:", self.loss) + print("The final circuit:") + print(self.cir) + + def optimization(self, cir: Circuit) -> float: + r"""Optimize circuit parameters with loss function. + + Args: + cir: Quantum circuit. + + Returns: + Optimized loss. + """ + + opt = paddle.optimizer.Adam( + learning_rate=self.LR, parameters=cir.parameters()) + + for itr in range(1, self.iter+1): + loss = self.loss_func(cir, *self.loss_args) + loss.backward() + opt.minimize(loss) + opt.clear_grad() + if itr % 20 == 0: + print("iter:", itr, "loss:", loss.numpy()) + + return loss.numpy() + + def delete_gates(self, cir: Circuit, loss: float) -> Circuit: + r"""Remove single qubit gates if the loss decreases or increases within a threshold. + + Args: + cir: Quantum circuit. + loss: Current loss. + + Returns: + Circuit after deleting unnecessary gates. + """ + count_delete = 0 + print(" start deleting gates") + gate_history = cir.gate_history + for idx, gate in enumerate(gate_history): + candidate_cir = cir_decompose(cir) + idx_true = idx - count_delete + if gate["gate"] != "cnot": + candidate_cir.pop(idx_true) + candidate_loss = self.loss_func( + candidate_cir, *self.loss_args).item() + + if candidate_loss <= loss or (candidate_loss - loss) / abs(self.loss) <= self.threshold: + print(" Deletion: accept deletion with acceptable loss") + loss = candidate_loss + cir = candidate_cir + count_delete += 1 + continue + print(" Deletion: reject deletion") + print(" ", count_delete, " gates are deleted!") + return cir + + +if __name__ == "__main__": + r""" + A simple application on VQE + """ + import paddle_quantum.qchem as qchem + from paddle_quantum import set_backend, Hamiltonian + + # Construct a Hamiltonian + geo = qchem.geometry( + structure=[["H", [-0.0, 0.0, 0.0]], ["H", [-0.0, 0.0, 0.74]]]) + molecule = qchem.get_molecular_data( + geometry=geo, + basis="sto-3g", + charge=0, + multiplicity=1, + method="fci", + if_save=True, + if_print=False, + ) + + molecular_hamiltonian = qchem.spin_hamiltonian( + molecule=molecule, + filename=None, + multiplicity=1, + mapping_method="jordan_wigner", + ) + + n = molecular_hamiltonian.n_qubits + + # Define a loss function, note that the first parameter should be an Circuit + def loss_f(cir: Circuit, H: Hamiltonian) -> paddle.Tensor: + return cir().expec_val(H) + + # Construct an instance of VAns, using n, loss function and other parameters. + set_backend(backend='state_vector') + vans = VAns( + n, + loss_f, + Hamiltonian(molecular_hamiltonian.pauli_str), + insert_rate=1, + iter_out=10, + zero_init_state=true, + ) + + # Train + vans.train() diff --git a/paddle_quantum/backend/__init__.py b/paddle_quantum/backend/__init__.py new file mode 100644 index 0000000..4de55dd --- /dev/null +++ b/paddle_quantum/backend/__init__.py @@ -0,0 +1,30 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The module that contains various backends. +""" + +from . import state_vector +from . import density_matrix +from . import quleaf +import enum + + +class Backend(enum.Enum): + StateVector = 'state_vector' + DensityMatrix = 'density_matrix' + QuLeaf = 'quleaf' + UnitaryMatrix = 'unitary_matrix' diff --git a/paddle_quantum/backend/density_matrix.py b/paddle_quantum/backend/density_matrix.py new file mode 100644 index 0000000..33c3208 --- /dev/null +++ b/paddle_quantum/backend/density_matrix.py @@ -0,0 +1,130 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the density_matrix backend. +""" + +import paddle +from typing import List, Iterable, Union + + +def unitary_transformation( + state: paddle.Tensor, gate: paddle.Tensor, qubit_idx: Union[List[int], int], num_qubits: int +) -> paddle.Tensor: + r"""The function of unitary transformation in the mode of density matrix. + + Args: + state: The input quantum state. + gate: The gate that represents the unitary transformation. + qubit_idx: The indices of the qubits on which the gate is acted. + num_qubits: The number of the qubits in the input quantum state. + + Returns: + The transformed quantum state. + """ + # The order of the tensor in paddle is less than 10. + higher_dims = state.shape[:-2] + num_higher_dims = len(higher_dims) + + if not isinstance(qubit_idx, Iterable): + qubit_idx = [qubit_idx] + + # generate swap_list + num_acted_qubits = len(qubit_idx) + origin_seq = list(range(0, num_qubits)) + seq_for_acted = qubit_idx + [x for x in origin_seq if x not in qubit_idx] + swapped = [False] * num_qubits + swap_ops = [] + for idx in range(0, num_qubits): + if not swapped[idx]: + next_idx = idx + swapped[next_idx] = True + while not swapped[seq_for_acted[next_idx]]: + swapped[seq_for_acted[next_idx]] = True + if next_idx < seq_for_acted[next_idx]: + swap_ops.append((next_idx, seq_for_acted[next_idx])) + else: + swap_ops.append((seq_for_acted[next_idx], next_idx)) + next_idx = seq_for_acted[next_idx] + + for swap_op in swap_ops: + shape = higher_dims.copy() + last_idx = -1 + for idx in swap_op: + shape.append(2 ** (idx - last_idx - 1)) + shape.append(2) + last_idx = idx + shape.append(2 ** (2 * num_qubits - last_idx - 1)) + state = paddle.reshape(state, shape) + state = paddle.transpose( + state, list(range(0, num_higher_dims)) + [item + num_higher_dims for item in [0, 3, 2, 1, 4]] + ) + state = paddle.reshape( + state, higher_dims.copy() + [2 ** num_acted_qubits, 2 ** (2 * num_qubits - num_acted_qubits)] + ) + state = paddle.matmul(gate, state) + swap_ops.reverse() + for swap_op in swap_ops: + shape = higher_dims.copy() + last_idx = -1 + for idx in swap_op: + shape.append(2 ** (idx - last_idx - 1)) + shape.append(2) + last_idx = idx + shape.append(2 ** (2 * num_qubits - last_idx - 1)) + state = paddle.reshape(state, shape) + state = paddle.transpose( + state, list(range(0, num_higher_dims)) + [item + num_higher_dims for item in [0, 3, 2, 1, 4]] + ) + swap_ops.reverse() + for idx, swap_op in enumerate(swap_ops): + swap_ops[idx] = (swap_op[0] + num_qubits, swap_op[1] + num_qubits) + for swap_op in swap_ops: + shape = higher_dims.copy() + last_idx = - 1 + for idx in swap_op: + shape.append(2 ** (idx - last_idx - 1)) + shape.append(2) + last_idx = idx + shape.append(2 ** (2 * num_qubits - last_idx - 1)) + state = paddle.reshape(state, shape) + state = paddle.transpose( + state, list(range(0, num_higher_dims)) + [item + num_higher_dims for item in [0, 3, 2, 1, 4]] + ) + state = paddle.reshape( + state, higher_dims.copy() + [2 ** num_qubits, 2 ** num_acted_qubits, 2 ** (num_qubits - num_acted_qubits)] + ) + # gate_dagger = paddle.conj(paddle.t(gate)) + # state = paddle.einsum('abc,bx->axc', state, gate_dagger) + # The computation below is equivalent to the einsum above. + gate_dagger = paddle.conj(gate) + state = paddle.matmul(gate_dagger, state) + swap_ops.reverse() + for swap_op in swap_ops: + shape = higher_dims.copy() + last_idx = - 1 + for idx in swap_op: + shape.append(2 ** (idx - last_idx - 1)) + shape.append(2) + last_idx = idx + shape.append(2 ** (2 * num_qubits - last_idx - 1)) + state = paddle.reshape(state, shape) + state = paddle.transpose( + state, list(range(0, num_higher_dims)) + [item + num_higher_dims for item in [0, 3, 2, 1, 4]] + ) + + state = paddle.reshape(state, higher_dims.copy() + [2 ** num_qubits, 2 ** num_qubits]) + return state diff --git a/paddle_quantum/backend/quleaf.py b/paddle_quantum/backend/quleaf.py new file mode 100644 index 0000000..3ac3f4f --- /dev/null +++ b/paddle_quantum/backend/quleaf.py @@ -0,0 +1,325 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the quleaf backend. +""" + +import copy +import math +import numpy as np +import paddle +import QCompute +import re +from QCompute import MeasureZ, RX, RY +import paddle_quantum + +BACKEND = 'local_baidu_sim2' +TOKEN = None +QCompute.Define.Settings.outputInfo = False +QCompute.Define.Settings.drawCircuitControl = [] + + +def set_quleaf_backend(backend: str) -> None: + r"""Set the backend of the QuLeaf. + + Args: + backend: The backend you want to set. + """ + global BACKEND + BACKEND = backend + + +def get_quleaf_backend() -> str: + r"""Get the current backend of the QuLeaf. + + Returns: + Current backend of the QuLeaf. + """ + if isinstance(BACKEND, str): + return QCompute.BackendName(BACKEND) + return BACKEND + + +def set_quleaf_token(token: str) -> None: + r"""Set the token of the QuLeaf. + + You need to input your token if you want tu use the cloud server. + + Args: + token: Your token. + """ + global TOKEN + TOKEN = token + + +def get_quleaf_token() -> str: + r"""Get the token you set. + + Returns: + The token you set. + """ + return TOKEN + + +def _act_gates_to_state(gate_history: list, quleaf_state: QCompute.QEnv, param_all: list) -> QCompute.QEnv: + r"""The function to act the quantum gate to the quantum state in the QuLeaf backend. + + Args: + gate_history: The history of quantum gate, which records the type, parameters and qubits index of the gates. + quleaf_state: The quantum state in QuLeaf. + param_all: All the parameters in the gates. + + Raises: + NotImplementedError: Some quantum gate is not supported in QuLeaf yet. + + Returns: + The acted quantum state. + """ + single_qubit_gates = { + 's': QCompute.S, 't': QCompute.T, 'sdg': QCompute.SDG, 'tdg': QCompute.TDG, + 'h': QCompute.H, 'x': QCompute.X, 'y': QCompute.Y, 'z': QCompute.Z, + 'u3': QCompute.U, 'rx': QCompute.RX, 'ry': QCompute.RY, 'rz': QCompute.RZ + } + multi_qubits_gates = { + 'cnot': QCompute.CX, 'cx': QCompute.CX, 'cy': QCompute.CY, 'cz': QCompute.CZ, 'swap': QCompute.SWAP, + 'cu': QCompute.CU, 'crx': QCompute.CRX, 'cry': QCompute.CRY, 'crz': QCompute.CRZ, + 'cswap': QCompute.CSWAP, 'ccx': QCompute.CCX + } + for gate in gate_history: + gate_name = gate['gate_name'] + if gate_name in single_qubit_gates: + gate_func = single_qubit_gates[gate_name] + fixed_gate = ['s', 't', 'sdg', 'tdg', 'h', 'x', 'y', 'z'] + if gate_name in fixed_gate: + for _ in range(0, gate['depth']): + for qubit_idx in gate['qubits_idx']: + gate_func(quleaf_state.Q[qubit_idx]) + elif gate_name == 'u': + for depth_idx in range(0, gate['depth']): + for idx, qubit_idx in enumerate(gate['qubits_idx']): + if gate['param_sharing']: + param_idx = gate['param'][depth_idx] + else: + param_idx = gate['param'][depth_idx][idx] + gate_param = [param_all[idx] for idx in param_idx] + gate_func(*gate_param)(quleaf_state.Q[qubit_idx]) + else: + for depth_idx in range(0, gate['depth']): + for idx, qubit_idx in enumerate(gate['qubits_idx']): + if gate['param_sharing']: + param_idx = gate['param'][depth_idx] + else: + param_idx = gate['param'][depth_idx][idx] + gate_func(param_all[param_idx])(quleaf_state.Q[qubit_idx]) + elif gate_name in multi_qubits_gates: + gate_func = multi_qubits_gates[gate_name] + fixed_gate = ['cnot', 'cx', 'cy', 'cz', 'swap', 'cswap', 'ccx'] + if gate_name in fixed_gate: + for _ in range(0, gate['depth']): + for qubits_idx in gate['qubits_idx']: + qubit_list = [quleaf_state.Q[qubit_idx] for qubit_idx in qubits_idx] + gate_func(*qubit_list) + elif gate_name == 'cu': + for depth_idx in range(0, gate['depth']): + for idx, qubits_idx in enumerate(gate['qubits_idx']): + if gate['param_sharing']: + param_idx = gate['param'][depth_idx] + else: + param_idx = gate['param'][depth_idx][idx] + gate_param = [param_all[idx] for idx in param_idx] + qubit_list = [quleaf_state.Q[qubit_idx] for qubit_idx in qubits_idx] + gate_func(*gate_param)(*qubit_list) + else: + for depth_idx in range(0, gate['depth']): + for idx, qubits_idx in enumerate(gate['qubits_idx']): + if gate['param_sharing']: + param_idx = gate['param'][0] + else: + param_idx = gate['param'][depth_idx][idx] + qubit_list = [quleaf_state.Q[qubit_idx] for qubit_idx in qubits_idx] + gate_func(param_all[param_idx])(*qubit_list) + else: + raise NotImplementedError + return quleaf_state + + +def _expec_val_on_quleaf(state: 'QCompute.QEnv', coeff: 'float', pauli_str: 'str', shots: 'int') -> float: + r"""Compute the expectation value of the observable with respect to the input state in the QuLeaf backend. + + Args: + state: The quantum state in the QuLeaf backend. + coeff: The coefficient value of the pauli string. + pauli_str: The pauli string, which is a term in hamiltonian. + shots: The number of measurement shots. + + Raises: + ValueError: The pauli string should be legal. + + Returns: + The expectation value of the observable with respect to the input quantum state. + """ + if pauli_str.lower() == 'i': + return coeff + pauli_terms = re.split(r',\s*', pauli_str.lower()) + observed_qubits = [] + # _state = state + _state = copy.deepcopy(state) + for pauli_term in pauli_terms: + pauli_matrix = pauli_term[0] + qubit_idx = int(pauli_term[1:]) + observed_qubits.append(qubit_idx) + if pauli_matrix == 'x': + RY(-np.pi / 2)(_state.Q[qubit_idx]) + elif pauli_matrix == 'y': + RX(np.pi / 2)(_state.Q[qubit_idx]) + elif pauli_matrix == 'z': + pass + else: + raise ValueError("Cannot recognize the pauli words of the hamiltonian.") + MeasureZ(*_state.Q.toListPair()) + counts = _state.commit(shots, fetchMeasure=True)['counts'] + filtered_counts = [(counts[key], [key[-idx - 1] for idx in observed_qubits]) for key in counts] + val = coeff * sum([((-1) ** key.count('1')) * val / shots for val, key in filtered_counts]) + return val + + +def _get_param_for_gate_list(gate_history: list) -> list: + r"""Get the all parameters from the gate list. + + Args: + gate_history: The gate history, it is automatically generated. + + Returns: + The list of the parameters. + """ + param_for_gate_list = [] + num_param_in_gate = { + 'rx': 1, 'ry': 1, 'rz': 1, 'u3': 3, + 'crx': 1, 'cry': 1, 'crz': 1, 'cu': 1, + } + for gate in gate_history: + gate_name = gate['gate_name'] + if gate_name in num_param_in_gate: + num_param = np.array(gate['param']).size + for _ in range(0, num_param): + param_for_gate_list.append(gate_name) + return param_for_gate_list + + +class ExpecValOp(paddle.autograd.PyLayer): + @staticmethod + def forward( + ctx: paddle.autograd.PyLayerContext, + param: paddle.Tensor, + state: 'paddle_quantum.State', + hamiltonian: 'paddle_quantum.Hamiltonian', + shots: int, + ) -> paddle.Tensor: + r"""The forward function to compute the expectation value of the observable in the QuLeaf Backend. + + Args: + ctx: To save some variables so that they can be used in the backward function. + param: The parameters in the previous quantum gates. + state: The quantum state to be measured. + hamiltonian: The observable. + shots: The number of measurement shots. + + Returns: + The expectation value of the observable for the input state. + """ + ctx.save_for_backward(param) + quleaf_state = copy.deepcopy(state.data) + ctx.quleaf_state = quleaf_state + gate_history = state.gate_history + ctx.gate_history = gate_history + ctx.hamiltonian = hamiltonian + ctx.shots = shots + state.gate_history = [] + state.param_list = [] + state.num_param = 0 + param_all = param.tolist() + _state = copy.deepcopy(quleaf_state) + acted_state = _act_gates_to_state(gate_history, _state, param_all) + expec_val = 0 + for coeff, pauli_str in hamiltonian.pauli_str: + _state = copy.deepcopy(acted_state) + expec_val += _expec_val_on_quleaf(_state, coeff, pauli_str, shots) + expec_val = paddle.to_tensor([expec_val], dtype=param.dtype) + return expec_val + + @staticmethod + def backward(ctx: paddle.autograd.PyLayerContext, expec_val_grad: paddle.Tensor) -> paddle.Tensor: + r"""The backward function which is to compute the gradient of the input parameters. + + Args: + ctx: To get the variables saved in the forward function. + expec_val_grad: The gradient of the expectation value. + + Returns: + The gradient of the parameters for the quantum gates. + """ + param, = ctx.saved_tensor() + param_all = param.tolist() + quleaf_state = ctx.quleaf_state + gate_history = ctx.gate_history + hamiltonian = ctx.hamiltonian + shots = ctx.shots + param_for_gate_list = _get_param_for_gate_list(gate_history) + assert len(param_for_gate_list) == len(param_all) + + def expec_val_shift(param_idx: int, param_shift: float) -> float: + param_temp = copy.deepcopy(param_all) + param_temp[param_idx] += param_shift + _state = copy.deepcopy(quleaf_state) + acted_state = _act_gates_to_state(gate_history, _state, param_temp) + expec_val = 0 + for coeff, pauli_str in hamiltonian.pauli_str: + _state = copy.deepcopy(acted_state) + expec_val += _expec_val_on_quleaf(_state, coeff, pauli_str, shots) + # expec_val = paddle.to_tensor([expec_val], dtype=expec_val_grad.dtype) + return expec_val + + def general_param_shift(param_idx: int) -> float: + gate_name = param_for_gate_list[param_idx] + if gate_name in ['crx', 'cry', 'crz', 'cu']: + coeff_list = [ + 1 / (16 * math.pow(math.sin(math.pi / 8), 2)), + -1 / (16 * math.pow(math.sin(3 * math.pi / 8), 2)), + 1 / (16 * math.pow(math.sin(5 * math.pi / 8), 2)), + - 1 / (16 * math.pow(math.sin(7 * math.pi / 8), 2)), + ] + shift_list = [math.pi / 2, 3 * math.pi / 2, 5 * math.pi / 2, 7 * math.pi / 2] + grad_terms = map( + lambda coeff, shift: coeff * expec_val_shift(param_idx, shift), + coeff_list, shift_list + ) + grad = sum(grad_terms) + else: + coeff1 = 0.5 + coeff2 = -0.5 + grad = ( + coeff1 * expec_val_shift(param_idx, math.pi / 2) + + coeff2 * expec_val_shift(param_idx, 3 * math.pi / 2) + ) + return grad + + param_grad = np.zeros(param.size) + for idx in range(0, param_grad.size): + param_grad[idx] = general_param_shift(idx) + param_grad = np.reshape(param_grad, param.shape) + param_grad = paddle.to_tensor(param_grad, dtype=param.dtype) + param_grad = expec_val_grad * param_grad + return param_grad diff --git a/paddle_quantum/backend/state_vector.py b/paddle_quantum/backend/state_vector.py new file mode 100644 index 0000000..3da9636 --- /dev/null +++ b/paddle_quantum/backend/state_vector.py @@ -0,0 +1,91 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the state_vector backend. +""" + +import paddle +from typing import List, Iterable, Union + + +def unitary_transformation( + state: paddle.Tensor, gate: paddle.Tensor, qubit_idx: Union[List[int], int], num_qubits: int +) -> paddle.Tensor: + r"""The function of unitary transformation in the mode of state vector. + + Args: + state: The input quantum state. + gate: The gate that represents the unitary transformation. + qubit_idx: The indices of the qubits on which the gate is acted. + num_qubits: The number of the qubits in the input quantum state. + + Returns: + The transformed quantum state. + """ + # The order of the tensor in paddle is less than 10. + higher_dims = state.shape[:-1] + num_higher_dims = len(higher_dims) + + if not isinstance(qubit_idx, Iterable): + qubit_idx = [qubit_idx] + + # generate swap_list + num_acted_qubits = len(qubit_idx) + origin_seq = list(range(0, num_qubits)) + seq_for_acted = qubit_idx + [x for x in origin_seq if x not in qubit_idx] + swapped = [False] * num_qubits + swap_ops = [] + for idx in range(0, num_qubits): + if not swapped[idx]: + next_idx = idx + swapped[next_idx] = True + while not swapped[seq_for_acted[next_idx]]: + swapped[seq_for_acted[next_idx]] = True + if next_idx < seq_for_acted[next_idx]: + swap_ops.append((next_idx, seq_for_acted[next_idx])) + else: + swap_ops.append((seq_for_acted[next_idx], next_idx)) + next_idx = seq_for_acted[next_idx] + for swap_op in swap_ops: + shape = higher_dims.copy() + last_idx = -1 + for idx in swap_op: + shape.append(2 ** (idx - last_idx - 1)) + shape.append(2) + last_idx = idx + shape.append(2 ** (num_qubits - last_idx - 1)) + state = paddle.reshape(state, shape) + state = paddle.transpose( + state, list(range(0, num_higher_dims)) + [item + num_higher_dims for item in [0, 3, 2, 1, 4]] + ) + state = paddle.reshape(state, higher_dims.copy() + [2 ** num_acted_qubits, 2 ** (num_qubits - num_acted_qubits)]) + state = paddle.matmul(gate, state) + swap_ops.reverse() + for swap_op in swap_ops: + shape = higher_dims.copy() + last_idx = -1 + for idx in swap_op: + shape.append(2 ** (idx - last_idx - 1)) + shape.append(2) + last_idx = idx + shape.append(2 ** (num_qubits - last_idx - 1)) + state = paddle.reshape(state, shape) + state = paddle.transpose( + state, list(range(0, num_higher_dims)) + [item + num_higher_dims for item in [0, 3, 2, 1, 4]] + ) + + state = paddle.reshape(state, higher_dims.copy() + [2 ** num_qubits]) + return state diff --git a/paddle_quantum/backend/unitary_matrix.py b/paddle_quantum/backend/unitary_matrix.py new file mode 100644 index 0000000..a614908 --- /dev/null +++ b/paddle_quantum/backend/unitary_matrix.py @@ -0,0 +1,93 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the unitary_matrix backend. +""" + +import paddle +from typing import List, Iterable, Union + + +def unitary_transformation( + state: paddle.Tensor, gate: paddle.Tensor, qubit_idx: Union[List[int], int], num_qubits: int +) -> paddle.Tensor: + r"""The function of unitary transformation in the mode of computing the unitary matrix. + + Args: + state: The input quantum state. + gate: The gate that represents the unitary transformation. + qubit_idx: The indices of the qubits on which the gate is acted. + num_qubits: The number of the qubits in the input quantum state. + + Returns: + The transformed quantum state. + """ + # The order of the tensor in paddle is less than 10. + higher_dims = state.shape[:-2] + num_higher_dims = len(higher_dims) + + if not isinstance(qubit_idx, Iterable): + qubit_idx = [qubit_idx] + + # generate swap_list + num_acted_qubits = len(qubit_idx) + origin_seq = list(range(0, num_qubits)) + seq_for_acted = qubit_idx + [x for x in origin_seq if x not in qubit_idx] + swapped = [False] * num_qubits + swap_ops = [] + for idx in range(0, num_qubits): + if not swapped[idx]: + next_idx = idx + swapped[next_idx] = True + while not swapped[seq_for_acted[next_idx]]: + swapped[seq_for_acted[next_idx]] = True + if next_idx < seq_for_acted[next_idx]: + swap_ops.append((next_idx, seq_for_acted[next_idx])) + else: + swap_ops.append((seq_for_acted[next_idx], next_idx)) + next_idx = seq_for_acted[next_idx] + + for swap_op in swap_ops: + shape = higher_dims.copy() + last_idx = -1 + for idx in swap_op: + shape.append(2 ** (idx - last_idx - 1)) + shape.append(2) + last_idx = idx + shape.append(2 ** (2 * num_qubits - last_idx - 1)) + state = paddle.reshape(state, shape) + state = paddle.transpose( + state, list(range(0, num_higher_dims)) + [item + num_higher_dims for item in [0, 3, 2, 1, 4]] + ) + state = paddle.reshape( + state, higher_dims.copy() + [2 ** num_acted_qubits, 2 ** (2 * num_qubits - num_acted_qubits)] + ) + state = paddle.matmul(gate, state) + swap_ops.reverse() + for swap_op in swap_ops: + shape = higher_dims.copy() + last_idx = -1 + for idx in swap_op: + shape.append(2 ** (idx - last_idx - 1)) + shape.append(2) + last_idx = idx + shape.append(2 ** (2 * num_qubits - last_idx - 1)) + state = paddle.reshape(state, shape) + state = paddle.transpose( + state, list(range(0, num_higher_dims)) + [item + num_higher_dims for item in [0, 3, 2, 1, 4]] + ) + state = paddle.reshape(state, higher_dims.copy() + [2 ** num_qubits, 2 ** num_qubits]) + return state diff --git a/paddle_quantum/base.py b/paddle_quantum/base.py new file mode 100644 index 0000000..b44b8fb --- /dev/null +++ b/paddle_quantum/base.py @@ -0,0 +1,133 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The basic function of the paddle quantum. +""" + +import paddle +import paddle_quantum +from typing import Union, Optional + +DEFAULT_DEVICE = 'cpu' +DEFAULT_SIMULATOR = paddle_quantum.Backend.StateVector +DEFAULT_DTYPE = 'complex64' + + +def set_device(device: 'str') -> None: + r"""Set the device to save the tensor. + + Args: + device: The name of the device. + """ + global DEFAULT_DEVICE + DEFAULT_DEVICE = device + paddle.set_device(device) + + +def get_device() -> 'str': + r"""Get the current device to save the tensor. + + Returns: + The name of the current device. + """ + return DEFAULT_DEVICE + + +def set_backend(backend: Union[str, paddle_quantum.Backend]) -> None: + r"""Set the backend implementation of paddle quantum. + + Args: + backend: The name of the backend. + """ + global DEFAULT_SIMULATOR + if isinstance(backend, str): + DEFAULT_SIMULATOR = paddle_quantum.Backend(backend) + else: + DEFAULT_SIMULATOR = backend + + +def get_backend() -> paddle_quantum.Backend: + r"""Get the current backend of paddle quantum. + + Returns: + The name of currently used backend. + """ + return DEFAULT_SIMULATOR + + +def set_dtype(dtype: 'str') -> None: + r"""Set the data type . + + Args: + dtype: The dtype can be ``complex64`` and ``complex128``. + + Raises: + ValueError: The dtype should be complex64 or complex128. + """ + global DEFAULT_DTYPE + DEFAULT_DTYPE = dtype + if dtype == 'complex64': + paddle.set_default_dtype('float32') + elif dtype == 'complex128': + paddle.set_default_dtype('float64') + else: + raise ValueError("The dtype should be complex64 or complex128.") + + +def get_dtype() -> 'str': + r"""Return currently used data type. + + Returns: + Currently used data type. + """ + return DEFAULT_DTYPE + + +class Operator(paddle.nn.Layer): + r"""The basic class to implement the quantum operation. + + Args: + backend: The backend implementation of the operator. + Defaults to ``None``, which means to use the default backend implementation. + dtype: The data type of the operator. + Defaults to ``None``, which means to use the default data type. + name_scope: Prefix name used by the operator to name parameters. Defaults to ``None``. + """ + def __init__(self, backend: Optional[paddle_quantum.Backend] = None, dtype: Optional[str] = None, + name_scope: Optional[str] = None): + if dtype is None: + super().__init__(name_scope) + else: + super().__init__(name_scope, dtype) + self.dtype = dtype if dtype is not None else get_dtype() + + if backend == paddle_quantum.Backend.StateVector: + self.backend = backend + elif backend == paddle_quantum.Backend.DensityMatrix: + self.backend = backend + elif backend is None: + self.backend = get_backend() + + def to(self, backend: Optional[paddle_quantum.Backend] = None, device: Optional[str] = None, + dtype: Optional[str] = None, blocking: Optional[str] = None): + super().to(device, dtype, blocking) + if backend is not None: + self.backend = backend + for sub_layer in self.children(): + sub_layer.backend = backend + + def forward(self, *inputs, **kwargs): + raise NotImplementedError diff --git a/paddle_quantum/channel/__init__.py b/paddle_quantum/channel/__init__.py new file mode 100644 index 0000000..982b0a2 --- /dev/null +++ b/paddle_quantum/channel/__init__.py @@ -0,0 +1,32 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The module of the quantum channels. +""" + +from .base import Channel +from .common import BitFlip +from .common import PhaseFlip +from .common import BitPhaseFlip +from .common import AmplitudeDamping +from .common import GeneralizedAmplitudeDamping +from .common import PhaseDamping +from .common import Depolarizing +from .common import PauliChannel +from .common import ResetChannel +from .common import ThermalRelaxation +from .custom import KrausRepr +from .custom import ChoiRepr diff --git a/paddle_quantum/channel/base.py b/paddle_quantum/channel/base.py new file mode 100644 index 0000000..33bdcd2 --- /dev/null +++ b/paddle_quantum/channel/base.py @@ -0,0 +1,54 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the basic class for the quantum channels. +""" + +from typing import Any, Optional +import paddle_quantum + + +class Channel(paddle_quantum.Operator): + r"""Basic class for quantum channels. + + Args: + backend: Backend on which the channel is executed. Defaults to ``None``. + dtype: Type of data. Defaults to ``None``. + name_scope: Prefix name used by the layer to name parameters. If prefix is "my_layer", parameter name in + MyLayer can be "my_layer_0.w_n", where "w" is the parameter base name and "n" is an unique suffix + auto-generated. If ``None``, prefix name will be snake cased class name. Defaults to ``None``. + """ + def __init__( + self, backend: paddle_quantum.Backend = None, dtype: str = None, name_scope: str = None + ) -> None: + super().__init__(backend, dtype, name_scope) + + def to(self, backend: Optional[str] = None, device: Optional[str] = None, + dtype: Optional[str] = None, blocking: Optional[str] = None) -> None: + super().to(device, dtype, blocking) + # TODO: to be implemented + raise NotImplementedError + + def forward(self, *inputs: Any, **kwargs: Any) -> None: + raise NotImplementedError + + def __setattr__(self, name, value): + super().__setattr__(name, value) + if isinstance(value, Channel): + if value.backend is None: + value.backend = paddle_quantum.get_backend() if self.backend is None else self.backend + if value.dtype is None: + value.dtype = paddle_quantum.get_dtype() if self.dtype is None else self.dtype diff --git a/paddle_quantum/channel/common.py b/paddle_quantum/channel/common.py new file mode 100644 index 0000000..2fa3435 --- /dev/null +++ b/paddle_quantum/channel/common.py @@ -0,0 +1,421 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the classes for several quantum channel. +""" + +import paddle +import paddle_quantum +from paddle_quantum.intrinsic import _format_qubits_idx +from .base import Channel +from . import functional +from ..backend import Backend +from typing import Union, Iterable + + +class BitFlip(Channel): + r"""A collection of bit flip channels. + + Such a channel's Kraus operators are + + .. math:: + + E_0 = \sqrt{1-p} I, + E_1 = \sqrt{p} X. + + Args: + prob: Probability of a bit flip. Its value should be in the range :math:`[0, 1]`. + qubits_idx: Indices of the qubits on which the channels act. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + """ + def __init__( + self, prob: Union[paddle.Tensor, float], + qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ): + super().__init__() + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + if isinstance(prob, float): + self.prob = paddle.to_tensor(prob) + else: + self.prob = prob + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for qubit_idx in self.qubits_idx: + state = functional.bit_flip(state, self.prob, qubit_idx, self.dtype, self.backend) + return state + + +class PhaseFlip(Channel): + r"""A collection of phase flip channels. + + Such a channel's Kraus operators are + + .. math:: + + E_0 = \sqrt{1 - p} I, + E_1 = \sqrt{p} Z. + + Args: + prob: Probability of a phase flip. Its value should be in the range :math:`[0, 1]`. + qubits_idx: Indices of the qubits on which the channels act. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + """ + def __init__( + self, prob: Union[paddle.Tensor, float], + qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ): + super().__init__() + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + if isinstance(prob, float): + self.prob = paddle.to_tensor(prob) + else: + self.prob = prob + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for qubit_idx in self.qubits_idx: + state = functional.phase_flip(state, self.prob, qubit_idx, self.dtype, self.backend) + return state + + +class BitPhaseFlip(Channel): + r"""A collection of bit phase flip channels. + + Such a channel's Kraus operators are + + .. math:: + + E_0 = \sqrt{1 - p} I, + E_1 = \sqrt{p} Y. + + Args: + prob: Probability of a bit phase flip. Its value should be in the range :math:`[0, 1]`. + qubits_idx: Indices of the qubits on which the channels act. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + """ + def __init__( + self, prob: Union[paddle.Tensor, float], + qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ): + super().__init__() + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + if isinstance(prob, float): + self.prob = paddle.to_tensor(prob) + else: + self.prob = prob + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for qubit_idx in self.qubits_idx: + state = functional.bit_phase_flip(state, self.prob, qubit_idx, self.dtype, self.backend) + return state + + +class AmplitudeDamping(Channel): + r"""A collection of amplitude damping channels. + + Such a channel's Kraus operators are + + .. math:: + + 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: Damping probability. Its value should be in the range :math:`[0, 1]`. + qubits_idx: Indices of the qubits on which the channels act. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + """ + def __init__( + self, gamma: Union[paddle.Tensor, float], + qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ): + super().__init__() + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + if isinstance(gamma, float): + self.gamma = paddle.to_tensor(gamma) + else: + self.gamma = gamma + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for qubit_idx in self.qubits_idx: + state = functional.amplitude_damping(state, self.gamma, qubit_idx, self.dtype, self.backend) + return state + + +class GeneralizedAmplitudeDamping(Channel): + r"""A collection of generalized amplitude damping channels. + + Such a channel's Kraus operators are + + .. math:: + + 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}. + + Args: + gamma: Damping probability. Its value should be in the range :math:`[0, 1]`. + prob: Excitation probability. Its value should be in the range :math:`[0, 1]`. + qubits_idx: Indices of the qubits on which the channels act. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + """ + def __init__( + self, gamma: Union[paddle.Tensor, float], prob: Union[paddle.Tensor, float], + qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ): + super().__init__() + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + if isinstance(prob, float): + self.prob = paddle.to_tensor(prob) + else: + self.prob = prob + if isinstance(gamma, float): + self.gamma = paddle.to_tensor(gamma) + else: + self.gamma = gamma + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for qubit_idx in self.qubits_idx: + state = functional.generalized_amplitude_damping( + state, self.gamma, self.prob, qubit_idx, self.dtype, self.backend) + return state + + +class PhaseDamping(Channel): + r"""A collection of phase damping channels. + + Such a channel's Kraus operators are + + .. math:: + + 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: Parameter of the phase damping channels. Its value should be in the range :math:`[0, 1]`. + qubits_idx: Indices of the qubits on which the channels act. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + """ + def __init__( + self, gamma: Union[paddle.Tensor, float], + qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ): + super().__init__() + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + if isinstance(gamma, float): + self.gamma = paddle.to_tensor(gamma) + else: + self.gamma = gamma + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for qubit_idx in self.qubits_idx: + state = functional.phase_damping(state, self.gamma, qubit_idx, self.dtype, self.backend) + return state + + +class Depolarizing(Channel): + r"""A collection of depolarizing channels. + + Such a channel's Kraus operators are + + .. math:: + + E_0 = \sqrt{1-p} I, + E_1 = \sqrt{p/3} X, + E_2 = \sqrt{p/3} Y, + E_3 = \sqrt{p/3} Z. + + Args: + prob: Parameter of the depolarizing channels. Its value should be in the range :math:`[0, 1]`. + qubits_idx: Indices of the qubits on which the channels act. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + """ + def __init__( + self, prob: Union[paddle.Tensor, float], + qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ): + super().__init__() + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + if isinstance(prob, float): + self.prob = paddle.to_tensor(prob) + else: + self.prob = prob + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for qubit_idx in self.qubits_idx: + state = functional.depolarizing(state, self.prob, qubit_idx, self.dtype, self.backend) + return state + + +class PauliChannel(Channel): + r"""A collection of Pauli channels. + + Args: + prob: Probabilities corresponding to the Pauli X, Y, and Z operators. Each value should be in the + range :math:`[0, 1]`. + qubits_idx: Indices of the qubits on which the channels act. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + + Note: + The sum of three input probabilities should be less than or equal to 1. + """ + def __init__( + self, prob: Union[paddle.Tensor, Iterable[float]], + qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ): + super().__init__() + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + if isinstance(prob, Iterable): + self.prob = paddle.to_tensor(prob) + else: + self.prob = prob + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for qubit_idx in self.qubits_idx: + state = functional.pauli_channel(state, self.prob, qubit_idx, self.dtype, self.backend) + return state + + +class ResetChannel(Channel): + r"""A collection of reset channels. + + Such a channel reset the state to :math:`|0\rangle` with a probability of p and to :math:`|1\rangle` with + a probability of q. Its Kraus operators are + + .. 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_4 = \sqrt{1-p-q} I. + + Args: + prob: Probabilities of resetting to :math:`|0\rangle` and to :math:`|1\rangle`. Each value should be + in the range :math:`[0, 1]`. + qubits_idx: Indices of the qubits on which the channels act. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + + Note: + The sum of two input probabilities should be less than or equal to 1. + """ + def __init__( + self, prob: Union[paddle.Tensor, Iterable[float]], + qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ): + super().__init__() + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + if isinstance(prob, Iterable): + self.prob = paddle.to_tensor(prob) + else: + self.prob = prob + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for qubit_idx in self.qubits_idx: + state = functional.reset_channel(state, self.prob, qubit_idx, self.dtype, self.backend) + return state + + +class ThermalRelaxation(Channel): + r"""A collection of thermal relaxation channels. + + Such a channel simulates the mixture of the :math:`T_1` and the :math:`T_2` processes on superconducting devices. + + Args: + const_t: :math:`T_1` and :math:`T_2` relaxation time in microseconds. + exec_time: Quantum gate execution time in the process of relaxation in nanoseconds. + qubits_idx: Indices of the qubits on which the channels act. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + + Note: + Relaxation time must satisfy :math:`T_2 \le T_1`. For reference please see https://arxiv.org/abs/2101.02109. + """ + def __init__( + self, const_t: Union[paddle.Tensor, Iterable[float]], exec_time: Union[paddle.Tensor, float], + qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ): + super().__init__() + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + if isinstance(const_t, float): + self.const_t = paddle.to_tensor(const_t) + else: + self.const_t = const_t + if isinstance(exec_time, float): + self.exec_time = paddle.to_tensor(exec_time) + else: + self.exec_time = exec_time + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for qubit_idx in self.qubits_idx: + state = functional.thermal_relaxation( + state, self.const_t, self.exec_time, qubit_idx, self.dtype, self.backend) + return state diff --git a/paddle_quantum/channel/custom.py b/paddle_quantum/channel/custom.py new file mode 100644 index 0000000..f2ca0ec --- /dev/null +++ b/paddle_quantum/channel/custom.py @@ -0,0 +1,57 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the classes for custom quantum channels. +""" + +import math +import paddle +import paddle_quantum +from .base import Channel +from paddle_quantum.intrinsic import _format_qubits_idx +from . import functional +from typing import Union, Iterable + + +class KrausRepr(Channel): + r"""A custom channel in Kraus representation. + + Args: + kraus_oper: Kraus operators of this channel. + qubits_idx: Indices of the qubits on which this channel acts. + num_qubits: Total number of qubits. Defaults to ``None``. + """ + def __init__( + self, kraus_oper: Iterable[paddle.Tensor], + qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int], + num_qubits: int = None + ): + # TODO: need to check whether the input is legal + super().__init__() + num_acted_qubits = int(math.log2(kraus_oper[0].shape[0])) + assert 2 ** num_acted_qubits == kraus_oper[0].shape[0], "The length of oracle should be integer power of 2." + self.kraus_oper = kraus_oper + is_single_qubit = True if num_acted_qubits == 1 else False + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit, num_acted_qubits) + + def forward(self, state: 'paddle_quantum.State') -> 'paddle_quantum.State': + for qubits_idx in self.qubits_idx: + state = functional.kraus_repr(state, self.kraus_oper, qubits_idx, self.dtype, self.backend) + return state + + +class ChoiRepr(Channel): + pass diff --git a/paddle_quantum/channel/functional/__init__.py b/paddle_quantum/channel/functional/__init__.py new file mode 100644 index 0000000..8f757f0 --- /dev/null +++ b/paddle_quantum/channel/functional/__init__.py @@ -0,0 +1,31 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The module that contains the functions of various quantum channels. +""" + +from .common import bit_flip +from .common import phase_flip +from .common import bit_phase_flip +from .common import amplitude_damping +from .common import generalized_amplitude_damping +from .common import phase_damping +from .common import depolarizing +from .common import pauli_channel +from .common import reset_channel +from .common import thermal_relaxation +from .common import kraus_repr +from .common import choi_repr diff --git a/paddle_quantum/channel/functional/common.py b/paddle_quantum/channel/functional/common.py new file mode 100644 index 0000000..b986f00 --- /dev/null +++ b/paddle_quantum/channel/functional/common.py @@ -0,0 +1,529 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the various quantum channels. +""" + +import functools +import paddle +import paddle_quantum +from ...backend import density_matrix +from ...intrinsic import _zero, _one +from typing import Iterable + + +def bit_flip( + state: paddle_quantum.State, prob: paddle.Tensor, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a bit flip channel on the input state. + + Args: + state: Input state. + prob: Probability of a bit flip. + qubit_idx: Index of the qubit on which the channel acts. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Raises: + RuntimeError: The noisy channel can only run in density matrix mode. + + Returns: + Output state. + """ + if backend != paddle_quantum.Backend.DensityMatrix: + raise RuntimeError("The noisy channel can only run in density matrix mode.") + kraus_oper = [ + [ + paddle.sqrt(1 - prob).cast(dtype), _zero(dtype), + _zero(dtype), paddle.sqrt(1 - prob).cast(dtype), + ], + [ + _zero(dtype), paddle.sqrt(prob).cast(dtype), + paddle.sqrt(prob).cast(dtype), _zero(dtype), + ] + ] + for idx, oper in enumerate(kraus_oper): + kraus_oper[idx] = paddle.reshape(paddle.concat(oper), [2, 2]) + state_data = [ + density_matrix.unitary_transformation(state.data, oper, [qubit_idx], state.num_qubits) for oper in kraus_oper + ] + state_data = functools.reduce(lambda x, y: x + y, state_data) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def phase_flip( + state: paddle_quantum.State, prob: paddle.Tensor, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a phase flip channel on the input state. + + Args: + state: Input state. + prob: Probability of a phase flip. + qubit_idx: Index of the qubit on which the channel acts. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Raises: + RuntimeError: The noisy channel can only run in density matrix mode. + + Returns: + Output state. + """ + if backend != paddle_quantum.Backend.DensityMatrix: + raise RuntimeError("The noisy channel can only run in density matrix mode.") + kraus_oper = [ + [ + paddle.sqrt(1 - prob).cast(dtype), _zero(dtype), + _zero(dtype), paddle.sqrt(1 - prob).cast(dtype), + ], + [ + paddle.sqrt(prob).cast(dtype), _zero(dtype), + _zero(dtype), (-paddle.sqrt(prob)).cast(dtype), + ] + ] + for idx, oper in enumerate(kraus_oper): + kraus_oper[idx] = paddle.reshape(paddle.concat(oper), [2, 2]) + state_data = [ + density_matrix.unitary_transformation(state.data, oper, [qubit_idx], state.num_qubits) for oper in kraus_oper + ] + state_data = functools.reduce(lambda x, y: x + y, state_data) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def bit_phase_flip( + state: paddle_quantum.State, prob: paddle.Tensor, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a bit phase flip channel on the input state. + + Args: + state: Input state. + prob: Probability of a bit phase flip. + qubit_idx: Index of the qubit on which the channel acts. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Raises: + RuntimeError: The noisy channel can only run in density matrix mode. + + Returns: + Output state. + """ + if backend != paddle_quantum.Backend.DensityMatrix: + raise RuntimeError("The noisy channel can only run in density matrix mode.") + kraus_oper = [ + [ + paddle.sqrt(1 - prob).cast(dtype), _zero(dtype), + _zero(dtype), paddle.sqrt(1 - prob).cast(dtype), + ], + [ + _zero(dtype), -1j * paddle.sqrt(prob), + 1j * -paddle.sqrt(prob), _zero(dtype), + ] + ] + for idx, oper in enumerate(kraus_oper): + kraus_oper[idx] = paddle.reshape(paddle.concat(oper), [2, 2]) + state_data = [ + density_matrix.unitary_transformation(state.data, oper, [qubit_idx], state.num_qubits) for oper in kraus_oper + ] + state_data = functools.reduce(lambda x, y: x + y, state_data) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def amplitude_damping( + state: paddle_quantum.State, gamma: paddle.Tensor, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply an amplitude damping channel on the input state. + + Args: + state: Input state. + gamma: Damping probability. + qubit_idx: Index of the qubit on which the channel acts. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Raises: + RuntimeError: The noisy channel can only run in density matrix mode. + + Returns: + Output state. + """ + if backend != paddle_quantum.Backend.DensityMatrix: + raise RuntimeError("The noisy channel can only run in density matrix mode.") + kraus_oper = [ + [ + _one(dtype), _zero(dtype), + _zero(dtype), paddle.sqrt(1 - gamma).cast(dtype), + ], + [ + _zero(dtype), paddle.sqrt(gamma).cast(dtype), + _zero(dtype), _zero(dtype)], + + ] + for idx, oper in enumerate(kraus_oper): + kraus_oper[idx] = paddle.reshape(paddle.concat(oper), [2, 2]) + state_data = [ + density_matrix.unitary_transformation(state.data, oper, [qubit_idx], state.num_qubits) for oper in kraus_oper + ] + state_data = functools.reduce(lambda x, y: x + y, state_data) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def generalized_amplitude_damping( + state: paddle_quantum.State, gamma: paddle.Tensor, prob: paddle.Tensor, + qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a generalized amplitude damping channel on the input state. + + Args: + state: Input state. + gamma: Damping probability. + prob: Excitation probability. + qubit_idx: Index of the qubit on which the channel acts. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Raises: + RuntimeError: The noisy channel can only run in density matrix mode. + + Returns: + Output state. + """ + if backend != paddle_quantum.Backend.DensityMatrix: + raise RuntimeError("The noisy channel can only run in density matrix mode.") + kraus_oper = [ + [ + paddle.sqrt(prob).cast(dtype), _zero(dtype), + _zero(dtype), (paddle.sqrt(prob).cast(dtype) * paddle.sqrt(1 - gamma)).cast(dtype), + ], + [ + _zero(dtype), (paddle.sqrt(prob) * paddle.sqrt(gamma)).cast(dtype), + _zero(dtype), _zero(dtype), + ], + [ + (paddle.sqrt(1 - prob) * paddle.sqrt(1 - gamma)).cast(dtype), _zero(dtype), + _zero(dtype), paddle.sqrt(1 - prob).cast(dtype), + ], + [ + _zero(dtype), _zero(dtype), + (paddle.sqrt(1 - prob) * paddle.sqrt(gamma)).cast(dtype), _zero(dtype), + ], + ] + for idx, oper in enumerate(kraus_oper): + kraus_oper[idx] = paddle.reshape(paddle.concat(oper), [2, 2]) + state_data = [ + density_matrix.unitary_transformation(state.data, oper, [qubit_idx], state.num_qubits) for oper in kraus_oper + ] + state_data = functools.reduce(lambda x, y: x + y, state_data) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def phase_damping( + state: paddle_quantum.State, gamma: paddle.Tensor, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a phase damping channel on the input state. + + Args: + state: Input state. + gamma: Parameter of the phase damping channel. + qubit_idx: Index of the qubit on which the channel acts. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Raises: + RuntimeError: The noisy channel can only run in density matrix mode. + + Returns: + Output state. + """ + if backend != paddle_quantum.Backend.DensityMatrix: + raise RuntimeError("The noisy channel can only run in density matrix mode.") + kraus_oper = [ + [ + _one(dtype), _zero(dtype), + _zero(dtype), paddle.sqrt(1 - gamma).cast(dtype), + ], + [ + _zero(dtype), _zero(dtype), + _zero(dtype), paddle.sqrt(gamma).cast(dtype), + ] + ] + for idx, oper in enumerate(kraus_oper): + kraus_oper[idx] = paddle.reshape(paddle.concat(oper), [2, 2]) + state_data = [ + density_matrix.unitary_transformation(state.data, oper, [qubit_idx], state.num_qubits) for oper in kraus_oper + ] + state_data = functools.reduce(lambda x, y: x + y, state_data) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def depolarizing( + state: paddle_quantum.State, prob: paddle.Tensor, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a depolarizing channel on the input state. + + Args: + state: Input state. + prob: Parameter of the depolarizing channel. + qubit_idx: Index of the qubit on which the channel acts. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Raises: + RuntimeError: The noisy channel can only run in density matrix mode. + + Returns: + Output state. + """ + if backend != paddle_quantum.Backend.DensityMatrix: + raise RuntimeError("The noisy channel can only run in density matrix mode.") + kraus_oper = [ + [ + paddle.sqrt(1 - prob).cast(dtype), _zero(dtype), + _zero(dtype), paddle.sqrt(1 - prob).cast(dtype), + ], + [ + _zero(dtype), paddle.sqrt(prob / 3).cast(dtype), + paddle.sqrt(prob / 3).cast(dtype), _zero(dtype), + ], + [ + _zero(dtype), -1j * paddle.sqrt(prob / 3).cast(dtype), + 1j * paddle.sqrt(prob / 3).cast(dtype), _zero(dtype), + ], + [ + paddle.sqrt(prob / 3).cast(dtype), _zero(dtype), + _zero(dtype), (-1 * paddle.sqrt(prob / 3)).cast(dtype), + ], + ] + for idx, oper in enumerate(kraus_oper): + kraus_oper[idx] = paddle.reshape(paddle.concat(oper), [2, 2]) + state_data = [ + density_matrix.unitary_transformation(state.data, oper, [qubit_idx], state.num_qubits) for oper in kraus_oper + ] + state_data = functools.reduce(lambda x, y: x + y, state_data) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def pauli_channel( + state: paddle_quantum.State, prob: paddle.Tensor, qubit_idx: int, + dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a Pauli channel on the input state. + + Args: + state: Input state. + prob: Probabilities corresponding to the Pauli X, Y, and Z operators. + qubit_idx: Index of the qubit on which the channel acts. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Raises: + RuntimeError: The noisy channel can only run in density matrix mode. + + Returns: + Output state. + """ + if backend != paddle_quantum.Backend.DensityMatrix: + raise RuntimeError("The noisy channel can only run in density matrix mode.") + prob_x, prob_y, prob_z = prob + prob_i = paddle.sqrt(1 - paddle.sum(prob)) + kraus_oper = [ + [ + paddle.sqrt(prob_i).cast(dtype), _zero(dtype), + _zero(dtype), paddle.sqrt(prob_i).cast(dtype), + ], + [ + _zero(dtype), paddle.sqrt(prob_x).cast(dtype), + paddle.sqrt(prob_x).cast(dtype), _zero(dtype), + ], + [ + _zero(dtype), -1j * paddle.sqrt(prob_y).cast(dtype), + 1j * paddle.sqrt(prob_y).cast(dtype), _zero(dtype), + ], + [ + paddle.sqrt(prob_z).cast(dtype), _zero(dtype), + _zero(dtype), (-paddle.sqrt(prob_z)).cast(dtype), + ], + ] + for idx, oper in enumerate(kraus_oper): + kraus_oper[idx] = paddle.reshape(paddle.concat(oper), [2, 2]) + state_data = [ + density_matrix.unitary_transformation(state.data, oper, [qubit_idx], state.num_qubits) for oper in kraus_oper + ] + state_data = functools.reduce(lambda x, y: x + y, state_data) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def reset_channel( + state: paddle_quantum.State, prob: paddle.Tensor, qubit_idx: int, + dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a reset channel on the input state. + + Args: + state: Input state. + prob: Probabilities of resetting to :math:`|0\rangle` and to :math:`|1\rangle`. + qubit_idx: Index of the qubit on which the channel acts. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Raises: + RuntimeError: The noisy channel can only run in density matrix mode. + + Returns: + Output state. + """ + if backend != paddle_quantum.Backend.DensityMatrix: + raise RuntimeError("The noisy channel can only run in density matrix mode.") + prob_0, prob_1 = prob + prob_i = 1 - paddle.sum(prob) + kraus_oper = [ + [ + paddle.sqrt(prob_0).cast(dtype), _zero(dtype), + _zero(dtype), _zero(dtype), + ], + [ + _zero(dtype), paddle.sqrt(prob_0).cast(dtype), + _zero(dtype), _zero(dtype), + ], + [ + _zero(dtype), _zero(dtype), + paddle.sqrt(prob_1).cast(dtype), _zero(dtype), + ], + [ + _zero(dtype), _zero(dtype), + _zero(dtype), paddle.sqrt(prob_1).cast(dtype), + ], + [ + paddle.sqrt(prob_i).cast(dtype), _zero(dtype), + _zero(dtype), paddle.sqrt(prob_i).cast(dtype), + ], + ] + for idx, oper in enumerate(kraus_oper): + kraus_oper[idx] = paddle.reshape(paddle.concat(oper), [2, 2]) + state_data = [ + density_matrix.unitary_transformation(state.data, oper, [qubit_idx], state.num_qubits) for oper in kraus_oper + ] + state_data = functools.reduce(lambda x, y: x + y, state_data) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def thermal_relaxation( + state: paddle_quantum.State, const_t: paddle.Tensor, exec_time: paddle.Tensor, + qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a thermal relaxation channel on the input state. + + Args: + state: Input state. + const_t: :math:`T_1` and :math:`T_2` relaxation time in microseconds. + exec_time: Quantum gate execution time in the process of relaxation in nanoseconds. + qubit_idx: Index of the qubit on which the channel acts. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Raises: + RuntimeError: The noisy channel can only run in density matrix mode. + + Returns: + Output state. + """ + if backend != paddle_quantum.Backend.DensityMatrix: + raise RuntimeError("The noisy channel can only run in density matrix mode.") + t1, t2 = const_t + exec_time = exec_time / 1000 + prob_reset = 1 - paddle.exp(-exec_time / t1) + prob_z = (1 - prob_reset) * (1 - paddle.exp(-exec_time / t2) * paddle.exp(exec_time / t1)) / 2 + prob_i = 1 - prob_reset - prob_z + kraus_oper = [ + [ + paddle.sqrt(prob_i).cast(dtype), _zero(dtype), + _zero(dtype), paddle.sqrt(prob_i).cast(dtype), + ], + [ + paddle.sqrt(prob_z).cast(dtype), _zero(dtype), + _zero(dtype), (-paddle.sqrt(prob_z)).cast(dtype), + ], + [ + paddle.sqrt(prob_reset).cast(dtype), _zero(dtype), + _zero(dtype), _zero(dtype), + ], + [ + _zero(dtype), paddle.sqrt(prob_reset).cast(dtype), + _zero(dtype), _zero(dtype), + ], + ] + for idx, oper in enumerate(kraus_oper): + kraus_oper[idx] = paddle.reshape(paddle.concat(oper), [2, 2]) + state_data = [ + density_matrix.unitary_transformation(state.data, oper, [qubit_idx], state.num_qubits) for oper in kraus_oper + ] + state_data = functools.reduce(lambda x, y: x + y, state_data) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def kraus_repr( + state: paddle_quantum.State, kraus_oper: Iterable[paddle.Tensor], qubit_idx: int, + dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a custom channel in the Kraus representation on the input state. + + Args: + state: Input state. + kraus_oper: Kraus operators of this channel. + qubit_idx: Index of the qubit on which the channel acts. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Raises: + RuntimeError: The noisy channel can only run in density matrix mode. + + Returns: + Output state. + """ + if backend != paddle_quantum.Backend.DensityMatrix: + raise RuntimeError("The noisy channel can only run in density matrix mode.") + kraus_oper = [paddle.cast(oper, dtype) for oper in kraus_oper] + state_data = [ + density_matrix.unitary_transformation(state.data, oper, [qubit_idx], state.num_qubits) for oper in kraus_oper + ] + state_data = functools.reduce(lambda x, y: x + y, state_data) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def choi_repr(): + raise NotImplementedError diff --git a/paddle_quantum/circuit.py b/paddle_quantum/circuit.py deleted file mode 100644 index d468cf3..0000000 --- a/paddle_quantum/circuit.py +++ /dev/null @@ -1,4001 +0,0 @@ -# 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. - -import warnings -import copy -import math -import re -import matplotlib.pyplot as plt -from functools import reduce -from collections import defaultdict -import numpy as np -import paddle -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, vec - -__all__ = [ - "UAnsatz", - "swap_test" -] - - -class UAnsatz: - r"""基于 PaddlePaddle 的动态图机制实现量子电路的 ``class`` 。 - - 用户可以通过实例化该 ``class`` 来搭建自己的量子电路。 - - Attributes: - n (int): 该电路的量子比特数 - """ - - def __init__(self, n): - r"""UAnsatz 的构造函数，用于实例化一个 UAnsatz 对象 - - Args: - n (int): 该电路的量子比特数 - """ - self.n = n - self.__has_channel = False - self.__state = None - 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] - n = self.n - # Record current section number for every qubit - qubit = [0] * n - # Number of sections - qubit_max = max(qubit) - # 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['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 - if qubit[curr_qubit] > qubit_max: - length.append(5) - qubit_max = qubit[curr_qubit] - # Gates with params to print - 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 - qubit[curr_qubit] = qubit[curr_qubit] + 1 - if qubit[curr_qubit] > qubit_max: - length.append(5) - qubit_max = qubit[curr_qubit] - # 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['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 - - 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----*--------------|-- - | | | | - --H----Ry(-1.88)---------X----*---------|----Ry(-0.98)---------X----*---------|-- - | | | | - --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 - 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['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['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['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['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] = ')' - # 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['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['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['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 expand(self, qubit_num): - """ - 为原来的量子电路进行比特数扩展 - - Args: - qubit_num (int): 扩展后的量子比特数 - """ - assert qubit_num >= self.n, '扩展后量子比特数要大于原量子比特数' - diff = qubit_num - self.n - dim = 2 ** diff - if self.__state is not None: - if self.__run_mode == 'density_matrix': - shape = (dim, dim) - _state = paddle.to_tensor(density_op(diff)) - elif self.__run_mode == 'state_vector': - shape = (dim,) - _state = paddle.to_tensor(vec(0, diff)) - - _state = paddle.reshape(_state, shape) - _state = kron(self.__state, _state) - self.__state = _state - self.n = qubit_num - - 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 - - import numpy as np - import paddle - from paddle_quantum.circuit import UAnsatz - from paddle_quantum.state import vec - n = 2 - theta = np.ones(3) - - input_state = paddle.to_tensor(vec(0, n)) - theta = paddle.to_tensor(theta) - cir = UAnsatz(n) - cir.h(0) - cir.ry(theta[0], 1) - cir.rz(theta[1], 1) - output_state = cir.run_state_vector(input_state).numpy() - print(f"The output state vector is {output_state}") - - :: - - The output state vector is [[0.62054458+0.j 0.18316521+0.28526291j 0.62054458+0.j 0.18316521+0.28526291j]] - """ - # Throw a warning when cir has channel - if self.__has_channel: - 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' - 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, self.__param) - - if store_state: - self.__state = state - # Add info about which function user called - 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: 量子电路输出的密度矩阵 - - 代码示例: - - .. code-block:: python - - import numpy as np - import paddle - from paddle_quantum.circuit import UAnsatz - from paddle_quantum.state import density_op - n = 1 - theta = np.ones(3) - - input_state = paddle.to_tensor(density_op(n)) - theta = paddle.to_tensor(theta) - cir = UAnsatz(n) - cir.rx(theta[0], 0) - cir.ry(theta[1], 0) - cir.rz(theta[2], 0) - density_matrix = cir.run_density_matrix(input_state).numpy() - print(f"The output density matrix is\n{density_matrix}") - - :: - - The output density matrix is - [[0.64596329+0.j 0.47686058+0.03603751j] - [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" - - if not self.__has_channel: - state = matmul(self.U, matmul(state, dagger(self.U))) - else: - dim = 2 ** self.n - shape = (dim, dim) - num_ele = dim ** 2 - identity = paddle.eye(dim, dtype='float64') - identity = paddle.cast(identity, 'complex128') - identity = reshape(identity, [num_ele]) - - u_start = 0 - i = 0 - for i, history_ele in enumerate(self.__history): - if history_ele['gate'] == 'channel': - # Combine preceding unitary operations - 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['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)], 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_mode = 'density_matrix' - - return state - - def reset_state(self, state, which_qubits): - r"""对当前电路中的量子态的部分量子比特进行重置。 - - Args: - state (paddle.Tensor): 输入的量子态，表示要把选定的量子比特重置为该量子态 - which_qubits (list): 需要被重置的量子比特编号 - - Returns: - paddle.Tensor: 重置后的量子态 - """ - 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 - return _state - - @property - def U(self): - r"""量子电路的酉矩阵形式。 - - Warning: - 该属性只限于无噪声的电路。 - - Returns: - Tensor: 当前电路的酉矩阵表示 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - n = 2 - cir = UAnsatz(2) - cir.h(0) - cir.cnot([0, 1]) - unitary_matrix = cir.U - print("The unitary matrix of the circuit for Bell state preparation is\n", unitary_matrix.numpy()) - - :: - - The unitary matrix of the circuit for Bell state preparation is - [[ 0.70710678+0.j 0. +0.j 0.70710678+0.j 0. +0.j] - [ 0. +0.j 0.70710678+0.j 0. +0.j 0.70710678+0.j] - [ 0. +0.j 0.70710678+0.j 0. +0.j -0.70710678+0.j] - [ 0.70710678+0.j 0. +0.j -0.70710678+0.j 0. +0.j]] - """ - # Throw a warning when cir has channel - if self.__has_channel: - warnings.warn('The unitary matrix of the noiseless circuit will be given.', RuntimeWarning) - dim = 2 ** self.n - shape = (dim, dim) - num_ele = dim ** 2 - state = paddle.eye(dim, dtype='float64') - state = paddle.cast(state, 'complex128') - state = reshape(state, [num_ele]) - state = transfer_by_history(state, self.__history, self.__param) - - return reshape(state, shape) - - 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` 。 - 这里假设量子态在编码前为全 0 的态，即 :math:`|00\ldots 0\rangle` 。 - - 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 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(which_qubits[idx]) - - def amplitude_encoding(self, x, mode, which_qubits=None): - r"""将输入的经典数据使用振幅编码的方式编码成量子态。 - - Args: - x (Tensor): 待编码的向量 - mode (str): 生成的量子态的表示方式，``"state_vector"`` 代表态矢量表示， ``"density_matrix"`` 代表密度矩阵表示 - which_qubits (list): 用于编码的量子比特 - - Returns: - Tensor: 一个形状为 ``(2 ** n, )`` 或 ``(2 ** n, 2 ** n)`` 的张量，表示编码之后的量子态。 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - n = 3 - built_in_amplitude_enc = UAnsatz(n) - # 经典信息 x 需要是 Tensor 的形式 - x = paddle.to_tensor([0.3, 0.4, 0.5, 0.6]) - state = built_in_amplitude_enc.amplitude_encoding(x, 'state_vector', [0,2]) - print(state.numpy()) - - :: - - [0.32349834+0.j 0.4313311 +0.j 0. +0.j 0. +0.j - 0.53916389+0.j 0.64699668+0.j 0. +0.j 0. +0.j] - - """ - 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) - 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": - result_tensor = paddle.cast(result_tensor, dtype="complex128") - elif mode == "density_matrix": - 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 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" - 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, which, gate): - if gate == "rx": - self.rx(theta, which) - elif gate == "ry": - self.ry(theta, which) - elif gate == "rz": - 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], which_qubits[idx], encoding_gate) - - def iqp_encoding(self, x, num_repeats=1, pattern=None, invert=False): - r"""将输入的经典数据使用 IQP 编码的方式进行编码。 - - Args: - x (Tensor): 待编码的向量 - num_repeats (int): 编码层的层数 - pattern (list): 量子比特的纠缠方式 - invert (bool): 添加的是否为编码电路的逆电路，默认为 ``False`` ，即添加正常的编码电路 - """ - 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: - pattern = list() - for idx0 in range(0, self.n): - for idx1 in range(idx0 + 1, self.n): - pattern.append((idx0, idx1)) - - while num_repeats > 0: - num_repeats -= 1 - if invert: - for item in pattern: - self.cnot(list(item)) - 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) - for idx in range(0, num_x): - self.h(idx) - else: - for idx in range(0, num_x): - self.h(idx) - for idx in range(0, num_x): - self.rz(x[idx], idx) - for item in pattern: - self.cnot(list(item)) - self.rz(x[item[0]] * x[item[1]], item[1]) - self.cnot(list(item)) - - """ - Common Gates - """ - - def rx(self, theta, which_qubit): - 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} - - 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 - theta = np.array([np.pi], np.float64) - theta = paddle.to_tensor(theta) - num_qubits = 1 - cir = UAnsatz(num_qubits) - which_qubit = 0 - cir.rx(theta[0], which_qubit) - - """ - 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} - - 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 - theta = np.array([np.pi], np.float64) - theta = paddle.to_tensor(theta) - num_qubits = 1 - cir = UAnsatz(num_qubits) - 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)" - 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} - - 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 - theta = np.array([np.pi], np.float64) - theta = paddle.to_tensor(theta) - num_qubits = 1 - cir = UAnsatz(num_qubits) - 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)" - 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 门。 - - 对于 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} - \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.cnot([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': 'CNOT', 'which_qubits': control, 'theta': None}) - - def cy(self, control): - r"""添加一个 cy 门。 - - 对于 2 量子比特的量子电路，当 ``control`` 为 ``[0, 1]`` 时，其矩阵形式为： - - .. math:: - - \begin{align} - CY &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Y\\ - &= - \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} - CZ &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Z\\ - &= - \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 门。 - - 其矩阵形式为： - - .. math:: - - \begin{align} - 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): 作用在的量子比特的编号，``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.swap([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 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[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} - - Args: - which_qubit (int): 作用在的qubit的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - num_qubits = 1 - cir = UAnsatz(num_qubits) - which_qubit = 0 - cir.x(which_qubit) - cir.run_state_vector() - print(cir.measure(shots = 0)) - - :: - - {'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({'gate': 'x', 'which_qubits': [which_qubit], 'theta': None}) - - def y(self, which_qubit): - r"""添加单量子比特 Y 门。 - - 其矩阵形式为： - - .. math:: - - \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 - cir = UAnsatz(num_qubits) - which_qubit = 0 - cir.y(which_qubit) - cir.run_state_vector() - print(cir.measure(shots = 0)) - - :: - - {'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({'gate': 'y', 'which_qubits': [which_qubit], 'theta': None}) - - def z(self, which_qubit): - r"""添加单量子比特 Z 门。 - - 其矩阵形式为： - - .. math:: - - \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 - cir = UAnsatz(num_qubits) - which_qubit = 0 - cir.z(which_qubit) - cir.run_state_vector() - print(cir.measure(shots = 0)) - - :: - - {'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({'gate': 'z', 'which_qubits': [which_qubit], 'theta': None}) - - def h(self, which_qubit): - r"""添加一个单量子比特的 Hadamard 门。 - - 其矩阵形式为： - - .. math:: - - 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({'gate': 'h', 'which_qubits': [which_qubit], 'theta': None}) - - def s(self, which_qubit): - r"""添加一个单量子比特的 S 门。 - - 其矩阵形式为： - - .. math:: - - 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({'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 门。 - - 其矩阵形式为： - - .. math:: - - 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({'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"""添加一个单量子比特的旋转门。 - - 其矩阵形式为： - - .. 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} - \end{align} - - Args: - theta (Tensor): 旋转角度 :math:`\theta` 。 - phi (Tensor): 旋转角度 :math:`\phi` 。 - lam (Tensor): 旋转角度 :math:`\lambda` 。 - 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)" - 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 门。 - - 其矩阵形式为： - - .. 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} - \end{align} - - Args: - theta (Tensor): 旋转角度 - which_qubits (list): 作用在的两个量子比特的编号，其值都应该在 :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.rxx(paddle.to_tensor(np.array([np.pi/2])), [0, 1]) - """ - 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" - 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 门。 - - 其矩阵形式为： - - .. 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} - \end{align} - - Args: - theta (Tensor): 旋转角度 - which_qubits (list): 作用在的两个量子比特的编号，其值都应该在 :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.ryy(paddle.to_tensor(np.array([np.pi/2])), [0, 1]) - """ - 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" - 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 门。 - - 其矩阵形式为： - - .. 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} - \end{align} - - Args: - theta (Tensor): 旋转角度 - which_qubits (list): 作用在的两个量子比特的编号，其值都应该在 :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.rzz(paddle.to_tensor(np.array([np.pi/2])), [0, 1]) - """ - 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" - 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) 门，用于离子阱设备。 - - 其矩阵形式为： - - .. 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} - \end{align} - - Args: - which_qubits (list): 作用在的两个量子比特的编号，其值都应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 - - Note: - 参考文献 https://arxiv.org/abs/quant-ph/9810040 - - .. code-block:: python - - import numpy as np - import paddle - from paddle_quantum.circuit import UAnsatz - num_qubits = 2 - cir = UAnsatz(num_qubits) - cir.ms([0, 1]) - """ - 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({'gate': 'MS_gate', 'which_qubits': which_qubits, 'theta': [2]}) - - def universal_2_qubit_gate(self, theta, which_qubits): - r"""添加 2-qubit 通用门，这个通用门需要 15 个参数。 - - Args: - theta (Tensor): 2-qubit 通用门的参数，其维度为 ``(15, )`` - which_qubits(list): 作用的量子比特编号 - - 代码示例: - - .. code-block:: python - - import numpy as np - import paddle - from paddle_quantum.circuit import UAnsatz - n = 2 - theta = paddle.to_tensor(np.ones(15)) - cir = UAnsatz(n) - cir.universal_2_qubit_gate(theta, [0, 1]) - cir.run_state_vector() - print(cir.measure(shots = 0)) - - :: - - {'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]) - self.rz(theta[6], a) - self.ry(theta[7], b) - self.cnot([a, b]) - self.ry(theta[8], b) - self.cnot([b, a]) - self.u3(theta[9], theta[10], theta[11], a) - self.u3(theta[12], theta[13], theta[14], b) - - def __u3qg_U(self, theta, which_qubits): - r""" - 用于构建 universal_3_qubit_gate - """ - self.cnot(which_qubits[1:]) - self.ry(theta[0], which_qubits[1]) - self.cnot(which_qubits[:2]) - self.ry(theta[1], which_qubits[1]) - self.cnot(which_qubits[:2]) - self.cnot(which_qubits[1:]) - self.h(which_qubits[2]) - self.cnot([which_qubits[1], which_qubits[0]]) - self.cnot([which_qubits[0], which_qubits[2]]) - self.cnot(which_qubits[1:]) - self.rz(theta[2], which_qubits[2]) - self.cnot(which_qubits[1:]) - self.cnot([which_qubits[0], which_qubits[2]]) - - def __u3qg_V(self, theta, which_qubits): - r""" - 用于构建 universal_3_qubit_gate - """ - self.cnot([which_qubits[2], which_qubits[0]]) - self.cnot(which_qubits[:2]) - self.cnot([which_qubits[2], which_qubits[1]]) - self.ry(theta[0], which_qubits[2]) - self.cnot(which_qubits[1:]) - self.ry(theta[1], which_qubits[2]) - self.cnot(which_qubits[1:]) - self.s(which_qubits[2]) - self.cnot([which_qubits[2], which_qubits[0]]) - self.cnot(which_qubits[:2]) - self.cnot([which_qubits[1], which_qubits[0]]) - self.h(which_qubits[2]) - self.cnot([which_qubits[0], which_qubits[2]]) - 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 个参数。 - - 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: 用电路表示的该门的一个参数的偏导 - - 代码示例: - - .. 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: - ind_history (int): 该门在本电路中的序号 - ind_gate (int): cu 门参数的 index，可以是 0 或 1 或 2 - - 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.cu(theta[0], theta[1], theta[2], [0, 1]) - print(cir.cu3_partial(0, 0)[0]) - print(cir.cu3_partial(0, 0)[1]) - - :: - - -----------------x-- - | - ------------z----U-- - | - --H---SDG---*----H-- - - ------------z---------x-- - | | - ------------|----z----U-- - | | - --H----S----*----*----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}, "CU gate has only three parameters, please choose from {0, 1, 2}" - assert history[ind_history]['gate'] == 'CU', "Not a CU gate." - - 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 的方法计算电路中所有需要训练的参数的梯度。损失函数默认为计算哈密顿量的期望值。 - - Args: - H (list or Hamiltonian): 损失函数中用到的记录哈密顿量信息的列表或 ``Hamiltonian`` 类的对象 - shots (int, optional): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 - - Return: - Tensor: 该电路中所有需要训练的参数的梯度 - - 代码示例: - - .. code-block:: python - - import numpy as np - import paddle - from paddle_quantum.circuit import UAnsatz - - 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"""该函数基于 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' - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - new_s = ''.join(s[j] for j in which_qubits) - return new_s - - def __process_similiar(self, result): - 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} - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - data = defaultdict(int) - for idx, val in result: - data[idx] += val - - return dict(data) - - def __measure_hist(self, result, which_qubits, shots): - r"""将测量的结果以柱状图的形式呈现。 - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - - Args: - result (dictionary): 测量结果 - which_qubits (list): 测量的量子比特，如测量所有则是 ``None`` - shots(int): 测量次数 - - Returns - dict: 测量结果 - - """ - n = self.n if which_qubits is None else len(which_qubits) - assert n < 6, "Too many qubits to plot" - - ylabel = "Measured Probabilities" - if shots == 0: - shots = 1 - ylabel = "Probabilities" - - state_list = [np.binary_repr(index, width=n) for index in range(0, 2 ** n)] - freq = [] - for state in state_list: - freq.append(result.get(state, 0.0) / shots) - - plt.bar(range(2 ** n), freq, tick_label=state_list) - plt.xticks(rotation=90) - plt.xlabel("Qubit State") - plt.ylabel(ylabel) - plt.show() - - return result - - # Which_qubits is list-like - def measure(self, which_qubits=None, shots=2 ** 10, plot=False): - r"""对量子电路输出的量子态进行测量。 - - Warning: - 当 ``plot`` 为 ``True`` 时，当前量子电路的量子比特数需要小于 6 ，否则无法绘制图片，会抛出异常。 - - Args: - 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) - cir.h(0) - cir.cnot([0,1]) - cir.run_state_vector() - result = cir.measure(shots = 2048, which_qubits = [1]) - print(f"The results of measuring qubit 1 2048 times are {result}") - - :: - - The results of measuring qubit 1 2048 times are {'0': 964, '1': 1084} - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - cir = UAnsatz(2) - cir.h(0) - cir.cnot([0,1]) - cir.run_state_vector() - result = cir.measure(shots = 0, which_qubits = [1]) - print(f"The probability distribution of measurement results on qubit 1 is {result}") - - :: - - The probability distribution of measurement results on qubit 1 is {'0': 0.4999999999999999, '1': 0.4999999999999999} - """ - if self.__run_mode == 'state_vector': - state = self.__state - 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)) - else: - # Raise error - raise ValueError("no state for measurement; please run the circuit first") - - if shots == 0: # Returns probability distribution over all measurement results - dic2to10, dic10to2 = dic_between2and10(self.n) - result = {} - for i in range(2 ** self.n): - result[dic10to2[i]] = (real(state)[i] ** 2 + imag(state)[i] ** 2).numpy()[0] - - if which_qubits is not None: - new_result = [(self.__process_string(key, which_qubits), value) for key, value in result.items()] - result = self.__process_similiar(new_result) - else: - if which_qubits is None: # Return all the qubits - result = measure_state(state, shots) - else: - assert all([e < self.n for e in which_qubits]), 'Qubit index out of range' - which_qubits.sort() # Sort in ascending order - - collapse_all = measure_state(state, shots) - new_collapse_all = [(self.__process_string(key, which_qubits), value) for key, value in - collapse_all.items()] - result = self.__process_similiar(new_collapse_all) - - return result if not plot else self.__measure_hist(result, which_qubits, shots) - - 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`` 的 ``list`` 形式为 ``[[0.7, 'Z0, X1'], [0.2, 'Z1']]`` 。 - - Args: - H (Hamiltonian or list): 可观测量的相关信息 - shots (int, optional): 测量次数；默认为 0，表示返回期望值的精确值，即测量无穷次后的期望值 - - Returns: - 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() - - 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}') - - :: - - The expectation value obtained by 1024 measurements is [-0.16328125] - The accurate expectation value of H is [-0.1682942] - """ - 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: - 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 - """ - - def superposition_layer(self): - r"""添加一层 Hadamard 门。 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - cir = UAnsatz(2) - cir.superposition_layer() - cir.run_state_vector() - result = cir.measure(shots = 0) - print(f"The probability distribution of measurement results on both qubits is {result}") - - :: - - 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) - - def weak_superposition_layer(self): - r"""添加一层旋转角度为 :math:`\pi/4` 的 Ry 门。 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - cir = UAnsatz(2) - cir.weak_superposition_layer() - cir.run_state_vector() - result = cir.measure(shots = 0) - print(f"The probability distribution of measurement results on both qubits is {result}") - - :: - - 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): - self.ry(_theta, i) - - def linear_entangled_layer(self, theta, depth, which_qubits=None): - r"""添加 ``depth`` 层包含 Ry 门，Rz 门和 CNOT 门的线性纠缠层。 - - Attention: - ``theta`` 的维度为 ``(depth, n, 2)`` ，最低维内容为对应的 ``ry`` 和 ``rz`` 的参数， ``n`` 为作用的量子比特数量。 - - Args: - theta (Tensor): Ry 门和 Rz 门的旋转角度 - depth (int): 纠缠层的深度 - which_qubits (list): 作用的量子比特编号 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - n = 2 - DEPTH = 3 - theta = paddle.ones([DEPTH, 2, 2], dtype='float64') - cir = UAnsatz(n) - cir.linear_entangled_layer(theta, DEPTH, [0, 1]) - cir.run_state_vector() - result = cir.measure(shots = 0) - print(f"The probability distribution of measurement results on both qubits is {result}") - - :: - - 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' - # assert theta.shape[1] == self.n, 'the shape of theta is not right' - assert theta.shape[0] == depth, 'the depth of theta has a mismatch' - - if which_qubits is None: - which_qubits = np.arange(self.n) - - for repeat in range(depth): - for i, q in enumerate(which_qubits): - self.ry(theta[repeat][i][0], q) - for i in range(len(which_qubits) - 1): - self.cnot([which_qubits[i], which_qubits[i + 1]]) - for i, q in enumerate(which_qubits): - self.rz(theta[repeat][i][1], q) - for i in range(len(which_qubits) - 1): - self.cnot([which_qubits[i + 1], which_qubits[i]]) - - def real_entangled_layer(self, theta, depth, which_qubits=None): - r"""添加 ``depth`` 层包含 Ry 门和 CNOT 门的强纠缠层。 - - Note: - 这一层量子门的数学表示形式为实数酉矩阵。 - - Attention: - ``theta`` 的维度为 ``(depth, n, 1)``， ``n`` 为作用的量子比特数量。 - - Args: - theta (Tensor): Ry 门的旋转角度 - depth (int): 纠缠层的深度 - which_qubits (list): 作用的量子比特编号 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - n = 2 - DEPTH = 3 - 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() - result = cir.measure(shots = 0) - print(f"The probability distribution of measurement results on both qubits is {result}") - - :: - - 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' - # assert theta.shape[1] == self.n, 'the shape of theta is not right' - assert theta.shape[0] == depth, 'the depth of theta has a mismatch' - - if which_qubits is None: - which_qubits = np.arange(self.n) - - for repeat in range(depth): - for i, q in enumerate(which_qubits): - self.ry(theta[repeat][i][0], q) - for i in range(len(which_qubits) - 1): - self.cnot([which_qubits[i], which_qubits[i + 1]]) - self.cnot([which_qubits[-1], which_qubits[0]]) - - def complex_entangled_layer(self, theta, depth, which_qubits=None): - r"""添加 ``depth`` 层包含 U3 门和 CNOT 门的强纠缠层。 - - Note: - 这一层量子门的数学表示形式为复数酉矩阵。 - - Attention: - ``theta`` 的维度为 ``(depth, n, 3)`` ，最低维内容为对应的 ``u3`` 的参数 ``(theta, phi, lam)``， ``n`` 为作用的量子比特数量。 - - Args: - theta (Tensor): U3 门的旋转角度 - depth (int): 纠缠层的深度 - which_qubits (list): 作用的量子比特编号 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - n = 2 - DEPTH = 3 - 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() - result = cir.measure(shots = 0) - print(f"The probability distribution of measurement results on both qubits is {result}") - - :: - - 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' - # assert theta.shape[1] == self.n, 'the shape of theta is not right' - assert theta.shape[0] == depth, 'the depth of theta has a mismatch' - - if which_qubits is None: - which_qubits = np.arange(self.n) - - for repeat in range(depth): - for i, q in enumerate(which_qubits): - self.u3(theta[repeat][i][0], theta[repeat][i][1], theta[repeat][i][2], q) - for i in range(len(which_qubits) - 1): - self.cnot([which_qubits[i], which_qubits[i + 1]]) - self.cnot([which_qubits[-1], which_qubits[0]]) - - def __add_real_block(self, theta, position): - r""" - Add a real block to the circuit in (position). theta is a one dimensional tensor - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - assert len(theta) == 4, 'the length of theta is not right' - assert 0 <= position[0] < self.n and 0 <= position[1] < self.n, 'position is out of range' - self.ry(theta[0], position[0]) - self.ry(theta[1], position[1]) - - self.cnot([position[0], position[1]]) - - self.ry(theta[2], position[0]) - self.ry(theta[3], position[1]) - - def __add_complex_block(self, theta, position): - r""" - Add a complex block to the circuit in (position). theta is a one dimensional tensor - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - assert len(theta) == 12, 'the length of theta is not right' - assert 0 <= position[0] < self.n and 0 <= position[1] < self.n, 'position is out of range' - self.u3(theta[0], theta[1], theta[2], position[0]) - self.u3(theta[3], theta[4], theta[5], position[1]) - - self.cnot([position[0], position[1]]) - - self.u3(theta[6], theta[7], theta[8], position[0]) - self.u3(theta[9], theta[10], theta[11], position[1]) - - 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. - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - 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. - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - 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]) - - def real_block_layer(self, theta, depth): - r"""添加 ``depth`` 层包含 Ry 门和 CNOT 门的弱纠缠层。 - - Note: - 这一层量子门的数学表示形式为实数酉矩阵。 - - Attention: - ``theta`` 的维度为 ``(depth, n-1, 4)`` 。 - - Args: - theta (Tensor): Ry 门的旋转角度 - depth (int): 纠缠层的深度 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - n = 4 - DEPTH = 3 - theta = paddle.ones([DEPTH, n - 1, 4], dtype='float64') - cir = UAnsatz(n) - 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} - """ - assert self.n > 1, 'you need at least 2 qubits' - assert len(theta.shape) == 3, 'The dimension of theta is not right' - _depth, m, block = theta.shape - assert depth > 0, 'depth must be greater than zero' - assert _depth == depth, 'the depth of parameters has a mismatch' - assert m == self.n - 1 and block == 4, 'The shape of theta is not right' - - if self.n % 2 == 0: - for i in range(depth): - self.__add_real_layer(theta[i][:int(self.n / 2)], [0, self.n - 1]) - self.__add_real_layer(theta[i][int(self.n / 2):], [1, self.n - 2]) if self.n > 2 else None - else: - for i in range(depth): - self.__add_real_layer(theta[i][:int((self.n - 1) / 2)], [0, self.n - 2]) - self.__add_real_layer(theta[i][int((self.n - 1) / 2):], [1, self.n - 1]) - - def complex_block_layer(self, theta, depth): - r"""添加 ``depth`` 层包含 U3 门和 CNOT 门的弱纠缠层。 - - Note: - 这一层量子门的数学表示形式为复数酉矩阵。 - - Attention: - ``theta`` 的维度为 ``(depth, n-1, 12)`` 。 - - Args: - theta (Tensor): U3 门的角度信息 - depth (int): 纠缠层的深度 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - n = 4 - DEPTH = 3 - theta = paddle.ones([DEPTH, n - 1, 12], dtype='float64') - cir = UAnsatz(n) - 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} - """ - assert self.n > 1, 'you need at least 2 qubits' - assert len(theta.shape) == 3, 'The dimension of theta is not right' - assert depth > 0, 'depth must be greater than zero' - _depth, m, block = theta.shape - assert _depth == depth, 'the depth of parameters has a mismatch' - assert m == self.n - 1 and block == 12, 'The shape of theta is not right' - - if self.n % 2 == 0: - for i in range(depth): - self.__add_complex_layer(theta[i][:int(self.n / 2)], [0, self.n - 1]) - self.__add_complex_layer(theta[i][int(self.n / 2):], [1, self.n - 2]) if self.n > 2 else None - else: - for i in range(depth): - 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: - if not isinstance(new_param[j], paddle.Tensor): - self.__param[i] = paddle.to_tensor(new_param[j], 'float64') - self.__param[i].stop_gradient = False - else: - self.__param[i] = new_param[j] - j += 1 - self.run_state_vector() - return self.__param - - """ - Channels - """ - - @apply_channel - def amplitude_damping(self, gamma, which_qubit): - 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}. - - Args: - gamma (float): 减振概率，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.circuit import UAnsatz - N = 2 - gamma = 0.1 - cir = UAnsatz(N) - cir.h(0) - cir.cnot([0, 1]) - cir.amplitude_damping(gamma, 0) - final_state = cir.run_density_matrix() - print(final_state.numpy()) - - :: - - [[0.5 +0.j 0. +0.j 0. +0.j 0.47434165+0.j] - [0. +0.j 0.05 +0.j 0. +0.j 0. +0.j] - [0. +0.j 0. +0.j 0. +0.j 0. +0.j] - [0.47434165+0.j 0. +0.j 0. +0.j 0.45 +0.j]] - """ - assert 0 <= gamma <= 1, 'the parameter gamma should be in range [0, 1]' - - e0 = paddle.to_tensor([[1, 0], [0, np.sqrt(1 - gamma)]], dtype='complex128') - e1 = paddle.to_tensor([[0, np.sqrt(gamma)], [0, 0]], dtype='complex128') - - return [e0, e1] - - @apply_channel - def generalized_amplitude_damping(self, gamma, p, which_qubit): - r"""添加广义振幅阻尼信道。 - - 其 Kraus 算符为： - - .. math:: - - 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}. - - Args: - gamma (float): 减振概率，其值应该在 :math:`[0, 1]` 区间内 - p (float): 激发概率，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.circuit import UAnsatz - N = 2 - gamma = 0.1 - p = 0.2 - cir = UAnsatz(N) - cir.h(0) - cir.cnot([0, 1]) - cir.generalized_amplitude_damping(gamma, p, 0) - final_state = cir.run_density_matrix() - print(final_state.numpy()) - - :: - - [[0.46 +0.j 0. +0.j 0. +0.j 0.47434165+0.j] - [0. +0.j 0.01 +0.j 0. +0.j 0. +0.j] - [0. +0.j 0. +0.j 0.04 +0.j 0. +0.j] - [0.47434165+0.j 0. +0.j 0. +0.j 0.49 +0.j]] - """ - assert 0 <= gamma <= 1, 'the parameter gamma should be in range [0, 1]' - assert 0 <= p <= 1, 'The parameter p should be in range [0, 1]' - - e0 = paddle.to_tensor(np.sqrt(p) * np.array([[1, 0], [0, np.sqrt(1 - gamma)]], dtype='complex128')) - e1 = paddle.to_tensor(np.sqrt(p) * np.array([[0, np.sqrt(gamma)], [0, 0]]), dtype='complex128') - e2 = paddle.to_tensor(np.sqrt(1 - p) * np.array([[np.sqrt(1 - gamma), 0], [0, 1]], dtype='complex128')) - e3 = paddle.to_tensor(np.sqrt(1 - p) * np.array([[0, 0], [np.sqrt(gamma), 0]]), dtype='complex128') - - return [e0, e1, e2, e3] - - @apply_channel - def phase_damping(self, gamma, which_qubit): - r"""添加相位阻尼信道。 - - 其 Kraus 算符为： - - .. math:: - - 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]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.circuit import UAnsatz - N = 2 - p = 0.1 - cir = UAnsatz(N) - cir.h(0) - cir.cnot([0, 1]) - cir.phase_damping(p, 0) - final_state = cir.run_density_matrix() - print(final_state.numpy()) - - :: - - [[0.5 +0.j 0. +0.j 0. +0.j 0.47434165+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.47434165+0.j 0. +0.j 0. +0.j 0.5 +0.j]] - """ - assert 0 <= gamma <= 1, 'the parameter gamma should be in range [0, 1]' - - e0 = paddle.to_tensor([[1, 0], [0, np.sqrt(1 - gamma)]], dtype='complex128') - e1 = paddle.to_tensor([[0, 0], [0, np.sqrt(gamma)]], dtype='complex128') - - return [e0, e1] - - @apply_channel - def bit_flip(self, p, which_qubit): - r"""添加比特反转信道。 - - 其 Kraus 算符为： - - .. math:: - - E_0 = \sqrt{1-p} I, - E_1 = \sqrt{p} X. - - Args: - p (float): 发生 bit flip 的概率，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.circuit import UAnsatz - N = 2 - p = 0.1 - cir = UAnsatz(N) - cir.h(0) - cir.cnot([0, 1]) - cir.bit_flip(p, 0) - final_state = cir.run_density_matrix() - print(final_state.numpy()) - - :: - - [[0.45+0.j 0. +0.j 0. +0.j 0.45+0.j] - [0. +0.j 0.05+0.j 0.05+0.j 0. +0.j] - [0. +0.j 0.05+0.j 0.05+0.j 0. +0.j] - [0.45+0.j 0. +0.j 0. +0.j 0.45+0.j]] - """ - 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') - e1 = paddle.to_tensor([[0, np.sqrt(p)], [np.sqrt(p), 0]], dtype='complex128') - - return [e0, e1] - - @apply_channel - def phase_flip(self, p, which_qubit): - r"""添加相位反转信道。 - - 其 Kraus 算符为： - - .. math:: - - E_0 = \sqrt{1 - p} I, - E_1 = \sqrt{p} Z. - - Args: - p (float): 发生 phase flip 的概率，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.circuit import UAnsatz - N = 2 - p = 0.1 - cir = UAnsatz(N) - cir.h(0) - cir.cnot([0, 1]) - cir.phase_flip(p, 0) - final_state = cir.run_density_matrix() - print(final_state.numpy()) - - :: - - [[0.5+0.j 0. +0.j 0. +0.j 0.4+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.4+0.j 0. +0.j 0. +0.j 0.5+0.j]] - """ - 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') - e1 = paddle.to_tensor([[np.sqrt(p), 0], [0, -np.sqrt(p)]], dtype='complex128') - - return [e0, e1] - - @apply_channel - def bit_phase_flip(self, p, which_qubit): - r"""添加比特相位反转信道。 - - 其 Kraus 算符为： - - .. math:: - - E_0 = \sqrt{1 - p} I, - E_1 = \sqrt{p} Y. - - Args: - p (float): 发生 bit phase flip 的概率，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.circuit import UAnsatz - N = 2 - p = 0.1 - cir = UAnsatz(N) - cir.h(0) - cir.cnot([0, 1]) - cir.bit_phase_flip(p, 0) - final_state = cir.run_density_matrix() - print(final_state.numpy()) - - :: - - [[ 0.45+0.j 0. +0.j 0. +0.j 0.45+0.j] - [ 0. +0.j 0.05+0.j -0.05+0.j 0. +0.j] - [ 0. +0.j -0.05+0.j 0.05+0.j 0. +0.j] - [ 0.45+0.j 0. +0.j 0. +0.j 0.45+0.j]] - """ - 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') - e1 = paddle.to_tensor([[0, -1j * np.sqrt(p)], [1j * np.sqrt(p), 0]], dtype='complex128') - - return [e0, e1] - - @apply_channel - def depolarizing(self, p, which_qubit): - r"""添加去极化信道。 - - 其 Kraus 算符为： - - .. math:: - - E_0 = \sqrt{1-p} I, - E_1 = \sqrt{p/3} X, - E_2 = \sqrt{p/3} Y, - E_3 = \sqrt{p/3} Z. - - Args: - p (float): depolarizing 信道的参数，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.circuit import UAnsatz - N = 2 - p = 0.1 - cir = UAnsatz(N) - cir.h(0) - cir.cnot([0, 1]) - cir.depolarizing(p, 0) - final_state = cir.run_density_matrix() - print(final_state.numpy()) - - :: - - [[0.46666667+0.j 0. +0.j 0. +0.j 0.43333333+0.j] - [0. +0.j 0.03333333+0.j 0. +0.j 0. +0.j] - [0. +0.j 0. +0.j 0.03333333+0.j 0. +0.j] - [0.43333333+0.j 0. +0.j 0. +0.j 0.46666667+0.j]] - """ - 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') - - return [e0, e1, e2, e3] - - @apply_channel - def pauli_channel(self, p_x, p_y, p_z, which_qubit): - r"""添加泡利信道。 - - Args: - p_x (float): 泡利矩阵 X 的对应概率，其值应该在 :math:`[0, 1]` 区间内 - p_y (float): 泡利矩阵 Y 的对应概率，其值应该在 :math:`[0, 1]` 区间内 - p_z (float): 泡利矩阵 Z 的对应概率，其值应该在 :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_x = 0.1 - p_y = 0.2 - p_z = 0.3 - cir = UAnsatz(N) - cir.h(0) - cir.cnot([0, 1]) - cir.pauli_channel(p_x, p_y, p_z, 0) - final_state = cir.run_density_matrix() - print(final_state.numpy()) - - :: - - [[ 0.35+0.j 0. +0.j 0. +0.j 0.05+0.j] - [ 0. +0.j 0.15+0.j -0.05+0.j 0. +0.j] - [ 0. +0.j -0.05+0.j 0.15+0.j 0. +0.j] - [ 0.05+0.j 0. +0.j 0. +0.j 0.35+0.j]] - """ - prob_list = [p_x, p_y, p_z] - assert sum(prob_list) <= 1, 'the sum of probabilities should be smaller than or equal to 1 ' - X = np.array([[0, 1], [1, 0]], dtype='complex128') - Y = np.array([[0, -1j], [1j, 0]], dtype='complex128') - Z = np.array([[1, 0], [0, -1]], dtype='complex128') - I = np.array([[1, 0], [0, 1]], dtype='complex128') - - op_list = [X, Y, Z] - for i, prob in enumerate(prob_list): - assert 0 <= prob <= 1, 'the parameter p' + str(i + 1) + ' should be in range [0, 1]' - op_list[i] = paddle.to_tensor(np.sqrt(prob_list[i]) * op_list[i]) - op_list.append(paddle.to_tensor(np.sqrt(1 - sum(prob_list)) * I)) - - return op_list - - @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_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 - q = 0 - cir = UAnsatz(N) - cir.h(0) - cir.cnot([0, 1]) - 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 混合过程。 - - Args: - t1 (float): :math:`T_1` 过程的弛豫时间常数，单位是微秒 - t2 (float): :math:`T_2` 过程的弛豫时间常数，单位是微秒 - time (float): 弛豫过程中量子门的执行时间，单位是纳秒 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 - - Note: - 时间常数必须满足 :math:`T_2 \le T_1`，参考文献 https://arxiv.org/abs/2101.02109 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.circuit import UAnsatz - N = 2 - t1 = 30 - t2 = 20 - tg = 200 - cir = UAnsatz(N) - cir.h(0) - cir.cnot([0, 1]) - cir.thermal_relaxation(t1, t2, tg, 0) - cir.thermal_relaxation(t1, t2, tg, 1) - final_state = cir.run_density_matrix() - print(final_state.numpy()) - - :: - - [[0.5 +0.j 0. +0.j 0. +0.j 0.4901+0.j] - [0. +0.j 0.0033+0.j 0. +0.j 0. +0.j] - [0. +0.j 0. +0.j 0.0033+0.j 0. +0.j] - [0.4901+0.j 0. +0.j 0. +0.j 0.4934+0.j]] - - """ - 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) - # Probability of phase flip - 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 - - 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"""添加自定义的量子信道。 - - Args: - ops (list): 表示信道的 Kraus 算符的列表 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, n)` 范围内， :math:`n` 为该量子电路的量子比特数 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - N = 2 - k1 = paddle.to_tensor([[1, 0], [0, 0]], dtype='complex128') - k2 = paddle.to_tensor([[0, 0], [0, 1]], dtype='complex128') - cir = UAnsatz(N) - cir.h(0) - cir.cnot([0, 1]) - cir.customized_channel([k1, k2], 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. +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.5+0.j]] - """ - completeness = paddle.to_tensor([[0, 0], [0, 0]], dtype='complex128') - for op in ops: - assert isinstance(op, paddle.Tensor), 'The input operators should be Tensors.' - 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.' - - 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""" - 构造出 Pauli 测量电路并测量 ancilla，处理实验结果来得到 ``H`` (只有一项)期望值的实验测量值。 - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - # Add one ancilla, which we later measure and process the result - new_cir = UAnsatz(cir.n + 1) - input_state = paddle.kron(cir.run_state_vector(store_state=False), init_state_gen(1)) - # Used in fixed Rz gate - _theta = paddle.to_tensor(np.array([-np.pi / 2])) - - op_list = hamiltonian.split(',') - # Set up pauli measurement circuit - for op in op_list: - element = op[0] - 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.lower() == 'z': - new_cir.cnot([index, cir.n]) - elif element.lower() == 'y': - new_cir.rz(_theta, index) - new_cir.h(index) - new_cir.cnot([index, cir.n]) - - new_cir.run_state_vector(input_state) - prob_result = new_cir.measure(shots=shots, which_qubits=[cir.n]) - if shots > 0: - if len(prob_result) == 1: - if '0' in prob_result: - result = (prob_result['0']) / shots - else: - result = -(prob_result['1']) / shots - else: - result = (prob_result['0'] - prob_result['1']) / shots - else: - result = (prob_result['0'] - prob_result['1']) - - return result - - -def swap_test(n): - r"""构造用 Swap Test 测量两个量子态之间差异的电路。 - - Args: - n (int): 待比较的两个态的量子比特数 - - Returns: - UAnsatz: Swap Test 的电路 - - 代码示例: - - .. code-block:: python - - import paddle - 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 inner product is 0.006591796875 - """ - 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/clifford.py b/paddle_quantum/clifford.py deleted file mode 100644 index 86e44af..0000000 --- a/paddle_quantum/clifford.py +++ /dev/null @@ -1,338 +0,0 @@ -# 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. - -""" -Class for randomly generating a Clifford operator -""" - -import numpy as np -from paddle_quantum.circuit import UAnsatz - -__all__ = [ - "Clifford", - "compose_clifford_circuit" -] - - -class Clifford: - r"""用户可以通过实例化该 ``class`` 来随机生成一个 Clifford operator。 - - Attributes: - n (int): 该 Clifford operator 作用的量子比特数目 - - References: - 1. Sergey Bravyi and Dmitri Maslov, Hadamard-free circuits expose the structure of the clifford group. arXiv preprint arXiv:2003.09412, 2020. - """ - - def __init__(self, n): - r"""Clifford 的构造函数，用于实例化一个 Clifford 对象 - - Args: - n (int): 该 Clifford operator 作用的量子比特数目 - """ - # number of qubit - self.n = n - self.__table, self.__Gamma, self.__Delta, self.__h, self.__s = _random_clifford(n) - self.phase = [] - for qbit in range(2 * self.n): - self.phase.append(np.random.randint(0, 2)) - - # Initialize stabilizer table - self.x = np.transpose(self.__table)[0:n, :] - # Initialize destabilizer table - self.z = np.transpose(self.__table)[n:2 * n, :] - - def print_clifford(self): - r"""输出该 Clifford 在 Pauli 基上的作用关系，来描述这个 Clifford - """ - base = [] - base_out = [] - n = 2 * self.n - - # Initialize Pauli basis - for position in range(self.n): - base.append('X' + str(position + 1)) - for position in range(self.n): - base.append('Z' + str(position + 1)) - - # Compute stabilizer table - for i in range(self.n): - temp = '' - for jx in range(n): - if self.x[i][jx] == 1: - temp += base[jx] - base_out.append(temp) - - # Compute destabilizer table - temp = '' - for jz in range(n): - if self.z[i][jz] == 1: - temp += base[jz] - base_out.append(temp) - - for i in range(n): - if i % 2 == 0: - # Fix the phase - if self.phase[i // 2] == 1: - print(base[i // 2] + ' |-> ' + '+' + base_out[i]) - else: - print(base[i // 2] + ' |-> ' + '-' + base_out[i]) - else: - if self.phase[self.n + (i - 1) // 2] == 1: - print(base[self.n + (i - 1) // 2] + ' |-> ' + '+' + base_out[i]) - else: - print(base[self.n + (i - 1) // 2] + ' |-> ' + '-' + base_out[i]) - - def sym(self): - r"""获取该 Clifford operator 所对应的辛矩阵 - - Returns: - numpy.ndarray: Clifford 对应的辛矩阵 - """ - sym = [] - for i in range(self.n): - tempx = [] - temp = self.x[i][self.n:2 * self.n] - for jx in range(0, self.n): - tempx.append(self.x[i][jx]) - tempx.append(temp[jx]) - sym.append(tempx) - - tempz = [] - temp = self.z[i][self.n:2 * self.n] - for jz in range(0, self.n): - tempz.append(self.z[i][jz]) - tempz.append(temp[jz]) - sym.append(tempz) - - return np.array(sym).T - - def tableau(self): - r"""获取该 Clifford operator 所对应的 table，对 n 个 qubits 情况，前 n 行对应 X_i 的结果，后 n 行对应 Z_i 的结果。 - - Returns: - numpy.ndarray: 该 Clifford 的 table - """ - return np.transpose(self.__table) - - def circuit(self): - r"""获取该 Clifford operator 所对应的电路 - - Returns: - UAnsatz: 该 Clifford 对应的电路 - """ - cir = UAnsatz(self.n) - gamma1 = self.__Gamma[0] - gamma2 = self.__Gamma[1] - delta1 = self.__Delta[0] - delta2 = self.__Delta[1] - - # The second cnot layer - for bitindex in range(self.n): - for j in range(bitindex + 1, self.n): - if delta2[j][bitindex] == 1: - cir.cnot([bitindex, j]) - - # The second cz layer - for bitindex in range(self.n): - for j in range(bitindex + 1, self.n): - if gamma2[bitindex][j] == 1: - cir.cz([bitindex, j]) - - # The second P layer - for bitindex in range(self.n): - if gamma2[bitindex][bitindex] == 1: - cir.s(bitindex) - - # Pauli layer - for bitindex in range(self.n): - if self.phase[bitindex] == 1 and self.phase[bitindex + self.n] == 0: - cir.x(bitindex) - elif self.phase[bitindex] == 0 and self.phase[bitindex + self.n] == 1: - cir.z(bitindex) - elif self.phase[bitindex] == 0 and self.phase[bitindex + self.n] == 0: - cir.y(bitindex) - - # S layer - swapped = [] - for bitindex in range(self.n): - if self.__s[bitindex] == bitindex: - continue - swapped.append(self.__s[bitindex]) - if bitindex in swapped: - continue - cir.swap([bitindex, self.__s[bitindex]]) - - # Hadamard layer - for bitindex in range(self.n): - if self.__h[bitindex] == 1: - cir.h(bitindex) - - # cnot layer - for bitindex in range(self.n): - for j in range(bitindex + 1, self.n): - if delta1[j][bitindex] == 1: - cir.cnot([bitindex, j]) - - # cz layer - for bitindex in range(self.n): - for j in range(bitindex + 1, self.n): - if gamma1[bitindex][j] == 1: - cir.cz([bitindex, j]) - - # P layer - for bitindex in range(self.n): - if gamma1[bitindex][bitindex] == 1: - cir.s(bitindex) - - return cir - - -def compose_clifford_circuit(clif1, clif2): - r"""计算两个指定的 Clifford 的复合，得到复合后的电路 - - Args: - clif1 (Clifford): 需要复合的第 1 个 Clifford - clif2 (Clifford): 需要复合的第 2 个 Clifford - - Returns: - UAnsatz: 复合后的 Clifford 所对应的电路，作用的顺序为 clif1、clif2 - """ - assert clif1.n == clif2.n, "the number of qubits of two cliffords should be the same" - - return clif1.circuit() + clif2.circuit() - - -def _sample_qmallows(n): - r"""n 量子比特的 quantum mallows 采样，来获得随机采样 Clifford 时所需要的 S 和 h - - Args: - n (int): 量子比特数目 - - Returns: - tuple: 包含 - - numpy.ndarray: Clifford 采样时需要的参数 h - numpy.ndarray: Clifford 采样时需要的参数 S - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - # Hadamard layer - h = np.zeros(n, dtype=int) - # S layer - S = np.zeros(n, dtype=int) - A = list(range(n)) - - for i in range(n): - m = n - i - r = np.random.uniform(0, 1) - index = int(2 * m - np.ceil(np.log(r * (4 ** m - 1) + 1) / np.log(2.0))) - h[i] = 1 * (index < m) - if index < m: - k = index - else: - k = 2 * m - index - 1 - S[i] = A[k] - del A[k] - return h, S - - -def _random_clifford(n): - r"""随机生成一个指定量子比特数目 n 的 Clifford 所对应的 table 及 canonical form 中的参数 - - Args: - n (int): 量子比特数目 - - Returns: - tuple: 包含 - - numpy.ndarray: 随机生成的 Clifford 所对应的 table - list: 随机生成的 Clifford 所对应的参数 Gamma - list: 随机生成的 Clifford 所对应的参数 Delta - numpy.ndarray: 随机生成的 Clifford 所对应的参数 h - numpy.ndarray: 随机生成的 Clifford 所对应的参数 S - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - assert (n <= 100), "too many qubits" - - # Some constant matrices - bigzero = np.zeros((2 * n, 2 * n), dtype=int) - nzero = np.zeros((n, n), dtype=int) - I = np.identity(n, dtype=int) - - h, S = _sample_qmallows(n) - Gamma1 = np.copy(nzero) - Delta1 = np.copy(I) - Gamma2 = np.copy(nzero) - Delta2 = np.copy(I) - - for i in range(n): - Gamma2[i, i] = np.random.randint(2) - if h[i] == 1: - Gamma1[i, i] = np.random.randint(2) - - # Constraints for canonical form - for j in range(n): - for i in range(j + 1, n): - b = np.random.randint(2) - Gamma2[i, j] = b - Gamma2[j, i] = b - Delta2[i, j] = np.random.randint(2) - if h[i] == 1 and h[j] == 1: - b = np.random.randint(2) - Gamma1[i, j] = b - Gamma1[j, i] = b - if h[i] == 1 and h[j] == 0 and S[i] < S[j]: - b = np.random.randint(2) - Gamma1[i, j] = b - Gamma1[j, i] = b - if h[i] == 0 and h[j] == 1 and S[i] > S[j]: - b = np.random.randint(2) - Gamma1[i, j] = b - Gamma1[j, i] = b - if h[i] == 0 and h[j] == 1: - Delta1[i, j] = np.random.randint(2) - - if h[i] == 1 and h[j] == 1 and S[i] > S[j]: - Delta1[i, j] = np.random.randint(2) - - if h[i] == 0 and h[j] == 0 and S[i] < S[j]: - Delta1[i, j] = np.random.randint(2) - - # Compute stabilizer table - st1 = np.matmul(Gamma1, Delta1) - st2 = np.matmul(Gamma2, Delta2) - inv1 = np.linalg.inv(np.transpose(Delta1)) - inv2 = np.linalg.inv(np.transpose(Delta2)) - f_1 = np.block([[Delta1, nzero], [st1, inv1]]) - f_2 = np.block([[Delta2, nzero], [st2, inv2]]) - f_1 = f_1.astype(int) % 2 - f_2 = f_2.astype(int) % 2 - U = np.copy(bigzero) - - for i in range(n): - U[i, :] = f_2[S[i], :] - U[i + n, :] = f_2[S[i] + n, :] - - # Apply Hadamard layer to the stabilizer table - for i in range(n): - if h[i] == 1: - U[(i, i + n), :] = U[(i + n, i), :] - - Gamma = [Gamma1, Gamma2] - Delta = [Delta1, Delta2] - return np.matmul(f_1, U) % 2, Gamma, Delta, h, S diff --git a/paddle_quantum/dataset.py b/paddle_quantum/dataset.py index 81bee22..0c9ab96 100644 --- a/paddle_quantum/dataset.py +++ b/paddle_quantum/dataset.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# 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. @@ -13,25 +14,22 @@ # limitations under the License. -""" -dataset: To learn more about the functions and properties of this application, -you could check the corresponding Jupyter notebook under the Tutorial folder. +r""" +The source file of the dataset. """ -import math import random -from math import sqrt -import time -import paddle.vision.transforms as transform +import math +from typing import Tuple, Union, Optional import numpy as np import paddle -from paddle_quantum.circuit import UAnsatz -from paddle.fluid.layers import reshape - +import paddle.vision.transforms as transform from sklearn.model_selection import train_test_split from sklearn import datasets +from paddle_quantum.gate import RY, RZ, U3, CNOT, IQPEncoding, AmplitudeEncoding __all__ = [ + "Dataset", "VisionDataset", "SimpleDataset", "MNIST", @@ -41,6 +39,8 @@ ] # data modes +import paddle_quantum.gate + DATAMODE_TRAIN = "train" DATAMODE_TEST = "test" @@ -61,45 +61,25 @@ def _normalize(x): r"""normalize vector ``x`` and the maximum will be pi. This is an internal function. - - Args: - x (ndarray): 需要归一化的向量 - - Returns: - ndarray: 归一化之后的向量 """ xx = np.abs(x) if xx.max() > 0: return x * np.pi / xx.max() - else: - return x + return x def _normalize_image(x): r"""normalize image vector ``x`` and the maximum will be pi. This is an internal function. - - Args: - x (ndarray): 需要归一化的图片向量 - - Returns: - ndarray: 归一化之后的向量 """ return x * np.pi / 256 def _crop(images, border): r"""crop ``images`` according to ``border``. This is an internal function. - - Args: - images (list/ndarray): 每一个元素是拉成一维的图片向量 - border(list): 裁剪的边界，从第一个元素切到第二个元素，比如说[4,24]就是从图片的第四行第四列到第24行第24列 - - Returns: - new_images(list): 裁剪之后被拉成一维的图片向量组成的list """ new_images = [] for i in range(len(images)): - size = int(sqrt(len(images[i]))) + size = int(np.sqrt(len(images[i]))) temp_image = images[i].reshape((size, size)) temp_image = temp_image[border[0]:border[1], border[0]:border[1]] new_images.append(temp_image.flatten()) @@ -107,26 +87,33 @@ def _crop(images, border): class Dataset(object): - r"""所有数据集的基类，集成了多种量子编码方法。 + r"""Base class for all datasets, integrating multiple quantum encoding methods. """ + def __init__(self): return - def data2circuit(self, classical_data, encoding, num_qubits, can_describe_dimension, split_circuit, - return_state, is_image=False): - r"""将输入的经典数据 ``classical_data`` 用编码方式 ``encoding`` 编码成量子态，这里的经典数据经过了截断或者补零，因而可以正好被编码。 + def data2circuit( + self, classical_data: list, encoding: str, num_qubits: int, can_describe_dimension: int, split_circuit: bool, + return_state: bool, is_image: Optional[bool] = False + ) -> list: + r"""Encode the input ``classical data`` into quantum states using ``encoding``, where the classical data is truncated or filled with zero. Args: - classical_data (list): 待编码的向量，ndarray 组成的 list，经过了截断或者补零，刚好可以被编码 - encoding (str): 编码方式，参见 MNIST 编码注释 - num_qubits (int): 量子比特数目 - can_describe_dimension (int): 以 ``encoding`` 编码方式可以编码的数目，比如说振幅编码为 ``2 ** n`` ，其他编码因为可以进行层层堆叠需要计算 - split_circuit (bool): 是否切分电路 - return_state (bool): 是否返回量子态 - is_image (bool): 是否是图片，如果是图片，归一化方法不太一样 + classical_data: vectors needed to encode, which have been already truncated or filled with zero to the length ``can_describe_dimension`` + For example, amplitude encoding can describe ``2 ** n`` dimension vectors. + encoding: The encoding method. + num_qubits: The number of qubits. + can_describe_dimension: The dimension which the circuit can describe by ``encoding``. + split_circuit: Whether to split the circuit. + return_state: Whether to return quantum state. + is_image:Whether it is a picture, if it is a picture, the normalization method is not quite the same. Defaults to ``False``. + + Raises: + Exception: Not support to return circuit in amplitude encoding. Returns: - List: 如果 ``return_state == True`` ，返回编码后的量子态，否则返回编码的电路 + If ``return_state == True``, return encoded quantum state, otherwise return encoding circuits. """ quantum_states = classical_data.copy() quantum_circuits = classical_data.copy() @@ -135,12 +122,12 @@ def data2circuit(self, classical_data, encoding, num_qubits, can_describe_dimens if return_state is False or split_circuit is True: raise Exception("Not support to return circuit in amplitude encoding") for i in range(len(classical_data)): - built_in_amplitude_enc = UAnsatz(num_qubits) x = paddle.to_tensor(_normalize(classical_data[i])) if is_image: x = paddle.to_tensor(_normalize_image(classical_data[i])) - state = built_in_amplitude_enc.amplitude_encoding(x, 'state_vector') - quantum_states[i] = state.numpy() + circuit = AmplitudeEncoding(qubits_idx='full', num_qubits=num_qubits) + state = circuit(x) + quantum_states[i] = state.data.numpy() elif encoding == ANGLE_ENCODING: for i in range(len(classical_data)): @@ -149,23 +136,22 @@ def data2circuit(self, classical_data, encoding, num_qubits, can_describe_dimens param = paddle.to_tensor(_normalize(classical_data[i])) if is_image: param = paddle.to_tensor(_normalize_image(classical_data[i])) - param = reshape(param, (depth, num_qubits, 1)) - which_qubits = [k for k in range(num_qubits)] + param = paddle.reshape(param, (depth, num_qubits, 1)) + which_qubits = list(range(num_qubits)) if split_circuit: quantum_circuits[i] = [] for repeat in range(depth): - circuit = UAnsatz(num_qubits) + circuit = paddle_quantum.ansatz.Sequential() for k, q in enumerate(which_qubits): - circuit.ry(param[repeat][k][0], q) - + circuit.append(RY(qubits_idx=q, param=param[repeat][k][0])) quantum_circuits[i].append(circuit) else: - circuit = UAnsatz(num_qubits) + circuit = paddle_quantum.ansatz.Sequential() for repeat in range(depth): for k, q in enumerate(which_qubits): - circuit.ry(param[repeat][k][0], q) - state_out = circuit.run_state_vector() - quantum_states[i] = state_out.numpy() + circuit.append(RY(qubits_idx=q, param=param[repeat][k][0])) + state_out = circuit(paddle_quantum.state.zero_state(num_qubits)) + quantum_states[i] = state_out.data.numpy() quantum_circuits[i] = [circuit] elif encoding == IQP_ENCODING: @@ -175,31 +161,29 @@ def data2circuit(self, classical_data, encoding, num_qubits, can_describe_dimens param = paddle.to_tensor(_normalize(classical_data[i])) if is_image: param = paddle.to_tensor(_normalize_image(classical_data[i])) - param = reshape(param, (depth, num_qubits)) + param = paddle.reshape(param, (depth, num_qubits)) if split_circuit: quantum_circuits[i] = [] for repeat in range(depth): - circuit = UAnsatz(num_qubits) - S = [] + circuit = paddle_quantum.ansatz.Sequential() + s = [] for k in range(num_qubits - 1): - S.append([k, k + 1]) + s.append([k, k + 1]) # r 是 U 重复的次数 r = 1 - circuit.iqp_encoding(param[repeat], r, S) + circuit.append(IQPEncoding(feature=param[repeat], num_repeat=r, qubits_idx=s)) quantum_circuits[i].append(circuit) else: - circuit = UAnsatz(num_qubits) + circuit = paddle_quantum.ansatz.Sequential() for repeat in range(depth): - temp_circuit = UAnsatz(num_qubits) - S = [] + s = [] for k in range(num_qubits - 1): - S.append([k, k + 1]) + s.append([k, k + 1]) # r 是 U 重复的次数 r = 1 - temp_circuit.iqp_encoding(param[repeat], r, S) - circuit = circuit + temp_circuit - state_out = circuit.run_state_vector() - quantum_states[i] = state_out.numpy() + circuit.append(IQPEncoding(feature=param[repeat], num_repeat=r, qubits_idx=s)) + state_out = circuit(paddle_quantum.state.zero_state(num_qubits)) + quantum_states[i] = state_out.data.numpy() quantum_circuits[i] = [circuit] elif encoding == PAULI_ROTATION_ENCODING: @@ -209,26 +193,26 @@ def data2circuit(self, classical_data, encoding, num_qubits, can_describe_dimens param = paddle.to_tensor(_normalize(classical_data[i])) if is_image: param = paddle.to_tensor(_normalize_image(classical_data[i])) - param = reshape(param, (depth, num_qubits, 3)) - which_qubits = [k for k in range(num_qubits)] + param = paddle.reshape(param, (depth, num_qubits, 3)) + which_qubits = list(range(num_qubits)) if split_circuit: quantum_circuits[i] = [] for repeat in range(depth): - circuit = UAnsatz(num_qubits) + circuit = paddle_quantum.ansatz.Sequential() for k, q in enumerate(which_qubits): - circuit.ry(param[repeat][k][0], q) - circuit.rz(param[repeat][k][1], q) - circuit.ry(param[repeat][k][2], q) + circuit.append(RY(q, param=param[repeat][k][0])) + circuit.append(RZ(q, param=param[repeat][k][1])) + circuit.append(RY(q, param=param[repeat][k][2])) quantum_circuits[i].append(circuit) else: - circuit = UAnsatz(num_qubits) + circuit = paddle_quantum.ansatz.Sequential() for repeat in range(depth): for k, q in enumerate(which_qubits): - circuit.ry(param[repeat][k][0], q) - circuit.rz(param[repeat][k][1], q) - circuit.ry(param[repeat][k][2], q) - state_out = circuit.run_state_vector() - quantum_states[i] = state_out.numpy() + circuit.append(RY(q, param=param[repeat][k][0])) + circuit.append(RZ(q, param=param[repeat][k][1])) + circuit.append(RY(q, param=param[repeat][k][2])) + state_out = circuit(paddle_quantum.state.zero_state(num_qubits)) + quantum_states[i] = state_out.data.numpy() quantum_circuits[i] = [circuit] elif encoding == LINEAR_ENTANGLED_ENCODING: @@ -238,34 +222,34 @@ def data2circuit(self, classical_data, encoding, num_qubits, can_describe_dimens param = paddle.to_tensor(_normalize(classical_data[i])) if is_image: param = paddle.to_tensor(_normalize_image(classical_data[i])) - param = reshape(param, (depth, num_qubits, 2)) + param = paddle.reshape(param, (depth, num_qubits, 2)) which_qubits = [k for k in range(num_qubits)] if split_circuit: quantum_circuits[i] = [] for j in range(depth): - circuit = UAnsatz(num_qubits) + circuit = paddle_quantum.ansatz.Sequential() for k, q in enumerate(which_qubits): - circuit.ry(param[j][k][0], q) + circuit.append(RY(q, param=param[j][k][0])) for k in range(len(which_qubits) - 1): - circuit.cnot([which_qubits[k], which_qubits[k + 1]]) + circuit.append(CNOT(qubits_idx=[which_qubits[k], which_qubits[k + 1]])) for k, q in enumerate(which_qubits): - circuit.rz(param[j][k][1], q) + circuit.append(RZ(q, param=param[j][k][1])) for k in range(len(which_qubits) - 1): - circuit.cnot([which_qubits[k + 1], which_qubits[k]]) + circuit.append(CNOT(qubits_idx=[which_qubits[k + 1], which_qubits[k]])) quantum_circuits[i].append(circuit) else: - circuit = UAnsatz(num_qubits) + circuit = paddle_quantum.ansatz.Sequential() for j in range(depth): for k, q in enumerate(which_qubits): - circuit.ry(param[j][k][0], q) + circuit.append(RY(q, param=param[j][k][0])) for k in range(len(which_qubits) - 1): - circuit.cnot([which_qubits[k], which_qubits[k + 1]]) + circuit.append(CNOT(qubits_idx=[which_qubits[k], which_qubits[k + 1]])) for k, q in enumerate(which_qubits): - circuit.rz(param[j][k][1], q) + circuit.append(RZ(q, param=param[j][k][1])) for k in range(len(which_qubits) - 1): - circuit.cnot([which_qubits[k + 1], which_qubits[k]]) - state_out = circuit.run_state_vector() - quantum_states[i] = state_out.numpy() + circuit.append(CNOT(qubits_idx=[which_qubits[k + 1], which_qubits[k]])) + state_out = circuit(paddle_quantum.state.zero_state(num_qubits)) + quantum_states[i] = state_out.data.numpy() quantum_circuits[i] = [circuit] elif encoding == REAL_ENTANGLED_ENCODING: @@ -275,28 +259,28 @@ def data2circuit(self, classical_data, encoding, num_qubits, can_describe_dimens param = paddle.to_tensor(_normalize(classical_data[i])) if is_image: param = paddle.to_tensor(_normalize_image(classical_data[i])) - param = reshape(param, (depth, num_qubits, 1)) + param = paddle.reshape(param, (depth, num_qubits, 1)) which_qubits = [k for k in range(num_qubits)] if split_circuit: quantum_circuits[i] = [] for repeat in range(depth): - circuit = UAnsatz(num_qubits) + circuit = paddle_quantum.ansatz.Sequential() for k, q in enumerate(which_qubits): - circuit.ry(param[repeat][k][0], q) + circuit.append(RY(q, param=param[repeat][k][0])) for k in range(len(which_qubits) - 1): - circuit.cnot([which_qubits[k], which_qubits[k + 1]]) - circuit.cnot([which_qubits[-1], which_qubits[0]]) + circuit.append(CNOT(qubits_idx=[which_qubits[k], which_qubits[k + 1]])) + circuit.append(CNOT(qubits_idx=[which_qubits[-1], which_qubits[0]])) quantum_circuits[i].append(circuit) else: - circuit = UAnsatz(num_qubits) + circuit = paddle_quantum.ansatz.Sequential() for repeat in range(depth): for k, q in enumerate(which_qubits): - circuit.ry(param[repeat][k][0], q) + circuit.append(RY(q, param=param[repeat][k][0])) for k in range(len(which_qubits) - 1): - circuit.cnot([which_qubits[k], which_qubits[k + 1]]) - circuit.cnot([which_qubits[-1], which_qubits[0]]) - state_out = circuit.run_state_vector() - quantum_states[i] = state_out.numpy() + circuit.append(CNOT(qubits_idx=[which_qubits[k], which_qubits[k + 1]])) + circuit.append(CNOT(qubits_idx=[which_qubits[-1], which_qubits[0]])) + state_out = circuit(paddle_quantum.state.zero_state(num_qubits)) + quantum_states[i] = state_out.data.numpy() quantum_circuits[i] = [circuit] elif encoding == COMPLEX_ENTANGLED_ENCODING: @@ -306,47 +290,49 @@ def data2circuit(self, classical_data, encoding, num_qubits, can_describe_dimens param = paddle.to_tensor(_normalize(classical_data[i])) if is_image: param = paddle.to_tensor(_normalize_image(classical_data[i])) - param = reshape(param, (depth, num_qubits, 3)) + param = paddle.reshape(param, (depth, num_qubits, 3)) which_qubits = [k for k in range(num_qubits)] if split_circuit: quantum_circuits[i] = [] for repeat in range(depth): - circuit = UAnsatz(num_qubits) + circuit = paddle_quantum.ansatz.Sequential() for k, q in enumerate(which_qubits): + circuit.append(U3(q, param=param[repeat][k])) circuit.u3(param[repeat][k][0], param[repeat][k][1], param[repeat][k][2], q) for k in range(len(which_qubits) - 1): - circuit.cnot([which_qubits[k], which_qubits[k + 1]]) - circuit.cnot([which_qubits[-1], which_qubits[0]]) + circuit.append(CNOT(qubits_idx=[which_qubits[k], which_qubits[k + 1]])) + circuit.append(CNOT(qubits_idx=[which_qubits[-1], which_qubits[0]])) quantum_circuits[i].append(circuit) else: - circuit = UAnsatz(num_qubits) + circuit = paddle_quantum.ansatz.Sequential() for repeat in range(depth): for k, q in enumerate(which_qubits): - circuit.u3(param[repeat][k][0], param[repeat][k][1], param[repeat][k][2], q) + circuit.append(U3(q, param=param[repeat][k])) for k in range(len(which_qubits) - 1): - circuit.cnot([which_qubits[k], which_qubits[k + 1]]) - circuit.cnot([which_qubits[-1], which_qubits[0]]) - state_out = circuit.run_state_vector() - quantum_states[i] = state_out.numpy() + circuit.append(CNOT(qubits_idx=[which_qubits[k], which_qubits[k + 1]])) + circuit.append(CNOT(qubits_idx=[which_qubits[-1], which_qubits[0]])) + state_out = circuit(paddle_quantum.state.zero_state(num_qubits)) + quantum_states[i] = state_out.data.numpy() quantum_circuits[i] = [circuit] return quantum_states, quantum_circuits - def filter_class(self, x, y, classes, data_num, need_relabel, seed=0): - r"""将输入的 ``x`` , ``y`` 按照 ``classes`` 给出的类别进行筛选，数目为 ``data_num`` 。 + def filter_class(self, x: Union[list, np.ndarray], y: Union[list, np.ndarray], classes: list, + data_num: int, need_relabel: bool, seed: Optional[int] = 0) -> Tuple[list]: + r"""Select ``data_num`` samples from ``x`` , ``y``, whose label is in ``classes``. Args: - x (ndarray/list): 样本的特征 - y (ndarray/list): 样本标签， ``classes`` 是其中某几个标签的取值 - classes (list): 需要筛选的类别 - data_num (int): 筛选出来的样本数目 - need_relabel (bool): 将原有类别按照顺序重新标记为 0、1、2 等新的名字，比如传入 ``[1,2]`` ， 重新标记之后变为 ``[0,1]`` 主要用于二分类 - seed (int): 随机种子，默认为 ``0`` + x: Training features. + y: Training labels. + classes: Classes needed to select. + data_num: The number of data needed to select. + need_relabel: Whether we need to relabel the labels to 0,1,2 for binary classification. For example ``[1,2]`` will be relabeled to ``[0,1]``. + seed: Random seed. Defaults to ``0``. Returns: - tuple: 包含如下元素: - - new_x (list): 筛选出的特征 - - new_y (list): 对应于 ``new_x`` 的标签 + contains elements + - new_x: selected features. + - new_y: selected labels corresponded to ``new_x``. """ new_x = [] new_y = [] @@ -377,49 +363,49 @@ def filter_class(self, x, y, classes, data_num, need_relabel, seed=0): class VisionDataset(Dataset): - r"""图片数据集类，通过继承 VisionDataset 类，用户可以快速生成自己的图片量子数据。 + r""" ``VisionDataset`` is the base class of all image datasets. By inheriting ``VisionDataset``, users can easily generate their own quantum data. - Attributes: - original_images (ndarray): 图片经过类别过滤，但是还没有降维、补零的特征，是一个一维向量（可调用 ``reshape()`` 函数转成图片） - classical_image_vectors (ndarray): 经过类别过滤和降维、补零等操作之后的特征，并未编码为量子态 - quantum_image_states (paddle.tensor): 经过类别过滤之后的所有特征经编码形成的量子态 - quantum_image_circuits (list): 所有特征编码的电路 + Args: + figure_size: The size of the figure. """ - def __init__(self, figure_size): - r"""构造函数 - - Args: - figure_size (int): 图片大小，也就是长和高的数值 - """ + def __init__(self, figure_size: int): Dataset.__init__(self) self.figure_size = figure_size return # The encode function only needs to import images to form one-dimensional vector features. # The pre-processing of images (except dimensionality reduction) is completed before the import of features - def encode(self, feature, encoding, num_qubits, split_circuit=False, - downscaling_method=DOWNSCALINGMETHOD_RESIZE, target_dimension=-1, return_state=True, full_return=False): - r"""根据降尺度方式、目标尺度、编码方式、量子比特数目进行编码。只需要输入一维图片向量就行。 + def encode(self, feature: Union[list, np.ndarray], encoding: str, num_qubits: int, split_circuit: Optional[bool] = False, + downscaling_method: Optional[str] = DOWNSCALINGMETHOD_RESIZE, target_dimension: Optional[int] = -1, + return_state: Optional[bool] = True, full_return: Optional[bool] = False) -> Tuple[paddle.Tensor, list, np.ndarray, np.ndarray]: + r"""Encode ``feature`` into ``num_qubits`` qubits using ``encoding`` after downscaling to ``target_dimension``. ``feature`` is one-dimension image vectors. Args: - feature (list/ndarray): 一维图片向量组成的list/ndarray - encoding (str): ``"angle_encoding"`` 表示角度编码，一个量子比特编码一个旋转门； ``"amplitude_encoding"`` 表示振幅编码； - ``"pauli_rotation_encoding"`` 表示SU(3)的角度编码; 还有 ``"linear_entangled_encoding"`` , - ``"real_entangled_encoding"`` , ``"complex_entangled_encoding"`` 三种纠缠编码和 ``"IQP_encoding"`` 编码 - num_qubits (int): 编码后的量子比特数目 - split_circuit (bool): 是否需要切分电路。除了振幅之外的所有电路都会存在堆叠的情况，如果选择 ``True`` 就将块与块分开 - downscaling_method (str): 包括 ``"PCA"`` 和 ``"resize"`` - target_dimension (int): 降维之后的尺度大小，如果是 ``"PCA"`` ，不能超过图片大小；如果是 ``"resize"`` ，不能超过原图大小 - return_state (bool): 是否返回量子态，如果是 ``False`` 返回量子电路 + feature: One-dimension image vectors which can be list or ndarray. + encoding: ``angle_encoding`` denotes angle encoding, and one qubit encodes one number with a Ry gate. ``amplitude_encoding`` denotes amplitude encoding; + ``pauli_rotation_encoding`` denotes using SU(3) rotation gate. ``linear_entanglement_encoding``, ``real_entanglement_encoding`` , ``complex_entanglement_encoding`` + and ``IQP_encoding`` encoding methods. + num_qubits: Qubit number. + split_circuit: Whether to split the circuits. If true, every layer of the encoding circuit will be split into a list. Defaults to ``False``. + downscaling_method: Including ``PCA`` and ``resize``. Defaults to ``resize``. + target_dimension: The dimension after downscaling. ``target_dimension`` is not allowed to surpass the figure size. Defaults to ``-1``. + return_state: Whether to return quantum states. If it is ``False``, return quantum circuits. Defaults to ``True``. + full_return: Whether to return ``quantum_image_states``, ``quantum_image_circuits``, ``original_images`` and ``classical_image_vectors``. Defaults to ``False``. + + Raises: + Exception: PCA dimension should be less than figure size. + Exception: Resize dimension should be a square. + Exception: Downscaling methods can only be resize and PCA. + Exception: Invalid encoding methods Returns: - tuple: 包含如下元素: - - quantum_image_states (paddle.tensor): 量子态，只有 ``full_return==True`` 或者 ``return_state==True`` 的时候会返回 - - quantum_image_circuits (list): 所有特征编码的电路， 只有 ``full_return==False`` 或者 ``return_state==True`` 的时候会返回 - - original_images (ndarray): 图片经过类别过滤，但是还没有降维、补零的特征，是一个一维向量（可以 reshape 成图片），只有 ``return_state==True`` 的时候会返回 - - classical_image_vectors (ndarray): 经过类别过滤和降维、补零等操作之后的特征，并未编码为量子态，只有 ``return_state==True`` 的时候会返回 + contain these elements + - quantum_image_states: Quantum states, only ``full_return==True`` or ``return_state==True`` will return. + - quantum_image_circuits: A list of circuits generating quantum states, only ``full_return==True`` or ``return_state==True`` will return. + - original_images: One-dimension original vectors without any processing, only ``return_state==True`` will return. + - classical_image_vectors: One-dimension original vectors after filling with zero, which are encoded to quantum states. only ``return_state==True`` will return. """ assert num_qubits > 0 if encoding in [IQP_ENCODING, COMPLEX_ENTANGLED_ENCODING, REAL_ENTANGLED_ENCODING, @@ -435,7 +421,7 @@ def encode(self, feature, encoding, num_qubits, split_circuit=False, if target_dimension > self.figure_size: raise Exception("PCA dimension should be less than {}.".format(self.figure_size)) elif downscaling_method == DOWNSCALINGMETHOD_RESIZE: - if int(sqrt(target_dimension)) ** 2 != target_dimension: # not a square + if int(np.sqrt(target_dimension)) ** 2 != target_dimension: # not a square raise Exception("Resize dimension should be a square.") else: raise Exception("Downscaling methods can only be resize and PCA.") @@ -474,7 +460,7 @@ def encode(self, feature, encoding, num_qubits, split_circuit=False, # iterating all items for i in range(len(self.classical_image_vectors)): cur_image = self.classical_image_vectors[i].astype(np.uint8) - new_size = int(sqrt(self.dimension)) + new_size = int(np.sqrt(self.dimension)) cur_image = transform.resize(cur_image.reshape((self.figure_size, self.figure_size)), (new_size, new_size)) self.classical_image_vectors[i] = cur_image.reshape(-1).astype(np.float64) # now it is one-dimension @@ -482,12 +468,14 @@ def encode(self, feature, encoding, num_qubits, split_circuit=False, if self.can_describe_dimension < len(self.classical_image_vectors[i]): self.classical_image_vectors[i] = self.classical_image_vectors[i][:self.can_describe_dimension] else: - self.classical_image_vectors[i] = np.append(self.classical_image_vectors[i], np.array( - [0.0] * (self.can_describe_dimension - len(self.classical_image_vectors[i])))) + self.classical_image_vectors[i] = np.append( + self.classical_image_vectors[i], + np.array([0.0] * (self.can_describe_dimension - len(self.classical_image_vectors[i]))) + ) elif downscaling_method == DOWNSCALINGMETHOD_PCA: for i in range(len(self.classical_image_vectors)): - U, s, V = np.linalg.svd(self.classical_image_vectors[i].reshape((self.figure_size, self.figure_size))) + _, s, _ = np.linalg.svd(self.classical_image_vectors[i].reshape((self.figure_size, self.figure_size))) s = s[:self.dimension].astype(np.float64) if self.can_describe_dimension > self.dimension: self.classical_image_vectors[i] = np.append(s, np.array( @@ -504,76 +492,45 @@ def encode(self, feature, encoding, num_qubits, split_circuit=False, self.quantum_image_states = paddle.to_tensor(np.array(self.quantum_image_states)) # transfer to tensor if full_return: - return self.quantum_image_states, self.quantum_image_circuits, self.original_images, \ - self.classical_image_vectors - else: - if return_state: - return self.quantum_image_states - else: - return self.quantum_image_circuits + return ( + self.quantum_image_states, self.quantum_image_circuits, + self.original_images, self.classical_image_vectors + ) + if return_state: + return self.quantum_image_states + return self.quantum_image_circuits class MNIST(VisionDataset): - r"""MNIST 数据集，它继承了 VisionDataset 图片数据集类。 - - Attributes: - original_images(ndarray): 图片经过类别过滤，但是还没有降维、补零的特征，是一个一维向量（可调用 ``reshape()`` 方法转成图片） - classical_image_vectors(ndarray): 经过类别过滤和降维、补零等操作之后的特征，并未编码为量子态 - quantum_image_states(paddle.tensor): 经过类别过滤之后的所有特征经编码形成的量子态 - quantum_image_circuits(list): 所有特征编码的电路 - labels(ndarray): 经过类别过滤之后的所有标签 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.dataset import MNIST - - # main parameters - training_data_num = 80 - testing_data_num = 20 - qubit_num = 4 - - # acquiring training dataset - train_dataset = MNIST(mode='train', encoding='pauli_rotation_encoding', num_qubits=qubit_num, classes=[3,6], - data_num=training_data_num,need_cropping=True, - downscaling_method='resize', target_dimension=16, return_state=True) - - # acquiring testing dataset - val_dataset = MNIST(mode='test', encoding='pauli_rotation_encoding', num_qubits=qubit_num, classes=[3,6], - data_num=testing_data_num,need_cropping=True, - downscaling_method='resize', target_dimension=16,return_state=True) - - # acquiring features and labels - train_x, train_y = train_dataset.quantum_image_states, train_dataset.labels # paddle.tensor, ndarray - test_x, test_y = val_dataset.quantum_image_states, val_dataset.labels + r"""MNIST quantum dataset. It inherits ``VisionDataset``. - print(train_x[0]) - print(train_y[0]) + Args: + mode: Data mode including ``train`` and ``test``. + encoding: ``angle_encoding`` denotes angle encoding, and one qubit encodes one number with a Ry gate. ``amplitude_encoding`` denotes amplitude encoding; + ``pauli_rotation_encoding`` denotes using SU(3) rotation gate. ``linear_entanglement_encoding``, ``real_entanglement_encoding`` , ``complex_entanglement_encoding`` + and ``IQP_encoding`` encoding methods. + num_qubits: Qubit number. + classes: Classes needed to classify, categories are indicated by numeric labels. + data_num: Data number returned. Defaults to ``-1``. + split_circuit: Whether to split the circuits. If True, every layer of the encoding circuit will be split into a list. Defaults to ``False``. + downscaling_method: Including ``PCA`` and ``resize``. Defaults to ``resize``. + target_dimension: The dimension after downscaling, which is not allowed to surpass the figure size. Defaults to ``-1``. + need_cropping: Whether needed to crop, If ``True``, ``image[0:27][0:27]`` will be cropped to ``image[4:24][4:24]``. Defaults to ``True``. + need_relabel: Whether we need to relabel the labels to 0,1,2… for binary classification.For example [1,2] will be relabeled to [0,1] Defaults to ``True``. + return_state: Whether to return quantum states. Defaults to ``True``. + seed: Select random seed. Defaults to ``0``. + + Raises: + Exception: Data mode can only be train and test. """ - def __init__(self, mode, encoding, num_qubits, classes, data_num=-1, split_circuit=False, - downscaling_method=DOWNSCALINGMETHOD_RESIZE, target_dimension=-1, need_cropping=True, - need_relabel=True, return_state=True, seed=0): - r"""构造函数 - - Args: - mode (str): 数据模式，包括 ``"train"`` 和 ``"test"`` - encoding (str): ``"angle_encoding"`` 表示角度编码，一个量子比特编码一个旋转门； ``"amplitude_encoding"`` 表示振幅编码； - ``"pauli_rotation_encoding"`` 表示SU(3)的角度编码; 还有 ``"linear_entangled_encoding"`` , - ``"real_entangled_encoding"`` , ``"complex_entangled_encoding"`` 三种纠缠编码和 ``"IQP_encoding"`` 编码 - num_qubits (int): 编码后的量子比特数目 - classes (list): 用列表给出需要的类别，类别用数字标签表示，不支持传入名字 - data_num (int): 使用的数据量大小，这样可以不用所有数据都进行编码，这样会很慢 - split_circuit (bool): 是否需要切分电路。除了振幅之外的所有电路都会存在堆叠的情况，如果选择 ``True`` 就将块与块分开 - need_cropping (bool): 是否需要裁边，如果为 ``True`` ，则从 ``image[0:27][0:27]`` 裁剪为 ``image[4:24][4:24]`` - need_relabel (bool): 将原有类别按照顺序重新标记为 0，1，2 等新的名字，比如传入 ``[1,2]`` ，重新标记之后变为 ``[0,1]`` ，主要用于二分类 - downscaling_method (str): 包括 ``"PCA"`` 和 ``"resize"`` - target_dimension (int): 降维之后的尺度大小，如果是 ``"PCA"`` ，不能超过图片大小；如果是 ``"resize"`` ，不能超过原图大小 - return_state (bool): 是否返回量子态，如果是 ``False`` 返回量子电路 - seed (int): 筛选样本的随机种子，默认为 ``0`` - """ + def __init__( + self, mode: str, encoding: str, num_qubits: int, classes : list, data_num: Optional[int]=-1, + split_circuit: Optional[bool]=False, downscaling_method: Optional[str] =DOWNSCALINGMETHOD_RESIZE, + target_dimension: Optional[int] = -1, need_cropping: Optional[bool] = True, + need_relabel: Optional[bool] = True, return_state: Optional[bool] =True, seed: Optional[int]=0 + ) -> None: VisionDataset.__init__(self, 28) if need_cropping: @@ -582,18 +539,20 @@ def __init__(self, mode, encoding, num_qubits, classes, data_num=-1, split_circu # Download data from paddlepaddle if mode == DATAMODE_TRAIN: train_dataset = paddle.vision.datasets.MNIST(mode='train') - feature, self.labels = self.filter_class(train_dataset.images, train_dataset.labels, - classes=classes, - data_num=data_num, need_relabel=need_relabel, seed=seed) + feature, self.labels = self.filter_class( + train_dataset.images, train_dataset.labels, + classes=classes, data_num=data_num, need_relabel=need_relabel, seed=seed + ) if need_cropping: feature = _crop(feature, [4, 24]) elif mode == DATAMODE_TEST: test_dataset = paddle.vision.datasets.MNIST(mode='test') # test_dataset.images is now a list of (784,1) shape - feature, self.labels = self.filter_class(test_dataset.images, test_dataset.labels, - classes=classes, - data_num=data_num, need_relabel=need_relabel, seed=seed) + feature, self.labels = self.filter_class( + test_dataset.images, test_dataset.labels, + classes=classes, data_num=data_num, need_relabel=need_relabel, seed=seed + ) if need_cropping: feature = _crop(feature, [4, 24]) @@ -602,8 +561,10 @@ def __init__(self, mode, encoding, num_qubits, classes, data_num=-1, split_circu # Start to encode self.quantum_image_states, self.quantum_image_circuits, self.original_images, self.classical_image_vectors = \ - self.encode(feature, encoding, num_qubits, split_circuit, downscaling_method, target_dimension, - return_state, True) + self.encode( + feature, encoding, num_qubits, split_circuit, + downscaling_method, target_dimension, return_state, True + ) self.labels = np.array(self.labels) def __len__(self): @@ -611,84 +572,64 @@ def __len__(self): class FashionMNIST(VisionDataset): - r""" FashionMNIST 数据集，它继承了 VisionDataset 图片数据集类 - - Attributes: - original_images (ndarray): 图片经过类别过滤，但是还没有降维、补零的特征，是一个一维向量（可调用 ``reshape()`` 方法转成图片） - classical_image_vectors (ndarray): 经过类别过滤和降维、补零等操作之后的特征，并未编码为量子态 - quantum_image_states (paddle.tensor): 经过类别过滤之后的所有特征经编码形成的量子态 - quantum_image_circuits (list): 所有特征编码的电路 - labels (ndarray): 经过类别过滤之后的所有标签 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.dataset import FashionMNIST - - training_data_num=80 - testing_data_num=20 - qubit_num=4 - - # acquiring training dataset - train_dataset = FashionMNIST(mode='train', encoding='pauli_rotation_encoding', num_qubits=qubit_num, classes=[3,6], - data_num=training_data_num,downscaling_method='resize', target_dimension=16, return_state=True) - - # 验acquiring testing dataset - val_dataset = FashionMNIST(mode='test', encoding='pauli_rotation_encoding', num_qubits=qubit_num, classes=[3,6], - data_num=testing_data_num,downscaling_method='resize', target_dimension=16,return_state=True) - - # acquiring features and labels - train_x, train_y = train_dataset.quantum_image_states, train_dataset.labels # paddle.tensor, ndarray - test_x, test_y = val_dataset.quantum_image_states, val_dataset.labels + r"""FashionMNIST quantum dataset. It inherits ``VisionDataset``. - print(train_x[0]) - print(train_y[0]) + Args: + mode: Data mode including ``train`` and ``test``. + encoding: ``angle_encoding`` denotes angle encoding, and one qubit encodes one number with a Ry gate. ``amplitude_encoding`` denotes amplitude encoding; + ``pauli_rotation_encoding`` denotes using SU(3) rotation gate. ``linear_entanglement_encoding``, ``real_entanglement_encoding`` , ``complex_entanglement_encoding`` + and ``IQP_encoding`` encoding methods. + num_qubits: Qubit number. + classes: Classes needed to classify, categories are indicated by numeric labels. + data_num: Data number returned. Defaults to ``-1``. + split_circuit: Whether to split the circuits. If True, every layer of the encoding circuit will be split into a list. Defaults to ``False``. + downscaling_method: Including ``PCA`` and ``resize``. Defaults to ``resize``. + target_dimension: The dimension after downscaling, which is not allowed to surpass the figure size. Defaults to ``-1``. + need_cropping: Whether needed to crop, If ``True``, ``image[0:27][0:27]`` will be cropped to ``image[4:24][4:24]``. Defaults to ``True``. + need_relabel: Whether we need to relabel the labels to 0,1,2… for binary classification.For example [1,2] will be relabeled to [0,1] Defaults to ``True``. + return_state: Whether to return quantum states. Defaults to ``True``. + seed: Select random seed. Defaults to ``0``. + + Raises: + Exception: Data mode can only be train and test. """ - def __init__(self, mode, encoding, num_qubits, classes, data_num=-1, split_circuit=False, - downscaling_method=DOWNSCALINGMETHOD_RESIZE, target_dimension=-1, - need_relabel=True, return_state=True, seed=0): - r""" 构造函数 + def __init__( + self, mode: str, encoding: str, num_qubits: int, classes: list, data_num: Optional[int] = -1, + split_circuit: Optional[bool] = False, downscaling_method: Optional[str] = DOWNSCALINGMETHOD_RESIZE, + target_dimension: Optional[int] = -1, need_relabel: Optional[bool] = True, + return_state: Optional[bool] = True, seed: Optional[int] = 0) -> None: + + r"""Constructor - Args: - mode (str): 数据模式，包括 ``"train"`` 和 ``"test"`` - encoding (str): ``"angle_encoding"`` 表示角度编码，一个量子比特编码一个旋转门； ``"amplitude_encoding"`` 表示振幅编码； - ``"pauli_rotation_encoding"`` 表示SU(3)的角度编码；还有 ``"linear_entangled_encoding"`` 、 - ``"real_entangled_encoding"`` 、 ``"complex_entangled_encoding"`` 三种纠缠编码和 ``"IQP_encoding"`` 编码 - num_qubits (int): 编码后的量子比特数目 - classes (list): 用列表给出需要的类别，类别用数字标签表示，不支持传入名字 - data_num (int): 使用的数据量大小，这样可以不用所有数据都进行编码，这样会很慢 - split_circuit (bool): 是否需要切分电路。除了振幅之外的所有电路都会存在堆叠的情况，如果选择true就将块与块分开 - need_relabel (bool): 将原有类别按照顺序重新标记为0，1，2等新的名字，比如传入 ``[1,2]`` ，重新标记之后变为 ``[0,1]`` ，主要用于二分类 - downscaling_method (str): 包括 ``"PCA"`` 和 ``"resize"`` - target_dimension (int): 降维之后的尺度大小，如果是 ``"PCA"`` ，不能超过图片大小；如果是 ``"resize"`` ，不能超过原图大小 - return_state (bool): 是否返回量子态，如果是 ``False`` 返回量子电路 - seed (int): 随机种子，默认为 ``0`` """ VisionDataset.__init__(self, 28) # Download data from paddlepaddle if mode == DATAMODE_TRAIN: train_dataset = paddle.vision.datasets.FashionMNIST(mode='train') - feature, self.labels = self.filter_class(train_dataset.images, train_dataset.labels, - classes=classes, - data_num=data_num, need_relabel=need_relabel, seed=seed) + feature, self.labels = self.filter_class( + train_dataset.images, train_dataset.labels, + classes=classes,data_num=data_num, need_relabel=need_relabel, seed=seed + ) elif mode == DATAMODE_TEST: test_dataset = paddle.vision.datasets.FashionMNIST(mode='test') # test_dataset.images is now a list of (784,1) shape - feature, self.labels = self.filter_class(test_dataset.images, test_dataset.labels, - classes=classes, - data_num=data_num, need_relabel=need_relabel, seed=seed) + feature, self.labels = self.filter_class( + test_dataset.images, test_dataset.labels, + classes=classes,data_num=data_num, need_relabel=need_relabel, seed=seed + ) else: raise Exception("data mode can only be train and test.") # Start to encode self.quantum_image_states, self.quantum_image_circuits, self.original_images, self.classical_image_vectors = \ - self.encode(feature, encoding, num_qubits, split_circuit, downscaling_method, target_dimension, - return_state, True) + self.encode( + feature, encoding, num_qubits, split_circuit, downscaling_method, target_dimension, + return_state, True + ) self.labels = np.array(self.labels) def __len__(self): @@ -696,106 +637,53 @@ def __len__(self): class SimpleDataset(Dataset): - r""" 用于不需要降维的简单分类数据。用户可以通过继承 ``SimpleDataset`` ，将自己的分类数据变为量子态。下面的几个属性也会被继承。 - - Attributes: - quantum_states (ndarray): 经过类别过滤之后的所有特征经编码形成的量子态 - quantum_circuits (list): 所有特征编码的电路 - origin_feature (ndarray): 经过类别过滤之后的所有特征，并未编码为量子态 - feature (ndarray): ``origin_feature`` 经过了补零之后的特征， ``quantum_states`` 就是将 ``feature`` 编码之后的结果 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.dataset import SimpleDataset - - def circle_data_point_generator(Ntrain, Ntest, boundary_gap, seed_data): - # generate binary classification data with circle boundaries - # The former Ntrain samples are training data, the latter Ntest samples are testing data. - - train_x, train_y = [], [] - num_samples, seed_para = 0, 0 - while num_samples < Ntrain + Ntest: - np.random.seed((seed_data + 10) * 1000 + seed_para + num_samples) - data_point = np.random.rand(2) * 2 - 1 # generator two-dimension vectors in [-1, 1] - - # If the norm is below (0.7 - gap), the data point is mark as zero - if np.linalg.norm(data_point) < 0.7 - boundary_gap / 2: - train_x.append(data_point) - train_y.append(0.) - num_samples += 1 - - # If the norm is over (0.7 + gap), the data point is mark as one - elif np.linalg.norm(data_point) > 0.7 + boundary_gap / 2: - train_x.append(data_point) - train_y.append(1.) - num_samples += 1 - else: - seed_para += 1 + r"""For simple dataset that does not require dimension reduction. You can inherit ``SimpleDataset`` to generate quantum states from your classical datasets. - train_x = np.array(train_x).astype("float64") - train_y = np.array([train_y]).astype("float64").T - - print("The dimension of the training data: x {} 和 y {}".format(np.shape(train_x[0:Ntrain]), np.shape(train_y[0:Ntrain]))) - print("The dimension of the testing data: x {} 和 y {}".format(np.shape(train_x[Ntrain:]), np.shape(train_y[Ntrain:])), "\n") - - return train_x[0:Ntrain], train_y[0:Ntrain], train_x[Ntrain:], train_y[Ntrain:] - - Ntrain = 200 # the size of the training dataset - Ntest = 100 # the size of the testing dataset - boundary_gap = 0.5 # the gap between two classes - seed_data = 2 # fixed seed - - # generate a new dataset - train_x, train_y, test_x, test_y = circle_data_point_generator(Ntrain, Ntest, boundary_gap, seed_data) - encoding="angle_encoding" - num_qubit=2 - dimension=2 - train_x=SimpleDataset(dimension).encode(train_x,encoding,num_qubit) - test_x=SimpleDataset(dimension).encode(test_x,encoding,num_qubit) - - print(train_x[0]) - print(test_x[0]) + Args: + dimension: Dimension of encoding data. - :: """ - def __init__(self, dimension): - r""" 构造函数 - - Args: - dimension (int): 编码数据的维度。 - """ + def __init__(self, dimension: int): Dataset.__init__(self) self.dimension = dimension return - def encode(self, feature, encoding, num_qubits, return_state=True, full_return=False): - r""" 进行编码 + def encode(self, feature: Union[list, np.ndarray], encoding: str, num_qubits: int, + return_state: Optional[bool] = True, full_return: Optional[bool] = False) -> Tuple[np.ndarray, list, np.ndarray, np.ndarray]: + r"""Encode ``feature`` with ``num_qubits`` qubits by ``encoding``. Args: - feature (list/ndarray): 编码的特征，每一个分量都是一个 ndarray 的特征向量 - encoding (str): 编码方法 - num_qubits (int): 编码的量子比特数目 - return_state (bool): 是否返回量子态 + feature: Features needed to encode. + encoding: Encoding methods. + num_qubits: Qubit number. + return_state: Whether to return quantum states. Defaults to ``True``. + full_return: Whether to return quantum_states, quantum_circuits, origin_feature and feature. Defaults to ``False``. + + Raises: + Exception: Invalid type of feature. + Exception: Invalid encoding methods. + Exception: The qubit number is not enough to encode the features. Returns: - tuple: 包含如下元素: - - quantum_states (ndarray): 量子态，只有 ``full_return==True`` 或者 ``return_state==True`` 的时候会返回 - - quantum_circuits (list): 所有特征编码的电路，只有 ``full_return==False`` 或者 ``return_state==True`` 的时候会返回 - - origin_feature (ndarray): 经过类别过滤之后的所有特征，并未编码为量子态，只有 ``return_state==True`` 的时候会返回 - - feature (ndarray): ``origin_feature`` 经过了补零之后的特征， ``quantum_states`` 就是将 ``feature`` 编码之后的结果。 只有 ``return_state==True`` 的时候会返回 - """ + contain these element + - quantum_states: Quantum states, only ``full_return==True`` or ``return_state==True`` will return; + - quantum_circuits: A list of circuits generating quantum states, only ``full_return==True`` or ``return_state==True`` will return; + - origin_feature: One-dimension original vectors without any processing, only ``return_state==True`` will return + - feature: One-dimension original vectors after filling with zero, which are encoded to quantum states. only ``return_state==True`` will return. + """ assert num_qubits > 0 - if encoding in [IQP_ENCODING, COMPLEX_ENTANGLED_ENCODING, REAL_ENTANGLED_ENCODING, - LINEAR_ENTANGLED_ENCODING]: + encoding_list = [ + IQP_ENCODING, COMPLEX_ENTANGLED_ENCODING, + REAL_ENTANGLED_ENCODING, LINEAR_ENTANGLED_ENCODING + ] + if encoding in encoding_list: assert num_qubits > 1 - if type(feature) == np.ndarray: + if isinstance(feature, np.ndarray): self.feature = list(feature) - elif type(feature) is list: + elif isinstance(feature, list): self.feature = feature else: raise Exception("invalid type of feature") @@ -828,93 +716,53 @@ def encode(self, feature, encoding, num_qubits, return_state=True, full_return=F for i in range(len(self.feature)): self.feature[i] = self.feature[i].reshape(-1).astype( np.float64) # now self.images[i] is a numpy with (new_size*new_size,1) shape - self.feature[i] = np.append(self.feature[i], - np.array([0.0] * ( - self.can_describe_dimension - self.dimension))) # now self.images[i] is filled to ``self.can_describe_dimension`` + self.feature[i] = np.append( + self.feature[i], + np.array([0.0] * (self.can_describe_dimension - self.dimension)) + ) # now self.images[i] is filled to ``self.can_describe_dimension`` # Step 3: Encode the data, which must be of float64 type(needed in paddle quantum) self.quantum_states, self.quantum_circuits = self.data2circuit( self.feature, encoding, num_qubits, self.can_describe_dimension, False, # split_circuit=False - return_state) + return_state + ) self.feature = np.array(self.feature) self.quantum_states = np.array(self.quantum_states) if full_return: return self.quantum_states, self.quantum_circuits, self.origin_feature, self.feature - else: - if return_state: - return self.quantum_states - else: - return self.quantum_circuits + if return_state: + return self.quantum_states + return self.quantum_circuits class Iris(SimpleDataset): - r""" Iris 数据集 - - Attributes: - quantum_states (ndarray): 经过类别过滤之后的所有特征经编码形成的量子态 - quantum_circuits (list): 所有特征编码的电路 - origin_feature (ndarray): 经过类别过滤之后的所有特征，并未编码为量子态 - feature (ndarray): ``origin_feature`` 经过了补零之后的特征， ``quantum_states`` 就是将 ``feature`` 编码之后的结果 - target (ndarray): 经过类别过滤之后的所有标签 - train_x (paddle.tensor): 从 ``quantum_states`` 中选出的训练集 - test_x (paddle.tensor): 从 ``quantum_states`` 中选出的测试集 - train_circuits (list): 对应于 ``train_x`` 的编码电路 - test_circuits (list): 对应于 ``test_x`` 的编码电路 - origin_train_x (ndarray): 和 ``train_x`` 对应的经典数据 - origin_test_x (ndarray): 和 ``test_x`` 对应的经典数据 - train_y (ndarray): 对应于 ``train_x`` 的标签 - test_y (ndarray): 对应于 ``test_x`` 的标签 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.dataset import Iris - - test_rate=0.2 - qubit_num=4 - - # Get Iris data, select two classes 0,1, and encode the data into four qubits using angle coding and return the quantum state. - # The proportion of the test set is 0.2. - iris =Iris (encoding='angle_encoding', num_qubits=qubit_num, test_rate=test_rate,classes=[0,1], return_state=True) - - # Get the features and labels of the classical Iris dataset - origin_feature=iris.origin_feature # ndarray - origin_target=iris.target - - # Gets the quantum states and labels of the training and test datasets - train_x, train_y = iris.train_x, iris.train_y # paddle.tensor, ndarray - test_x, test_y = iris.test_x, iris.test_y - - testing_data_num=len(test_y) - training_data_num=len(train_y) - print(training_data_num) - print(testing_data_num) - """ - - def __init__(self, encoding, num_qubits, classes, test_rate=0.2, need_relabel=True, return_state=True): - r""" 构造函数 + r"""Iris dataset - Args: - encoding (str): ``"angle_encoding"`` 表示角度编码，一个量子比特编码一个旋转门； ``"amplitude_encoding"`` 表示振幅编码； - ``"pauli_rotation_encoding"`` 表示SU(3)的角度编码；还有 ``"linear_entangled_encoding"`` 、 - ``"real_entangled_encoding"`` 、 ``"complex_entangled_encoding"`` 三种纠缠编码和 ``"IQP_encoding"`` 编码 - num_qubits (int): 量子比特数目 - classes (list): 用列表给出需要的类别，类别用数字标签表示，不支持传入名字 - test_rate (float): 测试集的占比 - need_relabel (bool): 将原有类别按照顺序重标记为 0、1、2 等新的名字，比如传入 ``[1,2]`` ，重标记之后变为 ``[0,1]`` ，主要用于二分类 - return_state (bool): 是否返回量子态，如果是 ``False`` 返回量子电路 - """ + Args: + encoding: ``angle_encoding`` denotes angle encoding, and one qubit encodes one number with a Ry gate. ``amplitude_encoding`` denotes amplitude encoding; + ``pauli_rotation_encoding`` denotes using SU(3) rotation gate. ``linear_entanglement_encoding``, ``real_entanglement_encoding`` , ``complex_entanglement_encoding`` + and ``IQP_encoding`` encoding methods. + num_qubits: Qubit number. + classes: Classes needed to classify, categories are indicated by numeric labels. + test_rate: The proportion of the testing dataset. Defaults to ``0.2``. + need_relabel: Whether we need to relabel the labels to 0,1,2… for binary classification.For example [1,2] will be relabeled to [0,1]. Defaults to ``True``. + return_state: Whether to return quantum states. Defaults to ``True``. + seed: Select random seed. Defaults to ``0``. + + """ + def __init__(self, encoding: str, num_qubits: int, classes: list, test_rate: Optional[float] = 0.2, + need_relabel: Optional[bool] = True, return_state: Optional[bool] = True, seed: Optional[int] = 0) -> None: SimpleDataset.__init__(self, dimension=4) # Download data from scikit-learn iris = datasets.load_iris() self.dimension = 4 # dimension of Iris dataset - feature, self.target = self.filter_class(iris.data, iris.target, classes, -1, - need_relabel) # here -1 means all data + feature, self.target = self.filter_class( + iris.data, iris.target, classes, -1,need_relabel + ) # here -1 means all data self.target = np.array(self.target) # Start to encode @@ -922,7 +770,6 @@ def __init__(self, encoding, num_qubits, classes, test_rate=0.2, need_relabel=Tr self.encode(feature, encoding, num_qubits, return_state, True) # Divide training and testing dataset - seed = int(time.time()) self.train_x, self.test_x, self.train_y, self.test_y = \ train_test_split(self.quantum_states, self.target, test_size=test_rate, random_state=seed) @@ -940,61 +787,21 @@ def __init__(self, encoding, num_qubits, classes, test_rate=0.2, need_relabel=Tr class BreastCancer(SimpleDataset): - r"""BreastCancer 数据集，569 组数据 30 维，只有两类。 - - Attributes: - quantum_states (ndarray): 经过类别过滤之后的所有特征经编码形成的量子态 - quantum_circuits (list): 所有特征编码的电路 - origin_feature (ndarray): 经过类别过滤之后的所有特征，并未编码为量子态 - feature (ndarray): ``origin_feature`` 经过了补零之后的特征， ``quantum_states`` 就是将 ``feature`` 编码之后的结果 - target (ndarray): 经过类别过滤之后的所有标签 - train_x (paddle.tensor): 从 ``quantum_states`` 中选出的训练集 - test_x (paddle.tensor): 从 ``quantum_states`` 中选出的测试集 - train_circuits (list): 对应于 ``train_x`` 的编码电路 - test_circuits (list): 对应于 ``test_x`` 的编码电路 - origin_train_x (ndarray): 和 ``train_x`` 对应的经典数据 - origin_test_x (ndarray): 和 ``test_x`` 对应的经典数据 - train_y (ndarray): 对应于 ``train_x`` 的标签 - test_y (ndarray): 对应于 ``test_x`` 的标签 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.dataset import BreastCancer - - test_rate = 0.2 - qubit_num = 4 - - # Get BreastCancer data, select two classes 0,1, and encode the data into four qubits using angle coding and return the quantum state. - # The proportion of the test set is 0.2. - breast_cancer =BreastCancer(encoding='angle_encoding', num_qubits=qubit_num, test_rate=test_rate, return_state=True) - - # Get the features and labels of the classical BreastCancer dataset - origin_feature=breast_cancer.origin_feature # ndarray - origin_target=breast_cancer.target - - # Gets the quantum states and labels of the training and test datasets - train_x, train_y = breast_cancer.train_x, breast_cancer.train_y # paddle.tensor, ndarray - test_x, test_y = breast_cancer.test_x, breast_cancer.test_y - - testing_data_num=len(test_y) - training_data_num=len(train_y) - print(training_data_num) - print(testing_data_num) - """ + r"""BreastCancer quantum dataset. - def __init__(self, encoding, num_qubits, test_rate=0.2, return_state=True): - r"""构造函数 + Args: + encoding: ``angle_encoding`` denotes angle encoding, and one qubit encodes one number with a Ry gate. ``amplitude_encoding`` denotes amplitude encoding; + ``pauli_rotation_encoding`` denotes using SU(3) rotation gate. ``linear_entanglement_encoding``, ``real_entanglement_encoding`` , ``complex_entanglement_encoding`` + and ``IQP_encoding`` encoding methods. + num_qubits: Qubit number. + test_rate:The proportion of the testing dataset. Defaults to ``0.2``. + return_state: Whether to return quantum states. Defaults to ``True``. + seed: Select random seed. Defaults to ``0``. - Args: - encoding (str): ``"angle_encoding"`` 表示角度编码，一个量子比特编码一个旋转门； ``"amplitude_encoding"`` 表示振幅编码； - ``"pauli_rotation_encoding"`` 表示SU(3)的角度编码；还有 ``"linear_entangled_encoding"`` 、 - ``"real_entangled_encoding"`` 、 ``"complex_entangled_encoding"`` 三种纠缠编码和 ``"IQP_encoding"`` 编码 - num_qubits (int): 量子比特数目 - test_rate (float): 测试集的占比 - return_state (bool): 是否返回量子态，如果是 ``False`` 返回量子电路 - """ + """ + + def __init__(self, encoding: str, num_qubits: int, test_rate: Optional[float] =0.2, + return_state: Optional[bool] = True, seed: Optional[int] = 0) -> None: SimpleDataset.__init__(self, dimension=30) # The dimension is 30 self.dimension = 30 @@ -1010,18 +817,14 @@ def __init__(self, encoding, num_qubits, test_rate=0.2, return_state=True): self.encode(feature, encoding, num_qubits, return_state, True) # Divide training and testing dataset - seed = int(time.time()) self.train_x, self.test_x, self.train_y, self.test_y = \ - train_test_split(self.quantum_states, self.target, test_size=test_rate, - random_state=seed) + train_test_split(self.quantum_states, self.target, test_size=test_rate, random_state=seed) self.train_circuits, self.test_circuits, temp1, temp2 = \ - train_test_split(self.quantum_circuits, self.target, test_size=test_rate, - random_state=seed) + train_test_split(self.quantum_circuits, self.target, test_size=test_rate, random_state=seed) self.origin_train_x, self.origin_test_x, temp1, temp2 = \ - train_test_split(self.origin_feature, self.target, test_size=test_rate, - random_state=seed) + train_test_split(self.origin_feature, self.target, test_size=test_rate, random_state=seed) if return_state: self.train_x = paddle.to_tensor(self.train_x) self.test_x = paddle.to_tensor(self.test_x) diff --git a/paddle_quantum/expecval.py b/paddle_quantum/expecval.py deleted file mode 100644 index 58269d6..0000000 --- a/paddle_quantum/expecval.py +++ /dev/null @@ -1,143 +0,0 @@ -# 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 index 93076bf..4deea18 100644 --- a/paddle_quantum/finance.py +++ b/paddle_quantum/finance.py @@ -1,3 +1,4 @@ +# !/usr/bin/env python3 # Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -12,13 +13,16 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" Functions and data simulator class of quantum finance. """ +from datetime import datetime +from typing import Optional import fastdtw +import networkx import numpy as np -from paddle_quantum.utils import Hamiltonian +import paddle_quantum __all__ = [ "DataSimulator", @@ -29,17 +33,14 @@ class DataSimulator: - r"""用于生成和计算投资组合优化和投资分散化问题要用的数据和相关参数 - + r"""Used to generate data and calculate relevant parameters for portfolio optimization and portfolio diversification problems. + + Args: + stocks: A list of names of investable stocks + start: The start date of the trading day when the stock data is randomly generated. Defaults to ``None``. + end: The end date of the trading day when the stock data is randomly generated. Defaults to ``None``. """ - def __init__(self, stocks, start=None, end=None): - r"""构造函数，用于实例化一个 ``DataSimulator`` 对象。 - - Args: - stocks (list): 表示所有可投资股票的名字 - start (datetime): 默认为 ``None``，表示随机生成股票数据时交易日的起始日期 - end (datetime): 默认为 ``None``，表示随机生成股票数据时交易日的结束日期 - """ + def __init__(self, stocks: list, start: Optional[datetime] = None, end: Optional[datetime] = None): self._n = len(stocks) self._stocks = stocks @@ -52,11 +53,11 @@ def __init__(self, stocks, start=None, end=None): self.asset_return_mean = None self.asset_return_cov = None - def set_data(self, data): - r"""决定实验使用的数据是随机生成的还是用户本地输入的 + def set_data(self, data: list) -> None: + r"""Decide which data source to use: randomly generated or locally entered. Args: - data (list): 用户输入的股票数据 + data: Stock data entered by the user. """ if len(data) == self._n: self._data = data @@ -64,11 +65,11 @@ def set_data(self, data): print("invalid data, data is still empty.") self._data = [] - def randomly_generate(self): - r"""根据开始日期和结束日期随机生成用于实验的股票数据 + def randomly_generate(self) -> None: + r"""Randomly generate stock data for experiments based on start date and end date. Note: - 若要随机生成股票数据，需要以 ``datetime`` 包中的格式指定开始日期和结束日期，如 ``start = datetime.datetime(2016, 1, 1)`` + To generate random stock data, you need to specify the start date and end date in the format of the ``datetime`` package, e.g. ``start = datetime.datetime(2016, 1, 1)``. """ if self._start and self._end: @@ -86,11 +87,11 @@ def randomly_generate(self): 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"""用于计算所有可投资股票的平均投资回报率 + def get_asset_return_mean_vector(self) -> list: + r"""Calculate expected return of each stock. Returns: - list: 所有可投资的股票的平均投资回报率 + Expected return of all investable stocks. """ returns = [] for i in range(self._n): @@ -102,11 +103,11 @@ def get_asset_return_mean_vector(self): return self.asset_return_mean - def get_asset_return_covariance_matrix(self): - r"""用于计算所有可投资股票回报率之间的协方差矩阵 + def get_asset_return_covariance_matrix(self) -> list: + r"""Calculate the covariance matrix between the returns of each stock. Returns: - list: 所有可投资股票回报率之间的协方差矩阵 + The covariance matrix between the returns of each stock. """ returns = [] for i in range(self._n): @@ -118,35 +119,35 @@ def get_asset_return_covariance_matrix(self): return self.asset_return_cov - def get_similarity_matrix(self): - r"""计算各股票之间的相似矩阵 + def get_similarity_matrix(self) -> list: + r"""Calculate the similarity matrix among stocks. - 通过动态时间规整算法（Dynamic Time Warping, DTW）计算两股票之间的相似性 + The Dynamic Time Warping algorithm (DTW) is used to calculate the similarity between two stocks. Returns: - list: 各股票间的相似矩阵 + The similarity matrix among stocks. """ - self.rho = np.zeros((self._n, self._n)) + rho = np.zeros((self._n, self._n)) for i in range(0, self._n): - self.rho[i, i] = 1 + 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 + rho[i, j] = curr_rho + rho[j, i] = curr_rho - return self.rho + return rho -def portfolio_optimization_hamiltonian(penalty, mu, sigma, q, budget): - r"""构建投资组合优化问题的哈密顿量 +def portfolio_optimization_hamiltonian(penalty: int, mu: list, sigma: list, q: float, budget: int) -> paddle_quantum.Hamiltonian: + r"""Construct the hamiltonian of the portfolio optimization problem. Args: - penalty (int): 惩罚参数 - mu (list): 各股票的预期回报率 - sigma (list): 各股票回报率间的协方差矩阵 - q (float): 投资股票的风险 - budget (int): 投资预算, 即要投资的股票数量 + penalty: Penalty parameter. + mu: Expected return of each stock. + sigma: The covariance matrix between the returns of each stock. + q: Risk appetite of the decision maker. + budget: Budget, i.e. the number of stocks to be invested. .. math:: @@ -154,57 +155,57 @@ def portfolio_optimization_hamiltonian(penalty, mu, sigma, q, budget): Hint: - 将布尔变量 :math:`x_i` 映射到哈密顿矩阵上，:math:`x_i \mapsto \frac{I-Z_i}{2}` + Mapping Boolean variables :math:`x_i` to Hamiltonian matrices under :math:`x_i \mapsto \frac{I-Z_i}{2}`. Returns: - Hamiltonian: 投资组合优化问题的哈密顿量 + The hamiltonian of the portfolio optimization problem. """ n = len(mu) - H_C_list1 = [] - for i in range(n): - for j in range(n): + h_c_list1 = [] + for i in range(0, n): + for j in range(0, n): sigma_ij = sigma[i][j] - H_C_list1.append([sigma_ij / 4, 'I']) + h_c_list1.append([sigma_ij / 4, 'I']) if i != j: - H_C_list1.append([sigma_ij / 4, 'Z' + str(i) + ',Z' + str(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) + 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(0, 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(0, 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(0, 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 = paddle_quantum.Hamiltonian(h_c_list) return po_hamiltonian -def portfolio_diversification_hamiltonian(penalty, rho, q): - r"""构建投资组合分散化问题的哈密顿量 +def portfolio_diversification_hamiltonian(penalty: int, rho: list, q: int) -> paddle_quantum.Hamiltonian: + r"""Construct the hamiltonian of the portfolio diversification problem. Args: - penalty (int): 惩罚参数 - rho (list): 各股票间的相似矩阵 - q (int): 股票聚类的类别数 + penalty: Penalty parameter. + rho: The similarity matrix among stocks. + q: Number of categories for stock clustering. .. math:: @@ -214,144 +215,144 @@ def portfolio_diversification_hamiltonian(penalty, rho, q): \end{aligned} Hint: - 将布尔变量 :math:`x_{ij}` 映射到哈密顿矩阵上，:math:`x_{ij} \mapsto \frac{I-Z_{ij}}{2}` + Mapping Boolean variables :math:`x_{ij}` to the Hamiltonian matrices under :math:`x_{ij} \mapsto \frac{I-Z_{ij}}{2}` Returns: - Hamiltonian: 投资组合分散化问题的哈密顿量 + The hamiltonian of the portfolio diversification problem. """ n = len(rho) - H_C_list1 = [] - for i in range(n): - for j in range(n): + h_c_list1 = [] + for i in range(0, n): + for j in range(0, 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)]) + 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(0, 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)]) + 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(0, n): + h_c_list3.append([1, 'I']) + for j in range(0, 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) + 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(0, 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(0, n): + for j in range(0, 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 = paddle_quantum.Hamiltonian(h_c_list) return pd_hamiltonian -def arbitrage_opportunities_hamiltonian(g, penalty, n, K): - r"""构建最佳套利机会问题的哈密顿量 +def arbitrage_opportunities_hamiltonian(g: networkx.DiGraph, penalty: int, n: int, k: int) -> paddle_quantum.Hamiltonian: + r"""Construct the hamiltonian of the arbitrage opportunity optimization problem. Args: - g (networkx.DiGraph): 不同货币市场间转换的图形化表示 - A (int): 惩罚参数 - n (int): 货币种类的数量，即图 g 中的顶点数量 - K (int): 套利回路中包含的顶点数 + g: Graphical representation of conversions between different markets. + penalty: Penalty parameter. + n: Number of currency types, i.e. number of vertices in the graph g. + k: Number of vertices contained in the arbitrage loop. .. 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}` + Mapping Boolean variables :math:`x_{i,k}` to the Hamiltonian matrices under :math:`x_{i,k} \mapsto \frac{I-Z_{i,k}}{2}`. Returns: - Hamiltonian: 最佳套利机会问题的哈密顿量 + The hamiltonian of the arbitrage opportunity optimization problem. """ nodes = list(g.nodes) - H_C_list1 = [] - for (i, c) in enumerate(nodes): - for (j, cc) in enumerate(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 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)]) + 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): + 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_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 = [] + 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)]) + 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) + 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 = paddle_quantum.Hamiltonian(h_c_list) return ao_hamiltonian diff --git a/paddle_quantum/fisher.py b/paddle_quantum/fisher.py new file mode 100644 index 0000000..43b11ea --- /dev/null +++ b/paddle_quantum/fisher.py @@ -0,0 +1,405 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the class for the fisher information. +""" + +from typing import Optional, Tuple, Union, List +import numpy as np +import paddle +from tqdm import tqdm +from scipy.special import logsumexp +from .ansatz import Circuit +import paddle_quantum + + +class QuantumFisher: + r"""Quantum fisher information (QFI) & related calculators. + + Args: + cir: Parameterized quantum circuits requiring calculation of quantum Fisher information. + + Note: + This class does not fit the situation when parameters among gates are correlated, such as control-gates. + + """ + def __init__(self, cir: Circuit): + self.cir = cir + paddle_quantum.set_backend('state_vector') + + def get_qfisher_matrix(self) -> np.ndarray: + r"""Use parameter shift rule of order 2 to calculate the matrix of QFI. + + Returns: + Matrix of QFI. + + .. code-block:: python + + import paddle + from paddle_quantum.ansatz import Circuit + from paddle_quantum.fisher import QuantumFisher + + cir = Circuit(1) + zero = paddle.zeros([1], dtype="float64") + cir.ry(0, param=zero) + cir.rz(0, param=zero) + + qf = QuantumFisher(cir) + qfim = qf.get_qfisher_matrix() + print(f'The QFIM at {cir.param.tolist()} is \n {qfim}.') + + :: + + The QFIM at [0.0, 0.0] is + [[1. 0.] + [0. 0.]]. + + """ + # Get the real-time parameters from the Circuit class + list_param = self.cir.param + num_param = len(list_param) + # Initialize a numpy array to record the QFIM + qfim = np.zeros((num_param, num_param)) + # Assign the signs corresponding to the four terms in a QFIM element + list_sign = [[1, 1], [1, -1], [-1, 1], [-1, -1]] + # Run the circuit and record the current state vector + psi = self.cir().numpy() + # For each QFIM element + for i in range(0, num_param): + for j in range(i, num_param): + # For each term in each element + for sign_i, sign_j in list_sign: + # Shift the parameters by pi/2 * sign + list_param[i] += np.pi / 2 * sign_i + list_param[j] += np.pi / 2 * sign_j + # Update the parameters in the circuit + self.cir.update_param(list_param) + # Run the shifted circuit and record the shifted state vector + psi_shift = self.cir().numpy() + # Calculate each term as the fidelity with a sign factor + qfim[i][j] += abs(np.vdot( + psi_shift, psi))**2 * sign_i * sign_j * (-0.5) + # De-shift the parameters + list_param[i] -= np.pi / 2 * sign_i + list_param[j] -= np.pi / 2 * sign_j + self.cir.update_param(list_param) + if i != j: + # The QFIM is symmetric + qfim[j][i] = qfim[i][j] + + return qfim + + def get_qfisher_norm(self, direction: np.ndarray, step_size: Optional[float] = 0.01) -> float: + r"""Use finite difference rule to calculate the projection norm of QFI along particular direction. + + Args: + direction: A direction represented by a vector. + step_size: Step size of the finite difference rule. Defaults to ``0.01``。 + + Returns: + Projection norm. + + .. code-block:: python + + import paddle + from paddle_quantum.ansatz import Circuit + from paddle_quantum.fisher import QuantumFisher + + cir = Circuit(2) + zero = paddle.zeros([1], dtype="float64") + cir.ry(0, param=zero) + cir.ry(1, param=zero) + cir.cnot(qubits_idx=[0, 1]) + cir.ry(0, param=zero) + cir.ry(1, param=zero) + + qf = QuantumFisher(cir) + v = [1,1,1,1] + qfi_norm = qf.get_qfisher_norm(direction=v) + print(f'The QFI norm along {v} at {cir.param.tolist()} is {qfi_norm:.7f}') + + :: + + The QFI norm along [1, 1, 1, 1] at [0.0, 0.0, 0.0, 0.0] is 6.0031546 + + """ + # Get the real-time parameters + list_param = self.cir.param + # Run the circuit and record the current state vector + psi = self.cir().numpy() + # Check whether the length of the input direction vector is equal to the number of the variational parameters + assert len(list_param) == len( + direction + ), "the length of direction vector should be equal to the number of the parameters" + # Shift the parameters by step_size * direction + array_params_shift = np.array( + list_param) + np.array(direction) * step_size + # Update the parameters in the circuit + self.cir.update_param(array_params_shift) + # Run the shifted circuit and record the shifted state vector + psi_shift = self.cir().numpy() + # Calculate quantum Fisher-Rao norm along the given direction + qfisher_norm = (1 - abs(np.vdot(psi_shift, psi))**2) * 4 / step_size**2 + # De-shift the parameters and update + self.cir.update_param(list_param) + + return qfisher_norm + + def get_eff_qdim(self, num_param_samples: Optional[int] = 4, tol: Optional[float] = None) -> int: + r"""Calculate the effective quantum dimension, i.e. the maximum rank of QFI matrix in the whole parameter space. + + Args: + num_param_samples: Number of samples to estimate the dimension. Defaults to ``4``. + tol: Minimum tolerance of the singular values to be 0. Defaults to ``None``, with the same meaning + as in ``numpy.linalg.matrix_rank()``. + + Returns: + Effective quantum dimension of the quantum circuit. + + .. code-block:: python + + import paddle + from paddle_quantum.ansatz import Circuit + from paddle_quantum.fisher import QuantumFisher + + cir = Circuit(1) + zero = paddle.zeros([1], dtype="float64") + cir.rz(0, param=zero) + cir.ry(0, param=zero) + + qf = QuantumFisher(cir) + print(cir) + print(f'The number of parameters of -Rz-Ry- is {len(cir.param.tolist())}') + print(f'The effective quantum dimension of -Rz-Ry- is {qf.get_eff_qdim()}') + + :: + + --Rz(0.000)----Ry(0.000)-- + + The number of parameters of -Rz-Ry- is 2 + The effective quantum dimension of -Rz-Ry- is 1 + """ + # Get the real-time parameters + list_param = self.cir.param.tolist() + num_param = len(list_param) + # Generate random parameters + param_samples = 2 * np.pi * np.random.random( + (num_param_samples, num_param)) + # Record the ranks + list_ranks = [] + # Here it has been assumed that the set of points that do not maximize the rank of QFIMs, as singularities, form a null set. + # Thus one can find the maximal rank using a few samples. + for param in param_samples: + # Set the random parameters + self.cir.update_param(param) + # Calculate the ranks + list_ranks.append(self.get_qfisher_rank(tol)) + # Recover the original parameters + self.cir.update_param(list_param) + + return max(list_ranks) + + def get_qfisher_rank(self, tol: Optional[float] = None) -> int: + r"""Calculate the rank of the QFI matrix. + + Args: + tol: Minimum tolerance of the singular values to be 0. Defaults to ``None``, with the same meaning + as in ``numpy.linalg.matrix_rank()``. + + Returns: + Rank of the QFI matrix. + """ + qfisher_rank = np.linalg.matrix_rank(self.get_qfisher_matrix().astype('float64'), + 1e-6, + hermitian=True) + return qfisher_rank + + +class ClassicalFisher: + r"""Classical fisher information (CFI) & related calculators. + + Args: + model: Instance of the classical or quantum neural network model. + num_thetas: Number of the parameter sets. + num_inputs: Number of the input samples. + model_type: Model type is ``'classical'`` or ``'quantum'``. Defaults to ``'quantum'``. + **kwargs: including + + - size: list of sizes of classical NN units + - num_qubits: number of qubits of quantum NN + - depth: depth of quantum NN + - encoding: ``IQP`` or ``re-uploading`` encoding of quantum NN + + Raises: + ValueError: Unsupported encoding. + ValueError: Unsupported model type. + """ + def __init__(self, + model: paddle.nn.Layer, + num_thetas: int, + num_inputs: int, + model_type: str = 'quantum', + **kwargs: Union[List[int], int, str]): + self.model = model + self.num_thetas = num_thetas + self.num_inputs = num_inputs + self._model_type = model_type + if self._model_type == 'classical': + layer_dims = kwargs['size'] + self.model_args = [layer_dims] + self.input_size = layer_dims[0] + self.output_size = layer_dims[-1] + self.num_params = sum(layer_dims[i] * layer_dims[i + 1] + for i in range(len(layer_dims) - 1)) + elif self._model_type == 'quantum': + num_qubits = kwargs['num_qubits'] + depth = kwargs['depth'] + # Supported QNN encoding: ‘IQP' and 're-uploading' + encoding = kwargs['encoding'] + self.model_args = [num_qubits, depth, encoding] + self.input_size = num_qubits + # Default dimension of output layer = 1 + self.output_size = 1 + # Determine the number of model parameters for different encoding types + if encoding == 'IQP': + self.num_params = 3 * depth * num_qubits + elif encoding == 're-uploading': + self.num_params = 3 * (depth + 1) * num_qubits + else: + raise ValueError('Non-existent encoding method') + else: + raise ValueError( + 'The model type should be equal to either classical or quantum' + ) + + # Generate random data + np.random.seed(0) + x = np.random.normal(0, 1, size=(num_inputs, self.input_size)) + # Use the same input data for each theta set + self.x = np.tile(x, (num_thetas, 1)) + + def get_gradient(self, x: Union[np.ndarray, paddle.Tensor]) -> np.ndarray: + r"""Calculate the gradients with respect to the variational parameters of the output layer. + + Args: + x: Input samples. + + Returns: + Gradient with respect to the variational parameters of the output layer with + shape [num_inputs, dimension of the output layer, num_thetas]. + """ + if not paddle.is_tensor(x): + x = paddle.to_tensor(x, stop_gradient=True) + gradvectors = [] + seed = 0 + + pbar = tqdm(desc="running in get_gradient: ", + total=len(x), + ncols=100, + ascii=True) + + for m in range(len(x)): + pbar.update(1) + if m % self.num_inputs == 0: + seed += 1 + paddle.seed(seed) + net = self.model(*self.model_args) + output = net(x[m]) + logoutput = paddle.log(output) + grad = [] + for i in range(self.output_size): + net.clear_gradients() + logoutput[i].backward(retain_graph=True) + grads = [] + for param in net.parameters(): + grads.append(param.grad.reshape((-1, ))) + gr = paddle.concat(grads) + grad.append(gr * paddle.sqrt(output[i])) + jacobian = paddle.concat(grad) + # Jacobian matrix corresponding to each data point + jacobian = paddle.reshape(jacobian, + (self.output_size, self.num_params)) + gradvectors.append(jacobian.detach().numpy()) + + pbar.close() + + return gradvectors + + def get_cfisher(self, gradients: np.ndarray) -> np.ndarray: + r"""Use the Jacobian matrix to calculate the CFI matrix. + + Args: + gradients: Gradients with respect to the variational parameter of the output layer. + + Returns: + CFI matrix with shape [num_inputs, dimension of the output layer, num_theta]. + """ + fishers = np.zeros((len(gradients), self.num_params, self.num_params)) + for i in range(len(gradients)): + grads = gradients[i] + temp_sum = np.zeros( + (self.output_size, self.num_params, self.num_params)) + for j in range(self.output_size): + temp_sum[j] += np.array( + np.outer(grads[j], np.transpose(grads[j]))) + fishers[i] += np.sum(temp_sum, axis=0) + + return fishers + + def get_normalized_cfisher(self) -> Tuple[np.ndarray, float]: + r"""Calculate the normalized CFI matrix. + + Returns: + contains elements + + - CFI matrix with shape [num_inputs, num_theta, num_theta] + - its trace + + """ + grads = self.get_gradient(self.x) + fishers = self.get_cfisher(grads) + fisher_trace = np.trace(np.average(fishers, axis=0)) + # Average over input data + fisher = np.average(np.reshape(fishers, + (self.num_thetas, self.num_inputs, + self.num_params, self.num_params)), + axis=1) + normalized_cfisher = self.num_params * fisher / fisher_trace + + return normalized_cfisher, fisher_trace + + def get_eff_dim(self, normalized_cfisher: np.ndarray, list_num_samples: List[int], gamma: Optional[int] = 1) -> List[int]: + r"""Calculate the classical effective dimension. + + Args: + normalized_cfisher: Normalized CFI matrix. + list_num_samples: List of different numbers of samples. + gamma: A parameter in the effective dimension. Defaults to ``1``. + + Returns: + Classical effective dimensions for different numbers of samples. + """ + eff_dims = [] + for n in list_num_samples: + one_plus_F = np.eye( + self.num_params) + normalized_cfisher * gamma * n / ( + 2 * np.pi * np.log(n)) + det = np.linalg.slogdet(one_plus_F)[1] + r = det / 2 + eff_dims.append(2 * (logsumexp(r) - np.log(self.num_thetas)) / + np.log(gamma * n / (2 * np.pi * np.log(n)))) + + return eff_dims diff --git a/paddle_quantum/gate/__init__.py b/paddle_quantum/gate/__init__.py new file mode 100644 index 0000000..396e934 --- /dev/null +++ b/paddle_quantum/gate/__init__.py @@ -0,0 +1,36 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The module of the quantum gates. +""" + +from . import functional +from .base import Gate +from .clifford import Clifford, compose_clifford_circuit +from .single_qubit_gate import H, S, T, X, Y, Z, P, RX, RY, RZ, U3 +from .multi_qubit_gate import CNOT, CX, CY, CZ, SWAP +from .multi_qubit_gate import CP, CRX, CRY, CRZ, CU, RXX, RYY, RZZ +from .multi_qubit_gate import MS, CSWAP, Toffoli +from .multi_qubit_gate import UniversalTwoQubits, UniversalThreeQubits +from .custom import Oracle, ControlOracle +from .layer import SuperpositionLayer, WeakSuperpositionLayer +from .layer import LinearEntangledLayer, RealEntangledLayer, ComplexEntangledLayer +from .layer import RealBlockLayer, ComplexBlockLayer +from .layer import QAOALayer +from .encoding import BasisEncoding +from .encoding import AmplitudeEncoding +from .encoding import AngleEncoding +from .encoding import IQPEncoding diff --git a/paddle_quantum/gate/base.py b/paddle_quantum/gate/base.py new file mode 100644 index 0000000..8499607 --- /dev/null +++ b/paddle_quantum/gate/base.py @@ -0,0 +1,49 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the basic class for the quantum gates. +""" + +import paddle_quantum + + +class Gate(paddle_quantum.Operator): + r"""Basis class for quantum gates. + + Args: + depth: Number of layers. Defaults to 1. + backend: Backend on which the gates are executed. Defaults to None. + dtype: Type of data. Defaults to None. + name_scope: Prefix name used by the layer to name parameters. If prefix is "my_layer", parameter name in + MyLayer can be "my_layer_0.w_n", where "w" is the parameter base name and "n" is an unique suffix + auto-generated. If ``None``, prefix name will be snake cased class name. Defaults to ``None``. + """ + def __init__( + self, depth: int = 1, backend: paddle_quantum.Backend = None, dtype: str = None, name_scope: str = None + ): + super().__init__(backend, dtype, name_scope) + self.depth = depth + + def forward(self, *inputs, **kwargs): + raise NotImplementedError + + def __setattr__(self, name, value): + super().__setattr__(name, value) + if isinstance(value, paddle_quantum.Operator): + if value.backend is None: + value.backend = paddle_quantum.get_backend() if self.backend is None else self.backend + if value.dtype is None: + value.dtype = paddle_quantum.get_dtype() if self.dtype is None else self.dtype diff --git a/paddle_quantum/gate/clifford.py b/paddle_quantum/gate/clifford.py new file mode 100644 index 0000000..33f12b4 --- /dev/null +++ b/paddle_quantum/gate/clifford.py @@ -0,0 +1,311 @@ +# !/usr/bin/env python3 +# 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. + +r""" +Class for randomly generating a Clifford operator. +""" + +import numpy as np +import paddle_quantum + +__all__ = [ + "Clifford", + "compose_clifford_circuit" +] + + +def _random_clifford(num_qubits): + assert (num_qubits <= 100), "too many qubits" + + # Some constant matrices + bigzero = np.zeros((2 * num_qubits, 2 * num_qubits), dtype=int) + nzero = np.zeros((num_qubits, num_qubits), dtype=int) + id_mat = np.identity(num_qubits, dtype=int) + + h, s = _sample_qmallows(num_qubits) + gamma1 = np.copy(nzero) + delta1 = np.copy(id_mat) + gamma2 = np.copy(nzero) + delta2 = np.copy(id_mat) + + for i in range(num_qubits): + gamma2[i, i] = np.random.randint(2) + if h[i] == 1: + gamma1[i, i] = np.random.randint(2) + + # Constraints for canonical form + for j in range(num_qubits): + for i in range(j + 1, num_qubits): + b = np.random.randint(2) + gamma2[i, j] = b + gamma2[j, i] = b + delta2[i, j] = np.random.randint(2) + if h[i] == 1 and h[j] == 1: + b = np.random.randint(2) + gamma1[i, j] = b + gamma1[j, i] = b + if h[i] == 1 and h[j] == 0 and s[i] < s[j]: + b = np.random.randint(2) + gamma1[i, j] = b + gamma1[j, i] = b + if h[i] == 0 and h[j] == 1 and s[i] > s[j]: + b = np.random.randint(2) + gamma1[i, j] = b + gamma1[j, i] = b + if h[i] == 0 and h[j] == 1: + delta1[i, j] = np.random.randint(2) + + if h[i] == 1 and h[j] == 1 and s[i] > s[j]: + delta1[i, j] = np.random.randint(2) + + if h[i] == 0 and h[j] == 0 and s[i] < s[j]: + delta1[i, j] = np.random.randint(2) + + # Compute stabilizer table + st1 = np.matmul(gamma1, delta1) + st2 = np.matmul(gamma2, delta2) + inv1 = np.linalg.inv(np.transpose(delta1)) + inv2 = np.linalg.inv(np.transpose(delta2)) + f_1 = np.block([[delta1, nzero], [st1, inv1]]) + f_2 = np.block([[delta2, nzero], [st2, inv2]]) + f_1 = f_1.astype(int) % 2 + f_2 = f_2.astype(int) % 2 + unitary = np.copy(bigzero) + + for i in range(num_qubits): + unitary[i, :] = f_2[s[i], :] + unitary[i + num_qubits, :] = f_2[s[i] + num_qubits, :] + + # Apply Hadamard layer to the stabilizer table + for i in range(num_qubits): + if h[i] == 1: + unitary[(i, i + num_qubits), :] = unitary[(i + num_qubits, i), :] + + gamma = [gamma1, gamma2] + delta = [delta1, delta2] + return np.matmul(f_1, unitary) % 2, gamma, delta, h, s + + +def _sample_qmallows(num_qubits): + # Hadamard layer + h = np.zeros(num_qubits, dtype=int) + # S layer + s = np.zeros(num_qubits, dtype=int) + a = list(range(0, num_qubits)) + + for i in range(0, num_qubits): + m = num_qubits - i + r = np.random.uniform(0, 1) + index = int(2 * m - np.ceil(np.log(r * (4 ** m - 1) + 1) / np.log(2.0))) + h[i] = 1 * (index < m) + if index < m: + k = index + else: + k = 2 * m - index - 1 + s[i] = a[k] + del a[k] + return h, s + + +def compose_clifford_circuit(clifd1: 'Clifford', clifd2: 'Clifford') -> 'paddle_quantum.ansatz.Circuit': + r"""Compute the composition of two Clifford operators and obtain the corresponding circuit. + + Args: + clifd1: The first Clifford operator to be composed. + clifd2: The second Clifford operator to be composed. + + Returns: + Circuit corresponding to the composed Clifford operator. + """ + assert clifd1.num_qubits == clifd2.num_qubits, "the number of qubits of two clifford circuits should be the same" + circuit = paddle_quantum.ansatz.Circuit(clifd1.num_qubits) + for sub_layer in clifd1.circuit().sublayers(): + circuit.append(sub_layer) + for sub_layer in clifd2.circuit().sublayers(): + circuit.append(sub_layer) + return circuit + + +class Clifford: + """Users can instantiate this class to randomly generate a Clifford operator. + + Args: + num_qubits: Number of qubits on which this Clifford operator acts. + + References: + 1. Bravyi, Sergey, and Dmitri Maslov. "Hadamard-free circuits expose the structure of the Clifford group." + IEEE Transactions on Information Theory 67.7 (2021): 4546-4563. + """ + def __init__(self, num_qubits: int): + # number of qubit + self.num_qubits = num_qubits + self.__table, self.__gamma, self.__delta, self.__h, self.__s = _random_clifford(num_qubits) + self.phase = [] + for qubit in range(2 * self.num_qubits): + self.phase.append(np.random.randint(0, 2)) + + # Initialize stabilizer table + self.x = np.transpose(self.__table)[0: num_qubits, :] + # Initialize destabilizer table + self.z = np.transpose(self.__table)[num_qubits: 2 * num_qubits, :] + + def print_clifford(self): + r"""Print how the Clifford operator acts on the Pauli basis. + """ + base = [] + base_out = [] + num_qubits = 2 * self.num_qubits + + # Initialize Pauli basis + for position in range(0, self.num_qubits): + base.append('X' + str(position + 1)) + for position in range(0, self.num_qubits): + base.append('Z' + str(position + 1)) + + # Compute stabilizer table + for i in range(0, self.num_qubits): + temp = '' + for jx in range(0, num_qubits): + if self.x[i][jx] == 1: + temp += base[jx] + base_out.append(temp) + + # Compute destabilizer table + temp = '' + for jz in range(num_qubits): + if self.z[i][jz] == 1: + temp += base[jz] + base_out.append(temp) + + for i in range(num_qubits): + if i % 2 == 0: + # Fix the phase + if self.phase[i // 2] == 1: + print(base[i // 2] + ' |-> ' + '+' + base_out[i]) + else: + print(base[i // 2] + ' |-> ' + '-' + base_out[i]) + else: + if self.phase[self.num_qubits + (i - 1) // 2] == 1: + print(base[self.num_qubits + (i - 1) // 2] + ' |-> ' + '+' + base_out[i]) + else: + print(base[self.num_qubits + (i - 1) // 2] + ' |-> ' + '-' + base_out[i]) + + def sym(self) -> np.ndarray: + r"""Obtain the Clifford operator's symplectic matrix. + + Returns: + Symplectic matrix corresponding to this Clifford operator. + """ + sym = [] + for i in range(0, self.num_qubits): + tempx = [] + temp = self.x[i][self.num_qubits: 2 * self.num_qubits] + for jx in range(0, self.num_qubits): + tempx.append(self.x[i][jx]) + tempx.append(temp[jx]) + sym.append(tempx) + + tempz = [] + temp = self.z[i][self.num_qubits: 2 * self.num_qubits] + for jz in range(0, self.num_qubits): + tempz.append(self.z[i][jz]) + tempz.append(temp[jz]) + sym.append(tempz) + + return np.array(sym).T + + def tableau(self) -> np.ndarray: + r"""Obtain the Clifford operator's table. + + For the number of qubits being ``num_qubits``, the first ``num_qubits`` lines correspoding to results of :math:`X_i`, + and the last ``num_qubits`` lines correspoding to results of :math:`Z_i`. + + Returns: + Table corresponding to this Clifford operator. + """ + return np.transpose(self.__table) + + def circuit(self) -> 'paddle_quantum.ansatz.Circuit': + r"""Obtain the circuit corresponding to the Clifford operator. + + Returns: + Circuit corresponding to this Clifford operator. + """ + cir = paddle_quantum.ansatz.Circuit(self.num_qubits) + + gamma1 = self.__gamma[0] + gamma2 = self.__gamma[1] + delta1 = self.__delta[0] + delta2 = self.__delta[1] + + # The second cnot layer + for bitindex in range(self.num_qubits): + for j in range(bitindex + 1, self.num_qubits): + if delta2[j][bitindex] == 1: + cir.cnot([bitindex, j]) + + # The second cz layer + for bitindex in range(self.num_qubits): + for j in range(bitindex + 1, self.num_qubits): + if gamma2[bitindex][j] == 1: + cir.cz([bitindex, j]) + + # The second P layer + for bitindex in range(self.num_qubits): + if gamma2[bitindex][bitindex] == 1: + cir.s(bitindex) + + # Pauli layer + for bitindex in range(self.num_qubits): + if self.phase[bitindex] == 1 and self.phase[bitindex + self.num_qubits] == 0: + cir.x(bitindex) + elif self.phase[bitindex] == 0 and self.phase[bitindex + self.num_qubits] == 1: + cir.z(bitindex) + elif self.phase[bitindex] == 0 and self.phase[bitindex + self.num_qubits] == 0: + cir.y(bitindex) + + # S layer + swapped = [] + for bitindex in range(self.num_qubits): + if self.__s[bitindex] == bitindex: + continue + swapped.append(self.__s[bitindex]) + if bitindex in swapped: + continue + cir.swap([bitindex, self.__s[bitindex]]) + + # Hadamard layer + for bitindex in range(self.num_qubits): + if self.__h[bitindex] == 1: + cir.h(bitindex) + + # cnot layer + for bitindex in range(self.num_qubits): + for j in range(bitindex + 1, self.num_qubits): + if delta1[j][bitindex] == 1: + cir.cnot([bitindex, j]) + + # cz layer + for bitindex in range(self.num_qubits): + for j in range(bitindex + 1, self.num_qubits): + if gamma1[bitindex][j] == 1: + cir.cz([bitindex, j]) + + # P layer + for bitindex in range(self.num_qubits): + if gamma1[bitindex][bitindex] == 1: + cir.s(bitindex) + + return cir diff --git a/paddle_quantum/gate/custom.py b/paddle_quantum/gate/custom.py new file mode 100644 index 0000000..0bdcea5 --- /dev/null +++ b/paddle_quantum/gate/custom.py @@ -0,0 +1,88 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the oracle class and the control oracle class. +""" + +import math +import paddle +import paddle_quantum +from . import functional +from .base import Gate +from paddle_quantum.intrinsic import _format_qubits_idx +from typing import Union, Iterable +from paddle_quantum.linalg import is_unitary + + +class Oracle(Gate): + """An oracle as a gate. + + Args: + oracle: Unitary oracle to be implemented. + qubits_idx: Indices of the qubits on which the gates are applied. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__( + self, oracle: paddle.Tensor, qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int], + num_qubits: int = None, depth: int = 1 + ): + super().__init__(depth) + assert is_unitary(oracle), "the input oracle must be a unitary matrix" + num_acted_qubits = int(math.log2(oracle.shape[0])) + self.oracle = paddle.cast(oracle, paddle_quantum.get_dtype()) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, False, num_acted_qubits) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + for _ in range(0, self.depth): + for qubits_idx in self.qubits_idx: + state = functional.oracle(state, self.oracle, qubits_idx, self.backend) + return state + + +class ControlOracle(Gate): + """A controlled oracle as a gate. + + Args: + oracle: Unitary oracle to be implemented. + qubits_idx: Indices of the qubits on which the gates are applied. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__( + self, oracle: paddle.Tensor, + # num_control_qubits: int, controlled_value: 'str', + qubits_idx: Union[Iterable[Iterable[int]], Iterable[int]], + num_qubits: int = None, depth: int = 1 + ): + super().__init__(depth) + assert is_unitary(oracle), "the input oracle must be a unitary matrix" + + num_acted_qubits = int(math.log2(oracle.shape[0])) + # 暂时只支持单控制位 + oracle = ( + paddle.kron(paddle.to_tensor([[1.0, 0], [0, 0]]), paddle.eye(2 ** num_acted_qubits)) + + paddle.kron(paddle.to_tensor([[0.0, 0], [0, 1]]), oracle) + ) + num_acted_qubits = num_acted_qubits + 1 + self.oracle = paddle.cast(oracle, paddle_quantum.get_dtype()) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, False, num_acted_qubits) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + for _ in range(0, self.depth): + for qubits_idx in self.qubits_idx: + state = functional.oracle(state, self.oracle, qubits_idx, self.backend) + return state diff --git a/paddle_quantum/gate/encoding.py b/paddle_quantum/gate/encoding.py new file mode 100644 index 0000000..f09531c --- /dev/null +++ b/paddle_quantum/gate/encoding.py @@ -0,0 +1,213 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the classes for quantum encoding. +""" + +import paddle +import paddle_quantum +from paddle_quantum.gate import functional +from .base import Gate +from paddle_quantum.intrinsic import _get_float_dtype, _format_qubits_idx +from typing import Iterable, Optional, Union + + +class BasisEncoding(Gate): + r"""Basis encoding gate for encoding input classical data into quantum states. + + In basis encoding, the input classical data can only consist of 0's and 1's. If the input data are 1101, + then the quantum state after encoding is :math:`|1101\rangle`. Note that the quantum state before encoding is + assumed to be :math:`|00\ldots 0\rangle`. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + """ + def __init__( + self, qubits_idx: Union[Iterable[int], int, str] = 'full', num_qubits: int = None + ) -> None: + super().__init__() + self.num_qubits = num_qubits + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + + def forward(self, feature: paddle.Tensor, + state: Optional[paddle_quantum.State] = None, inverse: Optional[bool] = False) -> paddle_quantum.State: + feature = paddle.cast(feature, 'int32') + if state is None: + state = paddle_quantum.state.zero_state(self.num_qubits) + for idx, element in enumerate(feature): + if element: + state = functional.x(state, self.qubits_idx[idx], self.dtype, self.backend) + return state + + +class AmplitudeEncoding(Gate): + r"""Amplitude encoding gate for encoding input classical data into quantum states. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable[int], int, str]] = 'full', num_qubits: Optional[int] = None + ) -> None: + if num_qubits is None: + num_qubits = max(qubits_idx) + super().__init__() + self.num_qubits = num_qubits + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + + def forward(self, feature: paddle.Tensor) -> paddle_quantum.State: + def calc_location(location_of_bits_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(0, 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): + location_of_bits_list = [] + for qubit_idx in which_qubits: + tmp = 2 ** (self.num_qubits - qubit_idx - 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(self.qubits_idx) + # Classical data preprocessing + feature = paddle.cast(feature, _get_float_dtype(paddle_quantum.get_dtype())) + feature = paddle.flatten(feature) + length = paddle.norm(feature, p=2) + # Normalization + feature = paddle.divide(feature, length) + # Create a quantum state with all zero amplitudes + data = paddle.zeros((2 ** self.num_qubits,), feature.dtype) + # The value of the encoded amplitude is filled into the specified qubits + for idx in range(0, len(feature)): + data[location_of_qubits_list[idx]] = feature[idx] + data = paddle.cast(data, dtype=paddle_quantum.get_dtype()) + if self.backend == paddle_quantum.Backend.DensityMatrix: + data = paddle.unsqueeze(data, axis=1) + data = paddle.matmul(data, paddle_quantum.linalg.dagger(data)) + elif self.backend != paddle_quantum.Backend.StateVector: + raise ValueError("the mode should be state_vector or density_matrix") + encoding_state = paddle_quantum.state.to_state(data, self.num_qubits) + return encoding_state + + +class AngleEncoding(Gate): + r"""Angle encoding gate for encoding input classical data into quantum states. + + Args: + feature: Vector to be encoded. + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + encoding_gate: The type of quantum gates used for encoding, which should be one of ``"rx"``, ``"ry"``, + and ``"rz"``. Defaults to ``None``. + """ + def __init__( + self, feature: paddle.Tensor, qubits_idx: Optional[Union[Iterable[int], int, str]] = 'full', + num_qubits: Optional[int] = None, encoding_gate: Optional[str] = None, + ) -> None: + if num_qubits is None: + num_qubits = max(qubits_idx) + super().__init__() + self.num_qubits = num_qubits + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + if encoding_gate == 'rx': + self.encoding_gate = functional.rx + elif encoding_gate == 'ry': + self.encoding_gate = functional.ry + elif encoding_gate == 'rz': + self.encoding_gate = functional.rz + feature = paddle.cast(feature, _get_float_dtype(paddle_quantum.get_dtype())) + feature = paddle.flatten(feature) + self.feature = feature + + def forward( + self, state: paddle_quantum.State, invert: Optional[bool] = False + ) -> paddle_quantum.State: + + if invert: + feature = -1 * self.feature + else: + feature = self.feature + for idx, element in enumerate(feature): + state = self.encoding_gate( + state, element[0], self.qubits_idx[idx], + dtype=self.dtype, backend=self.backend + ) + return state + + +class IQPEncoding(Gate): + r"""IQP style encoding gate for encoding input classical data into quantum states. + + Args: + feature: Vector to be encoded. + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``None``. + num_qubits: Total number of qubits. Defaults to ``None``. + num_repeat: Number of encoding layers. Defaults to ``1``. + """ + def __init__( + self, feature: paddle.Tensor, qubits_idx: Optional[Iterable[Iterable[int]]] = None, + num_qubits: Optional[int] = None, num_repeat: Optional[int] = 1, + ) -> None: + super().__init__() + self.qubits_idx = [list(idx) for idx in qubits_idx] + self.num_repeat = num_repeat + self.num_qubits = num_qubits + if feature is not None: + feature = paddle.cast(feature, _get_float_dtype(paddle_quantum.get_dtype())) + feature = paddle.flatten(feature) + self.feature = feature + + def forward( + self, state: paddle_quantum.State, invert: Optional[bool] = False + ) -> paddle_quantum.State: + for _ in range(0, self.num_repeat): + if invert: + for qubits_idx in self.qubits_idx: + state = functional.cnot(state, qubits_idx, dtype=self.dtype, backend=self.backend) + state = functional.rz( + state, -self.feature[qubits_idx[0]] * self.feature[qubits_idx[1]], qubits_idx[1], + dtype=self.dtype, backend=self.backend + ) + state = functional.cnot(state, qubits_idx, dtype=self.dtype, backend=self.backend) + for idx in range(0, self.feature.size): + state = functional.rz(state, -self.feature[idx], idx, dtype=self.dtype, backend=self.backend) + for idx in range(0, self.feature.size): + state = functional.h(state, idx, dtype=self.dtype, backend=self.backend) + else: + for idx in range(0, self.feature.size): + state = functional.h(state, idx, dtype=self.dtype, backend=self.backend) + for idx in range(0, self.feature.size): + state = functional.rz(state, self.feature[idx], idx, dtype=self.dtype, backend=self.backend) + for qubits_idx in self.qubits_idx: + state = functional.cnot(state, qubits_idx, dtype=self.dtype, backend=self.backend) + state = functional.rz( + state, self.feature[qubits_idx[0]] * self.feature[qubits_idx[1]], qubits_idx[1], + dtype=self.dtype, backend=self.backend + ) + state = functional.cnot(state, qubits_idx, dtype=self.dtype, backend=self.backend) + return state diff --git a/paddle_quantum/gate/functional/__init__.py b/paddle_quantum/gate/functional/__init__.py new file mode 100644 index 0000000..eb3c57f --- /dev/null +++ b/paddle_quantum/gate/functional/__init__.py @@ -0,0 +1,49 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The module that contains the functions of various quantum gates. +""" + +from .single_qubit_gate import h +from .single_qubit_gate import s +from .single_qubit_gate import t +from .single_qubit_gate import x +from .single_qubit_gate import y +from .single_qubit_gate import z +from .single_qubit_gate import p +from .single_qubit_gate import rx +from .single_qubit_gate import ry +from .single_qubit_gate import rz +from .single_qubit_gate import u3 +from .multi_qubit_gate import cnot +from .multi_qubit_gate import cx +from .multi_qubit_gate import cy +from .multi_qubit_gate import cz +from .multi_qubit_gate import swap +from .multi_qubit_gate import cp +from .multi_qubit_gate import crx +from .multi_qubit_gate import cry +from .multi_qubit_gate import crz +from .multi_qubit_gate import cu +from .multi_qubit_gate import rxx +from .multi_qubit_gate import ryy +from .multi_qubit_gate import rzz +from .multi_qubit_gate import ms +from .multi_qubit_gate import cswap +from .multi_qubit_gate import toffoli +from .multi_qubit_gate import universal_two_qubits +from .multi_qubit_gate import universal_three_qubits +from .multi_qubit_gate import oracle diff --git a/paddle_quantum/gate/functional/base.py b/paddle_quantum/gate/functional/base.py new file mode 100644 index 0000000..d84ad52 --- /dev/null +++ b/paddle_quantum/gate/functional/base.py @@ -0,0 +1,53 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the basic function for quantum gates. +""" + +import paddle +import paddle_quantum +from ...backend import state_vector +from ...backend import density_matrix +from ...backend import unitary_matrix +from typing import Union, List + + +def simulation( + state: paddle_quantum.State, gate: paddle.Tensor, qubit_idx: Union[int, List[int]], + num_qubits: int, backend: paddle_quantum.Backend +) -> 'paddle.Tensor': + r"""Apply the gate on the input state. + + Args: + state: Input state. + gate: Gate to be executed. + qubit_idx: Indices of the qubits on which the gate is applied. + num_qubits: Total number of qubits. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + if isinstance(qubit_idx, int): + qubit_idx = [qubit_idx] + if backend == paddle_quantum.Backend.StateVector: + return state_vector.unitary_transformation(state.data, gate, qubit_idx, num_qubits) + elif backend == paddle_quantum.Backend.DensityMatrix: + return density_matrix.unitary_transformation(state.data, gate, qubit_idx, num_qubits) + elif backend == paddle_quantum.Backend.UnitaryMatrix: + return unitary_matrix.unitary_transformation(state.data, gate, qubit_idx, num_qubits) + else: + return NotImplementedError diff --git a/paddle_quantum/gate/functional/multi_qubit_gate.py b/paddle_quantum/gate/functional/multi_qubit_gate.py new file mode 100644 index 0000000..55b2c75 --- /dev/null +++ b/paddle_quantum/gate/functional/multi_qubit_gate.py @@ -0,0 +1,554 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the functions for multi-qubit quantum gates. +""" + +import math +import paddle +import paddle_quantum +from paddle_quantum.intrinsic import _zero, _one +from .single_qubit_gate import h, s, ry, rz, u3 +from .base import simulation + + +def cnot(state: paddle_quantum.State, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a CNOT gate on the input state. + + Args: + state: Input state. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 0, 1], + [0, 0, 1, 0], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +cx = cnot + + +def cy(state: paddle_quantum.State, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a controlled Y gate on the input state. + + Args: + state: Input state. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 0, -1j], + [0, 0, 1j, 0], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def cz(state: paddle_quantum.State, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a controlled Z gate on the input state. + + Args: + state: Input state. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, 1, 0], + [0, 0, 0, -1], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def swap(state: paddle_quantum.State, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a SWAP gate on the input state. + + Args: + state: Input state. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + [1, 0, 0, 0], + [0, 0, 1, 0], + [0, 1, 0, 0], + [0, 0, 0, 1], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def cp(state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a controlled P gate on the input state. + + Args: + state: Input state. + theta: Parameter of the gate. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + _one(dtype), _zero(dtype), _zero(dtype), _zero(dtype), + _zero(dtype), _one(dtype), _zero(dtype), _zero(dtype), + _zero(dtype), _zero(dtype), _one(dtype), _zero(dtype), + _zero(dtype), _zero(dtype), _zero(dtype), paddle.cos(theta).cast(dtype) + 1j * paddle.sin(theta).cast(dtype), + ] + gate = paddle.reshape(paddle.concat(gate), [4, 4]) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def crx(state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a controlled rotation gate about the x-axis on the input state. + + Args: + state: Input state. + theta: Parameter of the gate. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + _one(dtype), _zero(dtype), _zero(dtype), _zero(dtype), + _zero(dtype), _one(dtype), _zero(dtype), _zero(dtype), + _zero(dtype), _zero(dtype), paddle.cos(theta / 2).cast(dtype), -1j * paddle.sin(theta / 2).cast(dtype), + _zero(dtype), _zero(dtype), -1j * paddle.sin(theta / 2).cast(dtype), paddle.cos(theta / 2).cast(dtype), + ] + gate = paddle.reshape(paddle.concat(gate), [4, 4]) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def cry(state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a controlled rotation gate about the y-axis on the input state. + + Args: + state: Input state. + theta: Parameter of the gate. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + _one(dtype), _zero(dtype), _zero(dtype), _zero(dtype), + _zero(dtype), _one(dtype), _zero(dtype), _zero(dtype), + _zero(dtype), _zero(dtype), paddle.cos(theta / 2).cast(dtype), (-paddle.sin(theta / 2)).cast(dtype), + _zero(dtype), _zero(dtype), paddle.sin(theta / 2).cast(dtype), paddle.cos(theta / 2).cast(dtype), + ] + gate = paddle.reshape(paddle.concat(gate), [4, 4]) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def crz(state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a controlled rotation gate about the z-axis on the input state. + + Args: + state: Input state. + theta: Parameter of the gate. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + param1 = paddle.cos(theta / 2).cast(dtype) - 1j * paddle.sin(theta / 2).cast(dtype) + param2 = paddle.cos(theta / 2).cast(dtype) + 1j * paddle.sin(theta / 2).cast(dtype) + gate = [ + _one(dtype), _zero(dtype), _zero(dtype), _zero(dtype), + _zero(dtype), _one(dtype), _zero(dtype), _zero(dtype), + _zero(dtype), _zero(dtype), param1, _zero(dtype), + _zero(dtype), _zero(dtype), _zero(dtype), param2, + ] + gate = paddle.reshape(paddle.concat(gate), [4, 4]) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def cu(state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a controlled single-qubit rotation gate on the input state. + + Args: + state: Input state. + theta: Parameters of the gate. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + # theta is theta[0], phi is theta[1], lambda is theta[2] + param1 = paddle.cos(theta[0] / 2).cast(dtype) + param2 = (paddle.cos(theta[2]).cast(dtype) + 1j * paddle.sin(theta[2]).cast(dtype)) * \ + (-paddle.sin(theta[0] / 2)).cast(dtype) + param3 = (paddle.cos(theta[1]).cast(dtype) + 1j * paddle.sin(theta[1]).cast(dtype)) * \ + paddle.sin(theta[0] / 2).cast(dtype) + param4 = (paddle.cos(theta[1] + theta[2]).cast(dtype) + 1j * paddle.sin(theta[1] + theta[2]).cast(dtype)) * \ + paddle.cos(theta[0] / 2).cast(dtype) + gate = [ + _one(dtype), _zero(dtype), _zero(dtype), _zero(dtype), + _zero(dtype), _one(dtype), _zero(dtype), _zero(dtype), + _zero(dtype), _zero(dtype), param1, param2, + _zero(dtype), _zero(dtype), param3, param4, + ] + gate = paddle.reshape(paddle.concat(gate), [4, 4]) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def rxx(state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply an RXX gate on the input state. + + Args: + state: Input state. + theta: Parameter of the gate. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + param1 = paddle.cos(theta / 2).cast(dtype) + param2 = -1j * paddle.sin(theta / 2).cast(dtype) + gate = [ + param1, _zero(dtype), _zero(dtype), param2, + _zero(dtype), param1, param2, _zero(dtype), + _zero(dtype), param2, param1, _zero(dtype), + param2, _zero(dtype), _zero(dtype), param1, + ] + gate = paddle.reshape(paddle.concat(gate), [4, 4]) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def ryy(state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply an RYY gate on the input state. + + Args: + state: Input state. + theta: Parameter of the gate. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + param1 = paddle.cos(theta / 2).cast(dtype) + param2 = -1j * paddle.sin(theta / 2).cast(dtype) + param3 = 1j * paddle.sin(theta / 2).cast(dtype) + gate = [ + param1, _zero(dtype), _zero(dtype), param3, + _zero(dtype), param1, param2, _zero(dtype), + _zero(dtype), param2, param1, _zero(dtype), + param3, _zero(dtype), _zero(dtype), param1, + ] + gate = paddle.reshape(paddle.concat(gate), [4, 4]) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def rzz(state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply an RZZ gate on the input state. + + Args: + state: Input state. + theta: Parameter of the gate. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + param1 = paddle.cos(theta / 2).cast(dtype) - 1j * paddle.sin(theta / 2).cast(dtype) + param2 = paddle.cos(theta / 2).cast(dtype) + 1j * paddle.sin(theta / 2).cast(dtype) + gate = [ + param1, _zero(dtype), _zero(dtype), _zero(dtype), + _zero(dtype), param2, _zero(dtype), _zero(dtype), + _zero(dtype), _zero(dtype), param2, _zero(dtype), + _zero(dtype), _zero(dtype), _zero(dtype), param1, + ] + gate = paddle.reshape(paddle.concat(gate), [4, 4]) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def ms(state: paddle_quantum.State, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a Mølmer-Sørensen (MS) gate on the input state. + + Args: + state: Input state. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + val1 = 1 / math.sqrt(2) + val2 = 1j / math.sqrt(2) + gate = [ + [val1, 0, 0, val2], + [0, val1, val2, 0], + [0, val2, val1, 0], + [val2, 0, 0, val1], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def cswap(state: paddle_quantum.State, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a CSWAP (Fredkin) gate on the input state. + + Args: + state: Input state. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + [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], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def toffoli(state: paddle_quantum.State, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a Toffoli gate on the input state. + + Args: + state: Input state. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + [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], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def universal_two_qubits( + state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a universal two-qubit gate on the input state. + + Args: + state: Input state. + theta: Parameters of the gate. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + idx0, idx1 = qubit_idx + state = u3(state, theta[[0, 1, 2]], idx0, dtype, backend) + state = u3(state, theta[[3, 4, 5]], idx1, dtype, backend) + state = cnot(state, [idx1, idx0], dtype, backend) + state = rz(state, theta[6], idx0, dtype, backend) + state = ry(state, theta[7], idx1, dtype, backend) + state = cnot(state, [idx0, idx1], dtype, backend) + state = ry(state, theta[8], idx1, dtype, backend) + state = cnot(state, [idx1, idx0], dtype, backend) + state = u3(state, theta[[9, 10, 11]], idx0, dtype, backend) + state = u3(state, theta[[12, 13, 14]], idx1, dtype, backend) + return state + + +def universal_three_qubits( + state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: list, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a universal three-qubit gate on the input state. + + Args: + state: Input state. + theta: Parameters of the gate. + qubit_idx: Indices of the qubits on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + idx0, idx1, idx2 = qubit_idx + psi = paddle.reshape(theta[:60], shape=[4, 15]) + phi = paddle.reshape(theta[60:], shape=[7, 3]) + + def __block_u(_state: paddle_quantum.State, _theta: paddle.Tensor) -> paddle_quantum.State: + _state = cnot(_state, [idx1, idx2], dtype, backend) + _state = ry(_state, _theta[0], idx1, dtype, backend) + _state = cnot(_state, [idx0, idx1], dtype, backend) + _state = ry(_state, _theta[1], idx1, dtype, backend) + _state = cnot(_state, [idx0, idx1], dtype, backend) + _state = cnot(_state, [idx1, idx2], dtype, backend) + _state = h(_state, idx2, dtype, backend) + _state = cnot(_state, [idx1, idx0], dtype, backend) + _state = cnot(_state, [idx0, idx2], dtype, backend) + _state = cnot(_state, [idx1, idx2], dtype, backend) + _state = rz(_state, _theta[2], idx2, dtype, backend) + _state = cnot(_state, [idx1, idx2], dtype, backend) + _state = cnot(_state, [idx0, idx2], dtype, backend) + return _state + + def __block_v(_state: paddle_quantum.State, _theta: paddle.Tensor) -> paddle_quantum.State: + _state = cnot(_state, [idx2, idx0], dtype, backend) + _state = cnot(_state, [idx1, idx2], dtype, backend) + _state = cnot(_state, [idx2, idx1], dtype, backend) + _state = ry(_state, _theta[0], idx2, dtype, backend) + _state = cnot(_state, [idx1, idx2], dtype, backend) + _state = ry(_state, _theta[1], idx2, dtype, backend) + _state = cnot(_state, [idx1, idx2], dtype, backend) + _state = s(_state, idx2, dtype, backend) + _state = cnot(_state, [idx2, idx0], dtype, backend) + _state = cnot(_state, [idx0, idx1], dtype, backend) + _state = cnot(_state, [idx1, idx0], dtype, backend) + _state = h(_state, idx2, dtype, backend) + _state = cnot(_state, [idx0, idx2], dtype, backend) + _state = rz(_state, _theta[2], idx2, dtype, backend) + _state = cnot(_state, [idx0, idx2], dtype, backend) + return _state + + state = universal_two_qubits(state, psi[0], [idx0, idx1], dtype, backend) + state = u3(state, phi[0, 0:3], idx2, dtype, backend) + state = __block_u(state, phi[1]) + state = universal_two_qubits(state, psi[1], [idx0, idx1], dtype, backend) + state = u3(state, phi[2, 0:3], idx2, dtype, backend) + state = __block_v(state, phi[3]) + state = universal_two_qubits(state, psi[2], [idx0, idx1], dtype, backend) + state = u3(state, phi[4, 0:3], idx2, dtype, backend) + state = __block_u(state, phi[5]) + state = universal_two_qubits(state, psi[3], [idx0, idx1], dtype, backend) + state = u3(state, phi[6, 0:3], idx2, dtype, backend) + return state + + +def oracle( + state: paddle_quantum.State, oracle: 'paddle.Tensor', qubit_idx: list, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply an oracle gate on the input state. + + Args: + state: Input state. + oracle: Oracle to be executed. + qubit_idx: Indices of the qubits on which the gate is applied. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + state_data = simulation(state, oracle, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state diff --git a/paddle_quantum/gate/functional/single_qubit_gate.py b/paddle_quantum/gate/functional/single_qubit_gate.py new file mode 100644 index 0000000..581fda7 --- /dev/null +++ b/paddle_quantum/gate/functional/single_qubit_gate.py @@ -0,0 +1,306 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the functions for single-qubit quantum gates. +""" + +import math +import paddle +import paddle_quantum +from .base import simulation +from paddle_quantum.intrinsic import _get_float_dtype, _zero, _one + + +def h(state: paddle_quantum.State, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a Hadamard gate on the input state. + + Args: + state: Input state. + qubit_idx: Index of the qubit on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + element = 1 / math.sqrt(2) + gate = [ + [element, element], + [element, -element], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def s(state: paddle_quantum.State, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply an S gate on the input state. + + Args: + state: Input state. + qubit_idx: Index of the qubit on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + [1, 0], + [0, 1j], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def t(state: paddle_quantum.State, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a T gate on the input state. + + Args: + state: Input state. + qubit_idx: Index of the qubit on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + [1, 0], + [0, math.cos(math.pi / 4) - math.sin(math.pi / 4) * 1j], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def x(state: paddle_quantum.State, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply an X gate on the input state. + + Args: + state: Input state. + qubit_idx: Index of the qubit on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + [0, 1], + [1, 0], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def y(state: paddle_quantum.State, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a Y gate on the input state. + + Args: + state: Input state. + qubit_idx: Index of the qubit on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + [0, -1j], + [1j, 0], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def z(state: paddle_quantum.State, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend) -> paddle_quantum.State: + r"""Apply a Z gate on the input state. + + Args: + state: Input state. + qubit_idx: Index of the qubit on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + [1, 0], + [0, -1], + ] + gate = paddle.to_tensor(gate, dtype=dtype) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def p( + state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a P gate on the input state. + + Args: + state: Input state. + theta: Parameter of the gate. + qubit_idx: Index of the qubit on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + _one(dtype), _zero(dtype), + _zero(dtype), paddle.cos(theta).cast(dtype) + 1j * paddle.sin(theta).cast(dtype), + ] + gate = paddle.reshape(paddle.concat(gate), [2, 2]) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def rx( + state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a single-qubit rotation gate about the x-axis on the input state. + + Args: + state: Input state. + theta: Parameter of the gate. + qubit_idx: Index of the qubit on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + paddle.cos(theta / 2).cast(dtype), -1j * paddle.sin(theta / 2).cast(dtype), + -1j * paddle.sin(theta / 2).cast(dtype), paddle.cos(theta / 2).cast(dtype), + ] + gate = paddle.reshape(paddle.concat(gate), [2, 2]) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def ry( + state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a single-qubit rotation gate about the y-axis on the input state. + + Args: + state: Input state. + theta: Parameter of the gate. + qubit_idx: Index of the qubit on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + paddle.cos(theta / 2).cast(dtype), (-paddle.sin(theta / 2)).cast(dtype), + paddle.sin(theta / 2).cast(dtype), paddle.cos(theta / 2).cast(dtype), + ] + gate = paddle.reshape(paddle.concat(gate), [2, 2]) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def rz( + state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a single-qubit rotation gate about the z-axis on the input state. + + Args: + state: Input state. + theta: Parameter of the gate. + qubit_idx: Index of the qubit on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + gate = [ + paddle.cos(theta / 2).cast(dtype) - 1j * paddle.sin(theta / 2).cast(dtype), _zero(dtype), + _zero(dtype), paddle.cos(theta / 2).cast(dtype) + 1j * paddle.sin(theta / 2).cast(dtype), + ] + gate = paddle.reshape(paddle.concat(gate), [2, 2]) + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state + + +def u3( + state: paddle_quantum.State, theta: paddle.Tensor, qubit_idx: int, dtype: str, backend: paddle_quantum.Backend +) -> paddle_quantum.State: + r"""Apply a single-qubit rotation gate on the input state. + + Args: + state: Input state. + theta: Parameters of the gate. + qubit_idx: Index of the qubit on which the gate is applied. + dtype: Type of data. + backend: Backend on which the simulation is run. + + Returns: + Output state. + """ + # theta is theta[0], phi is theta[1], lambda is theta[2] + gate_real = [ + paddle.cos(theta[0] / 2), + -paddle.cos(theta[2]) * paddle.sin(theta[0] / 2), + paddle.cos(theta[1]) * paddle.sin(theta[0] / 2), + paddle.cos(theta[1] + theta[2]) * paddle.cos(theta[0] / 2), + ] + gate_real = paddle.reshape(paddle.concat(gate_real), [2, 2]) + + gate_imag = [ + paddle.to_tensor(0, dtype=_get_float_dtype(dtype)), + -paddle.sin(theta[2]) * paddle.sin(theta[0] / 2), + paddle.sin(theta[1]) * paddle.sin(theta[0] / 2), + paddle.sin(theta[1] + theta[2]) * paddle.cos(theta[0] / 2), + ] + gate_imag = paddle.reshape(paddle.concat(gate_imag), [2, 2]) + + gate = gate_real + 1j * gate_imag + state_data = simulation(state, gate, qubit_idx, state.num_qubits, backend) + transformed_state = state.clone() + transformed_state.data = state_data + return transformed_state diff --git a/paddle_quantum/gate/layer.py b/paddle_quantum/gate/layer.py new file mode 100644 index 0000000..cc1134f --- /dev/null +++ b/paddle_quantum/gate/layer.py @@ -0,0 +1,387 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the class for quantum circuit templates. +""" + +import math +import numpy as np +import paddle +import paddle_quantum +from paddle_quantum.gate import functional +from paddle_quantum.intrinsic import _get_float_dtype +from .base import Gate +from typing import Iterable, List, Optional, Union + + +def qubits_idx_filter(qubits_idx: Union[Iterable[int], str], num_qubits: int) -> List[Iterable[int]]: + r"""Check the validity of ``qubits_idx`` and ``num_qubits``. + + Args: + qubits_idx: Indices of qubits. + num_qubits: Total number of qubits. + + Raises: + RuntimeError: You must specify ``qubits_idx`` or ``num_qubits`` to instantiate the class. + ValueError: The ``qubits_idx`` must be ``Iterable`` or ``'full'``. + + Returns: + Checked indices of qubits. + """ + if qubits_idx == 'full': + if num_qubits is None: + raise RuntimeError("You must specify qubits_idx or num_qubits to instantiate the class.") + return list(range(0, num_qubits)) + elif isinstance(qubits_idx, Iterable): + return list(qubits_idx) + else: + raise ValueError("The param qubits_idx must be iterable or full") + + +class SuperpositionLayer(Gate): + r"""Layers of Hadamard gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__( + self, qubits_idx: Union[Iterable[int], str] = 'full', num_qubits: int = None, depth: int = 1 + ): + super().__init__(depth) + self.qubits_idx = qubits_idx_filter(qubits_idx, num_qubits) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + for _ in range(0, self.depth): + for qubit_idx in self.qubits_idx: + state = functional.h(state, qubit_idx, self.dtype, self.backend) + return state + + +class WeakSuperpositionLayer(Gate): + r"""Layers of Ry gates with a rotation angle :math:`\pi/4`. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__( + self, qubits_idx: Union[Iterable[int], str] = 'full', num_qubits: int = None, depth: int = 1 + ): + super().__init__(depth) + self.qubits_idx = qubits_idx_filter(qubits_idx, num_qubits) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + theta = paddle.to_tensor([np.pi / 4]) + for _ in range(0, self.depth): + for qubit_idx in self.qubits_idx: + state = functional.ry(state, theta, qubit_idx, self.dtype, self.backend) + return state + + +class LinearEntangledLayer(Gate): + r"""Linear entangled layers consisting of Ry gates, Rz gates, and CNOT gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__( + self, qubits_idx: Union[Iterable[int], str] = 'full', num_qubits: int = None, depth: int = 1 + ): + super().__init__(depth) + self.qubits_idx = qubits_idx_filter(qubits_idx, num_qubits) + + float_dtype = _get_float_dtype(self.dtype) + param_shape = [self.depth] + list(np.shape(self.qubits_idx)) + [2] + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + theta = self.create_parameter( + shape=param_shape, + dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + for depth_idx in range(0, self.depth): + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.ry( + state, self.theta[depth_idx, param_idx, 0], qubit_idx, self.dtype, self.backend) + for idx in range(0, len(self.qubits_idx) - 1): + state = functional.cnot( + state, [self.qubits_idx[idx], self.qubits_idx[idx + 1]], self.dtype, self.backend) + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.rz( + state, self.theta[depth_idx, param_idx, 1], qubit_idx, self.dtype, self.backend) + for idx in range(0, len(self.qubits_idx) - 1): + state = functional.cnot( + state, [self.qubits_idx[idx], self.qubits_idx[idx + 1]], self.dtype, self.backend) + return state + + +class RealEntangledLayer(Gate): + r"""Strongly entangled layers consisting of Ry gates and CNOT gates. + + Note: + The mathematical representation of this layer of quantum gates is a real unitary matrix. + This ansatz is from the following paper: https://arxiv.org/pdf/1905.10876.pdf. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__( + self, qubits_idx: Union[Iterable[int], str] = 'full', num_qubits: int = None, depth: int = 1 + ): + super().__init__(depth) + self.qubits_idx = qubits_idx_filter(qubits_idx, num_qubits) + assert len(self.qubits_idx) > 1, 'you need at least 2 qubits' + + float_dtype = _get_float_dtype(self.dtype) + param_shape = [self.depth] + list(np.shape(self.qubits_idx)) + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + theta = self.create_parameter( + shape=param_shape, + dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + for depth_idx in range(0, self.depth): + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.ry( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + for qubit_idx in range(0, len(self.qubits_idx)): + state = functional.cnot( + state, [self.qubits_idx[qubit_idx], self.qubits_idx[(qubit_idx + 1) % len(self.qubits_idx)]], + self.dtype, self.backend) + return state + + +class ComplexEntangledLayer(Gate): + r"""Strongly entangled layers consisting of single-qubit rotation gates and CNOT gates. + + Note: + The mathematical representation of this layer of quantum gates is a complex unitary matrix. + This ansatz is from the following paper: https://arxiv.org/abs/1804.00633. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__( + self, qubits_idx: Union[Iterable[int], str] = 'full', num_qubits: int = None, depth: int = 1 + ): + super().__init__(depth) + self.qubits_idx = qubits_idx_filter(qubits_idx, num_qubits) + assert len(self.qubits_idx) > 1, 'you need at least 2 qubits' + + float_dtype = _get_float_dtype(self.dtype) + param_shape = [self.depth] + list(np.shape(self.qubits_idx)) + [3] + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + for depth_idx in range(0, self.depth): + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.u3( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + for qubit_idx in range(0, len(self.qubits_idx)): + state = functional.cnot( + state, [self.qubits_idx[qubit_idx], self.qubits_idx[(qubit_idx + 1) % len(self.qubits_idx)]], + self.dtype, self.backend) + return state + + +class RealBlockLayer(Gate): + r"""Weakly entangled layers consisting of Ry gates and CNOT gates. + + Note: + The mathematical representation of this layer of quantum gates is a real unitary matrix. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__( + self, qubits_idx: Union[Iterable[int], str] = 'full', num_qubits: int = None, depth: int = 1 + ): + super().__init__(depth) + self.qubits_idx = qubits_idx_filter(qubits_idx, num_qubits) + assert len(self.qubits_idx) > 1, 'you need at least 2 qubits' + + float_dtype = _get_float_dtype(self.dtype) + # TODO: currently do not support multiple dimensions of qubits_idx + param_shape = [self.depth] + [len(self.qubits_idx) - 1] + [4] + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + theta = self.create_parameter( + shape=param_shape, + dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def __add_real_block(self, theta: paddle.Tensor, position: List[int]) -> None: + assert len(theta) == 4, 'the length of theta is not right' + + position[0] = self.qubits_idx[position[0]] + position[1] = self.qubits_idx[position[1]] + + state = functional.ry(self.state, theta[0], position[0], self.dtype, self.backend) + state = functional.ry(state, theta[1], position[1], self.dtype, self.backend) + + state = functional.cnot(state, [position[0], position[1]], self.dtype, self.backend) + + state = functional.ry(state, theta[2], position[0], self.dtype, self.backend) + state = functional.ry(state, theta[3], position[1], self.dtype, self.backend) + + self.state = state + + def __add_real_layer(self, theta: paddle.Tensor, position: List) -> None: + 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 forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + self.state = state + n = len(self.qubits_idx) + + if n % 2 == 0: + for depth_idx in range(self.depth): + self.__add_real_layer(self.theta[depth_idx, :int(n / 2)], [0, n - 1]) + self.__add_real_layer(self.theta[depth_idx, int(n / 2):], [1, n - 2]) if n > 2 else None + else: + for depth_idx in range(self.depth): + self.__add_real_layer(self.theta[depth_idx, :int((n - 1) / 2)], [0, n - 2]) + self.__add_real_layer(self.theta[depth_idx, int((n - 1) / 2):], [1, n - 1]) + + return self.state + + +class ComplexBlockLayer(Gate): + r"""Weakly entangled layers consisting of single-qubit rotation gates and CNOT gates. + + Note: + The mathematical representation of this layer of quantum gates is a complex unitary matrix. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable[int], str]] = 'full', + num_qubits: Optional[int] = None, depth: Optional[int] = 1) -> None: + super().__init__(depth) + self.qubits_idx = qubits_idx_filter(qubits_idx, num_qubits) + assert len(self.qubits_idx) > 1, 'you need at least 2 qubits' + + float_dtype = _get_float_dtype(self.dtype) + # TODO: currently do not support multiple dimensions of qubits_idx + param_shape = [self.depth] + [len(self.qubits_idx) - 1] + [12] + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + theta = self.create_parameter( + shape=param_shape, + dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + self.state = None + + def __add_complex_block(self, theta: paddle.Tensor, position: List[int]) -> None: + assert len(theta) == 12, 'the length of theta is not right' + + position[0] = self.qubits_idx[position[0]] + position[1] = self.qubits_idx[position[1]] + + state = functional.u3(self.state, [theta[0], theta[1], theta[2]], position[0], self.dtype, self.backend) + state = functional.u3(state, [theta[3], theta[4], theta[5]], position[1], self.dtype, self.backend) + + state = functional.cnot(state, [position[0], position[1]], self.dtype, self.backend) + + state = functional.u3(state, [theta[6], theta[7], theta[8]], position[0], self.dtype, self.backend) + state = functional.u3(state, [theta[9], theta[10], theta[11]], position[1], self.dtype, self.backend) + + self.state = state + + def __add_complex_layer(self, theta: paddle.Tensor, position: List[int]) -> None: + 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]) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + self.state = state + + num_acted_qubits = len(self.qubits_idx) + + if num_acted_qubits % 2 == 0: + for depth_idx in range(self.depth): + self.__add_complex_layer(self.theta[depth_idx, :num_acted_qubits // 2], [0, num_acted_qubits - 1]) + if num_acted_qubits > 2: + self.__add_complex_layer(self.theta[depth_idx, num_acted_qubits // 2:], [1, num_acted_qubits - 2]) + else: + for depth_idx in range(0, self.depth): + self.__add_complex_layer(self.theta[depth_idx, :(num_acted_qubits - 1) // 2], [0, num_acted_qubits - 2]) + self.__add_complex_layer(self.theta[depth_idx, (num_acted_qubits - 1) // 2:], [1, num_acted_qubits - 1]) + + return self.state + + +class QAOALayer(Gate): + # TODO: only maxcut now + def __init__( + self, edges: Iterable, nodes: Iterable, depth: int = 1 + ): + super().__init__(depth) + float_dtype = _get_float_dtype(self.dtype) + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + self.edges = edges + self.nodes = nodes + gamma = self.create_parameter( + shape=[self.depth], + dtype=float_dtype, + default_initializer=initializer + ) + beta = self.create_parameter( + shape=[self.depth], + dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('gamma', gamma) + self.add_parameter('beta', beta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + for depth_idx in range(0, self.depth): + for node0, node1 in self.edges: + state = functional.cnot(state, [node0, node1], self.dtype, self.backend) + state = functional.rz(state, self.gamma[depth_idx], node1, self.dtype, self.backend) + state = functional.cnot(state, [node0, node1], self.dtype, self.backend) + for node in self.nodes: + state = functional.rx(state, self.beta[depth_idx], node, self.dtype, self.backend) + return state diff --git a/paddle_quantum/gate/multi_qubit_gate.py b/paddle_quantum/gate/multi_qubit_gate.py new file mode 100644 index 0000000..6e9ef2f --- /dev/null +++ b/paddle_quantum/gate/multi_qubit_gate.py @@ -0,0 +1,1082 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the classes for multi-qubit gates. +""" + +import copy +import math +import paddle +import paddle_quantum +from . import functional +from .base import Gate +from ..backend import Backend +from ..intrinsic import _format_qubits_idx, _get_float_dtype +from typing import Optional, Union, Iterable + + +class CNOT(Gate): + r"""A collection of CNOT gates. + + For a 2-qubit quantum circuit, when ``qubits_idx`` is ``[0, 1]``, the matrix form of such a gate is: + + .. 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} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 'cnot', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubits_idx in self.qubits_idx: + state = functional.cnot(state, qubits_idx, self.dtype, self.backend) + return state + + +class CX(Gate): + r"""Same as CNOT. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', + num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 'cx', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubits_idx in self.qubits_idx: + state = functional.cx(state, qubits_idx, self.dtype, self.backend) + return state + + +class CY(Gate): + r"""A collection of controlled Y gates. + + For a 2-qubit quantum circuit, when ``qubits_idx`` is ``[0, 1]``, the matrix form of such a gate is: + + .. math:: + + \begin{align} + CY &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Y\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & -1j \\ + 0 & 0 & 1j & 0 + \end{bmatrix} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', + num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 'cy', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubits_idx in self.qubits_idx: + state = functional.cy(state, qubits_idx, self.dtype, self.backend) + return state + + +class CZ(Gate): + r"""A collection of controlled Z gates. + + For a 2-qubit quantum circuit, when ``qubits_idx`` is ``[0, 1]``, the matrix form of such a gate is: + + .. math:: + + \begin{align} + CZ &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Z\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 0 & 0 & -1 + \end{bmatrix} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', + num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 'cz', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubits_idx in self.qubits_idx: + state = functional.cz(state, qubits_idx, self.dtype, self.backend) + return state + + +class SWAP(Gate): + r"""A collection of SWAP gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{align} + SWAP = + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 0 & 1 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & 0 & 1 + \end{bmatrix} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', + num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 'swap', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubits_idx in self.qubits_idx: + state = functional.swap(state, qubits_idx, self.dtype, self.backend) + return state + + +class CP(Gate): + r"""A collection of controlled P gates. + + For a 2-qubit quantum circuit, when ``qubits_idx`` is ``[0, 1]``, the matrix form of such a gate is: + + .. math:: + + \begin{bmatrix} + 1 & 0 & 0 & 0\\ + 0 & 1 & 0 & 0\\ + 0 & 0 & 1 & 0\\ + 0 & 0 & 0 & e^{i\theta} + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [1] + else: + param_shape = len(self.qubits_idx) + param_shape = [self.depth, param_shape] + if param is None: + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + else: + if isinstance(param, float): + initializer = paddle.nn.initializer.Constant(param) + elif isinstance(param, paddle.Tensor): + initializer = paddle.nn.initializer.Assign(param.reshape(param_shape)) + else: + raise ValueError("The param must be paddle.Tensor or float.") + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.cp(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.cp( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class CRX(Gate): + r"""A collection of controlled rotation gates about the x-axis. + + For a 2-qubit quantum circuit, when ``qubits_idx`` is ``[0, 1]``, the matrix form of such a gate is: + + .. math:: + + \begin{align} + CRx &=|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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [1] + else: + param_shape = len(self.qubits_idx) + param_shape = [self.depth, param_shape] + if param is None: + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + else: + if isinstance(param, float): + initializer = paddle.nn.initializer.Constant(param) + elif isinstance(param, paddle.Tensor): + initializer = paddle.nn.initializer.Assign(param.reshape(param_shape)) + else: + raise ValueError("The param must be paddle.Tensor or float.") + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.param_list.extend(self.theta) + if self.param_sharing: + param_idx_list = [[state.num_param]] + state.num_param += 1 + else: + param_idx_list = [] + for _ in range(0, self.depth): + param_idx_list.append(list(range(state.num_param, state.num_param + len(self.qubits_idx)))) + state.num_param += self.theta.size + state.gate_history.append({ + 'gate_name': 'crx', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + 'param': param_idx_list, + 'param_sharing': self.param_sharing, + }) + return state + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.crx(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.crx( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class CRY(Gate): + r"""A collection of controlled rotation gates about the y-axis. + + For a 2-qubit quantum circuit, when ``qubits_idx`` is ``[0, 1]``, the matrix form of such a gate is: + + .. math:: + + \begin{align} + CRy &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Ry\\ + &= + \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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [1] + else: + param_shape = len(self.qubits_idx) + param_shape = [self.depth, param_shape] + if param is None: + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + else: + if isinstance(param, float): + initializer = paddle.nn.initializer.Constant(param) + elif isinstance(param, paddle.Tensor): + initializer = paddle.nn.initializer.Assign(param.reshape(param_shape)) + else: + raise ValueError("The param must be paddle.Tensor or float.") + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.param_list.extend(self.theta) + if self.param_sharing: + param_idx_list = [[state.num_param]] + state.num_param += 1 + else: + param_idx_list = [] + for _ in range(0, self.depth): + param_idx_list.append(list(range(state.num_param, state.num_param + len(self.qubits_idx)))) + state.num_param += self.theta.size + state.gate_history.append({ + 'gate_name': 'cry', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + 'param': param_idx_list, + 'param_sharing': self.param_sharing, + }) + return state + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.cry(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.cry( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class CRZ(Gate): + r"""A collection of controlled rotation gates about the z-axis. + + For a 2-qubit quantum circuit, when ``qubits_idx`` is ``[0, 1]``, the matrix form of such a gate is: + + .. math:: + + \begin{align} + CRz &=|0\rangle \langle 0|\otimes I + |1 \rangle \langle 1|\otimes Rz\\ + &= + \begin{bmatrix} + 1 & 0 & 0 & 0 \\ + 0 & 1 & 0 & 0 \\ + 0 & 0 & e^{-i\frac{\theta}{2}} & 0 \\ + 0 & 0 & 0 & e^{i\frac{\theta}{2}} + \end{bmatrix} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [1] + else: + param_shape = len(self.qubits_idx) + param_shape = [self.depth, param_shape] + if param is None: + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + else: + if isinstance(param, float): + initializer = paddle.nn.initializer.Constant(param) + elif isinstance(param, paddle.Tensor): + initializer = paddle.nn.initializer.Assign(param.reshape(param_shape)) + else: + raise ValueError("The param must be paddle.Tensor or float.") + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.param_list.extend(self.theta) + if self.param_sharing: + param_idx_list = [[state.num_param]] + state.num_param += 1 + else: + param_idx_list = [] + for _ in range(0, self.depth): + param_idx_list.append(list(range(state.num_param, state.num_param + len(self.qubits_idx)))) + state.num_param += self.theta.size + state.gate_history.append({ + 'gate_name': 'crz', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + 'param': param_idx_list, + 'param_sharing': self.param_sharing, + }) + return state + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.crz(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.crz( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class CU(Gate): + r"""A collection of controlled single-qubit rotation gates. + + For a 2-qubit quantum circuit, when ``qubits_idx`` is ``[0, 1]``, the matrix form of such a gate is: + + .. 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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [3] + else: + param_shape = [len(self.qubits_idx), 3] + param_shape = [self.depth] + param_shape + if param is None: + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + else: + if isinstance(param, float): + initializer = paddle.nn.initializer.Constant(param) + elif isinstance(param, paddle.Tensor): + initializer = paddle.nn.initializer.Assign(param.reshape(param_shape)) + else: + raise ValueError("The param must be paddle.Tensor or float.") + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.param_list.extend(self.theta) + if self.param_sharing: + param_idx_list = [range(state.num_param, state.num_param + 3)] + state.num_param += 3 + else: + param_idx_list = [] + for _ in range(0, self.depth): + param_idx_list.append(list(range(state.num_param, state.num_param + len(self.qubits_idx)))) + state.num_param += self.theta.size + state.gate_history.append({ + 'gate_name': 'cu', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + 'param': param_idx_list, + 'param_sharing': self.param_sharing, + }) + return state + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.cu(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.cu( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class RXX(Gate): + r"""A collection of RXX gates. + + The matrix form of such a gate is: + + .. 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} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [1] + else: + param_shape = len(self.qubits_idx) + param_shape = [self.depth, param_shape] + if param is None: + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + else: + if isinstance(param, float): + initializer = paddle.nn.initializer.Constant(param) + elif isinstance(param, paddle.Tensor): + initializer = paddle.nn.initializer.Assign(param.reshape(param_shape)) + else: + raise ValueError("The param must be paddle.Tensor or float.") + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.rxx(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.rxx( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class RYY(Gate): + r"""A collection of RYY gates. + + The matrix form of such a gate is: + + .. 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} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [1] + else: + param_shape = len(self.qubits_idx) + param_shape = [self.depth, param_shape] + if param is None: + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + else: + if isinstance(param, float): + initializer = paddle.nn.initializer.Constant(param) + elif isinstance(param, paddle.Tensor): + initializer = paddle.nn.initializer.Assign(param.reshape(param_shape)) + else: + raise ValueError("The param must be paddle.Tensor or float.") + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.ryy(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.ryy( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class RZZ(Gate): + r"""A collection of RZZ gates. + + The matrix form of such a gate is: + + .. 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} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [1] + else: + param_shape = len(self.qubits_idx) + param_shape = [self.depth, param_shape] + if param is None: + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + else: + if isinstance(param, float): + initializer = paddle.nn.initializer.Constant(param) + elif isinstance(param, paddle.Tensor): + initializer = paddle.nn.initializer.Assign(param.reshape(param_shape)) + else: + raise ValueError("The param must be paddle.Tensor or float.") + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.rzz(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.rzz( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class MS(Gate): + r"""A collection of Mølmer-Sørensen (MS) gates for trapped ion devices. + + The matrix form of such a gate is: + + .. 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} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for _ in range(0, self.depth): + for qubits_idx in self.qubits_idx: + functional.ms(state, qubits_idx, self.dtype, self.backend) + return state + + +class CSWAP(Gate): + r"""A collection of CSWAP (Fredkin) gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{align} + CSWAP = + \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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=3) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 'cswap', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubits_idx in self.qubits_idx: + functional.cswap(state, qubits_idx, self.dtype, self.backend) + return state + + +class Toffoli(Gate): + r"""A collection of Toffoli gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{align} + \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: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=3) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 'toffoli', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubits_idx in self.qubits_idx: + functional.toffoli(state, qubits_idx, self.dtype, self.backend) + return state + + +class UniversalTwoQubits(Gate): + r"""A collection of universal two-qubit gates. One of such a gate requires 15 parameters. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=2) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [15] + else: + param_shape = [len(self.qubits_idx), 15] + param_shape = [self.depth] + param_shape + if param is None: + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + else: + if isinstance(param, float): + initializer = paddle.nn.initializer.Constant(param) + elif isinstance(param, paddle.Tensor): + initializer = paddle.nn.initializer.Assign(param.reshape(param_shape)) + else: + raise ValueError("The param must be paddle.Tensor or float.") + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.universal_two_qubits( + state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.universal_two_qubits( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class UniversalThreeQubits(Gate): + r"""A collection of universal three-qubit gates. One of such a gate requires 81 parameters. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, str]] = 'cycle', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=False, num_acted_qubits=3) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [81] + else: + param_shape = [len(self.qubits_idx), 81] + param_shape = [self.depth] + param_shape + if param is None: + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + else: + if isinstance(param, float): + initializer = paddle.nn.initializer.Constant(param) + elif isinstance(param, paddle.Tensor): + initializer = paddle.nn.initializer.Assign(param.reshape(param_shape)) + else: + raise ValueError("The param must be paddle.Tensor or float.") + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.universal_three_qubits( + state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.universal_three_qubits( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state diff --git a/paddle_quantum/gate/single_qubit_gate.py b/paddle_quantum/gate/single_qubit_gate.py new file mode 100644 index 0000000..1bc3e78 --- /dev/null +++ b/paddle_quantum/gate/single_qubit_gate.py @@ -0,0 +1,640 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the classes for single-qubit gates. +""" + +import copy +import math +import numpy as np +import paddle.nn +import paddle_quantum +from . import functional +from .base import Gate +from ..backend import Backend +from paddle_quantum.intrinsic import _format_qubits_idx, _get_float_dtype +from typing import Optional, Union, Iterable + + +class H(Gate): + r"""A collection of single-qubit Hadamard gates. + + The matrix form of such a gate is: + + .. math:: + + H = \frac{1}{\sqrt{2}} + \begin{bmatrix} + 1&1\\ + 1&-1 + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, int, str]] = 'full', num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 'h', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubit_idx in self.qubits_idx: + state = functional.h(state, qubit_idx, self.dtype, self.backend) + return state + + +class S(Gate): + r"""A collection of single-qubit S gates. + + The matrix form of such a gate is: + + .. math:: + + S = + \begin{bmatrix} + 1&0\\ + 0&i + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, int, str]] = 'full', num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 's', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubit_idx in self.qubits_idx: + state = functional.s(state, qubit_idx, self.dtype, self.backend) + return state + + +class T(Gate): + r"""A collection of single-qubit T gates. + + The matrix form of such a gate is: + + .. math:: + + T = + \begin{bmatrix} + 1&0\\ + 0&e^\frac{i\pi}{4} + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, int, str]] = 'full', num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 't', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubit_idx in self.qubits_idx: + state = functional.t(state, qubit_idx, self.dtype, self.backend) + return state + + +class X(Gate): + r"""A collection of single-qubit X gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{bmatrix} + 0 & 1 \\ + 1 & 0 + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, int, str]] = 'full', num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 'x', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubit_idx in self.qubits_idx: + state = functional.x(state, qubit_idx, self.dtype, self.backend) + return state + + +class Y(Gate): + r"""A collection of single-qubit Y gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{bmatrix} + 0 & -i \\ + i & 0 + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, int, str]] = 'full', num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 'y', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubit_idx in self.qubits_idx: + state = functional.y(state, qubit_idx, self.dtype, self.backend) + return state + + +class Z(Gate): + r"""A collection of single-qubit Z gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{bmatrix} + 1 & 0 \\ + 0 & -1 + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + def __init__(self, qubits_idx: Optional[Union[Iterable, int, str]] = 'full', num_qubits: Optional[int] = None, depth: Optional[int] = 1): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.gate_history.append({ + 'gate_name': 'z', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + }) + return state + for _ in range(0, self.depth): + for qubit_idx in self.qubits_idx: + state = functional.z(state, qubit_idx, self.dtype, self.backend) + return state + + +class P(Gate): + r"""A collection of single-qubit P gates. + + The matrix form of such a gate is: + + .. math:: + + \begin{bmatrix} + 1 & 0 \\ + 0 & e^{i\theta} + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, int, str]] = 'full', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [1] + else: + param_shape = list(np.shape(self.qubits_idx)) + param_shape = [self.depth] + param_shape + if param is None: + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + else: + if isinstance(param, float): + initializer = paddle.nn.initializer.Constant(param) + elif isinstance(param, paddle.Tensor): + initializer = paddle.nn.initializer.Assign(param.reshape(param_shape)) + else: + raise ValueError("The param must be paddle.Tensor or float.") + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + raise NotImplementedError + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.p(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.p( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class RX(Gate): + r"""A collection of single-qubit rotation gates about the x-axis. + + The matrix form of such a gate is: + + .. math:: + + \begin{bmatrix} + \cos\frac{\theta}{2} & -i\sin\frac{\theta}{2} \\ + -i\sin\frac{\theta}{2} & \cos\frac{\theta}{2} + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, int, str]] = 'full', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [1] + else: + param_shape = list(np.shape(self.qubits_idx)) + param_shape = [self.depth] + param_shape + if param is None: + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + ) + self.add_parameter('theta', theta) + elif isinstance(param, paddle.Tensor): + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=paddle.nn.initializer.Assign(param.reshape(param_shape)) + ) + self.add_parameter('theta', theta) + elif isinstance(param, float): + self.theta = paddle.ones(param_shape, dtype=float_dtype) * param + else: + raise ValueError("The param must be paddle.Tensor or float.") + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.param_list.extend(self.theta) + if self.param_sharing: + param_idx_list = [[state.num_param]] + state.num_param += 1 + else: + param_idx_list = [] + for _ in range(0, self.depth): + param_idx_list.append(list(range(state.num_param, state.num_param + len(self.qubits_idx)))) + state.num_param += self.theta.size + state.gate_history.append({ + 'gate_name': 'rx', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + 'param': param_idx_list, + 'param_sharing': self.param_sharing, + }) + return state + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.rx(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.rx( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class RY(Gate): + r"""A collection of single-qubit rotation gates about the y-axis. + + The matrix form of such a gate is: + + .. math:: + + \begin{bmatrix} + \cos\frac{\theta}{2} & -\sin\frac{\theta}{2} \\ + \sin\frac{\theta}{2} & \cos\frac{\theta}{2} + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, int, str]] = 'full', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [1] + else: + param_shape = list(np.shape(self.qubits_idx)) + param_shape = [self.depth] + param_shape + if param is None: + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + ) + self.add_parameter('theta', theta) + elif isinstance(param, paddle.Tensor): + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=paddle.nn.initializer.Assign(param.reshape(param_shape)) + ) + self.add_parameter('theta', theta) + elif isinstance(param, float): + self.theta = paddle.ones(param_shape, dtype=float_dtype) * param + else: + raise ValueError("The param must be paddle.Tensor or float.") + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.param_list.extend(self.theta) + if self.param_sharing: + param_idx_list = [[state.num_param]] + state.num_param += 1 + else: + param_idx_list = [] + for _ in range(0, self.depth): + param_idx_list.append(list(range(state.num_param, state.num_param + len(self.qubits_idx)))) + state.num_param += len(self.qubits_idx) + state.gate_history.append({ + 'gate_name': 'ry', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + 'param': param_idx_list, + 'param_sharing': self.param_sharing, + }) + return state + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.ry(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.ry( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class RZ(Gate): + r"""A collection of single-qubit rotation gates about the z-axis. + + The matrix form of such a gate is: + + .. math:: + + \begin{bmatrix} + e^{-i\frac{\theta}{2}} & 0 \\ + 0 & e^{i\frac{\theta}{2}} + \end{bmatrix} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, int, str]] = 'full', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, float]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [1] + else: + param_shape = list(np.shape(self.qubits_idx)) + param_shape = [self.depth] + param_shape + if param is None: + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + ) + self.add_parameter('theta', theta) + elif isinstance(param, paddle.Tensor): + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=paddle.nn.initializer.Assign(param.reshape(param_shape)) + ) + self.add_parameter('theta', theta) + elif isinstance(param, float): + self.theta = paddle.ones(param_shape, dtype=float_dtype) * param + else: + raise ValueError("The param must be paddle.Tensor or float.") + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.param_list.extend(self.theta) + if self.param_sharing: + param_idx_list = [[state.num_param]] + state.num_param += 1 + else: + param_idx_list = [] + for _ in range(0, self.depth): + param_idx_list.append(list(range(state.num_param, state.num_param + len(self.qubits_idx)))) + state.num_param += self.theta.size + state.gate_history.append({ + 'gate_name': 'rz', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + 'param': param_idx_list, + 'param_sharing': self.param_sharing, + }) + return state + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.rz(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.rz( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state + + +class U3(Gate): + r"""A collection of single-qubit rotation gates. + + The matrix form of such a gate is: + + .. 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} + \end{align} + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + + Raises: + ValueError: The ``param`` must be ``paddle.Tensor`` or ``float``. + """ + def __init__( + self, qubits_idx: Optional[Union[Iterable, int, str]] = 'full', num_qubits: Optional[int] = None, depth: Optional[int] = 1, + param: Optional[Union[paddle.Tensor, Iterable[float]]] = None, param_sharing: Optional[bool] = False + ): + super().__init__(depth) + self.qubits_idx = _format_qubits_idx(qubits_idx, num_qubits, is_single_qubit_gate=True) + self.param_sharing = param_sharing + float_dtype = _get_float_dtype(self.dtype) + + if param_sharing: + param_shape = [3] + else: + param_shape = list(np.shape(self.qubits_idx)) + [3] + param_shape = [self.depth] + param_shape + if param is None: + initializer = paddle.nn.initializer.Uniform(low=0, high=2 * math.pi) + else: + if isinstance(param, float): + initializer = paddle.nn.initializer.Constant(param) + elif isinstance(param, paddle.Tensor): + initializer = paddle.nn.initializer.Assign(param.reshape(param_shape)) + else: + raise ValueError("The param must be paddle.Tensor or float.") + theta = self.create_parameter( + shape=param_shape, dtype=float_dtype, + default_initializer=initializer + ) + self.add_parameter('theta', theta) + + def forward(self, state: paddle_quantum.State) -> paddle_quantum.State: + if self.backend == Backend.QuLeaf and state.backend == Backend.QuLeaf: + state.param_list.extend(self.theta) + if self.param_sharing: + param_idx_list = [range(state.num_param, state.num_param + 3)] + state.num_param += 3 + else: + param_idx_list = [] + for _ in range(0, self.depth): + param_idx_list.append(list(range(state.num_param, state.num_param + len(self.qubits_idx)))) + state.num_param += self.theta.size + state.gate_history.append({ + 'gate_name': 'u3', + 'qubits_idx': copy.deepcopy(self.qubits_idx), + 'depth': self.depth, + 'param': param_idx_list, + 'param_sharing': self.param_sharing, + }) + return state + for depth_idx in range(0, self.depth): + if self.param_sharing: + for qubit_idx in self.qubits_idx: + state = functional.u3(state, self.theta[depth_idx], qubit_idx, self.dtype, self.backend) + else: + for param_idx, qubit_idx in enumerate(self.qubits_idx): + state = functional.u3( + state, self.theta[depth_idx, param_idx], qubit_idx, self.dtype, self.backend) + return state diff --git a/paddle_quantum/gradtool.py b/paddle_quantum/gradtool.py index 8ec169e..93b7022 100644 --- a/paddle_quantum/gradtool.py +++ b/paddle_quantum/gradtool.py @@ -1,3 +1,4 @@ +# !/usr/bin/env python3 # Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -12,100 +13,62 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" -梯度分析工具模块 +r""" +The module of the gradient tool. """ +from typing import Any, Callable, Tuple, List import numpy as np import paddle -from paddle import reshape +import paddle_quantum +from paddle_quantum.ansatz import Circuit +from math import pi from random import choice from tqdm import tqdm import matplotlib.pyplot as plt __all__ = [ - "StateNet", "show_gradient", + "plot_distribution", "random_sample", - "random_sample_supervised", "plot_loss_grad", "plot_supervised_loss_grad", - "plot_distribution" + "random_sample_supervised" ] -class StateNet(paddle.nn.Layer): - r"""定义用于量子机器学习的量子神经网络模型 - - 用户可以通过实例化该类定义自己的量子神经网络模型。 - """ - - def __init__(self, shape, dtype='float64'): - r"""构造函数，用于实例化一个 ``StateNet`` 对象 - - Args: - shape (paddle.Tensor): 表示传入的量子电路中的需要被优化的参数个数 - """ - super(StateNet, self).__init__() - self.theta = self.create_parameter(shape=shape, - default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*np.pi), - dtype=dtype, is_bias=False) - - def forward(self, circuit, loss_func, *args): - r"""用于更新电路参数并计算该量子神经网络的损失值。 - - Args: - circuit (UAnsatz): 表示传入的参数化量子电路，即要训练的量子神经网络 - loss_func (function): 表示计算该量子神经网络损失值的函数 - *args (list): 表示用于损失函数计算的额外参数列表 - - Note: - 这里的 ``loss_func`` 是一个用户自定义的计算损失值的函数，参数为电路和一个可变参数列表。 - - Returns: - tuple: 包含如下两个元素: - - loss (paddle.Tensor): 表示该量子神经网络损失值 - - circuit (UAnsatz): 更新参数后的量子电路 - """ - circuit.update_param(self.theta) - circuit.run_state_vector() - loss = loss_func(circuit, *args) - return loss, circuit - - -def show_gradient(circuit, loss_func, ITR, LR, *args): - r"""计算量子神经网络中各可变参数的梯度值和损失函数值 +def show_gradient(circuit: Circuit, loss_func: Callable[[Circuit, Any], paddle.Tensor], + ITR: int, LR: float, *args: Any) -> Tuple[List[float], List[float]]: + r"""Calculate the gradient and loss function for every parameter in QNN. Args: - circuit (UAnsatz): 表示传入的参数化量子电路，即要训练的量子神经网络 - loss_func (function): 表示计算该量子神经网络损失值的函数 - ITR (int): 表示训练的次数 - LR (float): 表示学习训练的速率 - *args (list): 表示用于损失函数计算的额外参数列表 + circuit: QNN to be trained. + loss_func: Loss function that evaluates the QNN. + ITR: Number of iterations. + LR: Learning rate. + *args: Parameters for ``loss_func`` other than ``circuit``. Returns: - tuple: 包含如下两个元素: - - loss_list (list): 表示损失函数值随训练次数变化的列表 - - grad_list(list): 表示各参数梯度随训练次变化的列表 + Contains following two elements. + - loss_list: A list of losses for each iteration. + - grad_list: A list of gradients for each iteration. """ - grad_list = [] loss_list = [] - shape = paddle.shape(circuit.get_param()) - net = StateNet(shape=shape) - opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters()) - pbar = tqdm( desc="Training: ", total=ITR, ncols=100, ascii=True ) + + # randomize initial parameters + circuit.randomize_param() + opt = paddle.optimizer.Adam(learning_rate=LR, parameters=circuit.parameters()) - for itr in range(ITR): + for _ in range(ITR): pbar.update(1) - loss, cir = net(circuit, loss_func, *args) + loss = loss_func(circuit, *args) loss.backward() - grad = net.theta.grad.numpy() - grad_list.append(grad) + grad_list.append(circuit.grad) loss_list.append(loss.numpy()[0]) opt.minimize(loss) opt.clear_grad() @@ -114,13 +77,12 @@ def show_gradient(circuit, loss_func, ITR, LR, *args): return loss_list, grad_list -def plot_distribution(grad): - r"""根据输入的梯度的列表，画出梯度的分布图 +def plot_distribution(grad: np.ndarray) -> None: + r"""Plot the distribution map according to the input gradients. Args: - grad (np.array): 表示量子神经网络某参数的梯度列表 + grad: List of gradients with respect to a parameter. """ - grad = np.abs(grad) grad_list = [0, 0, 0, 0, 0] x = ['<0.0001', ' (0.0001,0.001)', '(0.001,0.01)', '(0.01,0.1)', '>0.1'] @@ -144,43 +106,41 @@ def plot_distribution(grad): plt.show() -def random_sample(circuit, loss_func, sample_num, *args, mode='single', if_plot=True, param=0): - r"""表示对模型进行随机采样，根据不同的计算模式，获得对应的平均值和方差 +def random_sample(circuit: Circuit, loss_func: Callable[[Circuit, Any], paddle.Tensor], sample_num: int, *args: Any, + mode: str = 'single', if_plot: bool = True, param: int = 0) -> Tuple[List[float], List[float]]: + r"""Randomly sample the model. Obtain mean and variance of gradients according to different calculation modes. Args: - circuit (UAnsatz): 表示传入的参数化量子电路，即要训练的量子神经网络 - loss_func (function): 表示计算该量子神经网络损失值的函数 - sample_num (int): 表示随机采样的次数 - mode (string): 表示随机采样后的计算模式，默认为 'single' - if_plot(boolean): 表示是否对梯度进行画图表示 - param (int): 表示 ``Single`` 模式中对第几个参数进行画图，默认为第一个参数 - *args (list): 表示用于损失函数计算的额外参数列表 + circuit: QNN to be trained. + loss_func: Loss function that evaluates the QNN. + sample_num: Number of samplings. + mode: Mode for calculation. Defaults to ``'single'``. + if_plot: Whether plot the calculation. Defaults to ``True``. + param: Which parameter to be plotted in single mode, Defaults to ``0``, which means the first one. + *args: Parameters for ``loss_func`` other than ``circuit``. Note: - 在本函数中提供了三种计算模式，``mode`` 分别可以选择 ``'single'``, ``'max'``, 以及 ``'random'`` - - mode='single': 表示计算电路中的每个可变参数梯度的平均值和方差 - - mode='max': 表示对电路中每轮采样的所有参数梯度的最大值求平均值和方差 - - mode='random': 表示对电路中每轮采样的所有参数随机取一个梯度，求平均值和方差 + This function provides three calculation modes: single, max and random. + - In single mode, we calculate the mean and variance of gradients of every trainable parameter. + - In max mode, we calculate the mean and variance of maximum gradients of for every trainable parameter. + - In random mode, we calculate the mean and variance of data randomly extracted from gradients of every trainable parameter. Returns: - tuple: 包含如下两个元素: - - loss_list (list): 表示多次采样后损失函数值的列表 - - grad_list(list): 表示多次采样后各参数梯度的列表 + Contains the following two elements. + - loss_list: A list of losses for each iteration. + - grad_list: A list of gradients for each iteration. """ - loss_list, grad_list = [], [] pbar = tqdm( desc="Sampling: ", total=sample_num, ncols=100, ascii=True ) - for itr in range(sample_num): + for _ in range(sample_num): pbar.update(1) - shape = paddle.shape(circuit.get_param()) - net = StateNet(shape=shape) - loss, cir = net(circuit, loss_func, *args) + circuit.randomize_param() + loss = loss_func(circuit, *args) loss.backward() - grad = net.theta.grad.numpy() loss_list.append(loss.numpy()[0]) - grad_list.append(grad) + grad_list.append(circuit.grad) pbar.close() @@ -238,16 +198,15 @@ def random_sample(circuit, loss_func, sample_num, *args, mode='single', if_plot= return loss_list, grad_list -def plot_loss_grad(circuit, loss_func, ITR, LR, *args): - r"""绘制损失值和梯度随训练次数变化的图 - +def plot_loss_grad(circuit: Circuit, loss_func: Callable[[Circuit, Any], paddle.Tensor], ITR: int, LR: float, *args: Any) -> None: + r"""Plot the distribution maps between loss values & gradients and number of iterations. + Args: - circuit (UAnsatz): 表示传入的参数化量子电路，即要训练的量子神经网络 - loss_func (function): 表示计算该量子神经网络损失值的函数 - ITR (int): 表示训练的次数 - LR (float): 表示学习训练的速率 - *args (list): 表示用于损失函数计算的额外参数列表 - + circuit: QNN to be trained. + loss_func: Loss function that evaluate QNN. + ITR: Number of iterations. + LR: Learning rate. + *args: Parameters for ``loss_func`` other than ``circuit``. """ loss, grad = show_gradient(circuit, loss_func, ITR, LR, *args) plt.xlabel(r"Iteration") @@ -264,24 +223,25 @@ def plot_loss_grad(circuit, loss_func, ITR, LR, *args): plt.show() -def plot_supervised_loss_grad(circuit, loss_func, N, EPOCH, LR, BATCH, TRAIN_X, TRAIN_Y, *args): - r"""绘制监督学习中损失值和梯度随训练次数变化的图 +def plot_supervised_loss_grad(circuit: Circuit, loss_func: Callable[[Circuit, Any], paddle.Tensor], N: int, EPOCH: int, LR: float, + BATCH: int, TRAIN_X: paddle.Tensor, TRAIN_Y: list, *args: Any) -> Tuple[List[float], List[float]]: + r""" plot the distribution maps between loss values & gradients and number of iterations in supervised training Args: - circuit (UAnsatz): 表示传入的参数化量子电路，即要训练的量子神经网络 - loss_func (function): 表示计算该量子神经网络损失值的函数 - N (int): 表示量子比特的数量 - EPOCH (int): 表示训练的轮数 - LR (float): 表示学习训练的速率 - BATCH (int): 表示训练时 batch 的大小 - TRAIN_X (paddle.Tensor): 表示训练数据集 - TRAIN_Y (list): 表示训练数据集的标签 - *args (list): 表示用于损失函数计算的额外参数列表 + circuit: QNN ready to be trained. + loss_func: Loss function that evaluates the QNN. + N: Number of qubits. + EPOCH: Number of training iterations. + LR: Learning rate. + BATCH: Size of batches. + TRAIN_X: Data set . + TRAIN_Y: Label set. + *args: Parameters for ``loss_func`` other than ``circuit``. Returns: - tuple: 包含如下两个元素: - - loss_list (list): 表示多次训练的损失函数值列表 - - grad_list(list): 表示多次训练后各参数梯度的列表 + Contains the following two elements. + - loss_list: A list of losses for each iteration. + - grad_list: A list of gradients for each iteration. """ grad_list = [] loss_list = [] @@ -289,19 +249,18 @@ def plot_supervised_loss_grad(circuit, loss_func, N, EPOCH, LR, BATCH, TRAIN_X, if type(TRAIN_X) != paddle.Tensor: raise Exception("Training data should be paddle.Tensor type") - shape = paddle.shape(circuit.get_param()) - net = StateNet(shape=shape) - opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters()) + circuit.randomize_param() + opt = paddle.optimizer.Adam(learning_rate=LR, parameters=circuit.parameters()) - for ep in range(EPOCH): + for _ in range(EPOCH): for itr in range(len(TRAIN_X)//BATCH): input_state = TRAIN_X[itr*BATCH:(itr+1)*BATCH] - input_state = reshape(input_state, [-1, 1, 2**N]) + input_state = input_state.reshape([-1, 1, 2**N]) label = TRAIN_Y[itr * BATCH:(itr + 1) * BATCH] - loss, circuit = net(circuit, loss_func, input_state, label) + + loss = loss_func(circuit, input_state, label) loss.backward() - grad = net.theta.grad.numpy() - grad_list.append(grad) + grad_list.append(circuit.grad) loss_list.append(loss.numpy()[0]) opt.minimize(loss) opt.clear_grad() @@ -322,56 +281,53 @@ def plot_supervised_loss_grad(circuit, loss_func, N, EPOCH, LR, BATCH, TRAIN_X, return loss_list, grad_list -def random_sample_supervised(circuit, loss_func, N, sample_num, BATCH, TRAIN_X, TRAIN_Y, *args, mode='single', if_plot=True, param=0): - r"""表示对监督学习模型进行随机采样，根据不同的计算模式，获得对应的平均值和方差 +def random_sample_supervised(circuit: Circuit, loss_func: Callable[[Circuit, Any], paddle.Tensor], + N: int, sample_num: int, BATCH: int, TRAIN_X: paddle.Tensor, TRAIN_Y: paddle.Tensor, + *args: Any, mode: str = 'single', if_plot: bool = True, param: int = 0) -> Tuple[List[float], List[float]]: + r"""Random sample the supervised model. Obtain mean and variance of gradients according to different calculation modes. Args: - circuit (UAnsatz): 表示传入的参数化量子电路，即要训练的量子神经网络 - loss_func (function): 表示计算该量子神经网络损失值的函数 - N (int): 表示量子比特的数量 - sample_num (int): 表示随机采样的次数 - BATCH (int): 表示训练时 batch 的大小 - TRAIN_X (paddle.Tensor): 表示训练数据集 - TRAIN_Y (list): 表示训练数据集的标签 - mode (string): 表示随机采样后的计算模式，默认为 'single' - if_plot(boolean): 表示是否对梯度进行画图表示 - param (int): 表示 ``Single`` 模式中对第几个参数进行画图，默认为第一个参数 - *args (list): 表示用于损失函数计算的额外参数列表 + circuit: QNN to be trained. + loss_func: Loss function that evaluates the QNN. + N: Number of qubits. + sample_num: Number of samplings. + BATCH: Size of batches. + TRAIN_X: Data set. + TRAIN_Y: Label set. + mode: Mode for calculation. Defaults to ``'single'``. + if_plot: Whether plot the calculation. Defaults to ``True``. + param: Which parameter to be plotted in single mode. Defaults to ``0``, which means the first one. + *args: Parameters for ``loss_func`` other than ``circuit``. Note: - 在本函数中提供了三种计算模式，``mode`` 分别可以选择 ``'single'``, ``'max'``, 以及 ``'random'`` - - mode='single': 表示计算电路中的每个可变参数梯度的平均值和方差 - - mode='max': 表示对电路中所有参数梯度的最大值求平均值和方差 - - mode='random': 表示随机对电路中采样的所有参数随机取一个梯度，求平均值和方差 + This function provides three calculation modes: single, max and random. + - In single mode, we calculate the mean and variance of gradients of every trainable parameters. + - In max mode, we calculate the mean and variance of maximum gradients of for every trainable parameters. + - In random mode, we calculate the mean and variance of data randomly extracted from gradients of every trainable parameters. Returns: - tuple: 包含如下两个元素: - - loss_list (list): 表示多次采样后损失函数值的列表 - - grad_list(list): 表示多次采样后各参数梯度的列表 + Contains the following two elements. + - loss_list: A list of losses for each iteration. + - grad_list: A list of gradients for each iteration. """ grad_list = [] loss_list = [] input_state = TRAIN_X[0:BATCH] - input_state = reshape(input_state, [-1, 1, 2**N]) + input_state = input_state.reshape([-1, 1, 2**N]) label = TRAIN_Y[0: BATCH] if type(TRAIN_X) != paddle.Tensor: raise Exception("Training data should be paddle.Tensor type") - label = TRAIN_Y[0: BATCH] - pbar = tqdm( desc="Sampling: ", total=sample_num, ncols=100, ascii=True ) for idx in range(sample_num): pbar.update(1) - shape = paddle.shape(circuit.get_param()) - net = StateNet(shape=shape) - - loss, circuit = net(circuit, loss_func, input_state, label) + circuit.randomize_param() + loss = loss_func(circuit, input_state, label) loss.backward() - grad = net.theta.grad.numpy() - grad_list.append(grad) + grad_list.append(circuit.grad) loss_list.append(loss.numpy()[0]) pbar.close() diff --git a/paddle_quantum/hamiltonian.py b/paddle_quantum/hamiltonian.py new file mode 100644 index 0000000..95d7e3b --- /dev/null +++ b/paddle_quantum/hamiltonian.py @@ -0,0 +1,409 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The module of the hamiltonian class. +""" + +import copy +import re +from typing import Optional, Tuple +import numpy as np +from scipy import sparse +import paddle +import paddle_quantum + + +class Hamiltonian: + r"""Hamiltonian ``class`` in Paddle Quantum. + + User can instantiate the ``class`` with a Pauli string. + + Args: + pauli_str: A list of Hamiltonian information, e.g. ``[(1, 'Z0, Z1'), (2, 'I')]`` + compress: Determines whether the input list will be automatically merged (e.g. ``(1, 'Z0, Z1')`` and ``(2, 'Z1, Z0')``, these two items will be automatically merged). + Defaults to ``True``. + + Returns: + Create a Hamiltonian class + + Note: + If ``compress=False``, the legitimacy of the input will not be checked. + """ + + def __init__(self, pauli_str: list, compress: Optional[bool] = True): + 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, 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) -> int: + r"""Number of terms of the hamiltonian. + """ + return len(self.__pauli_str) + + @property + def pauli_str(self) -> list: + r"""The Pauli string corresponding to the hamiltonian. + """ + return self.__pauli_str + + @property + def terms(self) -> list: + r"""All items in hamiltonian, i.e. ``[['Z0, Z1'], ['I']]``. + """ + if self.__update_flag: + self.__decompose() + return self.__terms + else: + return self.__terms + + @property + def coefficients(self) -> list: + r"""The coefficient of each term in the Hamiltonian，i.e. ``[1.0, 2.0]``. + """ + if self.__update_flag: + self.__decompose() + return self.__coefficients + else: + return self.__coefficients + + @property + def pauli_words(self) -> list: + r"""The Pauli word of each term，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) -> list: + r"""A list of Pauli word (exclude I)，i.e. ``['ZXZZ', 'Z', 'X']``. + """ + if self.__update_flag: + self.__decompose() + return self.__pauli_words_r + else: + return self.__pauli_words_r + + @property + def pauli_words_matrix(self) -> list: + r"""The list of matrices with respect to simplied Pauli words. + """ + + def to_matrix(string): + matrix = paddle.to_tensor([1 + 0j], dtype=paddle_quantum.get_dtype()) + for i in range(len(string)): + if string[i] == 'X': + matrix = paddle.kron( + matrix, + paddle.to_tensor([[0, 1], [1, 0]], dtype=paddle_quantum.get_dtype()) + ) + elif string[i] == 'Y': + matrix = paddle.kron( + matrix, + paddle.to_tensor([[0j, -1j], [1j, 0j]], dtype=paddle_quantum.get_dtype()) + ) + elif string[i] == 'Z': + matrix = paddle.kron( + matrix, + paddle.to_tensor([[1, 0], [0, -1]], dtype=paddle_quantum.get_dtype()) + ) + elif string[i] == 'I': + matrix = paddle.kron( + matrix, + paddle.to_tensor([[1, 0], [0, 1]], dtype=paddle_quantum.get_dtype()) + ) + else: + raise ValueError('wrong format of string ' + string) + return matrix + + return list(map(to_matrix, copy.deepcopy(self.pauli_words_r))) + + @property + def sites(self) -> list: + r"""A list of qubits index corresponding to the hamiltonian. + """ + if self.__update_flag: + self.__decompose() + return self.__sites + else: + return self.__sites + + @property + def n_qubits(self) -> int: + r"""Number of qubits. + """ + 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) -> Tuple[list]: + r"""Decompose pauli_str into coefficients, a simplified form of Pauli strings, and the indices of qubits on which the Pauli operators act on. + + Returns: + A tuple containing the following elements: + - coefficients: the coefficient for each term. + - pauli_words_r: the simplified form of the Pauli string for each item, e.g. the Pauli word of 'Z0, Z1, X3' is 'ZZX'. + - sites: a list of qubits index, e.g. the site of 'Z0, Z1, X3' is [0, 1, 3]. + """ + if self.__update_flag: + self.__decompose() + return self.coefficients, self.__pauli_words_r, self.__sites + + def decompose_pauli_words(self) -> Tuple[list]: + r"""Decompose pauli_str into coefficients and Pauli strings. + + Returns: + A tuple containing the following elements: + - coefficients: the coefficient for each term. + - the Pauli string for each item, e.g. the Pauli word of 'Z0, Z1, X3' is 'ZZIX'. + """ + if self.__update_flag: + self.__decompose() + else: + pass + return self.coefficients, self.__pauli_words + + def construct_h_matrix(self, qubit_num: Optional[int] = None) -> np.ndarray: + r"""Construct a matrix form of the Hamiltonian in Z-basis. + + Args: + qubit_num: The number of qubits. Defaults to ``1``. + + Returns: + The matrix form of the Hamiltonian in Z-basis. + """ + coefs, pauli_words, sites = self.decompose_with_sites() + if qubit_num is None: + qubit_num = 1 + for site in sites: + if type(site[0]) is int: + qubit_num = max(qubit_num, max(site) + 1) + else: + assert qubit_num >= self.n_qubits, "输入的量子数不小于哈密顿量表达式中所对应的量子比特数" + n_qubit = qubit_num + 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"""The spin operators in matrix forms, could be used to construct Hamiltonian matrix or spin observables. + + Args: + size: Size of the system (number of qubits). + use_sparse: Decide whether to use the sparse matrix to calculate. Default is ``False``. + """ + + def __init__(self, size: int, use_sparse: Optional[bool] = False): + self.size = size + self.id = sparse.eye(2, dtype='complex64') + self.__sigz = sparse.bsr_matrix([[1, 0], [0, -1]], dtype='complex64') + self.__sigy = sparse.bsr_matrix([[0, -1j], [1j, 0]], dtype='complex64') + self.__sigx = sparse.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)) + + @property + def sigz_p(self) -> list: + r""" A list of :math:`S^z_i` operators, different elements correspond to different indices :math:`i`. + """ + return self.__sigz_p + + @property + def sigy_p(self) -> list: + r""" A list of :math:`S^y_i` operators, different elements correspond to different indices :math:`i`. + """ + return self.__sigy_p + + @property + def sigx_p(self) -> list: + r""" A list of :math:`S^x_i` operators, different elements correspond to different indices :math:`i`. + """ + return self.__sigx_p + + 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() diff --git a/paddle_quantum/intrinsic.py b/paddle_quantum/intrinsic.py index 7e7b4e3..5f07a68 100644 --- a/paddle_quantum/intrinsic.py +++ b/paddle_quantum/intrinsic.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2020 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. @@ -12,156 +13,65 @@ # See the License for the specific language governing permissions and # limitations under the License. -import math -from functools import wraps +r""" +The intrinsic function of the paddle quantum. +""" + import numpy as np -from numpy import binary_repr -import re import paddle -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): - r""" - :param n: number of qubits - :return: dictionary between binary and decimal - - for example: if n=3, the dictionary is - dic2to10: {'000': 0, '011': 3, '010': 2, '111': 7, '100': 4, '101': 5, '110': 6, '001': 1} - dic10to2: ['000', '001', '010', '011', '100', '101', '110', '111'] - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - dic2to10 = {} - dic10to2 = [None] * 2 ** n - - for i in range(2 ** n): - binary_text = binary_repr(i, width=n) - dic2to10[binary_text] = i - dic10to2[i] = binary_text - - return dic2to10, dic10to2 # the returned dic will have 2 ** n value - - -def single_H_vec_i(H, target_vec): - r""" - If H = 'x0,z1,z2,y3,z5', target_vec = '100111', then it returns H * target_vec, which we record as [1j, '000011'] - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - 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: - 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': - new_vec[pos] = '0' if target_vec[pos] == '1' else '1' - coef *= 1j if target_vec[pos] == '0' else -1j - elif op[0] == 'z': - new_vec[pos] = target_vec[pos] - coef *= 1 if target_vec[pos] == '0' else -1 - - return [coef, ''.join(new_vec)] - - -def single_H_vec(H, vec): - r""" - If vec is a paddle variable [a1, a2, a3, a4], and H = 'x0,z1', then it returns H * vec, - which is [a3, -a4, a1, -a2] - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - old_vec = vec.numpy() - new_vec = np.zeros(len(old_vec)) + 0j - dic2to10, dic10to2 = dic_between2and10(int(math.log(len(old_vec), 2))) - # Iterate through all vectors in the computational basis - for i in range(len(old_vec)): - # If old_vec[i] is 0, the result is 0 - if old_vec[i] != 0: - coef, target_update = single_H_vec_i(H, dic10to2[i]) - index_update = dic2to10[target_update] - new_vec[index_update] = coef * old_vec[i] - return to_tensor(new_vec) - - -def H_vec(H, vec): - r""" - If H = [[0.2, 'x0,z1'], [0.6, 'x0'], [0.1, 'z1'], [-0.7, 'y0,y1']], then it returns H * vec - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - coefs = to_tensor(np.array([coef for coef, Hi in H], dtype=np.float64)) - # Convert all strings to lowercase - H_list = [Hi.lower() for coef, Hi in H] - result = paddle.zeros(shape=vec.shape, dtype='float64') - for i in range(len(coefs)): - xi = multiply(coefs[i], single_H_vec(H_list[i], vec)) - result = add(result, xi) - return result - - -def vec_expecval(H, vec): - r""" - It returns expectation value of H with respect to vector vec - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - vec_conj = paddle.conj(vec) - result = paddle.sum(multiply(vec_conj, H_vec(H, vec))) - return result - - -def transfer_by_history(state, history, params): - r""" - It transforms the input state according to the history given. - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - for history_ele in history: - 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['gate'], which_qubit, params=parameter) - return state - - -def apply_channel(func): - r""" - Decorator for channels. - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - @wraps(func) - def inner(self, *args): - """ - args should include channel parameters and which_qubit - """ - which_qubit = args[-1] - 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({'gate': 'channel', 'operators': ops, 'which_qubits': [which_qubit]}) - - return inner \ No newline at end of file +from typing import Union, Iterable, List + + +def _zero(dtype): + return paddle.to_tensor(0, dtype=dtype) + + +def _one(dtype): + return paddle.to_tensor(1, dtype=dtype) + + +def _format_qubits_idx( + qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int, str], + num_qubits: int, is_single_qubit_gate: bool, num_acted_qubits: int = 0 +) -> Union[List[List[int]], List[int]]: + if is_single_qubit_gate: + if qubits_idx == 'full': + qubits_idx = list(range(0, num_qubits)) + elif qubits_idx == 'even': + qubits_idx = list(range(0, num_qubits, 2)) + elif qubits_idx == 'odd': + qubits_idx = list(range(1, num_qubits, 2)) + elif isinstance(qubits_idx, Iterable): + qubits_idx = list(qubits_idx) + else: + qubits_idx = [qubits_idx] + else: + if qubits_idx == 'cycle': + qubits_idx = [] + for idx in range(0, num_qubits - 1): + qubits_idx.append([idx, idx + 1]) + qubits_idx.append([num_qubits - 1, 0]) + elif qubits_idx == 'linear': + qubits_idx = [] + for idx in range(0, num_qubits - 1): + qubits_idx.append([idx, idx + 1]) + elif len(np.shape(qubits_idx)) == 1 and len(qubits_idx) == num_acted_qubits: + qubits_idx = [list(qubits_idx)] + elif len(np.shape(qubits_idx)) == 2 and all((len(indices) == num_acted_qubits for indices in qubits_idx)): + qubits_idx = [list(indices) for indices in qubits_idx] + else: + raise TypeError( + "The qubits_idx should be iterable such as list, tuple, and so on whose elements are all integers." + "And the length of acted_qubits should be consistent with the corresponding gate." + ) + return qubits_idx + + +def _get_float_dtype(complex_dtype: str) -> str: + if complex_dtype == 'complex64': + float_dtype = 'float32' + elif complex_dtype == 'complex128': + float_dtype = 'float64' + else: + raise ValueError("The dtype should be complex64 or complex128.") + return float_dtype diff --git a/paddle_quantum/linalg.py b/paddle_quantum/linalg.py new file mode 100644 index 0000000..e545e40 --- /dev/null +++ b/paddle_quantum/linalg.py @@ -0,0 +1,300 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The common linear algorithm in paddle quantum. +""" + +from typing import Optional +import paddle +import math +import numpy as np +import scipy +from functools import reduce + +import paddle_quantum + + +def abs_norm(mat: paddle.Tensor) -> float: + r""" tool for calculation of matrix norm + + Args: + mat: matrix + + Returns: + norm of mat + + """ + mat = mat.cast('complex64') + return paddle.norm(paddle.abs(mat)).item() + + +def dagger(mat: paddle.Tensor) -> paddle.Tensor: + r""" tool for calculation of matrix dagger + + Args: + mat: matrix + + Returns: + The dagger of matrix + + """ + return paddle.conj(mat.T) + + +def is_hermitian(mat: paddle.Tensor, eps: Optional[float] = 1e-6) -> bool: + r""" verify whether mat ``P`` is Hermitian + + Args: + mat: matrix + eps: tolerance of error + + Returns: + determine whether :math:`mat - mat^\dagger = 0` + + """ + shape = mat.shape + if len(shape) != 2 or shape[0] != shape[1] or math.log2(shape[0]) != math.ceil(math.log2(shape[0])): + # not a mat / not a square mat / shape is not in form 2^n x 2^n + return False + return abs_norm(mat - dagger(mat)) < eps + + +def is_projector(mat: paddle.Tensor, eps: Optional[float] = 1e-6) -> bool: + r""" verify whether mat ``P`` is a projector + + Args: + mat: matrix + eps: tolerance of error + + Returns: + determine whether :math:`PP - P = 0` + + """ + shape = mat.shape + if len(shape) != 2 or shape[0] != shape[1] or math.log2(shape[0]) != math.ceil(math.log2(shape[0])): + # not a mat / not a square mat / shape is not in form 2^n x 2^n + return False + return abs_norm(mat @ mat - mat) < eps + + +def is_unitary(mat: paddle.Tensor, eps: Optional[float] = 1e-5) -> bool: + r""" verify whether mat ``P`` is a unitary + + Args: + mat: matrix + eps: tolerance of error + + Returns: + determine whether :math:`PP^\dagger - I = 0` + + """ + shape = mat.shape + if len(shape) != 2 or shape[0] != shape[1] or math.log2(shape[0]) != math.ceil(math.log2(shape[0])): + # not a mat / not a square mat / shape is not in form 2^n x 2^n + return False + return abs_norm(mat @ dagger(mat) - paddle.cast(paddle.eye(shape[0]), mat.dtype)) < eps + + +def hermitian_random(num_qubits: int) -> paddle.Tensor: + r"""randomly generate a :math:`2^n \times 2^n` hermitian matrix + + Args: + num_qubits: log2(dimension) + + Returns: + a :math:`2^n \times 2^n` hermitian matrix + + """ + assert num_qubits > 0 + n = 2 ** num_qubits + vec = paddle.randn([n, n]) + 1j * paddle.randn([n, n]) + mat = vec @ dagger(vec) + return mat / paddle.trace(mat) + + +def orthogonal_projection_random(num_qubits: int) -> paddle.Tensor: + r"""randomly generate a :math:`2^n \times 2^n` rank-1 orthogonal projector + + Args: + num_qubits: log2(dimension) + + Returns: + a :math:`2^n \times 2^n` orthogonal projector and its eigenstate + """ + assert num_qubits > 0 + n = 2 ** num_qubits + vec = paddle.randn([n, 1]) + 1j * paddle.randn([n, 1]) + mat = vec @ dagger(vec) + return mat / paddle.trace(mat) + + +def unitary_hermitian_random(num_qubits: int) -> paddle.Tensor: + r"""randomly generate a :math:`2^n \times 2^n` hermitian unitary + + Args: + num_qubits: :math:`\log_{2}(dimension)` + + Returns: + a :math:`2^n \times 2^n` hermitian unitary matrix + + """ + proj_mat = orthogonal_projection_random(num_qubits) + id_mat = paddle.eye(2 ** num_qubits) + return (2 + 0j) * proj_mat - id_mat + + +def unitary_random_with_hermitian_block(num_qubits: int) -> paddle.Tensor: + r"""randomly generate a unitary :math:`2^n \times 2^n` matrix that is a block encoding of a :math:`2^{n/2} \times 2^{n/2}` Hermitian matrix + + Args: + num_qubits: :math:`\log_{2}(dimension)` + + Returns: + a :math:`2^n \times 2^n` unitary matrix that its upper-left block is a Hermitian matrix + + """ + assert num_qubits > 0 + dtype = paddle_quantum.get_dtype() + mat0 = hermitian_random(num_qubits - 1).numpy() + id_mat = np.eye(2 ** (num_qubits - 1)) + mat1 = 1j * scipy.linalg.sqrtm(id_mat - np.matmul(mat0, mat0)) + + mat = np.block([[mat0, mat1], [mat1, mat0]]) + + return paddle.to_tensor(mat, dtype=dtype) + + +def unitary_random(num_qubits: int) -> paddle.Tensor: + r"""randomly generate a :math:`2^n \times 2^n` unitary + + Args: + num_qubits: :math:`\log_{2}(dimension)` + + Returns: + a :math:`2^n \times 2^n` unitary matrix + + """ + unitary = scipy.stats.unitary_group(2 ** num_qubits) + return paddle.to_tensor(unitary) + + +def haar_orthogonal(num_qubits: int) -> paddle.Tensor: + r""" randomly generate an orthogonal matrix following Haar random, referenced by arXiv:math-ph/0609050v2 + + Args: + num_qubits: number of qubits + + Returns: + a :math:`2^n \times 2^n` orthogonal matrix + + """ + # Matrix dimension + dim = 2 ** num_qubits + # Step 1: sample from Ginibre ensemble + ginibre = (np.random.randn(dim, dim)) + # Step 2: perform QR decomposition of G + mat_q, mat_r = np.linalg.qr(ginibre) + # Step 3: make the decomposition unique + mat_lambda = np.diag(mat_r) / abs(np.diag(mat_r)) + mat_u = mat_q @ np.diag(mat_lambda) + return paddle.to_tensor(mat_u) + + +def haar_unitary(num_qubits: int) -> paddle.Tensor: + r""" randomly generate a unitary following Haar random, referenced by arXiv:math-ph/0609050v2 + + Args: + num_qubits: number of qubits + + Returns: + a :math:`2^n \times 2^n` unitary + + """ + # Matrix dimension + dim = 2 ** num_qubits + # Step 1: sample from Ginibre ensemble + ginibre = (np.random.randn(dim, dim) + 1j * np.random.randn(dim, dim)) / np.sqrt(2) + # Step 2: perform QR decomposition of G + mat_q, mat_r = np.linalg.qr(ginibre) + # Step 3: make the decomposition unique + mat_lambda = np.diag(mat_r) / np.abs(np.diag(mat_r)) + mat_u = mat_q @ np.diag(mat_lambda) + return paddle.to_tensor(mat_u) + + +def haar_state_vector(num_qubits: int, is_real: Optional[bool] = False) -> paddle.Tensor: + r""" randomly generate a state vector following Haar random + + Args: + num_qubits: number of qubits + is_real: whether the vector is real, default to be False + + Returns: + a :math:`2^n \times 1` state vector + + """ + # Vector dimension + dim = 2 ** num_qubits + if is_real: + # Generate a Haar random orthogonal matrix + mat_orthog = haar_orthogonal(num_qubits) + # Perform u onto |0>, i.e., the first column of o + phi = mat_orthog[:, 0] + else: + # Generate a Haar random unitary + unitary = haar_unitary(num_qubits) + # Perform u onto |0>, i.e., the first column of u + phi = unitary[:, 0] + + return paddle.to_tensor(phi) + + +def haar_density_operator(num_qubits: int, rank: Optional[int] = None, is_real: Optional[bool] = False) -> paddle.Tensor: + r""" randomly generate a density matrix following Haar random + + Args: + num_qubits: number of qubits + rank: rank of density matrix, default to be False refering to full ranks + is_real: whether the density matrix is real, default to be False + + Returns: + a :math:`2^n \times 2^n` density matrix + """ + dim = 2 ** num_qubits + rank = rank if rank is not None else dim + assert 0 < rank <= dim, 'rank is an invalid number' + if is_real: + ginibre_matrix = np.random.randn(dim, rank) + rho = ginibre_matrix @ ginibre_matrix.T + else: + ginibre_matrix = np.random.randn(dim, rank) + 1j * np.random.randn(dim, rank) + rho = ginibre_matrix @ ginibre_matrix.conj().T + rho = rho / np.trace(rho) + return paddle.to_tensor(rho / np.trace(rho)) + + +def NKron(matrix_A: np.ndarray, matrix_B: np.ndarray, *args: np.ndarray) -> np.ndarray: + r""" calculate Kronecker product of at least two matrices + + Args: + matrix_A: matrix + matrix_B: matrix + *args: other matrices + + Returns: + Kronecker product of matrices + """ + return reduce(lambda result, index: np.kron(result, index), args, np.kron(matrix_A, matrix_B), ) \ No newline at end of file diff --git a/paddle_quantum/locc.py b/paddle_quantum/locc.py deleted file mode 100644 index df6bc5e..0000000 --- a/paddle_quantum/locc.py +++ /dev/null @@ -1,1042 +0,0 @@ -# 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. - -import warnings -import numpy as np -import paddle -from paddle_quantum.circuit import UAnsatz -from paddle_quantum.utils import NKron, partial_trace, dagger -from paddle import matmul, trace, divide, kron, add, multiply -from paddle import sin, cos, real -from math import log2, sqrt - - -class LoccStatus(object): - r"""用于表示 LOCCNet 中的一个 LOCC 态节点。 - - 由于我们在 LOCC 中不仅关心量子态的解析形式，同时还关心得到它的概率，以及是经过怎样的测量而得到。因此该类包含三个成员变量：量子态 ``state`` 、得到这个态的概率 ``prob`` 和得到这个态的测量的测量结果是什么，即 ``measured_result`` 。 - - Attributes: - state (paddle.Tensor): 表示量子态的矩阵形式 - prob (paddle.Tensor): 表示得到这个量子态的概率 - measured_result (str): 表示得到这个态的测量函数的测量结果 - """ - - def __init__(self, state=None, prob=None, measured_result=None): - r"""构造函数，用于实例化一个 ``LoccStatus`` 对象。 - - Args: - state (paddle.Tensor): 默认为 ``None`` ，该 ``LoccStatus`` 的量子态的矩阵形式 - prob (paddle.Tensor): 默认为 ``None`` ，得到该量子态的概率 - measured_result (str): 默认为 ``None`` ，表示得到这个态的测量函数的测量结果 - """ - super(LoccStatus, self).__init__() - if state is None and prob is None and measured_result is None: - self.state = paddle.to_tensor(np.array([1], dtype=np.complex128)) - self.prob = paddle.to_tensor(np.array([1], dtype=np.float64)) - self.measured_result = "" - else: - self.state = state - self.prob = prob - self.measured_result = measured_result - - def clone(self): - r"""创建一个当前对象的副本。 - - Returns: - LoccStatus: 当前对象的副本 - """ - return LoccStatus(self.state, self.prob, self.measured_result) - - def __getitem__(self, item): - if item == 0: - return self.state - elif item == 1: - return self.prob - elif item == 2: - return self.measured_result - else: - raise ValueError("too many values to unpack (expected 3)") - - def __repr__(self): - return f"state: {self.state.numpy()}\nprob: {self.prob.numpy()[0]}\nmeasured_result: {self.measured_result}" - - def __str__(self): - return f"state: {self.state.numpy()}\nprob: {self.prob.numpy()[0]}\nmeasured_result: {self.measured_result}" - - -class LoccParty(object): - r"""LOCC 的参与方。 - - Attributes: - qubit_number (int): 参与方的量子比特数量 - """ - - def __init__(self, qubit_number): - r""" - 构造函数，用于实例化一个 ``LoccParty`` 对象。 - - Args: - qubit_number (int): 参与方的量子比特数量 - """ - super(LoccParty, self).__init__() - self.qubit_number = qubit_number - self.qubits = [None] * qubit_number - - def __setitem__(self, key, value): - self.qubits[key] = value - - def __getitem__(self, item): - return self.qubits[item] - - def __len__(self): - return self.qubit_number - - -class LoccAnsatz(UAnsatz): - r"""继承 ``UAnsatz`` 类，目的是建立在 LOCC 任务上的电路模板。 - - 在 LOCC 任务中，每一方参与者只能在自己的量子比特上进行量子操作。因此我们只允许在每一方的量子比特上添加本地电路门。 - - Attributes: - party (LoccParty): 参与方 - m (int): 参与方的量子比特数量 - """ - - def __init__(self, party, n): - r"""构造函数，用于实例化一个 ``LoccAnsatz`` 的对象。 - - Args: - party (LoccParty): 参与方 - n (int): 全局的量子比特数量 - """ - super(LoccAnsatz, self).__init__(n) - self.party = party - self.m = len(self.party) - self.measure = None - self.expecval = None - - def run(self, status=None): - r"""运行当前添加的电路门，并获得运行后的 LOCC 态节点。 - - Args: - status (LoccStatus or list): 作为LOCC下的量子电路的输入的 LOCC 态节点，其类型应该为 ``LoccStatus`` 或由其组成的 ``list`` - - Returns: - LoccStatus or list: 量子电路运行后得到的 LOCC 态节点,类型为 ``LoccStatus`` 或由其组成的 ``list`` - """ - if isinstance(status, LoccStatus): - assert int(log2(sqrt(status.state.numpy().size))) == self.n, "the length of qubits should be same" - state = super(LoccAnsatz, self).run_density_matrix(status.state) - new_status = LoccStatus(state, status.prob, status.measured_result) - elif isinstance(status, list): - assert int(log2(sqrt(status[0].state.numpy().size))) == self.n, "the length of qubits should be same" - new_status = list() - for each_status in status: - state = super(LoccAnsatz, self).run_density_matrix(each_status.state) - new_status.append(LoccStatus(state, each_status.prob, each_status.measured_result)) - else: - raise ValueError("can't recognize the input status") - - return new_status - - def rx(self, theta, which_qubit): - r"""添加关于 x 轴的单量子比特旋转门。 - - Args: - theta (Tensor): 量子门的角度 - which_qubit (int): 添加该门量子比特编号 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).rx(theta, which_qubit) - - def ry(self, theta, which_qubit): - r"""添加关于 y 轴的单量子比特旋转门。 - - Args: - theta (Tensor): 量子门的角度 - which_qubit (int): 添加该门量子比特编号 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).ry(theta, which_qubit) - - def rz(self, theta, which_qubit): - r"""添加关于 z 轴的单量子比特旋转门。 - - Args: - theta (Tensor): 量子门的角度 - which_qubit (int): 添加该门量子比特编号 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).rz(theta, which_qubit) - - def cnot(self, control): - r"""添加一个 CNOT 门。 - - Args: - control (list): 作用在的 qubit 的编号，``control[0]`` 为控制位，``control[1]`` 为目标位，其值都应该在 :math:`[0, m)` 范围内， :math:`m` 为该参与方的量子比特数 - """ - control = [self.party[which_qubit] for which_qubit in control] - super(LoccAnsatz, self).cnot(control) - - def swap(self, control): - r"""添加一个 SWAP 门。 - - Args: - control (list): 作用在的 qubit 的编号，``control[0]`` 和 ``control[1]`` 是想要交换的位，其值都应该在 :math:`[0, m)`范围内， :math:`m` 为该参与方的量子比特数 - """ - control = [self.party[which_qubit] for which_qubit in control] - super(LoccAnsatz, self).swap(control) - - def x(self, which_qubit): - r"""添加单量子比特 X 门。 - - Args: - which_qubit (int): 添加该门量子比特编号 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).x(which_qubit) - - def y(self, which_qubit): - r"""添加单量子比特 Y 门。 - - Args: - which_qubit (int): 添加该门量子比特编号 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).y(which_qubit) - - def z(self, which_qubit): - r"""添加单量子比特 Z 门。 - - Args: - which_qubit (int): 添加该门量子比特编号 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).z(which_qubit) - - def h(self, which_qubit): - r"""添加单量子比特 Hadamard 门。 - - Args: - which_qubit (int): 添加该门量子比特编号 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).h(which_qubit) - - def s(self, which_qubit): - r"""添加单量子比特 S 门。 - - Args: - which_qubit (int): 添加该门量子比特编号 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).s(which_qubit) - - def t(self, which_qubit): - r"""添加单量子比特 T 门。 - - Args: - which_qubit (int): 添加该门量子比特编号 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).t(which_qubit) - - def u3(self, theta, phi, lam, which_qubit): - r"""添加一个单量子比特的旋转门。 - - Args: - theta (Tensor): 旋转角度 :math:`\theta` 。 - phi (Tensor): 旋转角度 :math:`\phi` 。 - lam (Tensor): 旋转角度 :math:`\lambda` 。 - which_qubit (int): 作用在的 qubit 的编号，其值应该在 :math:`[0, m)` 范围内， :math:`m` 为该量子电路的量子比特数 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).u3(theta, phi, lam, which_qubit) - - def universal_2_qubit_gate(self, theta, which_qubits): - r"""添加 2-qubit 通用门，这个通用门需要 15 个参数。 - - Args: - theta (Tensor): 2-qubit 通用门的参数，其维度为 ``(15, )`` - which_qubits(list): 作用的量子比特编号 - """ - - super(LoccAnsatz, self).universal_2_qubit_gate(theta, which_qubits) - - def universal_3_qubit_gate(self, theta, which_qubits): - r"""添加 3-qubit 通用门，这个通用门需要 81 个参数。 - - Note: - 参考: https://cds.cern.ch/record/708846/files/0401178.pdf - - Args: - theta (Tensor): 3-qubit 通用门的参数，其维度为 ``(81, )`` - which_qubits(list): 作用的量子比特编号 - """ - - super(LoccAnsatz, self).universal_3_qubit_gate(theta, which_qubits) - - def superposition_layer(self): - r"""添加一层 Hadamard 门。 - """ - for which_qubit in self.party.qubits: - self.h(which_qubit) - - def weak_superposition_layer(self): - r"""添加一层旋转角度为 :math:`\pi/4` 的 Ry 门。 - """ - _theta = paddle.to_tensor(np.array([np.pi / 4])) - for which_qubit in self.party.qubits: - self.ry(_theta, which_qubit) - - def linear_entangled_layer(self, theta, depth, which_qubits=None): - r"""添加 ``depth`` 层包含 Ry 门，Rz 门和 CNOT 门的线性纠缠层。 - - Attention: - ``theta`` 的维度为 ``(depth, m, 2)`` ，最低维内容为对应的 ``ry`` 和 ``rz`` 的参数。 - - Args: - theta (Tensor): Ry 门和 Rz 门的旋转角度 - depth (int): 纠缠层的深度 - which_qubits(list): 作用的量子比特编号 - """ - assert self.m > 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' - # assert theta.shape[1] == self.m, 'the shape of theta is not right' - assert theta.shape[0] == depth, 'the depth of theta has a mismatch' - - if which_qubits is None: - which_qubits = list(range(self.m)) - - for repeat in range(depth): - for i, q in enumerate(which_qubits): - self.ry(theta[repeat][i][0], q) - for i in range(len(which_qubits) - 1): - self.cnot([which_qubits[i], which_qubits[i + 1]]) - for i, q in enumerate(which_qubits): - self.rz(theta[repeat][i][1], q) - for i in range(len(which_qubits) - 1): - self.cnot([which_qubits[i + 1], which_qubits[i]]) - - def real_entangled_layer(self, theta, depth, which_qubits=None): - r"""添加 ``depth`` 层包含 Ry 门和 CNOT 门的强纠缠层。 - - Note: - 这一层量子门的数学表示形式为实数酉矩阵。 - - Attention: - ``theta`` 的维度为 ``(depth, m, 1)`` - - Args: - theta (Tensor): Ry 门的旋转角度 - depth (int): 纠缠层的深度 - which_qubits(list): 作用的量子比特编号 - """ - assert self.m > 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' - # assert theta.shape[1] == len(self.party), 'the shape of theta is not right' - assert theta.shape[0] == depth, 'the depth of theta has a mismatch' - - if which_qubits is None: - which_qubits = list(range(self.m)) - - for repeat in range(depth): - for i, q in enumerate(which_qubits): - self.ry(theta[repeat][i][0], q) - for i in range(len(which_qubits) - 1): - self.cnot([which_qubits[i], which_qubits[i + 1]]) - self.cnot([which_qubits[-1], which_qubits[0]]) - - def complex_entangled_layer(self, theta, depth, which_qubits=None): - r"""添加 ``depth`` 层包含 U3 门和 CNOT 门的强纠缠层。 - - Note: - 这一层量子门的数学表示形式为复数酉矩阵。 - - Attention: - ``theta`` 的维度为 ``(depth, m, 3)``，最低维内容为对应的 ``u3`` 的参数 ``(theta, phi, lam)`` - - Args: - theta (Tensor): U3 门的旋转角度 - depth (int): 纠缠层的深度 - which_qubits(list): 作用的量子比特编号 - """ - assert self.m > 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' - # assert theta.shape[1] == self.m, 'the shape of theta is not right' - assert theta.shape[0] == depth, 'the depth of theta has a mismatch' - - if which_qubits is None: - which_qubits = list(range(self.m)) - - for repeat in range(depth): - for i, q in enumerate(which_qubits): - self.u3(theta[repeat][i][0], theta[repeat][i][1], theta[repeat][i][2], q) - for i in range(len(which_qubits) - 1): - self.cnot([which_qubits[i], which_qubits[i + 1]]) - self.cnot([which_qubits[-1], which_qubits[0]]) - - def real_block_layer(self, theta, depth): - r"""添加 ``depth`` 层包含 Ry 门和 CNOT 门的弱纠缠层。 - - Note: - 这一层量子门的数学表示形式为实数酉矩阵。 - - Attention: - ``theta`` 的维度为 ``(depth, m-1, 4)`` 。 - - Args: - theta(Tensor): Ry 门的旋转角度 - depth(int): 纠缠层的深度 - """ - assert self.m > 1, 'you need at least 2 qubits' - assert len(theta.shape) == 3, 'The dimension of theta is not right' - _depth, _number, block = theta.shape - assert depth > 0, 'depth must be greater than zero' - assert _depth == depth, 'the depth of parameters has a mismatch' - assert _number == self.m - 1 and block == 4, 'The shape of theta is not right' - - if self.m % 2 == 0: - for i in range(depth): - self.__add_real_layer(theta[i][:int(self.m / 2)], [0, self.m - 1]) - self.__add_real_layer(theta[i][int(self.m / 2):], [1, self.m - 2]) if self.m > 2 else None - else: - for i in range(depth): - self.__add_real_layer(theta[i][:int((self.m - 1) / 2)], [0, self.m - 2]) - self.__add_real_layer(theta[i][int((self.m - 1) / 2):], [1, self.m - 1]) - - def complex_block_layer(self, theta, depth): - r"""添加 ``depth`` 层包含 U3 门和 CNOT 门的弱纠缠层。 - - Note: - 这一层量子门的数学表示形式为复数酉矩阵。 - - Attention: - ``theta`` 的维度为 ``(depth, m-1, 12)`` 。 - - Args: - theta (Tensor): U3 门的角度信息 - depth (int): 纠缠层的深度 - """ - assert self.m > 1, 'you need at least 2 qubits' - assert len(theta.shape) == 3, 'The dimension of theta is not right' - assert depth > 0, 'depth must be greater than zero' - _depth, _number, block = theta.shape - assert _depth == depth, 'the depth of parameters has a mismatch' - assert _number == self.m - 1 and block == 12, 'The shape of theta is not right' - - if self.m % 2 == 0: - for i in range(depth): - self.__add_complex_layer(theta[i][:int(self.m / 2)], [0, self.m - 1]) - self.__add_complex_layer(theta[i][int(self.m / 2):], [1, self.m - 2]) if self.n > 2 else None - else: - for i in range(depth): - self.__add_complex_layer(theta[i][:int((self.m - 1) / 2)], [0, self.m - 2]) - self.__add_complex_layer(theta[i][int((self.m - 1) / 2):], [1, self.m - 1]) - - def __add_real_block(self, theta, position): - r""" - Add a real block to the circuit in (position). theta is a one dimensional tensor - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - assert len(theta) == 4, 'the length of theta is not right' - assert 0 <= position[0] < self.m and 0 <= position[1] < self.m, 'position is out of range' - self.ry(theta[0], position[0]) - self.ry(theta[1], position[1]) - - self.cnot([position[0], position[1]]) - - self.ry(theta[2], position[0]) - self.ry(theta[3], position[1]) - - def __add_complex_block(self, theta, position): - r""" - Add a complex block to the circuit in (position). theta is a one dimensional tensor - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - assert len(theta) == 12, 'the length of theta is not right' - assert 0 <= position[0] < self.m and 0 <= position[1] < self.m, 'position is out of range' - self.u3(theta[0], theta[1], theta[2], position[0]) - self.u3(theta[3], theta[4], theta[5], position[1]) - - self.cnot([position[0], position[1]]) - - self.u3(theta[6], theta[7], theta[8], position[0]) - self.u3(theta[9], theta[10], theta[11], position[1]) - - 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 - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - 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 - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - 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]) - - def amplitude_damping(self, gamma, which_qubit): - 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}. - - Args: - gamma (float): 减振概率，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, m)` 范围内， :math:`m` 为该参与方的量子比特数 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).amplitude_damping(gamma, which_qubit) - - def generalized_amplitude_damping(self, gamma, p, which_qubit): - r"""添加广义振幅阻尼信道。 - - 其 Kraus 算符为： - - .. math:: - - 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}. - - Args: - gamma (float): 减振概率，其值应该在 :math:`[0, 1]` 区间内 - p (float): 激发概率，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, m)` 范围内， :math:`m` 为该参与方的量子比特数 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).generalized_amplitude_damping(gamma, p, which_qubit) - - def phase_damping(self, gamma, which_qubit): - r"""添加相位阻尼信道。 - - 其 Kraus 算符为： - - .. math:: - - 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]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, m)` 范围内， :math:`m` 为该参与方的量子比特数 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).phase_damping(gamma, which_qubit) - - def bit_flip(self, p, which_qubit): - r"""添加比特反转信道。 - - 其 Kraus 算符为： - - .. math:: - - E_0 = \sqrt{1-p} I, - E_1 = \sqrt{p} X. - - Args: - p (float): 发生 bit flip 的概率，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, m)` 范围内， :math:`m` 为该参与方的量子比特数 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).bit_flip(p, which_qubit) - - def phase_flip(self, p, which_qubit): - r"""添加相位反转信道。 - - 其 Kraus 算符为： - - .. math:: - - E_0 = \sqrt{1 - p} I, - E_1 = \sqrt{p} Z. - - Args: - p (float): 发生 phase flip 的概率，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, m)` 范围内， :math:`m` 为该参与方的量子比特数 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).phase_flip(p, which_qubit) - - def bit_phase_flip(self, p, which_qubit): - r"""添加比特相位反转信道。 - - 其 Kraus 算符为： - - .. math:: - - E_0 = \sqrt{1 - p} I, - E_1 = \sqrt{p} Y. - - Args: - p (float): 发生 bit phase flip 的概率，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, m)` 范围内， :math:`m` 为该参与方的量子比特数 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).bit_phase_flip(p, which_qubit) - - def depolarizing(self, p, which_qubit): - r"""添加去极化信道。 - - 其 Kraus 算符为： - - .. math:: - - E_0 = \sqrt{1-p} I, - E_1 = \sqrt{p/3} X, - E_2 = \sqrt{p/3} Y, - E_3 = \sqrt{p/3} Z. - - Args: - p (float): depolarizing 信道的参数，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, m)` 范围内， :math:`m` 为该参与方的量子比特数 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).depolarizing(p, which_qubit) - - def pauli_channel(self, p_x, p_y, p_z, which_qubit): - r"""添加泡利信道。 - - Args: - p_x (float): 泡利矩阵 X 的对应概率，其值应该在 :math:`[0, 1]` 区间内 - p_y (float): 泡利矩阵 Y 的对应概率，其值应该在 :math:`[0, 1]` 区间内 - p_z (float): 泡利矩阵 Z 的对应概率，其值应该在 :math:`[0, 1]` 区间内 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, m)` 范围内， :math:`m` 为该参与方的量子比特数 - - Note: - 三个输入的概率加起来需要小于等于 1。 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).pauli_channel(p_x, p_y, p_z, which_qubit) - - def customized_channel(self, ops, which_qubit): - r"""添加自定义的量子信道。 - - Args: - ops (list): 表示信道的 Kraus 算符的列表 - which_qubit (int): 该信道作用在的 qubit 的编号，其值应该在 :math:`[0, m)` 范围内， :math:`m` 为该参与方的量子比特数 - """ - which_qubit = self.party[which_qubit] - super(LoccAnsatz, self).customized_channel(ops, which_qubit) - - -class LoccNet(paddle.nn.Layer): - r"""用于设计我们的 LOCC 下的 protocol，并进行验证或者训练。 - """ - - def __init__(self): - r"""构造函数，用于实例化一个 LoccNet 对象。 - """ - super(LoccNet, self).__init__() - self.parties_by_number = list() - self.parties_by_name = dict() - self.init_status = LoccStatus() - - def set_init_status(self, state, which_qubits): - r"""对 LoccNet 的初始 LOCC 态节点进行初始化。 - - Warning: - 该方法已弃用，请使用 ``set_init_state()`` 方法以代替。 - - Args: - state (Tensor): 输入的量子态的矩阵形式 - which_qubits (tuple or list): 该量子态所对应的量子比特，其形式为 ``(party_id, qubit_id)`` 的 ``tuple`` ，或者由其组成的 ``list`` - """ - warnings.warn('The member method set_init_status() is deprecated and please use set_init_state() instead.', - DeprecationWarning) - - self.set_init_state(state, which_qubits) - - def set_init_state(self, state, which_qubits): - r"""对 LoccNet 的初始 LOCC 态节点进行初始化。 - - Args: - state (Tensor): 输入的量子态的矩阵形式 - which_qubits (tuple or list): 该量子态所对应的量子比特，其形式为 ``(party_id, qubit_id)`` 的 ``tuple`` ，或者由其组成的 ``list`` - """ - if isinstance(which_qubits, tuple): - which_qubits = [which_qubits] - temp_len = int(log2(sqrt(self.init_status.state.numpy().size))) - self.init_status.state = kron(self.init_status.state, state) - for idx, (party_id, qubit_id) in enumerate(which_qubits): - if isinstance(party_id, str): - self.parties_by_name[party_id][qubit_id] = (temp_len + idx) - elif isinstance(party_id, int): - self.parties_by_number[party_id][qubit_id] = (temp_len + idx) - else: - raise ValueError - - def partial_state(self, status, which_qubits, is_desired=True): - r"""得到你想要的部分量子比特上的量子态。 - - Args: - status (LoccStatus or list): 输入的 LOCC 态节点，其类型应该为 ``LoccStatus`` 或者由其组成的 ``list`` - which_qubits (tuple or list): 指定的量子比特编号，其形式为 ``(party_id, qubit_id)`` 的 ``tuple`` ，或者由其组成的 ``list`` - is_desired (bool, optional): 默认是 ``True`` ，即返回量子比特上的部分量子态。如果为 ``False`` ，则抛弃这部分量子比特上的量子态，返回剩下的部分量子态 - - Returns: - LoccStatus or list: 得到部分量子态后的 LOCC 态节点，其类型为 ``LoccStatus`` 或者由其组成的 ``list`` - """ - if isinstance(which_qubits, tuple): - which_qubits = [which_qubits] - qubits_list = list() - for party_id, qubit_id in which_qubits: - if isinstance(party_id, str): - qubits_list.append(self.parties_by_name[party_id][qubit_id]) - elif isinstance(party_id, int): - qubits_list.append(self.parties_by_number[party_id][qubit_id]) - else: - raise ValueError - m = len(qubits_list) - if isinstance(status, LoccStatus): - n = int(log2(sqrt(status.state.numpy().size))) - elif isinstance(status, list): - n = int(log2(sqrt(status[0].state.numpy().size))) - else: - raise ValueError("can't recognize the input status") - - 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 = [] - 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] - - cir = UAnsatz(n) - for a, b in swap_list: - cir.swap([a, b]) - - if isinstance(status, LoccStatus): - state = cir.run_density_matrix(status.state) - if is_desired: - state = partial_trace(state, 2 ** m, 2 ** (n - m), 2) - else: - state = partial_trace(state, 2 ** m, 2 ** (n - m), 1) - new_status = LoccStatus(state, status.prob, status.measured_result) - elif isinstance(status, list): - new_status = list() - for each_status in status: - state = cir.run_density_matrix(each_status.state) - if is_desired: - state = partial_trace(state, 2 ** m, 2 ** (n - m), 2) - else: - state = partial_trace(state, 2 ** m, 2 ** (n - m), 1) - new_status.append(LoccStatus(state, each_status.prob, each_status.measured_result)) - else: - raise ValueError("can't recognize the input status") - - return new_status - - def reset_state(self, status, state, which_qubits): - r"""用于重置你想要的量子比特上的部分量子态。 - - Args: - status (LoccStatus or list): 输入的 LOCC 态节点，其类型应该为 ``LoccStatus`` 或者由其组成的 ``list`` - state (Tensor): 输入的量子态的矩阵形式 - which_qubits (tuple or list): 指定需要被重置的量子比特编号，其形式为 ``(party_id, qubit_id)`` 的 ``tuple``，或者由其组成的 ``list`` - - Returns: - LoccStatus or list: 重置部分量子比特的量子态后的 LOCC 态节点，其类型为 ``LoccStatus`` 或者由其组成的 ``list`` - """ - if isinstance(which_qubits, tuple): - which_qubits = [which_qubits] - qubits_list = list() - for party_id, qubit_id in which_qubits: - if isinstance(party_id, str): - qubits_list.append(self.parties_by_name[party_id][qubit_id]) - elif isinstance(party_id, int): - qubits_list.append(self.parties_by_number[party_id][qubit_id]) - else: - raise ValueError - m = len(qubits_list) - if isinstance(status, LoccStatus): - n = int(log2(sqrt(status.state.numpy().size))) - elif isinstance(status, list): - n = int(log2(sqrt(status[0].state.numpy().size))) - else: - raise ValueError("can't recognize the input status") - 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 = [] - 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]) - - if isinstance(status, LoccStatus): - _state = cir0.run_density_matrix(status.state) - _state = partial_trace(_state, 2 ** m, 2 ** (n - m), 1) - _state = kron(state, _state) - _state = cir1.run_density_matrix(_state) - new_status = LoccStatus(_state, status.prob, status.measured_result) - elif isinstance(status, list): - new_status = list() - for each_status in status: - _state = cir0.run_density_matrix(each_status.state) - _state = partial_trace(_state, 2 ** m, 2 ** (n - m), 1) - _state = kron(state, _state) - _state = cir1.run_density_matrix(_state) - new_status.append(LoccStatus(_state, each_status.prob, each_status.measured_result)) - else: - raise ValueError("can't recognize the input status") - - return new_status - - def add_new_party(self, qubits_number, party_name=None): - r"""添加一个新的 LOCC 的参与方。 - - Args: - qubits_number (int): 参与方的量子比特个数 - party_name (str, optional): 可选参数，默认为 ``None``，参与方的名字 - - Note: - 你可以使用字符串或者数字对 party 进行索引。如果你想使用字符串索引，需要每次指定 ``party_name``；如果你想使用数字索引，则不需要指定 ``party_name``，其索引数字会从 0 开始依次增长。 - - Returns: - int or str: 该参与方的 ID，为数字或者字符串 - """ - party_id = None - if party_name is None: - party_id = party_name - party_name = str(len(self.parties_by_name)) - elif isinstance(party_name, str) is False: - raise ValueError - if party_id is None: - party_id = len(self.parties_by_name) - - new_party = LoccParty(qubits_number) - self.parties_by_name[party_name] = new_party - self.parties_by_number.append(new_party) - - return party_id - - def create_ansatz(self, party_id): - r"""创建一个新的本地电路模板。 - - Args: - party_id (int or str): 参与方的 ID - - Returns: - LoccAnsatz: 一个本地的量子电路 - """ - if isinstance(party_id, int): - return LoccAnsatz(self.parties_by_number[party_id], self.get_qubit_number()) - elif isinstance(party_id, str): - return LoccAnsatz(self.parties_by_name[party_id], self.get_qubit_number()) - else: - raise ValueError - - def __measure_parameterized(self, state, which_qubits, result_desired, theta): - r"""进行参数化的测量。 - - Args: - state (Tensor): 输入的量子态 - which_qubits (list): 测量作用的量子比特编号 - result_desired (str): 期望得到的测量结果 - theta (Tensor): 测量运算的参数 - - Returns: - Tensor: 测量坍塌后的量子态 - Tensor：测量坍塌得到的概率 - str: 测量得到的结果 - """ - n = self.get_qubit_number() - assert len(which_qubits) == len(result_desired), \ - "the length of qubits wanted to be measured and the result desired should be same" - op_list = [paddle.to_tensor(np.eye(2, dtype=np.complex128))] * n - for idx in range(0, len(which_qubits)): - i = which_qubits[idx] - ele = result_desired[idx] - if int(ele) == 0: - basis0 = paddle.to_tensor(np.array([[1, 0], [0, 0]], dtype=np.complex128)) - basis1 = paddle.to_tensor(np.array([[0, 0], [0, 1]], dtype=np.complex128)) - rho0 = multiply(basis0, cos(theta[idx])) - rho1 = multiply(basis1, sin(theta[idx])) - rho = add(rho0, rho1) - op_list[i] = rho - elif int(ele) == 1: - # rho = diag(concat([cos(theta[idx]), sin(theta[idx])])) - # rho = paddle.to_tensor(rho, zeros((2, 2), dtype="float64")) - basis0 = paddle.to_tensor(np.array([[1, 0], [0, 0]], dtype=np.complex128)) - basis1 = paddle.to_tensor(np.array([[0, 0], [0, 1]], dtype=np.complex128)) - rho0 = multiply(basis0, sin(theta[idx])) - rho1 = multiply(basis1, cos(theta[idx])) - rho = add(rho0, rho1) - op_list[i] = rho - else: - print("cannot recognize the result_desired.") - # rho = paddle.to_tensor(ones((2, 2), dtype="float64"), zeros((2, 2), dtype="float64")) - measure_operator = paddle.to_tensor(op_list[0]) - if n > 1: - for idx in range(1, len(op_list)): - measure_operator = kron(measure_operator, op_list[idx]) - state_measured = matmul(matmul(measure_operator, state), dagger(measure_operator)) - prob = real(trace(matmul(matmul(dagger(measure_operator), measure_operator), state))) - state_measured = divide(state_measured, prob) - return state_measured, prob, result_desired - - def __measure_parameterless(self, state, which_qubits, result_desired): - r"""进行 01 测量。 - - Args: - state (Tensor): 输入的量子态 - which_qubits (list): 测量作用的量子比特编号 - result_desired (str): 期望得到的测量结果 - - Returns: - Tensor: 测量坍塌后的量子态 - Tensor：测量坍塌得到的概率 - str: 测量得到的结果 - """ - n = self.get_qubit_number() - assert len(which_qubits) == len(result_desired), \ - "the length of qubits wanted to be measured and the result desired should be same" - op_list = [np.eye(2, dtype=np.complex128)] * n - for i, ele in zip(which_qubits, result_desired): - k = int(ele) - rho = np.zeros((2, 2), dtype=np.complex128) - rho[int(k), int(k)] = 1 - op_list[i] = rho - if n > 1: - measure_operator = paddle.to_tensor(NKron(*op_list)) - else: - measure_operator = paddle.to_tensor(op_list[0]) - state_measured = matmul(matmul(measure_operator, state), dagger(measure_operator)) - prob = real(trace(matmul(matmul(dagger(measure_operator), measure_operator), state))) - state_measured = divide(state_measured, prob) - return state_measured, prob, result_desired - - def measure(self, status, which_qubits, results_desired, theta=None): - r"""对 LOCC 态节点进行 01 测量或者含参测量。 - - Args: - status (LoccStatus or list): 输入的量子态，其类型应该为 ``LoccStatus`` 或者由其组成的 ``list`` - which_qubits (tuple or list): 测量作用的量子比特编号，其形式为 ``(party_id, qubit_id)`` 的 ``tuple`` ，或者由其组成的 ``list`` - results_desired (str or list): 期望得到的测量结果，用字符串进行表示，其类型为 ``str`` 或者由 ``str`` 组成的 ``list``，如 ``"0"``、``"1"`` 或者 ``["0", "1"]`` - theta (Tensor): 测量运算的参数，默认是 ``None``，表示 01 测量；若要使用含参测量则需要赋值 - - Returns: - LoccStatus or list: 测量后得到的 LOCC 态节点，其类型为 ``LoccStatus`` 或者由其组成的 ``list`` - """ - if isinstance(which_qubits, tuple): - which_qubits = [which_qubits] - if isinstance(results_desired, str): - results_desired = [results_desired] - elif not isinstance(results_desired, list): - raise ValueError("cannot recognize the input of results_desired") - - qubits_list = list() - for party_id, qubit_id in which_qubits: - if isinstance(party_id, int): - qubits_list.append((self.parties_by_number[party_id][qubit_id])) - elif isinstance(party_id, str): - qubits_list.append((self.parties_by_name[party_id][qubit_id])) - else: - raise ValueError - - if isinstance(status, LoccStatus): - existing_result = status.measured_result - prior_prob = status.prob - new_status = list() - for result_desired in results_desired: - if theta is None: - result_measured = self.__measure_parameterless(status.state, qubits_list, result_desired) - else: - result_measured = self.__measure_parameterized(status.state, qubits_list, result_desired, theta) - state, prob, res = result_measured - new_status.append(LoccStatus(state, prior_prob * prob, existing_result + res)) - if len(new_status) == 1: - new_status = new_status[0] - elif isinstance(status, list): - new_status = list() - for each_status in status: - existing_result = each_status.measured_result - prior_prob = each_status.prob - for result_desired in results_desired: - if theta is None: - result_measured = self.__measure_parameterless(each_status.state, qubits_list, result_desired) - else: - result_measured = self.__measure_parameterized(each_status.state, qubits_list, result_desired, theta) - state, prob, res = result_measured - new_status.append(LoccStatus(state, prior_prob * prob, existing_result + res)) - else: - raise ValueError("can't recognize the input status") - - return new_status - - def get_qubit_number(self): - r"""得到该 LoccNet 的量子比特数量。 - - Returns: - int: 当前量子比特数量 - """ - qubits_number = 0 - for party in self.parties_by_number: - qubits_number += party.qubit_number - return qubits_number diff --git a/paddle_quantum/locc/__init__.py b/paddle_quantum/locc/__init__.py new file mode 100644 index 0000000..f215e71 --- /dev/null +++ b/paddle_quantum/locc/__init__.py @@ -0,0 +1,23 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The module of the LOCCNet. +""" + +from .locc_party import LoccParty +from .locc_state import LoccState, LoccStatus +from .locc_ansatz import LoccAnsatz +from .locc_net import LoccNet diff --git a/paddle_quantum/locc/locc_ansatz.py b/paddle_quantum/locc/locc_ansatz.py new file mode 100644 index 0000000..78904e2 --- /dev/null +++ b/paddle_quantum/locc/locc_ansatz.py @@ -0,0 +1,667 @@ +# !/usr/bin/env python3 +# 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. + +r""" +The source file of the LoccAnsatz class. +""" + +import collections +import paddle +import paddle_quantum +from ..gate import H, S, T, X, Y, Z, P, RX, RY, RZ, U3 +from ..gate import CNOT, CX, CY, CZ, SWAP +from ..gate import CP, CRX, CRY, CRZ, CU, RXX, RYY, RZZ +from ..gate import MS, CSWAP, Toffoli +from ..gate import UniversalTwoQubits, UniversalThreeQubits +from ..gate import Oracle, ControlOracle +from .locc_party import LoccParty +from .locc_state import LoccState +from paddle_quantum import Operator +from typing import Iterable, Union, Optional, List + + +class LoccAnsatz(paddle_quantum.ansatz.Circuit): + r"""Inherit the ``Circuit`` class. The purpose is to build a circuit template for an LOCC task. + + In an LOCC task, each party can only perform quantum operations on their own qubits. So we only allow local quantum gates to be added to each party's qubits. + + Args: + party: The owner of this circuit. + """ + def __init__(self, party: LoccParty): + super().__init__() + self.party = party + self.num_local_qubits = len(self.party) + + def __transform_qubits_idx(self, oper): + if hasattr(oper, 'qubits_idx'): + if isinstance(oper.qubits_idx[0], Iterable): + oper.qubits_idx = [ + [self.party[qubit_idx] for qubit_idx in qubits_idx] for qubits_idx in oper.qubits_idx + ] + else: + oper.qubits_idx = [self.party[qubit_idx] for qubit_idx in oper.qubits_idx] + + def append(self, operator: Union[Iterable, paddle_quantum.Operator]): + r""" Append an operator. + + Args: + operator: operator with a name or just an operator. + + """ + if isinstance(operator, Iterable): + name, oper = operator + self.__transform_qubits_idx(oper) + self.add_sublayer(name, oper) + elif isinstance(operator, paddle_quantum.Operator): + self.__transform_qubits_idx(operator) + idx = len(self._sub_layers) + self.add_sublayer(str(idx), operator) + + def extend(self, operators: List[Operator]): + r""" Append a list of operators. + + Args: + operator: List of operators. + + """ + if len(operators) > 0 and isinstance(operators[0], (list, tuple)): + for name, oper in operators: + self.__transform_qubits_idx(oper) + self.add_sublayer(name, oper) + else: + origin_len = len(self._sub_layers) + for idx, oper in enumerate(operators): + self.__transform_qubits_idx(oper) + self.add_sublayer(str(idx + origin_len), oper) + + def insert(self, index: int, operator: Operator): + r""" Insert an operator at index ``index``. + + Args: + index: Index to be inserted. + operator: An operator. + + """ + new_operators = collections.OrderedDict() + for idx, name in enumerate(self._sub_layers): + if idx < index: + new_operators[name] = self._sub_layers[name] + elif idx == index: + if isinstance(operator, (list, tuple)): + name, oper = operator + self.__transform_qubits_idx(oper) + new_operators[name] = oper + elif isinstance(operator, paddle_quantum.Operator): + self.__transform_qubits_idx(operator) + new_operators[str(index)] = operator + elif name.isdigit(): + new_operators[str(int(name) + 1)] = self._sub_layers[name] + else: + new_operators[name] = self._sub_layers[name] + self._sub_layers = new_operators + + def pop(self, operator: Operator): + r"""Remove the matched operator. + + Args: + operator: Matched with which the operator will be popped. + """ + new_operators = collections.OrderedDict() + behind_operator = False + for idx, name in enumerate(self._sub_layers): + if operator is self._sub_layers[name]: + behind_operator = True + elif not behind_operator: + new_operators[name] = self._sub_layers[name] + elif name.isdigit(): + new_operators[str(int(name) - 1)] = self._sub_layers[name] + else: + new_operators[name] = self._sub_layers[name] + self._sub_layers = new_operators + + def forward(self, state: LoccState) -> LoccState: + r""" Forward the input. + + Args: + state: Initial state. + + Returns: + Output state. + + """ + for layer in self._sub_layers.values(): + state = layer(state) + return state + + def h( + self, qubits_idx: Union[Iterable, int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1 + ) -> None: + r"""Add single-qubit Hadamard gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = H(qubits_idx, num_qubits, depth) + self.append(oper) + + def s( + self, qubits_idx: Union[Iterable, int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1 + ) -> None: + r"""Add single-qubit S gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = S(qubits_idx, num_qubits, depth) + self.append(oper) + + def t( + self, qubits_idx: Union[Iterable, int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1 + ) -> None: + r"""Add single-qubit T gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = T(qubits_idx, num_qubits, depth) + self.append(oper) + + def x( + self, qubits_idx: Union[Iterable, int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1 + ) -> None: + r"""Add single-qubit X gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = X(qubits_idx, num_qubits, depth) + self.append(oper) + + def y( + self, qubits_idx: Union[Iterable, int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1 + ) -> None: + r"""Add single-qubit Y gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = Y(qubits_idx, num_qubits, depth) + self.append(oper) + + def z( + self, qubits_idx: Union[Iterable, int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1 + ) -> None: + r"""Add single-qubit Z gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = Z(qubits_idx, num_qubits, depth) + self.append(oper) + + def p( + self, qubits_idx: Union[Iterable, int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add single-qubit P gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = P(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def rx( + self, qubits_idx: Union[Iterable, int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add single-qubit rotation gates about the x-axis. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = RX(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def ry( + self, qubits_idx: Union[Iterable, int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add single-qubit rotation gates about the y-axis. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = RY(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def rz( + self, qubits_idx: Union[Iterable, int, str] = 'full', num_qubits: Optional[int] = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add single-qubit rotation gates about the z-axis. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = RZ(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def u3( + self, qubits_idx: Union[Iterable, int, str] = 'full', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, Iterable[float]] = None, param_sharing: bool = False + ) -> None: + r"""Add single-qubit rotation gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'full'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = U3(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def cnot( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add CNOT gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = CNOT(qubits_idx, num_qubits, depth) + self.append(oper) + + def cx( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Same as cnot. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = CX(qubits_idx, num_qubits, depth) + self.append(oper) + + def cy( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add controlled Y gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = CY(qubits_idx, num_qubits, depth) + self.append(oper) + + def cz( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add controlled Z gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = CZ(qubits_idx, num_qubits, depth) + self.append(oper) + + def swap( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add SWAP gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = SWAP(qubits_idx, num_qubits, depth) + self.append(oper) + + def cp( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add controlled P gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = CP(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def crx( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add controlled rotation gates about the x-axis. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = CRX(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def cry( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add controlled rotation gates about the y-axis. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = CRY(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def crz( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add controlled rotation gates about the z-axis. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = CRZ(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def cu( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add controlled single-qubit rotation gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = CU(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def rxx( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add RXX gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = RXX(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def ryy( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add RYY gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = RYY(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def rzz( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add RZZ gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = RZZ(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def ms( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add Mølmer-Sørensen (MS) gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = MS(qubits_idx, num_qubits, depth) + self.append(oper) + + def cswap( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add CSWAP (Fredkin) gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = CSWAP(qubits_idx, num_qubits, depth) + self.append(oper) + + def ccx( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add CCX gates. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = CSWAP(qubits_idx, num_qubits, depth) + self.append(oper) + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = Toffoli(qubits_idx, num_qubits, depth) + self.append(oper) + + def universal_two_qubits( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add universal two-qubit gates. One of such a gate requires 15 parameters. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = UniversalTwoQubits(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def universal_three_qubits( + self, qubits_idx: Union[Iterable, str] = 'cycle', num_qubits: int = None, depth: int = 1, + param: Union[paddle.Tensor, float] = None, param_sharing: bool = False + ) -> None: + r"""Add universal three-qubit gates. One of such a gate requires 81 parameters. + + Args: + qubits_idx: Indices of the qubits on which the gates are applied. Defaults to ``'cycle'``. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + param: Parameters of the gates. Defaults to ``None``. + param_sharing: Whether gates in the same layer share a parameter. Defaults to ``False``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = UniversalThreeQubits(qubits_idx, num_qubits, depth, param, param_sharing) + self.append(oper) + + def oracle( + self, oracle: paddle.Tensor, qubits_idx: Union[Iterable[Iterable[int]], Iterable[int], int], + num_qubits: int = None, depth: int = 1 + ) -> None: + r"""Add an oracle gate. + + Args: + oracle: Unitary oracle to be implemented. + qubits_idx: Indices of the qubits on which the gates are applied. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = Oracle(oracle, qubits_idx, num_qubits, depth) + self.append(oper) + + def control_oracle( + self, oracle: paddle.Tensor, + # num_control_qubits: int, controlled_value: 'str', + qubits_idx: Union[Iterable[Iterable[int]], Iterable[int]], + num_qubits: int = None, depth: int = 1 + ) -> None: + """Add a controlled oracle gate. + + Args: + oracle: Unitary oracle to be implemented. + qubits_idx: Indices of the qubits on which the gates are applied. + num_qubits: Total number of qubits. Defaults to ``None``. + depth: Number of layers. Defaults to ``1``. + """ + if num_qubits is None: + num_qubits = self.num_local_qubits + oper = ControlOracle(oracle, qubits_idx, num_qubits, depth) + self.append(oper) diff --git a/paddle_quantum/locc/locc_net.py b/paddle_quantum/locc/locc_net.py new file mode 100644 index 0000000..364a5c7 --- /dev/null +++ b/paddle_quantum/locc/locc_net.py @@ -0,0 +1,501 @@ +# !/usr/bin/env python3 +# 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. + +r""" +The source file of the LoccNet class. +""" + +import math +import numpy as np +import functools +import paddle +import paddle_quantum +from .locc_party import LoccParty +from .locc_state import LoccState +from .locc_ansatz import LoccAnsatz +from typing import Optional, Union, Iterable, List + + +class LoccNet(paddle.nn.Layer): + r"""Used to design LOCC protocols and perform training or verification. + """ + def __init__(self): + super().__init__() + self.parties_by_number = [] + self.parties_by_name = {} + self.init_status = LoccState() + + def set_init_state(self, state: paddle_quantum.State, qubits_idx: Iterable): + r"""Initialize the LoccState of LoccNet. + + Args: + state: Matrix form of the input quantum state. + qubits_idx: Indices of the qubits corresponding to the input quantum state. It should be a ``tuple`` of + ``(party_id, qubit_id)``, or a ``list`` of it. + + Raises: + ValueError: Party's ID should be ``str`` or ``int``. + """ + qubits_idx = list(qubits_idx) + temp_len = int(math.log2(math.sqrt(self.init_status.data.size))) + self.init_status.data = paddle.kron(self.init_status.data, state.data) + self.init_status.num_qubits += state.num_qubits + for idx, (party_id, qubit_id) in enumerate(qubits_idx): + if isinstance(party_id, str): + self.parties_by_name[party_id][qubit_id] = (temp_len + idx) + elif isinstance(party_id, int): + self.parties_by_number[party_id][qubit_id] = (temp_len + idx) + else: + raise ValueError + + def __partial_trace(self, rho_AB, dim1, dim2, A_or_B): + r"""TODO To be checked. + """ + if A_or_B == 2: + dim1, dim2 = dim2, dim1 + idty_np = np.identity(dim2) + idty_B = paddle.to_tensor(idty_np, dtype=rho_AB.dtype) + zero_np = np.zeros([dim2, dim2]) + res = paddle.to_tensor(zero_np, dtype=rho_AB.dtype) + for dim_j in range(dim1): + row_top = paddle.zeros([1, dim_j]) + row_mid = paddle.ones([1, 1]) + row_bot = paddle.zeros([1, dim1 - dim_j - 1]) + bra_j = paddle.concat([row_top, row_mid, row_bot], axis=1) + if A_or_B == 1: + row_tmp = paddle.kron(bra_j, idty_B) + row_tmp = paddle.cast(row_tmp, rho_AB.dtype) + row_tmp_conj = paddle.conj(row_tmp) + res = paddle.add( + res, + paddle.matmul( + paddle.matmul(row_tmp, rho_AB), + paddle.transpose(row_tmp_conj, perm=[1, 0]) + ) + ) + if A_or_B == 2: + row_tmp = paddle.kron(idty_B, bra_j) + row_tmp = paddle.cast(row_tmp, rho_AB.dtype) + row_tmp_conj = paddle.conj(row_tmp) + res = paddle.add( + res, + paddle.matmul( + paddle.matmul(row_tmp, rho_AB), + paddle.transpose(row_tmp_conj, perm=[1, 0]) + ) + ) + return res + + def partial_state( + self, state: Union[List[LoccState], LoccState], qubits_idx: Iterable, is_desired: bool = True + ) -> Union[List[LoccState], LoccState]: + r"""Get the quantum state of the qubits of interest. + + Args: + state: Input LOCC state. + qubits_idx: Indices of the qubits of interest. It should be a ``tuple`` of ``(party_id, qubit_id)``, + or a ``list`` of it. + is_desired: If ``True``, return the partial quantum state with the respect to the given qubits; + if ``False``, return the partial quantum state with the respect to the remaining qubits. Defaults to ``True``. + + Raises: + ValueError: Party's ID should be ``str`` or ``int``. + ValueError: The ``state`` should be ``LoccState`` or a ``list`` of it. + + Returns: + LOCC state after obtaining partial quantum state. + """ + qubits_idx = list(qubits_idx) + qubits_list = [] + for party_id, qubit_id in qubits_idx: + if isinstance(party_id, str): + qubits_list.append(self.parties_by_name[party_id][qubit_id]) + elif isinstance(party_id, int): + qubits_list.append(self.parties_by_number[party_id][qubit_id]) + else: + raise ValueError + m = len(qubits_list) + if isinstance(state, LoccState): + n = state.num_qubits + elif isinstance(state, list): + n = state[0].num_qubits + else: + raise ValueError("can't recognize the input status") + + 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 = [] + 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] + + cir = paddle_quantum.ansatz.Circuit() + for a, b in swap_list: + cir.swap([a, b]) + + if isinstance(state, LoccState): + state = cir(state) + if is_desired: + state_data = self.__partial_trace(state.data, 2 ** m, 2 ** (n - m), 2) + else: + state_data = self.__partial_trace(state.data, 2 ** m, 2 ** (n - m), 1) + new_state = state.clone() + new_state.data = state_data + new_state.num_qubits = int(math.log2(state_data.shape[-1])) + elif isinstance(state, list): + new_state = [] + for each_state in state: + each_state = cir(each_state) + if is_desired: + state_data = self.__partial_trace(each_state.data, 2 ** m, 2 ** (n - m), 2) + else: + state_data = self.__partial_trace(each_state.data, 2 ** m, 2 ** (n - m), 1) + _state = each_state.clone() + _state.data = state_data + _state.num_qubits = int(math.log2(state_data.shape[-1])) + new_state.append(_state) + else: + # TODO: seems unnecessary + raise ValueError("can't recognize the input status") + + return new_state + + def reset_state( + self, status: Union[List[LoccState], LoccState], state: paddle_quantum.State, which_qubits: Iterable + ) -> Union[List[LoccState], LoccState]: + r"""Reset the quantum state of the qubits of interest. + + Args: + status: LOCC state before resetting. + state: Matrix form of the input quantum state. + which_qubits: Indices of the qubits to be reset. It should be a ``tuple`` of ``(party_id, qubit_id)``, + or a ``list`` of it. + + Raises: + ValueError: Party's ID should be ``str`` or ``int``. + ValueError: The ``state`` should be ``LoccState`` or a ``list`` of it. + + Returns: + LOCC state after resetting the state of part of the qubits. + """ + # TODO: which_qubits -> qubits_idx? + if isinstance(which_qubits, tuple): + which_qubits = [which_qubits] + qubits_list = [] + for party_id, qubit_id in which_qubits: + if isinstance(party_id, str): + qubits_list.append(self.parties_by_name[party_id][qubit_id]) + elif isinstance(party_id, int): + qubits_list.append(self.parties_by_number[party_id][qubit_id]) + else: + raise ValueError + m = len(qubits_list) + if isinstance(status, LoccState): + n = status.num_qubits + elif isinstance(status, list): + n = status[0].num_qubits + else: + raise ValueError("can't recognize the input status") + 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 = [] + 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 = paddle_quantum.ansatz.Circuit() + for a, b in swap_list: + cir0.swap([a, b]) + + cir1 = paddle_quantum.ansatz.Circuit() + swap_list.reverse() + for a, b in swap_list: + cir1.swap([a, b]) + + if isinstance(status, LoccState): + _state = cir0(status) + state_data = self.__partial_trace(_state.data, 2 ** m, 2 ** (n - m), 1) + state_data = paddle.kron(state.data, state_data) + _state = _state.clone() + _state.data = state_data + _state = cir1(_state) + new_status = _state + elif isinstance(status, list): + new_status = [] + for each_status in status: + _state = cir0(each_status) + state_data = self.__partial_trace(_state.data, 2 ** m, 2 ** (n - m), 1) + state_data = paddle.kron(state.data, state_data) + _state = _state.clone() + _state.data = state_data + _state = cir1(_state) + _state = _state.clone() + new_status.append(_state) + else: + # TODO: seems unnecessary + raise ValueError("can't recognize the input status") + + return new_status + + def add_new_party(self, qubits_number: int, party_name: Optional[str] = None) -> Union[int, str]: + r"""Add a new LOCC party. + + Args: + qubits_number: Number of qubits of the party. + party_name: Name of the party. Defaults to ``None``. + + Note: + You can use a string or a number as a party's ID. If a string is preferred, + you can set ``party_name``; if a number is preferred, then you don't need to set ``party_name`` + and the party's index number will be automatically assigned. + + Raises: + ValueError: The ``party_name`` should be ``str``. + + Returns: + ID of the party. + """ + party_id = None + if party_name is None: + party_id = party_name + party_name = str(len(self.parties_by_name)) + elif isinstance(party_name, str) is False: + raise ValueError + if party_id is None: + party_id = len(self.parties_by_name) + + new_party = LoccParty(qubits_number) + self.parties_by_name[party_name] = new_party + self.parties_by_number.append(new_party) + + return party_id + + def create_ansatz(self, party_id: Union[int, str]) -> LoccAnsatz: + r"""Create a new local ansatz. + + Args: + party_id: Party's ID. + + Raises: + ValueError: Party's ID should be ``str`` or ``int``. + + Returns: + Created local ansatz. + """ + if isinstance(party_id, int): + return LoccAnsatz(self.parties_by_number[party_id]) + elif isinstance(party_id, str): + return LoccAnsatz(self.parties_by_name[party_id]) + else: + raise ValueError + + def __measure_parameterized(self, state_data, which_qubits, result_desired, theta): + r"""TODO 进行参数化的测量。 + + Args: + state_data (Tensor): 输入的量子态 + which_qubits (list): 测量作用的量子比特编号 + result_desired (str): 期望得到的测量结果 + theta (Tensor): 测量运算的参数 + + Returns: + Tensor: 测量坍塌后的量子态 + Tensor: 测量坍塌得到的概率 + str: 测量得到的结果 + """ + n = self.get_num_qubits() + assert len(which_qubits) == len(result_desired), \ + "the length of qubits wanted to be measured and the result desired should be same" + op_list = [paddle.to_tensor(np.eye(2), dtype=paddle_quantum.get_dtype())] * n + for idx in range(0, len(which_qubits)): + i = which_qubits[idx] + ele = result_desired[idx] + if int(ele) == 0: + basis0 = paddle.to_tensor(np.array([[1, 0], [0, 0]]), dtype=paddle_quantum.get_dtype()) + basis1 = paddle.to_tensor(np.array([[0, 0], [0, 1]]), dtype=paddle_quantum.get_dtype()) + rho0 = paddle.multiply(basis0, paddle.cos(theta[idx])) + rho1 = paddle.multiply(basis1, paddle.sin(theta[idx])) + rho = paddle.add(rho0, rho1) + op_list[i] = rho + elif int(ele) == 1: + # rho = diag(concat([cos(theta[idx]), sin(theta[idx])])) + # rho = paddle.to_tensor(rho, zeros((2, 2), dtype="float64")) + basis0 = paddle.to_tensor(np.array([[1, 0], [0, 0]]), dtype=paddle_quantum.get_dtype()) + basis1 = paddle.to_tensor(np.array([[0, 0], [0, 1]]), dtype=paddle_quantum.get_dtype()) + rho0 = paddle.multiply(basis0, paddle.sin(theta[idx])) + rho1 = paddle.multiply(basis1, paddle.cos(theta[idx])) + rho = paddle.add(rho0, rho1) + op_list[i] = rho + else: + print("cannot recognize the result_desired.") + # rho = paddle.to_tensor(ones((2, 2), dtype="float64"), zeros((2, 2), dtype="float64")) + measure_operator = paddle.to_tensor(op_list[0]) + if n > 1: + for idx in range(1, len(op_list)): + measure_operator = paddle.kron(measure_operator, op_list[idx]) + state_measured = paddle.matmul( + paddle.matmul(measure_operator, state_data), + paddle_quantum.linalg.dagger(measure_operator) + ) + prob = paddle.real(paddle.trace(paddle.matmul( + paddle.matmul(paddle_quantum.linalg.dagger(measure_operator), measure_operator), + state_data + ))) + state_measured = paddle.divide(state_measured, prob) + return state_measured, prob, result_desired + + def __measure_parameterless(self, state, which_qubits, result_desired): + r"""TODO 进行 01 测量。 + + Args: + state (Tensor): 输入的量子态 + which_qubits (list): 测量作用的量子比特编号 + result_desired (str): 期望得到的测量结果 + + Returns: + Tensor: 测量坍塌后的量子态 + Tensor: 测量坍塌得到的概率 + str: 测量得到的结果 + """ + n = self.get_num_qubits() + assert len(which_qubits) == len(result_desired), \ + "the length of qubits wanted to be measured and the result desired should be same" + op_list = [np.eye(2)] * n + for i, ele in zip(which_qubits, result_desired): + k = int(ele) + rho = np.zeros((2, 2)) + rho[int(k), int(k)] = 1 + op_list[i] = rho + if n > 1: + measure_operator = paddle.to_tensor(functools.reduce(np.kron, op_list), dtype=paddle_quantum.get_dtype()) + else: + measure_operator = paddle.to_tensor(op_list[0], dtype=paddle_quantum.get_dtype()) + state_measured = paddle.matmul( + paddle.matmul(measure_operator, state), + paddle_quantum.linalg.dagger(measure_operator) + ) + prob = paddle.real(paddle.trace(paddle.matmul( + paddle.matmul(paddle_quantum.linalg.dagger(measure_operator), measure_operator), + state + ))) + state_measured = paddle.divide(state_measured, prob) + return state_measured, prob, result_desired + + def measure( + self, status: Union[List[LoccState], LoccState], which_qubits: Iterable, + results_desired: Union[List[str], str], theta: paddle.Tensor = None + ) -> Union[List[LoccState], LoccState]: + r"""Perform 0-1 measurement or parameterized measurement on an LOCC state. + + Args: + status: LOCC state to be measured. + which_qubits: Indices of the qubits to be measured. + results_desired: Expected measurement outcomes. + theta: Parameters of measurement. Defaults to ``None``, which means 0-1 measurement. + + Raises: + ValueError: The ``results_desired`` should be ``str`` or a ``list`` of it. + ValueError: Party's ID should be ``str`` or ``int``. + ValueError: The ``status`` should be ``LoccState`` or a ``list`` of it. + + Returns: + LOCC state after measurement. + """ + # TODO: names of status, which_qubits + if isinstance(which_qubits, tuple): + which_qubits = [which_qubits] + if isinstance(results_desired, str): + results_desired = [results_desired] + elif not isinstance(results_desired, list): + raise ValueError("cannot recognize the input of results_desired") + + qubits_list = [] + for party_id, qubit_id in which_qubits: + if isinstance(party_id, int): + qubits_list.append((self.parties_by_number[party_id][qubit_id])) + elif isinstance(party_id, str): + qubits_list.append((self.parties_by_name[party_id][qubit_id])) + else: + raise ValueError + + if isinstance(status, LoccState): + existing_result = status.measured_result + prior_prob = status.prob + new_status = [] + for result_desired in results_desired: + if theta is None: + result_measured = self.__measure_parameterless(status.data, qubits_list, result_desired) + else: + result_measured = self.__measure_parameterized(status.data, qubits_list, result_desired, theta) + state_data, prob, res = result_measured + _state = status.clone() + _state.data = state_data + _state.num_qubits = int(math.log2(state_data.shape[-1])) + _state.prob = prior_prob * prob + _state.measured_result = existing_result + res + new_status.append(_state) + if len(new_status) == 1: + new_status = new_status[0] + elif isinstance(status, list): + new_status = [] + for each_status in status: + existing_result = each_status.measured_result + prior_prob = each_status.prob + for result_desired in results_desired: + if theta is None: + result_measured = self.__measure_parameterless(each_status.state, qubits_list, result_desired) + else: + result_measured = self.__measure_parameterized(each_status.state, qubits_list, result_desired, theta) + state_data, prob, res = result_measured + _state = each_status.clone() + _state.data = state_data + _state.num_qubits = int(math.log2(state_data.shape[-1])) + _state.prob = prior_prob * prob + _state.measured_result = existing_result + res + new_status.append(_state) + else: + raise ValueError("can't recognize the input status") + + return new_status + + def get_num_qubits(self) -> int: + r"""Get the number of the qubits in this LOCCNet. + + Returns: + Number of qubits in LOCCNet. + """ + num_qubits = 0 + for party in self.parties_by_number: + num_qubits += party.num_qubits + return num_qubits diff --git a/paddle_quantum/locc/locc_party.py b/paddle_quantum/locc/locc_party.py new file mode 100644 index 0000000..68409d4 --- /dev/null +++ b/paddle_quantum/locc/locc_party.py @@ -0,0 +1,39 @@ +# !/usr/bin/env python3 +# 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. + +r""" +The source file of the LoccParty class. +""" + + +class LoccParty(object): + r"""An LOCC party. + + Args: + num_qubits: Number of qubits of this party. + """ + def __init__(self, num_qubits: int): + super().__init__() + self.num_qubits = num_qubits + self.qubits = [None] * num_qubits + + def __setitem__(self, key, value): + self.qubits[key] = value + + def __getitem__(self, item): + return self.qubits[item] + + def __len__(self): + return self.num_qubits diff --git a/paddle_quantum/locc/locc_state.py b/paddle_quantum/locc/locc_state.py new file mode 100644 index 0000000..4e84c3b --- /dev/null +++ b/paddle_quantum/locc/locc_state.py @@ -0,0 +1,95 @@ +# !/usr/bin/env python3 +# 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. + +r""" +The source file of the LoccState class. +""" + +import math +import paddle +import paddle_quantum +from ..intrinsic import _get_float_dtype +from typing import Optional + + +class LoccState(paddle_quantum.State): + r"""An LOCC state in LOCCNet. + + We care not only about the quantum state in LOCC, but also about the probability of getting it and + the corresponding measurement result. Therefore, this class contains three attributes: + quantum state ``data``, the probability of getting this state ``prob``, and the measurement result leading + to this state, namely ``measured_result``. + + Args: + data: Matrix form of the quantum state of this ``LoccState``. Defaults to ``None``. + prob: Probability of getting this quantum state.. Defaults to ``None``. + measured_result: Measurement result leading to this quantum state. Defaults to ``None``. + num_qubits: Total number of qubits. Defaults to ``None``. + backend: Backend of Paddle Quantum. Defaults to ``None``. + dtype: Type of data. Defaults to ``None``. + """ + def __init__( + self, data: paddle.Tensor = None, prob: paddle.Tensor = None, measured_result: str = None, num_qubits: Optional[int] = None, + backend: Optional[paddle_quantum.Backend] = None, dtype: Optional[str] = None + ): + if data is None and prob is None and measured_result is None: + self.data = paddle.to_tensor([1], dtype=paddle_quantum.get_dtype()) + self.prob = paddle.to_tensor([1], dtype=_get_float_dtype(paddle_quantum.get_dtype())) + self.measured_result = '' + self.num_qubits = 0 + else: + self.data = data + self.prob = prob + self.measured_result = measured_result + if num_qubits is None: + self.num_qubits = int(math.log2(data.shape[-1])) + else: + self.num_qubits = num_qubits + backend = paddle_quantum.get_backend() if backend is None else backend + assert backend == paddle_quantum.Backend.DensityMatrix + self.backend = backend + self.dtype = dtype if dtype is not None else paddle_quantum.get_dtype() + + def clone(self) -> 'LoccState': + r"""Create a copy of the current object. + + Returns: + A copy of the current object. + """ + return LoccState(self.data, self.prob, self.measured_result, self.num_qubits, self.backend, self.dtype) + + def __getitem__(self, item): + if item == 0: + return self.data + if item == 1: + return self.prob + if item == 2: + return self.measured_result + raise ValueError("too many values to unpack (expected 3)") + + def __repr__(self): + return ( + f"state: {self.data.numpy()}\n" + f"prob: {self.prob.numpy()[0]}\n" + f"measured_result: {self.measured_result}") + + def __str__(self): + return ( + f"state: {self.data.numpy()}\n" + f"prob: {self.prob.numpy()[0]}\n" + f"measured_result: {self.measured_result}") + + +LoccStatus = LoccState diff --git a/paddle_quantum/loss/__init__.py b/paddle_quantum/loss/__init__.py new file mode 100644 index 0000000..8323d43 --- /dev/null +++ b/paddle_quantum/loss/__init__.py @@ -0,0 +1,21 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The module of the pre-provided loss. +""" + +from .measure import ExpecVal, Measure +from .distance import TraceDistance, StateFidelity diff --git a/paddle_quantum/loss/distance.py b/paddle_quantum/loss/distance.py new file mode 100644 index 0000000..ee82a54 --- /dev/null +++ b/paddle_quantum/loss/distance.py @@ -0,0 +1,115 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the class for the distance. +""" + +import paddle +import paddle_quantum + + +class TraceDistance(paddle_quantum.Operator): + r"""The class of the loss function to compute the trace distance. + + This interface can make you using the trace distance as the loss function. + + Args: + target_state: The target state to be used to compute the trace distance. + + """ + def __init__(self, target_state: paddle_quantum.State): + super().__init__() + self.target_state = target_state + + def forward(self, state: paddle_quantum.State) -> paddle.Tensor: + r"""Compute the trace distance between the input state and the target state. + + The value computed by this function can be used as a loss function to optimize. + + Args: + state: The input state which will be used to compute the trace distance with the target state. + + Raises: + NotImplementedError: The backend is wrong or not supported. + + Returns: + The trace distance between the input state and the target state. + """ + if self.backend == paddle_quantum.Backend.StateVector: + state = state.data + state = paddle.unsqueeze(state, axis=1) + target_state = paddle.unsqueeze(self.target_state.data, axis=1) + target_state_dagger = paddle.conj(paddle.t(target_state)) + fidelity = paddle.abs(paddle.matmul(target_state_dagger, state)) + distance = paddle.sqrt(1 - paddle.square(fidelity)) + distance = paddle.reshape(distance, [1]) + elif self.backend == paddle_quantum.Backend.DensityMatrix: + _matrix = state.data - self.target_state.data + _matrix = paddle.matmul(paddle.conj(paddle.t(_matrix)), _matrix) + eigenvalues = paddle.linalg.eigvalsh(_matrix).abs() + distance = paddle.sum(paddle.sqrt(eigenvalues)) * 0.5 + else: + raise NotImplementedError + return distance + + +class StateFidelity(paddle_quantum.Operator): + r"""The class of the loss function to compute the state fidelity. + + This interface can make you using the state fidelity as the loss function. + + Args: + target_state: The target state to be used to compute the state fidelity. + """ + def __init__(self, target_state: paddle_quantum.State): + super().__init__() + self.target_state = target_state + + def forward(self, state: paddle_quantum.State) -> paddle.Tensor: + r"""Compute the state fidelity between the input state and the target state. + + The value computed by this function can be used as a loss function to optimize. + + Args: + state: The input state which will be used to compute the state fidelity with the target state. + + Raises: + NotImplementedError: The backend is wrong or not supported. + + Returns: + The state fidelity between the input state and the target state. + """ + if self.backend == paddle_quantum.Backend.StateVector: + state = state.data + state = paddle.unsqueeze(state, axis=1) + target_state = paddle.unsqueeze(self.target_state.data, axis=1) + target_state_dagger = paddle.conj(paddle.t(target_state)) + fidelity = paddle.abs(paddle.matmul(target_state_dagger, state)) + fidelity = paddle.reshape(fidelity, [1]) + elif self.backend == paddle_quantum.Backend.DensityMatrix: + target_state = self.target_state.data + state = state.data + target_state_eig_vals, target_state_eig_vec = paddle.linalg.eigh(target_state) + target_state_sqrt = paddle.matmul( + paddle.matmul(target_state_eig_vec, paddle.diag(paddle.sqrt(paddle.abs(target_state_eig_vals)))), + paddle.conj(paddle.t(target_state_eig_vec)) + ) + _matrix = paddle.matmul(target_state_sqrt, paddle.matmul(state, target_state_sqrt)) + eig_vals = paddle.linalg.eigvalsh(_matrix) + fidelity = paddle.sum(paddle.sqrt(paddle.abs(eig_vals))) + else: + raise NotImplementedError + return fidelity diff --git a/paddle_quantum/loss/measure.py b/paddle_quantum/loss/measure.py new file mode 100644 index 0000000..da736c2 --- /dev/null +++ b/paddle_quantum/loss/measure.py @@ -0,0 +1,194 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the class for the measurement. +""" + +import paddle +import paddle_quantum +from ..backend import quleaf +from ..backend import Backend +from typing import Optional, Union, Iterable + + +class ExpecVal(paddle_quantum.Operator): + r"""The class of the loss function to compute the expectation value for the observable. + + This interface can make you using the expectation value for the observable as the loss function. + + Args: + hamiltonian: The input observable. + shots: The number of measurement shots. Defaults to ``0``. Now it just need to be input when the backend is QuLeaf. + """ + def __init__(self, hamiltonian: paddle_quantum.Hamiltonian, shots: Optional[int] = 0): + super().__init__() + self.hamiltonian = hamiltonian + self.shots = shots + self.num_terms = self.hamiltonian.n_terms + self.coeffs = paddle.to_tensor(self.hamiltonian.coefficients) + self.sites = self.hamiltonian.sites + self.matrices = self.hamiltonian.pauli_words_matrix + + def __state_qubits_swap(self, pauli_site, state_data, num_qubits): + # generate swap_list + origin_seq = list(range(0, num_qubits)) + target_seq = pauli_site + [x for x in origin_seq if x not in pauli_site] + swapped = [False] * num_qubits + swap_list = [] + for idx in range(0, num_qubits): + if not swapped[idx]: + next_idx = idx + swapped[next_idx] = True + while not swapped[target_seq[next_idx]]: + swapped[target_seq[next_idx]] = True + if next_idx < target_seq[next_idx]: + swap_list.append((next_idx, target_seq[next_idx])) + else: + swap_list.append((target_seq[next_idx], next_idx)) + next_idx = target_seq[next_idx] + + # function for swapping ath and bth qubit in state + def swap_a_and_b(target_state, size, pos_a, pos_b): + target_state = target_state.reshape([2 ** pos_a, 2, 2 ** (pos_b - pos_a - 1), 2, 2 ** (size - pos_b - 1)]) + return paddle.transpose(target_state, [0, 3, 2, 1, 4]) + + # begin swap + if self.backend == paddle_quantum.Backend.DensityMatrix: + for a, b in swap_list: + state_data = swap_a_and_b(state_data, 2 * num_qubits, a, b) + state_data = swap_a_and_b(state_data, 2 * num_qubits, a + num_qubits, b + num_qubits) + else: + for a, b in swap_list: + state_data = swap_a_and_b(state_data, num_qubits, a, b) + return state_data + + def forward(self, state: paddle_quantum.State) -> paddle.Tensor: + r"""Compute the expectation value of the observable with respect to the input state. + + The value computed by this function can be used as a loss function to optimize. + + Args: + state: The input state which will be used to compute the expectation value. + + Raises: + NotImplementedError: The backend is wrong or not supported. + + Returns: + The expectation value. If the backend is QuLeaf, it is computed by sampling. + """ + if self.backend == Backend.QuLeaf: + expec_val = quleaf.ExpecValOp.apply( + paddle.concat(state.param_list), + state, self.hamiltonian, self.shots + ) + return expec_val + + num_qubits = state.num_qubits + expec_val = paddle.zeros([1]) + state_data = state.data + for i in range(0, self.num_terms): + pauli_site = self.sites[i] + if pauli_site == ['']: + expec_val += self.coeffs[i] + continue + num_applied_qubits = len(pauli_site) + matrix = self.matrices[i] + # extract current state and do swap operation + if num_qubits != 1: + _state_data = self.__state_qubits_swap(pauli_site, state_data, num_qubits) + else: + _state_data = state_data + # use einstein sum notation to shrink the size of operation of matrix multiplication + if self.backend == Backend.StateVector: + _state_data = _state_data.reshape([2 ** num_applied_qubits, 2 ** (num_qubits - num_applied_qubits)]) + output_state = paddle.einsum('ia, ab->ib', matrix, _state_data).reshape([2 ** num_qubits]) + _state_data = paddle.conj(_state_data.reshape([2 ** num_qubits])) + expec_val += paddle.real(paddle.matmul(_state_data, output_state)) * self.coeffs[i] + elif self.backend == Backend.DensityMatrix: + _state_data = _state_data.reshape([2 ** num_applied_qubits, 2 ** (2 * num_qubits - num_applied_qubits)]) + output_state = paddle.einsum('ia, ab->ib', matrix, _state_data) + output_state = output_state.reshape([2 ** num_qubits, 2 ** num_qubits]) + expec_val += paddle.real(paddle.trace(output_state)) * self.coeffs[i] + else: + raise NotImplementedError + return expec_val + + +class Measure(paddle_quantum.Operator): + r"""Compute the probability of the specified measurement result. + + Args: + measure_basis: Specify the basis of the measurement. Defaults to ``'z'``. + + Raises: + NotImplementedError: Currently we just support the z basis. + """ + def __init__(self, measure_basis: Optional[Union[Iterable[paddle.Tensor], str]] = 'z'): + super().__init__() + if measure_basis == 'z' or measure_basis == 'computational_basis': + self.measure_basis = 'z' + else: + raise NotImplementedError + + def forward( + self, state: paddle_quantum.State, qubits_idx: Optional[Union[Iterable[int], int, str]] = 'full', + desired_result: Optional[Union[Iterable[str], str]] = None + ) -> paddle.Tensor: + r"""Compute the probability of measurement to the input state. + + Args: + state: The quantum state to be measured. + qubits_idx: The index of the qubits to be measured. Defaults to ``'full'`` which means measure all the qubits. + desired_result: Specify the results of the measurement to return. Defaults to ``None`` which means return the probability of all the results. + + Returns: + The probability of the measurement. + """ + num_qubits = state.num_qubits + if self.measure_basis == 'z': + if state.backend == paddle_quantum.Backend.StateVector: + prob_amplitude = paddle.multiply(paddle.conj(state.data), state.data).real() + elif state.backend == paddle_quantum.Backend.DensityMatrix: + prob_amplitude = paddle.zeros([2 ** num_qubits]) + for idx in range(0, 2 ** num_qubits): + prob_amplitude[idx] += state.data[idx, idx].real() + else: + raise NotImplementedError + + if isinstance(qubits_idx, int): + qubits_idx = [qubits_idx] + if isinstance(qubits_idx, Iterable) and all((isinstance(idx, int) for idx in qubits_idx)): + qubits_idx = list(qubits_idx) + measured_num = len(qubits_idx) + prob_array = paddle.zeros([2 ** measured_num]) + for idx in range(0, 2 ** num_qubits): + binary = bin(idx)[2:] + binary = '0' * (num_qubits - len(binary)) + binary + target_qubits = '' + for qubit_idx in qubits_idx: + target_qubits += binary[qubit_idx] + prob_array[int(target_qubits, base=2)] += prob_amplitude[idx] + elif qubits_idx == 'full': + prob_array = prob_amplitude + else: + raise NotImplementedError + if desired_result is None: + return prob_array + if isinstance(desired_result, str): + desired_result = [desired_result] + return paddle.concat([prob_array[int(res, base=2)] for res in desired_result]) + else: + raise NotImplementedError diff --git a/paddle_quantum/optimizer/__init__.py b/paddle_quantum/mbqc/GRCS/example/main.py similarity index 65% rename from paddle_quantum/optimizer/__init__.py rename to paddle_quantum/mbqc/GRCS/example/main.py index 5fe82ea..cdbad2a 100644 --- a/paddle_quantum/optimizer/__init__.py +++ b/paddle_quantum/mbqc/GRCS/example/main.py @@ -13,20 +13,18 @@ # limitations under the License. """ -Export the SciPy optimizers +main """ -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 +from paddle_quantum.mbqc.GRCS.supremacy import grcs, compare_time -__all__ = [ - 'CustomOptimizer', - 'ConjugateGradient', - 'NewtonCG', - 'Powell', - 'SLSQP' -] + +def main(): + r"""量子霸权电路主函数。 + """ + grcs() # Run GRCS circuits + compare_time() # Plot the running time of MBQC and Qiskit + + +if __name__ == '__main__': + main() diff --git a/paddle_quantum/mbqc/GRCS/example/record_time.txt b/paddle_quantum/mbqc/GRCS/example/record_time.txt new file mode 100644 index 0000000..321c74a --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/record_time.txt @@ -0,0 +1,15 @@ +The current example is: inst_5x5_10_0.txt +The qubit number is: 25 +MBQC running time is: 3.0552566000000003 s +Circuit model running time is: 1.7434521999999992 s + +The current example is: inst_5x5_10_1.txt +The qubit number is: 25 +MBQC running time is: 2.6848477000000006 s +Circuit model running time is: 1.7602902 s + +The current example is: inst_5x5_10_2.txt +The qubit number is: 25 +MBQC running time is: 3.0684313000000003 s +Circuit model running time is: 1.6926625000000008 s + diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_0.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_0.txt new file mode 100644 index 0000000..913a5b4 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_0.txt @@ -0,0 +1,185 @@ +25 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +1 cz 0 1 +1 cz 7 8 +1 cz 10 11 +1 cz 17 18 +1 cz 20 21 +1 t 2 +1 t 3 +1 t 4 +1 t 5 +1 t 6 +1 t 9 +1 t 12 +1 t 13 +1 t 14 +1 t 15 +1 t 16 +1 t 19 +1 t 22 +1 t 23 +1 t 24 +2 cz 5 10 +2 cz 16 21 +2 cz 7 12 +2 cz 18 23 +2 cz 9 14 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 8 +2 x_1_2 11 +2 y_1_2 17 +2 x_1_2 20 +3 cz 1 2 +3 cz 8 9 +3 cz 11 12 +3 cz 18 19 +3 cz 21 22 +3 t 0 +3 y_1_2 5 +3 x_1_2 7 +3 x_1_2 10 +3 y_1_2 14 +3 y_1_2 16 +3 t 17 +3 t 20 +3 y_1_2 23 +4 cz 0 5 +4 cz 11 16 +4 cz 2 7 +4 cz 13 18 +4 cz 4 9 +4 x_1_2 1 +4 y_1_2 8 +4 t 10 +4 y_1_2 12 +4 t 14 +4 x_1_2 19 +4 y_1_2 21 +4 y_1_2 22 +4 t 23 +5 cz 2 3 +5 cz 5 6 +5 cz 12 13 +5 cz 15 16 +5 cz 22 23 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 x_1_2 7 +5 t 8 +5 y_1_2 9 +5 y_1_2 11 +5 y_1_2 18 +5 t 19 +5 t 21 +6 cz 15 20 +6 cz 6 11 +6 cz 17 22 +6 cz 8 13 +6 cz 19 24 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 x_1_2 5 +6 t 7 +6 t 9 +6 y_1_2 12 +6 y_1_2 16 +6 t 18 +6 y_1_2 23 +7 cz 3 4 +7 cz 6 7 +7 cz 13 14 +7 cz 16 17 +7 cz 23 24 +7 t 2 +7 t 5 +7 x_1_2 8 +7 y_1_2 11 +7 t 12 +7 x_1_2 15 +7 y_1_2 19 +7 y_1_2 20 +7 x_1_2 22 +8 cz 10 15 +8 cz 1 6 +8 cz 12 17 +8 cz 3 8 +8 cz 14 19 +8 y_1_2 4 +8 x_1_2 7 +8 t 11 +8 y_1_2 13 +8 y_1_2 16 +8 t 20 +8 t 22 +8 x_1_2 23 +8 x_1_2 24 +9 cz 0 1 +9 cz 7 8 +9 cz 10 11 +9 cz 17 18 +9 cz 20 21 +9 y_1_2 3 +9 t 4 +9 x_1_2 6 +9 x_1_2 12 +9 t 13 +9 y_1_2 14 +9 x_1_2 15 +9 t 16 +9 y_1_2 19 +9 t 23 +9 t 24 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_1.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_1.txt new file mode 100644 index 0000000..736db41 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_1.txt @@ -0,0 +1,185 @@ +25 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +1 cz 0 1 +1 cz 7 8 +1 cz 10 11 +1 cz 17 18 +1 cz 20 21 +1 t 2 +1 t 3 +1 t 4 +1 t 5 +1 t 6 +1 t 9 +1 t 12 +1 t 13 +1 t 14 +1 t 15 +1 t 16 +1 t 19 +1 t 22 +1 t 23 +1 t 24 +2 cz 5 10 +2 cz 16 21 +2 cz 7 12 +2 cz 18 23 +2 cz 9 14 +2 x_1_2 0 +2 y_1_2 1 +2 y_1_2 8 +2 x_1_2 11 +2 x_1_2 17 +2 x_1_2 20 +3 cz 1 2 +3 cz 8 9 +3 cz 11 12 +3 cz 18 19 +3 cz 21 22 +3 t 0 +3 y_1_2 5 +3 y_1_2 7 +3 x_1_2 10 +3 x_1_2 14 +3 y_1_2 16 +3 t 17 +3 t 20 +3 x_1_2 23 +4 cz 0 5 +4 cz 11 16 +4 cz 2 7 +4 cz 13 18 +4 cz 4 9 +4 y_1_2 1 +4 x_1_2 8 +4 t 10 +4 x_1_2 12 +4 t 14 +4 y_1_2 19 +4 x_1_2 21 +4 y_1_2 22 +4 t 23 +5 cz 2 3 +5 cz 5 6 +5 cz 12 13 +5 cz 15 16 +5 cz 22 23 +5 y_1_2 0 +5 t 1 +5 x_1_2 4 +5 x_1_2 7 +5 t 8 +5 y_1_2 9 +5 y_1_2 11 +5 x_1_2 18 +5 t 19 +5 t 21 +6 cz 15 20 +6 cz 6 11 +6 cz 17 22 +6 cz 8 13 +6 cz 19 24 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 x_1_2 5 +6 t 7 +6 t 9 +6 x_1_2 12 +6 x_1_2 16 +6 t 18 +6 x_1_2 23 +7 cz 3 4 +7 cz 6 7 +7 cz 13 14 +7 cz 16 17 +7 cz 23 24 +7 t 2 +7 t 5 +7 x_1_2 8 +7 x_1_2 11 +7 t 12 +7 x_1_2 15 +7 x_1_2 19 +7 x_1_2 20 +7 x_1_2 22 +8 cz 10 15 +8 cz 1 6 +8 cz 12 17 +8 cz 3 8 +8 cz 14 19 +8 y_1_2 4 +8 y_1_2 7 +8 t 11 +8 y_1_2 13 +8 x_1_2 16 +8 t 20 +8 t 22 +8 y_1_2 23 +8 y_1_2 24 +9 cz 0 1 +9 cz 7 8 +9 cz 10 11 +9 cz 17 18 +9 cz 20 21 +9 x_1_2 3 +9 t 4 +9 x_1_2 6 +9 y_1_2 12 +9 t 13 +9 y_1_2 14 +9 y_1_2 15 +9 t 16 +9 x_1_2 19 +9 t 23 +9 t 24 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_2.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_2.txt new file mode 100644 index 0000000..2794e78 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_2.txt @@ -0,0 +1,185 @@ +25 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +1 cz 0 1 +1 cz 7 8 +1 cz 10 11 +1 cz 17 18 +1 cz 20 21 +1 t 2 +1 t 3 +1 t 4 +1 t 5 +1 t 6 +1 t 9 +1 t 12 +1 t 13 +1 t 14 +1 t 15 +1 t 16 +1 t 19 +1 t 22 +1 t 23 +1 t 24 +2 cz 5 10 +2 cz 16 21 +2 cz 7 12 +2 cz 18 23 +2 cz 9 14 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 8 +2 x_1_2 11 +2 y_1_2 17 +2 y_1_2 20 +3 cz 1 2 +3 cz 8 9 +3 cz 11 12 +3 cz 18 19 +3 cz 21 22 +3 t 0 +3 y_1_2 5 +3 x_1_2 7 +3 y_1_2 10 +3 y_1_2 14 +3 y_1_2 16 +3 t 17 +3 t 20 +3 x_1_2 23 +4 cz 0 5 +4 cz 11 16 +4 cz 2 7 +4 cz 13 18 +4 cz 4 9 +4 x_1_2 1 +4 x_1_2 8 +4 t 10 +4 y_1_2 12 +4 t 14 +4 y_1_2 19 +4 y_1_2 21 +4 y_1_2 22 +4 t 23 +5 cz 2 3 +5 cz 5 6 +5 cz 12 13 +5 cz 15 16 +5 cz 22 23 +5 x_1_2 0 +5 t 1 +5 x_1_2 4 +5 x_1_2 7 +5 t 8 +5 x_1_2 9 +5 x_1_2 11 +5 x_1_2 18 +5 t 19 +5 t 21 +6 cz 15 20 +6 cz 6 11 +6 cz 17 22 +6 cz 8 13 +6 cz 19 24 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 y_1_2 5 +6 t 7 +6 t 9 +6 y_1_2 12 +6 x_1_2 16 +6 t 18 +6 x_1_2 23 +7 cz 3 4 +7 cz 6 7 +7 cz 13 14 +7 cz 16 17 +7 cz 23 24 +7 t 2 +7 t 5 +7 x_1_2 8 +7 x_1_2 11 +7 t 12 +7 y_1_2 15 +7 y_1_2 19 +7 y_1_2 20 +7 x_1_2 22 +8 cz 10 15 +8 cz 1 6 +8 cz 12 17 +8 cz 3 8 +8 cz 14 19 +8 y_1_2 4 +8 y_1_2 7 +8 t 11 +8 y_1_2 13 +8 y_1_2 16 +8 t 20 +8 t 22 +8 y_1_2 23 +8 y_1_2 24 +9 cz 0 1 +9 cz 7 8 +9 cz 10 11 +9 cz 17 18 +9 cz 20 21 +9 x_1_2 3 +9 t 4 +9 y_1_2 6 +9 y_1_2 12 +9 t 13 +9 x_1_2 14 +9 y_1_2 15 +9 t 16 +9 y_1_2 19 +9 t 23 +9 t 24 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_3.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_3.txt new file mode 100644 index 0000000..2bf2af3 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_3.txt @@ -0,0 +1,185 @@ +25 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +1 cz 0 1 +1 cz 7 8 +1 cz 10 11 +1 cz 17 18 +1 cz 20 21 +1 t 2 +1 t 3 +1 t 4 +1 t 5 +1 t 6 +1 t 9 +1 t 12 +1 t 13 +1 t 14 +1 t 15 +1 t 16 +1 t 19 +1 t 22 +1 t 23 +1 t 24 +2 cz 5 10 +2 cz 16 21 +2 cz 7 12 +2 cz 18 23 +2 cz 9 14 +2 x_1_2 0 +2 y_1_2 1 +2 x_1_2 8 +2 y_1_2 11 +2 y_1_2 17 +2 x_1_2 20 +3 cz 1 2 +3 cz 8 9 +3 cz 11 12 +3 cz 18 19 +3 cz 21 22 +3 t 0 +3 x_1_2 5 +3 y_1_2 7 +3 x_1_2 10 +3 x_1_2 14 +3 y_1_2 16 +3 t 17 +3 t 20 +3 x_1_2 23 +4 cz 0 5 +4 cz 11 16 +4 cz 2 7 +4 cz 13 18 +4 cz 4 9 +4 y_1_2 1 +4 x_1_2 8 +4 t 10 +4 y_1_2 12 +4 t 14 +4 x_1_2 19 +4 y_1_2 21 +4 y_1_2 22 +4 t 23 +5 cz 2 3 +5 cz 5 6 +5 cz 12 13 +5 cz 15 16 +5 cz 22 23 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 y_1_2 7 +5 t 8 +5 x_1_2 9 +5 y_1_2 11 +5 y_1_2 18 +5 t 19 +5 t 21 +6 cz 15 20 +6 cz 6 11 +6 cz 17 22 +6 cz 8 13 +6 cz 19 24 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 y_1_2 5 +6 t 7 +6 t 9 +6 x_1_2 12 +6 y_1_2 16 +6 t 18 +6 y_1_2 23 +7 cz 3 4 +7 cz 6 7 +7 cz 13 14 +7 cz 16 17 +7 cz 23 24 +7 t 2 +7 t 5 +7 y_1_2 8 +7 y_1_2 11 +7 t 12 +7 x_1_2 15 +7 y_1_2 19 +7 x_1_2 20 +7 y_1_2 22 +8 cz 10 15 +8 cz 1 6 +8 cz 12 17 +8 cz 3 8 +8 cz 14 19 +8 y_1_2 4 +8 x_1_2 7 +8 t 11 +8 x_1_2 13 +8 x_1_2 16 +8 t 20 +8 t 22 +8 y_1_2 23 +8 x_1_2 24 +9 cz 0 1 +9 cz 7 8 +9 cz 10 11 +9 cz 17 18 +9 cz 20 21 +9 y_1_2 3 +9 t 4 +9 x_1_2 6 +9 y_1_2 12 +9 t 13 +9 x_1_2 14 +9 x_1_2 15 +9 t 16 +9 y_1_2 19 +9 t 23 +9 t 24 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_4.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_4.txt new file mode 100644 index 0000000..4f05a63 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_4.txt @@ -0,0 +1,185 @@ +25 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +1 cz 0 1 +1 cz 7 8 +1 cz 10 11 +1 cz 17 18 +1 cz 20 21 +1 t 2 +1 t 3 +1 t 4 +1 t 5 +1 t 6 +1 t 9 +1 t 12 +1 t 13 +1 t 14 +1 t 15 +1 t 16 +1 t 19 +1 t 22 +1 t 23 +1 t 24 +2 cz 5 10 +2 cz 16 21 +2 cz 7 12 +2 cz 18 23 +2 cz 9 14 +2 x_1_2 0 +2 x_1_2 1 +2 x_1_2 8 +2 x_1_2 11 +2 x_1_2 17 +2 x_1_2 20 +3 cz 1 2 +3 cz 8 9 +3 cz 11 12 +3 cz 18 19 +3 cz 21 22 +3 t 0 +3 y_1_2 5 +3 y_1_2 7 +3 y_1_2 10 +3 x_1_2 14 +3 y_1_2 16 +3 t 17 +3 t 20 +3 x_1_2 23 +4 cz 0 5 +4 cz 11 16 +4 cz 2 7 +4 cz 13 18 +4 cz 4 9 +4 x_1_2 1 +4 x_1_2 8 +4 t 10 +4 x_1_2 12 +4 t 14 +4 y_1_2 19 +4 y_1_2 21 +4 y_1_2 22 +4 t 23 +5 cz 2 3 +5 cz 5 6 +5 cz 12 13 +5 cz 15 16 +5 cz 22 23 +5 y_1_2 0 +5 t 1 +5 x_1_2 4 +5 x_1_2 7 +5 t 8 +5 y_1_2 9 +5 y_1_2 11 +5 y_1_2 18 +5 t 19 +5 t 21 +6 cz 15 20 +6 cz 6 11 +6 cz 17 22 +6 cz 8 13 +6 cz 19 24 +6 t 0 +6 y_1_2 2 +6 x_1_2 3 +6 t 4 +6 y_1_2 5 +6 t 7 +6 t 9 +6 y_1_2 12 +6 y_1_2 16 +6 t 18 +6 x_1_2 23 +7 cz 3 4 +7 cz 6 7 +7 cz 13 14 +7 cz 16 17 +7 cz 23 24 +7 t 2 +7 t 5 +7 x_1_2 8 +7 x_1_2 11 +7 t 12 +7 y_1_2 15 +7 y_1_2 19 +7 y_1_2 20 +7 x_1_2 22 +8 cz 10 15 +8 cz 1 6 +8 cz 12 17 +8 cz 3 8 +8 cz 14 19 +8 y_1_2 4 +8 y_1_2 7 +8 t 11 +8 y_1_2 13 +8 y_1_2 16 +8 t 20 +8 t 22 +8 y_1_2 23 +8 x_1_2 24 +9 cz 0 1 +9 cz 7 8 +9 cz 10 11 +9 cz 17 18 +9 cz 20 21 +9 y_1_2 3 +9 t 4 +9 x_1_2 6 +9 x_1_2 12 +9 t 13 +9 x_1_2 14 +9 y_1_2 15 +9 t 16 +9 x_1_2 19 +9 t 23 +9 t 24 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_5.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_5.txt new file mode 100644 index 0000000..fb0c986 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_5.txt @@ -0,0 +1,185 @@ +25 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +1 cz 0 1 +1 cz 7 8 +1 cz 10 11 +1 cz 17 18 +1 cz 20 21 +1 t 2 +1 t 3 +1 t 4 +1 t 5 +1 t 6 +1 t 9 +1 t 12 +1 t 13 +1 t 14 +1 t 15 +1 t 16 +1 t 19 +1 t 22 +1 t 23 +1 t 24 +2 cz 5 10 +2 cz 16 21 +2 cz 7 12 +2 cz 18 23 +2 cz 9 14 +2 y_1_2 0 +2 y_1_2 1 +2 y_1_2 8 +2 y_1_2 11 +2 y_1_2 17 +2 y_1_2 20 +3 cz 1 2 +3 cz 8 9 +3 cz 11 12 +3 cz 18 19 +3 cz 21 22 +3 t 0 +3 x_1_2 5 +3 x_1_2 7 +3 y_1_2 10 +3 y_1_2 14 +3 y_1_2 16 +3 t 17 +3 t 20 +3 x_1_2 23 +4 cz 0 5 +4 cz 11 16 +4 cz 2 7 +4 cz 13 18 +4 cz 4 9 +4 x_1_2 1 +4 x_1_2 8 +4 t 10 +4 y_1_2 12 +4 t 14 +4 y_1_2 19 +4 x_1_2 21 +4 x_1_2 22 +4 t 23 +5 cz 2 3 +5 cz 5 6 +5 cz 12 13 +5 cz 15 16 +5 cz 22 23 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 y_1_2 7 +5 t 8 +5 x_1_2 9 +5 y_1_2 11 +5 x_1_2 18 +5 t 19 +5 t 21 +6 cz 15 20 +6 cz 6 11 +6 cz 17 22 +6 cz 8 13 +6 cz 19 24 +6 t 0 +6 y_1_2 2 +6 x_1_2 3 +6 t 4 +6 x_1_2 5 +6 t 7 +6 t 9 +6 y_1_2 12 +6 x_1_2 16 +6 t 18 +6 x_1_2 23 +7 cz 3 4 +7 cz 6 7 +7 cz 13 14 +7 cz 16 17 +7 cz 23 24 +7 t 2 +7 t 5 +7 y_1_2 8 +7 y_1_2 11 +7 t 12 +7 x_1_2 15 +7 y_1_2 19 +7 y_1_2 20 +7 y_1_2 22 +8 cz 10 15 +8 cz 1 6 +8 cz 12 17 +8 cz 3 8 +8 cz 14 19 +8 x_1_2 4 +8 y_1_2 7 +8 t 11 +8 y_1_2 13 +8 y_1_2 16 +8 t 20 +8 t 22 +8 y_1_2 23 +8 x_1_2 24 +9 cz 0 1 +9 cz 7 8 +9 cz 10 11 +9 cz 17 18 +9 cz 20 21 +9 x_1_2 3 +9 t 4 +9 x_1_2 6 +9 x_1_2 12 +9 t 13 +9 x_1_2 14 +9 x_1_2 15 +9 t 16 +9 y_1_2 19 +9 t 23 +9 t 24 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_6.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_6.txt new file mode 100644 index 0000000..e9cef6c --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_6.txt @@ -0,0 +1,185 @@ +25 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +1 cz 0 1 +1 cz 7 8 +1 cz 10 11 +1 cz 17 18 +1 cz 20 21 +1 t 2 +1 t 3 +1 t 4 +1 t 5 +1 t 6 +1 t 9 +1 t 12 +1 t 13 +1 t 14 +1 t 15 +1 t 16 +1 t 19 +1 t 22 +1 t 23 +1 t 24 +2 cz 5 10 +2 cz 16 21 +2 cz 7 12 +2 cz 18 23 +2 cz 9 14 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 8 +2 x_1_2 11 +2 x_1_2 17 +2 y_1_2 20 +3 cz 1 2 +3 cz 8 9 +3 cz 11 12 +3 cz 18 19 +3 cz 21 22 +3 t 0 +3 x_1_2 5 +3 y_1_2 7 +3 x_1_2 10 +3 y_1_2 14 +3 x_1_2 16 +3 t 17 +3 t 20 +3 y_1_2 23 +4 cz 0 5 +4 cz 11 16 +4 cz 2 7 +4 cz 13 18 +4 cz 4 9 +4 y_1_2 1 +4 x_1_2 8 +4 t 10 +4 y_1_2 12 +4 t 14 +4 y_1_2 19 +4 x_1_2 21 +4 y_1_2 22 +4 t 23 +5 cz 2 3 +5 cz 5 6 +5 cz 12 13 +5 cz 15 16 +5 cz 22 23 +5 y_1_2 0 +5 t 1 +5 x_1_2 4 +5 y_1_2 7 +5 t 8 +5 y_1_2 9 +5 y_1_2 11 +5 x_1_2 18 +5 t 19 +5 t 21 +6 cz 15 20 +6 cz 6 11 +6 cz 17 22 +6 cz 8 13 +6 cz 19 24 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 y_1_2 5 +6 t 7 +6 t 9 +6 x_1_2 12 +6 x_1_2 16 +6 t 18 +6 x_1_2 23 +7 cz 3 4 +7 cz 6 7 +7 cz 13 14 +7 cz 16 17 +7 cz 23 24 +7 t 2 +7 t 5 +7 y_1_2 8 +7 x_1_2 11 +7 t 12 +7 y_1_2 15 +7 y_1_2 19 +7 x_1_2 20 +7 y_1_2 22 +8 cz 10 15 +8 cz 1 6 +8 cz 12 17 +8 cz 3 8 +8 cz 14 19 +8 x_1_2 4 +8 y_1_2 7 +8 t 11 +8 y_1_2 13 +8 y_1_2 16 +8 t 20 +8 t 22 +8 y_1_2 23 +8 y_1_2 24 +9 cz 0 1 +9 cz 7 8 +9 cz 10 11 +9 cz 17 18 +9 cz 20 21 +9 y_1_2 3 +9 t 4 +9 y_1_2 6 +9 x_1_2 12 +9 t 13 +9 x_1_2 14 +9 y_1_2 15 +9 t 16 +9 x_1_2 19 +9 t 23 +9 t 24 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_7.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_7.txt new file mode 100644 index 0000000..3fe6737 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_7.txt @@ -0,0 +1,185 @@ +25 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +1 cz 0 1 +1 cz 7 8 +1 cz 10 11 +1 cz 17 18 +1 cz 20 21 +1 t 2 +1 t 3 +1 t 4 +1 t 5 +1 t 6 +1 t 9 +1 t 12 +1 t 13 +1 t 14 +1 t 15 +1 t 16 +1 t 19 +1 t 22 +1 t 23 +1 t 24 +2 cz 5 10 +2 cz 16 21 +2 cz 7 12 +2 cz 18 23 +2 cz 9 14 +2 x_1_2 0 +2 x_1_2 1 +2 y_1_2 8 +2 x_1_2 11 +2 y_1_2 17 +2 x_1_2 20 +3 cz 1 2 +3 cz 8 9 +3 cz 11 12 +3 cz 18 19 +3 cz 21 22 +3 t 0 +3 x_1_2 5 +3 y_1_2 7 +3 x_1_2 10 +3 x_1_2 14 +3 x_1_2 16 +3 t 17 +3 t 20 +3 x_1_2 23 +4 cz 0 5 +4 cz 11 16 +4 cz 2 7 +4 cz 13 18 +4 cz 4 9 +4 x_1_2 1 +4 y_1_2 8 +4 t 10 +4 x_1_2 12 +4 t 14 +4 x_1_2 19 +4 y_1_2 21 +4 y_1_2 22 +4 t 23 +5 cz 2 3 +5 cz 5 6 +5 cz 12 13 +5 cz 15 16 +5 cz 22 23 +5 y_1_2 0 +5 t 1 +5 x_1_2 4 +5 y_1_2 7 +5 t 8 +5 x_1_2 9 +5 y_1_2 11 +5 x_1_2 18 +5 t 19 +5 t 21 +6 cz 15 20 +6 cz 6 11 +6 cz 17 22 +6 cz 8 13 +6 cz 19 24 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 x_1_2 5 +6 t 7 +6 t 9 +6 y_1_2 12 +6 x_1_2 16 +6 t 18 +6 y_1_2 23 +7 cz 3 4 +7 cz 6 7 +7 cz 13 14 +7 cz 16 17 +7 cz 23 24 +7 t 2 +7 t 5 +7 y_1_2 8 +7 x_1_2 11 +7 t 12 +7 y_1_2 15 +7 x_1_2 19 +7 x_1_2 20 +7 x_1_2 22 +8 cz 10 15 +8 cz 1 6 +8 cz 12 17 +8 cz 3 8 +8 cz 14 19 +8 y_1_2 4 +8 x_1_2 7 +8 t 11 +8 x_1_2 13 +8 y_1_2 16 +8 t 20 +8 t 22 +8 x_1_2 23 +8 x_1_2 24 +9 cz 0 1 +9 cz 7 8 +9 cz 10 11 +9 cz 17 18 +9 cz 20 21 +9 y_1_2 3 +9 t 4 +9 y_1_2 6 +9 x_1_2 12 +9 t 13 +9 y_1_2 14 +9 y_1_2 15 +9 t 16 +9 y_1_2 19 +9 t 23 +9 t 24 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_8.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_8.txt new file mode 100644 index 0000000..cfa64ff --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_8.txt @@ -0,0 +1,185 @@ +25 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +1 cz 0 1 +1 cz 7 8 +1 cz 10 11 +1 cz 17 18 +1 cz 20 21 +1 t 2 +1 t 3 +1 t 4 +1 t 5 +1 t 6 +1 t 9 +1 t 12 +1 t 13 +1 t 14 +1 t 15 +1 t 16 +1 t 19 +1 t 22 +1 t 23 +1 t 24 +2 cz 5 10 +2 cz 16 21 +2 cz 7 12 +2 cz 18 23 +2 cz 9 14 +2 x_1_2 0 +2 y_1_2 1 +2 x_1_2 8 +2 y_1_2 11 +2 x_1_2 17 +2 x_1_2 20 +3 cz 1 2 +3 cz 8 9 +3 cz 11 12 +3 cz 18 19 +3 cz 21 22 +3 t 0 +3 y_1_2 5 +3 x_1_2 7 +3 y_1_2 10 +3 x_1_2 14 +3 x_1_2 16 +3 t 17 +3 t 20 +3 x_1_2 23 +4 cz 0 5 +4 cz 11 16 +4 cz 2 7 +4 cz 13 18 +4 cz 4 9 +4 x_1_2 1 +4 y_1_2 8 +4 t 10 +4 x_1_2 12 +4 t 14 +4 x_1_2 19 +4 x_1_2 21 +4 x_1_2 22 +4 t 23 +5 cz 2 3 +5 cz 5 6 +5 cz 12 13 +5 cz 15 16 +5 cz 22 23 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 x_1_2 7 +5 t 8 +5 x_1_2 9 +5 x_1_2 11 +5 y_1_2 18 +5 t 19 +5 t 21 +6 cz 15 20 +6 cz 6 11 +6 cz 17 22 +6 cz 8 13 +6 cz 19 24 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 x_1_2 5 +6 t 7 +6 t 9 +6 y_1_2 12 +6 x_1_2 16 +6 t 18 +6 y_1_2 23 +7 cz 3 4 +7 cz 6 7 +7 cz 13 14 +7 cz 16 17 +7 cz 23 24 +7 t 2 +7 t 5 +7 x_1_2 8 +7 y_1_2 11 +7 t 12 +7 y_1_2 15 +7 y_1_2 19 +7 x_1_2 20 +7 x_1_2 22 +8 cz 10 15 +8 cz 1 6 +8 cz 12 17 +8 cz 3 8 +8 cz 14 19 +8 y_1_2 4 +8 x_1_2 7 +8 t 11 +8 x_1_2 13 +8 y_1_2 16 +8 t 20 +8 t 22 +8 y_1_2 23 +8 y_1_2 24 +9 cz 0 1 +9 cz 7 8 +9 cz 10 11 +9 cz 17 18 +9 cz 20 21 +9 y_1_2 3 +9 t 4 +9 x_1_2 6 +9 x_1_2 12 +9 t 13 +9 y_1_2 14 +9 x_1_2 15 +9 t 16 +9 y_1_2 19 +9 t 23 +9 t 24 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_9.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_9.txt new file mode 100644 index 0000000..4338e04 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x5_10_9.txt @@ -0,0 +1,185 @@ +25 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +1 cz 0 1 +1 cz 7 8 +1 cz 10 11 +1 cz 17 18 +1 cz 20 21 +1 t 2 +1 t 3 +1 t 4 +1 t 5 +1 t 6 +1 t 9 +1 t 12 +1 t 13 +1 t 14 +1 t 15 +1 t 16 +1 t 19 +1 t 22 +1 t 23 +1 t 24 +2 cz 5 10 +2 cz 16 21 +2 cz 7 12 +2 cz 18 23 +2 cz 9 14 +2 x_1_2 0 +2 x_1_2 1 +2 x_1_2 8 +2 y_1_2 11 +2 x_1_2 17 +2 y_1_2 20 +3 cz 1 2 +3 cz 8 9 +3 cz 11 12 +3 cz 18 19 +3 cz 21 22 +3 t 0 +3 y_1_2 5 +3 x_1_2 7 +3 y_1_2 10 +3 y_1_2 14 +3 x_1_2 16 +3 t 17 +3 t 20 +3 x_1_2 23 +4 cz 0 5 +4 cz 11 16 +4 cz 2 7 +4 cz 13 18 +4 cz 4 9 +4 y_1_2 1 +4 x_1_2 8 +4 t 10 +4 y_1_2 12 +4 t 14 +4 x_1_2 19 +4 x_1_2 21 +4 x_1_2 22 +4 t 23 +5 cz 2 3 +5 cz 5 6 +5 cz 12 13 +5 cz 15 16 +5 cz 22 23 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 y_1_2 7 +5 t 8 +5 y_1_2 9 +5 x_1_2 11 +5 y_1_2 18 +5 t 19 +5 t 21 +6 cz 15 20 +6 cz 6 11 +6 cz 17 22 +6 cz 8 13 +6 cz 19 24 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 y_1_2 5 +6 t 7 +6 t 9 +6 y_1_2 12 +6 x_1_2 16 +6 t 18 +6 x_1_2 23 +7 cz 3 4 +7 cz 6 7 +7 cz 13 14 +7 cz 16 17 +7 cz 23 24 +7 t 2 +7 t 5 +7 x_1_2 8 +7 x_1_2 11 +7 t 12 +7 x_1_2 15 +7 y_1_2 19 +7 x_1_2 20 +7 y_1_2 22 +8 cz 10 15 +8 cz 1 6 +8 cz 12 17 +8 cz 3 8 +8 cz 14 19 +8 y_1_2 4 +8 x_1_2 7 +8 t 11 +8 x_1_2 13 +8 x_1_2 16 +8 t 20 +8 t 22 +8 x_1_2 23 +8 x_1_2 24 +9 cz 0 1 +9 cz 7 8 +9 cz 10 11 +9 cz 17 18 +9 cz 20 21 +9 y_1_2 3 +9 t 4 +9 x_1_2 6 +9 y_1_2 12 +9 t 13 +9 x_1_2 14 +9 y_1_2 15 +9 t 16 +9 y_1_2 19 +9 t 23 +9 t 24 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_0.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_0.txt new file mode 100644 index 0000000..b6d4ff7 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_0.txt @@ -0,0 +1,220 @@ +30 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 y_1_2 9 +2 x_1_2 13 +2 y_1_2 17 +2 x_1_2 20 +2 x_1_2 24 +2 y_1_2 28 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 t 0 +3 t 4 +3 t 5 +3 y_1_2 6 +3 y_1_2 8 +3 x_1_2 12 +3 y_1_2 16 +3 t 17 +3 y_1_2 19 +3 t 20 +3 x_1_2 23 +3 t 24 +3 y_1_2 27 +3 t 28 +3 y_1_2 29 +4 cz 0 6 +4 cz 13 19 +4 cz 2 8 +4 cz 15 21 +4 cz 4 10 +4 cz 17 23 +4 y_1_2 1 +4 y_1_2 9 +4 t 12 +4 x_1_2 14 +4 t 16 +4 y_1_2 22 +4 y_1_2 25 +4 y_1_2 26 +4 t 27 +4 t 29 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 x_1_2 0 +5 t 1 +5 x_1_2 4 +5 x_1_2 8 +5 t 9 +5 y_1_2 13 +5 y_1_2 17 +5 y_1_2 21 +5 t 25 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 x_1_2 6 +6 t 8 +6 y_1_2 10 +6 y_1_2 14 +6 x_1_2 19 +6 t 21 +6 y_1_2 23 +6 x_1_2 27 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 y_1_2 11 +7 x_1_2 13 +7 t 14 +7 x_1_2 17 +7 y_1_2 18 +7 x_1_2 22 +7 t 23 +7 x_1_2 24 +7 y_1_2 26 +8 cz 12 18 +8 cz 1 7 +8 cz 14 20 +8 cz 3 9 +8 cz 16 22 +8 cz 5 11 +8 x_1_2 4 +8 y_1_2 8 +8 t 13 +8 x_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 y_1_2 27 +8 x_1_2 28 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 x_1_2 3 +9 x_1_2 7 +9 y_1_2 11 +9 y_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 y_1_2 22 +9 t 27 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_1.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_1.txt new file mode 100644 index 0000000..68011f2 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_1.txt @@ -0,0 +1,220 @@ +30 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 x_1_2 0 +2 y_1_2 1 +2 y_1_2 4 +2 x_1_2 5 +2 x_1_2 9 +2 x_1_2 13 +2 y_1_2 17 +2 y_1_2 20 +2 x_1_2 24 +2 x_1_2 28 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 t 0 +3 t 4 +3 t 5 +3 y_1_2 6 +3 x_1_2 8 +3 y_1_2 12 +3 x_1_2 16 +3 t 17 +3 x_1_2 19 +3 t 20 +3 y_1_2 23 +3 t 24 +3 x_1_2 27 +3 t 28 +3 y_1_2 29 +4 cz 0 6 +4 cz 13 19 +4 cz 2 8 +4 cz 15 21 +4 cz 4 10 +4 cz 17 23 +4 y_1_2 1 +4 x_1_2 9 +4 t 12 +4 x_1_2 14 +4 t 16 +4 y_1_2 22 +4 y_1_2 25 +4 x_1_2 26 +4 t 27 +4 t 29 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 x_1_2 0 +5 t 1 +5 x_1_2 4 +5 x_1_2 8 +5 t 9 +5 x_1_2 13 +5 x_1_2 17 +5 x_1_2 21 +5 t 25 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 x_1_2 6 +6 t 8 +6 x_1_2 10 +6 x_1_2 14 +6 x_1_2 19 +6 t 21 +6 y_1_2 23 +6 y_1_2 27 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 x_1_2 11 +7 y_1_2 13 +7 t 14 +7 y_1_2 17 +7 x_1_2 18 +7 x_1_2 22 +7 t 23 +7 y_1_2 24 +7 y_1_2 26 +8 cz 12 18 +8 cz 1 7 +8 cz 14 20 +8 cz 3 9 +8 cz 16 22 +8 cz 5 11 +8 y_1_2 4 +8 x_1_2 8 +8 t 13 +8 y_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 x_1_2 27 +8 y_1_2 28 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 y_1_2 3 +9 y_1_2 7 +9 y_1_2 11 +9 y_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 x_1_2 22 +9 t 27 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_2.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_2.txt new file mode 100644 index 0000000..4ff48bd --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_2.txt @@ -0,0 +1,220 @@ +30 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 y_1_2 9 +2 y_1_2 13 +2 y_1_2 17 +2 x_1_2 20 +2 y_1_2 24 +2 y_1_2 28 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 t 0 +3 t 4 +3 t 5 +3 y_1_2 6 +3 x_1_2 8 +3 x_1_2 12 +3 x_1_2 16 +3 t 17 +3 y_1_2 19 +3 t 20 +3 y_1_2 23 +3 t 24 +3 y_1_2 27 +3 t 28 +3 y_1_2 29 +4 cz 0 6 +4 cz 13 19 +4 cz 2 8 +4 cz 15 21 +4 cz 4 10 +4 cz 17 23 +4 x_1_2 1 +4 x_1_2 9 +4 t 12 +4 x_1_2 14 +4 t 16 +4 x_1_2 22 +4 x_1_2 25 +4 x_1_2 26 +4 t 27 +4 t 29 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 y_1_2 8 +5 t 9 +5 y_1_2 13 +5 x_1_2 17 +5 x_1_2 21 +5 t 25 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 y_1_2 6 +6 t 8 +6 y_1_2 10 +6 y_1_2 14 +6 x_1_2 19 +6 t 21 +6 y_1_2 23 +6 y_1_2 27 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 y_1_2 11 +7 y_1_2 13 +7 t 14 +7 y_1_2 17 +7 x_1_2 18 +7 y_1_2 22 +7 t 23 +7 y_1_2 24 +7 x_1_2 26 +8 cz 12 18 +8 cz 1 7 +8 cz 14 20 +8 cz 3 9 +8 cz 16 22 +8 cz 5 11 +8 y_1_2 4 +8 y_1_2 8 +8 t 13 +8 x_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 x_1_2 27 +8 y_1_2 28 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 y_1_2 3 +9 y_1_2 7 +9 x_1_2 11 +9 y_1_2 14 +9 t 15 +9 y_1_2 18 +9 t 19 +9 x_1_2 22 +9 t 27 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_3.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_3.txt new file mode 100644 index 0000000..5f4472a --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_3.txt @@ -0,0 +1,220 @@ +30 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 x_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 y_1_2 5 +2 y_1_2 9 +2 x_1_2 13 +2 x_1_2 17 +2 y_1_2 20 +2 x_1_2 24 +2 x_1_2 28 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 t 0 +3 t 4 +3 t 5 +3 y_1_2 6 +3 x_1_2 8 +3 y_1_2 12 +3 x_1_2 16 +3 t 17 +3 y_1_2 19 +3 t 20 +3 x_1_2 23 +3 t 24 +3 y_1_2 27 +3 t 28 +3 y_1_2 29 +4 cz 0 6 +4 cz 13 19 +4 cz 2 8 +4 cz 15 21 +4 cz 4 10 +4 cz 17 23 +4 y_1_2 1 +4 y_1_2 9 +4 t 12 +4 y_1_2 14 +4 t 16 +4 x_1_2 22 +4 y_1_2 25 +4 y_1_2 26 +4 t 27 +4 t 29 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 x_1_2 0 +5 t 1 +5 x_1_2 4 +5 y_1_2 8 +5 t 9 +5 x_1_2 13 +5 y_1_2 17 +5 y_1_2 21 +5 t 25 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 y_1_2 2 +6 y_1_2 3 +6 t 4 +6 x_1_2 6 +6 t 8 +6 y_1_2 10 +6 x_1_2 14 +6 y_1_2 19 +6 t 21 +6 y_1_2 23 +6 x_1_2 27 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 t 2 +7 t 6 +7 x_1_2 9 +7 t 10 +7 x_1_2 11 +7 y_1_2 13 +7 t 14 +7 x_1_2 17 +7 y_1_2 18 +7 x_1_2 22 +7 t 23 +7 y_1_2 24 +7 x_1_2 26 +8 cz 12 18 +8 cz 1 7 +8 cz 14 20 +8 cz 3 9 +8 cz 16 22 +8 cz 5 11 +8 x_1_2 4 +8 y_1_2 8 +8 t 13 +8 y_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 y_1_2 27 +8 y_1_2 28 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 y_1_2 3 +9 y_1_2 7 +9 y_1_2 11 +9 x_1_2 14 +9 t 15 +9 y_1_2 18 +9 t 19 +9 y_1_2 22 +9 t 27 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_4.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_4.txt new file mode 100644 index 0000000..5d2ec6c --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_4.txt @@ -0,0 +1,220 @@ +30 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 x_1_2 0 +2 x_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 x_1_2 9 +2 x_1_2 13 +2 y_1_2 17 +2 y_1_2 20 +2 y_1_2 24 +2 x_1_2 28 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 t 0 +3 t 4 +3 t 5 +3 y_1_2 6 +3 x_1_2 8 +3 x_1_2 12 +3 x_1_2 16 +3 t 17 +3 x_1_2 19 +3 t 20 +3 y_1_2 23 +3 t 24 +3 y_1_2 27 +3 t 28 +3 y_1_2 29 +4 cz 0 6 +4 cz 13 19 +4 cz 2 8 +4 cz 15 21 +4 cz 4 10 +4 cz 17 23 +4 y_1_2 1 +4 x_1_2 9 +4 t 12 +4 x_1_2 14 +4 t 16 +4 y_1_2 22 +4 y_1_2 25 +4 y_1_2 26 +4 t 27 +4 t 29 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 y_1_2 0 +5 t 1 +5 x_1_2 4 +5 y_1_2 8 +5 t 9 +5 y_1_2 13 +5 y_1_2 17 +5 x_1_2 21 +5 t 25 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 y_1_2 6 +6 t 8 +6 y_1_2 10 +6 y_1_2 14 +6 x_1_2 19 +6 t 21 +6 y_1_2 23 +6 y_1_2 27 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 y_1_2 11 +7 y_1_2 13 +7 t 14 +7 x_1_2 17 +7 y_1_2 18 +7 x_1_2 22 +7 t 23 +7 x_1_2 24 +7 x_1_2 26 +8 cz 12 18 +8 cz 1 7 +8 cz 14 20 +8 cz 3 9 +8 cz 16 22 +8 cz 5 11 +8 y_1_2 4 +8 x_1_2 8 +8 t 13 +8 x_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 x_1_2 27 +8 y_1_2 28 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 x_1_2 3 +9 x_1_2 7 +9 y_1_2 11 +9 x_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 x_1_2 22 +9 t 27 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_5.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_5.txt new file mode 100644 index 0000000..c13dad1 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_5.txt @@ -0,0 +1,220 @@ +30 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 y_1_2 0 +2 y_1_2 1 +2 y_1_2 4 +2 y_1_2 5 +2 y_1_2 9 +2 y_1_2 13 +2 x_1_2 17 +2 x_1_2 20 +2 y_1_2 24 +2 y_1_2 28 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 t 0 +3 t 4 +3 t 5 +3 y_1_2 6 +3 x_1_2 8 +3 x_1_2 12 +3 x_1_2 16 +3 t 17 +3 y_1_2 19 +3 t 20 +3 y_1_2 23 +3 t 24 +3 x_1_2 27 +3 t 28 +3 x_1_2 29 +4 cz 0 6 +4 cz 13 19 +4 cz 2 8 +4 cz 15 21 +4 cz 4 10 +4 cz 17 23 +4 x_1_2 1 +4 y_1_2 9 +4 t 12 +4 y_1_2 14 +4 t 16 +4 x_1_2 22 +4 y_1_2 25 +4 x_1_2 26 +4 t 27 +4 t 29 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 y_1_2 0 +5 t 1 +5 x_1_2 4 +5 x_1_2 8 +5 t 9 +5 y_1_2 13 +5 x_1_2 17 +5 x_1_2 21 +5 t 25 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 y_1_2 2 +6 y_1_2 3 +6 t 4 +6 x_1_2 6 +6 t 8 +6 y_1_2 10 +6 y_1_2 14 +6 y_1_2 19 +6 t 21 +6 x_1_2 23 +6 y_1_2 27 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 y_1_2 11 +7 y_1_2 13 +7 t 14 +7 x_1_2 17 +7 x_1_2 18 +7 x_1_2 22 +7 t 23 +7 x_1_2 24 +7 x_1_2 26 +8 cz 12 18 +8 cz 1 7 +8 cz 14 20 +8 cz 3 9 +8 cz 16 22 +8 cz 5 11 +8 x_1_2 4 +8 y_1_2 8 +8 t 13 +8 x_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 x_1_2 27 +8 x_1_2 28 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 y_1_2 3 +9 x_1_2 7 +9 x_1_2 11 +9 x_1_2 14 +9 t 15 +9 y_1_2 18 +9 t 19 +9 x_1_2 22 +9 t 27 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_6.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_6.txt new file mode 100644 index 0000000..7d09420 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_6.txt @@ -0,0 +1,220 @@ +30 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 x_1_2 9 +2 y_1_2 13 +2 x_1_2 17 +2 y_1_2 20 +2 x_1_2 24 +2 y_1_2 28 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 t 0 +3 t 4 +3 t 5 +3 x_1_2 6 +3 y_1_2 8 +3 y_1_2 12 +3 x_1_2 16 +3 t 17 +3 y_1_2 19 +3 t 20 +3 y_1_2 23 +3 t 24 +3 x_1_2 27 +3 t 28 +3 y_1_2 29 +4 cz 0 6 +4 cz 13 19 +4 cz 2 8 +4 cz 15 21 +4 cz 4 10 +4 cz 17 23 +4 y_1_2 1 +4 x_1_2 9 +4 t 12 +4 y_1_2 14 +4 t 16 +4 y_1_2 22 +4 y_1_2 25 +4 x_1_2 26 +4 t 27 +4 t 29 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 y_1_2 8 +5 t 9 +5 x_1_2 13 +5 x_1_2 17 +5 x_1_2 21 +5 t 25 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 y_1_2 2 +6 x_1_2 3 +6 t 4 +6 y_1_2 6 +6 t 8 +6 y_1_2 10 +6 x_1_2 14 +6 y_1_2 19 +6 t 21 +6 x_1_2 23 +6 y_1_2 27 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 y_1_2 11 +7 y_1_2 13 +7 t 14 +7 y_1_2 17 +7 y_1_2 18 +7 y_1_2 22 +7 t 23 +7 x_1_2 24 +7 x_1_2 26 +8 cz 12 18 +8 cz 1 7 +8 cz 14 20 +8 cz 3 9 +8 cz 16 22 +8 cz 5 11 +8 y_1_2 4 +8 x_1_2 8 +8 t 13 +8 y_1_2 15 +8 t 17 +8 x_1_2 19 +8 t 24 +8 t 26 +8 y_1_2 27 +8 y_1_2 28 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 x_1_2 3 +9 y_1_2 7 +9 x_1_2 11 +9 x_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 x_1_2 22 +9 t 27 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_7.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_7.txt new file mode 100644 index 0000000..6edca73 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_7.txt @@ -0,0 +1,220 @@ +30 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 x_1_2 0 +2 x_1_2 1 +2 y_1_2 4 +2 x_1_2 5 +2 y_1_2 9 +2 x_1_2 13 +2 x_1_2 17 +2 y_1_2 20 +2 x_1_2 24 +2 x_1_2 28 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 t 0 +3 t 4 +3 t 5 +3 x_1_2 6 +3 x_1_2 8 +3 x_1_2 12 +3 y_1_2 16 +3 t 17 +3 x_1_2 19 +3 t 20 +3 x_1_2 23 +3 t 24 +3 y_1_2 27 +3 t 28 +3 y_1_2 29 +4 cz 0 6 +4 cz 13 19 +4 cz 2 8 +4 cz 15 21 +4 cz 4 10 +4 cz 17 23 +4 y_1_2 1 +4 x_1_2 9 +4 t 12 +4 y_1_2 14 +4 t 16 +4 x_1_2 22 +4 y_1_2 25 +4 x_1_2 26 +4 t 27 +4 t 29 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 x_1_2 0 +5 t 1 +5 x_1_2 4 +5 x_1_2 8 +5 t 9 +5 y_1_2 13 +5 x_1_2 17 +5 y_1_2 21 +5 t 25 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 y_1_2 2 +6 x_1_2 3 +6 t 4 +6 y_1_2 6 +6 t 8 +6 x_1_2 10 +6 x_1_2 14 +6 x_1_2 19 +6 t 21 +6 y_1_2 23 +6 x_1_2 27 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 t 2 +7 t 6 +7 x_1_2 9 +7 t 10 +7 y_1_2 11 +7 x_1_2 13 +7 t 14 +7 x_1_2 17 +7 y_1_2 18 +7 y_1_2 22 +7 t 23 +7 x_1_2 24 +7 y_1_2 26 +8 cz 12 18 +8 cz 1 7 +8 cz 14 20 +8 cz 3 9 +8 cz 16 22 +8 cz 5 11 +8 y_1_2 4 +8 y_1_2 8 +8 t 13 +8 y_1_2 15 +8 t 17 +8 x_1_2 19 +8 t 24 +8 t 26 +8 y_1_2 27 +8 x_1_2 28 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 x_1_2 3 +9 y_1_2 7 +9 x_1_2 11 +9 x_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 y_1_2 22 +9 t 27 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_8.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_8.txt new file mode 100644 index 0000000..6df2bcf --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_8.txt @@ -0,0 +1,220 @@ +30 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 x_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 y_1_2 5 +2 x_1_2 9 +2 x_1_2 13 +2 y_1_2 17 +2 x_1_2 20 +2 y_1_2 24 +2 x_1_2 28 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 t 0 +3 t 4 +3 t 5 +3 x_1_2 6 +3 x_1_2 8 +3 x_1_2 12 +3 y_1_2 16 +3 t 17 +3 x_1_2 19 +3 t 20 +3 x_1_2 23 +3 t 24 +3 x_1_2 27 +3 t 28 +3 x_1_2 29 +4 cz 0 6 +4 cz 13 19 +4 cz 2 8 +4 cz 15 21 +4 cz 4 10 +4 cz 17 23 +4 x_1_2 1 +4 y_1_2 9 +4 t 12 +4 x_1_2 14 +4 t 16 +4 x_1_2 22 +4 x_1_2 25 +4 y_1_2 26 +4 t 27 +4 t 29 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 x_1_2 8 +5 t 9 +5 y_1_2 13 +5 x_1_2 17 +5 y_1_2 21 +5 t 25 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 y_1_2 6 +6 t 8 +6 y_1_2 10 +6 x_1_2 14 +6 x_1_2 19 +6 t 21 +6 y_1_2 23 +6 x_1_2 27 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 t 2 +7 t 6 +7 x_1_2 9 +7 t 10 +7 y_1_2 11 +7 y_1_2 13 +7 t 14 +7 y_1_2 17 +7 y_1_2 18 +7 x_1_2 22 +7 t 23 +7 x_1_2 24 +7 y_1_2 26 +8 cz 12 18 +8 cz 1 7 +8 cz 14 20 +8 cz 3 9 +8 cz 16 22 +8 cz 5 11 +8 x_1_2 4 +8 y_1_2 8 +8 t 13 +8 x_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 y_1_2 27 +8 y_1_2 28 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 y_1_2 3 +9 y_1_2 7 +9 x_1_2 11 +9 x_1_2 14 +9 t 15 +9 y_1_2 18 +9 t 19 +9 y_1_2 22 +9 t 27 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_9.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_9.txt new file mode 100644 index 0000000..7ba0d5d --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_5x6_10_9.txt @@ -0,0 +1,220 @@ +30 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 x_1_2 0 +2 x_1_2 1 +2 x_1_2 4 +2 y_1_2 5 +2 x_1_2 9 +2 y_1_2 13 +2 y_1_2 17 +2 x_1_2 20 +2 y_1_2 24 +2 y_1_2 28 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 t 0 +3 t 4 +3 t 5 +3 x_1_2 6 +3 x_1_2 8 +3 y_1_2 12 +3 x_1_2 16 +3 t 17 +3 y_1_2 19 +3 t 20 +3 x_1_2 23 +3 t 24 +3 x_1_2 27 +3 t 28 +3 x_1_2 29 +4 cz 0 6 +4 cz 13 19 +4 cz 2 8 +4 cz 15 21 +4 cz 4 10 +4 cz 17 23 +4 y_1_2 1 +4 y_1_2 9 +4 t 12 +4 y_1_2 14 +4 t 16 +4 y_1_2 22 +4 x_1_2 25 +4 y_1_2 26 +4 t 27 +4 t 29 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 x_1_2 0 +5 t 1 +5 x_1_2 4 +5 y_1_2 8 +5 t 9 +5 y_1_2 13 +5 x_1_2 17 +5 x_1_2 21 +5 t 25 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 x_1_2 6 +6 t 8 +6 y_1_2 10 +6 x_1_2 14 +6 y_1_2 19 +6 t 21 +6 y_1_2 23 +6 x_1_2 27 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 t 2 +7 t 6 +7 x_1_2 9 +7 t 10 +7 x_1_2 11 +7 x_1_2 13 +7 t 14 +7 x_1_2 17 +7 y_1_2 18 +7 x_1_2 22 +7 t 23 +7 y_1_2 24 +7 x_1_2 26 +8 cz 12 18 +8 cz 1 7 +8 cz 14 20 +8 cz 3 9 +8 cz 16 22 +8 cz 5 11 +8 y_1_2 4 +8 y_1_2 8 +8 t 13 +8 x_1_2 15 +8 t 17 +8 x_1_2 19 +8 t 24 +8 t 26 +8 x_1_2 27 +8 y_1_2 28 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 x_1_2 3 +9 x_1_2 7 +9 x_1_2 11 +9 y_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 x_1_2 22 +9 t 27 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_0.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_0.txt new file mode 100644 index 0000000..8b3f6ed --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_0.txt @@ -0,0 +1,265 @@ +36 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 cz 32 33 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 y_1_2 9 +2 x_1_2 13 +2 y_1_2 17 +2 x_1_2 20 +2 x_1_2 24 +2 y_1_2 28 +2 y_1_2 32 +2 y_1_2 33 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 cz 33 34 +3 t 0 +3 t 4 +3 t 5 +3 x_1_2 6 +3 y_1_2 8 +3 y_1_2 12 +3 x_1_2 16 +3 t 17 +3 y_1_2 19 +3 t 20 +3 y_1_2 23 +3 t 24 +3 y_1_2 27 +3 t 28 +3 y_1_2 29 +3 t 32 +4 cz 0 6 +4 cz 24 30 +4 cz 13 19 +4 cz 2 8 +4 cz 26 32 +4 cz 15 21 +4 cz 4 10 +4 cz 28 34 +4 cz 17 23 +4 x_1_2 1 +4 y_1_2 9 +4 t 12 +4 y_1_2 14 +4 t 16 +4 y_1_2 22 +4 x_1_2 25 +4 t 27 +4 t 29 +4 x_1_2 33 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 cz 30 31 +5 cz 34 35 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 y_1_2 8 +5 t 9 +5 y_1_2 13 +5 x_1_2 17 +5 y_1_2 21 +5 x_1_2 24 +5 t 25 +5 y_1_2 28 +5 y_1_2 32 +5 t 33 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 x_1_2 6 +6 t 8 +6 y_1_2 10 +6 y_1_2 14 +6 x_1_2 19 +6 t 21 +6 x_1_2 23 +6 y_1_2 27 +6 x_1_2 30 +6 x_1_2 31 +6 t 32 +6 y_1_2 34 +6 x_1_2 35 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 cz 31 32 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 x_1_2 11 +7 y_1_2 13 +7 t 14 +7 y_1_2 17 +7 x_1_2 18 +7 x_1_2 22 +7 t 23 +7 x_1_2 24 +7 y_1_2 26 +7 t 30 +7 t 34 +7 t 35 +8 cz 12 18 +8 cz 1 7 +8 cz 25 31 +8 cz 14 20 +8 cz 3 9 +8 cz 27 33 +8 cz 16 22 +8 cz 5 11 +8 cz 29 35 +8 y_1_2 4 +8 x_1_2 8 +8 t 13 +8 y_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 y_1_2 28 +8 y_1_2 32 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 cz 32 33 +9 y_1_2 3 +9 y_1_2 7 +9 y_1_2 11 +9 y_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 y_1_2 22 +9 x_1_2 27 +9 y_1_2 31 +9 x_1_2 35 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_1.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_1.txt new file mode 100644 index 0000000..81267ac --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_1.txt @@ -0,0 +1,265 @@ +36 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 cz 32 33 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 x_1_2 0 +2 y_1_2 1 +2 y_1_2 4 +2 x_1_2 5 +2 x_1_2 9 +2 x_1_2 13 +2 y_1_2 17 +2 y_1_2 20 +2 x_1_2 24 +2 x_1_2 28 +2 y_1_2 32 +2 x_1_2 33 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 cz 33 34 +3 t 0 +3 t 4 +3 t 5 +3 y_1_2 6 +3 x_1_2 8 +3 x_1_2 12 +3 y_1_2 16 +3 t 17 +3 x_1_2 19 +3 t 20 +3 y_1_2 23 +3 t 24 +3 y_1_2 27 +3 t 28 +3 x_1_2 29 +3 t 32 +4 cz 0 6 +4 cz 24 30 +4 cz 13 19 +4 cz 2 8 +4 cz 26 32 +4 cz 15 21 +4 cz 4 10 +4 cz 28 34 +4 cz 17 23 +4 x_1_2 1 +4 y_1_2 9 +4 t 12 +4 y_1_2 14 +4 t 16 +4 x_1_2 22 +4 x_1_2 25 +4 t 27 +4 t 29 +4 x_1_2 33 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 cz 30 31 +5 cz 34 35 +5 x_1_2 0 +5 t 1 +5 x_1_2 4 +5 x_1_2 8 +5 t 9 +5 x_1_2 13 +5 x_1_2 17 +5 x_1_2 21 +5 x_1_2 24 +5 t 25 +5 x_1_2 28 +5 x_1_2 32 +5 t 33 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 y_1_2 6 +6 t 8 +6 y_1_2 10 +6 x_1_2 14 +6 y_1_2 19 +6 t 21 +6 y_1_2 23 +6 x_1_2 27 +6 x_1_2 30 +6 y_1_2 31 +6 t 32 +6 y_1_2 34 +6 y_1_2 35 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 cz 31 32 +7 t 2 +7 t 6 +7 x_1_2 9 +7 t 10 +7 y_1_2 11 +7 y_1_2 13 +7 t 14 +7 x_1_2 17 +7 y_1_2 18 +7 y_1_2 22 +7 t 23 +7 y_1_2 24 +7 y_1_2 26 +7 t 30 +7 t 34 +7 t 35 +8 cz 12 18 +8 cz 1 7 +8 cz 25 31 +8 cz 14 20 +8 cz 3 9 +8 cz 27 33 +8 cz 16 22 +8 cz 5 11 +8 cz 29 35 +8 y_1_2 4 +8 x_1_2 8 +8 t 13 +8 x_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 x_1_2 28 +8 x_1_2 32 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 cz 32 33 +9 y_1_2 3 +9 y_1_2 7 +9 y_1_2 11 +9 x_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 y_1_2 22 +9 y_1_2 27 +9 y_1_2 31 +9 x_1_2 35 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_2.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_2.txt new file mode 100644 index 0000000..558df4d --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_2.txt @@ -0,0 +1,265 @@ +36 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 cz 32 33 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 y_1_2 9 +2 y_1_2 13 +2 y_1_2 17 +2 x_1_2 20 +2 y_1_2 24 +2 y_1_2 28 +2 y_1_2 32 +2 x_1_2 33 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 cz 33 34 +3 t 0 +3 t 4 +3 t 5 +3 x_1_2 6 +3 x_1_2 8 +3 y_1_2 12 +3 y_1_2 16 +3 t 17 +3 y_1_2 19 +3 t 20 +3 y_1_2 23 +3 t 24 +3 x_1_2 27 +3 t 28 +3 x_1_2 29 +3 t 32 +4 cz 0 6 +4 cz 24 30 +4 cz 13 19 +4 cz 2 8 +4 cz 26 32 +4 cz 15 21 +4 cz 4 10 +4 cz 28 34 +4 cz 17 23 +4 x_1_2 1 +4 x_1_2 9 +4 t 12 +4 x_1_2 14 +4 t 16 +4 x_1_2 22 +4 x_1_2 25 +4 t 27 +4 t 29 +4 y_1_2 33 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 cz 30 31 +5 cz 34 35 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 x_1_2 8 +5 t 9 +5 x_1_2 13 +5 x_1_2 17 +5 x_1_2 21 +5 y_1_2 24 +5 t 25 +5 y_1_2 28 +5 y_1_2 32 +5 t 33 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 y_1_2 6 +6 t 8 +6 y_1_2 10 +6 y_1_2 14 +6 y_1_2 19 +6 t 21 +6 y_1_2 23 +6 x_1_2 27 +6 y_1_2 30 +6 y_1_2 31 +6 t 32 +6 x_1_2 34 +6 y_1_2 35 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 cz 31 32 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 x_1_2 11 +7 y_1_2 13 +7 t 14 +7 x_1_2 17 +7 y_1_2 18 +7 y_1_2 22 +7 t 23 +7 y_1_2 24 +7 x_1_2 26 +7 t 30 +7 t 34 +7 t 35 +8 cz 12 18 +8 cz 1 7 +8 cz 25 31 +8 cz 14 20 +8 cz 3 9 +8 cz 27 33 +8 cz 16 22 +8 cz 5 11 +8 cz 29 35 +8 y_1_2 4 +8 y_1_2 8 +8 t 13 +8 x_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 y_1_2 28 +8 y_1_2 32 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 cz 32 33 +9 x_1_2 3 +9 x_1_2 7 +9 x_1_2 11 +9 y_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 y_1_2 22 +9 x_1_2 27 +9 y_1_2 31 +9 x_1_2 35 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_3.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_3.txt new file mode 100644 index 0000000..f87bdad --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_3.txt @@ -0,0 +1,265 @@ +36 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 cz 32 33 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 x_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 y_1_2 5 +2 y_1_2 9 +2 x_1_2 13 +2 x_1_2 17 +2 y_1_2 20 +2 x_1_2 24 +2 x_1_2 28 +2 y_1_2 32 +2 x_1_2 33 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 cz 33 34 +3 t 0 +3 t 4 +3 t 5 +3 y_1_2 6 +3 x_1_2 8 +3 y_1_2 12 +3 x_1_2 16 +3 t 17 +3 y_1_2 19 +3 t 20 +3 y_1_2 23 +3 t 24 +3 y_1_2 27 +3 t 28 +3 y_1_2 29 +3 t 32 +4 cz 0 6 +4 cz 24 30 +4 cz 13 19 +4 cz 2 8 +4 cz 26 32 +4 cz 15 21 +4 cz 4 10 +4 cz 28 34 +4 cz 17 23 +4 y_1_2 1 +4 x_1_2 9 +4 t 12 +4 y_1_2 14 +4 t 16 +4 y_1_2 22 +4 x_1_2 25 +4 t 27 +4 t 29 +4 x_1_2 33 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 cz 30 31 +5 cz 34 35 +5 y_1_2 0 +5 t 1 +5 x_1_2 4 +5 y_1_2 8 +5 t 9 +5 y_1_2 13 +5 y_1_2 17 +5 y_1_2 21 +5 x_1_2 24 +5 t 25 +5 y_1_2 28 +5 x_1_2 32 +5 t 33 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 y_1_2 2 +6 y_1_2 3 +6 t 4 +6 x_1_2 6 +6 t 8 +6 x_1_2 10 +6 x_1_2 14 +6 y_1_2 19 +6 t 21 +6 x_1_2 23 +6 y_1_2 27 +6 x_1_2 30 +6 y_1_2 31 +6 t 32 +6 x_1_2 34 +6 x_1_2 35 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 cz 31 32 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 y_1_2 11 +7 y_1_2 13 +7 t 14 +7 y_1_2 17 +7 y_1_2 18 +7 y_1_2 22 +7 t 23 +7 y_1_2 24 +7 y_1_2 26 +7 t 30 +7 t 34 +7 t 35 +8 cz 12 18 +8 cz 1 7 +8 cz 25 31 +8 cz 14 20 +8 cz 3 9 +8 cz 27 33 +8 cz 16 22 +8 cz 5 11 +8 cz 29 35 +8 x_1_2 4 +8 y_1_2 8 +8 t 13 +8 y_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 y_1_2 28 +8 y_1_2 32 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 cz 32 33 +9 x_1_2 3 +9 y_1_2 7 +9 y_1_2 11 +9 x_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 y_1_2 22 +9 y_1_2 27 +9 x_1_2 31 +9 y_1_2 35 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_4.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_4.txt new file mode 100644 index 0000000..fde28b0 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_4.txt @@ -0,0 +1,265 @@ +36 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 cz 32 33 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 x_1_2 0 +2 x_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 x_1_2 9 +2 x_1_2 13 +2 y_1_2 17 +2 y_1_2 20 +2 y_1_2 24 +2 x_1_2 28 +2 y_1_2 32 +2 x_1_2 33 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 cz 33 34 +3 t 0 +3 t 4 +3 t 5 +3 x_1_2 6 +3 x_1_2 8 +3 x_1_2 12 +3 y_1_2 16 +3 t 17 +3 y_1_2 19 +3 t 20 +3 y_1_2 23 +3 t 24 +3 y_1_2 27 +3 t 28 +3 x_1_2 29 +3 t 32 +4 cz 0 6 +4 cz 24 30 +4 cz 13 19 +4 cz 2 8 +4 cz 26 32 +4 cz 15 21 +4 cz 4 10 +4 cz 28 34 +4 cz 17 23 +4 x_1_2 1 +4 y_1_2 9 +4 t 12 +4 y_1_2 14 +4 t 16 +4 y_1_2 22 +4 y_1_2 25 +4 t 27 +4 t 29 +4 x_1_2 33 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 cz 30 31 +5 cz 34 35 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 y_1_2 8 +5 t 9 +5 x_1_2 13 +5 x_1_2 17 +5 x_1_2 21 +5 y_1_2 24 +5 t 25 +5 y_1_2 28 +5 y_1_2 32 +5 t 33 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 y_1_2 6 +6 t 8 +6 y_1_2 10 +6 y_1_2 14 +6 y_1_2 19 +6 t 21 +6 x_1_2 23 +6 y_1_2 27 +6 x_1_2 30 +6 x_1_2 31 +6 t 32 +6 x_1_2 34 +6 y_1_2 35 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 cz 31 32 +7 t 2 +7 t 6 +7 x_1_2 9 +7 t 10 +7 x_1_2 11 +7 y_1_2 13 +7 t 14 +7 x_1_2 17 +7 y_1_2 18 +7 x_1_2 22 +7 t 23 +7 x_1_2 24 +7 y_1_2 26 +7 t 30 +7 t 34 +7 t 35 +8 cz 12 18 +8 cz 1 7 +8 cz 25 31 +8 cz 14 20 +8 cz 3 9 +8 cz 27 33 +8 cz 16 22 +8 cz 5 11 +8 cz 29 35 +8 x_1_2 4 +8 x_1_2 8 +8 t 13 +8 x_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 x_1_2 28 +8 x_1_2 32 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 cz 32 33 +9 y_1_2 3 +9 x_1_2 7 +9 y_1_2 11 +9 y_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 x_1_2 22 +9 x_1_2 27 +9 y_1_2 31 +9 y_1_2 35 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_5.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_5.txt new file mode 100644 index 0000000..4b8048f --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_5.txt @@ -0,0 +1,265 @@ +36 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 cz 32 33 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 y_1_2 0 +2 y_1_2 1 +2 y_1_2 4 +2 y_1_2 5 +2 y_1_2 9 +2 y_1_2 13 +2 x_1_2 17 +2 x_1_2 20 +2 y_1_2 24 +2 y_1_2 28 +2 y_1_2 32 +2 x_1_2 33 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 cz 33 34 +3 t 0 +3 t 4 +3 t 5 +3 x_1_2 6 +3 x_1_2 8 +3 y_1_2 12 +3 y_1_2 16 +3 t 17 +3 x_1_2 19 +3 t 20 +3 x_1_2 23 +3 t 24 +3 x_1_2 27 +3 t 28 +3 y_1_2 29 +3 t 32 +4 cz 0 6 +4 cz 24 30 +4 cz 13 19 +4 cz 2 8 +4 cz 26 32 +4 cz 15 21 +4 cz 4 10 +4 cz 28 34 +4 cz 17 23 +4 y_1_2 1 +4 x_1_2 9 +4 t 12 +4 y_1_2 14 +4 t 16 +4 x_1_2 22 +4 y_1_2 25 +4 t 27 +4 t 29 +4 x_1_2 33 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 cz 30 31 +5 cz 34 35 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 x_1_2 8 +5 t 9 +5 x_1_2 13 +5 y_1_2 17 +5 y_1_2 21 +5 x_1_2 24 +5 t 25 +5 y_1_2 28 +5 y_1_2 32 +5 t 33 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 y_1_2 2 +6 x_1_2 3 +6 t 4 +6 y_1_2 6 +6 t 8 +6 y_1_2 10 +6 y_1_2 14 +6 y_1_2 19 +6 t 21 +6 x_1_2 23 +6 x_1_2 27 +6 x_1_2 30 +6 x_1_2 31 +6 t 32 +6 x_1_2 34 +6 x_1_2 35 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 cz 31 32 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 x_1_2 11 +7 y_1_2 13 +7 t 14 +7 x_1_2 17 +7 x_1_2 18 +7 y_1_2 22 +7 t 23 +7 x_1_2 24 +7 x_1_2 26 +7 t 30 +7 t 34 +7 t 35 +8 cz 12 18 +8 cz 1 7 +8 cz 25 31 +8 cz 14 20 +8 cz 3 9 +8 cz 27 33 +8 cz 16 22 +8 cz 5 11 +8 cz 29 35 +8 x_1_2 4 +8 y_1_2 8 +8 t 13 +8 x_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 x_1_2 28 +8 y_1_2 32 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 cz 32 33 +9 y_1_2 3 +9 x_1_2 7 +9 y_1_2 11 +9 x_1_2 14 +9 t 15 +9 y_1_2 18 +9 t 19 +9 x_1_2 22 +9 x_1_2 27 +9 x_1_2 31 +9 y_1_2 35 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_6.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_6.txt new file mode 100644 index 0000000..6deb842 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_6.txt @@ -0,0 +1,265 @@ +36 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 cz 32 33 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 x_1_2 9 +2 y_1_2 13 +2 x_1_2 17 +2 y_1_2 20 +2 x_1_2 24 +2 y_1_2 28 +2 x_1_2 32 +2 y_1_2 33 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 cz 33 34 +3 t 0 +3 t 4 +3 t 5 +3 y_1_2 6 +3 x_1_2 8 +3 y_1_2 12 +3 y_1_2 16 +3 t 17 +3 x_1_2 19 +3 t 20 +3 y_1_2 23 +3 t 24 +3 y_1_2 27 +3 t 28 +3 x_1_2 29 +3 t 32 +4 cz 0 6 +4 cz 24 30 +4 cz 13 19 +4 cz 2 8 +4 cz 26 32 +4 cz 15 21 +4 cz 4 10 +4 cz 28 34 +4 cz 17 23 +4 y_1_2 1 +4 y_1_2 9 +4 t 12 +4 y_1_2 14 +4 t 16 +4 x_1_2 22 +4 x_1_2 25 +4 t 27 +4 t 29 +4 y_1_2 33 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 cz 30 31 +5 cz 34 35 +5 y_1_2 0 +5 t 1 +5 x_1_2 4 +5 x_1_2 8 +5 t 9 +5 x_1_2 13 +5 y_1_2 17 +5 x_1_2 21 +5 y_1_2 24 +5 t 25 +5 y_1_2 28 +5 x_1_2 32 +5 t 33 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 y_1_2 2 +6 x_1_2 3 +6 t 4 +6 y_1_2 6 +6 t 8 +6 y_1_2 10 +6 y_1_2 14 +6 y_1_2 19 +6 t 21 +6 y_1_2 23 +6 y_1_2 27 +6 y_1_2 30 +6 x_1_2 31 +6 t 32 +6 x_1_2 34 +6 y_1_2 35 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 cz 31 32 +7 t 2 +7 t 6 +7 x_1_2 9 +7 t 10 +7 y_1_2 11 +7 x_1_2 13 +7 t 14 +7 y_1_2 17 +7 y_1_2 18 +7 x_1_2 22 +7 t 23 +7 y_1_2 24 +7 x_1_2 26 +7 t 30 +7 t 34 +7 t 35 +8 cz 12 18 +8 cz 1 7 +8 cz 25 31 +8 cz 14 20 +8 cz 3 9 +8 cz 27 33 +8 cz 16 22 +8 cz 5 11 +8 cz 29 35 +8 x_1_2 4 +8 x_1_2 8 +8 t 13 +8 x_1_2 15 +8 t 17 +8 x_1_2 19 +8 t 24 +8 t 26 +8 y_1_2 28 +8 y_1_2 32 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 cz 32 33 +9 x_1_2 3 +9 y_1_2 7 +9 x_1_2 11 +9 x_1_2 14 +9 t 15 +9 y_1_2 18 +9 t 19 +9 y_1_2 22 +9 x_1_2 27 +9 x_1_2 31 +9 x_1_2 35 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_7.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_7.txt new file mode 100644 index 0000000..cb435e8 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_7.txt @@ -0,0 +1,265 @@ +36 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 cz 32 33 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 x_1_2 0 +2 x_1_2 1 +2 y_1_2 4 +2 x_1_2 5 +2 y_1_2 9 +2 x_1_2 13 +2 x_1_2 17 +2 y_1_2 20 +2 x_1_2 24 +2 x_1_2 28 +2 x_1_2 32 +2 x_1_2 33 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 cz 33 34 +3 t 0 +3 t 4 +3 t 5 +3 x_1_2 6 +3 y_1_2 8 +3 x_1_2 12 +3 x_1_2 16 +3 t 17 +3 y_1_2 19 +3 t 20 +3 y_1_2 23 +3 t 24 +3 y_1_2 27 +3 t 28 +3 x_1_2 29 +3 t 32 +4 cz 0 6 +4 cz 24 30 +4 cz 13 19 +4 cz 2 8 +4 cz 26 32 +4 cz 15 21 +4 cz 4 10 +4 cz 28 34 +4 cz 17 23 +4 y_1_2 1 +4 x_1_2 9 +4 t 12 +4 y_1_2 14 +4 t 16 +4 x_1_2 22 +4 x_1_2 25 +4 t 27 +4 t 29 +4 x_1_2 33 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 cz 30 31 +5 cz 34 35 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 x_1_2 8 +5 t 9 +5 y_1_2 13 +5 y_1_2 17 +5 x_1_2 21 +5 y_1_2 24 +5 t 25 +5 x_1_2 28 +5 x_1_2 32 +5 t 33 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 x_1_2 6 +6 t 8 +6 x_1_2 10 +6 y_1_2 14 +6 x_1_2 19 +6 t 21 +6 x_1_2 23 +6 y_1_2 27 +6 y_1_2 30 +6 x_1_2 31 +6 t 32 +6 y_1_2 34 +6 y_1_2 35 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 cz 31 32 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 y_1_2 11 +7 x_1_2 13 +7 t 14 +7 y_1_2 17 +7 x_1_2 18 +7 x_1_2 22 +7 t 23 +7 y_1_2 24 +7 x_1_2 26 +7 t 30 +7 t 34 +7 t 35 +8 cz 12 18 +8 cz 1 7 +8 cz 25 31 +8 cz 14 20 +8 cz 3 9 +8 cz 27 33 +8 cz 16 22 +8 cz 5 11 +8 cz 29 35 +8 x_1_2 4 +8 x_1_2 8 +8 t 13 +8 y_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 y_1_2 28 +8 y_1_2 32 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 cz 32 33 +9 x_1_2 3 +9 y_1_2 7 +9 y_1_2 11 +9 y_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 y_1_2 22 +9 y_1_2 27 +9 x_1_2 31 +9 y_1_2 35 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_8.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_8.txt new file mode 100644 index 0000000..8abe775 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_8.txt @@ -0,0 +1,265 @@ +36 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 cz 32 33 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 x_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 y_1_2 5 +2 x_1_2 9 +2 x_1_2 13 +2 y_1_2 17 +2 x_1_2 20 +2 y_1_2 24 +2 x_1_2 28 +2 x_1_2 32 +2 x_1_2 33 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 cz 33 34 +3 t 0 +3 t 4 +3 t 5 +3 x_1_2 6 +3 y_1_2 8 +3 x_1_2 12 +3 x_1_2 16 +3 t 17 +3 x_1_2 19 +3 t 20 +3 x_1_2 23 +3 t 24 +3 x_1_2 27 +3 t 28 +3 y_1_2 29 +3 t 32 +4 cz 0 6 +4 cz 24 30 +4 cz 13 19 +4 cz 2 8 +4 cz 26 32 +4 cz 15 21 +4 cz 4 10 +4 cz 28 34 +4 cz 17 23 +4 x_1_2 1 +4 x_1_2 9 +4 t 12 +4 x_1_2 14 +4 t 16 +4 y_1_2 22 +4 x_1_2 25 +4 t 27 +4 t 29 +4 y_1_2 33 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 cz 30 31 +5 cz 34 35 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 x_1_2 8 +5 t 9 +5 y_1_2 13 +5 x_1_2 17 +5 y_1_2 21 +5 y_1_2 24 +5 t 25 +5 y_1_2 28 +5 x_1_2 32 +5 t 33 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 x_1_2 6 +6 t 8 +6 x_1_2 10 +6 y_1_2 14 +6 y_1_2 19 +6 t 21 +6 y_1_2 23 +6 y_1_2 27 +6 x_1_2 30 +6 x_1_2 31 +6 t 32 +6 y_1_2 34 +6 x_1_2 35 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 cz 31 32 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 x_1_2 11 +7 y_1_2 13 +7 t 14 +7 y_1_2 17 +7 y_1_2 18 +7 y_1_2 22 +7 t 23 +7 y_1_2 24 +7 x_1_2 26 +7 t 30 +7 t 34 +7 t 35 +8 cz 12 18 +8 cz 1 7 +8 cz 25 31 +8 cz 14 20 +8 cz 3 9 +8 cz 27 33 +8 cz 16 22 +8 cz 5 11 +8 cz 29 35 +8 x_1_2 4 +8 y_1_2 8 +8 t 13 +8 y_1_2 15 +8 t 17 +8 x_1_2 19 +8 t 24 +8 t 26 +8 y_1_2 28 +8 y_1_2 32 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 cz 32 33 +9 y_1_2 3 +9 x_1_2 7 +9 x_1_2 11 +9 x_1_2 14 +9 t 15 +9 x_1_2 18 +9 t 19 +9 x_1_2 22 +9 x_1_2 27 +9 x_1_2 31 +9 y_1_2 35 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_9.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_9.txt new file mode 100644 index 0000000..e890abb --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x6_10_9.txt @@ -0,0 +1,265 @@ +36 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +1 cz 0 1 +1 cz 4 5 +1 cz 8 9 +1 cz 12 13 +1 cz 16 17 +1 cz 20 21 +1 cz 24 25 +1 cz 28 29 +1 cz 32 33 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 10 +1 t 11 +1 t 14 +1 t 15 +1 t 18 +1 t 19 +1 t 22 +1 t 23 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +2 cz 6 12 +2 cz 19 25 +2 cz 8 14 +2 cz 21 27 +2 cz 10 16 +2 cz 23 29 +2 x_1_2 0 +2 x_1_2 1 +2 x_1_2 4 +2 y_1_2 5 +2 x_1_2 9 +2 y_1_2 13 +2 y_1_2 17 +2 x_1_2 20 +2 y_1_2 24 +2 y_1_2 28 +2 x_1_2 32 +2 x_1_2 33 +3 cz 1 2 +3 cz 9 10 +3 cz 13 14 +3 cz 21 22 +3 cz 25 26 +3 cz 33 34 +3 t 0 +3 t 4 +3 t 5 +3 y_1_2 6 +3 x_1_2 8 +3 y_1_2 12 +3 x_1_2 16 +3 t 17 +3 x_1_2 19 +3 t 20 +3 x_1_2 23 +3 t 24 +3 y_1_2 27 +3 t 28 +3 y_1_2 29 +3 t 32 +4 cz 0 6 +4 cz 24 30 +4 cz 13 19 +4 cz 2 8 +4 cz 26 32 +4 cz 15 21 +4 cz 4 10 +4 cz 28 34 +4 cz 17 23 +4 y_1_2 1 +4 y_1_2 9 +4 t 12 +4 x_1_2 14 +4 t 16 +4 y_1_2 22 +4 x_1_2 25 +4 t 27 +4 t 29 +4 x_1_2 33 +5 cz 2 3 +5 cz 6 7 +5 cz 10 11 +5 cz 14 15 +5 cz 18 19 +5 cz 22 23 +5 cz 26 27 +5 cz 30 31 +5 cz 34 35 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 x_1_2 8 +5 t 9 +5 x_1_2 13 +5 x_1_2 17 +5 x_1_2 21 +5 x_1_2 24 +5 t 25 +5 y_1_2 28 +5 x_1_2 32 +5 t 33 +6 cz 18 24 +6 cz 7 13 +6 cz 20 26 +6 cz 9 15 +6 cz 22 28 +6 cz 11 17 +6 t 0 +6 y_1_2 2 +6 y_1_2 3 +6 t 4 +6 x_1_2 6 +6 t 8 +6 x_1_2 10 +6 x_1_2 14 +6 x_1_2 19 +6 t 21 +6 x_1_2 23 +6 y_1_2 27 +6 x_1_2 30 +6 y_1_2 31 +6 t 32 +6 x_1_2 34 +6 y_1_2 35 +7 cz 3 4 +7 cz 7 8 +7 cz 15 16 +7 cz 19 20 +7 cz 27 28 +7 cz 31 32 +7 t 2 +7 t 6 +7 y_1_2 9 +7 t 10 +7 x_1_2 11 +7 x_1_2 13 +7 t 14 +7 x_1_2 17 +7 y_1_2 18 +7 x_1_2 22 +7 t 23 +7 x_1_2 24 +7 x_1_2 26 +7 t 30 +7 t 34 +7 t 35 +8 cz 12 18 +8 cz 1 7 +8 cz 25 31 +8 cz 14 20 +8 cz 3 9 +8 cz 27 33 +8 cz 16 22 +8 cz 5 11 +8 cz 29 35 +8 y_1_2 4 +8 x_1_2 8 +8 t 13 +8 x_1_2 15 +8 t 17 +8 y_1_2 19 +8 t 24 +8 t 26 +8 x_1_2 28 +8 y_1_2 32 +9 cz 0 1 +9 cz 4 5 +9 cz 8 9 +9 cz 12 13 +9 cz 16 17 +9 cz 20 21 +9 cz 24 25 +9 cz 28 29 +9 cz 32 33 +9 x_1_2 3 +9 y_1_2 7 +9 y_1_2 11 +9 x_1_2 14 +9 t 15 +9 y_1_2 18 +9 t 19 +9 y_1_2 22 +9 x_1_2 27 +9 x_1_2 31 +9 y_1_2 35 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_0.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_0.txt new file mode 100644 index 0000000..0aa2b96 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_0.txt @@ -0,0 +1,311 @@ +42 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +2 cz 7 14 +2 cz 22 29 +2 cz 9 16 +2 cz 24 31 +2 cz 11 18 +2 cz 26 33 +2 cz 13 20 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 y_1_2 10 +2 x_1_2 15 +2 y_1_2 19 +2 x_1_2 23 +2 x_1_2 28 +2 y_1_2 32 +2 y_1_2 37 +2 y_1_2 38 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 t 0 +3 t 4 +3 x_1_2 7 +3 y_1_2 9 +3 y_1_2 13 +3 x_1_2 14 +3 y_1_2 18 +3 y_1_2 22 +3 t 23 +3 y_1_2 26 +3 t 28 +3 y_1_2 31 +3 t 32 +3 t 37 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 x_1_2 1 +4 y_1_2 5 +4 y_1_2 10 +4 t 14 +4 y_1_2 16 +4 t 18 +4 x_1_2 20 +4 x_1_2 25 +4 x_1_2 29 +4 t 31 +4 y_1_2 33 +4 y_1_2 38 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 y_1_2 0 +5 t 1 +5 x_1_2 4 +5 t 5 +5 y_1_2 6 +5 x_1_2 9 +5 t 10 +5 y_1_2 13 +5 y_1_2 15 +5 x_1_2 19 +5 t 20 +5 y_1_2 24 +5 x_1_2 28 +5 t 29 +5 y_1_2 32 +5 t 33 +5 y_1_2 34 +5 x_1_2 37 +5 t 38 +5 x_1_2 41 +6 cz 21 28 +6 cz 8 15 +6 cz 23 30 +6 cz 10 17 +6 cz 25 32 +6 cz 12 19 +6 cz 27 34 +6 t 0 +6 y_1_2 2 +6 x_1_2 3 +6 t 4 +6 t 6 +6 x_1_2 7 +6 t 9 +6 y_1_2 11 +6 t 13 +6 x_1_2 16 +6 y_1_2 22 +6 t 24 +6 x_1_2 26 +6 y_1_2 31 +6 y_1_2 35 +6 x_1_2 36 +6 t 37 +6 x_1_2 39 +6 x_1_2 40 +6 t 41 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 t 2 +7 t 7 +7 y_1_2 10 +7 t 11 +7 y_1_2 15 +7 t 16 +7 x_1_2 19 +7 y_1_2 21 +7 y_1_2 25 +7 y_1_2 28 +7 y_1_2 30 +7 y_1_2 34 +7 t 35 +7 t 39 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 y_1_2 4 +8 y_1_2 9 +8 y_1_2 13 +8 t 15 +8 x_1_2 17 +8 t 19 +8 y_1_2 22 +8 x_1_2 26 +8 t 28 +8 t 30 +8 y_1_2 32 +8 t 34 +8 x_1_2 37 +8 x_1_2 41 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 x_1_2 3 +9 y_1_2 8 +9 y_1_2 12 +9 t 13 +9 x_1_2 16 +9 t 17 +9 x_1_2 20 +9 y_1_2 21 +9 t 22 +9 y_1_2 25 +9 t 26 +9 y_1_2 27 +9 y_1_2 31 +9 y_1_2 36 +9 y_1_2 40 +9 t 41 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_1.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_1.txt new file mode 100644 index 0000000..1eb19aa --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_1.txt @@ -0,0 +1,311 @@ +42 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +2 cz 7 14 +2 cz 22 29 +2 cz 9 16 +2 cz 24 31 +2 cz 11 18 +2 cz 26 33 +2 cz 13 20 +2 x_1_2 0 +2 y_1_2 1 +2 y_1_2 4 +2 x_1_2 5 +2 x_1_2 10 +2 x_1_2 15 +2 y_1_2 19 +2 y_1_2 23 +2 x_1_2 28 +2 x_1_2 32 +2 y_1_2 37 +2 x_1_2 38 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 t 0 +3 t 4 +3 y_1_2 7 +3 x_1_2 9 +3 x_1_2 13 +3 y_1_2 14 +3 x_1_2 18 +3 y_1_2 22 +3 t 23 +3 y_1_2 26 +3 t 28 +3 x_1_2 31 +3 t 32 +3 t 37 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 x_1_2 1 +4 y_1_2 5 +4 y_1_2 10 +4 t 14 +4 x_1_2 16 +4 t 18 +4 x_1_2 20 +4 x_1_2 25 +4 x_1_2 29 +4 t 31 +4 x_1_2 33 +4 x_1_2 38 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 x_1_2 0 +5 t 1 +5 x_1_2 4 +5 t 5 +5 x_1_2 6 +5 x_1_2 9 +5 t 10 +5 x_1_2 13 +5 x_1_2 15 +5 x_1_2 19 +5 t 20 +5 y_1_2 24 +5 y_1_2 28 +5 t 29 +5 y_1_2 32 +5 t 33 +5 x_1_2 34 +5 y_1_2 37 +5 t 38 +5 y_1_2 41 +6 cz 21 28 +6 cz 8 15 +6 cz 23 30 +6 cz 10 17 +6 cz 25 32 +6 cz 12 19 +6 cz 27 34 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 t 6 +6 y_1_2 7 +6 t 9 +6 y_1_2 11 +6 t 13 +6 y_1_2 16 +6 x_1_2 22 +6 t 24 +6 y_1_2 26 +6 y_1_2 31 +6 x_1_2 35 +6 y_1_2 36 +6 t 37 +6 y_1_2 39 +6 y_1_2 40 +6 t 41 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 t 2 +7 t 7 +7 y_1_2 10 +7 t 11 +7 y_1_2 15 +7 t 16 +7 x_1_2 19 +7 x_1_2 21 +7 y_1_2 25 +7 x_1_2 28 +7 x_1_2 30 +7 y_1_2 34 +7 t 35 +7 t 39 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 y_1_2 4 +8 y_1_2 9 +8 x_1_2 13 +8 t 15 +8 x_1_2 17 +8 t 19 +8 y_1_2 22 +8 y_1_2 26 +8 t 28 +8 t 30 +8 y_1_2 32 +8 t 34 +8 x_1_2 37 +8 x_1_2 41 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 x_1_2 3 +9 x_1_2 8 +9 y_1_2 12 +9 t 13 +9 y_1_2 16 +9 t 17 +9 y_1_2 20 +9 x_1_2 21 +9 t 22 +9 x_1_2 25 +9 t 26 +9 y_1_2 27 +9 y_1_2 31 +9 y_1_2 36 +9 y_1_2 40 +9 t 41 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_2.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_2.txt new file mode 100644 index 0000000..146e284 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_2.txt @@ -0,0 +1,311 @@ +42 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +2 cz 7 14 +2 cz 22 29 +2 cz 9 16 +2 cz 24 31 +2 cz 11 18 +2 cz 26 33 +2 cz 13 20 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 y_1_2 10 +2 y_1_2 15 +2 y_1_2 19 +2 x_1_2 23 +2 y_1_2 28 +2 y_1_2 32 +2 y_1_2 37 +2 x_1_2 38 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 t 0 +3 t 4 +3 x_1_2 7 +3 x_1_2 9 +3 y_1_2 13 +3 y_1_2 14 +3 y_1_2 18 +3 y_1_2 22 +3 t 23 +3 x_1_2 26 +3 t 28 +3 x_1_2 31 +3 t 32 +3 t 37 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 x_1_2 1 +4 x_1_2 5 +4 x_1_2 10 +4 t 14 +4 x_1_2 16 +4 t 18 +4 x_1_2 20 +4 y_1_2 25 +4 y_1_2 29 +4 t 31 +4 y_1_2 33 +4 x_1_2 38 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 x_1_2 0 +5 t 1 +5 x_1_2 4 +5 t 5 +5 x_1_2 6 +5 y_1_2 9 +5 t 10 +5 y_1_2 13 +5 y_1_2 15 +5 x_1_2 19 +5 t 20 +5 y_1_2 24 +5 y_1_2 28 +5 t 29 +5 y_1_2 32 +5 t 33 +5 y_1_2 34 +5 y_1_2 37 +5 t 38 +5 y_1_2 41 +6 cz 21 28 +6 cz 8 15 +6 cz 23 30 +6 cz 10 17 +6 cz 25 32 +6 cz 12 19 +6 cz 27 34 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 t 6 +6 y_1_2 7 +6 t 9 +6 x_1_2 11 +6 t 13 +6 y_1_2 16 +6 y_1_2 22 +6 t 24 +6 x_1_2 26 +6 y_1_2 31 +6 x_1_2 35 +6 y_1_2 36 +6 t 37 +6 y_1_2 39 +6 y_1_2 40 +6 t 41 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 t 2 +7 t 7 +7 x_1_2 10 +7 t 11 +7 y_1_2 15 +7 t 16 +7 y_1_2 19 +7 x_1_2 21 +7 y_1_2 25 +7 y_1_2 28 +7 y_1_2 30 +7 x_1_2 34 +7 t 35 +7 t 39 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 x_1_2 4 +8 x_1_2 9 +8 y_1_2 13 +8 t 15 +8 x_1_2 17 +8 t 19 +8 y_1_2 22 +8 x_1_2 26 +8 t 28 +8 t 30 +8 y_1_2 32 +8 t 34 +8 x_1_2 37 +8 y_1_2 41 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 y_1_2 3 +9 y_1_2 8 +9 y_1_2 12 +9 t 13 +9 y_1_2 16 +9 t 17 +9 y_1_2 20 +9 x_1_2 21 +9 t 22 +9 x_1_2 25 +9 t 26 +9 y_1_2 27 +9 y_1_2 31 +9 y_1_2 36 +9 x_1_2 40 +9 t 41 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_3.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_3.txt new file mode 100644 index 0000000..0fe1193 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_3.txt @@ -0,0 +1,311 @@ +42 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +2 cz 7 14 +2 cz 22 29 +2 cz 9 16 +2 cz 24 31 +2 cz 11 18 +2 cz 26 33 +2 cz 13 20 +2 x_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 y_1_2 5 +2 y_1_2 10 +2 x_1_2 15 +2 x_1_2 19 +2 y_1_2 23 +2 x_1_2 28 +2 x_1_2 32 +2 y_1_2 37 +2 x_1_2 38 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 t 0 +3 t 4 +3 y_1_2 7 +3 x_1_2 9 +3 y_1_2 13 +3 x_1_2 14 +3 y_1_2 18 +3 y_1_2 22 +3 t 23 +3 y_1_2 26 +3 t 28 +3 y_1_2 31 +3 t 32 +3 t 37 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 y_1_2 1 +4 x_1_2 5 +4 y_1_2 10 +4 t 14 +4 y_1_2 16 +4 t 18 +4 x_1_2 20 +4 x_1_2 25 +4 y_1_2 29 +4 t 31 +4 x_1_2 33 +4 y_1_2 38 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 t 5 +5 y_1_2 6 +5 x_1_2 9 +5 t 10 +5 y_1_2 13 +5 x_1_2 15 +5 y_1_2 19 +5 t 20 +5 y_1_2 24 +5 x_1_2 28 +5 t 29 +5 x_1_2 32 +5 t 33 +5 x_1_2 34 +5 y_1_2 37 +5 t 38 +5 x_1_2 41 +6 cz 21 28 +6 cz 8 15 +6 cz 23 30 +6 cz 10 17 +6 cz 25 32 +6 cz 12 19 +6 cz 27 34 +6 t 0 +6 y_1_2 2 +6 x_1_2 3 +6 t 4 +6 t 6 +6 y_1_2 7 +6 t 9 +6 x_1_2 11 +6 t 13 +6 x_1_2 16 +6 y_1_2 22 +6 t 24 +6 y_1_2 26 +6 y_1_2 31 +6 y_1_2 35 +6 y_1_2 36 +6 t 37 +6 y_1_2 39 +6 y_1_2 40 +6 t 41 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 t 2 +7 t 7 +7 y_1_2 10 +7 t 11 +7 x_1_2 15 +7 t 16 +7 y_1_2 19 +7 y_1_2 21 +7 y_1_2 25 +7 y_1_2 28 +7 y_1_2 30 +7 x_1_2 34 +7 t 35 +7 t 39 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 y_1_2 4 +8 y_1_2 9 +8 x_1_2 13 +8 t 15 +8 x_1_2 17 +8 t 19 +8 y_1_2 22 +8 y_1_2 26 +8 t 28 +8 t 30 +8 x_1_2 32 +8 t 34 +8 y_1_2 37 +8 x_1_2 41 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 x_1_2 3 +9 x_1_2 8 +9 y_1_2 12 +9 t 13 +9 y_1_2 16 +9 t 17 +9 x_1_2 20 +9 y_1_2 21 +9 t 22 +9 x_1_2 25 +9 t 26 +9 y_1_2 27 +9 x_1_2 31 +9 y_1_2 36 +9 y_1_2 40 +9 t 41 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_4.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_4.txt new file mode 100644 index 0000000..f79d2c1 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_4.txt @@ -0,0 +1,311 @@ +42 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +2 cz 7 14 +2 cz 22 29 +2 cz 9 16 +2 cz 24 31 +2 cz 11 18 +2 cz 26 33 +2 cz 13 20 +2 x_1_2 0 +2 x_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 x_1_2 10 +2 x_1_2 15 +2 y_1_2 19 +2 y_1_2 23 +2 y_1_2 28 +2 x_1_2 32 +2 y_1_2 37 +2 x_1_2 38 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 t 0 +3 t 4 +3 x_1_2 7 +3 x_1_2 9 +3 x_1_2 13 +3 y_1_2 14 +3 y_1_2 18 +3 y_1_2 22 +3 t 23 +3 y_1_2 26 +3 t 28 +3 x_1_2 31 +3 t 32 +3 t 37 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 x_1_2 1 +4 y_1_2 5 +4 y_1_2 10 +4 t 14 +4 y_1_2 16 +4 t 18 +4 y_1_2 20 +4 x_1_2 25 +4 y_1_2 29 +4 t 31 +4 y_1_2 33 +4 y_1_2 38 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 x_1_2 0 +5 t 1 +5 x_1_2 4 +5 t 5 +5 x_1_2 6 +5 y_1_2 9 +5 t 10 +5 y_1_2 13 +5 y_1_2 15 +5 x_1_2 19 +5 t 20 +5 y_1_2 24 +5 y_1_2 28 +5 t 29 +5 y_1_2 32 +5 t 33 +5 y_1_2 34 +5 y_1_2 37 +5 t 38 +5 x_1_2 41 +6 cz 21 28 +6 cz 8 15 +6 cz 23 30 +6 cz 10 17 +6 cz 25 32 +6 cz 12 19 +6 cz 27 34 +6 t 0 +6 y_1_2 2 +6 x_1_2 3 +6 t 4 +6 t 6 +6 x_1_2 7 +6 t 9 +6 x_1_2 11 +6 t 13 +6 y_1_2 16 +6 x_1_2 22 +6 t 24 +6 x_1_2 26 +6 y_1_2 31 +6 x_1_2 35 +6 y_1_2 36 +6 t 37 +6 x_1_2 39 +6 x_1_2 40 +6 t 41 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 t 2 +7 t 7 +7 y_1_2 10 +7 t 11 +7 x_1_2 15 +7 t 16 +7 x_1_2 19 +7 x_1_2 21 +7 y_1_2 25 +7 x_1_2 28 +7 x_1_2 30 +7 y_1_2 34 +7 t 35 +7 t 39 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 x_1_2 4 +8 y_1_2 9 +8 y_1_2 13 +8 t 15 +8 x_1_2 17 +8 t 19 +8 x_1_2 22 +8 x_1_2 26 +8 t 28 +8 t 30 +8 y_1_2 32 +8 t 34 +8 y_1_2 37 +8 x_1_2 41 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 x_1_2 3 +9 x_1_2 8 +9 x_1_2 12 +9 t 13 +9 x_1_2 16 +9 t 17 +9 y_1_2 20 +9 y_1_2 21 +9 t 22 +9 y_1_2 25 +9 t 26 +9 y_1_2 27 +9 y_1_2 31 +9 x_1_2 36 +9 x_1_2 40 +9 t 41 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_5.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_5.txt new file mode 100644 index 0000000..32b7e05 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_5.txt @@ -0,0 +1,311 @@ +42 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +2 cz 7 14 +2 cz 22 29 +2 cz 9 16 +2 cz 24 31 +2 cz 11 18 +2 cz 26 33 +2 cz 13 20 +2 y_1_2 0 +2 y_1_2 1 +2 y_1_2 4 +2 y_1_2 5 +2 y_1_2 10 +2 y_1_2 15 +2 x_1_2 19 +2 x_1_2 23 +2 y_1_2 28 +2 y_1_2 32 +2 y_1_2 37 +2 x_1_2 38 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 t 0 +3 t 4 +3 x_1_2 7 +3 x_1_2 9 +3 y_1_2 13 +3 y_1_2 14 +3 x_1_2 18 +3 x_1_2 22 +3 t 23 +3 x_1_2 26 +3 t 28 +3 y_1_2 31 +3 t 32 +3 t 37 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 y_1_2 1 +4 x_1_2 5 +4 y_1_2 10 +4 t 14 +4 x_1_2 16 +4 t 18 +4 y_1_2 20 +4 x_1_2 25 +4 x_1_2 29 +4 t 31 +4 y_1_2 33 +4 x_1_2 38 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 t 5 +5 y_1_2 6 +5 x_1_2 9 +5 t 10 +5 y_1_2 13 +5 y_1_2 15 +5 y_1_2 19 +5 t 20 +5 x_1_2 24 +5 y_1_2 28 +5 t 29 +5 y_1_2 32 +5 t 33 +5 y_1_2 34 +5 y_1_2 37 +5 t 38 +5 x_1_2 41 +6 cz 21 28 +6 cz 8 15 +6 cz 23 30 +6 cz 10 17 +6 cz 25 32 +6 cz 12 19 +6 cz 27 34 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 t 6 +6 x_1_2 7 +6 t 9 +6 x_1_2 11 +6 t 13 +6 x_1_2 16 +6 y_1_2 22 +6 t 24 +6 x_1_2 26 +6 y_1_2 31 +6 x_1_2 35 +6 x_1_2 36 +6 t 37 +6 y_1_2 39 +6 x_1_2 40 +6 t 41 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 t 2 +7 t 7 +7 x_1_2 10 +7 t 11 +7 x_1_2 15 +7 t 16 +7 y_1_2 19 +7 x_1_2 21 +7 y_1_2 25 +7 x_1_2 28 +7 y_1_2 30 +7 y_1_2 34 +7 t 35 +7 t 39 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 x_1_2 4 +8 y_1_2 9 +8 x_1_2 13 +8 t 15 +8 y_1_2 17 +8 t 19 +8 x_1_2 22 +8 x_1_2 26 +8 t 28 +8 t 30 +8 x_1_2 32 +8 t 34 +8 y_1_2 37 +8 x_1_2 41 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 y_1_2 3 +9 y_1_2 8 +9 y_1_2 12 +9 t 13 +9 x_1_2 16 +9 t 17 +9 x_1_2 20 +9 y_1_2 21 +9 t 22 +9 y_1_2 25 +9 t 26 +9 x_1_2 27 +9 y_1_2 31 +9 y_1_2 36 +9 y_1_2 40 +9 t 41 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_6.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_6.txt new file mode 100644 index 0000000..fa43558 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_6.txt @@ -0,0 +1,311 @@ +42 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +2 cz 7 14 +2 cz 22 29 +2 cz 9 16 +2 cz 24 31 +2 cz 11 18 +2 cz 26 33 +2 cz 13 20 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 x_1_2 10 +2 y_1_2 15 +2 x_1_2 19 +2 y_1_2 23 +2 x_1_2 28 +2 y_1_2 32 +2 x_1_2 37 +2 y_1_2 38 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 t 0 +3 t 4 +3 y_1_2 7 +3 x_1_2 9 +3 y_1_2 13 +3 y_1_2 14 +3 x_1_2 18 +3 y_1_2 22 +3 t 23 +3 y_1_2 26 +3 t 28 +3 x_1_2 31 +3 t 32 +3 t 37 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 y_1_2 1 +4 y_1_2 5 +4 y_1_2 10 +4 t 14 +4 x_1_2 16 +4 t 18 +4 x_1_2 20 +4 y_1_2 25 +4 y_1_2 29 +4 t 31 +4 x_1_2 33 +4 x_1_2 38 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 t 5 +5 x_1_2 6 +5 y_1_2 9 +5 t 10 +5 y_1_2 13 +5 x_1_2 15 +5 y_1_2 19 +5 t 20 +5 x_1_2 24 +5 y_1_2 28 +5 t 29 +5 y_1_2 32 +5 t 33 +5 y_1_2 34 +5 y_1_2 37 +5 t 38 +5 y_1_2 41 +6 cz 21 28 +6 cz 8 15 +6 cz 23 30 +6 cz 10 17 +6 cz 25 32 +6 cz 12 19 +6 cz 27 34 +6 t 0 +6 y_1_2 2 +6 y_1_2 3 +6 t 4 +6 t 6 +6 x_1_2 7 +6 t 9 +6 x_1_2 11 +6 t 13 +6 y_1_2 16 +6 x_1_2 22 +6 t 24 +6 y_1_2 26 +6 x_1_2 31 +6 y_1_2 35 +6 y_1_2 36 +6 t 37 +6 x_1_2 39 +6 y_1_2 40 +6 t 41 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 t 2 +7 t 7 +7 x_1_2 10 +7 t 11 +7 x_1_2 15 +7 t 16 +7 x_1_2 19 +7 x_1_2 21 +7 x_1_2 25 +7 y_1_2 28 +7 y_1_2 30 +7 x_1_2 34 +7 t 35 +7 t 39 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 y_1_2 4 +8 x_1_2 9 +8 x_1_2 13 +8 t 15 +8 y_1_2 17 +8 t 19 +8 y_1_2 22 +8 x_1_2 26 +8 t 28 +8 t 30 +8 x_1_2 32 +8 t 34 +8 x_1_2 37 +8 x_1_2 41 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 y_1_2 3 +9 x_1_2 8 +9 x_1_2 12 +9 t 13 +9 y_1_2 16 +9 t 17 +9 x_1_2 20 +9 y_1_2 21 +9 t 22 +9 x_1_2 25 +9 t 26 +9 y_1_2 27 +9 y_1_2 31 +9 y_1_2 36 +9 y_1_2 40 +9 t 41 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_7.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_7.txt new file mode 100644 index 0000000..9b5c167 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_7.txt @@ -0,0 +1,311 @@ +42 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +2 cz 7 14 +2 cz 22 29 +2 cz 9 16 +2 cz 24 31 +2 cz 11 18 +2 cz 26 33 +2 cz 13 20 +2 x_1_2 0 +2 x_1_2 1 +2 y_1_2 4 +2 x_1_2 5 +2 y_1_2 10 +2 x_1_2 15 +2 x_1_2 19 +2 y_1_2 23 +2 x_1_2 28 +2 x_1_2 32 +2 x_1_2 37 +2 x_1_2 38 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 t 0 +3 t 4 +3 x_1_2 7 +3 y_1_2 9 +3 x_1_2 13 +3 x_1_2 14 +3 y_1_2 18 +3 y_1_2 22 +3 t 23 +3 y_1_2 26 +3 t 28 +3 x_1_2 31 +3 t 32 +3 t 37 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 y_1_2 1 +4 x_1_2 5 +4 y_1_2 10 +4 t 14 +4 x_1_2 16 +4 t 18 +4 x_1_2 20 +4 x_1_2 25 +4 x_1_2 29 +4 t 31 +4 y_1_2 33 +4 x_1_2 38 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 t 5 +5 x_1_2 6 +5 y_1_2 9 +5 t 10 +5 x_1_2 13 +5 x_1_2 15 +5 x_1_2 19 +5 t 20 +5 y_1_2 24 +5 x_1_2 28 +5 t 29 +5 x_1_2 32 +5 t 33 +5 y_1_2 34 +5 x_1_2 37 +5 t 38 +5 x_1_2 41 +6 cz 21 28 +6 cz 8 15 +6 cz 23 30 +6 cz 10 17 +6 cz 25 32 +6 cz 12 19 +6 cz 27 34 +6 t 0 +6 y_1_2 2 +6 y_1_2 3 +6 t 4 +6 t 6 +6 x_1_2 7 +6 t 9 +6 y_1_2 11 +6 t 13 +6 y_1_2 16 +6 y_1_2 22 +6 t 24 +6 y_1_2 26 +6 x_1_2 31 +6 y_1_2 35 +6 x_1_2 36 +6 t 37 +6 x_1_2 39 +6 y_1_2 40 +6 t 41 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 t 2 +7 t 7 +7 x_1_2 10 +7 t 11 +7 x_1_2 15 +7 t 16 +7 x_1_2 19 +7 y_1_2 21 +7 y_1_2 25 +7 y_1_2 28 +7 y_1_2 30 +7 x_1_2 34 +7 t 35 +7 t 39 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 y_1_2 4 +8 y_1_2 9 +8 y_1_2 13 +8 t 15 +8 x_1_2 17 +8 t 19 +8 y_1_2 22 +8 y_1_2 26 +8 t 28 +8 t 30 +8 x_1_2 32 +8 t 34 +8 y_1_2 37 +8 x_1_2 41 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 y_1_2 3 +9 y_1_2 8 +9 y_1_2 12 +9 t 13 +9 y_1_2 16 +9 t 17 +9 x_1_2 20 +9 x_1_2 21 +9 t 22 +9 y_1_2 25 +9 t 26 +9 x_1_2 27 +9 x_1_2 31 +9 x_1_2 36 +9 x_1_2 40 +9 t 41 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_8.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_8.txt new file mode 100644 index 0000000..9bd5f03 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_8.txt @@ -0,0 +1,311 @@ +42 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +2 cz 7 14 +2 cz 22 29 +2 cz 9 16 +2 cz 24 31 +2 cz 11 18 +2 cz 26 33 +2 cz 13 20 +2 x_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 y_1_2 5 +2 x_1_2 10 +2 x_1_2 15 +2 y_1_2 19 +2 x_1_2 23 +2 y_1_2 28 +2 x_1_2 32 +2 x_1_2 37 +2 x_1_2 38 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 t 0 +3 t 4 +3 x_1_2 7 +3 y_1_2 9 +3 x_1_2 13 +3 x_1_2 14 +3 x_1_2 18 +3 x_1_2 22 +3 t 23 +3 x_1_2 26 +3 t 28 +3 y_1_2 31 +3 t 32 +3 t 37 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 x_1_2 1 +4 x_1_2 5 +4 x_1_2 10 +4 t 14 +4 y_1_2 16 +4 t 18 +4 x_1_2 20 +4 y_1_2 25 +4 x_1_2 29 +4 t 31 +4 y_1_2 33 +4 x_1_2 38 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 y_1_2 0 +5 t 1 +5 x_1_2 4 +5 t 5 +5 y_1_2 6 +5 y_1_2 9 +5 t 10 +5 y_1_2 13 +5 x_1_2 15 +5 x_1_2 19 +5 t 20 +5 y_1_2 24 +5 x_1_2 28 +5 t 29 +5 x_1_2 32 +5 t 33 +5 y_1_2 34 +5 y_1_2 37 +5 t 38 +5 y_1_2 41 +6 cz 21 28 +6 cz 8 15 +6 cz 23 30 +6 cz 10 17 +6 cz 25 32 +6 cz 12 19 +6 cz 27 34 +6 t 0 +6 y_1_2 2 +6 x_1_2 3 +6 t 4 +6 t 6 +6 x_1_2 7 +6 t 9 +6 y_1_2 11 +6 t 13 +6 x_1_2 16 +6 y_1_2 22 +6 t 24 +6 x_1_2 26 +6 y_1_2 31 +6 y_1_2 35 +6 y_1_2 36 +6 t 37 +6 y_1_2 39 +6 y_1_2 40 +6 t 41 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 t 2 +7 t 7 +7 x_1_2 10 +7 t 11 +7 x_1_2 15 +7 t 16 +7 y_1_2 19 +7 y_1_2 21 +7 x_1_2 25 +7 y_1_2 28 +7 y_1_2 30 +7 y_1_2 34 +7 t 35 +7 t 39 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 x_1_2 4 +8 x_1_2 9 +8 x_1_2 13 +8 t 15 +8 x_1_2 17 +8 t 19 +8 x_1_2 22 +8 x_1_2 26 +8 t 28 +8 t 30 +8 x_1_2 32 +8 t 34 +8 y_1_2 37 +8 y_1_2 41 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 x_1_2 3 +9 x_1_2 8 +9 x_1_2 12 +9 t 13 +9 y_1_2 16 +9 t 17 +9 y_1_2 20 +9 x_1_2 21 +9 t 22 +9 y_1_2 25 +9 t 26 +9 x_1_2 27 +9 x_1_2 31 +9 y_1_2 36 +9 x_1_2 40 +9 t 41 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_9.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_9.txt new file mode 100644 index 0000000..a3d9267 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_6x7_10_9.txt @@ -0,0 +1,311 @@ +42 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +2 cz 7 14 +2 cz 22 29 +2 cz 9 16 +2 cz 24 31 +2 cz 11 18 +2 cz 26 33 +2 cz 13 20 +2 x_1_2 0 +2 x_1_2 1 +2 x_1_2 4 +2 y_1_2 5 +2 x_1_2 10 +2 y_1_2 15 +2 y_1_2 19 +2 x_1_2 23 +2 y_1_2 28 +2 y_1_2 32 +2 x_1_2 37 +2 x_1_2 38 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 t 0 +3 t 4 +3 y_1_2 7 +3 x_1_2 9 +3 y_1_2 13 +3 x_1_2 14 +3 x_1_2 18 +3 x_1_2 22 +3 t 23 +3 y_1_2 26 +3 t 28 +3 y_1_2 31 +3 t 32 +3 t 37 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 y_1_2 1 +4 y_1_2 5 +4 x_1_2 10 +4 t 14 +4 y_1_2 16 +4 t 18 +4 x_1_2 20 +4 x_1_2 25 +4 y_1_2 29 +4 t 31 +4 y_1_2 33 +4 x_1_2 38 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 x_1_2 0 +5 t 1 +5 x_1_2 4 +5 t 5 +5 x_1_2 6 +5 x_1_2 9 +5 t 10 +5 y_1_2 13 +5 x_1_2 15 +5 y_1_2 19 +5 t 20 +5 y_1_2 24 +5 x_1_2 28 +5 t 29 +5 x_1_2 32 +5 t 33 +5 x_1_2 34 +5 x_1_2 37 +5 t 38 +5 x_1_2 41 +6 cz 21 28 +6 cz 8 15 +6 cz 23 30 +6 cz 10 17 +6 cz 25 32 +6 cz 12 19 +6 cz 27 34 +6 t 0 +6 y_1_2 2 +6 x_1_2 3 +6 t 4 +6 t 6 +6 y_1_2 7 +6 t 9 +6 x_1_2 11 +6 t 13 +6 y_1_2 16 +6 y_1_2 22 +6 t 24 +6 x_1_2 26 +6 x_1_2 31 +6 x_1_2 35 +6 y_1_2 36 +6 t 37 +6 x_1_2 39 +6 x_1_2 40 +6 t 41 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 t 2 +7 t 7 +7 x_1_2 10 +7 t 11 +7 y_1_2 15 +7 t 16 +7 x_1_2 19 +7 x_1_2 21 +7 y_1_2 25 +7 x_1_2 28 +7 y_1_2 30 +7 x_1_2 34 +7 t 35 +7 t 39 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 y_1_2 4 +8 y_1_2 9 +8 x_1_2 13 +8 t 15 +8 y_1_2 17 +8 t 19 +8 y_1_2 22 +8 x_1_2 26 +8 t 28 +8 t 30 +8 x_1_2 32 +8 t 34 +8 y_1_2 37 +8 y_1_2 41 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 x_1_2 3 +9 y_1_2 8 +9 y_1_2 12 +9 t 13 +9 x_1_2 16 +9 t 17 +9 y_1_2 20 +9 x_1_2 21 +9 t 22 +9 x_1_2 25 +9 t 26 +9 y_1_2 27 +9 y_1_2 31 +9 y_1_2 36 +9 x_1_2 40 +9 t 41 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_0.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_0.txt new file mode 100644 index 0000000..03549eb --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_0.txt @@ -0,0 +1,365 @@ +49 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +0 h 42 +0 h 43 +0 h 44 +0 h 45 +0 h 46 +0 h 47 +0 h 48 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 cz 42 43 +1 cz 46 47 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +1 t 44 +1 t 45 +1 t 48 +2 cz 7 14 +2 cz 35 42 +2 cz 22 29 +2 cz 9 16 +2 cz 37 44 +2 cz 24 31 +2 cz 11 18 +2 cz 39 46 +2 cz 26 33 +2 cz 13 20 +2 cz 41 48 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 y_1_2 10 +2 x_1_2 15 +2 y_1_2 19 +2 x_1_2 23 +2 x_1_2 28 +2 y_1_2 32 +2 y_1_2 38 +2 y_1_2 43 +2 x_1_2 47 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 cz 43 44 +3 cz 47 48 +3 t 0 +3 t 4 +3 y_1_2 7 +3 y_1_2 9 +3 x_1_2 13 +3 y_1_2 14 +3 y_1_2 18 +3 y_1_2 22 +3 t 23 +3 y_1_2 26 +3 t 28 +3 x_1_2 31 +3 t 32 +3 y_1_2 35 +3 y_1_2 37 +3 y_1_2 41 +3 x_1_2 42 +3 x_1_2 46 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 x_1_2 1 +4 y_1_2 5 +4 y_1_2 10 +4 t 14 +4 y_1_2 16 +4 t 18 +4 x_1_2 20 +4 y_1_2 25 +4 x_1_2 29 +4 t 31 +4 y_1_2 33 +4 y_1_2 38 +4 t 42 +4 x_1_2 43 +4 y_1_2 44 +4 t 46 +4 x_1_2 47 +4 y_1_2 48 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 cz 44 45 +5 y_1_2 0 +5 t 1 +5 x_1_2 4 +5 t 5 +5 x_1_2 6 +5 y_1_2 9 +5 t 10 +5 x_1_2 13 +5 x_1_2 15 +5 y_1_2 19 +5 t 20 +5 x_1_2 24 +5 y_1_2 28 +5 t 29 +5 x_1_2 32 +5 t 33 +5 y_1_2 34 +5 y_1_2 37 +5 t 38 +5 x_1_2 41 +5 t 43 +5 t 47 +5 t 48 +6 cz 21 28 +6 cz 8 15 +6 cz 36 43 +6 cz 23 30 +6 cz 10 17 +6 cz 38 45 +6 cz 25 32 +6 cz 12 19 +6 cz 40 47 +6 cz 27 34 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 t 6 +6 y_1_2 7 +6 t 9 +6 y_1_2 11 +6 t 13 +6 x_1_2 16 +6 y_1_2 22 +6 t 24 +6 y_1_2 26 +6 y_1_2 31 +6 y_1_2 35 +6 t 37 +6 y_1_2 39 +6 t 41 +6 y_1_2 44 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 cz 45 46 +7 t 2 +7 t 7 +7 y_1_2 10 +7 t 11 +7 y_1_2 15 +7 t 16 +7 x_1_2 19 +7 y_1_2 21 +7 x_1_2 25 +7 y_1_2 28 +7 x_1_2 30 +7 x_1_2 34 +7 t 35 +7 x_1_2 38 +7 t 39 +7 y_1_2 43 +7 t 44 +7 y_1_2 47 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 x_1_2 4 +8 x_1_2 9 +8 y_1_2 13 +8 t 15 +8 y_1_2 17 +8 t 19 +8 y_1_2 22 +8 y_1_2 26 +8 t 28 +8 t 30 +8 y_1_2 32 +8 t 34 +8 y_1_2 37 +8 y_1_2 41 +8 t 43 +8 x_1_2 45 +8 y_1_2 46 +8 t 47 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 cz 42 43 +9 cz 46 47 +9 x_1_2 3 +9 y_1_2 8 +9 y_1_2 12 +9 t 13 +9 y_1_2 16 +9 t 17 +9 y_1_2 20 +9 y_1_2 21 +9 t 22 +9 y_1_2 25 +9 t 26 +9 x_1_2 27 +9 y_1_2 31 +9 y_1_2 36 +9 y_1_2 40 +9 t 41 +9 t 45 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 +10 h 42 +10 h 43 +10 h 44 +10 h 45 +10 h 46 +10 h 47 +10 h 48 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_1.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_1.txt new file mode 100644 index 0000000..f964170 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_1.txt @@ -0,0 +1,365 @@ +49 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +0 h 42 +0 h 43 +0 h 44 +0 h 45 +0 h 46 +0 h 47 +0 h 48 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 cz 42 43 +1 cz 46 47 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +1 t 44 +1 t 45 +1 t 48 +2 cz 7 14 +2 cz 35 42 +2 cz 22 29 +2 cz 9 16 +2 cz 37 44 +2 cz 24 31 +2 cz 11 18 +2 cz 39 46 +2 cz 26 33 +2 cz 13 20 +2 cz 41 48 +2 x_1_2 0 +2 y_1_2 1 +2 y_1_2 4 +2 x_1_2 5 +2 x_1_2 10 +2 x_1_2 15 +2 y_1_2 19 +2 y_1_2 23 +2 x_1_2 28 +2 x_1_2 32 +2 y_1_2 38 +2 x_1_2 43 +2 y_1_2 47 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 cz 43 44 +3 cz 47 48 +3 t 0 +3 t 4 +3 x_1_2 7 +3 x_1_2 9 +3 y_1_2 13 +3 x_1_2 14 +3 y_1_2 18 +3 y_1_2 22 +3 t 23 +3 x_1_2 26 +3 t 28 +3 x_1_2 31 +3 t 32 +3 y_1_2 35 +3 y_1_2 37 +3 x_1_2 41 +3 x_1_2 42 +3 x_1_2 46 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 x_1_2 1 +4 x_1_2 5 +4 x_1_2 10 +4 t 14 +4 x_1_2 16 +4 t 18 +4 x_1_2 20 +4 x_1_2 25 +4 x_1_2 29 +4 t 31 +4 x_1_2 33 +4 x_1_2 38 +4 t 42 +4 x_1_2 43 +4 y_1_2 44 +4 t 46 +4 y_1_2 47 +4 y_1_2 48 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 cz 44 45 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 t 5 +5 y_1_2 6 +5 x_1_2 9 +5 t 10 +5 x_1_2 13 +5 y_1_2 15 +5 y_1_2 19 +5 t 20 +5 y_1_2 24 +5 x_1_2 28 +5 t 29 +5 y_1_2 32 +5 t 33 +5 y_1_2 34 +5 x_1_2 37 +5 t 38 +5 y_1_2 41 +5 t 43 +5 t 47 +5 t 48 +6 cz 21 28 +6 cz 8 15 +6 cz 36 43 +6 cz 23 30 +6 cz 10 17 +6 cz 38 45 +6 cz 25 32 +6 cz 12 19 +6 cz 40 47 +6 cz 27 34 +6 t 0 +6 y_1_2 2 +6 y_1_2 3 +6 t 4 +6 t 6 +6 y_1_2 7 +6 t 9 +6 y_1_2 11 +6 t 13 +6 x_1_2 16 +6 x_1_2 22 +6 t 24 +6 y_1_2 26 +6 x_1_2 31 +6 x_1_2 35 +6 t 37 +6 y_1_2 39 +6 t 41 +6 y_1_2 44 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 cz 45 46 +7 t 2 +7 t 7 +7 y_1_2 10 +7 t 11 +7 x_1_2 15 +7 t 16 +7 x_1_2 19 +7 y_1_2 21 +7 y_1_2 25 +7 y_1_2 28 +7 x_1_2 30 +7 x_1_2 34 +7 t 35 +7 x_1_2 38 +7 t 39 +7 x_1_2 43 +7 t 44 +7 y_1_2 47 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 y_1_2 4 +8 y_1_2 9 +8 x_1_2 13 +8 t 15 +8 x_1_2 17 +8 t 19 +8 y_1_2 22 +8 y_1_2 26 +8 t 28 +8 t 30 +8 y_1_2 32 +8 t 34 +8 y_1_2 37 +8 y_1_2 41 +8 t 43 +8 x_1_2 45 +8 y_1_2 46 +8 t 47 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 cz 42 43 +9 cz 46 47 +9 y_1_2 3 +9 y_1_2 8 +9 x_1_2 12 +9 t 13 +9 x_1_2 16 +9 t 17 +9 y_1_2 20 +9 y_1_2 21 +9 t 22 +9 x_1_2 25 +9 t 26 +9 y_1_2 27 +9 y_1_2 31 +9 y_1_2 36 +9 y_1_2 40 +9 t 41 +9 t 45 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 +10 h 42 +10 h 43 +10 h 44 +10 h 45 +10 h 46 +10 h 47 +10 h 48 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_2.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_2.txt new file mode 100644 index 0000000..cab8a3f --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_2.txt @@ -0,0 +1,365 @@ +49 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +0 h 42 +0 h 43 +0 h 44 +0 h 45 +0 h 46 +0 h 47 +0 h 48 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 cz 42 43 +1 cz 46 47 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +1 t 44 +1 t 45 +1 t 48 +2 cz 7 14 +2 cz 35 42 +2 cz 22 29 +2 cz 9 16 +2 cz 37 44 +2 cz 24 31 +2 cz 11 18 +2 cz 39 46 +2 cz 26 33 +2 cz 13 20 +2 cz 41 48 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 y_1_2 10 +2 y_1_2 15 +2 y_1_2 19 +2 x_1_2 23 +2 y_1_2 28 +2 y_1_2 32 +2 y_1_2 38 +2 x_1_2 43 +2 x_1_2 47 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 cz 43 44 +3 cz 47 48 +3 t 0 +3 t 4 +3 x_1_2 7 +3 y_1_2 9 +3 y_1_2 13 +3 y_1_2 14 +3 y_1_2 18 +3 x_1_2 22 +3 t 23 +3 x_1_2 26 +3 t 28 +3 x_1_2 31 +3 t 32 +3 x_1_2 35 +3 x_1_2 37 +3 x_1_2 41 +3 x_1_2 42 +3 y_1_2 46 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 y_1_2 1 +4 y_1_2 5 +4 x_1_2 10 +4 t 14 +4 x_1_2 16 +4 t 18 +4 x_1_2 20 +4 x_1_2 25 +4 y_1_2 29 +4 t 31 +4 y_1_2 33 +4 y_1_2 38 +4 t 42 +4 x_1_2 43 +4 y_1_2 44 +4 t 46 +4 y_1_2 47 +4 y_1_2 48 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 cz 44 45 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 t 5 +5 y_1_2 6 +5 x_1_2 9 +5 t 10 +5 y_1_2 13 +5 y_1_2 15 +5 x_1_2 19 +5 t 20 +5 y_1_2 24 +5 y_1_2 28 +5 t 29 +5 x_1_2 32 +5 t 33 +5 y_1_2 34 +5 x_1_2 37 +5 t 38 +5 y_1_2 41 +5 t 43 +5 t 47 +5 t 48 +6 cz 21 28 +6 cz 8 15 +6 cz 36 43 +6 cz 23 30 +6 cz 10 17 +6 cz 38 45 +6 cz 25 32 +6 cz 12 19 +6 cz 40 47 +6 cz 27 34 +6 t 0 +6 y_1_2 2 +6 y_1_2 3 +6 t 4 +6 t 6 +6 x_1_2 7 +6 t 9 +6 y_1_2 11 +6 t 13 +6 y_1_2 16 +6 x_1_2 22 +6 t 24 +6 y_1_2 26 +6 y_1_2 31 +6 y_1_2 35 +6 t 37 +6 x_1_2 39 +6 t 41 +6 x_1_2 44 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 cz 45 46 +7 t 2 +7 t 7 +7 x_1_2 10 +7 t 11 +7 y_1_2 15 +7 t 16 +7 x_1_2 19 +7 y_1_2 21 +7 x_1_2 25 +7 y_1_2 28 +7 x_1_2 30 +7 y_1_2 34 +7 t 35 +7 y_1_2 38 +7 t 39 +7 y_1_2 43 +7 t 44 +7 y_1_2 47 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 y_1_2 4 +8 y_1_2 9 +8 x_1_2 13 +8 t 15 +8 x_1_2 17 +8 t 19 +8 y_1_2 22 +8 y_1_2 26 +8 t 28 +8 t 30 +8 y_1_2 32 +8 t 34 +8 x_1_2 37 +8 y_1_2 41 +8 t 43 +8 y_1_2 45 +8 y_1_2 46 +8 t 47 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 cz 42 43 +9 cz 46 47 +9 x_1_2 3 +9 y_1_2 8 +9 x_1_2 12 +9 t 13 +9 y_1_2 16 +9 t 17 +9 x_1_2 20 +9 x_1_2 21 +9 t 22 +9 y_1_2 25 +9 t 26 +9 x_1_2 27 +9 y_1_2 31 +9 y_1_2 36 +9 x_1_2 40 +9 t 41 +9 t 45 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 +10 h 42 +10 h 43 +10 h 44 +10 h 45 +10 h 46 +10 h 47 +10 h 48 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_3.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_3.txt new file mode 100644 index 0000000..357bdc4 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_3.txt @@ -0,0 +1,365 @@ +49 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +0 h 42 +0 h 43 +0 h 44 +0 h 45 +0 h 46 +0 h 47 +0 h 48 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 cz 42 43 +1 cz 46 47 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +1 t 44 +1 t 45 +1 t 48 +2 cz 7 14 +2 cz 35 42 +2 cz 22 29 +2 cz 9 16 +2 cz 37 44 +2 cz 24 31 +2 cz 11 18 +2 cz 39 46 +2 cz 26 33 +2 cz 13 20 +2 cz 41 48 +2 x_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 y_1_2 5 +2 y_1_2 10 +2 x_1_2 15 +2 x_1_2 19 +2 y_1_2 23 +2 x_1_2 28 +2 x_1_2 32 +2 y_1_2 38 +2 x_1_2 43 +2 y_1_2 47 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 cz 43 44 +3 cz 47 48 +3 t 0 +3 t 4 +3 x_1_2 7 +3 y_1_2 9 +3 x_1_2 13 +3 y_1_2 14 +3 y_1_2 18 +3 y_1_2 22 +3 t 23 +3 y_1_2 26 +3 t 28 +3 y_1_2 31 +3 t 32 +3 x_1_2 35 +3 y_1_2 37 +3 y_1_2 41 +3 x_1_2 42 +3 x_1_2 46 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 y_1_2 1 +4 x_1_2 5 +4 y_1_2 10 +4 t 14 +4 y_1_2 16 +4 t 18 +4 y_1_2 20 +4 y_1_2 25 +4 x_1_2 29 +4 t 31 +4 y_1_2 33 +4 x_1_2 38 +4 t 42 +4 y_1_2 43 +4 y_1_2 44 +4 t 46 +4 x_1_2 47 +4 x_1_2 48 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 cz 44 45 +5 x_1_2 0 +5 t 1 +5 y_1_2 4 +5 t 5 +5 x_1_2 6 +5 y_1_2 9 +5 t 10 +5 x_1_2 13 +5 y_1_2 15 +5 x_1_2 19 +5 t 20 +5 x_1_2 24 +5 y_1_2 28 +5 t 29 +5 y_1_2 32 +5 t 33 +5 y_1_2 34 +5 y_1_2 37 +5 t 38 +5 y_1_2 41 +5 t 43 +5 t 47 +5 t 48 +6 cz 21 28 +6 cz 8 15 +6 cz 36 43 +6 cz 23 30 +6 cz 10 17 +6 cz 38 45 +6 cz 25 32 +6 cz 12 19 +6 cz 40 47 +6 cz 27 34 +6 t 0 +6 y_1_2 2 +6 y_1_2 3 +6 t 4 +6 t 6 +6 y_1_2 7 +6 t 9 +6 x_1_2 11 +6 t 13 +6 y_1_2 16 +6 y_1_2 22 +6 t 24 +6 y_1_2 26 +6 y_1_2 31 +6 y_1_2 35 +6 t 37 +6 x_1_2 39 +6 t 41 +6 y_1_2 44 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 cz 45 46 +7 t 2 +7 t 7 +7 y_1_2 10 +7 t 11 +7 x_1_2 15 +7 t 16 +7 x_1_2 19 +7 y_1_2 21 +7 y_1_2 25 +7 x_1_2 28 +7 y_1_2 30 +7 x_1_2 34 +7 t 35 +7 x_1_2 38 +7 t 39 +7 x_1_2 43 +7 t 44 +7 y_1_2 47 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 y_1_2 4 +8 x_1_2 9 +8 y_1_2 13 +8 t 15 +8 x_1_2 17 +8 t 19 +8 y_1_2 22 +8 x_1_2 26 +8 t 28 +8 t 30 +8 y_1_2 32 +8 t 34 +8 y_1_2 37 +8 y_1_2 41 +8 t 43 +8 y_1_2 45 +8 x_1_2 46 +8 t 47 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 cz 42 43 +9 cz 46 47 +9 x_1_2 3 +9 y_1_2 8 +9 x_1_2 12 +9 t 13 +9 x_1_2 16 +9 t 17 +9 x_1_2 20 +9 y_1_2 21 +9 t 22 +9 x_1_2 25 +9 t 26 +9 x_1_2 27 +9 y_1_2 31 +9 x_1_2 36 +9 y_1_2 40 +9 t 41 +9 t 45 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 +10 h 42 +10 h 43 +10 h 44 +10 h 45 +10 h 46 +10 h 47 +10 h 48 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_4.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_4.txt new file mode 100644 index 0000000..3f2e0ca --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_4.txt @@ -0,0 +1,365 @@ +49 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +0 h 42 +0 h 43 +0 h 44 +0 h 45 +0 h 46 +0 h 47 +0 h 48 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 cz 42 43 +1 cz 46 47 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +1 t 44 +1 t 45 +1 t 48 +2 cz 7 14 +2 cz 35 42 +2 cz 22 29 +2 cz 9 16 +2 cz 37 44 +2 cz 24 31 +2 cz 11 18 +2 cz 39 46 +2 cz 26 33 +2 cz 13 20 +2 cz 41 48 +2 x_1_2 0 +2 x_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 x_1_2 10 +2 x_1_2 15 +2 y_1_2 19 +2 y_1_2 23 +2 y_1_2 28 +2 x_1_2 32 +2 y_1_2 38 +2 x_1_2 43 +2 x_1_2 47 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 cz 43 44 +3 cz 47 48 +3 t 0 +3 t 4 +3 x_1_2 7 +3 x_1_2 9 +3 y_1_2 13 +3 y_1_2 14 +3 y_1_2 18 +3 y_1_2 22 +3 t 23 +3 x_1_2 26 +3 t 28 +3 x_1_2 31 +3 t 32 +3 y_1_2 35 +3 y_1_2 37 +3 y_1_2 41 +3 y_1_2 42 +3 x_1_2 46 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 y_1_2 1 +4 y_1_2 5 +4 y_1_2 10 +4 t 14 +4 x_1_2 16 +4 t 18 +4 x_1_2 20 +4 x_1_2 25 +4 y_1_2 29 +4 t 31 +4 y_1_2 33 +4 y_1_2 38 +4 t 42 +4 x_1_2 43 +4 y_1_2 44 +4 t 46 +4 y_1_2 47 +4 y_1_2 48 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 cz 44 45 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 t 5 +5 x_1_2 6 +5 y_1_2 9 +5 t 10 +5 x_1_2 13 +5 x_1_2 15 +5 x_1_2 19 +5 t 20 +5 y_1_2 24 +5 x_1_2 28 +5 t 29 +5 x_1_2 32 +5 t 33 +5 y_1_2 34 +5 x_1_2 37 +5 t 38 +5 y_1_2 41 +5 t 43 +5 t 47 +5 t 48 +6 cz 21 28 +6 cz 8 15 +6 cz 36 43 +6 cz 23 30 +6 cz 10 17 +6 cz 38 45 +6 cz 25 32 +6 cz 12 19 +6 cz 40 47 +6 cz 27 34 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 t 6 +6 y_1_2 7 +6 t 9 +6 x_1_2 11 +6 t 13 +6 x_1_2 16 +6 x_1_2 22 +6 t 24 +6 y_1_2 26 +6 x_1_2 31 +6 x_1_2 35 +6 t 37 +6 y_1_2 39 +6 t 41 +6 x_1_2 44 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 cz 45 46 +7 t 2 +7 t 7 +7 y_1_2 10 +7 t 11 +7 y_1_2 15 +7 t 16 +7 x_1_2 19 +7 x_1_2 21 +7 x_1_2 25 +7 y_1_2 28 +7 y_1_2 30 +7 x_1_2 34 +7 t 35 +7 x_1_2 38 +7 t 39 +7 x_1_2 43 +7 t 44 +7 x_1_2 47 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 x_1_2 4 +8 y_1_2 9 +8 y_1_2 13 +8 t 15 +8 y_1_2 17 +8 t 19 +8 y_1_2 22 +8 y_1_2 26 +8 t 28 +8 t 30 +8 x_1_2 32 +8 t 34 +8 x_1_2 37 +8 y_1_2 41 +8 t 43 +8 y_1_2 45 +8 x_1_2 46 +8 t 47 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 cz 42 43 +9 cz 46 47 +9 y_1_2 3 +9 y_1_2 8 +9 y_1_2 12 +9 t 13 +9 x_1_2 16 +9 t 17 +9 x_1_2 20 +9 x_1_2 21 +9 t 22 +9 x_1_2 25 +9 t 26 +9 x_1_2 27 +9 y_1_2 31 +9 x_1_2 36 +9 x_1_2 40 +9 t 41 +9 t 45 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 +10 h 42 +10 h 43 +10 h 44 +10 h 45 +10 h 46 +10 h 47 +10 h 48 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_5.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_5.txt new file mode 100644 index 0000000..318c97f --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_5.txt @@ -0,0 +1,365 @@ +49 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +0 h 42 +0 h 43 +0 h 44 +0 h 45 +0 h 46 +0 h 47 +0 h 48 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 cz 42 43 +1 cz 46 47 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +1 t 44 +1 t 45 +1 t 48 +2 cz 7 14 +2 cz 35 42 +2 cz 22 29 +2 cz 9 16 +2 cz 37 44 +2 cz 24 31 +2 cz 11 18 +2 cz 39 46 +2 cz 26 33 +2 cz 13 20 +2 cz 41 48 +2 y_1_2 0 +2 y_1_2 1 +2 y_1_2 4 +2 y_1_2 5 +2 y_1_2 10 +2 y_1_2 15 +2 x_1_2 19 +2 x_1_2 23 +2 y_1_2 28 +2 y_1_2 32 +2 y_1_2 38 +2 x_1_2 43 +2 x_1_2 47 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 cz 43 44 +3 cz 47 48 +3 t 0 +3 t 4 +3 x_1_2 7 +3 y_1_2 9 +3 y_1_2 13 +3 x_1_2 14 +3 x_1_2 18 +3 x_1_2 22 +3 t 23 +3 y_1_2 26 +3 t 28 +3 y_1_2 31 +3 t 32 +3 x_1_2 35 +3 y_1_2 37 +3 x_1_2 41 +3 y_1_2 42 +3 x_1_2 46 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 x_1_2 1 +4 y_1_2 5 +4 x_1_2 10 +4 t 14 +4 x_1_2 16 +4 t 18 +4 y_1_2 20 +4 y_1_2 25 +4 x_1_2 29 +4 t 31 +4 y_1_2 33 +4 y_1_2 38 +4 t 42 +4 y_1_2 43 +4 x_1_2 44 +4 t 46 +4 y_1_2 47 +4 y_1_2 48 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 cz 44 45 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 t 5 +5 x_1_2 6 +5 x_1_2 9 +5 t 10 +5 x_1_2 13 +5 x_1_2 15 +5 x_1_2 19 +5 t 20 +5 x_1_2 24 +5 y_1_2 28 +5 t 29 +5 x_1_2 32 +5 t 33 +5 y_1_2 34 +5 x_1_2 37 +5 t 38 +5 x_1_2 41 +5 t 43 +5 t 47 +5 t 48 +6 cz 21 28 +6 cz 8 15 +6 cz 36 43 +6 cz 23 30 +6 cz 10 17 +6 cz 38 45 +6 cz 25 32 +6 cz 12 19 +6 cz 40 47 +6 cz 27 34 +6 t 0 +6 y_1_2 2 +6 x_1_2 3 +6 t 4 +6 t 6 +6 x_1_2 7 +6 t 9 +6 x_1_2 11 +6 t 13 +6 y_1_2 16 +6 x_1_2 22 +6 t 24 +6 y_1_2 26 +6 x_1_2 31 +6 y_1_2 35 +6 t 37 +6 y_1_2 39 +6 t 41 +6 x_1_2 44 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 cz 45 46 +7 t 2 +7 t 7 +7 y_1_2 10 +7 t 11 +7 x_1_2 15 +7 t 16 +7 y_1_2 19 +7 x_1_2 21 +7 x_1_2 25 +7 x_1_2 28 +7 y_1_2 30 +7 x_1_2 34 +7 t 35 +7 y_1_2 38 +7 t 39 +7 y_1_2 43 +7 t 44 +7 y_1_2 47 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 x_1_2 4 +8 x_1_2 9 +8 y_1_2 13 +8 t 15 +8 y_1_2 17 +8 t 19 +8 x_1_2 22 +8 y_1_2 26 +8 t 28 +8 t 30 +8 y_1_2 32 +8 t 34 +8 y_1_2 37 +8 x_1_2 41 +8 t 43 +8 y_1_2 45 +8 x_1_2 46 +8 t 47 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 cz 42 43 +9 cz 46 47 +9 x_1_2 3 +9 y_1_2 8 +9 y_1_2 12 +9 t 13 +9 x_1_2 16 +9 t 17 +9 y_1_2 20 +9 y_1_2 21 +9 t 22 +9 x_1_2 25 +9 t 26 +9 x_1_2 27 +9 x_1_2 31 +9 x_1_2 36 +9 x_1_2 40 +9 t 41 +9 t 45 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 +10 h 42 +10 h 43 +10 h 44 +10 h 45 +10 h 46 +10 h 47 +10 h 48 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_6.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_6.txt new file mode 100644 index 0000000..87e482d --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_6.txt @@ -0,0 +1,365 @@ +49 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +0 h 42 +0 h 43 +0 h 44 +0 h 45 +0 h 46 +0 h 47 +0 h 48 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 cz 42 43 +1 cz 46 47 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +1 t 44 +1 t 45 +1 t 48 +2 cz 7 14 +2 cz 35 42 +2 cz 22 29 +2 cz 9 16 +2 cz 37 44 +2 cz 24 31 +2 cz 11 18 +2 cz 39 46 +2 cz 26 33 +2 cz 13 20 +2 cz 41 48 +2 y_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 x_1_2 5 +2 x_1_2 10 +2 y_1_2 15 +2 x_1_2 19 +2 y_1_2 23 +2 x_1_2 28 +2 y_1_2 32 +2 x_1_2 38 +2 y_1_2 43 +2 y_1_2 47 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 cz 43 44 +3 cz 47 48 +3 t 0 +3 t 4 +3 x_1_2 7 +3 y_1_2 9 +3 y_1_2 13 +3 x_1_2 14 +3 y_1_2 18 +3 y_1_2 22 +3 t 23 +3 x_1_2 26 +3 t 28 +3 y_1_2 31 +3 t 32 +3 y_1_2 35 +3 y_1_2 37 +3 x_1_2 41 +3 x_1_2 42 +3 y_1_2 46 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 y_1_2 1 +4 x_1_2 5 +4 x_1_2 10 +4 t 14 +4 x_1_2 16 +4 t 18 +4 y_1_2 20 +4 x_1_2 25 +4 y_1_2 29 +4 t 31 +4 y_1_2 33 +4 x_1_2 38 +4 t 42 +4 y_1_2 43 +4 x_1_2 44 +4 t 46 +4 y_1_2 47 +4 y_1_2 48 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 cz 44 45 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 t 5 +5 y_1_2 6 +5 y_1_2 9 +5 t 10 +5 y_1_2 13 +5 x_1_2 15 +5 x_1_2 19 +5 t 20 +5 y_1_2 24 +5 x_1_2 28 +5 t 29 +5 y_1_2 32 +5 t 33 +5 x_1_2 34 +5 y_1_2 37 +5 t 38 +5 y_1_2 41 +5 t 43 +5 t 47 +5 t 48 +6 cz 21 28 +6 cz 8 15 +6 cz 36 43 +6 cz 23 30 +6 cz 10 17 +6 cz 38 45 +6 cz 25 32 +6 cz 12 19 +6 cz 40 47 +6 cz 27 34 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 t 6 +6 x_1_2 7 +6 t 9 +6 x_1_2 11 +6 t 13 +6 x_1_2 16 +6 x_1_2 22 +6 t 24 +6 x_1_2 26 +6 y_1_2 31 +6 y_1_2 35 +6 t 37 +6 x_1_2 39 +6 t 41 +6 y_1_2 44 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 cz 45 46 +7 t 2 +7 t 7 +7 x_1_2 10 +7 t 11 +7 x_1_2 15 +7 t 16 +7 y_1_2 19 +7 y_1_2 21 +7 x_1_2 25 +7 x_1_2 28 +7 x_1_2 30 +7 x_1_2 34 +7 t 35 +7 y_1_2 38 +7 t 39 +7 x_1_2 43 +7 t 44 +7 x_1_2 47 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 y_1_2 4 +8 x_1_2 9 +8 y_1_2 13 +8 t 15 +8 x_1_2 17 +8 t 19 +8 y_1_2 22 +8 y_1_2 26 +8 t 28 +8 t 30 +8 y_1_2 32 +8 t 34 +8 y_1_2 37 +8 x_1_2 41 +8 t 43 +8 y_1_2 45 +8 y_1_2 46 +8 t 47 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 cz 42 43 +9 cz 46 47 +9 y_1_2 3 +9 x_1_2 8 +9 y_1_2 12 +9 t 13 +9 x_1_2 16 +9 t 17 +9 x_1_2 20 +9 y_1_2 21 +9 t 22 +9 x_1_2 25 +9 t 26 +9 x_1_2 27 +9 y_1_2 31 +9 x_1_2 36 +9 x_1_2 40 +9 t 41 +9 t 45 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 +10 h 42 +10 h 43 +10 h 44 +10 h 45 +10 h 46 +10 h 47 +10 h 48 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_7.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_7.txt new file mode 100644 index 0000000..9e1b4c2 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_7.txt @@ -0,0 +1,365 @@ +49 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +0 h 42 +0 h 43 +0 h 44 +0 h 45 +0 h 46 +0 h 47 +0 h 48 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 cz 42 43 +1 cz 46 47 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +1 t 44 +1 t 45 +1 t 48 +2 cz 7 14 +2 cz 35 42 +2 cz 22 29 +2 cz 9 16 +2 cz 37 44 +2 cz 24 31 +2 cz 11 18 +2 cz 39 46 +2 cz 26 33 +2 cz 13 20 +2 cz 41 48 +2 x_1_2 0 +2 x_1_2 1 +2 y_1_2 4 +2 x_1_2 5 +2 y_1_2 10 +2 x_1_2 15 +2 x_1_2 19 +2 y_1_2 23 +2 x_1_2 28 +2 x_1_2 32 +2 x_1_2 38 +2 x_1_2 43 +2 x_1_2 47 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 cz 43 44 +3 cz 47 48 +3 t 0 +3 t 4 +3 y_1_2 7 +3 x_1_2 9 +3 x_1_2 13 +3 y_1_2 14 +3 y_1_2 18 +3 y_1_2 22 +3 t 23 +3 x_1_2 26 +3 t 28 +3 y_1_2 31 +3 t 32 +3 x_1_2 35 +3 y_1_2 37 +3 x_1_2 41 +3 x_1_2 42 +3 x_1_2 46 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 x_1_2 1 +4 y_1_2 5 +4 x_1_2 10 +4 t 14 +4 y_1_2 16 +4 t 18 +4 y_1_2 20 +4 x_1_2 25 +4 y_1_2 29 +4 t 31 +4 x_1_2 33 +4 x_1_2 38 +4 t 42 +4 x_1_2 43 +4 y_1_2 44 +4 t 46 +4 x_1_2 47 +4 x_1_2 48 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 cz 44 45 +5 y_1_2 0 +5 t 1 +5 x_1_2 4 +5 t 5 +5 x_1_2 6 +5 y_1_2 9 +5 t 10 +5 y_1_2 13 +5 x_1_2 15 +5 y_1_2 19 +5 t 20 +5 y_1_2 24 +5 y_1_2 28 +5 t 29 +5 y_1_2 32 +5 t 33 +5 x_1_2 34 +5 y_1_2 37 +5 t 38 +5 x_1_2 41 +5 t 43 +5 t 47 +5 t 48 +6 cz 21 28 +6 cz 8 15 +6 cz 36 43 +6 cz 23 30 +6 cz 10 17 +6 cz 38 45 +6 cz 25 32 +6 cz 12 19 +6 cz 40 47 +6 cz 27 34 +6 t 0 +6 x_1_2 2 +6 y_1_2 3 +6 t 4 +6 t 6 +6 x_1_2 7 +6 t 9 +6 x_1_2 11 +6 t 13 +6 x_1_2 16 +6 y_1_2 22 +6 t 24 +6 y_1_2 26 +6 y_1_2 31 +6 y_1_2 35 +6 t 37 +6 x_1_2 39 +6 t 41 +6 y_1_2 44 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 cz 45 46 +7 t 2 +7 t 7 +7 y_1_2 10 +7 t 11 +7 y_1_2 15 +7 t 16 +7 x_1_2 19 +7 y_1_2 21 +7 y_1_2 25 +7 x_1_2 28 +7 y_1_2 30 +7 x_1_2 34 +7 t 35 +7 y_1_2 38 +7 t 39 +7 y_1_2 43 +7 t 44 +7 y_1_2 47 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 y_1_2 4 +8 x_1_2 9 +8 x_1_2 13 +8 t 15 +8 y_1_2 17 +8 t 19 +8 x_1_2 22 +8 x_1_2 26 +8 t 28 +8 t 30 +8 x_1_2 32 +8 t 34 +8 x_1_2 37 +8 x_1_2 41 +8 t 43 +8 y_1_2 45 +8 x_1_2 46 +8 t 47 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 cz 42 43 +9 cz 46 47 +9 x_1_2 3 +9 x_1_2 8 +9 y_1_2 12 +9 t 13 +9 x_1_2 16 +9 t 17 +9 x_1_2 20 +9 y_1_2 21 +9 t 22 +9 y_1_2 25 +9 t 26 +9 y_1_2 27 +9 y_1_2 31 +9 x_1_2 36 +9 x_1_2 40 +9 t 41 +9 t 45 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 +10 h 42 +10 h 43 +10 h 44 +10 h 45 +10 h 46 +10 h 47 +10 h 48 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_8.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_8.txt new file mode 100644 index 0000000..052a288 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_8.txt @@ -0,0 +1,365 @@ +49 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +0 h 42 +0 h 43 +0 h 44 +0 h 45 +0 h 46 +0 h 47 +0 h 48 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 cz 42 43 +1 cz 46 47 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +1 t 44 +1 t 45 +1 t 48 +2 cz 7 14 +2 cz 35 42 +2 cz 22 29 +2 cz 9 16 +2 cz 37 44 +2 cz 24 31 +2 cz 11 18 +2 cz 39 46 +2 cz 26 33 +2 cz 13 20 +2 cz 41 48 +2 x_1_2 0 +2 y_1_2 1 +2 x_1_2 4 +2 y_1_2 5 +2 x_1_2 10 +2 x_1_2 15 +2 y_1_2 19 +2 x_1_2 23 +2 y_1_2 28 +2 x_1_2 32 +2 x_1_2 38 +2 x_1_2 43 +2 x_1_2 47 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 cz 43 44 +3 cz 47 48 +3 t 0 +3 t 4 +3 y_1_2 7 +3 x_1_2 9 +3 x_1_2 13 +3 x_1_2 14 +3 x_1_2 18 +3 x_1_2 22 +3 t 23 +3 y_1_2 26 +3 t 28 +3 x_1_2 31 +3 t 32 +3 x_1_2 35 +3 x_1_2 37 +3 y_1_2 41 +3 x_1_2 42 +3 y_1_2 46 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 x_1_2 1 +4 y_1_2 5 +4 x_1_2 10 +4 t 14 +4 y_1_2 16 +4 t 18 +4 x_1_2 20 +4 y_1_2 25 +4 y_1_2 29 +4 t 31 +4 y_1_2 33 +4 x_1_2 38 +4 t 42 +4 x_1_2 43 +4 y_1_2 44 +4 t 46 +4 x_1_2 47 +4 x_1_2 48 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 cz 44 45 +5 y_1_2 0 +5 t 1 +5 y_1_2 4 +5 t 5 +5 y_1_2 6 +5 y_1_2 9 +5 t 10 +5 x_1_2 13 +5 x_1_2 15 +5 y_1_2 19 +5 t 20 +5 x_1_2 24 +5 y_1_2 28 +5 t 29 +5 x_1_2 32 +5 t 33 +5 y_1_2 34 +5 y_1_2 37 +5 t 38 +5 y_1_2 41 +5 t 43 +5 t 47 +5 t 48 +6 cz 21 28 +6 cz 8 15 +6 cz 36 43 +6 cz 23 30 +6 cz 10 17 +6 cz 38 45 +6 cz 25 32 +6 cz 12 19 +6 cz 40 47 +6 cz 27 34 +6 t 0 +6 y_1_2 2 +6 y_1_2 3 +6 t 4 +6 t 6 +6 x_1_2 7 +6 t 9 +6 x_1_2 11 +6 t 13 +6 y_1_2 16 +6 y_1_2 22 +6 t 24 +6 x_1_2 26 +6 y_1_2 31 +6 y_1_2 35 +6 t 37 +6 y_1_2 39 +6 t 41 +6 x_1_2 44 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 cz 45 46 +7 t 2 +7 t 7 +7 x_1_2 10 +7 t 11 +7 x_1_2 15 +7 t 16 +7 x_1_2 19 +7 x_1_2 21 +7 x_1_2 25 +7 x_1_2 28 +7 y_1_2 30 +7 y_1_2 34 +7 t 35 +7 x_1_2 38 +7 t 39 +7 x_1_2 43 +7 t 44 +7 x_1_2 47 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 y_1_2 4 +8 y_1_2 9 +8 x_1_2 13 +8 t 15 +8 y_1_2 17 +8 t 19 +8 x_1_2 22 +8 x_1_2 26 +8 t 28 +8 t 30 +8 y_1_2 32 +8 t 34 +8 x_1_2 37 +8 x_1_2 41 +8 t 43 +8 x_1_2 45 +8 x_1_2 46 +8 t 47 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 cz 42 43 +9 cz 46 47 +9 x_1_2 3 +9 x_1_2 8 +9 x_1_2 12 +9 t 13 +9 y_1_2 16 +9 t 17 +9 x_1_2 20 +9 x_1_2 21 +9 t 22 +9 x_1_2 25 +9 t 26 +9 x_1_2 27 +9 y_1_2 31 +9 x_1_2 36 +9 y_1_2 40 +9 t 41 +9 t 45 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 +10 h 42 +10 h 43 +10 h 44 +10 h 45 +10 h 46 +10 h 47 +10 h 48 diff --git a/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_9.txt b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_9.txt new file mode 100644 index 0000000..2c018e3 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/example/rectangular/depth10/inst_7x7_10_9.txt @@ -0,0 +1,365 @@ +49 +0 h 0 +0 h 1 +0 h 2 +0 h 3 +0 h 4 +0 h 5 +0 h 6 +0 h 7 +0 h 8 +0 h 9 +0 h 10 +0 h 11 +0 h 12 +0 h 13 +0 h 14 +0 h 15 +0 h 16 +0 h 17 +0 h 18 +0 h 19 +0 h 20 +0 h 21 +0 h 22 +0 h 23 +0 h 24 +0 h 25 +0 h 26 +0 h 27 +0 h 28 +0 h 29 +0 h 30 +0 h 31 +0 h 32 +0 h 33 +0 h 34 +0 h 35 +0 h 36 +0 h 37 +0 h 38 +0 h 39 +0 h 40 +0 h 41 +0 h 42 +0 h 43 +0 h 44 +0 h 45 +0 h 46 +0 h 47 +0 h 48 +1 cz 0 1 +1 cz 4 5 +1 cz 9 10 +1 cz 14 15 +1 cz 18 19 +1 cz 23 24 +1 cz 28 29 +1 cz 32 33 +1 cz 37 38 +1 cz 42 43 +1 cz 46 47 +1 t 2 +1 t 3 +1 t 6 +1 t 7 +1 t 8 +1 t 11 +1 t 12 +1 t 13 +1 t 16 +1 t 17 +1 t 20 +1 t 21 +1 t 22 +1 t 25 +1 t 26 +1 t 27 +1 t 30 +1 t 31 +1 t 34 +1 t 35 +1 t 36 +1 t 39 +1 t 40 +1 t 41 +1 t 44 +1 t 45 +1 t 48 +2 cz 7 14 +2 cz 35 42 +2 cz 22 29 +2 cz 9 16 +2 cz 37 44 +2 cz 24 31 +2 cz 11 18 +2 cz 39 46 +2 cz 26 33 +2 cz 13 20 +2 cz 41 48 +2 x_1_2 0 +2 x_1_2 1 +2 x_1_2 4 +2 y_1_2 5 +2 x_1_2 10 +2 y_1_2 15 +2 y_1_2 19 +2 x_1_2 23 +2 y_1_2 28 +2 y_1_2 32 +2 x_1_2 38 +2 x_1_2 43 +2 y_1_2 47 +3 cz 1 2 +3 cz 5 6 +3 cz 10 11 +3 cz 15 16 +3 cz 19 20 +3 cz 24 25 +3 cz 29 30 +3 cz 33 34 +3 cz 38 39 +3 cz 43 44 +3 cz 47 48 +3 t 0 +3 t 4 +3 x_1_2 7 +3 y_1_2 9 +3 x_1_2 13 +3 x_1_2 14 +3 x_1_2 18 +3 y_1_2 22 +3 t 23 +3 y_1_2 26 +3 t 28 +3 y_1_2 31 +3 t 32 +3 y_1_2 35 +3 x_1_2 37 +3 y_1_2 41 +3 x_1_2 42 +3 x_1_2 46 +4 cz 0 7 +4 cz 28 35 +4 cz 15 22 +4 cz 2 9 +4 cz 30 37 +4 cz 17 24 +4 cz 4 11 +4 cz 32 39 +4 cz 19 26 +4 cz 6 13 +4 cz 34 41 +4 y_1_2 1 +4 y_1_2 5 +4 x_1_2 10 +4 t 14 +4 x_1_2 16 +4 t 18 +4 x_1_2 20 +4 x_1_2 25 +4 x_1_2 29 +4 t 31 +4 y_1_2 33 +4 x_1_2 38 +4 t 42 +4 y_1_2 43 +4 y_1_2 44 +4 t 46 +4 x_1_2 47 +4 x_1_2 48 +5 cz 2 3 +5 cz 7 8 +5 cz 11 12 +5 cz 16 17 +5 cz 21 22 +5 cz 25 26 +5 cz 30 31 +5 cz 35 36 +5 cz 39 40 +5 cz 44 45 +5 x_1_2 0 +5 t 1 +5 x_1_2 4 +5 t 5 +5 x_1_2 6 +5 y_1_2 9 +5 t 10 +5 x_1_2 13 +5 y_1_2 15 +5 x_1_2 19 +5 t 20 +5 y_1_2 24 +5 y_1_2 28 +5 t 29 +5 x_1_2 32 +5 t 33 +5 x_1_2 34 +5 x_1_2 37 +5 t 38 +5 y_1_2 41 +5 t 43 +5 t 47 +5 t 48 +6 cz 21 28 +6 cz 8 15 +6 cz 36 43 +6 cz 23 30 +6 cz 10 17 +6 cz 38 45 +6 cz 25 32 +6 cz 12 19 +6 cz 40 47 +6 cz 27 34 +6 t 0 +6 x_1_2 2 +6 x_1_2 3 +6 t 4 +6 t 6 +6 x_1_2 7 +6 t 9 +6 y_1_2 11 +6 t 13 +6 x_1_2 16 +6 x_1_2 22 +6 t 24 +6 y_1_2 26 +6 x_1_2 31 +6 y_1_2 35 +6 t 37 +6 x_1_2 39 +6 t 41 +6 y_1_2 44 +7 cz 3 4 +7 cz 8 9 +7 cz 12 13 +7 cz 17 18 +7 cz 22 23 +7 cz 26 27 +7 cz 31 32 +7 cz 36 37 +7 cz 40 41 +7 cz 45 46 +7 t 2 +7 t 7 +7 y_1_2 10 +7 t 11 +7 x_1_2 15 +7 t 16 +7 y_1_2 19 +7 y_1_2 21 +7 x_1_2 25 +7 x_1_2 28 +7 y_1_2 30 +7 y_1_2 34 +7 t 35 +7 x_1_2 38 +7 t 39 +7 y_1_2 43 +7 t 44 +7 y_1_2 47 +8 cz 14 21 +8 cz 1 8 +8 cz 29 36 +8 cz 16 23 +8 cz 3 10 +8 cz 31 38 +8 cz 18 25 +8 cz 5 12 +8 cz 33 40 +8 cz 20 27 +8 x_1_2 4 +8 y_1_2 9 +8 x_1_2 13 +8 t 15 +8 x_1_2 17 +8 t 19 +8 y_1_2 22 +8 y_1_2 26 +8 t 28 +8 t 30 +8 y_1_2 32 +8 t 34 +8 x_1_2 37 +8 x_1_2 41 +8 t 43 +8 y_1_2 45 +8 y_1_2 46 +8 t 47 +9 cz 0 1 +9 cz 4 5 +9 cz 9 10 +9 cz 14 15 +9 cz 18 19 +9 cz 23 24 +9 cz 28 29 +9 cz 32 33 +9 cz 37 38 +9 cz 42 43 +9 cz 46 47 +9 x_1_2 3 +9 x_1_2 8 +9 y_1_2 12 +9 t 13 +9 y_1_2 16 +9 t 17 +9 x_1_2 20 +9 y_1_2 21 +9 t 22 +9 x_1_2 25 +9 t 26 +9 x_1_2 27 +9 x_1_2 31 +9 x_1_2 36 +9 x_1_2 40 +9 t 41 +9 t 45 +10 h 0 +10 h 1 +10 h 2 +10 h 3 +10 h 4 +10 h 5 +10 h 6 +10 h 7 +10 h 8 +10 h 9 +10 h 10 +10 h 11 +10 h 12 +10 h 13 +10 h 14 +10 h 15 +10 h 16 +10 h 17 +10 h 18 +10 h 19 +10 h 20 +10 h 21 +10 h 22 +10 h 23 +10 h 24 +10 h 25 +10 h 26 +10 h 27 +10 h 28 +10 h 29 +10 h 30 +10 h 31 +10 h 32 +10 h 33 +10 h 34 +10 h 35 +10 h 36 +10 h 37 +10 h 38 +10 h 39 +10 h 40 +10 h 41 +10 h 42 +10 h 43 +10 h 44 +10 h 45 +10 h 46 +10 h 47 +10 h 48 diff --git a/paddle_quantum/mbqc/GRCS/supremacy.py b/paddle_quantum/mbqc/GRCS/supremacy.py new file mode 100644 index 0000000..540d512 --- /dev/null +++ b/paddle_quantum/mbqc/GRCS/supremacy.py @@ -0,0 +1,193 @@ +# 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. + +""" +Use MBQC to simulate Google quantum GRCS circuits and compare with Qiskit simulator. +To prove our simulation advantage in quantum shallow circuit simulation +""" + +import os +from time import perf_counter +from paddle_quantum.mbqc.utils import plot_results, write_running_data, read_running_data +from paddle_quantum.mbqc.qobject import Circuit +from paddle_quantum.mbqc.simulator import simulate_by_mbqc +from paddle import to_tensor +from numpy import pi +from qiskit import QuantumCircuit, transpile, Aer + +__all__ = [ + "grcs_circuit", + "cir_mbqc", + "cir_qiskit", + "grcs", + "compare_time" +] + + +def grcs_circuit(input_cir, cir): + r"""定义 GRCS 电路。 + + Args: + input_cir (list): 根据 ``".txt"`` 文件处理后得到的输入电路的列表，列表中记录了电路信息 + cir (Circuit or QuantumCircuit): Circuit 为 MBQC 电路模块中的类，QuantumCircuit 为 "Qiskit" 电路模型中的类， + 二者都具有类似的量子门输入方式 + + Returns: + float: MBQC 模型下运行电路需要的时间 + """ + half_pi = pi / 2 + half_pi_tensor = to_tensor([pi / 2], dtype='float64') + for gate in input_cir[1:]: + + # Qiskit input + if not isinstance(cir, Circuit): + if gate[1] == 'h': + cir.h(int(gate[2])) + elif gate[1] == 'cz': + cir.cz(int(gate[2]), int(gate[3])) + elif gate[1] == 't': + cir.t(int(gate[2])) + elif gate[1] == 'x_1_2': + cir.rx(half_pi, int(gate[2])) + elif gate[1] == 'y_1_2': + cir.ry(half_pi, int(gate[2])) + + # MBQC input + # Note: MBQC model start from plus state by default, so we can omit the first layer of Hadamard gates + # in the circuit; We can also merge the last layer of Hadamard gates with the final Z measurements + # and replace them by X measurements. + else: + if gate[1] == 'cz': + cir.cz([int(gate[2]), int(gate[3])]) + elif gate[1] == 't': + cir.t(int(gate[2])) + elif gate[1] == 'x_1_2': + cir.rx(half_pi_tensor, int(gate[2])) + elif gate[1] == 'y_1_2': + cir.ry(half_pi_tensor, int(gate[2])) + return cir + + +def cir_mbqc(input_cir): + r"""运用 MBQC 模型模拟谷歌量子霸权电路并运算计时。 + + Args: + input_cir (list): 根据 ``".txt"`` 文件处理后得到的输入电路的列表，列表中记录了电路信息 + + Returns: + float: MBQC 模型下运行电路需要的时间 + """ + qubit_number = int(input_cir[0][0]) + cir = Circuit(qubit_number) + cir = grcs_circuit(input_cir, cir) + + x_measurement = [to_tensor([0], dtype='float64'), 'XY', [], []] + for output_qubit in range(qubit_number): + cir.measure(output_qubit, x_measurement) + + mbqc_start_time = perf_counter() + simulate_by_mbqc(cir) + mbqc_end_time = perf_counter() + return mbqc_end_time - mbqc_start_time + + +def cir_qiskit(input_cir): + r""" 运用 Qiskit 模拟器模拟谷歌量子霸权电路并运算计时。 + + Args: + input_cir (list): 根据 ``".txt"`` 文件处理后得到的输入电路的列表，列表中记录了电路信息 + + Returns: + float: Qiskit 模拟谷歌量子霸权电路需要的时间 + """ + qubit_number = int(input_cir[0][0]) + cir = QuantumCircuit(qubit_number, qubit_number) + cir = grcs_circuit(input_cir, cir) + cir.measure(list(range(qubit_number)), list(range(qubit_number))) + + # Set the simulator + # Note: We can choose either "aer_simulator_statevector" or "aer_simulator_matrix_product_state" as simulator + # and choose the minimum time of Qiskit simulation to compare with MBQC + + # We use "aer_simulator_statevector" for those circuits with qubits number lower than 25. + if qubit_number <= 25: + which_simulator = 'aer_simulator_statevector' + # And use "aer_simulator_matrix_product_state" for for those circuits with qubits number higher than 25 + else: + which_simulator = 'aer_simulator_matrix_product_state' + + simulator = Aer.get_backend(which_simulator) + compiled_circuit = transpile(cir, simulator) + + # Run with Qiskit + qiskit_start_time = perf_counter() + job = simulator.run(compiled_circuit, shots=1) + result = job.result() + result.get_counts(0) + qiskit_end_time = perf_counter() + + return qiskit_end_time - qiskit_start_time + + +def grcs(): + r"""定义 GRCS 主函数。 + + 主函数分别调用两个模拟方式来模拟测试用例，并写入运行时间。 + + Note: + 我们选取的电路为谷歌量子霸权电路图 [https://github.com/sboixo/GRCS] 中的部分浅层量子电路， + 对于深层的量子电路，MBQC 的模拟思路依然存在计算瓶颈。 + 在使用 Qiskit 进行模拟时，我们选取了 "aer_simulator_statevector" 和 "aer_simulator_matrix_product_state" 中时间较短 + 的模拟器作为 Qiskit 对电路的运行时间，与 MBQC 模拟器运行时间对比。 + """ + # Initialize + CRED = '\033[91m' + CEND = '\033[0m' + egs = os.listdir(os.path.dirname(__file__) + "/example/rectangular/depth10") + time_text = open("record_time.txt", 'w') + + # Start examples + for eg in egs: + + input_cir = [] + with open(os.path.dirname(__file__) + "/example/rectangular/depth10/" + eg, 'r') as file: + for line in file: + input_cir.append(list(line.strip('\n').split(' '))) + width = input_cir[0][0] + + mbqc_time = cir_mbqc(input_cir) + qiskit_time = cir_qiskit(input_cir) + + print(CRED + "The current example is:" + CEND, eg) + print("The qubit number is: " + width) + print(CRED + "MBQC running time is:" + CEND, mbqc_time, "s") + print(CRED + "Qiskit running time is:" + CEND, qiskit_time, "s") + print("--------------------------------------------------------------------------------------------") + + write_running_data(time_text, eg, width, mbqc_time, qiskit_time) + + time_text.close() + + +def compare_time(): + r"""定义画图函数。 + + 画图函数读取测试用例的时间，并用 matplotlib 画出来。 + """ + time_comparison = read_running_data("record_time.txt") + bar_labels = ['MBQC', 'Qiskit'] + title = "GRCS Example: Time comparison between MBQC and Qiskit" + xlabel = "Index of test example" + ylabel = "Running time (s)" + plot_results(time_comparison, bar_labels, title, xlabel, ylabel) diff --git a/paddle_quantum/mbqc/QAOA/maxcut.py b/paddle_quantum/mbqc/QAOA/maxcut.py index 1eb8377..69a63c0 100644 --- a/paddle_quantum/mbqc/QAOA/maxcut.py +++ b/paddle_quantum/mbqc/QAOA/maxcut.py @@ -309,23 +309,25 @@ def circuit_maxcut(SEED, GRAPH, DEPTH, LR, ITR, EPOCH, SHOTS): # Initialize seed(SEED) - pq_net = Circuit_QAOA_Net(DEPTH) + pq_net = Circuit_QAOA_Net(DEPTH, GRAPH, H_D_list) opt = optimizer.Adam(learning_rate=LR, parameters=pq_net.parameters()) for epoch in range(EPOCH): for itr in range(1, ITR + 1): - loss, cir = pq_net(GRAPH, H_D_list) + loss, state = pq_net() loss.backward() opt.minimize(loss) opt.clear_grad() if itr % 10 == 0: print("iter:", itr, " loss_cir:", "%.4f" % loss.numpy()) - print("Optimal parameter gamma: ", pq_net.gamma.numpy()) - print("Optimal parameter beta: ", pq_net.beta.numpy()) + gamma = pq_net.parameters()[0] + beta = pq_net.parameters()[1] + print("Optimal parameter gamma: ", gamma.numpy()) + print("Optimal parameter beta: ", beta.numpy()) end_time_PQ = perf_counter() print("Circuit running time: ", end_time_PQ - start_time_PQ) # Obtain the bit string - prob_measure = cir.measure(shots=SHOTS, plot=False) + prob_measure = state.measure(shots=SHOTS, plot=False) cut_bitstring = max(prob_measure, key=prob_measure.get) plot_solution(GRAPH, cut_bitstring) return cut_bitstring diff --git a/paddle_quantum/mbqc/QAOA/qaoa.py b/paddle_quantum/mbqc/QAOA/qaoa.py index d61eefe..469fd48 100644 --- a/paddle_quantum/mbqc/QAOA/qaoa.py +++ b/paddle_quantum/mbqc/QAOA/qaoa.py @@ -21,9 +21,9 @@ from numpy import pi, random, log2 from paddle import to_tensor, real, abs, zeros, t, conj, matmul, multiply from paddle import nn +import paddle_quantum from paddle_quantum.mbqc.utils import kron, basis, permute_systems from paddle_quantum.mbqc.simulator import MBQC -from paddle_quantum.circuit import UAnsatz __all__ = [ "get_all_indices", @@ -551,7 +551,7 @@ def forward(self, poly): # Get cost Hamiltonian HC = get_cost_hamiltonian(poly) # Calculate loss - loss = - expecval(vec_out, HC) + loss = -expecval(vec_out, HC) return loss, vec_out @@ -570,7 +570,7 @@ def circuit_qaoa(graph, depth, gamma, beta): vertices = graph[0] edges = graph[1] qubit_number = len(vertices) - cir = UAnsatz(qubit_number) + cir = paddle_quantum.ansatz.Circuit(qubit_number) cir.superposition_layer() for layer in range(depth): for (u, v) in edges: @@ -584,7 +584,7 @@ def circuit_qaoa(graph, depth, gamma, beta): return cir -class Circuit_QAOA_Net(nn.Layer): +class Circuit_QAOA_Net(paddle_quantum.gate.Gate): r"""定义电路模型下的 QAOA 优化网络，用于实例化一个电路模型下 QAOA 的优化网络。 Attributes: @@ -595,28 +595,25 @@ class Circuit_QAOA_Net(nn.Layer): Tensor: 输出量子态列向量 """ - def __init__(self, - depth, # depth - dtype="float64" - ): + def __init__(self, depth, graph, H): r"""定义电路模型下的 QAOA 优化网络。 Args: depth (int): QAOA 算法深度 """ - super(Circuit_QAOA_Net, self).__init__() - - self.p = depth - self.gamma = self.create_parameter(shape=[self.p], - default_initializer=nn.initializer.Uniform(low=0.0, high=2 * pi), - dtype=dtype, - is_bias=False) - self.beta = self.create_parameter(shape=[self.p], - default_initializer=nn.initializer.Uniform(low=0.0, high=2 * pi), - dtype=dtype, - is_bias=False) - - def forward(self, graph, H): + super().__init__() + V = graph[0] + E = graph[1] + V = [item - 1for item in V] + E = [(edge[0] - 1, edge[1] - 1) for edge in E] + n = len(V) + self.net = paddle_quantum.ansatz.Circuit(n) + self.net.superposition_layer() + self.net.qaoa_layer(E, V, depth) + hamiltonian = paddle_quantum.Hamiltonian(H) + self.loss_func = paddle_quantum.loss.ExpecVal(hamiltonian) + + def forward(self): r"""定义优化网络的前向传播机制。 Args: @@ -627,9 +624,6 @@ def forward(self, graph, H): Tensor: 输出损失函数 UAnsatz: 电路模型的 UAnsatz 电路 """ - cir_gamma = multiply(self.gamma, to_tensor([-1], dtype='float64')) - cir_beta = multiply(self.beta, to_tensor([2], dtype='float64')) - cir = circuit_qaoa(graph, self.p, cir_gamma, cir_beta) - cir.run_state_vector() - loss = -cir.expecval(H) - return loss, cir + state = self.net() + loss = self.loss_func(state) + return loss, state diff --git a/paddle_quantum/mbqc/QKernel/qkernel.py b/paddle_quantum/mbqc/QKernel/qkernel.py index e66a5e5..5fca2d7 100644 --- a/paddle_quantum/mbqc/QKernel/qkernel.py +++ b/paddle_quantum/mbqc/QKernel/qkernel.py @@ -22,8 +22,8 @@ from time import perf_counter from paddle_quantum.mbqc.simulator import simulate_by_mbqc, sample_by_mbqc from numpy import random +import paddle_quantum from paddle_quantum.mbqc.qobject import Circuit -from paddle_quantum.circuit import UAnsatz __all__ = [ "qkernel_circuit", @@ -47,29 +47,47 @@ def qkernel_circuit(alpha, cir): """ qubit_number = alpha.shape[0] - # U - for i in range(qubit_number): - if not isinstance(cir, Circuit): - cir.h(i) - cir.rx(alpha[i, 1], i) - cir.rz(alpha[i, 2], i) - cir.rx(alpha[i, 3], i) - # cz - for i in range(qubit_number - 1): - cir.h(i + 1) - cir.cnot([i, i + 1]) - cir.h(i + 1) - - # U^{\dagger} - for i in range(qubit_number): - cir.rx(alpha[i, 5], i) - cir.rz(alpha[i, 6], i) - cir.rx(alpha[i, 7], i) - cir.h(i) - - # Measure if isinstance(cir, Circuit): + # U + for i in range(qubit_number): + if not isinstance(cir, Circuit): + cir.h(i) + cir.rx(alpha[i, 1], i) + cir.rz(alpha[i, 2], i) + cir.rx(alpha[i, 3], i) + # cz + for i in range(qubit_number - 1): + cir.h(i + 1) + cir.cnot([i, i + 1]) + cir.h(i + 1) + + # U^{\dagger} + for i in range(qubit_number): + cir.rx(alpha[i, 5], i) + cir.rz(alpha[i, 6], i) + cir.rx(alpha[i, 7], i) + cir.h(i) cir.measure() + else: + # U + for i in range(qubit_number): + if not isinstance(cir, Circuit): + cir.h(i) + cir.rx(i, param=alpha[i, 1]) + cir.rz(i, param=alpha[i, 2]) + cir.rx(i, param=alpha[i, 3]) + # cz + for i in range(qubit_number - 1): + cir.h(i + 1) + cir.cnot([i, i + 1]) + cir.h(i + 1) + + # U^{\dagger} + for i in range(qubit_number): + cir.rx(i, param=alpha[i, 5]) + cir.rz(i, param=alpha[i, 6]) + cir.rx(i, param=alpha[i, 7]) + cir.h(i) return cir @@ -91,12 +109,12 @@ def cir_uansatz(alpha, shots=1): raise ValueError("the UAnsatz model could not support qubit number larger than 25 on a laptop.") else: - cir = UAnsatz(qubit_number) + cir = paddle_quantum.ansatz.Circuit(qubit_number) cir = qkernel_circuit(alpha, cir) uansatz_start_time = perf_counter() - cir.run_state_vector() - outcome = cir.measure(shots=shots) + state = cir() + outcome = state.measure(shots=shots) uansatz_end_time = perf_counter() # As the outcome dictionary is in a messy order, we need to reorder the outcome diff --git a/paddle_quantum/mbqc/VQSVD/vqsvd.py b/paddle_quantum/mbqc/VQSVD/vqsvd.py index 5c3148e..c9ce18c 100644 --- a/paddle_quantum/mbqc/VQSVD/vqsvd.py +++ b/paddle_quantum/mbqc/VQSVD/vqsvd.py @@ -21,7 +21,7 @@ from time import perf_counter from paddle_quantum.mbqc.simulator import simulate_by_mbqc, sample_by_mbqc from numpy import random -from paddle_quantum.circuit import UAnsatz +import paddle_quantum from paddle_quantum.mbqc.qobject import Circuit __all__ = [ @@ -48,18 +48,21 @@ def vqsvd_circuit(cir, alpha): width = alpha.shape[0] depth = alpha.shape[1] - if not isinstance(cir, Circuit): - for which_qubit in range(width): - cir.h(which_qubit) - - for layer_num in range(depth): - for which_qubit in range(width): - cir.ry(alpha[which_qubit, layer_num], which_qubit) - for which_qubit in range(width - 1): - cir.cnot([which_qubit, which_qubit + 1]) - if isinstance(cir, Circuit): + for layer_num in range(depth): + for which_qubit in range(width): + cir.ry(alpha[which_qubit, layer_num], which_qubit) + for which_qubit in range(width - 1): + cir.cnot([which_qubit, which_qubit + 1]) cir.measure() + else: + for which_qubit in range(width): + cir.h(which_qubit) + for layer_num in range(depth): + for which_qubit in range(width): + cir.ry(which_qubit, param=alpha[which_qubit, layer_num]) + for which_qubit in range(width - 1): + cir.cnot([which_qubit, which_qubit + 1]) return cir @@ -82,13 +85,13 @@ def cir_uansatz(alpha, shots=1): else: # Input information of circuits - cir = UAnsatz(qubit_number) + cir = paddle_quantum.ansatz.Circuit(qubit_number) cir = vqsvd_circuit(cir, alpha) # Start running uansatz_start_time = perf_counter() - cir.run_state_vector() - outcome = cir.measure(shots=shots) + state = cir() + outcome = state.measure(shots=shots) uansatz_end_time = perf_counter() # As the outcome dictionary is in a messy order, we need to reorder the outcome diff --git a/paddle_quantum/qchem/ansatz/__init__.py b/paddle_quantum/operator/__init__.py old mode 100755 new mode 100644 similarity index 75% rename from paddle_quantum/qchem/ansatz/__init__.py rename to paddle_quantum/operator/__init__.py index 7300cef..c21206d --- a/paddle_quantum/qchem/ansatz/__init__.py +++ b/paddle_quantum/operator/__init__.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +# !/usr/bin/env python3 +# Copyright (c) 2022 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. @@ -13,9 +14,7 @@ # limitations under the License. r""" -化学模块的 ansatz +The module of the special quantum operator. """ - -from .hardware_efficient import HardwareEfficientModel -from .rhf import RestrictHartreeFockModel +from .operator import ResetState, PartialState, Collapse \ No newline at end of file diff --git a/paddle_quantum/operator/operator.py b/paddle_quantum/operator/operator.py new file mode 100644 index 0000000..7e500be --- /dev/null +++ b/paddle_quantum/operator/operator.py @@ -0,0 +1,127 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The source file of the class for the special quantum operator. +""" + +import random +import paddle +import paddle_quantum +from ..base import Operator +from typing import Union, Iterable + + +class ResetState(Operator): + r"""The class to reset the quantum state. It will be implemented soon. + """ + def __init__(self): + super().__init__() + + def forward(self, *inputs, **kwargs): + r"""The forward function. + + Returns: + NotImplemented. + """ + return NotImplemented + + +class PartialState(Operator): + r"""The class to obtain the partial quantum state. It will be implemented soon. + """ + def __init__(self): + super().__init__() + + def forward(self, *inputs, **kwargs): + r"""The forward function. + + Returns: + NotImplemented. + """ + return NotImplemented + + +class Collapse(Operator): + r"""The class to compute the collapse of the quantum state. + + Args: + measure_basis: The basis of the measurement. The quantum state will collapse to the corresponding eigenstate. + + Raises: + NotImplementedError: If the basis of measurement is not z. Other bases will be implemented soon. + """ + def __init__(self, measure_basis: Union[Iterable[paddle.Tensor], str]): + super().__init__() + self.measure_basis = [] + if measure_basis == 'z' or measure_basis == 'computational_basis': + basis0 = paddle.to_tensor([[1.0, 0], [0, 0]]) + basis1 = paddle.to_tensor([[0.0, 0], [0, 1]]) + self.measure_basis.append(basis0) + self.measure_basis.append(basis1) + else: + raise NotImplementedError + + def forward(self, state: paddle_quantum.State, desired_result: Union[int, str]) -> paddle_quantum.State: + r"""Compute the collapse of the input state. + + Args: + state: The input state, which will be collapsed. + desired_result: The desired result you want to collapse. + + Raises: + NotImplementedError: Currently we just support the z basis. + + Returns: + The collapsed quantum state. + """ + if self.backend == paddle_quantum.Backend.StateVector: + if desired_result == 'random': + prob_list = [] + idx_list = list(range(0, len(self.measure_basis))) + for idx in idx_list: + measure_op = self.measure_basis[idx] + state = paddle.unsqueeze(state.data, axis=1) + _prob = paddle.matmul(measure_op, state.data) + prob = paddle.matmul(paddle.conj(paddle.t(_prob)), _prob).item() + prob_list.append(prob) + desired_result = random.choices(idx_list, prob_list) + measure_op = self.measure_basis[desired_result] + state = paddle.unsqueeze(state.data, axis=1) + _prob = paddle.matmul(measure_op, state.data) + prob = paddle.matmul(paddle.conj(paddle.t(_prob)), _prob) + prob = paddle.reshape(prob, [1]) + state = paddle.matmul(measure_op, state) / paddle.sqrt(prob) + measured_state = paddle_quantum.State(state, backend=self.backend) + elif self.backend == paddle_quantum.Backend.DensityMatrix: + if desired_result == 'random': + prob_list = [] + idx_list = list(range(0, len(self.measure_basis))) + for idx in idx_list: + measure_op = self.measure_basis[idx] + state = paddle.unsqueeze(state.data, axis=1) + measure_op_dagger = paddle.conj(paddle.t(measure_op)) + prob = paddle.trace(paddle.matmul(paddle.matmul(measure_op_dagger, measure_op), state)).item() + prob_list.append(prob) + desired_result = random.choices(idx_list, prob_list) + measure_op = self.measure_basis[desired_result] + state = state.data + measure_op_dagger = paddle.conj(paddle.t(measure_op)) + prob = paddle.trace(paddle.matmul(paddle.matmul(measure_op_dagger, measure_op), state)) + state = paddle.matmul(paddle.matmul(measure_op, state), measure_op_dagger) / prob + measured_state = paddle_quantum.State(state) + else: + raise NotImplementedError + return measured_state diff --git a/paddle_quantum/optimizer/conjugate_gradient.py b/paddle_quantum/optimizer/conjugate_gradient.py deleted file mode 100644 index cc75e28..0000000 --- a/paddle_quantum/optimizer/conjugate_gradient.py +++ /dev/null @@ -1,63 +0,0 @@ -# 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 deleted file mode 100644 index 4743879..0000000 --- a/paddle_quantum/optimizer/custom_optimizer.py +++ /dev/null @@ -1,108 +0,0 @@ -# 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 deleted file mode 100644 index fc5285e..0000000 --- a/paddle_quantum/optimizer/newton_cg.py +++ /dev/null @@ -1,63 +0,0 @@ -# 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 deleted file mode 100644 index 8669f2f..0000000 --- a/paddle_quantum/optimizer/powell.py +++ /dev/null @@ -1,59 +0,0 @@ -# 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 deleted file mode 100644 index 037dec8..0000000 --- a/paddle_quantum/optimizer/slsqp.py +++ /dev/null @@ -1,58 +0,0 @@ -# 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/qchem/__init__.py b/paddle_quantum/qchem/__init__.py old mode 100755 new mode 100644 index f4e8f18..1765692 --- a/paddle_quantum/qchem/__init__.py +++ b/paddle_quantum/qchem/__init__.py @@ -1,3 +1,4 @@ +# !/usr/bin/env python3 # Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -12,32 +13,13 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" -量桨平台的量子化学模块 +r""" +The module of the quantum chemistry. """ -from .qmodel import QModel -from . import ansatz -from .run import run_chem +from .hardware_efficient import HardwareEfficientModel +from .slater_determinant import RHFSlaterDeterminantModel +from .uccsd import UCCSDModel +from .density_matrix import get_spinorb_onebody_dm from .qchem import * -import platform -import warnings - -__all__ = [ - "run_chem", - "QModel", - "ansatz", - "geometry", - "get_molecular_data", - "active_space", - # forward compatible with original qchem module - "fermionic_hamiltonian", - "spin_hamiltonian" -] - -if platform.system() == "Windows": - warning_msg = ("Currently, Windows' users can't use 'hartree fock' ansatz " - "for ground state energy calculation in `run_chem`, " - "since it depends on pyscf, which is not available on Windows. " - "We will work it out in the near future, sorry for the inconvenience.") - warnings.warn(message=warning_msg) +from .loss import RHFEnergyLoss, MolEnergyLoss diff --git a/paddle_quantum/qchem/ansatz/hardware_efficient.py b/paddle_quantum/qchem/ansatz/hardware_efficient.py deleted file mode 100755 index 60c0d8f..0000000 --- a/paddle_quantum/qchem/ansatz/hardware_efficient.py +++ /dev/null @@ -1,78 +0,0 @@ -# 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. - -""" -Hardware efficient ansatz 量子电路，以 -`Hardware-efficient variational quantum eigensolver -for small molecules and quantum magnets` 方式构建。 -具体细节可以参见 https://arxiv.org/abs/1704.05018 - -该模块依赖于 - - paddlepaddle - - paddle_quantum - - ../layers - - ../qmodel -""" - -import paddle -from paddle import nn -from paddle_quantum.circuit import UAnsatz - -from ..qmodel import QModel -from .. import layers - - -class HardwareEfficientModel(QModel): - r"""面向硬件的量子线路。 - - Args: - num_qubit (int): 量子线路的量子比特数量。 - circuit_depth (int): Cross resonance 和 Euler 转动层的数量。 - """ - - def __init__(self, num_qubit: int, circuit_depth: int) -> None: - super().__init__(num_qubit) - - mid_layers = [] - for i in range(circuit_depth): - mid_layers.append(layers.CrossResonanceLayer(num_qubit)) - mid_layers.append(layers.EulerRotationLayer(num_qubit)) - - self.model = nn.Sequential( - layers.RotationLayer(num_qubit, "X"), - layers.RotationLayer(num_qubit, "Z"), - *mid_layers, - ) - - def forward( - self, - state: "paddle.Tensor[paddle.complex128]" - ) -> "paddle.Tensor[paddle.complex128]": - r"""运行量子电路 - - Args: - state (paddle.Tensor[paddle.complex128]): 传入量子线路的量子态。 - - Returns: - paddle.Tensor[paddle.complex128]: 运行电路后的量子态 - """ - - out = self.model(state) - - cir0 = UAnsatz(self._n_qubit) - for subcir in self.model: - cir0 += subcir.circuit - self._circuit = cir0 - - return out diff --git a/paddle_quantum/qchem/ansatz/rhf.py b/paddle_quantum/qchem/ansatz/rhf.py deleted file mode 100755 index 0209b8a..0000000 --- a/paddle_quantum/qchem/ansatz/rhf.py +++ /dev/null @@ -1,133 +0,0 @@ -# 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. - -""" -Restrict Hartree Fock 模块 -""" - -from collections import OrderedDict -from copy import deepcopy -import numpy as np -import paddle -from paddle.nn import initializer -from paddle_quantum.circuit import UAnsatz -from ..linalg import givens_decomposition, parameters_to_givens_matrix2 -from ..qmodel import QModel -from .. import functional - - -class _MakeGivensMatrix(paddle.autograd.PyLayer): - r"""Construct Givens rotation matrix G from parameters \theta and \phi. - - .. math:: - G[j-1,j-1] = \cos(\theta) - G[j,j] = \cos(\theta) - G[j-1,j] = -\phi\sin(\theta) - G[j,j-1] = \phi\sin(\theta) - - We define this function since paddle doesn't fully support differentiate over - copy and slice operation, e.g. A[i,j] = \theta, where \theta is the parameter - to be differentiated. - """ - - @staticmethod - def forward(ctx, theta: paddle.Tensor, phi: paddle.Tensor, j: int, n: int): - G = parameters_to_givens_matrix2(theta, phi, j, n) - ctx.saved_index = j - ctx.save_for_backward(theta, phi) - return G - - @staticmethod - def backward(ctx, dG): - j = ctx.saved_index - theta, phi = ctx.saved_tensor() - dtheta = (-1.0 * (dG[j - 1, j - 1] + dG[j, j]) * paddle.sin(theta) - + (dG[j, j - 1] - dG[j - 1, j]) * phi * paddle.cos(theta)) - return dtheta, None - - -class RestrictHartreeFockModel(QModel): - r"""限制性 Hartree Fock (RHF) 波函数的量子线路。 - - Args: - num_qubits (int): RHF 计算中需要使用的量子比特数量。 - n_electrons (int): 待模拟的量子化学系统中的电子数量。 - onebody (paddle.Tensor(dtype=paddle.float64)): 经过 L\"owdin 正交化之后的单体积分。 - """ - - def __init__( - self, - num_qubits: int, - n_electrons: int, - onebody: paddle.Tensor - ) -> None: - super().__init__(num_qubits) - - self.nocc = n_electrons // 2 - self.norb = num_qubits // 2 - self.nvir = self.norb - self.nocc - - givens_angles = self.get_init_givens_angles(onebody) - models = [] - for ij, (theta, phi) in givens_angles.items(): - models.append((ij, _GivensBlock(self.n_qubit, -theta, phi))) - - self.models = paddle.nn.Sequential(*models) - - def get_init_givens_angles(self, onebody: paddle.Tensor) -> OrderedDict: - r"""利用单体积分来初始化 Givens 旋转的角度。 - - Args: - onebody (paddle.Tensor): 经过 L\"owdin 正交化之后的单体积分。 - - Returns: - OrderedDict - """ - assert type(onebody) == paddle.Tensor, "The onebody integral must be a paddle.Tensor." - _, U = np.linalg.eigh(onebody.numpy()) - U_tensor = paddle.to_tensor(U) - return givens_decomposition(U_tensor) - - def forward(self, state: paddle.Tensor) -> paddle.Tensor: - r"""运行量子电路 - - Args: - state (paddle.Tensor[paddle.complex128]): 传入量子线路的量子态矢量。 - - Returns: - paddle.Tensor[paddle.complex128]: 运行电路后的量子态 - """ - s = deepcopy(state) - self._circuit = UAnsatz(self.n_qubit) - for ij, givens_ops in self.models.named_children(): - i, j = [int(p) for p in ij.split(",")] - s = givens_ops(s, 2 * i, 2 * j) - self._circuit += givens_ops.circuit - s = givens_ops(s, 2 * i + 1, 2 * j + 1) - self._circuit += givens_ops.circuit - - return s - - def single_particle_U(self): - r"""获取 Hartree Fock 轨道旋转矩阵 - - Returns: - paddle.Tensor, Hartree Fock 轨道旋转矩阵，:math:`n_{orbitals}\times n_{occ}` - """ - self.register_buffer("_U", paddle.eye(int(self.norb), dtype=paddle.float64)) - for ij, givens_ops in self.models.named_children(): - j = int(ij.split(",")[1]) - self._U = givens_ops.single_particle_U(j, self.norb) @ self._U - - return self._U[:, :self.nocc] diff --git a/paddle_quantum/qchem/complex_utils.py b/paddle_quantum/qchem/complex_utils.py new file mode 100644 index 0000000..70566b5 --- /dev/null +++ b/paddle_quantum/qchem/complex_utils.py @@ -0,0 +1,115 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +Linear algebra functions which support complex data type (Complex64, Complex128). +""" + +import paddle + +__all__ = ["_general_vnorm", "_general_vv", "_general_mv", "_hermitian_expv"] + + +def _general_vnorm(vec: paddle.Tensor) -> paddle.Tensor: + r""" + Calculate the vector norm for complex vector ||v||^2. + + Args: + vec: Complex valued vector. + + Returns: + Real scalar. + """ + + if vec.dtype in [paddle.complex64, paddle.complex128]: + return paddle.dot(vec.real(), vec.real()) + paddle.dot(vec.imag(), vec.imag()) + else: + return paddle.dot(vec, vec) + + +def _general_vv(vec1: paddle.Tensor, vec2: paddle.Tensor) -> paddle.Tensor: + r""" + Calculate the vector dot product between two complex vectors. + + Args: + vec1: Complex valued vector. + vec2: Complex valued vector. + + Returns: + Complex scalar. + """ + + try: + vec1.dtype == vec2.dtype + except AssertionError: + raise ValueError(f"Tensors are expected to have the same dtype, but receive {vec1.dtype} and {vec2.dtype}") + if vec1.dtype in [paddle.complex64, paddle.complex128]: + return paddle.dot(vec1.real(), vec2.real()) + paddle.dot(vec2.imag(), vec2.imag()) + \ + 1j * paddle.dot(vec1.real(), vec2.imag()) - 1j * paddle.dot(vec1.imag(), vec2.real()) + else: + return paddle.dot(vec1, vec2) + + +def _general_mv(mat: paddle.Tensor, vec: paddle.Tensor) -> paddle.Tensor: + r""" + Calculate the complex matrix vector multiplication. + + Args: + mat: Complex valued matrix. + vec: Complex valued vector. + + Returns: + Complex valued tensor. + """ + + try: + mat.dtype == vec.dtype + except AssertionError: + raise ValueError(f"Tensors are expected to have the same dtype, but receive {mat.dtype} and {vec.dtype}") + if mat.dtype in [paddle.complex64, paddle.complex128]: + return paddle.mv(mat.real(), vec.real()) - paddle.mv(mat.imag(), vec.imag()) + \ + 1j * paddle.mv(mat.real(), vec.imag()) + 1j * paddle.mv(mat.imag(), vec.real()) + else: + return paddle.mv(mat, vec) + + +def _hermitian_expv(mat: paddle.Tensor, vec: paddle.Tensor) -> paddle.Tensor: + r""" + Calculate + .. math: + \langle v|M|v\rangle + + where M is a Hermitian matrix: + M.real(): real symmetric matrix. + M.imag(): real antisymmetric matrix. + + Args: + mat: Complex valued Hermitian matrix. + vec: Complex valued vector. + + Returns: + A scalar, paddle.Tensor. + """ + + try: + mat.dtype == vec.dtype + except AssertionError: + raise ValueError(f"Tensors are expected to have the same dtype, but receive {mat.dtype} and {vec.dtype}") + if mat.dtype in [paddle.complex64, paddle.complex128]: + return paddle.dot(vec.real(), paddle.mv(mat.real(), vec.real())) + \ + paddle.dot(vec.imag(), paddle.mv(mat.real(), vec.imag())) + \ + 2 * paddle.dot(vec.imag(), paddle.mv(mat.imag(), vec.real())) + else: + return paddle.dot(vec, paddle.mv(mat, vec)) diff --git a/paddle_quantum/qchem/density_matrix.py b/paddle_quantum/qchem/density_matrix.py new file mode 100644 index 0000000..431b7e4 --- /dev/null +++ b/paddle_quantum/qchem/density_matrix.py @@ -0,0 +1,131 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +Measure onebody density matrix from quantum state. +""" + +from typing import List, Tuple +import paddle +import openfermion +import paddle_quantum + +from .complex_utils import * + +__all__ = ["get_spinorb_onebody_dm"] + + +def _get_float_dtype(dtype): + r""" + Get the compatible floating data type from the given complex data type. + """ + if dtype == paddle.complex64: + return paddle.float32 + elif dtype == paddle.complex128: + return paddle.float64 + + +def _get_onebody_hermitian_operator(n_qubits: int, i: int, j: int, with_spin: bool, dtype) -> paddle.Tensor: + r""" + Return the matrix corresponds to the + .. math: + \hat{c}_i^{\dagger}\hat{c}_j+\hat{c}_j^{\dagger}\hat{c}_i. + + Args: + n_qubits: Number of qubits in the quantum circuit. + i: Operator index. + j: Operator index. + with_spin: Whether use spin orbital or orbital to label the qubits in the quantum circuit. + + Returns: + Hermitian matrix. + """ + + if i == j: + ops = openfermion.QubitOperator("", 0.5) - openfermion.QubitOperator(f"Z{i}", 0.5) + ops_array = openfermion.get_sparse_operator(ops, n_qubits).toarray() + else: + if with_spin: + qstr_xzx = f"X{i} " + " ".join([f"Z{k}" for k in range(i + 2, j, 2)]) + f" X{j}" + qstr_yzy = f"Y{i} " + " ".join([f"Z{k}" for k in range(i + 2, j, 2)]) + f" Y{j}" + else: + qstr_xzx = f"X{i} " + " ".join([f"Z{k}" for k in range(i + 1, j)]) + f" X{j}" + qstr_yzy = f"Y{i} " + " ".join([f"Z{k}" for k in range(i + 1, j)]) + f" Y{j}" + ops = openfermion.QubitOperator(qstr_xzx, 0.5) + openfermion.QubitOperator(qstr_yzy, 0.5) + ops_array = openfermion.get_sparse_operator(ops, n_qubits).toarray() + return paddle.to_tensor(ops_array, dtype=dtype) + + +class OneBodyDensityMatrix(paddle.autograd.PyLayer): + r""" + Measure the onebody density matrix from a quantum state. + """ + @staticmethod + def forward(ctx, n_qubits: int, orb_index: List[int], with_spin: bool, state: paddle.Tensor) -> paddle.Tensor: + ctx.with_spin = with_spin + ctx.n_qubits = n_qubits + ctx.orb_index = orb_index + ctx.save_for_backward(state) + + nao = len(orb_index) + dm = paddle.zeros((nao, nao), dtype=_get_float_dtype(state.dtype)) + for i in range(nao): + dm_op = _get_onebody_hermitian_operator(n_qubits, orb_index[i], orb_index[i], with_spin, state.dtype) + dm[i, i] = _hermitian_expv(dm_op, state) + for j in range(i + 1, nao): + dm_op = _get_onebody_hermitian_operator(n_qubits, orb_index[i], orb_index[j], with_spin, state.dtype) + dm[i, j] = 0.5 * _hermitian_expv(dm_op, state) + dm[j, i] = dm[i, j] + return dm + + @staticmethod + def backward(ctx, grad_dm: paddle.Tensor): + n_qubits = ctx.n_qubits + state, = ctx.saved_tensor() + orb_index = ctx.orb_index + + grad_state = 0.0 + 0.0j + nao = len(orb_index) + for i in range(nao): + dm_op = _get_onebody_hermitian_operator(n_qubits, orb_index[i], orb_index[i], ctx.with_spin, state.dtype) + grad_state += grad_dm[i, i] * 2 * _general_mv(dm_op, state) + for j in range(i + 1, nao): + dm_op = _get_onebody_hermitian_operator(n_qubits, orb_index[i], orb_index[j], ctx.with_spin, + state.dtype) + grad_state += (grad_dm[i, j] + grad_dm[j, i]) * _general_mv(dm_op, state) + return grad_state + + +get_onebody_dm = OneBodyDensityMatrix.apply + + +def get_spinorb_onebody_dm(n_qubits: int, state: paddle.Tensor) -> Tuple[paddle.Tensor]: + r""" + Get the onebody density matrix from a given state in which qubits are label by spin orbital index. + + Args: + n_qubits: number of qubits in the quantum circuit. + state: the given quantum state. + + Returns: + spin up and spin down onebody density matrix. + """ + + assert n_qubits % 2 == 0, "number of spin orbital should be even." + a_orb_index = range(0, n_qubits, 2) + b_orb_index = range(1, n_qubits, 2) + dm_a = get_onebody_dm(n_qubits, a_orb_index, True, state) + dm_b = get_onebody_dm(n_qubits, b_orb_index, True, state) + return dm_a, dm_b diff --git a/paddle_quantum/qchem/functional.py b/paddle_quantum/qchem/functional.py deleted file mode 100755 index bcc9158..0000000 --- a/paddle_quantum/qchem/functional.py +++ /dev/null @@ -1,180 +0,0 @@ -# !/usr/bin/env python3 -# 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. - -""" -用于构建量子电路层的函数操作。 -该模块依赖于 paddlepaddle 和 paddle_quantum -""" - -import paddle -from paddle_quantum.circuit import UAnsatz - - -# Rotation layer function -def rot_layer( - cir: UAnsatz, - parameters: "paddle.Tensor[paddle.float64]", - gate_type: str -) -> UAnsatz: - r"""该函数用来在量子线路上添加一层单比特旋转门，"Rx", "Ry", "Rz" - - Args: - cir (UAnsatz): 量子线路 - parameters (paddle.Tensor[paddle.float64]): 旋转门的旋转角度 - gate_type (str): "X", "Y" 和 "Z"，例如：如果是 "Rx" 门，则添 "X" - - Returns: - UAnsatz - """ - - n_qubits = cir.n - assert n_qubits == len(parameters), \ - "length of the parameters must equal the number of qubits" - - for i in range(n_qubits): - if gate_type == "X": - cir.rx(parameters[i], i) - elif gate_type == "Y": - cir.ry(parameters[i], i) - elif gate_type == "Z": - cir.rz(parameters[i], i) - - return cir - - -# Euler rotation gate function -def euler_rotation( - cir: UAnsatz, - which_qubit: int, - angles: "paddle.Tensor[paddle.float64]", -) -> UAnsatz: - r"""该函数定义了单比特的 Euler 旋转门（使用 ZXZ 规范） - - .. math:: - U(\theta,\phi,\gamma)=e^{-i\gamma/2\hat{Z}}e^{-i\phi/2\hat{X}}e^{-i\theta/2\hat{X}}. - - Args: - cir (UAnsatz): 量子线路 - which (int): Euler 旋转门作用的量子比特编号 - angles (paddle.Tensor[paddle.float64]): Euler 角，存储顺序与 ZXZ 操作的顺序相反。 - - Returns: - UAnsatz - """ - cir.rz(angles[0], which_qubit) - cir.rx(angles[1], which_qubit) - cir.rz(angles[2], which_qubit) - return cir - - -# Euler rotation layer function -def euler_rotation_layer( - cir: UAnsatz, - parameters: "paddle.Tensor[paddle.float64]", -) -> UAnsatz: - r"""该函数会在给定的量子线路上添加一层 Euler 旋转门。 - - Args: - cir (UAnsatz): 量子线路。 - parameters (paddle.Tensor[paddle.float64]): Euler 角参数集合。 - """ - n_qubits = cir.n - assert len( - parameters) == 3 * n_qubits, "length of parameter should be 3 times of the number of qubits in the circuit." - - for i in range(n_qubits): - cir = euler_rotation(cir, i, parameters[3 * i:3 * (i + 1)]) - - return cir - - -# Cross resonance gate function -def cross_resonance( - cir: UAnsatz, - ctrl_targ: "list[int]", - phase_angle: paddle.Tensor -) -> UAnsatz: - r"""该函数定义了一个双比特的 cross resonance (CR) 门。 - - .. math:: - U(\theta) = \exp(-i\frac{\theta}{2}\hat{X}\otimes\hat{Z}) - - Args: - cir (UAnsatz): 量子线路。 - ctrl_targ (list[int]): 控制比特和目标比特对应的比特编号。 - phase_angle (paddle.Tensor[paddle.float64]): 旋转角度。 - - Returns: - UAnsatz - """ - cir.h(ctrl_targ[0]) - cir.rzz(phase_angle, ctrl_targ) - cir.h(ctrl_targ[0]) - return cir - - -# Cross resonance layer function -def cr_layer( - cir: UAnsatz, - parameters: "paddle.Tensor[paddle.float64]", - ctrl_qubit_index: "list[int]", - targ_qubit_index: "list[int]" -) -> UAnsatz: - """该函数在给定线路上按照给定的控制和目标比特编号添加一层 cross resonance (CR) 门。 - - Args: - cir (UAnsatz): 量子线路。 - parameters (paddle.Tensor[paddle.float64]): CR 门中的角度。 - ctrl_qubit_index (list[int]): 控制比特序号。 - targ_qubit_index (list[int]): 目标比特序号。 - - Returns: - UAnsatz - """ - assert len(parameters) == len(ctrl_qubit_index) and len(ctrl_qubit_index) == len(targ_qubit_index), \ - "length of parameter must be the same as the number of cr gates" - - for i, ct_index in enumerate(zip(ctrl_qubit_index, targ_qubit_index)): - cir = cross_resonance(cir, list(ct_index), parameters[i]) - - return cir - - -# Nearest neighbor Givens rotation gate function -def givens_rotation( - cir: UAnsatz, - theta: "paddle.Tensor[paddle.float64]", - q1_index: int, - q2_index: int -) -> UAnsatz: - r"""该函数定义了两个相邻比特之间的 Givens 旋转门。详细信息参见 https://arxiv.org/abs/1711.05395. - - Note: - 在 paddlequantum :math:`Ry(\theta)=e^{-i\frac{\theta}{2}\hat{Y}}`. - - Args: - cir (UAnsatz): 量子线路。 - theta (paddle.Tensor[paddle.float64]): 操作中 Ry 门的角度。 - q1_index (int): 第一个 qubit 的编号。 - q2_index (int): 第二个 qubit 的编号。 - - Returns: - UAnsatz - """ - - cir.cnot([q2_index, q1_index]) - cir.cry(-2 * theta, [q1_index, q2_index]) - cir.cnot([q2_index, q1_index]) - return cir diff --git a/paddle_quantum/qchem/hardware_efficient.py b/paddle_quantum/qchem/hardware_efficient.py new file mode 100644 index 0000000..8d24e83 --- /dev/null +++ b/paddle_quantum/qchem/hardware_efficient.py @@ -0,0 +1,64 @@ +# !/usr/bin/env python3 +# 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. + +r""" +Hardware Efficient ansatz. +""" + +from typing import Union, Optional +import paddle +import paddle_quantum as pq + +__all__ = ["HardwareEfficientModel"] + + +class HardwareEfficientModel(pq.gate.Gate): + r""" + Args: + n_qubits: number of qubits. + depth: depth of the circuit, a layer in Hardware efficient circuit contains [Ry, Rz, CNOT]. + theta: parameters for the Ry and Rz gates inside the circuit. + """ + + def __init__( + self, + n_qubits: int, + depth: int, + theta: Optional[paddle.Tensor] = None + ): + super().__init__(depth, backend=pq.Backend.StateVector) + + layers = [] + if theta is not None: + assert theta.shape == [n_qubits, 2, + depth], "shape of the parameter should be compatible to n_qubits and depths" + for d in range(depth - 1): + layers.append(pq.gate.RY("full", n_qubits, param=theta[:, 0, d])) + layers.append(pq.gate.RZ("full", n_qubits, param=theta[:, 1, d])) + layers.append(pq.gate.CNOT("cycle", n_qubits)) + layers.append(pq.gate.RY("full", n_qubits, param=theta[:, 0, depth - 1])) + layers.append(pq.gate.RZ("full", n_qubits, param=theta[:, 1, depth - 1])) + else: + for d in range(depth - 1): + layers.append(pq.gate.RY("full", n_qubits)) + layers.append(pq.gate.RZ("full", n_qubits)) + layers.append(pq.gate.CNOT("cycle", n_qubits)) + layers.append(pq.gate.RY("full", n_qubits)) + layers.append(pq.gate.RZ("full", n_qubits)) + + self.model = pq.ansatz.Sequential(*layers) + + def forward(self, state: pq.State) -> pq.State: + return self.model(state) diff --git a/paddle_quantum/qchem/layers.py b/paddle_quantum/qchem/layers.py deleted file mode 100755 index 406b9d0..0000000 --- a/paddle_quantum/qchem/layers.py +++ /dev/null @@ -1,183 +0,0 @@ -# !/usr/bin/env python3 -# 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. - -""" -量子电路层，该模块依赖于 paddlepaddle，paddle_quantum 和 math 包。 -同时依赖于 qmodel 和 functional 模块。 -""" - -import math -import paddle -from paddle.nn import initializer - -from paddle_quantum.circuit import UAnsatz - -from .qmodel import QModel -from . import functional - - -# Rotation layer -class RotationLayer(QModel): - r"""单比特旋转门层。 - - Args: - num_qubits (int): 量子线路的量子比特数。 - gate_type (str): 量子门的类型，"X", "Y" 和 "Z" 中的一个。 - trainable (bool): 层中的角度参数是否可训练。 - """ - def __init__(self, num_qubits: int, gate_type: str, trainable: bool = True): - super().__init__(num_qubits) - - self._angle_attr = paddle.ParamAttr( - initializer=initializer.Uniform(0.0, 2*math.pi), - trainable=trainable - ) - - self.angles = self.create_parameter( - shape=[num_qubits], - attr=self._angle_attr, - dtype="float64" - ) - - self._gate_type = gate_type - - def forward( - self, - state: "paddle.Tensor[paddle.complex128]" - ) -> "paddle.Tensor[paddle.complex128]": - r"""获取运行后的量子态 - - Args: - state (paddle.Tensor[paddle.complex128, shape=[n]]): 送入电路的量子态 - - Returns: - paddle.Tensor[paddle.complex128, shape=[n]]: 运行电路后的量子态 - """ - cir0 = UAnsatz(self._n_qubit) - self._circuit = functional.rot_layer(cir0, self.angles, self._gate_type) - return self.circuit.run_state_vector(state) - - def extra_repr(self): - r"""额外表示 - """ - return "gate={:s}, dtype={:s}".format( - self._gate_type, - self.angles.dtype.name) - - -# Euler rotation layer -class EulerRotationLayer(QModel): - r"""Euler 旋转门层。 - - Args: - num_qubits (int): 量子线路中的量子比特数量。 - trainable (bool): 层中的参数是否是可训练的。 - """ - - def __init__(self, num_qubits: int, trainable: bool = True) -> None: - super().__init__(num_qubits) - self._angle_attr = paddle.ParamAttr( - initializer=initializer.Uniform(0.0, 2*math.pi), - trainable=trainable - ) - self.euler_angles = self.create_parameter( - shape=[3*num_qubits], - attr=self._angle_attr, - dtype="float64" - ) - - def forward( - self, - state: "paddle.Tensor[paddle.complex128]" - ) -> "paddle.Tensor[paddle.complex128]": - r"""获取运行后的量子态 - - Args: - state (paddle.Tensor[paddle.complex128, shape=[n]]): 送入电路的量子态 - - Returns: - paddle.Tensor[paddle.complex128, shape=[n]]: 运行电路后的量子态 - """ - cir0 = UAnsatz(self._n_qubit) - self._circuit = functional.euler_rotation_layer(cir0, self.euler_angles) - return self._circuit.run_state_vector(state) - - def extra_repr(self): - r"""额外表示 - """ - return "dtype={:s}".format(self.euler_angles.dtype.name) - - -# Cross resonance layer -class CrossResonanceLayer(QModel): - r"""在量子线路中按照给定的控制和目标比特添加一层 cross resonance 门。 - - Args: - num_qubits (int): 量子比特数目。 - ctrl_qubit_index (list[int]): 控制比特的序号。 - targ_qubit_index (list[int]): 目标比特的序号。 - trainable (bool): 层中的参数是否可训练。 - """ - def __init__( - self, - num_qubits: int, - ctrl_qubit_index: "list[int]" = None, - targ_qubit_index: "list[int]" = None, - trainable: bool = True - ) -> None: - super().__init__(num_qubits) - - if ctrl_qubit_index is None: - ctrl_qubit_index = list(range(num_qubits)) - if targ_qubit_index is None: - targ_qubit_index = list(range(1, num_qubits)) + [0] - - self._ctrl_qubit_index = ctrl_qubit_index - self._targ_qubit_index = targ_qubit_index - - self._phase_attr = paddle.ParamAttr( - initializer=initializer.Uniform(0.0, 2*math.pi), - trainable=trainable - ) - self.phase = self.create_parameter( - shape=[len(ctrl_qubit_index)], - attr=self._phase_attr, - dtype="float64" - ) - - def forward( - self, - state: "paddle.Tensor[paddle.complex128]" - ) -> "paddle.Tensor[paddle.complex128]": - r"""获取运行后的量子态 - - Args: - state (paddle.Tensor[paddle.complex128, shape=[n]]): 送入电路的量子态 - - Returns: - paddle.Tensor[paddle.complex128, shape=[n]]: 运行电路后的量子态 - """ - cir0 = UAnsatz(self._n_qubit) - self._circuit = functional.cr_layer( - cir0, - self.phase, - self._ctrl_qubit_index, - self._targ_qubit_index) - return self._circuit.run_state_vector(state) - - def extra_repr(self): - r"""额外表示 - """ - return "dtype={:s}".format(self.phase.dtype.name) diff --git a/paddle_quantum/qchem/linalg.py b/paddle_quantum/qchem/linalg.py deleted file mode 100755 index 7def15d..0000000 --- a/paddle_quantum/qchem/linalg.py +++ /dev/null @@ -1,154 +0,0 @@ -# !/usr/bin/env python3 -# 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. -""" -qchem 开发所需的线性代数操作 -""" - -from typing import OrderedDict, Tuple -from collections import OrderedDict -import math -from copy import deepcopy -import paddle - - -DEFAULT_TOL = 1e-8 - - -def get_givens_rotation_parameters( - a: paddle.Tensor, - b: paddle.Tensor -) -> Tuple[paddle.Tensor]: - r"""计算 Givens 旋转的 (c,s) 参数。 - 详细过程参见：https://www.netlib.org/lapack/lawnspdf/lawn148.pdf - - Note: - :math:`r = \operatorname{sign}(a)\sqrt{a^2+b^2}, c = |a|/|r|, s = \operatorname{sign}(a)*b/|r|` - - Args: - a (paddle.Tensor(dtype=float64)): 计算所用参数 - b (paddle.Tensor(dtype=float64)): 计算所用参数 - - Returns: - tuple: - - c (paddle.Tensor(dtype=float64)) - - s (paddle.Tensor(dtype=float64)) - """ - assert a.dtype is paddle.float64 and b.dtype is paddle.float64,\ - "dtype not match, require dtype of a, b be paddle.float64!" - - if math.isclose(b.item(), 0.0, abs_tol=DEFAULT_TOL): - r = a - c = paddle.to_tensor(1.0, dtype=paddle.float64) - s = paddle.to_tensor(0.0, dtype=paddle.float64) - elif math.isclose(a.item(), 0.0, abs_tol=DEFAULT_TOL): - r = b.abs() - c = paddle.to_tensor(0.0, dtype=paddle.float64) - s = paddle.sign(b) - else: - abs_r = paddle.sqrt(a.abs()**2+b.abs()**2) - r = paddle.sign(a)*abs_r - c = a.abs()/abs_r - s = paddle.sign(a)*b/abs_r - return r, c, s - - -def parameter_to_givens_matrix1(c: paddle.Tensor, s: paddle.Tensor, j: int, n_size: int): - r"""该函数可利用 (c,s) 参数来构造 Givens 旋转矩阵以消去 A[i,j] 上的元素。 - - Args: - c (paddle.Tensor): :math:`|A[i,j-1]|/r`, 其中 :math:`r=\sqrt{A[i,j-1]^2+A[i,j]^2}`; - s (paddle.Tensor): :math:`\operatorname{sign}{(A[i,j]*A[i,j-1])*A[i,j]/r)}`; - j (int): 计算所用参数 - n_size (int): Givens 旋转矩阵的维度 - - Returns: - Givens 旋转矩阵 (paddle.Tensor) - """ - G = paddle.eye(n_size, dtype=paddle.float64) - - G[j - 1, j - 1] = c - G[j, j] = c - G[j - 1, j] = -s - G[j, j - 1] = s - - return G - - -def givens_decomposition(A: paddle.Tensor) -> OrderedDict: - r"""对于一个给定的矩阵 A，该函数会返回一个 Givens 旋转操作的 list，用户可以使用其中的 Givens 旋转操作消除掉 A 的上三角的元素。 - - Note: - :math:`r = \operatorname{sign}(a)\sqrt{a^2+b^2}, c = |a|/|r|` - - :math:`s = \operatorname{sign}(a)*b/|r| , \theta = arc\cos(c), phi = \operatorname{sign}(a*b)` - - :math:`A^{\prime}[:,j-1] = c*A[:,j-1]+s*A[:,j]` - - :math:`A^{\prime}[:,j] = -s*A[:,j-1]+c*A[:,j]` - - Args: - A (paddle.Tensor(dtype=paddle.float64)): 矩阵 - - Returns: - OrderedDict, 包含 Givens 旋转操作以及其对应的参数。 - """ - n = A.shape[0] - assert n == A.shape[1], "The input tensor should be a square matrix." - assert A.dtype is paddle.float64, "dtype of input tensor must be paddle.float64!" - - # The givens rotations are not parallel !!! - A1 = deepcopy(A) - rotations = [] - for i in range(n): - for j in range(n-1, i, -1): - _, c, s = get_givens_rotation_parameters(A1[i, j - 1], A1[i, j]) - theta = paddle.acos(c) - phi = paddle.sign(A1[i, j - 1]*A1[i, j]) - rotations.append((f"{i:>d},{j:>d}", (theta, phi))) - - # update A matrix - A1_jprev = c*A1[:, j - 1] + s*A1[:, j] - A1_j = -s*A1[:, j-1] + c*A1[:, j] - A1[:, j-1] = A1_jprev - A1[:, j] = A1_j - - return OrderedDict(rotations) - - -def parameters_to_givens_matrix2( - theta: paddle.Tensor, - phi: paddle.Tensor, - j: int, - n_size: int -) -> paddle.Tensor: - r"""该函数用来从 :math:`(\theta,\phi)` 参数中构建 Givens 旋转矩阵消去 :math:`A[i,j]`。 - - Args: - theta (paddle.Tensor): arccos(c); - phi (paddle.Tensor): :math:`\operatorname{sign}(A[i,j-1]*A[i,j])`; - j (int): 计算所用参数 - n_size (int): Givens 旋转矩阵的维度。 - - Returns: - paddle.Tensor, Givens 旋转矩阵 - """ - G = paddle.eye(int(n_size), dtype=paddle.float64) - - G[j - 1, j - 1] = paddle.cos(theta) - G[j, j] = paddle.cos(theta) - G[j - 1, j] = -phi*paddle.sin(theta) - G[j, j - 1] = phi*paddle.sin(theta) - - return G diff --git a/paddle_quantum/qchem/loss.py b/paddle_quantum/qchem/loss.py new file mode 100644 index 0000000..cf21dc7 --- /dev/null +++ b/paddle_quantum/qchem/loss.py @@ -0,0 +1,108 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +Loss functions for quantum chemistry calculation. +""" + +import paddle +import numpy as np +import paddle_quantum as pq + +from .qchem import get_molecular_data, spin_hamiltonian +from .density_matrix import get_spinorb_onebody_dm + +__all__ = ["MolEnergyLoss", "RHFEnergyLoss"] + + +class MolEnergyLoss(pq.loss.ExpecVal): + r"""Loss function for molecular ground state calculation. + + Args: + geometry: e.g. "H 0.0 0.0 0.0; H 0.0 0.0 0.74". + basis: chemical basis, e.g. "sto-3g". + multiplicity: spin multiplicity. + charge: charge of the molecule. + """ + + def __init__( + self, + geometry: str, + basis: str, + multiplicity: int = 1, + charge: int = 0) -> None: + geometry_internal = [] + for atom in geometry.split(";"): + atom = atom.strip() + atom_list = atom.split(" ") + atom_symbol = atom_list[0] + atom_coord = atom_list[1:] + geometry_internal.append((atom_symbol, [float(x) for x in atom_coord])) + + mol = get_molecular_data(geometry_internal, charge, multiplicity, basis) + mol_H = spin_hamiltonian(mol) + super().__init__(mol_H) + + +class RHFEnergyLoss(pq.Operator): + r"""Loss function for Restricted Hartree Fock calculation. + NOTE: This function needs PySCF be installed! + + Args: + geometry: e.g. "H 0.0 0.0 0.0; H 0.0 0.0 0.74". + basis: chemical basis, e.g. "sto-3g". + multiplicity: spin multiplicity. + charge: charge of the molecule. + """ + + def __init__( + self, + geometry: str, + basis: str, + multiplicity: int = 1, + charge: int = 0 + ) -> None: + super().__init__(backend=pq.Backend.StateVector) + + try: + import pyscf + except ModuleNotFoundError: + raise ModuleNotFoundError( + "`hartree fock` method needs pyscf being installed, please run `pip install -U pyscf`.") + + from pyscf.lo import lowdin + + mol = pyscf.gto.Mole(atom=geometry, basis=basis, multiplicity=multiplicity, charge=charge) + mol.build() + ovlp = mol.intor_symmetric("int1e_ovlp") + kin = mol.intor_symmetric("int1e_kin") + vext = mol.intor_symmetric("int1e_nuc") + vint = np.transpose(mol.intor("int2e"), (0, 2, 3, 1)) + V = lowdin(ovlp) + onebody_tensor, twobody_tensor, V_tensor = map(paddle.to_tensor, [kin + vext, 0.5 * vint, V]) + + self.energy_nuc = mol.energy_nuc() + self.onebody = onebody_tensor + self.twobody = twobody_tensor + self._V = V_tensor + + def forward(self, state: pq.State) -> paddle.Tensor: + state_tensor = state.data + rdm_spinup, _ = get_spinorb_onebody_dm(state.num_qubits, state_tensor) + rdm = 2 * (self._V @ rdm_spinup @ self._V) + rhf_energy = self.energy_nuc + paddle.einsum("pq,qp->", self.onebody, rdm) + \ + paddle.einsum("pqrs,qp,sr->", self.twobody, rdm, rdm) - \ + 0.5 * paddle.einsum("pqrs,sp,qr->", self.twobody, rdm, rdm) + return rhf_energy diff --git a/paddle_quantum/qchem/molecule.py b/paddle_quantum/qchem/molecule.py deleted file mode 100755 index 8272206..0000000 --- a/paddle_quantum/qchem/molecule.py +++ /dev/null @@ -1,102 +0,0 @@ -# !/usr/bin/env python3 -# 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. -""" -从分子结构等信息中提取量子化学需要的输入。 -""" - -from typing import Tuple, List -import numpy as np -from pyscf import gto, scf -from pyscf.lo import lowdin - - -# Transform one and two body integral into L\"owdin basis -def lowdin_transform( - ovlp: np.array, - onebody: np.array, - twobody: np.array -) -> Tuple[np.array]: - r"""该函数会将 pyscf 中得到的高斯积分利用 L\"owdin 正交化方法进行变换。 - - Note: - L\"owdin 正交化: - :math:`S_{ij}=\langle\phi_i^{\text{G}}|\phi_j^{\text{G}}\rangle`, - :math:`X = S^{-1/2}` - - Operators 的变换方式: - :math:`A^{\prime}_{ij}=\sum_{pq}A_{pq}X_{ip}X_{qj}` - :math:`B^{\prime}_{iklj}=\sum_{pqrs}B_{prsq}X_{ip}X_{kr}X_{sl}X_{qj}` - - 分子轨道的变换方式: - :math:`C^{\prime}_{ij}=\sum_{p}C_{pj}X^{-1}_{ip}` - - Args: - ovlp (np.array): 交叠积分，`mol.intor("int1e_ovlp")`。 - onebody (np.array): 单体积分，`mol.intor("int1e_kin")+mol.intor("int1e_nuc")`。 - twobody (np.array): 两体积分，`mol.intor("int2e")`。 - - Returns: - Tuple[np.array]: - - 变换之后的单体积分。 - - 变换之后的两体积分。 - """ - - inv_half_ovlp = lowdin(ovlp) - t_onebody = inv_half_ovlp @ onebody @ inv_half_ovlp - t_twobody = np.einsum( - "pqrs,ip,qj,kr,sl->ijkl", - twobody, inv_half_ovlp, inv_half_ovlp, inv_half_ovlp, inv_half_ovlp - ) - return t_onebody, t_twobody - - -# Molecular information -def get_molecular_information( - geometry: List[Tuple[str, List]], - basis: str = "sto-3g", - charge: int = 0, - debug: bool = False -) -> Tuple: - r"""该函数会返回量子化学（目前是 "hartree fock" 方法）计算所需要的分子信息，包括有计算需要的量子比特的数量，分子中的电子数，分子积分和 pyscf 平均场结果 (optional)。 - - Args: - geometry (List[Tuple[str,List]]): 分子中各原子笛卡尔坐标； - basis (str): 基函数名称，例如："sto-3g"； - charge (int): 分子的电荷； - debug (bool): 是否使用 debug 模式。debug 模式会返回 pyscf 的平均场计算结果。 - - Returns: - Tuple: - - 量子比特数目； - - 分子中的电子数； - - 原子核之间的排斥能、单体积分、双体积分； - - pyscf 的平均场计算结果 (可选，只有 debug=True 才会返回)。 - """ - mol = gto.M(atom=geometry, basis=basis, charge=charge, unit="angstrom") - mol.build() - if debug: - mf_mol = scf.RHF(mol).run() - - int_ovlp = mol.intor("int1e_ovlp") - nuc_energy = mol.energy_nuc() - onebody = mol.intor("int1e_kin") + mol.intor("int1e_nuc") - twobody = mol.intor("int2e") - - orth_onebody, orth_twobody = lowdin_transform(int_ovlp, onebody, twobody) - - if debug: - return 2*mol.nao, mol.nelectron, (nuc_energy, orth_onebody, 0.5*orth_twobody), mf_mol - else: - return 2*mol.nao, mol.nelectron, (nuc_energy, orth_onebody, 0.5*orth_twobody) diff --git a/paddle_quantum/qchem/qchem.py b/paddle_quantum/qchem/qchem.py old mode 100755 new mode 100644 index ebabfbf..f15ed6f --- a/paddle_quantum/qchem/qchem.py +++ b/paddle_quantum/qchem/qchem.py @@ -13,20 +13,23 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" -量子化学模块 +r""" +The function for quantum chemistry. """ import os import re +import string +from typing import Optional import numpy as np -import psi4 import openfermion from openfermion import MolecularData, transforms from openfermion.ops import general_basis_change -from paddle_quantum.utils import Hamiltonian +from paddle_quantum.hamiltonian import Hamiltonian + __all__ = [ + "qubitOperator_to_Hamiltonian", "geometry", "get_molecular_data", "active_space", @@ -35,18 +38,15 @@ ] -def _hamiltonian_transformation(spin_h, tol=1e-8): - r"""将哈密顿量从 openfermion 格式转换成 Paddle Quantum 格式。 - - Warning: - 输入的哈密顿量必须为埃尔米特的，输入的哈密顿中虚数的系数会和实数一起转换成他们的范数 (norm)。 +def qubitOperator_to_Hamiltonian(spin_h: openfermion.ops.operators.qubit_operator.QubitOperator, tol: Optional[float] = 1e-8) -> Hamiltonian: + r"""Transfer openfermion form to Paddle Quantum Hamiltonian form. Args: - spin_h (openfermion.ops.operators.qubit_operator.QubitOperator): openfermion 格式的哈密顿量 - tol (float, optional): 系数小于 tol 的值将被忽略掉，默认为 1e-8 + spin_h: Hamiltonian in openfermion form. + tol: Value less than tol will be ignored. Defaults to 1e-8. Returns: - paddle_quantum.Hamiltonian object: Paddle Quantum 格式的哈密顿量 + Hamiltonian in Paddle Quantum form. """ terms = spin_h.__str__().split('+\n') spin_h.compress(abs_tol=tol) @@ -73,15 +73,15 @@ def _hamiltonian_transformation(spin_h, tol=1e-8): return Hamiltonian(pauli_str) -def _geo_str(geometry): - r"""创建分子几何信息的字符串 +def _geo_str(geometry: list) -> str: + r"""String of molecular geometry information Args: - geometry (list): 包含了分子的几何信息，以 H2 分子为例 - [['H', [-1.68666, 1.79811, 0.0]], ['H', [-1.12017, 1.37343, 0.0]]] + geometry: contains the geometry of the molecule, for example, the H2 molecule + [['H', [-1.68666, 1.79811, 0.0]], ['H', [-1.12017, 1.37343, 0.0]]] Returns: - str: 分子几何信息的字符串 + String of molecular geometry information """ geo_str = '' for item in geometry: @@ -99,27 +99,28 @@ def _geo_str(geometry): def _run_psi4( - molecule, - charge, - multiplicity, - method, - basis, - if_print, - if_save -): - r"""计算分子的必要信息，包括单体积分 (one-body integrations) 和双体积分 (two-body integrations)， - 以及用 scf 和 fci 的方法计算基态的能量。 + molecule: MolecularData, + charge: int, + multiplicity: int, + method: str, + basis: str, + if_print: bool, + if_save: bool +) -> None: + r"""The necessary information to calculate molecules, including one-body integrations and two-body integrations, as well as the energy of ground states by scf and fci methods. Args: - molecule (MolecularData object): 包含分子所有信息的类 (class) - charge (int): 分子的电荷 - multiplicity (int): 分子的多重度 - method (str): 用于计算基态能量的方法，包括 'scf'和 'fci' - basis (str): 常用的基组是 'sto-3g', '6-31g'等。更多的基组选择可以参考网站 - https://psicode.org/psi4manual/master/basissets_byelement.html#apdx-basiselement - if_print (Boolean): 是否需要打印出选定方法 (method) 计算出的分子基态能量 - if_save (Boolean): 是否需要将分子信息存储成 .hdf5 文件 + molecule: Class containing all information about a molecule. + charge: Charge of the molecule. + multiplicity: The multiplicity of the molecule. + method: Method used to calculate the ground state energy, including 'scf' and 'fci'. + basis: Most common used basis are ‘sto-3g’, ‘6-31g’. For more basis options, please refer to + https://psicode.org/psi4manual/master/basissets_byelement.html#apdx-basiselement. + if_print: If or not the base state energy of the molecule calculated by the selected method should be printed. + if_save: If the molecular information needs to be stored as an .hdf5 file. """ + + import psi4 psi4.set_memory('500 MB') psi4.set_options({'soscf': 'false', 'scf_type': 'pk'}) @@ -182,19 +183,19 @@ def _run_psi4( print('Calculation is done') -def geometry(structure=None, file=None): - r"""读取分子的几何信息 +def geometry(structure: Optional[str] = None, file: Optional[str] = None) -> str: + r"""Read molecular geometry information. Args: - structure (string, optional): 分子几何信息的字符串形式，以 H2 分子为例 - ``[['H', [-1.68666, 1.79811, 0.0]], ['H', [-1.12017, 1.37343, 0.0]]]`` - file (string, optional): .xyz 文件的路径 - - Returns: - str: 分子的几何信息 + structure: Including molecular geometry information in string, take H2 as an example + ``[['H', [-1.68666, 1.79811, 0.0]], ['H', [-1.12017, 1.37343, 0.0]]]``. Defaults to None. + file: The path of .xyz file. Defaults to None. Raises: - AssertionError: 两个输入参数不可以同时为 ``None`` + AssertionError: The two optional input cannot be None simultaneously. + + Returns: + Molecular geometry information. """ if structure is None and file is None: raise AssertionError('Input must be structure or .xyz file') @@ -202,7 +203,7 @@ def geometry(structure=None, file=None): shape = np.array(structure).shape assert shape[1] == 2, 'The shape of structure must be (n, 2)' for i in range(shape[0]): - assert type(np.array(structure)[:, 0][i]) == str, 'The first position must be element symbol' + assert isinstance(np.array(structure)[:, 0][i], str), 'The first position must be element symbol' assert len(np.array(structure)[:, 1][i]) == 3, 'The second position represents coordinate ' \ 'of particle: x, y, z' geo = structure @@ -222,33 +223,32 @@ def geometry(structure=None, file=None): def get_molecular_data( - geometry, - charge=0, - multiplicity=1, - basis='sto-3g', - method='scf', - if_save=True, - if_print=True, - name="", - file_path="." -): - r"""计算分子的必要信息，包括单体积分（one-body integrations）和双体积分（two-body integrations）， - 以及用选定的方法计算基态的能量。 + geometry: str, + charge: int=0, + multiplicity: int=1, + basis: str='sto-3g', + method: str='scf', + if_save: bool=True, + if_print: bool=True, + name: str="", + file_path: str="." +) -> MolecularData: + r"""Calculate necessary values of molecule, including one-body integrations, two-body integrations, and the ground state energy calculated by a chosen method Args: - geometry (str): 分子的几何信息 - charge (int, optional): 分子的电荷，默认值为 0 - multiplicity (int, optional): 分子的多重度，默认值为 1 - basis (str, optional): 常用的基组是 ``'sto-3g'`` 、 ``'6-31g'`` 等，默认的基组是 ``'sto-3g'``，更多的基组选择可以参考网站 - https://psicode.org/psi4manual/master/basissets_byelement.html#apdx-basiselement - method (str, optional): 用于计算基态能量的方法，包括 ``'scf'`` 和 ``'fci'`` ，默认方法为 ``'scf'`` - if_save (bool, optional): 是否需要将分子信息存储成 .hdf5 文件，默认为 ``True`` - if_print (bool, optional): 是否需要打印出选定方法 (method) 计算出的分子基态能量，默认为 ``True`` - name (str, optional): 命名储存的文件，默认为 ``""`` - file_path (str, optional): 文件的储存路径，默认为 ``"."`` + geometry: Molecular geometry information. + charge: Molecular charge. Defaults to 0. + multiplicity: Molecular multiplicity. Defaults to 1. + basis: Most common used basis are ‘sto-3g’, ‘6-31g’. For more basis options, please refer to + https://psicode.org/psi4manual/master/basissets_byelement.html#apdx-basiselement. Defaults to 'sto-3g'. + method: Method to calculate ground state energy, including ``scf``, ``fci``. Defaults to ``scf``. + if_save: If need to save molecule information as .hdf5 file. Defaults to True. + if_print: If need to print ground state energy calculated by chosen method. Defaults to True. + name: The name of the file to save. Defaults to "". + file_path: The path of the file to save. Defaults to ".". Returns: - MolecularData: 包含分子所有信息的类 + A class contains information of the molecule. """ methods = ['scf', 'fci'] assert method in methods, 'We provide 2 methods: scf and fci' @@ -293,23 +293,23 @@ def get_molecular_data( def active_space( - electrons, - orbitals, - multiplicity=1, - active_electrons=None, - active_orbitals=None -): - r"""对于给定的活跃电子和活跃轨道计算相应的活跃空间（active space）。 + electrons: int, + orbitals: int, + multiplicity: int=1, + active_electrons: int=None, + active_orbitals: int=None +) -> tuple: + r"""Calculate active space by nominating the number of active electrons and active orbitals. Args: - electrons (int): 电子数 - orbitals (int): 轨道数 - multiplicity (int, optional): 自旋多重度 - active_electrons (int, optional): 活跃 (active) 电子数，默认情况为所有电子均为活跃电子 - active_orbitals (int, optional): 活跃 (active) 轨道数，默认情况为所有轨道均为活跃轨道 + electrons: Number of total electrons. + orbitals: Number of total orbitals. + multiplicity: Spin multiplicity. Defaults to 1. + active_electrons: Number of active electrons, default to the case that all electrons are active. + active_orbitals: Number of active orbitals, default to the case that all orbitals are active. Returns: - tuple: 核心轨道和活跃轨道的索引 + Index for core orbitals and active orbitals. """ assert type(electrons) == int and electrons > 0, 'Number of electrons must be positive integer.' assert type(orbitals) == int and orbitals > 0, 'Number of orbitals must be positive integer.' @@ -348,23 +348,23 @@ def active_space( def fermionic_hamiltonian( - molecule, - filename=None, - multiplicity=1, - active_electrons=None, - active_orbitals=None -): - r"""计算给定分子的费米哈密顿量。 + molecule: MolecularData, + filename: str=None, + multiplicity: int=1, + active_electrons: int=None, + active_orbitals: int=None +) -> openfermion.ops.operators.qubit_operator.QubitOperator: + r"""Calculate the fermionic hamiltonian of the given molecule. Args: - molecule (MolecularData): 包含分子所有信息的类 - filename (str, optional): 分子的 .hdf5 文件的路径 - multiplicity (int, optional): 自旋多重度 - active_electrons (int, optional): 活跃 (active) 电子数，默认情况为所有电子均为活跃电子 - active_orbitals (int, optional): 活跃 (active) 轨道数，默认情况为所有轨道均为活跃轨道 + molecule: A class contains information of the molecule. + filename: Path of .hdf5 file of molecule. Defaults to None. + multiplicity: Spin multiplicity. Defaults to 1. + active_electrons: Number of active electrons, default to the case that all electrons are active. + active_orbitals: Number of active orbitals, default to the case that all orbitals are active. Returns: - openfermion.ops.operators.qubit_operator.QubitOperator: openfermion 格式的哈密顿量 + Hamiltonian in openfermion form. """ if molecule is None: assert type(filename) == str, 'Please provide the path of .hdf5 file.' @@ -385,25 +385,25 @@ def fermionic_hamiltonian( def spin_hamiltonian( - molecule, - filename=None, - multiplicity=1, - mapping_method='jordan_wigner', - active_electrons=None, - active_orbitals=None -): - r"""生成 Paddle Quantum 格式的哈密顿量 + molecule: openfermion.ops.operators.qubit_operator.QubitOperator , + filename: str=None, + multiplicity: int=1, + mapping_method: str='jordan_wigner', + active_electrons: int=None, + active_orbitals: int=None +) -> Hamiltonian: + r"""Generate Hamiltonian in Paddle Quantum form. Args: - molecule (openfermion.ops.operators.qubit_operator.QubitOperator): openfermion 格式的哈密顿量 - filename (str, optional): 分子的 .hdf5 文件的路径 - multiplicity (int, optional): 自旋多重度 - mapping_method (str, optional): 映射方法，这里默认为 ``'jordan_wigner'`` ，此外还提供 ``'bravyi_kitaev'`` - active_electrons (int, optional): 活跃 (active) 电子数，默认情况为所有电子均为活跃电子 - active_orbitals (int, optional): 活跃 (active) 轨道数默认情况为所有轨道均为活跃轨道 + molecule: Hamiltonian in openfermion form. + filename: Path of .hdf5 file of molecule. Defaults to None. + multiplicity: Spin multiplicity. Defaults to 1. + mapping_method: Transformation method, default to ``jordan_wigner``, besides, ``bravyi_kitaev`` is supported. Defaults to ``jordan_wigner``. + active_electrons: Number of active electrons, default to the case that all electrons are active. + active_orbitals: Number of active orbitals, default to the case that all orbitals are active. Returns: - paddle_quantum.utils.Hamiltonian: Paddle Quantum 格式的哈密顿量 + Hamiltonian in Paddle Quantum form """ assert mapping_method in ['jordan_wigner', 'bravyi_kitaev'], "Please choose the mapping " \ "in ['jordan_wigner', 'bravyi_kitaev']." @@ -417,4 +417,4 @@ def spin_hamiltonian( spin_h = transforms.jordan_wigner(fermionic_h) elif mapping_method == 'bravyi_kitaev': spin_h = transforms.bravyi_kitaev(fermionic_h) - return _hamiltonian_transformation(spin_h, tol=1e-8) + return qubitOperator_to_Hamiltonian(spin_h, tol=1e-8) diff --git a/paddle_quantum/qchem/qmodel.py b/paddle_quantum/qchem/qmodel.py deleted file mode 100755 index fd6321c..0000000 --- a/paddle_quantum/qchem/qmodel.py +++ /dev/null @@ -1,51 +0,0 @@ -# !/usr/bin/env python3 -# 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. - -""" -用于构建量子电路层的基类 -该模块依赖 paddlepaddle。 -""" - -from paddle import nn - - -class QModel(nn.Layer): - r"""量子化学用量子线路的基类，任何自定义量子线路都需要继承自这个类。 - """ - def __init__(self, num_qubit: int): - r"""构造函数 - - Args: - num_qubit (int): 量子比特数目 - """ - super().__init__(name_scope="QModel") - self._n_qubit = num_qubit - self._circuit = None - - @property - def n_qubit(self): - r"""量子比特数目 - """ - return self._n_qubit - - @property - def circuit(self): - r"""量子电路 - """ - if self._circuit is None: - print("Circuit is not built, please run `forward` to build the circuit first.") - return None - else: - return self._circuit diff --git a/paddle_quantum/qchem/run.py b/paddle_quantum/qchem/run.py deleted file mode 100755 index cb2c9f5..0000000 --- a/paddle_quantum/qchem/run.py +++ /dev/null @@ -1,180 +0,0 @@ -# !/usr/bin/env python3 -# 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. -""" -利用不同的 ansatz 运行量子化学计算。 -""" - -from typing import List, Tuple, Callable -import numpy as np -import paddle -from paddle.optimizer import Optimizer, Adam -from . import qchem as pq_chem -import paddle_quantum.state as pq_state -from paddle_quantum.intrinsic import vec_expecval - -from .ansatz.rhf import RestrictHartreeFockModel -from .qmodel import QModel -from .ansatz import HardwareEfficientModel - - -def _minimize( - model: QModel, - loss_fn: Callable[[QModel], Tuple[float, QModel]], - optimizer: Optimizer, - max_iters: int, - a_tol: float -) -> Tuple[float, QModel]: - loss_prev = -np.inf - for i in range(max_iters): - with paddle.no_grad(): - loss = loss_fn(model) - print(f"Iteration {i+1:>d}, {model.__class__.__name__} energy {loss.item():>.5f}.") - - if np.abs(loss.item() - loss_prev) < a_tol: - print(f"Converge after {(i+1):>d} number of iterations.") - break - else: - loss_prev = loss.item() - - optimizer.clear_grad() - loss = loss_fn(model) - loss.backward() - optimizer.step() - - with paddle.no_grad(): - loss = loss_fn(model) - - return loss.item(), model - - -def run_chem( - geometry: List[Tuple[str, List[float]]], - ansatz: str, - basis_set: str = "sto-3g", - charge: int = 0, - max_iters: int = 100, - a_tol: float = 1e-6, - optimizer_option: dict = {}, - ansatz_option: dict = {} -) -> Tuple[float, QModel]: - r"""根据输入的分子信息进行量子化学计算。 - - Args: - geometry (List[Tuple[str, List[float]]]): 分子的几何结构，例如：[("H", [0.0, 0.0, 0.0]), ("H", [0.0, 0.0, 0.74])]。定义结构时使用的长度单位是 Angstrom。 - ansatz (str): 表示多体波函数的量子线路，目前我们支持 "hardware efficient" 和 "hartree fock"。 - basis_set (str): 用来展开原子轨道的量子化学的基函数，例如："sto-3g"。注意，复杂的基函数会极大占用计算资源。 - charge (int): 分子的电荷量。 - max_iters (int): 优化过程的最大迭代次数。 - a_tol (float): 优化收敛的判断依据，当 :math:`|e_{i+1} - e_i| < a_{tol}` 时，优化结束。 - optimizer_options (dict): 优化器的可选参数，例如：学习率 (learning_rate)、权重递减 (weight_decay)。 - ansatz_option (dict): 定义 ansatz 量子线路的可选参数。目前，对于 "hardware efficient" 方法，可选参数为 "cir_depth"（线路深度）。"hartree fock" 方法没有可选参数。 - - Returns: - tuple: - - 基态能量 - - 优化后的 ansatz 量子线路 - """ - - if ansatz == "hardware efficient": - return run_hardware( - geometry, basis_set, charge, - max_iters, a_tol, optimizer_option, **ansatz_option - ) - - if ansatz == "hartree fock": - return run_rhf( - geometry, basis_set, charge, - max_iters, a_tol, optimizer_option, **ansatz_option - ) - - else: - raise NotImplementedError( - """ - Currently, we only support "hardware efficient" or "hartree fock" for `ansatz` parameter, we will add more in the future. You can open an issue here - https://github.com/PaddlePaddle/Quantum/issues to report the ansatz you're interested in. - """) - - -def run_hardware( - geometry: List[Tuple[str, List[float]]], - basis_set: str, - charge: int, - max_iters: int, - a_tol: float, - optimizer_option: dict = {}, - cir_depth: int = 3 -) -> Tuple[float, QModel]: - r"""hardware efficient 方法的 run 函数。 - - """ - mol_data = pq_chem.get_molecular_data(geometry, basis=basis_set, charge=charge, if_print=False) - mol_qubitH = pq_chem.spin_hamiltonian(mol_data) - - n_qubits = mol_qubitH.n_qubits - ansatz = HardwareEfficientModel(n_qubits, cir_depth) - optimizer = Adam(parameters=ansatz.parameters(), **optimizer_option) - - s0 = paddle.to_tensor(pq_state.vec(0, n_qubits)) - s0 = paddle.reshape(s0, [2**n_qubits]) - - def loss_fn(model: QModel) -> paddle.Tensor: - s = model(s0) - return paddle.real(vec_expecval(mol_qubitH.pauli_str, s)) - - mol_gs_en, updated_ansatz = _minimize(ansatz, loss_fn, optimizer, max_iters, a_tol) - return mol_gs_en, updated_ansatz - - -def run_rhf( - geometry: List[Tuple[str, List[float]]], - basis_set: str, - charge: int, - max_iters: int, - a_tol: float, - optimizer_option: dict = {} -) -> Tuple[float, QModel]: - r"""hartree fock 方法的 run 函数。 - """ - try: - import pyscf - except ModuleNotFoundError as e: - raise ModuleNotFoundError( - """ - Hartree Fock method needs `pyscf`, - please run `pip install -U pyscf` to first install pyscf. - """) - - from .molecule import get_molecular_information - - n_qubits, n_electrons, integrals = get_molecular_information(geometry, basis_set, charge) - nuc_energy, onebody, twobody = [paddle.to_tensor(t) for t in integrals] - ansatz = RestrictHartreeFockModel(n_qubits, n_electrons, onebody) - optimizer = Adam(parameters=ansatz.parameters(), **optimizer_option) - - # run model to build the circuit - bstr = "1"*n_electrons+"0"*(n_qubits-n_electrons) - _s0 = paddle.to_tensor(pq_state.vec(int(bstr, 2), n_qubits)) - _s0 = paddle.reshape(_s0, [2**n_qubits]) - ansatz(_s0) - - def loss_fn(model: QModel) -> paddle.Tensor: - U_hf = model.single_particle_U() - rdm1 = U_hf @ U_hf.conj().t() - return nuc_energy + 2*paddle.einsum("pq,qp->", onebody, rdm1)\ - + 4*paddle.einsum("pqrs,qp,sr->", twobody, rdm1, rdm1)\ - - 2*paddle.einsum("pqrs,sp,qr->", twobody, rdm1, rdm1) - - mol_gs_en, updated_ansatz = _minimize(ansatz, loss_fn, optimizer, max_iters, a_tol) - return mol_gs_en, updated_ansatz diff --git a/paddle_quantum/qchem/slater_determinant.py b/paddle_quantum/qchem/slater_determinant.py new file mode 100644 index 0000000..5ce6a6b --- /dev/null +++ b/paddle_quantum/qchem/slater_determinant.py @@ -0,0 +1,98 @@ +# !/usr/bin/env python3 +# 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. + +r""" +Slater determinant ansatz used in restricted Hartree Fock method. +""" + +import logging +from typing import Union, cast +import numpy as np +from scipy.stats import unitary_group +import openfermion +import paddle +import paddle_quantum as pq + +__all__ = ["RHFSlaterDeterminantModel"] + + +class GivensRotationBlock(pq.gate.Gate): + r"""This is a two-qubit gate performs the Givens rotation. + + .. math:: + + \begin{align} + U(\theta)=e^{-i\frac{\theta}{2}(Y\otimes X-X\otimes Y)} + \end{align} + + Args: + pindex, qindex qubits where Givens rotation gate acts on. + theta: Givens rotation angle. + """ + def __init__( + self, + pindex: int, + qindex: int, + theta: float) -> None: + super().__init__(backend=pq.Backend.StateVector) + + cnot1 = pq.gate.CNOT([qindex, pindex]) + cnot2 = pq.gate.CNOT([pindex, qindex]) + ry_pos = pq.gate.RY(qindex, param=paddle.to_tensor(theta)) + ry_neg = pq.gate.RY(qindex, param=paddle.to_tensor(-theta)) + self.model = pq.ansatz.Sequential(cnot1, cnot2, ry_pos, cnot2, ry_neg, cnot1) + + def forward(self, state: pq.State) -> pq.State: + return self.model(state) + + +class RHFSlaterDeterminantModel(pq.gate.Gate): + r"""Slater determinant ansatz used in Restricted Hartree Fock calculation. + + Args: + n_qubits: number of qubits used to encode the Slater determinant state. + n_electrons: number of electrons inside the molecule. + mo_coeff: parameters used to initialize Slater determinant state. + """ + def __init__( + self, + n_qubits: int, + n_electrons: int, + mo_coeff: Union[np.array, None] = None) -> None: + assert (n_qubits % 2 == 0 and n_electrons % 2 == 0), "Restricted Hartree Fock calculation\ + should only be carried out for molecules with even number of electrons" + super().__init__(n_qubits, backend=pq.Backend.StateVector) + if mo_coeff is not None: + assert mo_coeff.shape == ( + n_electrons // 2, n_qubits // 2), f"The shape of `mo_coeff` should be {(n_electrons // 2, n_qubits // 2)},\ + but get {mo_coeff.shape}." + else: + logging.info("Will randomly initialize the circuit parameters.") + U = unitary_group.rvs(n_qubits // 2) + mo_coeff = U[:, :n_electrons // 2].T + + circuit_description = openfermion.slater_determinant_preparation_circuit(mo_coeff) + models = [] + for parallel_ops in circuit_description: + for op in parallel_ops: + qi, qj, theta, _ = cast((int, int, float, float), op) + givens_block_spinup = GivensRotationBlock(2 * qi, 2 * qj, theta) + givens_block_spindown = GivensRotationBlock(2 * qi + 1, 2 * qj + 1, theta) + models.append(givens_block_spinup) + models.append(givens_block_spindown) + self.model = pq.ansatz.Sequential(*models) + + def forward(self, state: pq.State) -> pq.State: + return self.model(state) diff --git a/paddle_quantum/qchem/uccsd.py b/paddle_quantum/qchem/uccsd.py new file mode 100644 index 0000000..f8cb957 --- /dev/null +++ b/paddle_quantum/qchem/uccsd.py @@ -0,0 +1,163 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +Unitary coupled cluster with singles and doubles for molecular ground state calculation. +""" + +from typing import Union +import numpy as np +import openfermion +from openfermion import FermionOperator +from openfermion.transforms import normal_ordered +import paddle_quantum as pq +from paddle_quantum.trotter import construct_trotter_circuit +from .qchem import qubitOperator_to_Hamiltonian + + +def _get_single_excitation_operator(p: int, q: int) -> FermionOperator: + r""" + Args: + p: index of the unoccupied orbital. + q: index of the occupied orbital. + + Returns: + FermionOperator, + .. math: + \hat{E}_{pq}\equiv\sum_{\sigma}\hat{c}^{\dagger}_{p\sigma}\hat{c}_{q\sigma} + """ + + return FermionOperator(f"{2 * p}^ {2 * q}") + FermionOperator(f"{2 * p + 1}^ {2 * q + 1}") + + +def _get_double_excitation_operator(p: int, q: int, r: int, s: int) -> FermionOperator: + r""" + Args: + p, r: index of the unoccupied orbital. + q, s: index of the occupied orbital. + + Returns: + FermionOperator, + .. math: + \hat{e}_{pqrs}=\sum_{\sigma\tau}\hat{c}^{\dagger}_{p\sigma}\hat{c}^{\dagger}_{r\tau}\hat{c}_{s\tau}\hat{c}_{q\sigma} + """ + + if p == r or q == s: + e2 = FermionOperator(f"{2 * p}^ {2 * r + 1}^ {2 * s + 1} {2 * q}") + \ + FermionOperator(f"{2 * p + 1}^ {2 * r}^ {2 * s} {2 * q + 1}") + else: + e2 = FermionOperator(f"{2 * p}^ {2 * r}^ {2 * s} {2 * q}") + \ + FermionOperator(f"{2 * p}^ {2 * r + 1}^ {2 * s + 1} {2 * q}") + \ + FermionOperator(f"{2 * p + 1}^ {2 * r}^ {2 * s} {2 * q + 1}") + \ + FermionOperator(f"{2 * p + 1}^ {2 * r + 1}^ {2 * s + 1} {2 * q + 1}") + return normal_ordered(e2) + + +def _get_antiH_single_excitation_operator(p: int, q: int) -> FermionOperator: + r""" + Args: + p: index of the unoccupied orbital. + q: index of the occupied orbital. + + Returns: + FermionOperator, + .. math: + \hat{E}_{pq}-\hat{E}_{qp} + """ + + e1_pq = _get_single_excitation_operator(p, q) + e1_qp = _get_single_excitation_operator(q, p) + return e1_pq - e1_qp + + +def _get_antiH_double_excitation_operator(p: int, q: int, r: int, s: int) -> FermionOperator: + r""" + Args: + p, r: index of the unoccupied orbital. + q, s: index of the occupied orbital. + + Returns: + FermionOperator, + .. math: + \hat{e}_{pqrs}-\hat{e}_{srqp} + """ + + e2_pqrs = _get_double_excitation_operator(p, q, r, s) + e2_srqp = _get_double_excitation_operator(s, r, q, p) + return e2_pqrs - e2_srqp + + +class UCCSDModel(pq.gate.Gate): + r"""Unitary Coupled Cluster ansatz for quantum chemistry calculation. + + .. note:: + UCCSD model typically results in REALLY deep quantum circuit. Training UCCSD ansatz for molecules beyond H2 is time consuming and demands better hardware. + + .. math:: + + \begin{align} + U(\theta)&=e^{\hat{T}-\hat{T}^{\dagger}}\\ + \hat{T}&=\hat{T}_1+\hat{T}_2\\ + \hat{T}_1&=\sum_{a\in{\text{virt}}}\sum_{i\in\text{occ}}t_{ai}\sum_{\sigma}\hat{c}^{\dagger}_{a\sigma}\hat{c}_{i\sigma}-h.c.\\ + \hat{T}_2&=\frac{1}{2}\sum_{a,b\in\text{virt}}\sum_{i,j\in\text{occ}}t_{aibj}\sum_{\sigma\tau}\hat{c}^{\dagger}_{a\sigma}\hat{c}^{\dagger}_{b\tau}\hat{c}_{j\tau}\hat{c}_{i\sigma}-h.c. + \end{align} + + Args: + n_qubits: number of qubits used to represent the quantum system. + n_electrons: number of electrons inside the system. + n_trotter_steps: number of Trotter steps required to build the UCCSD circuit. + single_excitation_amplitude: :math:`t_{ai}` in the definition of :math:`\hat{T}_1`. + double_excitation_amplitude: :math:`t_{aibj}` in the definition of :math:`\hat{T}_2`. + """ + def __init__( + self, + n_qubits: int, + n_electrons: int, + n_trotter_steps: int, + single_excitation_amplitude: Union[np.array, None] = None, + double_excitation_amplitude: Union[np.array, None] = None) -> None: + super().__init__(n_qubits, backend=pq.Backend.StateVector) + + n_occupied_mos = n_electrons // 2 + n_mos = n_qubits // 2 + occupied_orbitals = list(range(n_occupied_mos)) + virtual_orbitals = list(range(n_occupied_mos, n_mos)) + + if single_excitation_amplitude is None: + single_excitation_amplitude = np.random.randn(n_qubits, n_qubits) + if double_excitation_amplitude is None: + double_excitation_amplitude = np.random.randn(n_qubits, n_qubits, n_qubits, n_qubits) + + ucc_generator = FermionOperator() + for a in virtual_orbitals: + for i in occupied_orbitals: + ucc_generator += single_excitation_amplitude[a, i] * _get_antiH_single_excitation_operator(a, i) + for b in virtual_orbitals: + for j in occupied_orbitals: + ucc_generator += double_excitation_amplitude[ + a, i, b, j] * _get_antiH_double_excitation_operator(a, i, b, j) + + ucc_hamiltonian = -1j * ucc_generator + ucc_hamilton_qubit = openfermion.jordan_wigner(ucc_hamiltonian) + ucc_pqH = qubitOperator_to_Hamiltonian(ucc_hamilton_qubit) + self.uccsd_hamilton = ucc_pqH + + circuit = pq.ansatz.Circuit() + tau = 1.0 / n_trotter_steps + construct_trotter_circuit(circuit, ucc_pqH, tau=tau, steps=n_trotter_steps) + self.model = circuit + + def forward(self, state: pq.State) -> pq.State: + return self.model(state) diff --git a/paddle_quantum/qinfo.py b/paddle_quantum/qinfo.py new file mode 100644 index 0000000..dd54692 --- /dev/null +++ b/paddle_quantum/qinfo.py @@ -0,0 +1,641 @@ +# !/usr/bin/env python3 +# 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. + +r""" +The function for quantum information. +""" + +import paddle_quantum +import math +import re +import numpy as np +from scipy.linalg import logm, sqrtm +import paddle +from paddle import kron +from paddle import matmul +from paddle import transpose +from paddle_quantum.intrinsic import _get_float_dtype +import matplotlib.image +from paddle_quantum.linalg import dagger, is_unitary, NKron +from typing import Optional, Tuple, List + + +def partial_trace(rho_AB: paddle_quantum.State, dim1: int, dim2: int, A_or_B: int) -> paddle.Tensor: + r"""Calculate the partial trace of the quantum state. + + Args: + rho_AB: Input quantum state. + dim1: The dimension of system A. + dim2: The dimension of system B. + A_or_B: 1 or 2. 1 means to calculate partial trace on system A; 2 means to calculate partial trace on system B. + + Returns: + Partial trace of the input quantum state. + """ + if A_or_B == 2: + dim1, dim2 = dim2, dim1 + + rho_AB = rho_AB.data + complex_dtype = paddle_quantum.get_dtype() + float_dtype = _get_float_dtype(complex_dtype) + + idty_np = np.identity(dim2).astype(complex_dtype) + idty_B = paddle.to_tensor(idty_np) + + zero_np = np.zeros([dim2, dim2], complex_dtype) + res = paddle.to_tensor(zero_np) + + for dim_j in range(dim1): + row_top = paddle.zeros([1, dim_j]) + row_mid = paddle.ones([1, 1]) + row_bot = paddle.zeros([1, dim1 - dim_j - 1]) + bra_j = paddle.concat([row_top, row_mid, row_bot], axis=1) + bra_j = paddle.cast(bra_j, complex_dtype) + + if A_or_B == 1: + row_tmp = kron(bra_j, idty_B) + row_tmp_conj = paddle.conj(row_tmp) + res = paddle.add(res, paddle.matmul(paddle.matmul(row_tmp, rho_AB), paddle.transpose(row_tmp_conj, perm=[1, 0]), ), ) + + if A_or_B == 2: + row_tmp = kron(idty_B, bra_j) + row_tmp_conj = paddle.conj(row_tmp) + res = paddle.add(res, paddle.matmul(paddle.matmul(row_tmp, rho_AB), paddle.transpose(row_tmp_conj, perm=[1, 0]), ), ) + + return res + + +def partial_trace_discontiguous(rho: paddle_quantum.State, preserve_qubits: Optional[list] = None) -> paddle.Tensor: + r"""Calculate the partial trace of the quantum state with arbitrarily selected subsystem + + Args: + rho: Input quantum state. + preserve_qubits: Remaining qubits, default is None, indicate all qubits remain. + + Returns: + Partial trace of the quantum state with arbitrarily selected subsystem. + """ + if type(rho) == paddle_quantum.State: + rho = rho.data + complex_dtype = paddle_quantum.get_dtype() + float_dtype = _get_float_dtype(complex_dtype) + + if preserve_qubits is None: + return rho + else: + n = int(math.log2(rho.size) // 2) + num_preserve = len(preserve_qubits) + + shape = paddle.ones((n + 1,)) + shape = 2 * shape + shape[n] = 2 ** n + shape = paddle.cast(shape, "int32") + identity = paddle.eye(2 ** n) + identity = paddle.reshape(identity, shape=shape) + discard = list() + for idx in range(0, n): + if idx not in preserve_qubits: + discard.append(idx) + addition = [n] + preserve_qubits.sort() + + preserve_qubits = paddle.to_tensor(preserve_qubits) + discard = paddle.to_tensor(discard) + addition = paddle.to_tensor(addition) + permute = paddle.concat([discard, preserve_qubits, addition]) + + identity = paddle.transpose(identity, perm=permute) + identity = paddle.reshape(identity, (2 ** n, 2 ** n)) + + result = np.zeros((2 ** num_preserve, 2 ** num_preserve), dtype=complex_dtype) + result = paddle.to_tensor(result) + + for i in range(0, 2 ** (n - num_preserve)): + bra = identity[i * 2 ** num_preserve:(i + 1) * 2 ** num_preserve, :] + result = result + matmul(matmul(bra, rho), transpose(bra, perm=[1, 0])) + + return result + + +def trace_distance(rho: paddle_quantum.State, sigma: paddle_quantum.State) -> paddle.Tensor: + r"""Calculate the trace distance between two quantum states. + + .. math:: + + D(\rho, \sigma) = 1 / 2 * \text{tr}|\rho-\sigma| + + Args: + rho: Density matrix form of the quantum state. + sigma: Density matrix form of the quantum state. + + Returns: + Trace distance between the input quantum states. + """ + assert rho.data.shape == sigma.data.shape, 'The shape of two quantum states are different' + A = rho.data.numpy() - sigma.data.numpy() + distance = 1 / 2 * np.sum(np.abs(np.linalg.eigvals(A))) + + return paddle.to_tensor(distance) + + +def state_fidelity(rho: paddle_quantum.State, sigma: paddle_quantum.State) -> paddle.Tensor: + r"""Calculate the fidelity of two quantum states. + + .. math:: + F(\rho, \sigma) = \text{tr}(\sqrt{\sqrt{\rho}\sigma\sqrt{\rho}}) + + Args: + rho: Density matrix form of the quantum state. + sigma: Density matrix form of the quantum state. + + Returns: + The fidelity between the input quantum states. + """ + rho = rho.data.numpy() + sigma = sigma.data.numpy() + assert rho.shape == sigma.shape, 'The shape of two quantum states are different' + fidelity = np.trace(sqrtm(sqrtm(rho) @ sigma @ sqrtm(rho))).real + + return paddle.to_tensor(fidelity) + + +def gate_fidelity(U: paddle.Tensor, V: paddle.Tensor) -> paddle.Tensor: + r"""calculate the fidelity between gates + + .. math:: + + F(U, V) = |\text{tr}(UV^\dagger)|/2^n + + :math:`U` is a :math:`2^n\times 2^n` unitary gate + + Args: + U: quantum gate :math:`U` in matrix form + V: quantum gate :math:`V` in matrix form + + Returns: + fidelity between gates + + """ + complex_dtype = paddle_quantum.get_dtype() + U = paddle.to_tensor(U, dtype=complex_dtype) + V = paddle.to_tensor(V, dtype=complex_dtype) + # assert is_unitary(U), "U is not a unitary" + # assert is_unitary(V), "V is not a unitary" + assert U.shape == V.shape, 'The shape of two unitary matrices are different' + + fidelity = paddle.abs(paddle.trace(U @ dagger(V))) / U.shape[0] + return fidelity + + +def purity(rho: paddle_quantum.State) -> paddle.Tensor: + r"""Calculate the purity of a quantum state. + + .. math:: + + P = \text{tr}(\rho^2) + + Args: + rho: Density matrix form of the quantum state. + + Returns: + The purity of the input quantum state. + """ + rho = rho.data + gamma = paddle.trace(paddle.matmul(rho, rho)) + + return gamma.real() + + +def von_neumann_entropy(rho: paddle_quantum.State) -> paddle.Tensor: + r"""Calculate the von Neumann entropy of a quantum state. + + .. math:: + + S = -\text{tr}(\rho \log(\rho)) + + Args: + rho: Density matrix form of the quantum state. + + Returns: + The von Neumann entropy of the input quantum state. + """ + rho = rho.data.numpy() + rho_eigenvalues = np.real(np.linalg.eigvals(rho)) + entropy = 0 + for eigenvalue in rho_eigenvalues: + if np.abs(eigenvalue) < 1e-8: + continue + entropy -= eigenvalue * np.log(eigenvalue) + + return paddle.to_tensor(entropy) + + +def relative_entropy(rho: paddle_quantum.State, sig: paddle_quantum.State) -> paddle.Tensor: + r"""Calculate the relative entropy of two quantum states. + + .. math:: + + S(\rho \| \sigma)=\text{tr} \rho(\log \rho-\log \sigma) + + + Args: + rho: Density matrix form of the quantum state. + sig: Density matrix form of the quantum state. + + Returns: + Relative entropy between input quantum states. + """ + rho = rho.data.numpy() + sig = sig.data.numpy() + assert rho.shape == sig.shape, 'The shape of two quantum states are different' + res = np.trace(rho @ logm(rho) - rho @ logm(sig)) + return paddle.to_tensor(res.real) + + +def random_pauli_str_generator(n: int, terms: Optional[int] = 3) -> List: + r"""Generate a random observable in list form. + + An observable :math:`O=0.3X\otimes I\otimes I+0.5Y\otimes I\otimes Z`'s list form is + ``[[0.3, 'x0'], [0.5, 'y0,z2']]``. Such an observable is generated by + ``random_pauli_str_generator(3, terms=2)`` + + Args: + n: Number of qubits. + terms: Number of terms in the observable. Defaults to 3. + + Returns: + The randomly generated observable’s list form. + """ + pauli_str = [] + for sublen in np.random.randint(1, high=n + 1, size=terms): + # Tips: -1 <= coeff < 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)] + pauli_str.append([coeff, ','.join(op_list)]) + return pauli_str + + +def pauli_str_to_matrix(pauli_str: list, n: int) -> paddle.Tensor: + r"""Convert the input list form of an observable to its matrix form. + + For example, if the input ``pauli_str`` is ``[[0.7, 'z0,x1'], [0.2, 'z1']]`` and ``n=3``, + then this function returns the observable :math:`0.7Z\otimes X\otimes I+0.2I\otimes Z\otimes I` + in matrix form. + + Args: + pauli_str: A list form of an observable. + n: Number of qubits. + + Raises: + ValueError: Only Pauli operator "I" can be accepted without specifying its position. + + Returns: + The matrix form of the input observable. + """ + pauli_dict = {'i': np.eye(2) + 0j, 'x': np.array([[0, 1], [1, 0]]) + 0j, + 'y': np.array([[0, -1j], [1j, 0]]), 'z': np.array([[1, 0], [0, -1]]) + 0j} + + # Parse pauli_str; 'x0,z1,y4' to 'xziiy' + new_pauli_str = [] + for coeff, op_str in pauli_str: + init = list('i' * n) + op_list = re.split(r',\s*', op_str.lower()) + for op in op_list: + 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) + matrices = [] + for coeff, op_str in new_pauli_str: + sub_matrices = [] + for op in op_str: + sub_matrices.append(pauli_dict[op.lower()]) + if len(op_str) == 1: + matrices.append(coeff * sub_matrices[0]) + else: + matrices.append(coeff * NKron(sub_matrices[0], sub_matrices[1], *sub_matrices[2:])) + + return paddle.to_tensor(sum(matrices), dtype=paddle_quantum.get_dtype()) + + +def partial_transpose_2(density_op: paddle_quantum.State, sub_system: Optional[int] = None) -> paddle.Tensor: + r"""Calculate the partial transpose :math:`\rho^{T_A}` of the input quantum state. + + Args: + density_op: Density matrix form of the quantum state. + sub_system: 1 or 2. 1 means to perform partial transpose on system A; 2 means to perform partial trace on system B. Default is 2. + + Returns: + The partial transpose of the input quantum state. + """ + sys_idx = 2 if sub_system is None else 1 + + # Copy the density matrix and not corrupt the original one + density_op = density_op.data.numpy() + transposed_density_op = np.copy(density_op) + 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() + 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] + + return paddle.to_tensor(transposed_density_op) + + +def partial_transpose(density_op: paddle_quantum.State, n: int) -> paddle.Tensor: + r"""Calculate the partial transpose :math:`\rho^{T_A}` of the input quantum state. + + Args: + density_op: Density matrix form of the quantum state. + n: Number of qubits of the system to be transposed. + + Returns: + The partial transpose of the input quantum state. + """ + # Copy the density matrix and not corrupt the original one + density_op = density_op.data.numpy() + 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() + + return paddle.to_tensor(transposed_density_op) + + +def negativity(density_op: paddle_quantum.State) -> paddle.Tensor: + r"""Compute the Negativity :math:`N = ||\frac{\rho^{T_A}-1}{2}||` of the input quantum state. + + Args: + density_op: Density matrix form of the quantum state. + + Returns: + The Negativity of the input quantum state. + """ + # Implement the partial transpose + density_op_T = partial_transpose_2(density_op) + + # Calculate through the equivalent expression N = sum(abs(\lambda_i)) when \lambda_i<0 + n = 0.0 + eigen_val, _ = np.linalg.eig(density_op_T) + for val in eigen_val: + if val < 0: + n = n + np.abs(val) + return paddle.to_tensor(n) + + +def logarithmic_negativity(density_op: paddle_quantum.State) -> paddle.Tensor: + r"""Calculate the Logarithmic Negativity :math:`E_N = ||\rho^{T_A}||` of the input quantum state. + + Args: + density_op: Density matrix form of the quantum state. + + Returns: + The Logarithmic Negativity of the input quantum state. + """ + # Calculate the negativity + n = negativity(density_op) + + # Calculate through the equivalent expression + log2_n = paddle.log2(2 * n + 1) + return log2_n + + +def is_ppt(density_op: paddle_quantum.State) -> bool: + r"""Check if the input quantum state is PPT. + + Args: + density_op: Density matrix form of the quantum state. + + Returns: + Whether the input quantum state is PPT. + """ + # By default the PPT condition is satisfied + ppt = True + + # Detect negative eigenvalues from the partial transposed density_op + if negativity(density_op) > 0: + ppt = False + return ppt + + +def schmidt_decompose(psi: paddle_quantum.State, sys_A: Optional[List[int]] = None) -> Tuple[paddle.Tensor]: + r"""Calculate the Schmidt decomposition of a quantum state :math:`\lvert\psi\rangle=\sum_ic_i\lvert i_A\rangle\otimes\lvert i_B \rangle`. + + Args: + psi: State vector form of the quantum state, with shape（2**n） + sys_A: Qubit indices to be included in subsystem A (other qubits are included in subsystem B), default are the first half qubits of :math:`\lvert \psi\rangle` + + Returns: + contains elements + + * A one dimensional array composed of Schmidt coefficients, with shape ``(k)`` + * A high dimensional array composed of bases for subsystem A :math:`\lvert i_A\rangle`, with shape ``(k, 2**m, 1)`` + * A high dimensional array composed of bases for subsystem B :math:`\lvert i_B\rangle` , with shape ``(k, 2**m, 1)`` + """ + psi = psi.data.numpy() + assert psi.ndim == 1, 'Psi must be a one dimensional vector.' + assert np.log2(psi.size).is_integer(), 'The number of amplitutes must be an integral power of 2.' + + + tot_qu = int(np.log2(psi.size)) + sys_A = sys_A if sys_A is not None else [i for i in range(tot_qu//2)] + sys_B = [i for i in range(tot_qu) if i not in sys_A] + + # Permute qubit indices + psi = psi.reshape([2] * tot_qu).transpose(sys_A + sys_B) + + # construct amplitute matrix + amp_mtr = psi.reshape([2**len(sys_A), 2**len(sys_B)]) + + # Standard process to obtain schmidt decomposition + u, c, v = np.linalg.svd(amp_mtr) + + k = np.count_nonzero(c > 1e-13) + c = c[:k] + u = u.T[:k].reshape([k, -1, 1]) + v = v[:k].reshape([k, -1, 1]) + return paddle.to_tensor(c), paddle.to_tensor(u), paddle.to_tensor(v) + + +def image_to_density_matrix(image_filepath: str) -> paddle_quantum.State: + r"""Encode image to density matrix + + Args: + image_filepath: Path to the image file. + + Returns: + The density matrix obtained by encoding + """ + image_matrix = matplotlib.image.imread(image_filepath) + + # Converting images to grayscale + image_matrix = image_matrix.mean(axis=2) + + # Fill the matrix so that it becomes a matrix whose shape is [2**n,2**n] + length = int(2**np.ceil(np.log2(np.max(image_matrix.shape)))) + image_matrix = np.pad(image_matrix, ((0, length-image_matrix.shape[0]), (0, length-image_matrix.shape[1])), 'constant') + # Density matrix whose trace is 1 + rho = image_matrix@image_matrix.T + rho = rho/np.trace(rho) + return paddle_quantum.State(paddle.to_tensor(rho), backend=paddle_quantum.Backend.DensityMatrix) + + +def shadow_trace(state: 'paddle_quantum.State', hamiltonian: paddle_quantum.Hamiltonian, + sample_shots: int, method: Optional[str] = 'CS') -> float: + r"""Estimate the expectation value :math:`\text{trace}(H\rho)` of an observable :math:`H`. + + Args: + state: Quantum state. + hamiltonian: Observable. + sample_shots: Number of samples. + method: Method used to , which should be one of “CS”, “LBCS”, and “APS”. Default is “CS”. + + Returns: + The estimated expectation value for the hamiltonian. + """ + if not isinstance(hamiltonian, list): + hamiltonian = hamiltonian.pauli_str + num_qubits = state.num_qubits + mode = state.backend + if method == "LBCS": + result, beta = paddle_quantum.shadow.shadow_sample(state, num_qubits, sample_shots, mode, hamiltonian, method) + else: + result = paddle_quantum.shadow.shadow_sample(state, num_qubits, sample_shots, mode, hamiltonian, method) + + def prepare_hamiltonian(hamiltonian, num_qubits): + 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 = [] + pauli_terms = [] + 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): + 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): + # 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): + 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): + 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): + 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 = {} + 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 diff --git a/paddle_quantum/shadow.py b/paddle_quantum/shadow.py index 4aef814..182d9c1 100644 --- a/paddle_quantum/shadow.py +++ b/paddle_quantum/shadow.py @@ -1,3 +1,4 @@ +# !/usr/bin/env python3 # Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -12,200 +13,46 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" -shadow sample module +r""" +Shadow sample module. """ +import math import numpy as np import paddle import re -import math -from paddle_quantum import circuit -from paddle_quantum.utils import Hamiltonian +import paddle_quantum +from paddle_quantum import Hamiltonian +from typing import List, Optional __all__ = [ "shadow_sample" ] -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, mode, method): - r"""搭建 pauli 测量电路，返回测量结果 - - Args: - pauli_str (str): 输入的是随机选取的num_qubits pauli 测量基 - phi (numpy.ndarray): 输入量子态，支持态矢量和密度矩阵形式 - num_qubits (int): 量子比特数量 - mode (str): 输入量子态的表示方式，``"state_vector"`` 表示态矢量形式， ``"density_matrix"`` 表示密度矩阵形式 - 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 - - -def paulistr_to_matrix(paulistr): - r"""识别随机选取的 pauli 并转换成作用于 Z 测量的酉变换的矩阵形式 - - Args: - paulistr (str): 输入的是某一量子位上随机选取的 Pauli 测量基 - - Returns: - numpy.ndarray: 返回酉变换的矩阵形式 - - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - - # Define the matrix form of H, S gates - a = math.pow(2, 0.5) - H_matrix = np.array([[1 / a, 1 / a], [1 / a, -1 / a]]) - S_matrix = np.array([[1, 0], [0, 1j]]) - I_matrix = np.array([[1, 0], [0, 1]]) - - if paulistr == 'x': - paulistr_matrix = H_matrix - elif paulistr == 'y': - paulistr_matrix = np.dot(np.dot(H_matrix, S_matrix), H_matrix) - elif paulistr == 'z': - paulistr_matrix = I_matrix - return paulistr_matrix - - -def measure_result_to_matrix(measure_str): - r"""将单个量子位上测量的结果转换为密度矩阵形式 - - Args: - measure_str (str): 输入的是某一量子位上的测量结果 - - Returns: - numpy.ndarray: 返回测量结果的密度矩阵形式 - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ - - ket_0 = np.array([[1, 0]]).T - ket_1 = np.array([[0, 1]]).T - if measure_str == '0': - b_matrix = np.kron(ket_0, ket_0.conj().T) - elif measure_str == '1': - b_matrix = np.kron(ket_1, ket_1.conj().T) - return b_matrix - - -def shadow_sample(state, num_qubits, sample_shots, mode, hamiltonian=None, method='CS'): - r"""对给定的量子态进行随机的泡利测量并返回测量结果。 +def shadow_sample( + state: 'paddle_quantum.State', num_qubits: int, sample_shots: int, mode: paddle_quantum.Backend, + hamiltonian: Optional[paddle_quantum.Hamiltonian] = None, method: str = 'CS' +) -> list: + r"""Measure a given quantum state with random Pauli operators and return the measurement results. 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"`` + state: Input quantum state, which is either a state vector or a density matrix. + num_qubits: The number of qubits. + sample_shots: The number of random samples. + mode: Representation form of the input quantum state. + hamiltonian: A ``Hamiltonian`` object representing the observable to be measured. Defaults to ``None``. + method: Method for sampling random Pauli operators, which should be one of ``'CS'``, ``'LBCS'``, and ``'APS'``. Defaults to ``'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', ham, "LBCS") - sample_data_aps = shadow_sample(state, n_qubit, sample_shots, 'state_vector', ham, "APS") - - 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')] - + Randomly chosen Pauli operators and their corresponding measurement result in a list of shape ``(sample_shots, 2)``. """ - 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() + new_hamiltonian = [] for idx, (coeff, pauli_term) in enumerate(hamiltonian): pauli_term = re.split(r',\s*', pauli_term.lower()) pauli_list = ['i'] * num_qubits @@ -223,23 +70,46 @@ def prepare_hamiltonian(hamiltonian, num_qubits): pauli2index = {'x': 0, 'y': 1, 'z': 2} - # 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 测量基的概率分布 + def random_pauli_sample(num_qubits: int, beta: Optional[List[float]]=None): + # assume beta obeys a uniform distribution if it is not given + if beta is None: + beta = [] + 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 - Returns: - float: 返回计算值 + def measure_by_pauli_str(pauli_str, input_state, num_qubits, method): + if method == "clifford": + # Add the clifford function + pass + else: + # Other method are transformed as follows + # Convert to tensor form + for qubit in range(num_qubits): + if pauli_str[qubit] == 'x': + input_state = paddle_quantum.gate.functional.h(input_state, qubit, input_state.dtype, input_state.backend) + elif pauli_str[qubit] == 'y': + input_state = paddle_quantum.gate.functional.s(input_state, qubit, input_state.dtype, input_state.backend) + input_state = paddle_quantum.gate.functional.z(input_state, qubit, input_state.dtype, input_state.backend) + input_state = paddle_quantum.gate.functional.h(input_state, qubit, input_state.dtype, input_state.backend) + if input_state.backend == paddle_quantum.Backend.StateVector: + data = input_state.data.numpy() + prob_array = np.real(np.multiply(data, np.conj(data))) + elif input_state.backend == paddle_quantum.Backend.DensityMatrix: + data = input_state.data.numpy() + prob_array = np.real(np.diag(data)) + else: + raise NotImplementedError + sample = np.random.choice(range(0, 2 ** num_qubits), size=1, p=prob_array) + bit_string = bin(sample[0])[2:].zfill(num_qubits) + return bit_string - Note: - 这是内部函数，你并不需要直接调用到该函数。 - """ + # Define the function used to update the beta of the LBCS algorithm + def calculate_diagonal_product(pauli_str, beta): product = 1 for qubit_idx in range(len(pauli_str)): if pauli_str[qubit_idx] != 'i': @@ -253,22 +123,6 @@ def calculate_diagonal_product(pauli_str, beta): 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': @@ -280,22 +134,6 @@ def lagrange_restriction_numerator(qubit_idx, hamiltonian, 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": @@ -305,38 +143,12 @@ def lagrange_restriction_denominator(qubit_idx, random_observable, beta): 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) @@ -344,21 +156,6 @@ def beta_distance(beta1, beta2): 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): @@ -379,17 +176,6 @@ def update_beta_in_lbcs(hamiltonian, num_qubit, beta_old=None, weight=0.1): # 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): @@ -399,20 +185,6 @@ def in_omega(pauli_str, qubit_idx, qubit_shift, base_shift): 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): @@ -428,41 +200,16 @@ def update_in_aps(qubit_idx, qubits_shift, bases_shift, hamiltonian): 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() + pauli_str_shift = [] 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) @@ -473,15 +220,15 @@ def random_pauli_sample_in_aps(hamiltonian): pauli_sample = pauli_sample + pauli_str_shift[j] return pauli_sample - sample_result = list() + sample_result = [] 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, mode, method) + 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() + beta = [] for _ in range(0, num_qubits): beta.append([1 / 3] * 3) beta_opt_iter_num = 10000 @@ -491,94 +238,15 @@ def random_pauli_sample_in_aps(hamiltonian): beta = beta_opt if distance < distance_limit: break - sample_result = list() + sample_result = [] 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, mode, method) + 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, mode, method) + measurement_result = measure_by_pauli_str(random_pauli_str, state, num_qubits, method) sample_result.append((random_pauli_str, measurement_result)) return sample_result - - -def classical_shadow(state, num_qubits, sample_shots, mode, method=None): - r"""获得量子态 state 的经典影子 - - Args: - state (numpy.ndarray): 输入量子态，支持态矢量和密度矩阵形式 - num_qubits (int): 量子比特数量 - sample_shots (int): 随机采样的次数 - mode (str): 输入量子态的表示方式，``"state_vector"`` 表示态矢量形式， ``"density_matrix"`` 表示密度矩阵形式 - method (str, optional): 可选方法 restructure (R)，获得量子态的密度矩阵形式；或默认为None (即 not restructure, NR)，获得量子态的密度矩阵形式 - - Returns: - tuple: 包含如下两个元素 - - state_hat (list): 返回量子态 state 的经典影子 (method = 'NR') - - reconstructed_state (numpy.ndarray): 返回估计的量子态 state 的密度矩阵 (method = 'R') - - 代码示例: - - .. code-block:: python - - from paddle_quantum.shadow import classical_shadow - from paddle_quantum.state import vec_random - - n_qubit = 2 - sample_shots = 2 - state = vec_random(n_qubit) - state_shadow = classical_shadow(state, n_qubit, sample_shots, mode='state_vector', method='NR') - state_density_matrix = classical_shadow(state, n_qubit, sample_shots, mode='state_vector', method='R') - - print('classical shadow of quantum state = ', state_shadow) - print('density matrix of quantum state = ', state_density_matrix) - - :: - classical shadow of quantum state = [array([[ 0.25+0.j , 0. +0.75j, -0.75+0.j , -0. -2.25j], - [ 0. -0.75j, 0.25+0.j , 0. +2.25j, -0.75+0.j ], - [-0.75+0.j , -0. -2.25j, 0.25+0.j , 0. +0.75j], - [ 0. +2.25j, -0.75+0.j , 0. -0.75j, 0.25+0.j ]]), - array([[0.25+0.j , 0. -0.75j, 0.75+0.j , 0. -2.25j], - [0. +0.75j, 0.25+0.j , 0. +2.25j, 0.75+0.j ], - [0.75+0.j , 0. -2.25j, 0.25+0.j , 0. -0.75j], - [0. +2.25j, 0.75+0.j , 0. +0.75j, 0.25+0.j ]])] - density matrix of quantum state = [[ 0.625+0.j 0.375+0.j -1.5 +0.375j 0. +1.125j] - [ 0.375+0.j -0.125+0.j 0. +1.125j 0.75 +0.375j] - [-1.5 -0.375j 0. -1.125j 0.625+0.j 0.375+0.j ] - [ 0. -1.125j 0.75 -0.375j 0.375+0.j -0.125+0.j ]] - - """ - # Used to store the classic shadow for each sample - state_hat = [] - I_matrix = np.array([[1, 0], [0, 1]]) - - for _ in range(sample_shots): - # Randomly selected Pauli - random_pauli_str = random_pauli_sample(num_qubits, beta=None) - # Measure according to the selected Pauli - measurement_result = measure_by_pauli_str(random_pauli_str, state, num_qubits, mode, None) - # Generate a 1×1 matrix, convenient tensor product - hat_state = np.eye(1) - for i in range(num_qubits): - single_pauli_matrix = paulistr_to_matrix(random_pauli_str[i]) - single_b_matrix = measure_result_to_matrix(measurement_result[i]) - # The classical shadow on a single qubit is obtained according to the derived M inverse - single_qubit_state_left = np.dot(np.dot(single_pauli_matrix.conj().T, single_b_matrix), single_pauli_matrix) - single_qubit_state = 3 * single_qubit_state_left - I_matrix - # The classical shadow of quantum state is obtained - hat_state = np.kron(hat_state, single_qubit_state) - - # Store classical shadows - state_hat.append(hat_state) - - if method == 'R': - # Returns the density matrix of the quantum state - reconstructed_state = sum(state_hat)/len(state_hat) - return reconstructed_state - - else: - # Returns the classical shadow of the quantum state - return state_hat diff --git a/paddle_quantum/simulator.py b/paddle_quantum/simulator.py deleted file mode 100644 index ee49078..0000000 --- a/paddle_quantum/simulator.py +++ /dev/null @@ -1,989 +0,0 @@ -# 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. - -""" -This simulator uses statevector(Tensor) to simulate quantum behaviors. -Basically, the core of the algorithm is tensor contraction with one-way calculation that each gate is -contracted to the init vector when imported by the program. All the states including the gate and init -are converted to TENSOR and the calculating is also around tensor. - -:DEBUG INFO: -Sim2 --Sim2Main.py: this file, main entry of sim2 --InitProcess.py: Initial the state. --StateTransfer.py: Decide the gate matrix by gate name and real state process. --TransferProcess.py: Real transfer state process --MeasureProcess.py: Measure process -Ancilla --Random Circuit: Generate random circuit by requiring qubits and circuit depth --DEFINE_GATE: Gate matrix. -Two measure types are provided: Meas_MED = MEAS_METHOD.PROB and Meas_MED = MEAS_METHOD.SINGLE. PROB is the sample with -probability and SINGLE is by the state collapse method. Former is significant faster than the later. -""" - -import numpy as np -import paddle -import gc -from collections import Counter -import copy -from interval import Interval -from enum import Enum -import random - - -# InitProcess -def init_state_10(n): - """ - Generate state with n qubits - :param n: number of qubits - :return: tensor of state - """ - state1 = paddle.ones([1], 'float64') - state0 = paddle.zeros([2 ** n - 1], 'float64') - state = paddle.concat([state1, state0]) - del state1, state0 - gc.collect() # free the intermediate big data immediately - state = paddle.cast(state, 'complex128') - gc.collect() # free the intermediate big data immediately - - return state - - -def init_state_gen(n, i=0): - """ - Generate state with n qubits - :param n: number of qubits - :param i: the ith vector in computational basis - :return: tensor of state - """ - assert 0 <= i < 2 ** n, 'Invalid index' - - state = np.zeros([2 ** n], dtype=np.complex128) - state[i] = 1 - state = paddle.to_tensor(state) - - return state - - -# Define gate -def x_gate_matrix(): - """ - Pauli x - :return: - """ - return np.array([[0, 1], - [1, 0]], dtype=complex) - - -def y_gate_matrix(): - """ - Pauli y - :return: - """ - return np.array([[0, -1j], - [1j, 0]], dtype=complex) - - -def z_gate_matrix(): - """ - Pauli y - :return: - """ - return np.array([[1, 0], - [0, -1]], dtype=complex) - - -def h_gate_matrix(): - """ - Hgate - :return: - """ - isqrt_2 = 1.0 / np.sqrt(2.0) - return np.array([[isqrt_2, isqrt_2], - [isqrt_2, -isqrt_2]], dtype=complex) - - -def u_gate_matrix(params): - """ - U3 - :param params: - :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]) - - return re + im * paddle.to_tensor([1j], 'complex128') - elif (type(theta) is float and - type(phi) is float and - type(lam) is float): - return 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)]]) - else: - assert False - - -# compare the paddle and np version, they should be equal -# a = u_gate_matrix([1.0, 2.0, 3.0]) -# print(a) -# a = u_gate_matrix([paddle.to_tensor(np.array([1.0])), -# paddle.to_tensor(np.array([2.0])), -# 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(): - """ - Control Not - :return: - """ - return np.array([[1, 0, 0, 0], - [0, 1, 0, 0], - [0, 0, 0, 1], - [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 - :return: - """ - return np.array([[1, 0, 0, 0], - [0, 0, 1, 0], - [0, 1, 0, 0], - [0, 0, 0, 1]], dtype=complex).reshape(2, 2, 2, 2) - - -def rxx_gate_matrix(params): - """ - RXX gate - :return: - """ - theta = params[0] - re_a = paddle.cos(theta / 2) - re_b = paddle.zeros([1], 'float64') - im_a = paddle.sin(theta / 2) - im_b = paddle.zeros([1], 'float64') - re = paddle.reshape(paddle.concat([re_a, re_b, re_b, re_b, - re_b, re_a, re_b, re_b, - re_b, re_b, re_a, re_b, - re_b, re_b, re_b, re_a]), [4, 4]) - im = paddle.reshape(paddle.concat([im_b, im_b, im_b, im_a, - im_b, im_b, im_a, im_b, - im_b, im_a, im_b, im_b, - im_a, im_b, im_b, im_b]), [4, 4]) - - return re - im * paddle.to_tensor([1j], 'complex128') - - -def ryy_gate_matrix(params): - """ - RYY gate - :return: - """ - theta = params[0] - re_a = paddle.cos(theta / 2) - re_b = paddle.zeros([1], 'float64') - im_a = paddle.sin(theta / 2) - im_b = paddle.zeros([1], 'float64') - re = paddle.reshape(paddle.concat([re_a, re_b, re_b, re_b, - re_b, re_a, re_b, re_b, - re_b, re_b, re_a, re_b, - re_b, re_b, re_b, re_a]), [4, 4]) - im = paddle.reshape(paddle.concat([im_b, im_b, im_b, im_a, - im_b, im_b, -im_a, im_b, - im_b, -im_a, im_b, im_b, - im_a, im_b, im_b, im_b]), [4, 4]) - - return re + im * paddle.to_tensor([1j], 'complex128') - - -def rzz_gate_matrix(params): - """ - RZZ gate - :return: - """ - theta = params[0] - re_a = paddle.cos(theta / 2) - re_b = paddle.zeros([1], 'float64') - im_a = paddle.sin(theta / 2) - im_b = paddle.zeros([1], 'float64') - re = paddle.reshape(paddle.concat([re_a, re_b, re_b, re_b, - re_b, re_a, re_b, re_b, - re_b, re_b, re_a, re_b, - re_b, re_b, re_b, re_a]), [4, 4]) - im = paddle.reshape(paddle.concat([-im_a, im_b, im_b, im_b, - im_b, im_a, im_b, im_b, - im_b, im_b, im_a, im_b, - im_b, im_b, im_b, -im_a]), [4, 4]) - - return re + im * paddle.to_tensor([1j], 'complex128') - - -# PaddleE -def normalize_axis(axis, ndim): - if axis < 0: - axis += ndim - - if axis >= ndim or axis < 0: - raise ValueError("Invalid axis index %d for ndim=%d" % (axis, ndim)) - - return axis - - -def _operator_index(a): - return a.__index__() - - -def _normalize_axis_tuple(axis, ndim, argname=None, allow_duplicate=False): - # Optimization to speed-up the most common cases. - if type(axis) not in (tuple, list): - try: - axis = [_operator_index(axis)] - except TypeError: - pass - # Going via an iterator directly is slower than via list comprehension. - axis = tuple([normalize_axis(ax, ndim) for ax in axis]) - if not allow_duplicate and len(set(axis)) != len(axis): - if argname: - raise ValueError('repeated axis in `{}` argument'.format(argname)) - else: - raise ValueError('repeated axis') - return axis - - -def moveaxis(m, source, destination): - """ - extend paddle - :param m: - :param source: - :param destination: - :return: - """ - source = _normalize_axis_tuple(source, len(m.shape), 'source') - destination = _normalize_axis_tuple(destination, len(m.shape), 'destination') - if len(source) != len(destination): - raise ValueError('`source` and `destination` arguments must have ' - 'the same number of elements') - - order = [n for n in range(len(m.shape)) if n not in source] - - for dest, src in sorted(zip(destination, source)): - order.insert(dest, src) - - result = paddle.transpose(m, order) - return result - - -def complex_moveaxis(m, source, destination): - """ - extend paddle - :param m: - :param source: - :param destination: - :return: - """ - source = _normalize_axis_tuple(source, len(m.shape), 'source') - destination = _normalize_axis_tuple(destination, len(m.shape), 'destination') - if len(source) != len(destination): - raise ValueError('`source` and `destination` arguments must have ' - 'the same number of elements') - - order = [n for n in range(len(m.shape)) if n not in source] - - for dest, src in sorted(zip(destination, source)): - order.insert(dest, src) - - result = paddle.transpose(m, order) - return result - - -# def complex_abs(m): -# # check1 = np.abs(m.numpy()) -# -# re = paddle.multiply(paddle.real(m), paddle.real(m)) -# im = paddle.multiply(paddle.imag(m), paddle.imag(m)) -# m = paddle.add(re, im) -# m = paddle.sqrt(m) -# # m = paddle.pow(m, paddle.ones_like(m) * 0.5) -# -# # check2 = m.numpy() -# # assert (check1 == check2).all() -# -# 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): - """ - Transfer to the next state - :param state: - :param gate_matrix: - :param bits: - :return: - """ - - assert (type(gate_matrix) is np.ndarray) or \ - (type(gate_matrix) is paddle.Tensor and gate_matrix.dtype.name == "COMPLEX128") - - assert type(state) is paddle.Tensor and state.dtype.name == "COMPLEX128" and len(state.shape) == 1 - # calc source_pos target_pos - n = int(np.log2(state.shape[0])) - source_pos = copy.deepcopy(bits) # copy bits, it should NOT change the order of bits - # source_pos = [n - 1 - idex for idex in source_pos] # qubit index - # source_pos = list(reversed(source_pos)) # reverse qubit index - target_pos = list(range(len(bits))) - - # ### check - # state_check = transfer_state(paddle.reshape(state, [2] * n), gate_matrix, bits) - # state_check = paddle.reshape(state_check, [2 ** n]) - - # 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 - # 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] - compressed_source_pos = [-1] * len(source_pos) - for i in range(n): - if i in source_pos: - compressed_source_pos[source_pos.index(i)] = len(compressed_shape_before_moveaxis) - compressed_shape_before_moveaxis.append(2) - compressed_shape_before_moveaxis.append(1) - else: - compressed_shape_before_moveaxis[-1] = compressed_shape_before_moveaxis[-1] * 2 - # print([2] * n) - # print(source_pos) - # print('->') - # print(compressed_shape) - # print(compressed_source_pos) # always [1], [1, 3], or [3, 1] - state = paddle.reshape(state, compressed_shape_before_moveaxis) - state = complex_moveaxis(state, compressed_source_pos, target_pos) - compressed_shape_after_moveaxis = state.shape - - # reshape - state_new_shape = [2 ** len(bits), 2 ** (n - len(bits))] - state = paddle.reshape(state, state_new_shape) - - # gate_matrix - if type(gate_matrix) is np.ndarray: - gate_new_shape = [2 ** (len(gate_matrix.shape) - len(bits)), 2 ** len(bits)] - gate_matrix = gate_matrix.reshape(gate_new_shape) - gate_matrix = paddle.to_tensor(gate_matrix) - elif type(gate_matrix) is paddle.Tensor and gate_matrix.dtype.name == "COMPLEX128": - pass - else: - assert False - - # matmul - state = paddle.matmul(gate_matrix, state) - - # restore compressed moveaxis reshape - state = paddle.reshape(state, compressed_shape_after_moveaxis) - state = complex_moveaxis(state, target_pos, compressed_source_pos) - state = paddle.reshape(state, [2 ** n]) - - # ### check - # assert (np.all(state.numpy() == state_check.numpy())) - - return state - - -# StateTransfer -def StateTransfer(state, gate_name, bits, params=None): - """ - To transfer state by only gate name and bits - :param state: the last step state, can be init vector or the last step vector. - :param gate_name:x,y,z,h,CNOT, SWAP - :param bits: the gate working on the bits. - :param params: params for u gate. - :return: the updated state - """ - if gate_name == 'h': - # print('----------', gate_name, bits, '----------') - gate_matrix = h_gate_matrix() - elif gate_name == 'x': - # print('----------', gate_name, bits, '----------') - gate_matrix = x_gate_matrix() - elif gate_name == 'y': - # print('----------', gate_name, bits, '----------') - gate_matrix = y_gate_matrix() - elif gate_name == 'z': - # print('----------', gate_name, bits, '----------') - gate_matrix = z_gate_matrix() - 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() - elif gate_name == 'u': - # print('----------', gate_name, bits, '----------') - gate_matrix = u_gate_matrix(params) - elif gate_name == 'RXX_gate': - # print('----------', gate_name, bits, '----------') - gate_matrix = rxx_gate_matrix(params) - elif gate_name == 'RYY_gate': - # print('----------', gate_name, bits, '----------') - gate_matrix = ryy_gate_matrix(params) - 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") - - state = transfer_state(state, gate_matrix, bits) - return state - - -# MeasureProcess -class MEAS_METHOD(Enum): - """ - To control the measure method - """ - SINGLE = 1 - PROB = 2 - - -Meas_MED = MEAS_METHOD.PROB - - -def oct_to_bin_str(oct_number, n): - """ - Oct to bin by real order - :param oct_number: - :param n: - :return: - """ - bin_string = bin(oct_number)[2:].zfill(n) - # return (''.join(reversed(bin_string))) - return bin_string - - -def measure_single(state, bit): - """ - Method one qubit one time - :param state: - :param bit: - :return: - """ - n = len(state.shape) - axis = list(range(n)) - axis.remove(n - 1 - bit) - probs = np.sum(np.abs(state) ** 2, axis=tuple(axis)) - rnd = np.random.rand() - - # measure single bit - if rnd < probs[0]: - out = 0 - prob = probs[0] - else: - out = 1 - prob = probs[1] - - # collapse single bit - if out == 0: - matrix = np.array([[1.0 / np.sqrt(prob), 0.0], - [0.0, 0.0]], complex) - else: - matrix = np.array([[0.0, 0.0], - [0.0, 1.0 / np.sqrt(prob)]], complex) - state = transfer_state(state, matrix, [bit]) - - return out, state - - -def measure_all(state): - """ - Method all by single qubits - :param state: - :return: - """ - n = len(state.shape) - outs = '' - for i in range(n): - out, state = measure_single(state, i) # measure qubit0 will collapse it - outs = str(out) + outs # from low to high position - return outs - - -def measure_by_single_accumulation(state, shots): - """ - Method by accumulation, one shot one time - :param state: - :param shots: - :return: - """ - print("Measure method Single Accu") - result = {} - for i in range(shots): - outs = measure_all(state) - if outs not in result: - result[outs] = 0 - result[outs] += 1 - return result - - -def measure_by_probability(state, times): - """ - Measure by probability method - :param state: - :param times: - :return: - """ - # print("Measure method Probability") - - assert type(state) is paddle.Tensor and state.dtype.name == "COMPLEX128" and len(state.shape) == 1 - n = int(np.log2(state.shape[0])) - prob_array = paddle.abs(state) # complex -> real - prob_array = paddle.multiply(prob_array, prob_array) - prob_array = prob_array.numpy() - gc.collect() - - """ - prob_key = [] - prob_values = [] - pos_list = list(np.nonzero(prob_array)[0]) - for index in pos_list: - string = oct_to_bin_str(index, n) - prob_key.append(string) - prob_values.append(prob_array[index]) - - # print("The sum prob is ", sum(prob_values)) - - samples = np.random.choice(len(prob_key), times, p=prob_values) - """ - samples = np.random.choice(range(2 ** n), times, p=prob_array) - count_samples = Counter(samples) - result = {} - for idx in count_samples: - """ - result[prob_key[idx]] = count_samples[idx] - """ - result[oct_to_bin_str(idx, n)] = count_samples[idx] - return result - - -def measure_state(state, shots): - """ - Measure main entry - :param state: - :param shots: - :return: - """ - if Meas_MED == MEAS_METHOD.SINGLE: - return measure_by_single_accumulation(state, shots) - elif Meas_MED == MEAS_METHOD.PROB: - return measure_by_probability(state, shots) - else: - raise Exception("Measure Error") - - -# RandomCircuit -def GenerateRandomCirc(state, circ_depth, n): - """ - Generate random circ - :param state: The whole state - :param circ_depth: number of circuit - :param n: number of qubits - :return: state - """ - gate_string = ['x', 'y', 'z', 'h', 'CNOT'] - internal_state = state - for index in range(circ_depth): - rand_gate_pos = random.randint(0, len(gate_string) - 1) - if rand_gate_pos == (len(gate_string) - 1): - rand_gate_bits = random.sample(range(n), 2) - else: - rand_gate_bits = random.sample(range(n), 1) - internal_state = StateTransfer(internal_state, gate_string[rand_gate_pos], rand_gate_bits) - state = internal_state - return state - - -def GenerateRandomCircAndRev(state, circ_depth, n): - """ - Generate random circ - :param state: The whole state - :param circ_depth: number of circuit - :param n: number of qubits - :return: state - """ - rand_gate_pos_all = [] - rand_gate_bits_all = [] - gate_string = ['x', 'y', 'z', 'h', 'CNOT'] - internal_state = state - for index in range(circ_depth): - rand_gate_pos = random.randint(0, len(gate_string) - 1) - if rand_gate_pos == (len(gate_string) - 1): - rand_gate_bits = random.sample(range(n), 2) - else: - rand_gate_bits = random.sample(range(n), 1) - - rand_gate_pos_all.append(rand_gate_pos) - rand_gate_bits_all.append(rand_gate_bits) - - internal_state = StateTransfer(internal_state, gate_string[rand_gate_pos], rand_gate_bits) - - rand_gate_pos_all = list(reversed(rand_gate_pos_all)) - rand_gate_bits_all = list(reversed(rand_gate_bits_all)) - - for idex, item in enumerate(rand_gate_pos_all): - internal_state = StateTransfer(internal_state, gate_string[item], rand_gate_bits_all[idex]) - - state = internal_state - return state - - -# Tester -def RandomTestIt(bits_num, circ_num): - """ - Random Check - :param bits_num: - :param circ_num: - :return: - """ - n = bits_num - repeat_num = 1 # 2 ** 5 - state = init_state_10(n) - - for _ in range(repeat_num): - # state = copy.deepcopy(state_origin) - state = GenerateRandomCircAndRev(state, circ_num, n) - re = measure_state(state, 2 ** 10) - # print(re) - assert (str('0' * n) in list(re.keys())) - assert (2 ** 10 in list(re.values())) - - return True - - -def Test_x_h_CNOT(): # 3 bits coverage test - """ - The smallest tester program - :return: - """ - state = init_state_10(3) - - state = StateTransfer(state, 'x', [0]) - state = StateTransfer(state, 'h', [1]) - state = StateTransfer(state, 'CNOT', [1, 2]) - re = measure_state(state, 2 ** 10) - # print(re) - assert ('001' in list(re.keys()) and '111' in list(re.keys())) - assert (list(re.values())[0] / list(re.values())[1] in Interval(0.9, 1.1)) - return True - - -def Test_cnot_1(): - """ - Check CNOT using reverse circ - :return: - """ - state = init_state_10(3) - - state = StateTransfer(state, 'h', [0]) - state = StateTransfer(state, 'CNOT', [0, 1]) - state = StateTransfer(state, 'CNOT', [0, 2]) - state = StateTransfer(state, 'CNOT', [1, 2]) - state = StateTransfer(state, 'CNOT', [1, 2]) - state = StateTransfer(state, 'CNOT', [0, 2]) - state = StateTransfer(state, 'CNOT', [0, 1]) - state = StateTransfer(state, 'h', [0]) - re = measure_state(state, 2 ** 10) - assert ('000' in list(re.keys())) - assert (2 ** 10 in list(re.values())) - return True - - -def Test_cnot_2(): - """ - Check retation of CNOTS - :return: - """ - state = init_state_10(3) - - state = StateTransfer(state, 'h', [2]) - state = StateTransfer(state, 'CNOT', [2, 1]) - state = StateTransfer(state, 'CNOT', [2, 0]) - state = StateTransfer(state, 'CNOT', [1, 0]) - state = StateTransfer(state, 'CNOT', [1, 0]) - state = StateTransfer(state, 'CNOT', [2, 0]) - state = StateTransfer(state, 'CNOT', [2, 1]) - state = StateTransfer(state, 'h', [2]) - re = measure_state(state, 2 ** 10) - assert ('000' in list(re.keys())) - assert (2 ** 10 in list(re.values())) - return True - - -def Test3All(): - """ - Check all 3 qubits cases - :return: - """ - return Test_x_h_CNOT() and Test_cnot_1() and Test_cnot_2() - - -# Sim2Main -def main(bits_num=None, circ_num=None): - """ - :param bits_num: the number of qubits - :param circ_num: the circuit depth to be expected - These two args can be None type and the default behavior is bits_num =5 and circ_num=50. - Two args must be given together. - :return: - :DEBUG INFO: - 1) np.random.seed(0) can be uncomment to guarantee the random sequence can be tracked. - 2) re is the return result: vector string: counter - """ - - # init seed - # np.random.seed(0) - - print('----------', 'init', bits_num, 'bits', '----------') - print('----------', 'init', circ_num, 'circ depth', '----------') - - state = init_state_10(bits_num) - - # ------------------tik------- - # state = StateTransfer(state, 'h', [0]) - # state = StateTransfer(state, 'x', [1]) - # state = StateTransfer(state, 'x', [2]) - # state = StateTransfer(state, 'u', [3], [0.3, 0.5, 0.7]) - # state = StateTransfer(state, 'CNOT', [0, 1]) - # state = StateTransfer(state, 'CNOT', [2, 1]) - # -----------------tok--------- - - # ------------------tik------- - state = StateTransfer(state, 'x', [0]) - state = StateTransfer(state, 'h', [1]) - # state = StateTransfer(state, 'CNOT', [0, 1]) - # -----------------tok--------- - - # ------------------tik------- - # state = GenerateRandomCirc(state, circ_num, n) - # -----------------tok--------- - - # ------------------tik------- - re = measure_state(state, 2 ** 10) - # -----------------tok--------- - - print(re) - - -def Tester(bits_num=None, circ_num=None): - """ - This part is to guarantee the behaviors of the simualtor2. Every Modification MUST ensure this function can be executed correctly. - :return: True: Pass or False: NO Pass - """ - # random tester - - check_value_rand = RandomTestIt(bits_num, circ_num) - check_value_3 = Test3All() - check_all = check_value_rand and check_value_3 - print(check_all) - return check_all - - -if __name__ == '__main__': - paddle.set_device('cpu') - # main(bits_num=5, circ_num=50) - main(bits_num=5) - # RandomTestIt(bits_num=5, circ_num=50) - # print(Test3All()) - - # print(Tester(bits_num=5, circ_num=50)) - # Tester(bits_num=6, circ_num=100) diff --git a/paddle_quantum/state.py b/paddle_quantum/state.py deleted file mode 100644 index 3a3cd4f..0000000 --- a/paddle_quantum/state.py +++ /dev/null @@ -1,469 +0,0 @@ -# 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. - -import numpy as np -from numpy import trace as np_trace -from numpy import matmul as np_matmul -from numpy import random as np_random -from numpy import zeros as np_zeros -from numpy import eye as np_eye - -__all__ = [ - "vec", - "vec_random", - "w_state", - "GHZ_state", - "density_op", - "density_op_random", - "completely_mixed_computational", - "bell_state", - "bell_diagonal_state", - "R_state", - "S_state", - "isotropic_state" -] - - -def vec(i, n): - r"""生成计算基态 :math:`|e_{i}\rangle` 的 numpy 形式，其中 :math:`|e_{i}\rangle` 的第 :math:`i` 个元素为 1，其余元素为 0。 - - Args: - i(int): 计算基态 :math`|e_{i}\rangle` 的下标 :math:`i` - n(int): 生成的量子态的量子比特数量 - - Returns: - numpy.ndarray: 计算基态 :math:`|e_{i}\rangle` 的态矢量形式。 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.state import vec - vector = vec(1, 3) - print(vector) - - :: - - [[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' - 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") - - -def vec_random(n, real_or_complex=2): - r"""随机生成一个量子态的 numpy 形式。 - - Args: - n (int): 量子比特数量 - real_or_complex (int, optional): 默认为 2，即生成复数组；若为 1，则生成实数组 - - Returns: - numpy.ndarray: 一个形状为 ``(1, 2**n)`` 的 numpy 数组 - """ - assert n > 0, 'qubit number must be larger than 1' - assert real_or_complex == 1 or real_or_complex == 2, 'real_or_complex must be 1 or 2' - # real - if real_or_complex == 1: - psi = np_random.randn(1, 2 ** n) - # complex - else: - psi = np_random.randn(1, 2 ** n) + 1j * np_random.randn(1, 2 ** n) - psi = psi / np.linalg.norm(psi) - - return psi.astype("complex128") - - -def w_state(n, coeff=None): - r"""生成一个 W-state 的 numpy 形式。 - - Args: - n (int): 量子比特数量 - coeff (numpy.ndarray, optional): 默认为 ``None`` ，即生成平均概率幅（系数） - - Returns: - numpy.ndarray: 一个形状为 ``(1, 2**n)`` 的 numpy 数组 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.state import w_state - vector = w_state(3) - print(vector) - - :: - - [[0. +0.j 0.57735027+0.j 0.57735027+0.j 0. +0.j - 0.57735027+0.j 0. +0.j 0. +0.j 0. +0.j]] - """ - assert n > 0, 'qubit number must be larger than 1' - - c = coeff if coeff is not None else np.ones((1, 2 ** n)) / np.sqrt(n) - assert c.shape[0] == 1 and c.shape[1] == 2 ** n, 'The dimension of coeff is not right' - - state = np_zeros((1, 2 ** n)) - for i in range(n): - state[0][2 ** i] = c[0][n - i - 1] - - return state.astype("complex128") - - -def GHZ_state(n): - r"""生成一个 GHZ-state 的 numpy 形式。 - - Args: - n (int): 量子比特数量 - - Returns: - numpy.ndarray: 一个形状为 ``(1, 2**n)`` 的 numpy 数组 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.state import GHZ_state - vector = GHZ_state(3) - print(vector) - - :: - - [[0.70710678+0.j 0. +0.j 0. +0.j 0. +0.j - 0. +0.j 0. +0.j 0. +0.j 0.70710678+0.j]] - """ - assert n > 2, 'qubit number must be larger than 2' - state = np_zeros((1, 2 ** n)) - state[0][0] = 1 / np.sqrt(2) - state[0][-1] = 1 / np.sqrt(2) - - return state.astype("complex128") - - -def density_op(n): - r"""生成密度矩阵 :math:`|00..0\rangle \langle00..0|` 的 numpy 形式。 - - Args: - n (int): 量子比特数量 - - Returns: - numpy.ndarray: 一个形状为 ``(2**n, 2**n)`` 的 numpy 数组 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.state import density_op - state = density_op(2) - print(state) - - :: - - [[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 0.+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 positive' - rho = np_zeros((2 ** n, 2 ** n)) - rho[0, 0] = 1 - - return rho.astype("complex128") - - -def density_op_random(n, real_or_complex=2, rank=None): - r"""随机生成一个密度矩阵的 numpy 形式。 - - Args: - n (int): 量子比特数量 - real_or_complex (int, optional): 默认为 2，即生成复数组，若为 1，则生成实数组 - rank (int, optional): 矩阵的秩，默认为 :math:`2^n` （当 ``rank`` 为 ``None`` 时） - - Returns: - numpy.ndarray: 一个形状为 ``(2**n, 2**n)`` 的 numpy 数组 - """ - assert n > 0, 'qubit number must be positive' - rank = rank if rank is not None else 2 ** n - assert 0 < rank <= 2 ** n, 'rank is an invalid number' - - if real_or_complex == 1: - psi = np_random.randn(2 ** n, rank) - else: - psi = np_random.randn(2 ** n, rank) + 1j * np_random.randn(2 ** n, rank) - - psi_dagger = psi.conj().T - rho = np_matmul(psi, psi_dagger) - rho = rho / np_trace(rho) - - return rho.astype('complex128') - - -def completely_mixed_computational(n): - r"""生成完全混合态的密度矩阵的 numpy 形式。 - - 其矩阵形式为： - - .. math:: - - \frac{I}{2^n} - - Args: - n (int): 量子比特数量 - - Returns: - numpy.ndarray: 一个形状为 ``(2**n, 2**n)`` 的 numpy 数组 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.state import completely_mixed_computational - state = completely_mixed_computational(2) - print(state) - - :: - - [[0.25+0.j 0. +0.j 0. +0.j 0. +0.j] - [0. +0.j 0.25+0.j 0. +0.j 0. +0.j] - [0. +0.j 0. +0.j 0.25+0.j 0. +0.j] - [0. +0.j 0. +0.j 0. +0.j 0.25+0.j]] - """ - assert n > 0, 'qubit number must be positive' - rho = np_eye(2 ** n) / (2 ** n) - - return rho.astype('complex128') - - -def bell_state(n): - r"""生成（推广）贝尔态的密度矩阵的 numpy 形式。 - - 其数学表达形式为： - - .. math:: - - |\Phi_{D}\rangle=\frac{1}{\sqrt{D}} \sum_{j=0}^{D-1}|j\rangle_{A}|j\rangle_{B} - - - Args: - n (int): 量子比特数量，必须为大于等于 2 的偶数 - - Returns: - numpy.ndarray: 一个形状为 ``(2**n, 2**n)`` 的 numpy 数组 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.state import bell_state - state = bell_state(2) - print(state) - - :: - - [[0.5+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.5+0.j 0. +0.j 0. +0.j 0.5+0.j]] - """ - assert n > 0, "Qubit number must be positive" - assert n % 2 == 0, "Qubit number must be even" - - dim = 2 ** n - local_dim = 2 ** int(n / 2) - coeff = 1 / local_dim - state = np.zeros((dim, dim)) - for i in range(0, dim, local_dim + 1): - for j in range(0, dim, local_dim + 1): - state[i, j] = coeff - - return state.astype("complex128") - - -def bell_diagonal_state(p1, p2, p3, p4): - r"""生成对角贝尔态的密度矩阵的 numpy 形式。 - - 其数学表达形式为： - - .. math:: - - p_{1}|\Phi^{+}\rangle\langle\Phi^{+}|+p_{2}| \Psi^{+}\rangle\langle\Psi^{+}|+p_{3}| \Phi^{-}\rangle\langle\Phi^{-}| + - p4|\Psi^{-}\rangle\langle\Psi^{-}| - - Args: - p1 (float): 第一个分量。 - p2 (float): 第二个分量。 - p3 (float): 第三个分量。 - p4 (float): 第四个分量。 - - Note: - 四个参数构成了一个概率分布，因此它们是非负数，加起来必为 1。 - - Returns: - numpy.ndarray: 一个形状为 ``(4, 4)`` 的 numpy 数组 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.state import bell_diagonal_state - state = bell_diagonal_state(0.25, 0.25, 0.25, 0.25) - print(state) - - :: - - [[0.25+0.j 0. +0.j 0. +0.j 0. +0.j] - [0. +0.j 0.25+0.j 0. +0.j 0. +0.j] - [0. +0.j 0. +0.j 0.25+0.j 0. +0.j] - [0. +0.j 0. +0.j 0. +0.j 0.25+0.j]] - """ - assert 0 <= p1 <= 1 and 0 <= p2 <= 1 and 0 <= p3 <= 1 and 0 <= p4 <= 1, "Each probability must be in [0, 1]" - assert abs(p1 + p2 + p3 + p4 - 1) < 1e-6, "The sum of probabilities should be 1" - - coeff = np.sqrt(0.5) - phi_p_vec = np.array([[coeff, 0, 0, coeff]]) - phi_p_mat = np.matmul(phi_p_vec.T, phi_p_vec) - phi_m_vec = np.array([[coeff, 0, 0, -coeff]]) - phi_m_mat = np.matmul(phi_m_vec.T, phi_m_vec) - psi_p_vec = np.array([[0, coeff, coeff, 0]]) - psi_p_mat = np.matmul(psi_p_vec.T, psi_p_vec) - psi_m_vec = np.array([[0, coeff, -coeff, 0]]) - psi_m_mat = np.matmul(psi_m_vec.T, psi_m_vec) - - state = p1 * phi_p_mat + p2 * psi_p_mat + p3 * phi_m_mat + p4 * psi_m_mat - - return state.astype("complex128") - - -def R_state(p): - r"""生成 R-state 的密度矩阵的 numpy 形式。 - - 其数学表达形式为： - - .. math:: - - p|\Psi^{+}\rangle\langle\Psi^{+}| + (1 - p)|11\rangle\langle11| - - Args: - p (float): 控制生成 R-state 的参数，属于 :math:`[0, 1]` 区间内 - - Returns: - numpy.ndarray: 一个形状为 ``(4, 4)`` 的 numpy 数组 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.state import R_state - state = R_state(0.5) - print(state) - - :: - - [[0. +0.j 0. +0.j 0. +0.j 0. +0.j] - [0. +0.j 0.25+0.j 0.25+0.j 0. +0.j] - [0. +0.j 0.25+0.j 0.25+0.j 0. +0.j] - [0. +0.j 0. +0.j 0. +0.j 0.5 +0.j]] - """ - assert 0 <= p <= 1, "Probability must be in [0, 1]" - - coeff = np.sqrt(0.5) - psi_p_vec = np.array([[0, coeff, coeff, 0]]) - psi_p_mat = np.matmul(psi_p_vec.T, psi_p_vec) - state_11 = np.zeros((4, 4)) - state_11[3, 3] = 1 - - state = p * psi_p_mat + (1 - p) * state_11 - - return state.astype("complex128") - - -def S_state(p): - r"""生成 S-state 的密度矩阵的 numpy 形式。 - - 其数学表达形式为： - - .. math:: - - p|\Phi^{+}\rangle\langle\Phi^{+}| + (1 - p)|00\rangle\langle00| - - Args: - p (float): 控制生成 S-state 的参数，属于 :math:`[0, 1]` 区间内 - - Returns: - numpy.ndarray: 一个形状为 ``(4, 4)`` 的 numpy 数组 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.state import S_state - state = S_state(0.5) - print(state) - - :: - - [[0.75+0.j 0. +0.j 0. +0.j 0.25+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.25+0.j 0. +0.j 0. +0.j 0.25+0.j]] - """ - assert 0 <= p <= 1, "Probability must be in [0, 1]" - - phi_p = bell_state(2) - psi0 = np.zeros_like(phi_p) - psi0[0, 0] = 1 - - state = p * phi_p + (1 - p) * psi0 - return state.astype("complex128") - - -def isotropic_state(n, p): - r"""生成 isotropic state 的密度矩阵的 numpy 形式。 - - 其数学表达形式为： - - .. math:: - - p(\frac{1}{\sqrt{D}} \sum_{j=0}^{D-1}|j\rangle_{A}|j\rangle_{B}) + (1 - p)\frac{I}{2^n} - - Args: - n (int): 量子比特数量 - p (float): 控制生成 isotropic state 的参数，属于 :math:`[0, 1]` 区间内 - - Returns: - numpy.ndarray: 一个形状为 ``(2**n, 2**n)`` 的 numpy 数组 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.state import isotropic_state - state = isotropic_state(2, 0.5) - print(state) - - :: - - [[0.375+0.j 0. +0.j 0. +0.j 0.25 +0.j] - [0. +0.j 0.125+0.j 0. +0.j 0. +0.j] - [0. +0.j 0. +0.j 0.125+0.j 0. +0.j] - [0.25 +0.j 0. +0.j 0. +0.j 0.375+0.j]] - """ - assert 0 <= p <= 1, "Probability must be in [0, 1]" - - dim = 2 ** n - state = p * bell_state(n) + (1 - p) * np.eye(dim) / dim - - return state diff --git a/paddle_quantum/state/__init__.py b/paddle_quantum/state/__init__.py new file mode 100644 index 0000000..86a7900 --- /dev/null +++ b/paddle_quantum/state/__init__.py @@ -0,0 +1,32 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The module of the quantum state. +""" + +from .state import State +from .common import zero_state +from .common import computational_basis +from .common import bell_state +from .common import random_state +from .common import to_state +from .common import w_state +from .common import ghz_state +from .common import bell_diagonal_state +from .common import completely_mixed_computational +from .common import r_state +from .common import s_state +from .common import isotropic_state diff --git a/paddle_quantum/state/common.py b/paddle_quantum/state/common.py new file mode 100644 index 0000000..ca408cf --- /dev/null +++ b/paddle_quantum/state/common.py @@ -0,0 +1,485 @@ +# !/usr/bin/env python3 +# 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. + +r""" +The common function of the quantum state. +""" + +import numpy as np +import paddle +import paddle_quantum +import QCompute +from ..backend import Backend +from ..backend import quleaf +from .state import State +from typing import Union, Optional, List + + +def to_state( + data: Union[paddle.Tensor, np.ndarray, QCompute.QEnv], num_qubits: Optional[int] = None, + backend: Optional[paddle_quantum.Backend] = None, dtype: Optional[str] = None +) -> State: + r"""The function to generate a specified state instance. + + Args: + data: The analytical form of quantum state. + num_qubits: The number of qubits contained in the quantum state. Defaults to ``None``, which means it will be inferred by the data. + backend: Used to specify the backend used. Defaults to ``None``, which means to use the default backend. + dtype: Used to specify the data dtype of the data. Defaults to ``None``, which means to use the default data type. + + Returns: + The generated quantum state. + """ + if isinstance(data, np.ndarray): + data = paddle.to_tensor(data) + return State(data, num_qubits, backend, dtype) + + +def zero_state( + num_qubits: int, backend: Optional[paddle_quantum.Backend] = None, dtype: Optional[str] = None +) -> State: + r"""The function to generate a zero state. + + Args: + num_qubits: The number of qubits contained in the quantum state. + backend: Used to specify the backend used. Defaults to ``None``, which means to use the default backend. + dtype: Used to specify the data dtype of the data. Defaults to ``None``, which means to use the default data type. + + Raises: + NotImplementedError: If the backend is wrong or not implemented. + + Returns: + The generated quantum state. + """ + dtype = paddle_quantum.get_dtype() if dtype is None else dtype + np_dtype = np.complex64 if dtype == 'complex64' else np.complex128 + data = np.zeros((2 ** num_qubits,), dtype=np_dtype) + data[0] = 1 + data = paddle.to_tensor(data) + backend = paddle_quantum.get_backend() if backend is None else backend + if backend == Backend.StateVector: + state = State(data, num_qubits, backend=backend, dtype=dtype) + elif backend == Backend.DensityMatrix: + data = paddle.unsqueeze(data, axis=1) + data = paddle.matmul(data, paddle.conj(paddle.t(data))) + state = State(data, num_qubits, backend=backend, dtype=dtype) + elif backend == Backend.QuLeaf: + data = QCompute.QEnv() + data.backend(quleaf.get_quleaf_backend()) + data.Q.createList(num_qubits) + state = State(data, num_qubits, backend=backend, dtype=dtype) + else: + raise NotImplementedError + return state + + +def computational_basis( + num_qubits: int, index: int, backend: Optional[paddle_quantum.Backend] = None, dtype: Optional[str] = None +) -> State: + r"""Generate a computational basis state :math:`|e_{i}\rangle` , whose i-th element is 1 and all the other elements are 0. + + Args: + num_qubits: The number of qubits contained in the quantum state. + index: Index :math:`i` of the computational basis state :math`|e_{i}rangle` . + backend: Used to specify the backend used. Defaults to ``None``, which means to use the default backend. + dtype: Used to specify the data dtype of the data. Defaults to ``None``, which means to use the default data type. + + Raises: + NotImplementedError: If the backend is wrong or not implemented. + + Returns: + The generated quantum state. + """ + dtype = paddle_quantum.get_dtype() if dtype is None else dtype + np_dtype = np.complex64 if dtype == 'complex64' else np.complex128 + data = np.zeros((2 ** num_qubits,), dtype=np_dtype) + data[index] = 1 + data = paddle.to_tensor(data) + backend = paddle_quantum.get_backend() if backend is None else backend + if backend == Backend.StateVector: + state = State(data, num_qubits, backend=backend) + elif backend == Backend.DensityMatrix: + data = paddle.unsqueeze(data, axis=1) + data = paddle.matmul(data, paddle.conj(paddle.t(data))) + state = State(data, num_qubits, backend=backend) + else: + raise NotImplementedError + return state + + +def bell_state(num_qubits: int, backend: Optional[paddle_quantum.Backend] = None) -> State: + r"""Generate a bell state. + + Its matrix form is: + + .. math:: + + |\Phi_{D}\rangle=\frac{1}{\sqrt{D}} \sum_{j=0}^{D-1}|j\rangle_{A}|j\rangle_{B} + + Args: + num_qubits: The number of qubits contained in the quantum state. + backend: Used to specify the backend used. Defaults to ``None``, which means to use the default backend. + + Raises: + NotImplementedError: If the backend is wrong or not implemented. + + Returns: + The generated quantum state. + """ + np_dtype = np.complex64 if paddle_quantum.get_dtype() == 'complex64' else np.complex128 + dim = 2 ** num_qubits + local_dim = 2 ** int(num_qubits / 2) + coeff = 1 / local_dim + data = np.zeros((dim, dim), dtype=np_dtype) + for i in range(0, dim, local_dim + 1): + for j in range(0, dim, local_dim + 1): + data[i, j] = coeff + backend = paddle_quantum.get_backend() if backend is None else backend + if backend == Backend.StateVector: + eigenvalue, eigenvector = paddle.linalg.eig(paddle.to_tensor(data)) + data = eigenvector[:, paddle.argmax(paddle.real(eigenvalue))] + state = State(data, num_qubits, backend=backend) + elif backend == Backend.DensityMatrix: + state = State(paddle.to_tensor(data), num_qubits, backend=backend) + else: + raise NotImplementedError + return state + + +def bell_diagonal_state(prob: List[float]) -> State: + r"""Generate a bell diagonal state. + + Its matrix form is: + + .. math:: + + p_{1}|\Phi^{+}\rangle\langle\Phi^{+}|+p_{2}| \Psi^{+}\rangle\langle\Psi^{+}|+p_{3}| \Phi^{-}\rangle\langle\Phi^{-}| + + p_{4}|\Psi^{-}\rangle\langle\Psi^{-}| + + Args: + prob: The prob of each bell state. + + Raises: + Exception: The state should bu a pure state if the backend is state_vector. + NotImplementedError: If the backend is wrong or not implemented. + + Returns: + The generated quantum state. + """ + p1, p2, p3, p4 = prob + assert 0 <= p1 <= 1 and 0 <= p2 <= 1 and 0 <= p3 <= 1 and 0 <= p4 <= 1, "Each probability must be in [0, 1]." + assert abs(p1 + p2 + p3 + p4 - 1) < 1e-6, "The sum of probabilities should be 1." + + np_dtype = np.complex64 if paddle_quantum.get_dtype() == 'complex64' else np.complex128 + coeff = np.sqrt(0.5) + phi_p_vec = np.array([[coeff, 0, 0, coeff]], dtype=np_dtype) + phi_p_mat = np.matmul(phi_p_vec.T, phi_p_vec) + phi_m_vec = np.array([[coeff, 0, 0, -coeff]], dtype=np_dtype) + phi_m_mat = np.matmul(phi_m_vec.T, phi_m_vec) + psi_p_vec = np.array([[0, coeff, coeff, 0]], dtype=np_dtype) + psi_p_mat = np.matmul(psi_p_vec.T, psi_p_vec) + psi_m_vec = np.array([[0, coeff, -coeff, 0]], dtype=np_dtype) + psi_m_mat = np.matmul(psi_m_vec.T, psi_m_vec) + + state = p1 * phi_p_mat + p2 * psi_p_mat + p3 * phi_m_mat + p4 * psi_m_mat + + backend = paddle_quantum.get_backend() + if backend == Backend.StateVector: + trace_rho = paddle.trace(paddle.to_tensor(state) @ paddle.to_tensor(state)) + if trace_rho.numpy()[0] == 1: + eigenvalue, eigenvector = paddle.linalg.eig(paddle.to_tensor(state)) + data = eigenvector[:, paddle.argmax(paddle.real(eigenvalue))] + state = State(data, backend=backend) + else: + raise Exception("The state is not a pure state") + elif backend == Backend.DensityMatrix: + state = State(paddle.to_tensor(state), backend=backend) + else: + raise NotImplementedError + return state + + +def random_state(num_qubits: int, is_real: Optional[bool] = False, rank: Optional[int] = None) -> State: + r"""Generate a random quantum state. + + Args: + num_qubits: The number of qubits contained in the quantum state. + is_real: If the quantum state only contains the real number. Defaults to ``False``. + rank: The rank of the density matrix. Defaults to ``None`` which means full rank. + + Raises: + NotImplementedError: If the backend is wrong or not implemented. + + Returns: + The generated quantum state. + """ + float_dtype = 'float32' if paddle_quantum.get_dtype() == 'complex64' else 'float64' + backend = paddle_quantum.get_backend() + if backend == Backend.StateVector: + if is_real: + data = paddle.rand((2 ** num_qubits,), dtype=float_dtype) + else: + data_real = paddle.rand((2 ** num_qubits,), dtype=float_dtype) + data_imag = paddle.rand((2 ** num_qubits,), dtype=float_dtype) + data = data_real + 1j * data_imag + norm = np.linalg.norm(data.numpy()) + data = data / paddle.to_tensor(norm) + state = State(data, num_qubits, backend=backend) + elif backend == Backend.DensityMatrix: + rank = 2 ** num_qubits if rank is None else rank + if is_real: + data = paddle.rand((2 ** num_qubits, rank), dtype=float_dtype) + else: + data_real = paddle.rand((2 ** num_qubits, rank), dtype=float_dtype) + data_imag = paddle.rand((2 ** num_qubits, rank), dtype=float_dtype) + data = data_real + 1j * data_imag + data = paddle.matmul(data, paddle.conj(paddle.t(data))) + data = data / paddle.trace(data) + state = State(data, num_qubits, backend=backend) + else: + raise NotImplementedError + return state + + +def w_state(num_qubits: int) -> 'State': + r"""Generate a W-state. + + Args: + num_qubits: The number of qubits contained in the quantum state. + + Raises: + NotImplementedError: If the backend is wrong or not implemented. + + Returns: + The generated quantum state. + """ + np_dtype = np.complex64 if paddle_quantum.get_dtype() == 'complex64' else np.complex128 + coeff = np.ones((1, 2 ** num_qubits)) / np.sqrt(num_qubits) + backend = paddle_quantum.get_backend() + if backend == Backend.StateVector: + state = np.zeros((1, 2 ** num_qubits), dtype=np_dtype) + for i in range(num_qubits): + state[0][2 ** i] = coeff[0][num_qubits - i - 1] + state = State(paddle.to_tensor(state), num_qubits, backend=backend) + elif backend == Backend.DensityMatrix: + state = np.zeros(2 ** num_qubits, dtype=np_dtype) + for i in range(num_qubits): + state[2 ** i] = coeff[0][num_qubits - i - 1] + state = paddle.to_tensor(state) + state = paddle.unsqueeze(state, axis=1) + state = paddle.matmul(state, paddle.conj(paddle.t(state))) + state = State(state, num_qubits, backend=backend) + else: + raise NotImplementedError + return state + + +def ghz_state(num_qubits: int) -> 'State': + r"""Generate a GHZ-state. + + Args: + num_qubits: The number of qubits contained in the quantum state. + + Raises: + NotImplementedError: If the backend is wrong or not implemented. + + Returns: + The generated quantum state. + """ + np_dtype = np.complex64 if paddle_quantum.get_dtype() == 'complex64' else np.complex128 + backend = paddle_quantum.get_backend() + if backend == Backend.StateVector: + state = np.zeros((1, 2 ** num_qubits)) + state[0][0] = 1 / np.sqrt(2) + state[0][-1] = 1 / np.sqrt(2) + state = State(paddle.to_tensor(state), num_qubits, backend=backend) + elif backend == Backend.DensityMatrix: + state = np.zeros(2 ** num_qubits, dtype=np_dtype) + state[0] = 1 / np.sqrt(2) + state[-1] = 1 / np.sqrt(2) + state = paddle.to_tensor(state) + state = paddle.unsqueeze(state, axis=1) + state = paddle.matmul(state, paddle.conj(paddle.t(state))) + state = State(state, num_qubits, backend=backend) + else: + raise NotImplementedError + return state + + +def completely_mixed_computational(num_qubits: int) -> State: + r"""Generate the density matrix of the completely mixed state. + + Args: + num_qubits: The number of qubits contained in the quantum state. + + Raises: + Exception: The state should bu a pure state if the backend is state_vector. + NotImplementedError: If the backend is wrong or not implemented. + + Returns: + The generated quantum state. + """ + assert num_qubits > 0, 'qubit number must be positive' + + np_dtype = np.complex64 if paddle_quantum.get_dtype() == 'complex64' else np.complex128 + state = np.eye(2 ** num_qubits) / (2 ** num_qubits) + state = state.astype(np_dtype) + backend = paddle_quantum.get_backend() + if backend == Backend.StateVector: + trace_rho = paddle.trace(paddle.to_tensor(state) @ paddle.to_tensor(state)) + if trace_rho.numpy()[0] == 1: + eigenvalue, eigenvector = paddle.linalg.eig(paddle.to_tensor(state)) + data = eigenvector[:, paddle.argmax(paddle.real(eigenvalue))] + state = State(data, backend=backend) + else: + raise Exception("The state is not a pure state") + elif backend == Backend.DensityMatrix: + state = State(paddle.to_tensor(state), num_qubits, backend=backend) + else: + raise NotImplementedError + return state + + +def r_state(prob: float) -> State: + r"""Generate an R-state. + + Its matrix form is: + + .. math:: + + p|\Psi^{+}\rangle\langle\Psi^{+}| + (1 - p)|11\rangle\langle11| + + Args: + prob: The parameter of the R-state to be generated. It should be in :math:`[0,1]` . + + Raises: + Exception: The state should bu a pure state if the backend is state_vector. + NotImplementedError: If the backend is wrong or not implemented. + + Returns: + The generated quantum state. + """ + assert 0 <= prob <= 1, "Probability must be in [0, 1]" + + np_dtype = np.complex64 if paddle_quantum.get_dtype() == 'complex64' else np.complex128 + coeff = np.sqrt(0.5) + psi_p_vec = np.array([[0, coeff, coeff, 0]]) + psi_p_mat = np.matmul(psi_p_vec.T, psi_p_vec) + state_11 = np.zeros((4, 4)) + state_11[3, 3] = 1 + state = prob * psi_p_mat + (1 - prob) * state_11 + state = state.astype(np_dtype) + backend = paddle_quantum.get_backend() + if backend == Backend.StateVector: + trace_rho = paddle.trace(paddle.to_tensor(state) @ paddle.to_tensor(state)) + if trace_rho.numpy()[0] == 1: + eigenvalue, eigenvector = paddle.linalg.eig(paddle.to_tensor(state)) + data = eigenvector[:, paddle.argmax(paddle.real(eigenvalue))] + state = State(data, backend=backend) + else: + raise Exception("The state is not a pure state") + elif backend == Backend.DensityMatrix: + state = State(paddle.to_tensor(state), backend=backend) + else: + raise NotImplementedError + return state + + +def s_state(prob: float) -> State: + r"""Generate the S-state. + + Its matrix form is: + + .. math:: + + p|\Phi^{+}\rangle\langle\Phi^{+}| + (1 - p)|00\rangle\langle00| + + Args: + prob: The parameter of the S-state to be generated. It should be in :math:`[0,1]` . + + Raises: + Exception: The state should bu a pure state if the backend is state_vector. + NotImplementedError: If the backend is wrong or not implemented. + + Returns: + The generated quantum state. + """ + assert 0 <= prob <= 1, "Probability must be in [0, 1]" + + np_dtype = np.complex64 if paddle_quantum.get_dtype() == 'complex64' else np.complex128 + phi_p = bell_state(2).data.numpy() + psi0 = np.zeros_like(phi_p) + psi0[0, 0] = 1 + state = prob * phi_p + (1 - prob) * psi0 + state = state.astype(np_dtype) + + backend = paddle_quantum.get_backend() + if backend == Backend.StateVector: + trace_rho = paddle.trace(paddle.to_tensor(state) @ paddle.to_tensor(state)) + if trace_rho.numpy()[0] == 1: + eigenvalue, eigenvector = paddle.linalg.eig(paddle.to_tensor(state)) + data = eigenvector[:, paddle.argmax(paddle.real(eigenvalue))] + state = State(data, backend=backend) + else: + raise Exception("The state is not a pure state") + elif backend == Backend.DensityMatrix: + state = State(paddle.to_tensor(state), backend=backend) + else: + raise NotImplementedError + return state + + +def isotropic_state(num_qubits: int, prob: float) -> State: + r"""Generate the isotropic state. + + Its matrix form is: + + .. math:: + + p(\frac{1}{\sqrt{D}} \sum_{j=0}^{D-1}|j\rangle_{A}|j\rangle_{B}) + (1 - p)\frac{I}{2^n} + + Args: + num_qubits: The number of qubits contained in the quantum state. + prob: The parameter of the isotropic state to be generated. It should be in :math:`[0,1]` . + + Raises: + Exception: The state should bu a pure state if the backend is state_vector. + NotImplementedError: If the backend is wrong or not implemented. + + Returns: + The generated quantum state. + """ + assert 0 <= prob <= 1, "Probability must be in [0, 1]" + + np_dtype = np.complex64 if paddle_quantum.get_dtype() == 'complex64' else np.complex128 + dim = 2 ** num_qubits + phi_b = bell_state(num_qubits).data.numpy() + state = prob * phi_b + (1 - prob) * np.eye(dim) / dim + state = state.astype(np_dtype) + + backend = paddle_quantum.get_backend() + if backend == Backend.StateVector: + trace_rho = paddle.trace(paddle.to_tensor(state) @ paddle.to_tensor(state)) + if trace_rho.numpy()[0] == 1: + eigenvalue, eigenvector = paddle.linalg.eig(paddle.to_tensor(state)) + data = eigenvector[:, paddle.argmax(paddle.real(eigenvalue))] + state = State(data, backend=backend) + else: + raise Exception("The state is not a pure state") + elif backend == Backend.DensityMatrix: + state = State(paddle.to_tensor(state), backend=backend) + else: + raise NotImplementedError + return state diff --git a/paddle_quantum/state/state.py b/paddle_quantum/state/state.py new file mode 100644 index 0000000..10dd262 --- /dev/null +++ b/paddle_quantum/state/state.py @@ -0,0 +1,265 @@ +# !/usr/bin/env python3 +# Copyright (c) 2022 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. + +r""" +The basic class of the quantum state. +""" + +import collections +import math +import matplotlib.pyplot as plt +import numpy as np +import random +import paddle +import QCompute +import paddle_quantum +from ..backend import Backend +from ..backend import state_vector, density_matrix, quleaf +from ..hamiltonian import Hamiltonian +from typing import Optional, Union, Iterable + + +class State(object): + r"""The quantum state class. + + Args: + data: The mathematical analysis of quantum state. + num_qubits: The number of qubits contained in the quantum state. Defaults to ``None``, which means it will be inferred by the data. + backend: Used to specify the backend used. Defaults to ``None``, which means to use the default backend. + dtype: Used to specify the data dtype of the data. Defaults to ``None``, which means to use the default data type. + + """ + def __init__( + self, data: Union[paddle.Tensor, np.ndarray, QCompute.QEnv], num_qubits: Optional[int] = None, + backend: Optional[paddle_quantum.Backend] = None, dtype: Optional[str] = None + ): + # TODO: need to check whether it is a legal quantum state + super().__init__() + self.backend = paddle_quantum.get_backend() if backend is None else backend + if self.backend != Backend.QuLeaf: + if not isinstance(data, paddle.Tensor): + data = paddle.to_tensor(data) + if dtype is not None: + data = paddle.cast(data, dtype) + self.dtype = dtype if dtype is not None else paddle_quantum.get_dtype() + if self.backend == Backend.StateVector: + self.data = data + if num_qubits is not None: + if data.shape[-1] != 2 ** num_qubits: + raise Exception("The shape of the data should (2 ** num_qubits, ).") + else: + num_qubits = int(math.log2(data.shape[-1])) + assert 2 ** num_qubits == data.shape[-1], "The length of the state should be the integer power of two." + elif self.backend == Backend.DensityMatrix: + self.data = data + if num_qubits is not None: + if data.shape[-1] != 2 ** num_qubits or data.shape[-2] != 2 ** num_qubits: + raise Exception("The shape of the data should (2 ** num_qubits, 2 ** num_qubits).") + else: + assert data.shape[-1] == data.shape[-2], "The data should be a square matrix." + num_qubits = int(math.log2(data.shape[-1])) + assert 2 ** num_qubits == data.shape[-1], "The data should be integer power of 2." + elif self.backend == Backend.UnitaryMatrix: + self.data = data + if num_qubits is not None: + if data.shape[-1] != 2 ** num_qubits or data.shape[-2] != 2 ** num_qubits: + raise Exception("The shape of the data should (2 ** num_qubits, 2 ** num_qubits).") + else: + assert data.shape[-1] == data.shape[-2], "The data should be a square matrix." + num_qubits = int(math.log2(data.shape[-1])) + assert 2 ** num_qubits == data.shape[-1], "The data should be integer power of 2." + elif self.backend == Backend.QuLeaf: + self.data = data + if quleaf.get_quleaf_backend() != QCompute.BackendName.LocalBaiduSim2: + assert quleaf.get_quleaf_token() is not None, "You must input token tu use cloud server." + self.gate_history = [] + self.param_list = [] + self.num_param = 0 + else: + raise NotImplementedError + self.num_qubits = num_qubits + + def numpy(self) -> np.ndarray: + r"""get the data in numpy. + + Returns: + The numpy array of the data for the quantum state. + """ + return self.data.numpy() + + def to(self, backend: str, dtype: str, device: str, blocking: str): + r"""Change the property of the state. + + Args: + backend: Specify the new backend of the state. + dtype: Specify the new data type of the state. + device: Specify the new device of the state. + blocking: Specify the new blocking of the state. + + Returns: + Return a error because this function is not implemented. + """ + # TODO: to be implemented + return NotImplementedError + + def clone(self) -> 'paddle_quantum.State': + r"""Return a copy of the quantum state. + + Returns: + A new state which is identical to this state. + """ + return State(self.data, self.num_qubits, self.backend, self.dtype) + + def __str__(self): + return str(self.data.numpy()) + + def expec_val(self, hamiltonian: Hamiltonian, shots: Optional[int] = 0) -> float: + r"""The expectation value of the observable with respect to the quantum state. + + Args: + hamiltonian: Input observable. + shots: Number of measurement shots. + + Returns: + The expectation value of the input observable for the quantum state. + """ + if shots == 0: + func = paddle_quantum.loss.ExpecVal(hamiltonian) + result = func(self) + return result + result = 0 + gate_for_x = paddle.to_tensor([ + [1 / math.sqrt(2), 1 / math.sqrt(2)], + [1 / math.sqrt(2), -1 / math.sqrt(2)], + ], dtype=self.dtype) + gate_for_y = paddle.to_tensor([ + [1 / math.sqrt(2), -1j / math.sqrt(2)], + [1 / math.sqrt(2), 1j / math.sqrt(2)], + ], dtype=self.dtype) + # gate_for_x = paddle.to_tensor([ + # [1 / math.sqrt(2), 1j / math.sqrt(2)], + # [1j / math.sqrt(2), 1 / math.sqrt(2)], + # ], dtype=self.dtype) + # gate_for_y = paddle.to_tensor([ + # [1 / math.sqrt(2), -1j / math.sqrt(2)], + # [-1j / math.sqrt(2), 1 / math.sqrt(2)], + # ], dtype=self.dtype) + if self.backend == Backend.StateVector: + simulator = state_vector.unitary_transformation + elif self.backend == Backend.DensityMatrix: + simulator = density_matrix.unitary_transformation + else: + raise NotImplementedError + for coeff, pauli_str in hamiltonian.pauli_str: + pauli_list = pauli_str.split(',') + state_data = paddle.to_tensor(self.data.numpy()) + if pauli_str.lower() == 'i': + result += coeff + continue + qubits_list = [] + for pauli_term in pauli_list: + pauli = pauli_term[0] + idx = int(pauli_term[1:]) + qubits_list.append(idx) + if pauli.lower() == 'x': + state_data = simulator( + state_data, gate_for_x, idx, self.num_qubits + ) + elif pauli.lower() == 'y': + state_data = simulator( + state_data, gate_for_y, idx, self.num_qubits + ) + if self.backend == paddle_quantum.Backend.StateVector: + prob_amplitude = paddle.multiply(paddle.conj(state_data), state_data).real() + elif self.backend == paddle_quantum.Backend.DensityMatrix: + prob_amplitude = paddle.zeros([2 ** self.num_qubits]) + for idx in range(0, 2 ** self.num_qubits): + prob_amplitude[idx] += state_data[idx, idx].real() + else: + raise NotImplementedError + prob_amplitude = prob_amplitude.tolist() + all_case = [bin(element)[2:].zfill(self.num_qubits) for element in range(0, 2 ** self.num_qubits)] + samples = random.choices(all_case, weights=prob_amplitude, k=shots) + counter = collections.Counter(samples) + measured_results = [] + for key, val in counter.items(): + measured_results.append(([key[idx] for idx in qubits_list], val)) + temp_res = sum(((-1) ** key.count('1') * val / shots for key, val in measured_results)) + result += coeff * temp_res + return result + + def measure(self, shots: Optional[int] = 0, qubits_idx: Optional[Union[Iterable[int], int]] = None, + plot: Optional[bool] = False) -> dict: + r"""Measure the quantum state + + Args: + shots: the number of measurements on the quantum state output by the quantum circuit. + Default is ``0``, which means the exact probability distribution of measurement results are returned. + qubits_idx: The index of the qubit to be measured. Defaults to ``None``, which means all qubits are measured. + plot: Whether to draw the measurement result plot. Defaults to ``False`` which means no plot. + + + Returns: + Measurement results + """ + if self.backend == paddle_quantum.Backend.StateVector: + prob_amplitude = paddle.multiply(paddle.conj(self.data), self.data).real() + elif self.backend == paddle_quantum.Backend.DensityMatrix: + prob_amplitude = paddle.zeros([2 ** self.num_qubits]) + for idx in range(0, 2 ** self.num_qubits): + prob_amplitude[idx] += self.data[idx, idx].real() + else: + raise NotImplementedError + if qubits_idx is None: + prob_array = prob_amplitude + num_measured = self.num_qubits + elif isinstance(qubits_idx, (Iterable, int)): + if isinstance(qubits_idx, int): + qubits_idx = [qubits_idx] + else: + qubits_idx = list(qubits_idx) + num_measured = len(qubits_idx) + prob_array = paddle.zeros([2 ** num_measured]) + for idx in range(0, 2 ** self.num_qubits): + binary = bin(idx)[2:].zfill(self.num_qubits) + target_qubits = '' + for qubit_idx in qubits_idx: + target_qubits += binary[qubit_idx] + prob_array[int(target_qubits, base=2)] += prob_amplitude[idx] + else: + raise NotImplementedError + if shots == 0: + freq = prob_array.tolist() + result = {bin(idx)[2:].zfill(num_measured): val for idx, val in enumerate(freq)} + else: + samples = random.choices(range(0, 2 ** num_measured), weights=prob_array, k=shots) + freq = [0] * (2 ** num_measured) + for item in samples: + freq[item] += 1 + freq = [val / shots for val in freq] + result = {bin(idx)[2:].zfill(num_measured): val for idx, val in enumerate(freq)} + if plot: + assert num_measured < 6, "Too many qubits to plot" + if shots == 0: + ylabel = "Measured Probabilities" + else: + ylabel = "Probabilities" + state_list = [bin(idx)[2:].zfill(num_measured) for idx in range(0, 2 ** num_measured)] + plt.bar(range(2 ** num_measured), freq, tick_label=state_list) + plt.xticks(rotation=90) + plt.xlabel("Qubit State") + plt.ylabel(ylabel) + plt.show() + return result diff --git a/paddle_quantum/trotter.py b/paddle_quantum/trotter.py index 6c70f48..088fc43 100644 --- a/paddle_quantum/trotter.py +++ b/paddle_quantum/trotter.py @@ -1,3 +1,4 @@ +# !/usr/bin/env python3 # Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); @@ -12,75 +13,59 @@ # See the License for the specific language governing permissions and # limitations under the License. +r""" +Trotter Hamiltonian time evolution circuit module. """ -Trotter Hamiltonian time evolution circuit module -""" -from paddle_quantum.utils import Hamiltonian -from paddle_quantum.circuit import UAnsatz + from collections import defaultdict +from typing import Optional, Union, Iterable +import paddle_quantum +from paddle_quantum import Hamiltonian import warnings import numpy as np import re import paddle +from .intrinsic import _get_float_dtype +from .ansatz import Circuit -PI = paddle.to_tensor(np.pi, dtype='float64') +float_dtype = _get_float_dtype(paddle_quantum.get_dtype()) +PI = paddle.to_tensor(np.pi, dtype=float_dtype) def construct_trotter_circuit( - circuit: UAnsatz, + circuit: Circuit, hamiltonian: Hamiltonian, tau: float, steps: int, - method: str = 'suzuki', - order: int = 1, - grouping: str = None, - coefficient: np.ndarray or paddle.Tensor = None, - permutation: np.ndarray = None + method: Optional[str] = 'suzuki', + order: Optional[int] = 1, + grouping: Optional[str] = None, + coefficient: Optional[Union[np.ndarray, paddle.Tensor]] = None, + permutation: Optional[np.ndarray] = None ): - r"""向 circuit 的后面添加 trotter 时间演化电路，即给定一个系统的哈密顿量 H，该电路可以模拟系统的时间演化 :math:`U_{cir}~ e^{-iHt}` 。 + r"""Add time-evolving circuits to a user-specified circuit. + + This circuit could approximate the time-evolving operator of a system given its Hamiltonian H, + i.e., :math:`U_{\rm cir}~ e^{-iHt}`. Args: - circuit (UAnsatz): 需要添加时间演化电路的 UAnsatz 对象 - hamiltonian (Hamiltonian): 需要模拟时间演化的系统的哈密顿量 H - tau (float): 每个 trotter 块的演化时间长度 - steps (int): 添加多少个 trotter 块（提示： ``steps * tau`` 即演化的时间总长度 t） - method (str): 搭建时间演化电路的方法，默认为 ``'suzuki'`` ，即使用 Trotter-Suzuki 分解。可以设置为 ``'custom'`` 来使用自定义的演化策略 - （需要用 permutation 和 coefficient 来定义） - order (int): Trotter-Suzuki decomposition 的阶数，默认为 ``1`` ，仅在使用 ``method='suzuki'`` 时有效 - grouping (str): 是否对哈密顿量进行指定策略的重新排列，默认为 ``None`` ，支持 ``'xyz'`` 和 ``'even_odd'`` 两种方法 - coefficient (array or Tensor): 自定义时间演化电路的系数，对应哈密顿量中的各项，默认为 ``None`` ，仅在 ``method='custom'`` 时有效 - permutation (array): 自定义哈密顿量的排列方式，默认为 ``None`` ，仅在 ``method='custom'`` 时有效 - - 代码示例： - - .. code-block:: python - - from paddle_quantum.utils import Hamiltonian - from paddle_quantum.circuit import UAnsatz - from paddle_quantum.trotter import construct_trotter_circuit, get_1d_heisenberg_hamiltonian - import numpy as np - - h = get_1d_heisenberg_hamiltonian(length=3) - cir = UAnsatz(h.n_qubits) - t = 1 - r = 10 - # 1st order product formula (PF) circuit - construct_trotter_circuit(cir, h, tau=t/r, steps=r) - # 2nd order product formula (PF) circuit - construct_trotter_circuit(cir, h, tau=t/r, steps=r, order=2) - # higher order product formula (PF) circuit - construct_trotter_circuit(cir, h, tau=t/r, steps=r, order=10) - - # customize coefficient and permutation - # the following codes is equivalent to adding the 1st order PF - permutation = np.arange(h.n_terms) - coefficients = np.ones(h.n_terms) - construct_trotter_circuit(cir, h, tau=t/r, steps=r, method='custom', - permutation=permutation, coefficient=coefficients) + circuit: Circuit object to which a time evolution circuit will be added. + hamiltonian: Hamiltonian of the system whose time evolution is to be simulated. + tau: Evolution time of each trotter block. + steps: Number of trotter blocks that will be added in total. + (Hint: ``steps * tau`` should be the total evolution time.) + method: How the time evolution circuit will be constructed. Defaults to ``'suzuki'``, i.e., using + Trotter-Suzuki decomposition. Set to ``'custom'`` to use a customized simulation strategy. + (Needs to be specified with arguments permutation and coefficient.) + order: Order of the Trotter-Suzuki decomposition. Only works when ``method='suzuki'``. Defaults to 1. + grouping: Whether the Hamiltonian's ordering will be rearranged in a user-specified way. Supports ``'xyz'`` + and ``'even_odd'`` grouping methods. Defaults to None. + coefficient: Custom coefficients corresponding to terms of the Hamiltonian. Only works for ``method='custom'``. Defaults to None. + permutation: Custom permutation of the Hamiltonian. Only works for ``method='custom'``. Defaults to None. Hint: - 对于该函数的原理以及其使用方法更详细的解释，可以参考量桨官网中量子模拟部分的教程 https://qml.baidu.com/tutorials/overview.html + For a more detailed explanation of how this function works, users may refer to the tutorials on Paddle Quantum's website: https://qml.baidu.com/tutorials/overview.html. """ # check the legitimacy of the inputs (coefficient and permutation) def check_input_legitimacy(arg_in): @@ -184,7 +169,7 @@ def __get_suzuki_num(order): def __sort_pauli_word(pauli_word, site): - r""" 将 pauli_word 按照 site 的大小进行排列，并同时返回排序后的 pauli_word 和 site。 + r"""将 pauli_word 按照 site 的大小进行排列，并同时返回排序后的 pauli_word 和 site。 Note: 这是一个内部函数，一般你不需要直接使用它。 @@ -194,10 +179,10 @@ def __sort_pauli_word(pauli_word, site): def _add_trotter_block(circuit, tau, grouped_hamiltonian, order): - r""" 添加一个 trotter 块，i.e. :math:`e^{-iH\tau}`，并使用 Trotter-Suzuki 分解对其进行展开。 + r"""添加一个 trotter 块，i.e. :math:`e^{-iH\tau}`，并使用 Trotter-Suzuki 分解对其进行展开。 Args: - circuit (UAnsatz): 需要添加 trotter 块的电路 + circuit (Circuit): 需要添加 trotter 块的电路 tau (float or tensor): 该 trotter 块的演化时间 grouped_hamiltonian (list): 一个由 Hamiltonian 对象组成的列表，该函数会默认该列表中的哈密顿量为 Trotter-Suzuki 展开的基本项 order (int): Trotter-Suzuki 展开的阶数 @@ -224,7 +209,7 @@ def _add_custom_block(circuit, tau, grouped_hamiltonian, custom_coefficients, pe r""" 添加一个自定义形式的 trotter 块 Args: - circuit (UAnsatz): 需要添加 trotter 块的电路 + circuit (Circuit)): 需要添加 trotter 块的电路 tau (float or tensor): 该 trotter 块的演化时间 grouped_hamiltonian (list): 一个由 Hamiltonian 对象组成的列表，该函数会默认该列表中的哈密顿量为 trotter-suzuki 展开的基本项 order (int): trotter-suzuki 展开的阶数 @@ -326,29 +311,30 @@ def __add_first_order_trotter_block(circuit, tau, grouped_hamiltonian, reverse=F add_n_pauli_gate(circuit, 2 * tau * coeffs[term_index], pauli_word, site) -def optimal_circuit(circuit, theta, which_qubits): - r""" 添加一个优化电路，哈密顿量为'XXYYZZ' +def optimal_circuit(circuit: paddle_quantum.ansatz.Circuit, theta: Union[paddle.Tensor, float], which_qubits: Iterable): + """Add an optimized circuit with the Hamiltonian 'XXYYZZ'. Args: - circuit (UAnsatz): 需要添加门的电路 - theta list(paddle.Tensor or float): 旋转角度需要传入三个参数 - which_qubits (list or numpy.ndarray): ``pauli_word`` 中的每个算符所作用的量子比特编号 + circuit: Circuit where the gates are to be added. + theta: Three rotation angles. + which_qubits: List of the index of the qubit that each Pauli operator acts on. """ - p = np.pi/2 + p = paddle.to_tensor(np.pi / 2, dtype=float_dtype) x, y, z = theta - alpha = paddle.to_tensor(3*p-4*x*p+2*x, dtype='float64') - beta = paddle.to_tensor(-3*p+4*y*p-2*y, dtype='float64') - gamma = paddle.to_tensor(2*z-p, dtype='float64') + alpha = paddle.to_tensor(3 * p - 4 * x * p + 2 * x, dtype=float_dtype) + beta = paddle.to_tensor(-3 * p + 4 * y * p - 2 * y, dtype=float_dtype) + gamma = paddle.to_tensor(2 * z - p, dtype=float_dtype) which_qubits.sort() a, b = which_qubits - circuit.rz(paddle.to_tensor(p, dtype='float64'), b) + + circuit.rz(b, param=p) circuit.cnot([b, a]) - circuit.rz(gamma, a) - circuit.ry(alpha, b) + circuit.rz(a, param=gamma) + circuit.ry(b, param=alpha) circuit.cnot([a, b]) - circuit.ry(beta, b) + circuit.ry(b, param=beta) circuit.cnot([b, a]) - circuit.rz(paddle.to_tensor(-p, dtype='float64'), a) + circuit.rz(a, param=-p) def __add_second_order_trotter_block(circuit, tau, grouped_hamiltonian): @@ -377,14 +363,20 @@ def __add_higher_order_trotter_block(circuit, tau, grouped_hamiltonian, order): __add_second_order_trotter_block(circuit, p * tau, grouped_hamiltonian) -def add_n_pauli_gate(circuit, theta, pauli_word, which_qubits): - r""" 添加一个对应着 N 个泡利算符张量积的旋转门，例如 :math:`e^{-\theta/2 * X \otimes I \otimes X \otimes Y}` +def add_n_pauli_gate( + circuit: paddle_quantum.ansatz.Circuit, theta: Union[paddle.Tensor, float], + pauli_word: str, which_qubits: Iterable +): + r"""Add a rotation gate for a tensor product of Pauli operators, for example :math:`e^{-\theta/2 * X \otimes I \otimes X \otimes Y}`. Args: - circuit (UAnsatz): 需要添加门的电路 - theta (tensor or float): 旋转角度 - pauli_word (str): 泡利算符组成的字符串，例如 ``"XXZ"`` - which_qubits (list or np.ndarray): ``pauli_word`` 中的每个算符所作用的量子比特编号 + circuit: Circuit where the gates are to be added. + theta: Rotation angle. + pauli_word: Pauli operators in a string format, e.g., ``"XXZ"``. + which_qubits: List of the index of the qubit that each Pauli operator in the ``pauli_word`` acts on. + + Raises: + ValueError: The ``which_qubits`` should be either ``list``, ``tuple``, or ``np.ndarray``. """ if isinstance(which_qubits, tuple) or isinstance(which_qubits, list): which_qubits = np.array(which_qubits) @@ -392,18 +384,15 @@ def add_n_pauli_gate(circuit, theta, pauli_word, which_qubits): raise ValueError('which_qubits should be either a list, tuple or np.ndarray') if not isinstance(theta, paddle.Tensor): - theta = paddle.to_tensor(theta, dtype='float64') - # the following assert is not working properly - # assert isinstance(circuit, UAnsatz), 'the circuit should be an UAnstaz object' - + theta = paddle.to_tensor(theta, dtype=float_dtype) # if it is a single-Pauli case, apply the single qubit rotation gate accordingly if len(which_qubits) == 1: if re.match(r'X', pauli_word[0], flags=re.I): - circuit.rx(theta, which_qubit=which_qubits[0]) + circuit.rx(which_qubits[0], param=theta) elif re.match(r'Y', pauli_word[0], flags=re.I): - circuit.ry(theta, which_qubit=which_qubits[0]) + circuit.ry(which_qubits[0], param=theta) elif re.match(r'Z', pauli_word[0], flags=re.I): - circuit.rz(theta, which_qubit=which_qubits[0]) + circuit.rz(which_qubits[0], param=theta) # if it is a multiple-Pauli case, implement a Pauli tensor rotation # we use a scheme described in 4.7.3 of Nielson & Chuang, that is, basis change + tensor Z rotation @@ -414,23 +403,23 @@ def add_n_pauli_gate(circuit, theta, pauli_word, which_qubits): # Change the basis for qubits on which the acting operators are not 'Z' for qubit_index in range(len(which_qubits)): if re.match(r'X', pauli_word[qubit_index], flags=re.I): - circuit.h(which_qubits[qubit_index]) + circuit.h([which_qubits[qubit_index]]) elif re.match(r'Y', pauli_word[qubit_index], flags=re.I): - circuit.rx(PI / 2, which_qubits[qubit_index]) + circuit.rx(which_qubits[qubit_index], param=PI / 2) # Add a Z tensor n rotational gate for i in range(len(which_qubits) - 1): circuit.cnot([which_qubits[i], which_qubits[i + 1]]) - circuit.rz(theta, which_qubits[-1]) + circuit.rz(which_qubits[-1], param=theta) for i in reversed(range(len(which_qubits) - 1)): circuit.cnot([which_qubits[i], which_qubits[i + 1]]) # Change the basis for qubits on which the acting operators are not 'Z' for qubit_index in range(len(which_qubits)): if re.match(r'X', pauli_word[qubit_index], flags=re.I): - circuit.h(which_qubits[qubit_index]) + circuit.h([which_qubits[qubit_index]]) elif re.match(r'Y', pauli_word[qubit_index], flags=re.I): - circuit.rx(- PI / 2, which_qubits[qubit_index]) + circuit.rx(which_qubits[qubit_index], param=-PI / 2) def __group_hamiltonian_xyz(hamiltonian): @@ -502,15 +491,15 @@ def __group_hamiltonian_even_odd(hamiltonian): return grouped_hamiltonian -def get_suzuki_permutation(length, order): - r""" 计算 Suzuki 分解对应的置换数组。 +def get_suzuki_permutation(length: int, order: int) -> np.ndarray: + r"""Calculate the permutation array corresponding to the Suzuki decomposition. Args: - length (int): 对应哈密顿量中的项数，即需要置换的项数 - order (int): Suzuki 分解的阶数 + length: Number of terms in the Hamiltonian, i.e., how many terms to be permuted. + order: Order of the Suzuki decomposition. Returns: - np.ndarray : 置换数组 + Permutation array. """ if order == 1: return np.arange(length) @@ -520,28 +509,28 @@ def get_suzuki_permutation(length, order): return np.vstack([get_suzuki_permutation(length=length, order=order - 2) for _ in range(5)]) -def get_suzuki_p_values(k): - r""" 计算 Suzuki 分解中递推关系中的因数 p(k)。 +def get_suzuki_p_values(k: int) -> list: + r"""Calculate the parameter p(k) in the Suzuki recurrence relationship. Args: - k (int): Suzuki 分解的阶数 + k: Order of the Suzuki decomposition. Returns: - list : 一个长度为 5 的列表，其形式为 [p, p, (1 - 4 * p), p, p] + A list of length five of form [p, p, (1 - 4 * p), p, p]. """ p = 1 / (4 - 4 ** (1 / (k - 1))) return [p, p, (1 - 4 * p), p, p] -def get_suzuki_coefficients(length, order): - r""" 计算 Suzuki 分解对应的系数数组。 +def get_suzuki_coefficients(length: int, order: int) -> np.ndarray: + r"""Calculate the coefficient array corresponding to the Suzuki decomposition. Args: - length (int): 对应哈密顿量中的项数，即需要置换的项数 - order (int): Suzuki 分解的阶数 + length: Number of terms in the Hamiltonian, i.e., how many terms to be permuted. + order: Order of the Suzuki decomposition. Returns: - np.ndarray : 系数数组 + Coefficient array. """ if order == 1: return np.ones(length) @@ -560,19 +549,19 @@ def get_1d_heisenberg_hamiltonian( j_z: float = 1., h_z: float or np.ndarray = 0., periodic_boundary_condition: bool = True -): - r"""生成一个一维海森堡链的哈密顿量。 +) -> Hamiltonian: + r"""Generate the Hamiltonian of a one-dimensional Heisenberg chain. Args: - length (int): 链长 - j_x (float): x 方向的自旋耦合强度 Jx，默认为 ``1`` - j_y (float): y 方向的自旋耦合强度 Jy，默认为 ``1`` - j_z (float): z 方向的自旋耦合强度 Jz，默认为 ``1`` - h_z (float or np.ndarray): z 方向的磁场，默认为 ``0`` ，若输入为单个 float 则认为是均匀磁场（施加在每一个格点上） - periodic_boundary_condition (bool): 是否考虑周期性边界条件，即 l + 1 = 0，默认为 ``True`` + length: Chain length. + j_x: Coupling strength Jx on the x direction. Defaults to ``1.``. + j_y: Coupling strength Jy on the y direction. Defaults to ``1.``. + j_z: Coupling strength Jz on the z direction. Defaults to ``1.``. + h_z: Magnet field along z-axis. A uniform field will be added for single float input. Defaults to ``0.``. + periodic_boundary_condition: Whether to consider the periodic boundary, i.e., l + 1 = 0. Defaults to ``True``. Returns: - Hamiltonian :该海森堡链的哈密顿量 + Hamiltonian of this Heisenberg chain. """ # Pauli words for Heisenberg interactions and their coupling strength interactions = ['XX', 'YY', 'ZZ'] @@ -595,6 +584,7 @@ def get_1d_heisenberg_hamiltonian( boundary_sites = [0, length - 1] for interaction_idx in range(len(interactions)): term_str = '' + interaction = interactions[interaction_idx] for idx_word in range(len(interaction)): term_str += interaction[idx_word] + str(boundary_sites[idx_word]) if idx_word != len(interaction) - 1: diff --git a/paddle_quantum/utils.py b/paddle_quantum/utils.py deleted file mode 100644 index 164d83d..0000000 --- a/paddle_quantum/utils.py +++ /dev/null @@ -1,2240 +0,0 @@ -# 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. - -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 scipy.special import logsumexp -from tqdm import tqdm -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 -from paddle import matmul -from paddle import transpose -from paddle import concat, ones -from paddle import zeros -from scipy import sparse -import matplotlib as mpl -from paddle_quantum import simulator -import matplotlib.animation as animation -import matplotlib.image - -__all__ = [ - "partial_trace", - "partial_trace_discontiguous", - "state_fidelity", - "trace_distance", - "gate_fidelity", - "purity", - "von_neumann_entropy", - "relative_entropy", - "NKron", - "dagger", - "random_pauli_str_generator", - "pauli_str_to_matrix", - "partial_transpose_2", - "partial_transpose", - "negativity", - "logarithmic_negativity", - "is_ppt", - "haar_orthogonal", - "haar_unitary", - "haar_state_vector", - "haar_density_operator", - "schmidt_decompose", - "plot_state_in_bloch_sphere", - "plot_multi_qubits_state_in_bloch_sphere", - "plot_rotation_in_bloch_sphere", - "plot_density_matrix_graph", - "image_to_density_matrix", - "Hamiltonian", - "QuantumFisher", - "ClassicalFisher", -] - - -def partial_trace(rho_AB, dim1, dim2, A_or_B): - r"""计算量子态的偏迹。 - - Args: - rho_AB (Tensor): 输入的量子态 - dim1 (int): 系统A的维数 - dim2 (int): 系统B的维数 - A_or_B (int): 1或者2，1表示计算系统A上的偏迹，2表示计算系统B上的偏迹 - - Returns: - Tensor: 输入的量子态的偏迹 - - """ - if A_or_B == 2: - dim1, dim2 = dim2, dim1 - - idty_np = np.identity(dim2).astype("complex128") - idty_B = to_tensor(idty_np) - - zero_np = np.zeros([dim2, dim2], "complex128") - res = to_tensor(zero_np) - - for dim_j in range(dim1): - row_top = zeros([1, dim_j], dtype="float64") - row_mid = ones([1, 1], dtype="float64") - row_bot = zeros([1, dim1 - dim_j - 1], dtype="float64") - bra_j = concat([row_top, row_mid, row_bot], axis=1) - bra_j = paddle.cast(bra_j, 'complex128') - - if A_or_B == 1: - row_tmp = kron(bra_j, idty_B) - row_tmp_conj = paddle.conj(row_tmp) - res = add(res, matmul(matmul(row_tmp, rho_AB), transpose(row_tmp_conj, perm=[1, 0]), ), ) - - if A_or_B == 2: - row_tmp = kron(idty_B, bra_j) - row_tmp_conj = paddle.conj(row_tmp) - res = add(res, matmul(matmul(row_tmp, rho_AB), transpose(row_tmp_conj, perm=[1, 0]), ), ) - - return res - - -def partial_trace_discontiguous(rho, preserve_qubits=None): - r"""计算量子态的偏迹，可选取任意子系统。 - - Args: - rho (Tensor): 输入的量子态 - preserve_qubits (list): 要保留的量子比特，默认为 None，表示全保留 - """ - if preserve_qubits is None: - return rho - else: - n = int(log2(rho.size) // 2) - num_preserve = len(preserve_qubits) - - shape = paddle.ones((n + 1,)) - shape = 2 * shape - shape[n] = 2 ** n - shape = paddle.cast(shape, "int32") - identity = paddle.eye(2 ** n) - identity = paddle.reshape(identity, shape=shape) - discard = list() - for idx in range(0, n): - if idx not in preserve_qubits: - discard.append(idx) - addition = [n] - preserve_qubits.sort() - - preserve_qubits = paddle.to_tensor(preserve_qubits) - discard = paddle.to_tensor(discard) - addition = paddle.to_tensor(addition) - permute = paddle.concat([discard, preserve_qubits, addition]) - - identity = paddle.transpose(identity, perm=permute) - identity = paddle.reshape(identity, (2 ** n, 2 ** n)) - - result = np.zeros((2 ** num_preserve, 2 ** num_preserve), dtype="complex64") - result = paddle.to_tensor(result) - - for i in range(0, 2 ** (n - num_preserve)): - bra = identity[i * 2 ** num_preserve:(i + 1) * 2 ** num_preserve, :] - result = result + matmul(matmul(bra, rho), transpose(bra, perm=[1, 0])) - - return result - - -def state_fidelity(rho, sigma): - r"""计算两个量子态的保真度。 - - .. math:: - F(\rho, \sigma) = \text{tr}(\sqrt{\sqrt{\rho}\sigma\sqrt{\rho}}) - - Args: - rho (numpy.ndarray): 量子态的密度矩阵形式 - sigma (numpy.ndarray): 量子态的密度矩阵形式 - - Returns: - float: 输入的量子态之间的保真度 - """ - assert rho.shape == sigma.shape, 'The shape of two quantum states are different' - fidelity = np.trace(sqrtm(sqrtm(rho) @ sigma @ sqrtm(rho))).real - - return fidelity - - -def trace_distance(rho, sigma): - r"""计算两个量子态的迹距离。 - - .. math:: - D(\rho, \sigma) = 1 / 2 * \text{tr}|\rho-\sigma| - - Args: - rho (numpy.ndarray): 量子态的密度矩阵形式 - sigma (numpy.ndarray): 量子态的密度矩阵形式 - - Returns: - float: 输入的量子态之间的迹距离 - """ - assert rho.shape == sigma.shape, 'The shape of two quantum states are different' - A = rho - sigma - distance = 1 / 2 * np.sum(np.abs(np.linalg.eigvals(A))) - - return distance - - -def gate_fidelity(U, V): - r"""计算两个量子门的保真度。 - - .. math:: - - F(U, V) = |\text{tr}(UV^\dagger)|/2^n - - :math:`U` 是一个 :math:`2^n\times 2^n` 的 Unitary 矩阵。 - - Args: - U (numpy.ndarray): 量子门 :math:`U` 的酉矩阵形式 - V (numpy.ndarray): 量子门 :math:`V` 的酉矩阵形式 - - Returns: - float: 输入的量子门之间的保真度 - """ - 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 - - return fidelity - - -def purity(rho): - r"""计算量子态的纯度。 - - .. math:: - - P = \text{tr}(\rho^2) - - Args: - rho (numpy.ndarray): 量子态的密度矩阵形式 - - Returns: - float: 输入的量子态的纯度 - """ - gamma = np.trace(np.matmul(rho, rho)) - - return gamma.real - - -def von_neumann_entropy(rho): - r"""计算量子态的冯诺依曼熵。 - - .. math:: - - S = -\text{tr}(\rho \log(\rho)) - - Args: - rho(numpy.ndarray): 量子态的密度矩阵形式 - - Returns: - float: 输入的量子态的冯诺依曼熵 - """ - rho_eigenvalues = np.real(np.linalg.eigvals(rho)) - entropy = 0 - for eigenvalue in rho_eigenvalues: - if np.abs(eigenvalue) < 1e-8: - continue - entropy -= eigenvalue * np.log(eigenvalue) - - return entropy - - -def relative_entropy(rho, sig): - r"""计算两个量子态的相对熵。 - - .. math:: - - S(\rho \| \sigma)=\text{tr} \rho(\log \rho-\log \sigma) - - Args: - rho (numpy.ndarray): 量子态的密度矩阵形式 - sig (numpy.ndarray): 量子态的密度矩阵形式 - - Returns: - float: 输入的量子态之间的相对熵 - """ - assert rho.shape == sig.shape, 'The shape of two quantum states are different' - res = np.trace(rho @ logm(rho) - rho @ logm(sig)) - return res.real - - -def NKron(matrix_A, matrix_B, *args): - r"""计算两个及以上的矩阵的Kronecker积。 - - Args: - matrix_A (numpy.ndarray): 一个矩阵 - matrix_B (numpy.ndarray): 一个矩阵 - *args (numpy.ndarray): 其余矩阵 - - Returns: - Tensor: 输入矩阵的Kronecker积 - - .. code-block:: python - - from paddle_quantum.state import density_op_random - from paddle_quantum.utils import NKron - A = density_op_random(2) - B = density_op_random(2) - C = density_op_random(2) - result = NKron(A, B, C) - - ``result`` 应为 :math:`A \otimes B \otimes C` - """ - return reduce(lambda result, index: np.kron(result, index), args, np.kron(matrix_A, matrix_B), ) - - -def dagger(matrix): - r"""计算矩阵的埃尔米特转置，即Hermitian transpose。 - - Args: - matrix (Tensor): 需要埃尔米特转置的矩阵 - - Returns: - Tensor: 输入矩阵的埃尔米特转置 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.utils import dagger - import numpy as np - rho = paddle.to_tensor(np.array([[1+1j, 2+2j], [3+3j, 4+4j]])) - print(dagger(rho).numpy()) - - :: - - [[1.-1.j 3.-3.j] - [2.-2.j 4.-4.j]] - """ - matrix_conj = paddle.conj(matrix) - matrix_dagger = transpose(matrix_conj, perm=[1, 0]) - - return matrix_dagger - - -def random_pauli_str_generator(n, terms=3): - r"""随机生成一个可观测量（observable）的列表（ ``list`` ）形式。 - - 一个可观测量 :math:`O=0.3X\otimes I\otimes I+0.5Y\otimes I\otimes Z` 的 - 列表形式为 ``[[0.3, 'x0'], [0.5, 'y0,z2']]`` 。这样一个可观测量是由 - 调用 ``random_pauli_str_generator(3, terms=2)`` 生成的。 - - Args: - n (int): 量子比特数量 - terms (int, optional): 可观测量的项数 - - Returns: - list: 随机生成的可观测量的列表形式 - """ - pauli_str = [] - for sublen in np.random.randint(1, high=n + 1, size=terms): - # Tips: -1 <= coeff < 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)] - pauli_str.append([coeff, ','.join(op_list)]) - return pauli_str - - -def pauli_str_to_matrix(pauli_str, n): - r"""将输入的可观测量（observable）的列表（ ``list`` ）形式转换为其矩阵形式。 - - 如输入的 ``pauli_str`` 为 ``[[0.7, 'z0,x1'], [0.2, 'z1']]`` 且 ``n=3`` , - 则此函数返回可观测量 :math:`0.7Z\otimes X\otimes I+0.2I\otimes Z\otimes I` 的 - 矩阵形式。 - - Args: - pauli_str (list): 一个可观测量的列表形式 - n (int): 量子比特数量 - - Returns: - numpy.ndarray: 输入列表对应的可观测量的矩阵形式 - """ - pauli_dict = {'i': np.eye(2) + 0j, 'x': np.array([[0, 1], [1, 0]]) + 0j, - 'y': np.array([[0, -1j], [1j, 0]]), 'z': np.array([[1, 0], [0, -1]]) + 0j} - - # Parse pauli_str; 'x0,z1,y4' to 'xziiy' - new_pauli_str = [] - for coeff, op_str in pauli_str: - init = list('i' * n) - op_list = re.split(r',\s*', op_str.lower()) - for op in op_list: - 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) - matrices = [] - for coeff, op_str in new_pauli_str: - sub_matrices = [] - for op in op_str: - sub_matrices.append(pauli_dict[op.lower()]) - if len(op_str) == 1: - matrices.append(coeff * sub_matrices[0]) - else: - matrices.append(coeff * NKron(sub_matrices[0], sub_matrices[1], *sub_matrices[2:])) - - return sum(matrices) - - -def partial_transpose_2(density_op, sub_system=None): - r"""计算输入量子态的 partial transpose :math:`\rho^{T_A}` - - Args: - density_op (numpy.ndarray): 量子态的密度矩阵形式 - sub_system (int): 1或2，表示关于哪个子系统进行 partial transpose，默认为第二个 - - Returns: - float: 输入的量子态的 partial transpose - - 代码示例: - - .. code-block:: python - - from paddle_quantum.utils import partial_transpose_2 - rho_test = np.arange(1,17).reshape(4,4) - partial_transpose_2(rho_test, sub_system=1) - - :: - - [[ 1, 2, 9, 10], - [ 5, 6, 13, 14], - [ 3, 4, 11, 12], - [ 7, 8, 15, 16]] - """ - sys_idx = 2 if sub_system is None else 1 - - # Copy the density matrix and not corrupt the original one - transposed_density_op = np.copy(density_op) - 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() - 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] - - return transposed_density_op - - -def partial_transpose(density_op, n): - r"""计算输入量子态的 partial transpose :math:`\rho^{T_A}`。 - - Args: - density_op (numpy.ndarray): 量子态的密度矩阵形式 - - Returns: - float: 输入的量子态的 partial transpose - """ - - # 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() - - return transposed_density_op - - -def negativity(density_op): - r"""计算输入量子态的 Negativity :math:`N = ||\frac{\rho^{T_A}-1}{2}||`。 - - Args: - density_op (numpy.ndarray): 量子态的密度矩阵形式 - - Returns: - float: 输入的量子态的 Negativity - - 代码示例: - - .. code-block:: python - - from paddle_quantum.utils import negativity - from paddle_quantum.state import bell_state - rho = bell_state(2) - print("Negativity of the Bell state is:", negativity(rho)) - - :: - - Negativity of the Bell state is: 0.5 - """ - # Implement the partial transpose - density_op_T = partial_transpose_2(density_op) - - # Calculate through the equivalent expression N = sum(abs(\lambda_i)) when \lambda_i<0 - n = 0 - eigen_val, _ = np.linalg.eig(density_op_T) - for val in eigen_val: - if val < 0: - n = n + np.abs(val) - return n - - -def logarithmic_negativity(density_op): - r"""计算输入量子态的 Logarithmic Negativity :math:`E_N = ||\rho^{T_A}||`。 - - Args: - density_op (numpy.ndarray): 量子态的密度矩阵形式 - - Returns: - float: 输入的量子态的 Logarithmic Negativity - - 代码示例: - - .. code-block:: python - - from paddle_quantum.utils import logarithmic_negativity - from paddle_quantum.state import bell_state - rho = bell_state(2) - print("Logarithmic negativity of the Bell state is:", logarithmic_negativity(rho)) - - :: - - Logarithmic negativity of the Bell state is: 1.0 - """ - # Calculate the negativity - n = negativity(density_op) - - # Calculate through the equivalent expression - log2_n = np.log2(2 * n + 1) - return log2_n - - -def is_ppt(density_op): - r"""计算输入量子态是否满足 PPT 条件。 - - Args: - density_op (numpy.ndarray): 量子态的密度矩阵形式 - - Returns: - bool: 输入的量子态是否满足 PPT 条件 - - 代码示例: - - .. code-block:: python - - from paddle_quantum.utils import is_ppt - from paddle_quantum.state import bell_state - rho = bell_state(2) - print("Whether the Bell state satisfies PPT condition:", is_ppt(rho)) - - :: - - Whether the Bell state satisfies PPT condition: False - """ - # By default the PPT condition is satisfied - ppt = True - - # Detect negative eigenvalues from the partial transposed density_op - if negativity(density_op) > 0: - ppt = False - return ppt - - -def haar_orthogonal(n): - r"""生成一个服从 Haar random 的正交矩阵。采样算法参考文献：arXiv:math-ph/0609050v2 - - Args: - n (int): 正交矩阵对应的量子比特数 - - Returns: - numpy.ndarray: 一个形状为 ``(2**n, 2**n)`` 随机正交矩阵 - """ - # Matrix dimension - d = 2 ** n - # Step 1: sample from Ginibre ensemble - g = (np.random.randn(d, d)) - # Step 2: perform QR decomposition of G - q, r = np.linalg.qr(g) - # Step 3: make the decomposition unique - lam = np.diag(r) / abs(np.diag(r)) - u = q @ np.diag(lam) - - return u - - -def haar_unitary(n): - r"""生成一个服从 Haar random 的酉矩阵。采样算法参考文献：arXiv:math-ph/0609050v2 - - Args: - n (int): 酉矩阵对应的量子比特数 - - Returns: - numpy.ndarray: 一个形状为 ``(2**n, 2**n)`` 随机酉矩阵 - """ - # Matrix dimension - d = 2 ** n - # Step 1: sample from Ginibre ensemble - g = (np.random.randn(d, d) + 1j * np.random.randn(d, d)) / np.sqrt(2) - # Step 2: perform QR decomposition of G - q, r = np.linalg.qr(g) - # Step 3: make the decomposition unique - lam = np.diag(r) / abs(np.diag(r)) - u = q @ np.diag(lam) - - return u - - -def haar_state_vector(n, real=False): - r"""生成一个服从 Haar random 的态矢量。 - - Args: - n (int): 量子态的量子比特数 - real (bool): 生成的态矢量是否为实态矢量，默认为 ``False`` - - Returns: - numpy.ndarray: 一个形状为 ``(2**n, 1)`` 随机态矢量 - """ - # Vector dimension - d = 2 ** n - if real: - # Generate a Haar random orthogonal matrix - o = haar_orthogonal(n) - # Perform u onto |0>, i.e., the first column of o - phi = o[:, 0] - else: - # Generate a Haar random unitary - u = haar_unitary(n) - # Perform u onto |0>, i.e., the first column of u - phi = u[:, 0] - - return phi - - -def haar_density_operator(n, k=None, real=False): - r"""生成一个服从 Haar random 的密度矩阵。 - - Args: - n (int): 量子态的量子比特数 - k (int): 密度矩阵的秩，默认为 ``None``，表示满秩 - real (bool): 生成的密度矩阵是否为实矩阵，默认为 ``False`` - - Returns: - numpy.ndarray: 一个形状为 ``(2**n, 2**n)`` 随机密度矩阵 - """ - d = 2 ** n - k = k if k is not None else d - assert 0 < k <= d, 'rank is an invalid number' - if real: - ginibre_matrix = np.random.randn(d, k) - rho = ginibre_matrix @ ginibre_matrix.T - else: - ginibre_matrix = np.random.randn(d, k) + 1j * np.random.randn(d, k) - rho = ginibre_matrix @ ginibre_matrix.conj().T - - return rho / np.trace(rho) - - -def schmidt_decompose(psi, sys_A=None): - r"""计算输入量子态的施密特分解 :math:`\lvert\psi\rangle=\sum_ic_i\lvert i_A\rangle\otimes\lvert i_B \rangle`。 - - Args: - psi (numpy.ndarray): 量子态的向量形式，形状为（2**n） - sys_A (list): 包含在子系统 A 中的 qubit 下标（其余 qubit 包含在子系统B中），默认为量子态 :math:`\lvert \psi\rangle` 的前半数 qubit - - Returns: - tuple: 包含如下元素 - - numpy.ndarray: 由施密特系数组成的一维数组，形状为 ``(k)`` - - numpy.ndarray: 由子系统A的基 :math:`\lvert i_A\rangle` 组成的高维数组，形状为 ``(k, 2**m, 1)`` - - numpy.ndarray: 由子系统B的基 :math:`\lvert i_B\rangle` 组成的高维数组，形状为 ``(k, 2**l, 1)`` - - Warning: - 小于 ``1e-13`` 的施密特系数将被视作浮点误差并舍去 - - .. code-block:: python - - # zz = 1/√2 * (<010| + <101|) - zz = 1/np.sqrt(2) * (np.array([0., 0., 1., 0., 0., 0., 0., 0.]) + np.array([0., 0., 0., 0., 0., 1., 0., 0.])) - print('input state:', zz) - l, u, v = schmidt_decompose(zz, [0, 2]) - - print('output state:') - for i in range(len(l)): - print('+', l[i], '*', u[i].reshape([-1]), '⨂', v[i].reshape([-1])) - - Note: - 代码示例结果应为 1/√2 * (<00|⨂<1| + <11|⨂<0|)。注意，输入态的第 0、2 个 qubit 处于输出态的子系统 A，输入态的第1个 qubit 处于输出态的子系统 B。 - """ - - assert psi.ndim == 1, 'Psi must be a one dimensional vector.' - assert np.log2(psi.size).is_integer(), 'The number of amplitutes must be an integral power of 2.' - - tot_qu = int(np.log2(psi.size)) - sys_A = sys_A if sys_A is not None else [i for i in range(tot_qu//2)] - sys_B = [i for i in range(tot_qu) if i not in sys_A] - - # Permute qubit indices - psi = psi.reshape([2] * tot_qu).transpose(sys_A + sys_B) - - # construct amplitute matrix - amp_mtr = psi.reshape([2**len(sys_A), 2**len(sys_B)]) - - # Standard process to obtain schmidt decomposition - u, c, v = np.linalg.svd(amp_mtr) - - k = np.count_nonzero(c > 1e-13) - c = c[:k] - u = u.T[:k].reshape([k, -1, 1]) - v = v[:k].reshape([k, -1, 1]) - return c, u, v - - -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, - set_color=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): 视图的角度， - 第一个元素为关于xy平面的夹角[0-360],第二个元素为关于xz平面的夹角[0-360], 默认为 (30, 45) - view_dist (int): 视图的距离，默认为 7 - set_color (str): 设置指定的颜色，请查阅cmap表，默认为 "红-黑-根据向量的模长渐变" 颜色方案 - """ - # 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 - if set_color is None: - 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]) - else: - color = set_color - - # 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.0 - ) - - # 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.0 - ) - - -def plot_state_in_bloch_sphere( - state, - show_arrow=False, - save_gif=False, - filename=None, - view_angle=None, - view_dist=None, - set_color=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): 视图的角度， - 第一个元素为关于 xy 平面的夹角 [0-360]，第二个元素为关于 xz 平面的夹角 [0-360], 默认为 ``(30, 45)`` - view_dist (int): 视图的距离，默认为 7 - set_color (str): 若要设置指定的颜色，请查阅 ``cmap`` 表。默认为红色到黑色的渐变颜色 - """ - # 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 "state" 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, '"state" is NULL.' - for i in range(state_len): - assert type(state[i]) == paddle.Tensor or type(state[i]) == np.ndarray, \ - 'the type of "state[i]" should be "paddle.Tensor" or "numpy.ndarray".' - if set_color is not None: - assert type(set_color) == str, \ - 'the type of "set_color" should be "str".' - - # 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) - - # A update function for animation class - def update(frame): - view_rotating_angle = 5 - new_view_angle = [view_angle[0], view_angle[1] + view_rotating_angle * frame] - __plot_bloch_sphere( - ax, bloch_vectors, show_arrow, clear_plt=True, - view_angle=new_view_angle, view_dist=view_dist, set_color=set_color - ) - - # Dynamic update and save - if save_gif: - # 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') - - frames_num = 7 - anim = animation.FuncAnimation(fig, update, frames=frames_num, interval=600, repeat=False) - anim.save(filename, dpi=100, writer='pillow') - # close the plt - plt.close(fig) - - # 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') - - __plot_bloch_sphere( - ax, bloch_vectors, show_arrow, clear_plt=True, - view_angle=view_angle, view_dist=view_dist, set_color=set_color - ) - - plt.show() - - -def plot_multi_qubits_state_in_bloch_sphere( - state, - which_qubits=None, - show_arrow=False, - save_gif=False, - save_pic=True, - filename=None, - view_angle=None, - view_dist=None, - set_color='#0000FF' -): - r"""将输入的多量子比特的量子态展示在 Bloch 球面上 - - Args: - state (numpy.ndarray or paddle.Tensor): 输入的量子态，可以支持态矢量和密度矩阵 - which_qubits (list or None): 要展示的量子比特，默认为全展示 - show_arrow (bool): 是否展示向量的箭头，默认为 ``False`` - save_gif (bool): 是否存储 gif 动图，默认为 ``False`` - save_pic (bool): 是否存储静态图片，默认为 ``True`` - filename (str): 存储的图片的名字 - view_angle (list or tuple): 视图的角度，第一个元素为关于 xy 平面的夹角 [0-360]，第二个元素为关于 xz 平面的夹角 [0-360], 默认为 ``(30, 45)`` - view_dist (int): 视图的距离，默认为 7 - set_color (str): 若要设置指定的颜色，请查阅 ``cmap`` 表。默认为蓝色 - """ - # Check input data - __input_args_dtype_check(show_arrow, save_gif, filename, view_angle, view_dist) - - assert type(state) == paddle.Tensor or type(state) == np.ndarray, \ - 'the type of "state" must be "paddle.Tensor" or "np.ndarray".' - assert type(set_color) == str, \ - 'the type of "set_color" should be "str".' - - n_qubits = int(np.log2(state.shape[0])) - - if which_qubits is None: - which_qubits = list(range(n_qubits)) - else: - assert type(which_qubits) == list, 'the type of which_qubits should be None or list' - assert 1 <= len(which_qubits) <= n_qubits, '展示的量子数量需要小于n_qubits' - for i in range(len(which_qubits)): - assert 0 <= which_qubits[i] < n_qubits, '0= 2 and state.size == state.shape[0]: - state_vector = state - state = np.outer(state_vector, np.conj(state_vector)) - - # multi qubits state decompose - if state.shape[0] > 2: - rho = paddle.to_tensor(state) - tmp_s = [] - for q in which_qubits: - tmp_s.append(partial_trace_discontiguous(rho, [q])) - state = tmp_s - else: - state = [state] - 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) - - # A update function for animation class - def update(frame): - view_rotating_angle = 5 - new_view_angle = [view_angle[0], view_angle[1] + view_rotating_angle * frame] - __plot_bloch_sphere( - ax, bloch_vectors, show_arrow, clear_plt=True, - view_angle=new_view_angle, view_dist=view_dist, set_color=set_color - ) - - # Dynamic update and save - if save_gif: - # 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') - - frames_num = 7 - anim = animation.FuncAnimation(fig, update, frames=frames_num, interval=600, repeat=False) - anim.save(filename, dpi=100, writer='pillow') - # close the plt - plt.close(fig) - - # 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) - dim = np.ceil(sqrt(len(which_qubits))) - for i in range(1, len(which_qubits)+1): - ax = fig.add_subplot(dim, dim, i, projection='3d') - bloch_vector = np.array([bloch_vectors[i-1]]) - __plot_bloch_sphere( - ax, bloch_vector, show_arrow, clear_plt=True, - view_angle=view_angle, view_dist=view_dist, set_color=set_color - ) - if save_pic: - plt.savefig('n_qubit_state_in_bloch.png', bbox_inches='tight') - 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, - color_scheme=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): 视图的角度， - 第一个元素为关于 xy 平面的夹角 [0-360]，第二个元素为关于 xz 平面的夹角 [0-360], 默认为 ``(30, 45)`` - view_dist (int): 视图的距离，默认为 7 - color_scheme (list(str,str,str)): 分别是初始颜色，轨迹颜色，结束颜色。若要设置指定的颜色，请查阅 ``cmap`` 表。默认为红色 - """ - # 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].' - if color_scheme is not None: - assert type(color_scheme) == list and len(color_scheme) <= 3, \ - 'the type of "color_scheme" should be "list" and ' \ - 'the length of "color_scheme" should be less than or equal to "3".' - for i in range(len(color_scheme)): - assert type(color_scheme[i]) == str, \ - 'the type of "color_scheme[i] should be "str".' - - # Assign a value to an empty variable - if filename is None: - filename = 'rotation_in_bloch_sphere.gif' - - # Assign colors to bloch vectors - color_list = ['orangered', 'lightsalmon', 'darkred'] - if color_scheme is not None: - for i in range(len(color_scheme)): - color_list[i] = color_scheme[i] - set_init_color, set_trac_color, set_end_color = color_list - - 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) - - # A update function for animation class - def update(frame): - frame = frame + 2 - if frame <= len(bloch_vectors) - 1: - __plot_bloch_sphere( - ax, bloch_vectors[1:frame], show_arrow=show_arrow, clear_plt=True, - rotating_angle_list=rotating_angle_list, - view_angle=view_angle, view_dist=view_dist, set_color=set_trac_color - ) - - # 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, set_color=set_init_color - ) - - # 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, set_color=set_end_color - ) - - if save_gif: - # 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') - - # Dynamic update and save - stop_frames = 15 - frames_num = len(bloch_vectors) - 2 + stop_frames - anim = animation.FuncAnimation(fig, update, frames=frames_num, interval=100, repeat=False) - anim.save(filename, dpi=100, writer='pillow') - # close the plt - plt.close(fig) - - # 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') - - # Draw the penultimate bloch vector - update(len(bloch_vectors) - 3) - # Draw the last bloch vector - update(len(bloch_vectors) - 2) - - plt.show() - - -def plot_density_matrix_graph(density_matrix, size=0.3): - r"""密度矩阵可视化工具。 - - Args: - density_matrix (numpy.ndarray or paddle.Tensor): 多量子比特的量子态的状态向量或者密度矩阵,要求量子数大于 1 - size (float): 条宽度，在 0 到 1 之间，默认为 0.3 - """ - if not isinstance(density_matrix, (np.ndarray, paddle.Tensor)): - msg = f'Expected density_matrix to be np.ndarray or paddle.Tensor, but got {type(density_matrix)}' - raise TypeError(msg) - if isinstance(density_matrix, paddle.Tensor): - density_matrix = density_matrix.numpy() - if density_matrix.shape[0] != density_matrix.shape[1]: - msg = f'Expected density matrix dim0 equal to dim1, but got dim0={density_matrix.shape[0]}, dim1={density_matrix.shape[1]}' - raise ValueError(msg) - - real = density_matrix.real - imag = density_matrix.imag - - figure = plt.figure() - ax_real = figure.add_subplot(121, projection='3d', title="real") - ax_imag = figure.add_subplot(122, projection='3d', title="imag") - - xx, yy = np.meshgrid( - list(range(real.shape[0])), list(range(real.shape[1]))) - xx, yy = xx.ravel(), yy.ravel() - real = real.reshape(-1) - imag = imag.reshape(-1) - - ax_real.bar3d(xx, yy, np.zeros_like(real), size, size, np.abs(real)) - ax_imag.bar3d(xx, yy, np.zeros_like(imag), size, size, np.abs(imag)) - plt.show() - - return - - -def image_to_density_matrix(image_filepath): - r"""将图片编码为密度矩阵 - - Args: - image_filepath (str): 图片文件的路径 - - Return: - rho (numpy.ndarray): 编码得到的密度矩阵 - """ - image_matrix = matplotlib.image.imread(image_filepath) - - # Converting images to grayscale - image_matrix = image_matrix.mean(axis=2) - - # Fill the matrix so that it becomes a matrix whose shape is [2**n,2**n] - length = int(2**np.ceil(np.log2(np.max(image_matrix.shape)))) - image_matrix = np.pad(image_matrix, ((0, length-image_matrix.shape[0]), (0, length-image_matrix.shape[1])), 'constant') - # Density matrix whose trace is 1 - rho = image_matrix@image_matrix.T - rho = rho/np.trace(rho) - return rho - - -def pauli_basis(n): - r"""生成 n 量子比特的泡利基空间 - - Args: - n (int): 量子比特的数量 - - Return: - tuple: - - basis_str: 泡利基空间的一组基底表示（array形式） - - label_str: 泡利基空间对应的一组基底表示（标签形式），形如``[ 'X', 'Y', 'Z', 'I']`` - """ - sigma_x = np.array([[0, 1], [1, 0]], dtype=np.complex128) - sigma_y = np.array([[0, -1j], [1j, 0]], dtype=np.complex128) - sigma_z = np.array([[1, 0], [0, -1]], dtype=np.complex128) - sigma_id = np.array([[1, 0], [0, 1]], dtype=np.complex128) - pauli = [sigma_x, sigma_y, sigma_z, sigma_id] - labels = ['X', 'Y', 'Z', 'I'] - - num_qubits = n - num = 1 - if num_qubits > 0: - basis_str = pauli[:] - label_str = labels[:] - pauli_basis = pauli[:] - pauli_label = labels[:] - while num < num_qubits: - length = len(basis_str) - for i in range(4): - for j in range(length): - basis_str.append(np.kron(basis_str[j], pauli_basis[i])) - label_str.append(label_str[j] + pauli_label[i]) - basis_str = basis_str[-1:-4**(num+1)-1:-1] - label_str = label_str[-1:-4**(num+1)-1:-1] - num += 1 - return basis_str, label_str - - -def decompose(matrix): - r"""生成 n 量子比特的泡利基空间 - - Args: - matrix (numpy.ndarray): 要分解的矩阵 - - Return: - pauli_form (list): 返回矩阵分解后的哈密顿量，形如 ``[[1, 'Z0, Z1'], [2, 'I']]`` - """ - if np.log2(len(matrix)) % 1 != 0: - print("Please input correct matrix!") - return -1 - basis_space, label_str = pauli_basis(np.log2(len(matrix))) - coefficients = [] # 对应的系数 - pauli_word = [] # 对应的label - pauli_form = [] # 输出pauli_str list形式：[[1, 'Z0, Z1'], [2, 'I']] - for i in range(len(basis_space)): - # 求系数 - a_ij = 1/len(matrix) * np.trace(matrix@basis_space[i]) - if a_ij != 0: - if a_ij.imag != 0: - coefficients.append(a_ij) - else: - coefficients.append(a_ij.real) - pauli_word.append(label_str[i]) - for i in range(len(coefficients)): - pauli_site = [] # 临时存放一个基 - pauli_site.append(coefficients[i]) - word = '' - for j in range(len(pauli_word[0])): - if pauli_word[i] == 'I'*int(np.log2(len(matrix))): - word = 'I' # 和Hamiltonian类似，若全是I就用一个I指代 - break - if pauli_word[i][j] == 'I': - continue # 如果是I就不加数字下标 - if j != 0 and len(word) != 0: - word += ',' - word += pauli_word[i][j] - word += str(j) # 对每一个label加标签，说明是作用在哪个比特 - pauli_site.append(word) # 添加上对应作用的门 - pauli_form.append(pauli_site) - - return pauli_form - - -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, qubit_num=None): - r"""构建 Hamiltonian 在 Z 基底下的矩阵。 - - Returns: - np.ndarray: Z 基底下的哈密顿量矩阵形式 - """ - coefs, pauli_words, sites = self.decompose_with_sites() - if qubit_num is None: - qubit_num = 1 - for site in sites: - if type(site[0]) is int: - qubit_num = max(qubit_num, max(site) + 1) - else: - assert qubit_num >= self.n_qubits, "输入的量子数不小于哈密顿量表达式中所对应的量子比特数" - n_qubit = qubit_num - 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 计算，默认为 ``False`` - """ - 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)) - - @property - def sigz_p(self): - r""" :math:`Z` 基底下的 :math:`S^z_i` 算符。 - - Returns: - list : :math:`S^z_i` 算符组成的列表，其中每一项对应不同的 :math:`i` - """ - return self.__sigz_p - - @property - def sigy_p(self): - r""" :math:`Z` 基底下的 :math:`S^y_i` 算符。 - - Returns: - list : :math:`S^y_i` 算符组成的列表，其中每一项对应不同的 :math:`i` - """ - return self.__sigy_p - - @property - def sigx_p(self): - r""" :math:`Z` 基底下的 :math:`S^x_i` 算符。 - - Returns: - list : :math:`S^x_i` 算符组成的列表，其中每一项对应不同的 :math:`i` - """ - return self.__sigx_p - - 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 动图 - filename (str): 存储的 gif 动图的名字 - view_angle (list or tuple): 视图的角度， - 第一个元素为关于xy平面的夹角[0-360],第二个元素为关于xz平面的夹角[0-360], 默认为 (30, 45) - 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".' - - -class QuantumFisher: - r"""量子费舍信息及相关量的计算器。 - - Attributes: - cir (UAnsatz): 需要计算量子费舍信息的参数化量子电路 - """ - def __init__(self, cir): - r"""QuantumFisher 的构造函数，用于实例化一个量子费舍信息的计算器。 - - Args: - cir (UAnsatz): 需要计算量子费舍信息的参数化量子电路 - """ - self.cir = cir - - def get_qfisher_matrix(self): - r"""利用二阶参数平移规则计算量子费舍信息矩阵。 - - Returns: - numpy.ndarray: 量子费舍信息矩阵 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - from paddle_quantum.utils import QuantumFisher - - cir = UAnsatz(1) - cir.ry(theta=paddle.to_tensor(0., dtype="float64", stop_gradient=False), - which_qubit=0) - cir.rz(theta=paddle.to_tensor(0., dtype="float64", stop_gradient=False), - which_qubit=0) - - qf = QuantumFisher(cir) - qfim = qf.get_qfisher_matrix() - print(f'The QFIM at {cir.get_param().tolist()} is \n {qfim}.') - - :: - - The QFIM at [0.0, 0.0] is - [[1. 0.] - [0. 0.]]. - """ - # Get the real-time parameters from the UAnsatz class - list_param = self.cir.get_param().tolist() - num_param = len(list_param) - # Initialize a numpy array to record the QFIM - qfim = np.zeros((num_param, num_param)) - # Assign the signs corresponding to the four terms in a QFIM element - list_sign = [[1, 1], [1, -1], [-1, 1], [-1, -1]] - # Run the circuit and record the current state vector - psi = self.cir.run_state_vector().numpy() - # For each QFIM element - for i in range(0, num_param): - for j in range(i, num_param): - # For each term in each element - for sign_i, sign_j in list_sign: - # Shift the parameters by pi/2 * sign - list_param[i] += np.pi / 2 * sign_i - list_param[j] += np.pi / 2 * sign_j - # Update the parameters in the circuit - self.cir.update_param(list_param) - # Run the shifted circuit and record the shifted state vector - psi_shift = self.cir.run_state_vector().numpy() - # Calculate each term as the fidelity with a sign factor - qfim[i][j] += abs(np.vdot( - psi_shift, psi))**2 * sign_i * sign_j * (-0.5) - # De-shift the parameters - list_param[i] -= np.pi / 2 * sign_i - list_param[j] -= np.pi / 2 * sign_j - self.cir.update_param(list_param) - if i != j: - # The QFIM is symmetric - qfim[j][i] = qfim[i][j] - - return qfim - - def get_qfisher_norm(self, direction, step_size=0.01): - r"""利用有限差分计算沿给定方向的量子费舍信息的投影。 - - Args: - direction (list): 要计算量子费舍信息投影的方向 - step_size (float, optional): 有限差分的步长，默认为 0.01 - - Returns: - float: 沿给定方向的量子费舍信息的投影 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - from paddle_quantum.utils import QuantumFisher - - cir = UAnsatz(2) - cir.ry(theta=paddle.to_tensor(0., dtype="float64", stop_gradient=False), - which_qubit=0) - cir.ry(theta=paddle.to_tensor(0., dtype="float64", stop_gradient=False), - which_qubit=1) - cir.cnot(control=[0, 1]) - cir.ry(theta=paddle.to_tensor(0., dtype="float64", stop_gradient=False), - which_qubit=0) - cir.ry(theta=paddle.to_tensor(0., dtype="float64", stop_gradient=False), - which_qubit=1) - - qf = QuantumFisher(cir) - v = [1,1,1,1] - qfi_norm = qf.get_qfisher_norm(direction=v) - print(f'The QFI norm along {v} at {cir.get_param().tolist()} is {qfi_norm:.7f}') - - :: - - The QFI norm along [1, 1, 1, 1] at [0.0, 0.0, 0.0, 0.0] is 5.9996250 - """ - # Get the real-time parameters - list_param = self.cir.get_param().tolist() - # Run the circuit and record the current state vector - psi = self.cir.run_state_vector().numpy() - # Check whether the length of the input direction vector is equal to the number of the variational parameters - assert len(list_param) == len( - direction - ), "the length of direction vector should be equal to the number of the parameters" - # Shift the parameters by step_size * direction - array_params_shift = np.array( - list_param) + np.array(direction) * step_size - # Update the parameters in the circuit - self.cir.update_param(array_params_shift.tolist()) - # Run the shifted circuit and record the shifted state vector - psi_shift = self.cir.run_state_vector().numpy() - # Calculate quantum Fisher-Rao norm along the given direction - qfisher_norm = (1 - abs(np.vdot(psi_shift, psi))**2) * 4 / step_size**2 - # De-shift the parameters and update - self.cir.update_param(list_param) - - return qfisher_norm - - def get_eff_qdim(self, num_param_samples=4, tol=None): - r"""计算有效量子维数，即量子费舍信息矩阵的秩在整个参数空间的最大值。 - - Args: - num_param_samples (int, optional): 用来估计有效量子维数时所用的参数样本量，默认为 4 - tol (float, optional): 奇异值的最小容差，低于此容差的奇异值认为是 0，默认为 None，其含义同 ``numpy.linalg.matrix_rank()`` - - Returns: - int: 给定量子电路对应的有效量子维数 - - 代码示例: - - .. code-block:: python - - import paddle - from paddle_quantum.circuit import UAnsatz - from paddle_quantum.utils import QuantumFisher - - cir = UAnsatz(1) - cir.rz(theta=paddle.to_tensor(0., dtype="float64", stop_gradient=False), - which_qubit=0) - cir.ry(theta=paddle.to_tensor(0., dtype="float64", stop_gradient=False), - which_qubit=0) - - qf = QuantumFisher(cir) - print(cir) - print(f'The number of parameters of -Rz-Ry- is {len(cir.get_param().tolist())}') - print(f'The effective quantum dimension -Rz-Ry- is {qf.get_eff_qdim()}') - - :: - - --Rz(0.000)----Ry(0.000)-- - - The number of parameters of -Rz-Ry- is 2 - The effective quantum dimension -Rz-Ry- is 1 - """ - # Get the real-time parameters - list_param = self.cir.get_param().tolist() - num_param = len(list_param) - # Generate random parameters - param_samples = 2 * np.pi * np.random.random( - (num_param_samples, num_param)) - # Record the ranks - list_ranks = [] - # Here it has been assumed that the set of points that do not maximize the rank of QFIMs, as singularities, form a null set. - # Thus one can find the maximal rank using a few samples. - for param in param_samples: - # Set the random parameters - self.cir.update_param(param.tolist()) - # Calculate the ranks - list_ranks.append(self.get_qfisher_rank(tol)) - # Recover the original parameters - self.cir.update_param(list_param) - - return max(list_ranks) - - def get_qfisher_rank(self, tol=None): - r"""计算量子费舍信息矩阵的秩。 - - Args: - tol (float, optional): 奇异值的最小容差，低于此容差的奇异值认为是 0，默认为 None，其含义同 ``numpy.linalg.matrix_rank()`` - - Returns: - int: 量子费舍信息矩阵的秩 - """ - qfisher_rank = np.linalg.matrix_rank(self.get_qfisher_matrix(), - tol, - hermitian=True) - return qfisher_rank - - -class ClassicalFisher: - r"""经典费舍信息及相关量的计算器。 - - Attributes: - model (paddle.nn.Layer): 经典或量子神经网络模型的实例 - num_thetas (int): 参数集合的数量 - num_inputs (int): 输入的样本数量 - """ - def __init__(self, - model, - num_thetas, - num_inputs, - model_type='quantum', - **kwargs): - r"""ClassicalFisher 的构造函数，用于实例化一个经典费舍信息的计算器。 - - Args: - model (paddle.nn.Layer): 经典或量子神经网络模型的实例 - num_thetas (int): 参数集合的数量 - num_inputs (int): 输入的样本数量 - model_type (str, optional): 模型是经典 "classical" 的还是量子 "quantum" 的，默认是量子的 - - Note: - 这里 ``**kwargs`` 包含如下选项: - - size (list): 经典神经网络各层神经元的数量 - - num_qubits (int): 量子神经网络量子比特的数量 - - depth (int): 量子神经网络的深度 - - encoding (str): 量子神经网络中经典数据的编码方式，目前支持 "IQP" 和 "re-uploading" - - Raises: - ValueError: 不被支持的编码方式 - ValueError: 不被支持的模型类别 - """ - self.model = model - self.num_thetas = num_thetas - self.num_inputs = num_inputs - self._model_type = model_type - if self._model_type == 'classical': - layer_dims = kwargs['size'] - self.model_args = [layer_dims] - self.input_size = layer_dims[0] - self.output_size = layer_dims[-1] - self.num_params = sum(layer_dims[i] * layer_dims[i + 1] - for i in range(len(layer_dims) - 1)) - elif self._model_type == 'quantum': - num_qubits = kwargs['num_qubits'] - depth = kwargs['depth'] - # Supported QNN encoding: ‘IQP' and 're-uploading' - encoding = kwargs['encoding'] - self.model_args = [num_qubits, depth, encoding] - self.input_size = num_qubits - # Default dimension of output layer = 1 - self.output_size = 1 - # Determine the number of model parameters for different encoding types - if encoding == 'IQP': - self.num_params = 3 * depth * num_qubits - elif encoding == 're-uploading': - self.num_params = 3 * (depth + 1) * num_qubits - else: - raise ValueError('Non-existent encoding method') - else: - raise ValueError( - 'The model type should be equal to either classical or quantum' - ) - - # Generate random data - np.random.seed(0) - x = np.random.normal(0, 1, size=(num_inputs, self.input_size)) - # Use the same input data for each theta set - self.x = np.tile(x, (num_thetas, 1)) - - def get_gradient(self, x): - r"""计算输出层关于变分参数的梯度。 - - Args: - x (numpy.ndarray): 输入样本 - - Returns: - numpy.ndarray: 输出层关于变分参数的梯度，数组形状为（输入样本数量, 输出层维数, 变分参数数量） - """ - if not paddle.is_tensor(x): - x = paddle.to_tensor(x, stop_gradient=True) - gradvectors = [] - seed = 0 - - pbar = tqdm(desc="running in get_gradient: ", - total=len(x), - ncols=100, - ascii=True) - - for m in range(len(x)): - pbar.update(1) - if m % self.num_inputs == 0: - seed += 1 - paddle.seed(seed) - net = self.model(*self.model_args) - output = net(x[m]) - logoutput = paddle.log(output) - grad = [] - for i in range(self.output_size): - net.clear_gradients() - logoutput[i].backward(retain_graph=True) - grads = [] - for param in net.parameters(): - grads.append(param.grad.reshape((-1, ))) - gr = paddle.concat(grads) - grad.append(gr * paddle.sqrt(output[i])) - jacobian = paddle.concat(grad) - # Jacobian matrix corresponding to each data point - jacobian = paddle.reshape(jacobian, - (self.output_size, self.num_params)) - gradvectors.append(jacobian.detach().numpy()) - - pbar.close() - - return gradvectors - - def get_cfisher(self, gradients): - r"""利用雅可比矩阵计算经典费舍信息矩阵。 - - Args: - gradients (numpy.ndarray): 输出层关于变分参数的梯度, 数组形状为（输入样本数量, 输出层维数, 变分参数数量） - - Returns: - numpy.ndarray: 经典费舍信息矩阵，数组形状为（输入样本数量, 变分参数数量, 变分参数数量） - """ - fishers = np.zeros((len(gradients), self.num_params, self.num_params)) - for i in range(len(gradients)): - grads = gradients[i] - temp_sum = np.zeros( - (self.output_size, self.num_params, self.num_params)) - for j in range(self.output_size): - temp_sum[j] += np.array( - np.outer(grads[j], np.transpose(grads[j]))) - fishers[i] += np.sum(temp_sum, axis=0) - - return fishers - - def get_normalized_cfisher(self): - r"""计算归一化的经典费舍信息矩阵。 - - Returns: - numpy.ndarray: 归一化的经典费舍信息矩阵，数组形状为（输入样本数量, 变分参数数量, 变分参数数量） - """ - grads = self.get_gradient(self.x) - fishers = self.get_cfisher(grads) - fisher_trace = np.trace(np.average(fishers, axis=0)) - # Average over input data - fisher = np.average(np.reshape(fishers, - (self.num_thetas, self.num_inputs, - self.num_params, self.num_params)), - axis=1) - normalized_cfisher = self.num_params * fisher / fisher_trace - - return normalized_cfisher, fisher_trace - - def get_eff_dim(self, normalized_cfisher, list_num_samples, gamma=1): - r"""计算经典的有效维数。 - - Args: - normalized_cfisher (numpy.ndarray): 归一化的经典费舍信息矩阵 - list_num_samples (list): 不同样本量构成的列表 - gamma (int, optional): 有效维数定义中包含的一个人为可调参数，默认为 1 - - Returns: - list: 对于不同样本量的有效维数构成的列表 - """ - eff_dims = [] - for n in list_num_samples: - one_plus_F = np.eye( - self.num_params) + normalized_cfisher * gamma * n / ( - 2 * np.pi * np.log(n)) - det = np.linalg.slogdet(one_plus_F)[1] - r = det / 2 - eff_dims.append(2 * (logsumexp(r) - np.log(self.num_thetas)) / - np.log(gamma * n / (2 * np.pi * np.log(n)))) - - return eff_dims diff --git a/paddle_quantum/visual.py b/paddle_quantum/visual.py new file mode 100644 index 0000000..e58841a --- /dev/null +++ b/paddle_quantum/visual.py @@ -0,0 +1,830 @@ +# !/usr/bin/env python3 +# 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. + +r""" +The visualization function in paddle quantum. +""" + +import paddle +import numpy as np +import matplotlib.pyplot as plt +import matplotlib.animation as animation +from matplotlib import colors as mplcolors +import paddle_quantum +from paddle_quantum.qinfo import partial_trace_discontiguous +from math import sqrt +from typing import Optional, Union, Tuple, List +import os + + +def plot_state_in_bloch_sphere( + state: List[paddle_quantum.State], + show_arrow: Optional[bool] = False, + save_gif: Optional[bool] = False, + filename: Optional[str] = None, + view_angle: Optional[Union[tuple, list]]=None, + view_dist: Optional[int] = None, + set_color: Optional[str] =None +) -> None: + r"""Plot the input quantum state on the Bloch sphere. + + Args: + state: List of the input quantum states in the state vector form or the density matrix form. + show_arrow: Whether to show an arrow for each vector. Defaults to ``False``. + save_gif: Whether to store the gif. Defaults to ``False``. + filename: The name of the gif file to be stored. Defaults to ``None``. + view_angle: View angle. The first element is the angle [0-360] to the x-y plane, and the second element is the angle [0-360] to the x-z plane. Defaults to ``(30, 45)``. + view_dist: View distance. Defaults to ``7``. + set_color:To set the specified color, consult the ``cmap`` table. Defaults to ``"red to black gradient"``. + """ + # 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 + or type(state) == paddle_quantum.State + ), 'the type of "state" must be "list" or "paddle.Tensor" or "np.ndarray" or "paddle_quantum.State".' + if type(state) == paddle_quantum.State: + state = [state.data] + if type(state) == paddle.Tensor or type(state) == np.ndarray: + state = [state] + state_len = len(state) + assert state_len >= 1, '"state" is NULL.' + for i in range(state_len): + assert type(state[i]) == paddle.Tensor or type(state[i]) == np.ndarray or type(state[i]) == paddle_quantum.State, \ + 'the type of "state[i]" should be "paddle.Tensor" or "numpy.ndarray" or "paddle_quantum.State".' + if set_color is not None: + assert type(set_color) == str, 'the type of "set_color" should be "str".' + + # 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() + if type(state[i]) == paddle_quantum.State: + state[i] = state[i].data.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_tmp = bloch_vector_tmp.numpy() + bloch_vector_list.append(bloch_vector_tmp) + + # List must be converted to array for slicing. + bloch_vectors = np.array(bloch_vector_list) + + # A update function for animation class + def update(frame): + view_rotating_angle = 5 + new_view_angle = [view_angle[0], view_angle[1] + view_rotating_angle * frame] + __plot_bloch_sphere( + ax, + bloch_vectors, + show_arrow, + clear_plt=True, + view_angle=new_view_angle, + view_dist=view_dist, + set_color=set_color, + ) + + # Dynamic update and save + if save_gif: + # 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') + + frames_num = 7 + anim = animation.FuncAnimation( + fig, update, frames=frames_num, interval=600, repeat=False + ) + anim.save(filename, dpi=100, writer='pillow') + # close the plt + plt.close(fig) + + # 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') + + __plot_bloch_sphere( + ax, + bloch_vectors, + show_arrow, + clear_plt=True, + view_angle=view_angle, + view_dist=view_dist, + set_color=set_color, + ) + + plt.show() + + +def plot_multi_qubits_state_in_bloch_sphere( + state: paddle_quantum.State, + which_qubits: Optional[List[int]]=None, + show_arrow: Optional[bool] = False, + save_gif: Optional[bool] = False, + save_pic: Optional[bool] = True, + filename: Optional[str] = None, + view_angle: Optional[Union[tuple, list]]=None, + view_dist: Optional[int] = None, + set_color: Optional[str] = '#0000FF' +) -> None: + r"""Displaying the quantum state on the Bloch sphere which has multi qubits. + + Args: + state: List of the input quantum states in the state vector form or the density matrix form. + which_qubits: Index of qubits to display, default to be fully displayed. + show_arrow: Whether to show an arrow for each vector. Default is ``False``. + save_gif: Whether to store the gif. Default is ``False``. + save_pic: Whether to store the picture. Default is ``True``. + filename: The name of the picture to be stored. Defaults to ``None``. + view_angle: View angle. The first element is the angle [0-360] to the x-y plane, and the second element is the angle [0-360] to the x-z plane. Defaults to ``(30, 45)``. + view_dist: View distance. Default is ``7``. + set_color: To set the specified color, consult the ``cmap`` table. Default is ``"blue"``. + """ + # Check input data + __input_args_dtype_check(show_arrow, save_gif, filename, view_angle, view_dist) + + assert ( + type(state) == paddle.Tensor + or type(state) == np.ndarray + or type(state) == paddle_quantum.State + ), 'the type of "state" must be "paddle.Tensor" or "np.ndarray" or "paddle_quantum.State".' + assert type(set_color) == str, 'the type of "set_color" should be "str".' + + if type(state) == paddle_quantum.State: + state = state.data.numpy() + + n_qubits = int(np.log2(state.shape[0])) + + if which_qubits is None: + which_qubits = list(range(n_qubits)) + else: + assert ( + type(which_qubits) == list + ), 'the type of which_qubits should be None or list' + assert 1 <= len(which_qubits) <= n_qubits, '展示的量子数量需要小于n_qubits' + for i in range(len(which_qubits)): + assert 0 <= which_qubits[i] < n_qubits, '0= 2 and state.size == state.shape[0]: + state_vector = state + state = np.outer(state_vector, np.conj(state_vector)) + + # multi qubits state decompose + if state.shape[0] > 2: + rho = paddle.to_tensor(state) + tmp_s = [] + for q in which_qubits: + tmp_s.append(partial_trace_discontiguous(rho, [q])) + state = tmp_s + else: + state = [state] + 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_tmp = bloch_vector_tmp.numpy() + bloch_vector_list.append(bloch_vector_tmp) + + # List must be converted to array for slicing. + bloch_vectors = np.array(bloch_vector_list) + + # A update function for animation class + def update(frame): + view_rotating_angle = 5 + new_view_angle = [view_angle[0], view_angle[1] + view_rotating_angle * frame] + __plot_bloch_sphere( + ax, + bloch_vectors, + show_arrow, + clear_plt=True, + view_angle=new_view_angle, + view_dist=view_dist, + set_color=set_color, + ) + + # Dynamic update and save + if save_gif: + # 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') + + frames_num = 7 + anim = animation.FuncAnimation( + fig, update, frames=frames_num, interval=600, repeat=False + ) + anim.save(filename, dpi=100, writer='pillow') + # close the plt + plt.close(fig) + + # 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) + dim = np.ceil(sqrt(len(which_qubits))).astype("int") + for i in range(1, len(which_qubits) + 1): + ax = fig.add_subplot(dim, dim, i, projection='3d') + bloch_vector = np.array([bloch_vectors[i - 1]]) + __plot_bloch_sphere( + ax, + bloch_vector, + show_arrow, + clear_plt=True, + view_angle=view_angle, + view_dist=view_dist, + set_color=set_color, + ) + if save_pic: + plt.savefig('n_qubit_state_in_bloch.png', bbox_inches='tight') + plt.show() + + +def plot_rotation_in_bloch_sphere( + init_state: paddle_quantum.State, + rotating_angle: List[paddle.Tensor], + show_arrow: Optional[bool] = False, + save_gif: Optional[bool] = False, + filename: Optional[str] = None, + view_angle: Optional[Union[list, tuple]] = None, + view_dist: Optional[int] = None, + color_scheme: Optional[List[str]] = None +) -> None: + r"""Plot the rotation starting from the initial quantum state on the Bloch sphere. + + Args: + init_state: Initial quantum state in the state vector form or the density matrix form. + rotating_angle: Rotation angle ``[theta, phi, lam]``. + show_arrow: Whether to show an arrow for each vector. Defaults to ``False``. + save_gif: Whether to store the gif. Defaults to ``False``. + filename: The name of the gif file to be stored. Defaults to ``None``. + view_angle: The first element is the angle [0-360] to the x-y plane, and the second element is the angle [0-360] to the x-z plane. Defaults to ``None``. + view_dist: View distance. Default is ``7``. + color_scheme:initial color, trace color, and end color, respectively. To set the specified color, consult the ``cmap`` table. Default is ``“red”``. + """ + # 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 + or type(init_state) == paddle_quantum.State + ), 'the type of input data should be "paddle.Tensor" or "numpy.ndarray" or "paddle_quantum.State".' + 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].' + if color_scheme is not None: + assert type(color_scheme) == list and len(color_scheme) <= 3, ( + 'the type of "color_scheme" should be "list" and ' + 'the length of "color_scheme" should be less than or equal to "3".' + ) + for i in range(len(color_scheme)): + assert ( + type(color_scheme[i]) == str + ), 'the type of "color_scheme[i] should be "str".' + + # Assign a value to an empty variable + if filename is None: + filename = 'rotation_in_bloch_sphere.gif' + + # Assign colors to bloch vectors + color_list = ['orangered', 'lightsalmon', 'darkred'] + if color_scheme is not None: + for i in range(len(color_scheme)): + color_list[i] = color_scheme[i] + set_init_color, set_trac_color, set_end_color = color_list + + for i in range(len(rotating_angle)): + if type(rotating_angle[i]) == paddle.Tensor: + rotating_angle[i] = float(rotating_angle[i].numpy()[0]) + + theta, phi, lam = rotating_angle + + # Convert Tensor to numpy + if type(init_state) == paddle_quantum.State: + init_state = init_state.data.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)) + + def u_gate_matrix(params): + theta, phi, lam = params + + if (isinstance(theta, paddle.Tensor) and + isinstance(phi, paddle.Tensor) and + isinstance(lam, 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]) + + return re + im * paddle.to_tensor([1j]) + elif (type(theta) is float and + type(phi) is float and + type(lam) is float): + return 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)]]) + else: + assert False + # Rotating angle + def rotating_operation(rotating_angle_each): + gate_matrix = u_gate_matrix(rotating_angle_each) + if type(gate_matrix) == paddle.Tensor: + gate_matrix = gate_matrix.numpy() + 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_tmp = bloch_vector_tmp.numpy() + bloch_vector_list.append(bloch_vector_tmp) + + # List must be converted to array for slicing. + bloch_vectors = np.array(bloch_vector_list) + + # A update function for animation class + def update(frame): + frame = frame + 2 + if frame <= len(bloch_vectors) - 1: + __plot_bloch_sphere( + ax, + bloch_vectors[1:frame], + show_arrow=show_arrow, + clear_plt=True, + rotating_angle_list=rotating_angle_list, + view_angle=view_angle, + view_dist=view_dist, + set_color=set_trac_color, + ) + + # 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, + set_color=set_init_color, + ) + + # 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, + set_color=set_end_color, + ) + + if save_gif: + # 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') + + # Dynamic update and save + stop_frames = 15 + frames_num = len(bloch_vectors) - 2 + stop_frames + anim = animation.FuncAnimation( + fig, update, frames=frames_num, interval=100, repeat=False + ) + anim.save(filename, dpi=100, writer='pillow') + # close the plt + plt.close(fig) + + # 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') + + # Draw the penultimate bloch vector + update(len(bloch_vectors) - 3) + # Draw the last bloch vector + update(len(bloch_vectors) - 2) + + plt.show() + + +def plot_density_matrix_graph(density_matrix: paddle_quantum.State, size: Optional[float] = 0.3) -> None: + r"""Density matrix visualization tools + + Args: + density_matrix: The state vector or density matrix of quantum state with multi qubits, requiring the number of qubits greater than 1 + size: Bar width, between 0 and 1, default is ``0.3``. + """ + if not isinstance( + density_matrix, (np.ndarray, paddle.Tensor, paddle_quantum.State) + ): + msg = f'Expected density_matrix to be np.ndarray or paddle.Tensor or paddle_quantum.State, but got {type(density_matrix)}' + raise TypeError(msg) + if isinstance(density_matrix, paddle_quantum.State): + density_matrix = density_matrix.data.numpy() + if isinstance(density_matrix, paddle.Tensor): + density_matrix = density_matrix.numpy() + if density_matrix.shape[0] != density_matrix.shape[1]: + msg = f'Expected density matrix dim0 equal to dim1, but got dim0={density_matrix.shape[0]}, dim1={density_matrix.shape[1]}' + raise ValueError(msg) + + real = density_matrix.real + imag = density_matrix.imag + + figure = plt.figure() + ax_real = figure.add_subplot(121, projection='3d', title="real") + ax_imag = figure.add_subplot(122, projection='3d', title="imag") + + xx, yy = np.meshgrid(list(range(real.shape[0])), list(range(real.shape[1]))) + xx, yy = xx.ravel(), yy.ravel() + real = real.reshape(-1) + imag = imag.reshape(-1) + + ax_real.bar3d(xx, yy, np.zeros_like(real), size, size, np.abs(real)) + ax_imag.bar3d(xx, yy, np.zeros_like(imag), size, size, np.abs(imag)) + plt.show() + + return + + +def __plot_bloch_sphere( + ax, + bloch_vectors=None, + show_arrow=False, + clear_plt=True, + rotating_angle_list=None, + view_angle=None, + view_dist=None, + set_color=None, +) -> None: + # 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 + if set_color is None: + 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]) + else: + color = set_color + + # 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.0, + ) + + # 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.0, + ) + + +def __density_matrix_convert_to_bloch_vector( + density_matrix: paddle_quantum.State, +) -> paddle.Tensor: + assert ( + type(density_matrix) == np.ndarray + or type(density_matrix) == paddle_quantum.State + ), 'the type of "state" must be "np.ndarray" or "paddle_quantum.State".' + if isinstance(density_matrix, paddle_quantum.State): + density_matrix = density_matrix.data.numpy() + + # 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 paddle.to_tensor(bloch_vector) + + +def __input_args_dtype_check(show_arrow: bool, save_gif: bool, filename: str, view_angle: Union[tuple, list], view_dist: int) -> None: + 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".' diff --git a/requirements.txt b/requirements.txt index d1c6ce7..26e4707 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,8 +1,10 @@ +qcompute paddlepaddle>=2.2.0 scipy networkx>=2.5 -matplotlib>=3.3.0 -interval +matplotlib tqdm openfermion pyscf; platform_system == "Linux" or platform_system == "Darwin" +scikit-learn +opencv-python diff --git a/setup.py b/setup.py index a4c86ce..f329267 100644 --- a/setup.py +++ b/setup.py @@ -1,4 +1,5 @@ -# Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. +#!/usr/bin/env python +# Copyright (c) 2020 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. @@ -12,7 +13,7 @@ # See the License for the specific language governing permissions and # limitations under the License. -""" +r""" Install library to site-packages """ @@ -23,7 +24,7 @@ setuptools.setup( name='paddle-quantum', - version='2.1.3', + version='2.2.0', author='Institute for Quantum Computing, Baidu INC.', author_email='qml@baidu.com', description='Paddle Quantum is a quantum machine learning (QML) toolkit developed based on Baidu PaddlePaddle.', @@ -31,32 +32,63 @@ long_description_content_type="text/markdown", url='http://qml.baidu.com', packages=[ - 'paddle_quantum', 'paddle_quantum.optimizer', 'paddle_quantum.mbqc', - 'paddle_quantum.qchem', 'paddle_quantum.qchem.ansatz', - 'paddle_quantum.GIBBS', 'paddle_quantum.GIBBS.example', - 'paddle_quantum.SSVQE', 'paddle_quantum.SSVQE.example', - 'paddle_quantum.VQE', 'paddle_quantum.VQE.example', - 'paddle_quantum.QAOA', 'paddle_quantum.QAOA.example', - 'paddle_quantum.VQSD', 'paddle_quantum.VQSD.example', - 'paddle_quantum.mbqc.QAOA', 'paddle_quantum.mbqc.QAOA.example', - 'paddle_quantum.mbqc.QKernel', 'paddle_quantum.mbqc.QKernel.example', - 'paddle_quantum.mbqc.VQSVD', 'paddle_quantum.mbqc.VQSVD.example', + 'paddle_quantum', + 'paddle_quantum.ansatz', + 'paddle_quantum.backend', + 'paddle_quantum.channel', + 'paddle_quantum.channel.functional', + 'paddle_quantum.gate', + 'paddle_quantum.gate.functional', + 'paddle_quantum.locc', + 'paddle_quantum.loss', + 'paddle_quantum.operator', + 'paddle_quantum.state', + 'paddle_quantum.qchem', + 'paddle_quantum.mbqc', + 'paddle_quantum.GIBBS', + 'paddle_quantum.GIBBS.example', + 'paddle_quantum.QAOA', + 'paddle_quantum.QAOA.example', + 'paddle_quantum.SSVQE', + 'paddle_quantum.SSVQE.example', + 'paddle_quantum.VQE', + 'paddle_quantum.VQE.example', + 'paddle_quantum.VQSD', + 'paddle_quantum.VQSD.example', + 'paddle_quantum.mbqc.gates', + 'paddle_quantum.mbqc.gates.mcalculus_tests', + 'paddle_quantum.mbqc.gates.simulator_tests', + 'paddle_quantum.mbqc.GRCS', + 'paddle_quantum.mbqc.GRCS.example', + 'paddle_quantum.mbqc.GRCS.example.rectangular', + 'paddle_quantum.mbqc.GRCS.example.rectangular.depth10', + 'paddle_quantum.mbqc.QAOA', + 'paddle_quantum.mbqc.QAOA.example', + 'paddle_quantum.mbqc.QKernel', + 'paddle_quantum.mbqc.QKernel.example', + 'paddle_quantum.mbqc.VQSVD', + 'paddle_quantum.mbqc.VQSVD.example', ], package_data={ 'paddle_quantum.VQE': ['*.xyz'], 'paddle_quantum.VQE.example': ['*.xyz'], + 'paddle_quantum.mbqc.GRCS.example': ['*.txt'], + 'paddle_quantum.mbqc.GRCS.example.rectangular.depth10': ['*.txt'], 'paddle_quantum.mbqc.QKernel.example': ['*.txt'], 'paddle_quantum.mbqc.VQSVD.example': ['*.txt'], }, install_requires=[ 'paddlepaddle>=2.2.0', + 'qcompute', 'scipy', 'networkx>=2.5', 'matplotlib>=3.3.0', - 'interval', 'tqdm', 'openfermion', - 'pyscf; platform_system == "Linux" or platform_system == "Darwin"' + 'pyscf; platform_system == "Linux" or platform_system == "Darwin"', + 'opencv-python', + 'scikit-learn', + 'fastdtw', ], python_requires='>=3.6, <4', classifiers=[ @@ -67,4 +99,6 @@ project_urls={ 'Documentation': 'https://qml.baidu.com/api/introduction.html', 'Source': 'https://github.com/PaddlePaddle/Quantum/', - 'Tracker': 'https://github.com/PaddlePaddle/Quantum/issues'},) + 'Tracker': 'https://github.com/PaddlePaddle/Quantum/issues', + }, +) diff --git a/tutorial/combinatorial_optimization/DC-QAOA_CN.ipynb b/tutorial/combinatorial_optimization/DC-QAOA_CN.ipynb deleted file mode 100644 index 9386cb0..0000000 --- a/tutorial/combinatorial_optimization/DC-QAOA_CN.ipynb +++ /dev/null @@ -1,734 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 大规模量子近似优化分治算法\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 概览\n", - "\n", - "[量子近似优化算法](./QAOA_CN.ipynb)（quantum approximate optimization algorithm, QAOA）是一个将量子与经典结合起来，用于解决组合优化问题的算法。但是，由于现阶段量子比特数量的限制，该算法无法处理大规模问题，且该算法的运行时间随着问题规模的增大，成指数增长。关于量子近似优化算法更详细的讨论见 [1]。\n", - "\n", - "分治法（divide-and-conquer, DC）是可以解决上述瓶颈的一种方法。主要是将一个大问题拆分若干个相似的子问题，将这些子问题解决之后再将子问题合并，从而得到母问题的解。Junde Li 等人在2021年提出量子近似优化的分治算法 [2] 将上述技术应用于解决较大规模的最大割问题。本教程所使用的方法在该论文的基础之上做出了一些改进。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 具体算法" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 大图分割\n", - "\n", - "在图论中，我们用一个图形的边 $E$ 和顶点 $V$ 定义一个图形 $G=(V,E)$。假设它有 $|V| = n$ 个顶点，但是含噪中型量子（noisy intermediate-scale quantum, NISQ）设备上最多可以运行 $k$ 个量子比特（$n > k$）。这种情况下，我们使用``大图分割 LGP``的方法将图形 $G$ 拆分两个子图 $G_0$ 和 $G_1$。为了防止遗漏任意一条边，在拆分的时候至少有一个点被两个子图共同拥有。我们把这些共有的顶点叫做分离顶点（集合），并且约束这个集合的大小小于 $k$。以下的代码定义了如何进行大图分割。" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-16T03:41:44.449329Z", - "start_time": "2021-05-16T03:41:43.034272Z" - } - }, - "outputs": [], - "source": [ - "import networkx as nx # networkx的版本 >= 2.5\n", - "import matplotlib.pyplot as plt\n", - "from itertools import combinations\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\")\n", - "\n", - "# 将一个图形分割成两个有重合的分离顶点子图\n", - "def NaiveLGP(g, k):\n", - " E = list(g.edges)\n", - " E = [(min([u, v]),max([u, v])) for (u, v) in E]\n", - " E.sort(key=lambda tup:tup[0])\n", - " V = list(g.nodes)\n", - " V.sort()\n", - "\n", - " counter = 1\n", - " while counter < k:\n", - " num_nodes = counter\n", - " nodes_combo = list(combinations(V, num_nodes))\n", - " # 找有效的分离顶点\n", - " for p in nodes_combo:\n", - " V1 = [x for x in V if x not in p]\n", - " E1 = [e for e in g.edges if e not in g.edges(p)]\n", - " G1 = nx.Graph()\n", - " G1.add_nodes_from(V1)\n", - " G1.add_edges_from(E1)\n", - " S = [G1.subgraph(c).copy() for c in nx.connected_components(G1)]\n", - " if len(S) == 2:\n", - " # 将分离顶点加入不相连的子图中\n", - " V_S0 = list(S[0].nodes)\n", - " E_S0 = list(S[0].edges) \n", - " V_S1 = list(S[1].nodes)\n", - " E_S1 = list(S[1].edges)\n", - " for (u, v) in g.edges(p):\n", - " if u in V_S0 or v in V_S0:\n", - " S[0].add_edges_from([(u, v)])\n", - " if u in V_S1 or v in V_S1:\n", - " S[1].add_edges_from([(u, v)])\n", - " if u in p and v in p:\n", - " S[0].add_edges_from([(u, v)])\n", - " S[1].add_edges_from([(u, v)])\n", - "\n", - " return S\n", - "\n", - " counter += 1\n", - " print(\"G的连接度大于k\")\n", - "\n", - " return {}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "我们给了以下的例子去说明``大图分割``是如何进行的。假设一个随机图形有10个顶点，但是 NISQ 设备最多支持9个量子比特，即 $k=9$。那么根据``大图分割``，红色的顶点0和2将被选为分离顶点。首先将这些分离顶点去掉，剩下的图将是一个不连接图形并可以被分成两个子图，比如下图中的顶点3-9和顶点1。随后，我们再将这些分离顶点和相关边分别加回两个子图中，从而保证所有的边都不会被遗漏。" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-16T03:41:44.839484Z", - "start_time": "2021-05-16T03:41:44.455664Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# 生成一个有 10 个顶点的图形\n", - "n = 10\n", - "G = nx.Graph()\n", - "G.add_nodes_from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n", - "G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (1, 7),\n", - " (5, 6), (6, 7), (7, 8), (8, 9), (9, 0)])\n", - " \n", - "k = 9 # 设定量子比特的最大数量\n", - "S = NaiveLGP(G,k) # 利用大图分割对图形 G 进行分割\n", - "sep_node = list(set(S[0].nodes).intersection(set(S[1].nodes))) # 找到分离顶点\n", - "\n", - "# 图形示例\n", - "options = {\n", - " \"with_labels\": True,\n", - " \"font_color\": \"white\"\n", - "}\n", - "node_color1 = [\"red\" if i in sep_node else \"blue\" for i in range(n)]\n", - "node_color2 = [\"red\" if list(S[0].nodes)[i] in sep_node else \"blue\" for i in range(len(S[0].nodes))]\n", - "node_color3 = [\"red\" if list(S[1].nodes)[i] in sep_node else \"blue\" for i in range(len(S[1].nodes))]\n", - "\n", - "fig, ax = plt.subplots(1, 3, figsize=(15, 4))\n", - "for i, a in enumerate(ax):\n", - " a.axis('off')\n", - " a.margins(0.20)\n", - "nx.draw_networkx(G, pos=nx.circular_layout(G), ax=ax[0], **options, node_color=node_color1)\n", - "nx.draw_networkx(S[0], pos=nx.circular_layout(S[0]), ax=ax[1], **options, node_color=node_color2)\n", - "nx.draw_networkx(S[1], pos=nx.circular_layout(S[1]), ax=ax[2], **options, node_color=node_color3)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "值得提醒的一点是，我们的例子中 $k=9$，``大图分割``得到的两个子图的顶点数都小于或等于 $k$，那么两个子图的最大割问题可以直接被``量子近似优化算法``解决。但如果得到的子图的顶点数依然大于 $k$，那我们将对子图重复之前的做法，直至所有的子图顶点都小于或等于 $k$。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 图形重构\n", - "\n", - "当``量子近似优化（分治）算法``被应用到分离的子图上之后，所有的顶点会被分成两个部分，即 $S_0$ 和 $S_1$。我们需要将子图的最大割进行整合，得到母图的最大割。因为两个子图有共同的顶点，即分离顶点，我们要确保它们所在的最大割集合吻合，即 $S_0$ 还是 $S_1$ 需要吻合。比如，如果对于一个子图来说，分离顶点在它的最大割当中所在的分割集合都是 $S_0$，而另一个子图的最大割中，分离顶点们在的分割集合是 $S_1$，那么相应的两个最大割将不能被整合。所以为了解决这一问题，对于每个子图，我们将提供多个可能的最大割，从而在这些可能的最大割当中寻找可以整合的且可能性最高的进行整合，从而得到母图的最大割。" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-16T03:41:46.108438Z", - "start_time": "2021-05-16T03:41:45.970323Z" - } - }, - "outputs": [], - "source": [ - "def GR(str_cnt1, str_cnt2):\n", - " com_cnt = []\n", - " n = len(str_cnt1[0][0])\n", - " com_index = []\n", - " for i in range(n):\n", - " if str_cnt1[0][0][i] != \"x\" and str_cnt2[0][0][i] != \"x\":\n", - " com_index.append(i)\n", - "\n", - " for (str1, cnt1) in str_cnt1:\n", - " for (str2, cnt2) in str_cnt2: \n", - " # 检查分离顶点在两个子图所在的集合是否一致\n", - " validity = [str1[i] == str2[i] for i in com_index]\n", - " if False not in validity:\n", - " com_str = [[0]] * n\n", - " for i in range(n):\n", - " if str1[i] != \"x\":\n", - " com_str[i] = str(str1[i])\n", - " else:\n", - " com_str[i] = str(str2[i])\n", - " com_cnt.append((\"\".join(com_str), min(cnt1, cnt2)))\n", - "\n", - " # 将{最大割：频率}按频率从大到小排列\n", - " com_cnt.sort(key=lambda tup:tup[1])\n", - " return com_cnt[::-1]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "我们将延续上述10个顶点的圆的例子对``图形重构（graph reconstruction, GR）``进行说明。对于所分得的两个子图，我们先用``量子近似优化算法``求解最大割，再用``图形重构``将子图的最大割整合，得到原图的最大割。下面所给的代码实现了这一步骤。代码中的参数 $t$，代表想要保留最有可能的最大割的数量。如果 $t$ 大于 $2^n$，那么所有可能的最大割，即所有可能的顶点分类，都将被保留用于整合。" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-16T03:42:41.303385Z", - "start_time": "2021-05-16T03:41:47.071053Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "第一个子图的最大割：\n", - "{'01010101xx': 0.07887396513978905, '10010101xx': 0.07887396513978903, '01101010xx': 0.078873965139789, '10101010xx': 0.078873965139789, '10101101xx': 0.040906327139884305, '01010010xx': 0.0409063271398843, '01010110xx': 0.04004434869249364, '10100101xx': 0.04004434869249363, '01011010xx': 0.040044348692493625, '10101001xx': 0.040044348692493625}\n", - "第二个子图的最大割：\n", - "{'0xxxxxx101': 0.4556003303152275, '1xxxxxx010': 0.45560033031522745, '1xxxxxx100': 0.0254542520553071, '0xxxxxx011': 0.025454252055307092, '0xxxxxx110': 0.010740876742244158, '1xxxxxx001': 0.010740876742244157, '1xxxxxx000': 0.0022930869455346486, '0xxxxxx111': 0.002293086945534646, '0xxxxxx100': 0.002293086945534642, '1xxxxxx011': 0.002293086945534638}\n", - "母图的最大割：\n", - "{'0101010101': 0.07887396513978905, '1010101010': 0.078873965139789, '1010100100': 0.0254542520553071, '1010010100': 0.0254542520553071, '1010110100': 0.0254542520553071, '1001010100': 0.0254542520553071, '0101101011': 0.025454252055307092, '0101011011': 0.025454252055307092, '0101001011': 0.025454252055307092, '0110101011': 0.025454252055307092}\n" - ] - } - ], - "source": [ - "# 我们利用 量子近似优化算法 计算上面例子两个子图的最大割\n", - "# 在下一小章中，我们将使用 量子近似优化分治算法 计算子图的最大割，因为子图顶点数量有可能超过量子比特的限制。\n", - "import paddle\n", - "from paddle_quantum.QAOA.maxcut import find_cut\n", - "\n", - "# 设定 量子近似优化算法 中的参数\n", - "p = 3 # 量子电路的层数\n", - "ITR = 100 # 训练迭代的次数\n", - "LR = 0.5 # 基于梯度下降的优化方法的学习率\n", - "# 设定 图形重构 中的参数\n", - "t = 10 # 想要保留最有可能的最大割的数量\n", - "paddle.seed(999) # 固定随机种子\n", - "\n", - "# 图形重构完整过程\n", - "S_str_cnt = []\n", - "for si in S:\n", - " siv = list(si.nodes)\n", - " \n", - " # 计算子图的最大割\n", - " tmp, si_str_cnt_relabeled = find_cut(si, p, ITR, LR)\n", - " \n", - " # 填充子图的最大割结果，使它们和原图的顶点数量和顺序吻合\n", - " si_str_cnt = []\n", - " for str_relabeled in si_str_cnt_relabeled:\n", - " strr = \"\"\n", - " for i in range(len(G.nodes)):\n", - " if i in siv:\n", - " strr += str_relabeled[siv.index(i)]\n", - " else:\n", - " strr += \"x\"\n", - " si_str_cnt.append((strr, si_str_cnt_relabeled[str_relabeled]))\n", - " si_str_cnt.sort(key=lambda tup:tup[1])\n", - " S_str_cnt.append(si_str_cnt[::-1][:t])\n", - "\n", - "# 当子图的最大割被找到之后，我们开始图形重构这一步\n", - "print(\"第一个子图的最大割：\\n\" + str(dict(S_str_cnt[0])))\n", - "print(\"第二个子图的最大割：\\n\" + str(dict(S_str_cnt[1])))\n", - "out_cnt = GR(S_str_cnt[0], S_str_cnt[1])\n", - "print(\"母图的最大割：\\n\" + str(dict(out_cnt[:t])))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "就以上例子来说，对于第一个子图而言，最有可能的几个最大割将包括 {'01010101xx', '10010101xx', '01101010xx', '10101010xx'}，而第二个子图最有可能的最大割将包括 {'0xxxxxx101,'1xxxxxx010'}。这些字符串中的 'x' 代表不在这个子图却在母图的顶点。\n", - "\n", - "从这个例子中我们看到，分离顶点 0 和 7 在第一个子图中可能的最大割，'01010101xx' 中分别属于 $S_0$ 和 $S_1$，它们在第二个子图的最大割，'0xxxxxx101'，中也分别属于 $S_0$ 和 $S_1$，所以我们可以整合这两个最大割并得到母图的最大割，'0101010101'，如下图第三张图所示。\n", - "\n", - "以下为图形展示，前两个图为两个子图的最大割实例，最右的图为母图的最大割。红色点和蓝色点分别表示被分在在 $S_0$ 和 $S_1$ 中的顶点，虚线表示被切割的边。" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-16T03:42:41.647686Z", - "start_time": "2021-05-16T03:42:41.309407Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# 计算出的两个子图的最大割\n", - "strr1 = '01010101xx'\n", - "strr2 = '0xxxxxx101' \n", - "strr = '0101010101'\n", - "\n", - "# 图形示例展示\n", - "options0 = {\n", - " \"node_color\": [\"red\" if strr1[i] == '0' else \"blue\" for i in S[0].nodes],\n", - " \"style\": [\"solid\" if strr1[u] == strr1[v] else \"dashed\" for (u, v) in list(S[0].edges)]\n", - "}\n", - "options1 = {\n", - " \"node_color\": [\"red\" if strr2[i] == '0' else \"blue\" for i in S[1].nodes],\n", - " \"style\": [\"solid\" if strr2[u] == strr2[v] else \"dashed\" for (u, v) in list(S[1].edges)]\n", - "}\n", - "options2 = {\n", - " \"node_color\": [\"red\" if strr[i] == '0' else \"blue\" for i in range(n)],\n", - " \"style\": [\"solid\" if strr[u] == strr[v] else \"dashed\" for (u, v) in list(G.edges)]\n", - "}\n", - "\n", - "fig, ax = plt.subplots(1, 3, figsize=(15,4))\n", - "for i, a in enumerate(ax):\n", - " a.axis('off')\n", - " a.margins(0.20)\n", - "nx.draw_networkx(S[0], pos=nx.circular_layout(S[0]), ax=ax[0], **options, **options0)\n", - "nx.draw_networkx(S[1], pos=nx.circular_layout(S[1]), ax=ax[1], **options, **options1)\n", - "nx.draw_networkx(G, pos=nx.circular_layout(G), ax=ax[2], **options, **options2)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 量子近似优化分治法\n", - "\n", - "为了找到一个大图 $G$ 的最大割，我们采用``量子近似优化分治法``。这个方法像上面描述的一样，先递归性地利用``大图分割``分割图形，再利用``图形重构``递归性地整合两个子图的最大割。\n", - "\n", - "首先如果输入图形的顶点数大于量子比特数量限制 $k$，它将被``大图分割``分成两个子图。反之，可以直接求解它的最大割（不用拆分）。每一个子图将递归性地被输入进``量子近似优化分治法``，直到它的最大割被返回。最大割被返回说明在某一步，它某些递归的子图的顶点数量小于$k$，直接被``量子近似优化分治法``解得，再一层一层地经历``图形重构``，直到返回这个子图所在层。\n", - "\n", - "下面是利用``图形重构``和``大图分割``完成的``量子近似优化分治法``的代码。``量子近似优化分治法``将返回最有可能的最大割和前 $t$ 个最有可能的最大割。" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-16T03:44:13.784486Z", - "start_time": "2021-05-16T03:42:41.653981Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "最有可能的 t 个图形 G 的最大割: {'1010101100': 419, '0101010011': 382, '0101011011': 368, '1010100100': 351, '0110101011': 303, '0101001011': 251, '1001010100': 247, '1010101010': 229, '0100101011': 227, '1011010100': 218}\n", - "量子近似优化分治算法找到的图形 G 的（最有可能的）最大割: 1010101100\n" - ] - } - ], - "source": [ - "def DC_QAOA(g, p, t, s, k, ITR, LR):\n", - " if len(g.nodes) > k:\n", - " # 利用 大图分割 得到两个子图\n", - " S = NaiveLGP(g, k)\n", - "\n", - " S_str_cnt = []\n", - " for si in S:\n", - " siv = list(si.nodes)\n", - " # 递归性地计算子图的最大割\n", - " _, si_str_cnt_relabeled = DC_QAOA(si, p, t, s, k, ITR, LR)\n", - " # 填充子图的最大割结果，使其和母图的顶点吻合\n", - " si_str_cnt = []\n", - " for str_relabeled in si_str_cnt_relabeled:\n", - " strr = \"\"\n", - " for v in g.nodes:\n", - " if v in siv:\n", - " strr += str_relabeled[siv.index(v)]\n", - " else:\n", - " strr += \"x\" \n", - " si_str_cnt.append((strr, si_str_cnt_relabeled[str_relabeled]))\n", - " si_str_cnt.sort(key = lambda tup:tup[1])\n", - " S_str_cnt.append(si_str_cnt[::-1][:t])\n", - "\n", - " # 利用 图形重构 整合子图最大割\n", - " out_cnt = GR(S_str_cnt[0], S_str_cnt[1])\n", - " else:\n", - " if len(g.nodes) == 1:\n", - " return [(\"0\", 99999), (\"1\", 99999)]\n", - " _, out_cnt = find_cut(g, p, ITR, LR, shots=3000)\n", - " # 将词典格式转成列表格式，易于排序\n", - " out_cnt = [(k, v) for k, v in out_cnt.items()]\n", - " # 将{最大割：频率}按频率从大到小排列\n", - " out_cnt.sort(key=lambda tup:tup[1])\n", - " out_cnt = out_cnt[::-1]\n", - "\n", - " # 只保留最有可能的t个最大割\n", - " out_cnt = out_cnt[:t]\n", - " # 等比例调节频率的显示\n", - " cnt_sum = sum(cnt for (str,cnt) in out_cnt)\n", - " out_cnt = [(k, int(s * v / cnt_sum)) for (k, v) in out_cnt]\n", - "\n", - " return out_cnt[0][0], dict(out_cnt)\n", - "\n", - "# 设定 量子近似优化算法 中的参数\n", - "p = 2 # 量子电路的层数\n", - "ITR = 100 # 训练迭代的次数\n", - "LR = 0.5 # 基于梯度下降的优化方法的学习率\n", - "\n", - "# 设定 量子近似优化分治算法 中的参数\n", - "s = 3000 # 等比例调节频率的比例\n", - "t = 10 # 想要保留最有可能的最大割的数量\n", - "k = 5 # 量子比特的数量限制\n", - "\n", - "# 量子近似优化分治算法使用\n", - "max_cut, out_cnt = DC_QAOA(G, p, t, s, k, ITR, LR)\n", - "print(\"最有可能的 t 个图形 G 的最大割: \" + str(out_cnt))\n", - "print(\"量子近似优化分治算法找到的图形 G 的（最有可能的）最大割: \" + str(max_cut))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 应用范围\n", - "\n", - "**以上表述的``量子近似优化分治法``可以估计一个图形的最大割，当且仅当，它和它递归出来的顶点数量大于 $k$，且子图的伪连接度（pseudo-connectivity）都小于 $k$**。伪连接度的定义为：一个连接图变成不连接的两个子图所需要移除的最小的顶点数量。\n", - "\n", - "当 $k > 1$ 的时候，圆圈就是一个例子。因为只需要移除两个点，圆圈就会被拆成两条不相连的子图，所以所有圆圈的伪连接度都是2。我们拿六个顶点的圆 $C_6$ 并且 $k=4$ 举例。``大图分割``会将它分成 $P_5$（顶点数量为5的子图）和 $P_2$，$P_2$ 的顶点数量在 $k$ 之下，可以直接使用``近似优化算法``计算。而子图 $P_5$ 是一个链状结构，他的伪连接度是 $1 < k$。所以``大图分割``将继续分割 $P_5$，并把它分成了 $P'_4$ 和 $P'_2$。新的子图的顶点数量都小于或等于 $k$，我们都不再需要考虑他们伪连接度。\n", - "\n", - "``量子近似优化分治法``不可解的图包括顶点数量大于 $k$ 的完全图（complete graph）。对于完全图来说，无论怎么移除顶点，剩余的图都是连接图。有些图是否适用决定于 $k$ 的大小，我们以下给了个这样的例子。\n", - "\n", - "最左的图就是实例图，这个图的伪连接度是2。如果 $k=2$，那么分离点的数量只能为1个，如果分离点是4,那么这个图被拆分成三部分而不是两部分（下图中间所示）；如果分离点是其他的几个，这个图仍然连在一起，没有被拆开。此外，该图的伪连接度为2并不小于 $k$，不满足条件，所以``量子近似优化分治法``并不适用于这个例子。但如果 $k=3$，伪连接度是 $2 < k$，这个图可以进行拆分成两个子图，其中一个的顶点数量小于等于 $k$，另一个的伪连接度显而易见是 $1" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "plt.plot(value_dc_qaoa_ls, label=\"DC-QAOA\")\n", - "plt.plot(ubound_sdp_ls, label=\"SDP upper bound\", linestyle=\"--\")\n", - "plt.title('Max-Cut Performancce')\n", - "plt.xlabel('Random Graph')\n", - "plt.ylabel('Calculated Optimal Max Cut')\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "从上面的线形图中，我们可以说明``量子近似优化分治法``找到的最大割和理论上限接近。\n", - "\n", - "## 应用\n", - "\n", - "最大割问题属于应用范围很广的二次无约束二值优化（quadratic unconstrained binary optimization, QUBO）问题。此类问题的应用范围十分广泛，上至为NP-困难问题创建模型，下到找自旋玻璃的基态 [5]。同时最大割问题本身也有很广泛的应用。\n", - "\n", - "最大割问题和很多领域都有紧密的联系，比如超大规模集成电路（VLSI circuit）设计，统计物理。减少超大规模集成电路设计所用的孔和寻找自选玻璃基态都可以归约到最大割问题 [6]。更重要的是，最大割问题给很多算法或者技术提供了一个测试台。比如适用于最大割问题的半正定规划方法被后续用在了数据集合设计 [7] 和相位检索上 [8, 9]。\n", - "\n", - "更多关于最大割的应用可以在 [10-12] 里找到。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "\n", - "## 参考文献\n", - "\n", - "[1] Akshay, V., et al. \"Reachability deficits in quantum approximate optimization.\" [Physical Review Letters 124.9 (2020): 090504.](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.124.090504)\n", - "\n", - "[2] Li, Junde, Mahabubul Alam, and Swaroop Ghosh. \"Large-scale Quantum Approximate Optimization via Divide-and-Conquer.\" [arXiv preprint arXiv:2102.13288 (2021).](https://arxiv.org/abs/2101.03717)\n", - "\n", - "[3] Goemans, Michel X., and David P. Williamson. \"Improved approximation algorithms for maximum cut and satisfiability problems using semidefinite programming.\" [Journal of the ACM (JACM) 42.6 (1995): 1115-1145.](http://www-math.mit.edu/~goemans/PAPERS/maxcut-jacm.pdf)\n", - "\n", - "[4] Burer, Samuel, and Renato DC Monteiro. \"Local minima and convergence in low-rank semidefinite programming.\" [Mathematical Programming 103.3 (2005): 427-444.](https://link.springer.com/article/10.1007/s10107-004-0564-1)\n", - "\n", - "[5] Kochenberger, Gary, et al. \"The unconstrained binary quadratic programming problem: a survey.\" [Journal of Combinatorial Optimization 28.1 (2014): 58-81.](https://link.springer.com/article/10.1007/s10878-014-9734-0)\n", - "\n", - "[6] Barahona, Francisco, et al. \"An application of combinatorial optimization to statistical physics and circuit layout design.\" [Operations Research 36.3 (1988): 493-513.](https://www.jstor.org/stable/170992?seq=1)\n", - "\n", - "[7] Poland, Jan, and Thomas Zeugmann. \"Clustering pairwise distances with missing data: Maximum cuts versus normalized cuts.\" [International Conference on Discovery Science. Springer, Berlin, Heidelberg, 2006.](https://link.springer.com/chapter/10.1007/11893318_21)\n", - "\n", - "[8] Candes, Emmanuel J., et al. \"Phase retrieval via matrix completion.\" [SIAM review 57.2 (2015): 225-251.](https://epubs.siam.org/doi/10.1137/110848074)\n", - "\n", - "[9] Waldspurger, Irene, Alexandre d’Aspremont, and Stéphane Mallat. \"Phase recovery, maxcut and complex semidefinite programming.\" [Mathematical Programming 149.1 (2015): 47-81.](https://link.springer.com/article/10.1007/s10107-013-0738-9)\n", - "\n", - "[10] Deza, Michel, and Monique Laurent. \"Applications of cut polyhedra—I.\" [Journal of Computational and Applied Mathematics 55.2 (1994): 191-216.](https://www.sciencedirect.com/science/article/pii/0377042794900205)\n", - "\n", - "[11] Deza, Michel, and Monique Laurent. \"Applications of cut polyhedra—II.\" [Journal of Computational and Applied Mathematics 55.2 (1994): 217-247.](https://www.sciencedirect.com/science/article/pii/0377042794900213)\n", - "\n", - "[12] Poljak, Svatopluk, and Zsolt Tuza. \"Maximum cuts and largest bipartite subgraphs.\" [DIMACS Series 20 (1995): 181-244.](https://arxiv.org/pdf/1810.12144.pdf)" - ] - } - ], - "metadata": { - "celltoolbar": "Raw Cell Format", - "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.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 -} diff --git a/tutorial/combinatorial_optimization/TSP_CN.ipynb b/tutorial/combinatorial_optimization/TSP_CN.ipynb deleted file mode 100644 index 8fd6289..0000000 --- a/tutorial/combinatorial_optimization/TSP_CN.ipynb +++ /dev/null @@ -1,610 +0,0 @@ -{ - "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", - "旅行商问题（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）的问题。哈密顿回路为一个通过且仅通过每一个顶点一次的回路。 " - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## 使用量子神经网络解旅行商问题\n", - "\n", - "使用量子神经网络方法解决旅行商问题，需要首先将该问题编码为量子形式。\n", - "具体的包括以下两部分：\n", - "\n", - "1. 旅行商经过城市的顺序将编码进量子态 —— ${\\rm qubit}_{i,t} = |1\\rangle$ 对应于在时间 $t$ 经过城市$i$。\n", - " 1. 以两城市$\\{A,B\\}$举例。先经过$A$再经过$B$ 将由$|1001\\rangle$表示，对应于旅行商在时间 $1$ 经过城市$A$，在时间 $2$ 经过城市$B$。\n", - " 2. 类似的 $|0110\\rangle$对应于先经过$B$再经过$A$.\n", - " 3. 注意：$|0101\\rangle$意味着在时间 $2$ 同时经过城市 $A$、$B$，而这是不可能的。为避免此类量子态，我们会通过引入代价函数的方式 (具体见下一节)。\n", - "\n", - "2. 总距离被编码进损失函数： \n", - "\n", - "$$\n", - "L(\\psi(\\vec{\\theta})) = \\langle\\psi(\\vec{\\theta})|H_C|\\psi(\\vec{\\theta})\\rangle \\, ,\n", - "\\tag{1}\n", - "$$\n", - "其中 $|\\psi(\\vec{\\theta})\\rangle$ 对应于参数化量子电路的输出。\n", - "\n", - "在下一节中将详细介绍如何编码旅行商问题为对应量子问题。通过优化损失函数，我们将得到对应最优量子态。再通过解码，将得到最终的路线规划" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "### 编码旅行商问题\n", - "\n", - "为了将旅行商问题转化成一个参数化量子电路（parameterized quantum circuits, PQC）可解的问题，我们首先需要编码旅行商问题的哈密顿量。\n", - "\n", - "我们先将此问题转化为一个整数规划问题：假设图形 $G$ 的顶点数量为 $|V| = n$ 个，那么对于每个顶点 $i \\in V$，我们定义 $n$ 个二进制变量 $x_{i,t}$，$t \\in [0,n-1]$：\n", - "\n", - "$$\n", - "x_{i, t}=\n", - "\\begin{cases}\n", - "1, & \\text{如果在最后的哈密顿回路中，顶点 } i \\text { 的顺序为 $t$，即在时间 $t$ 的时候被旅行商访问}\\\\\n", - "0, & \\text{其他情况}\n", - "\\end{cases}.\n", - "\\tag{2}\n", - "$$\n", - "\n", - "因为 $G$ 有 $n$ 个顶点，所以我们共有 $n^2$ 个变量 $x_{i,t}$，所有这些变量的取值我们用 $x=x_{1,1}x_{1,2}\\dots x_{n,n}$ 来表示。现在我们假设 $x$ 对应了一条哈密顿回路，那么对于图中的每一条边 $(i,j,w_{i,j}) \\in E$，条件 $x_{i,t} = x_{j,t+1} = 1$（也可以等价地写成 $x_{i,t}\\cdot x_{j,t+1} = 1$）成立当且仅当该哈密顿回路中的第 $t$ 个顶点是顶点 $i$ 并且第 $t+1$ 个顶点是顶点 $j$；否则，$x_{i,t}\\cdot x_{j,t+1} = 0$。所以我们可以用下式计算哈密顿回路的长度\n", - "\n", - "$$\n", - "D(x) = \\sum_{i,j} w_{i,j} \\sum_{t} x_{i,t} x_{j,t+1}.\n", - "\\tag{3}\n", - "$$\n", - "\n", - "根据哈密顿回路的定义，$x$ 如果对应一条哈密顿回路需要满足如下的限制：\n", - "\n", - "$$\n", - "\\sum_t x_{i,t} = 1 \\quad \\forall i \\in [0,n-1] \\quad \\text{ 和 } \\quad \\sum_i x_{i,t} = 1 \\quad \\forall t \\in [0,n-1],\n", - "\\tag{4}\n", - "$$\n", - "\n", - "其中第一个式子用来保证找到的 $x$ 所代表的路线中每个顶点仅出现一次，第二个式子保证在每个时间只有一个顶点可以出现。这两个式子共同保证了参数化量子电路找到的 $x$ 是个哈密顿回路。所以，我们可以定义在此限制下的代价函数：\n", - "\n", - "$$\n", - "C(x) = D(x)+ A\\left( \\sum_{i} \\left(1-\\sum_t x_{i,t}\\right)^2 + \\sum_{t} \\left(1-\\sum_i x_{i,t}\\right)^2 \\right).\n", - "\\tag{5}\n", - "$$\n", - "\n", - "其中 $A$ 是惩罚参数，它保证了上述的限制被遵守。因为我们想要在找哈密顿回路的长度 $D(x)$ 的最小值的同时保证 $x$ 确实表示一个哈密顿回路，所以我们需要设置一个大一点的 $A$，最起码大过图 $G$ 中边的最大的权重，从而保证不遵守限制的路线不会成为最终的路线。\n", - "\n", - "我们现在需要将代价函数 $C(x)$ 转化为一个哈密顿量从而完成旅行商问题的编码。每一个二进制变量可以取0和1两个值，分别对应量子态 $|0\\rangle$ 和 $|1\\rangle$。**每个二进制变量都对应一个量子比特，所以我们需要 $n^2$ 个量子比特来解决旅行商问题。** 和最大割问题相似，因为泡利 $Z$ 的两个本征态和我们需要的量子态 $|0\\rangle$、$|1\\rangle$ 一样，这两个本征态所对应的本征值分别是 1 和 -1，所以我们考虑利用泡利 $Z$ 矩阵将代价函数编码为哈密顿量。\n", - "\n", - "我们现在将二进制变量映射到泡利 $Z$ 矩阵上，从而使 $C(x)$ 转化成哈密顿矩阵：\n", - "\n", - "$$\n", - "x_{i,t} \\mapsto \\frac{I-Z_{i,t}}{2}, \\tag{6}\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} |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$ 的基态即为旅行商问题的最优解。在接下来的章节中，我们将展示怎么用参数化量子电路找到这个矩阵的基态，即对应最小本征值的本征态。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Paddle Quantum 实现\n", - "\n", - "要在量桨上实现用参数化量子电路解决旅行商问题，首先要做的便是加载需要用到的包。其中 `networkx` 包可以帮助我们方便地处理图。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 1, - "source": [ - "# 加载量桨、飞桨的相关模块\n", - "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "\n", - "# 旅行商问题相关函数\n", - "from paddle_quantum.QAOA.tsp import tsp_hamiltonian # 构造旅行商问题哈密顿量的函数\n", - "from paddle_quantum.QAOA.tsp import solve_tsp_brute_force # 暴力求解旅行商问题\n", - "\n", - "# 用于生成图\n", - "import networkx as nx\n", - "\n", - "# 加载额外需要用到的包\n", - "from numpy import pi as PI\n", - "import matplotlib.pyplot as plt\n", - "import random\n", - "import time" - ], - "outputs": [], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:00:15.901429Z", - "start_time": "2021-05-17T08:00:12.708945Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "### 生成该旅行商问题中的图 " - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "接下来，我们生成该旅行商问题中的图 $G$。为了运算方便，图中的顶点从0开始计数。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 2, - "source": [ - "# n 代表图形 G 的顶点数量\n", - "n = 4\n", - "E = [(0, 1, 3), (0, 2, 2), (0, 3, 10), (1, 2, 6), (1, 3, 2), (2, 3, 6)] # 线段参数(顶点1， 顶点2， 权重(距离))\n", - "G = nx.Graph()\n", - "G.add_weighted_edges_from(E)\n", - "\n", - "# 将生成的图 G 打印出来\n", - "pos = nx.spring_layout(G)\n", - "options = {\n", - " \"with_labels\": True,\n", - " \"font_weight\": \"bold\",\n", - " \"font_color\": \"white\",\n", - " \"node_size\": 2000,\n", - " \"width\": 2\n", - "}\n", - "nx.draw_networkx(G, pos, **options)\n", - "nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=nx.get_edge_attributes(G,'weight'))\n", - "ax = plt.gca()\n", - "ax.margins(0.20)\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", - "量桨中，哈密顿量可以以 ``list`` 的形式输入。这里我们将式（4）中的二进制变量用式（5）替换，从而构建哈密顿量 $H_C$。具体的形式可以通过内置函数 tsp_hamiltonian(G, A, n)直接得到。\n", - "\n", - "**注意：** 对于旅行商问题，由于我们总可以选定某一个城市为第一个抵达的城市，故实际所需量子比特数可以从 $n^2$ 降到了 $(n-1)^2$。在我们接下来的实现当中都会使用改进过的哈密顿量来计算。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 3, - "source": [ - "# 以 list 的形式构建哈密顿量 H_C -- 通过内置函数tsp_hamiltonian(G, A, n)\n", - "A = 20 # 惩罚参数\n", - "H_C_list = tsp_hamiltonian(G, A, n)" - ], - "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", - "在最大割问题（[Max-Cut 教程](./MAXCUT_CN.ipynb)）中，我们用 QAOA 构建了我们的参数化量子电路，但除了 QAOA 电路，其他的电路也可以用来解决组合优化问题。对于旅行商问题，我们将使用 $U_3(\\vec{\\theta})$ 和 $\\text{CNOT}$ 门构造的参数化量子电路。这可以通过调用量桨内部的 [`complex entangled layer`](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html) 来实现。\n", - "\n", - " \n", - "
图 1: 旅行商问题使用的参数化电路
\n", - "\n", - "上述电路会给出一个输出态 $|\\psi(\\vec{\\theta})\\rangle$，由此输出态，我们可以计算最大割问题的目标函数，也就是旅行商问题的损失函数：\n", - "\n", - "$$\n", - "L(\\psi(\\vec{\\theta})) = \\langle\\psi(\\vec{\\theta})|H_C|\\psi(\\vec{\\theta})\\rangle.\n", - "\\tag{7}\n", - "$$\n", - "\n", - "然后我们利用经典的优化算法寻找最优参数 $\\vec{\\theta}^*$。下面的代码给出了通过量桨和飞桨搭建的完整网络：" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 4, - "source": [ - "# 此处使用内置量子电路：complex_entangled_layer()\n", - "def cir_TSP(N, DEPTH, theta):\n", - " cir = UAnsatz(N)\n", - " cir.complex_entangled_layer(theta, DEPTH)\n", - " return cir" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 5, - "source": [ - "class Opt_TSP(paddle.nn.Layer):\n", - " def __init__(self, G, DEPTH, H_ls, dtype=\"float64\",):\n", - " # 输入：图G, PQC层数DEPTH, 哈密顿量泡利list形式\n", - " super(Opt_TSP, self).__init__()\n", - " self.DEPTH = DEPTH\n", - " self.theta = self.create_parameter(shape=[self.DEPTH, (len(G.nodes) - 1) ** 2, 3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * PI),\n", - " dtype=dtype, is_bias=False)\n", - " self.H_ls = H_ls\n", - " self.num_qubits = (len(G) - 1) ** 2 # 总qubit数取为：(城市数-1)**2\n", - "\n", - " def forward(self):\n", - " # 定义 complex entangled layer\n", - " cir = cir_TSP(self.num_qubits, self.DEPTH, self.theta)\n", - " # 运行该量子电路\n", - " cir.run_state_vector()\n", - " # 计算损失函数\n", - " loss = cir.expecval(self.H_ls)\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": [ - "### 训练量子神经网络\n", - "\n", - "定义好了量子神经网络后，我们使用梯度下降的方法来更新其中的参数，使得式（7）的期望值最小。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 6, - "source": [ - "DEPTH = 2 # 量子电路的层数\n", - "ITR = 120 # 训练迭代的次数\n", - "LR = 0.5 # 基于梯度下降的优化方法的学习率\n", - "SEED = 1000 #设置随机数种子" - ], - "outputs": [], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:00:16.274144Z", - "start_time": "2021-05-17T08:00:16.264684Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "这里，我们在飞桨中优化上面定义的网络。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 7, - "source": [ - "# 固定 paddle 随机种子\n", - "paddle.seed(SEED)\n", - "# 记录运行时间\n", - "time_start = time.time()\n", - "\n", - "myLayer = Opt_TSP(G, DEPTH, H_C_list)\n", - "# 使用 Adam 优化器\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=myLayer.parameters())\n", - "# 梯度下降循环\n", - "for itr in range(1, ITR + 1):\n", - " # 运行上面定义的网络\n", - " loss, cir = myLayer()\n", - " # 计算梯度并优化\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - " # 输出迭代中performance\n", - " if itr % 10 == 0:\n", - " print(\"循环数:\", itr, \"损失:\", \"%.4f\"% loss.numpy(), \"用时:\", time.time()-time_start)\n", - "\n", - "# 显示QNN得到最小路程\n", - "print('得到最小路程:', loss.numpy())" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "循环数: 10 损失: 46.0232 用时: 5.425132751464844\n", - "循环数: 20 损失: 22.6648 用时: 11.279906749725342\n", - "循环数: 30 损失: 16.6194 用时: 19.115557432174683\n", - "循环数: 40 损失: 14.3719 用时: 26.60259699821472\n", - "循环数: 50 损失: 13.5547 用时: 34.130993127822876\n", - "循环数: 60 损失: 13.1736 用时: 41.717233657836914\n", - "循环数: 70 损失: 13.0661 用时: 50.04284143447876\n", - "循环数: 80 损失: 13.0219 用时: 58.36803317070007\n", - "循环数: 90 损失: 13.0035 用时: 66.84098410606384\n", - "循环数: 100 损失: 13.0032 用时: 75.09722661972046\n", - "循环数: 110 损失: 13.0008 用时: 84.32974600791931\n", - "循环数: 120 损失: 13.0004 用时: 94.5128538608551\n", - "得到最小路程: [13.00038342]\n" - ] - } - ], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:02:14.495970Z", - "start_time": "2021-05-17T08:00:16.496407Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "最理想的情况是我们使用的量子神经网络可以找到最短哈密顿回路，同时最后的损失值应该等于这条回路上的权重之和，即旅行商所需要走的最短长度。但如果最后的情况不是这样，读者可以通过调整参数化量子电路的参数值，即 DEPTH，ITR 和 LR，来获得更好的训练效果。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "### 解码量子答案\n", - "\n", - "当求得损失函数的最小值以及相对应的一组参数 $\\vec{\\theta}^*$后，我们的任务还没有完成。为了进一步求得旅行商问题的近似解，需要从电路输出的量子态 $|\\psi(\\vec{\\theta})^*\\rangle$ 中解码出经典优化问题的答案。物理上，解码量子态需要对量子态进行测量，然后统计测量结果的概率分布（我们的测量结果是表示旅行商问题答案的比特串）：\n", - "\n", - "$$\n", - "p(z) = |\\langle z|\\psi(\\vec{\\theta})^*\\rangle|^2.\n", - "\\tag{8}\n", - "$$\n", - "\n", - "通常情况下，某个比特串出现的概率越大，意味着其对应旅行商问题最优解的可能性越大。\n", - "\n", - "量桨提供了查看参数化量子电路输出状态的测量结果概率分布的函数：" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 8, - "source": [ - "# 模拟重复测量电路输出态 1024 次\n", - "prob_measure = cir.measure(shots=1024)\n", - "reduced_salesman_walk = max(prob_measure, key=prob_measure.get)\n", - "print(\"利用改进后的哈密顿量找到的解的比特串形式：\", reduced_salesman_walk)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "利用改进后的哈密顿量找到的解的比特串形式： 010001100\n" - ] - } - ], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:02:14.554317Z", - "start_time": "2021-05-17T08:02:14.500593Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "因为我们之前为了减少所需要的量子比特数改进了一下旅行商问题对应的哈密顿量，上面显示的比特串缺少了顶点 $n-1$ 的信息，以及所有顶点在时间 $t =n-1$ 的时候的信息。所以我们需要将这些信息加回找到的比特串中。\n", - "\n", - "首先为了加上对于 $i \\in [0，n-2]$， $x_{i,n-1} = 0$ 这一信息，我们需要在每 $(n-1)$ 个比特之后加上一个 $0$。接着在比特串的最后，我们为了加上顶点 $n-1$在每个时间的状态，我们加上包含 $n-1$ 个 '0' 的 '00...01'，用来表示对于$t \\in [0,n-2]$来说，$x_{n-1,t} = 0$，同时 $x_{n-1,n-1} = 0$。\n", - "\n", - "以下代码通过测量，找到了出现几率最高的比特串，每一个比特都包含了式（1）定义的 $x_{i,t}$ 的信息。我们将找到的比特串映射回经典解，即转化成了 ``dictionary`` 的形式。其中 ``key`` 代表顶点编号，``value`` 代表顶点在哈密顿回路中的顺序，即访问城市的顺序。在以下代码中，我们还将量子电路找到的最优解和暴力算法找到的相比较，从而说明量子算法的正确性。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 9, - "source": [ - "# 参数化量子电路找到的最优解\n", - "str_by_vertex = [reduced_salesman_walk[i:i + n - 1] for i in range(0, len(reduced_salesman_walk) + 1, n - 1)]\n", - "salesman_walk = '0'.join(str_by_vertex) + '0' * (n - 1) + '1'\n", - "solution = {i:t for i in range(n) for t in range(n) if salesman_walk[i * n + t] == '1'}\n", - "distance = sum([G[u][v][\"weight\"] if solution[u] == (solution[v] + 1) % n \n", - " or solution[v] == (solution[u] + 1) % n else 0\n", - " for (u, v) in G.edges])\n", - "print(\"参数化量子电路找到的最优解：\", solution, \"，最短距离为：\", distance)\n", - "\n", - "# 经典暴力算法找到的最优解\n", - "salesman_walk_brute_force, distance_brute_force = solve_tsp_brute_force(G)\n", - "solution_brute_force = {i:salesman_walk_brute_force.index(i) for i in range(n)}\n", - "print(\"经典暴力算法找到的最优解：\", solution_brute_force, \"，最短距离为：\", distance_brute_force)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "参数化量子电路找到的最优解： {0: 1, 1: 2, 2: 0, 3: 3} ，最短距离为： 13\n", - "经典暴力算法找到的最优解： {0: 0, 1: 1, 2: 3, 3: 2} ，最短距离为： 13\n" - ] - } - ], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:02:14.571954Z", - "start_time": "2021-05-17T08:02:14.559634Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "以下的代码将字典形式的经典解用图的形式展示了出来：\n", - "* 顶点中的第一个数字代表城市编号\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_color = [\"red\" if solution[u] == (solution[v] + 1) % n\n", - " or solution[v] == (solution[u] + 1) % n else \"black\"\n", - " for (u, v) in G.edges]\n", - "label_dict_bf = {i: str(i) + \", \" + str(t) for i, t in solution_brute_force.items()}\n", - "edge_color_bf = [\"red\" if solution_brute_force[u] == (solution_brute_force[v] + 1) % n\n", - " or solution_brute_force[v] == (solution_brute_force[u] + 1) % n else \"black\"\n", - " for (u, v) in G.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(G, pos=pos, labels=label_dict, edge_color=edge_color, ax=ax[0], **options)\n", - "nx.drawing.nx_pylab.draw_networkx_edge_labels(G, pos=pos, ax=ax[0], edge_labels=nx.get_edge_attributes(G, 'weight'))\n", - "nx.draw(G, pos=pos, labels=label_dict_bf, edge_color=edge_color_bf, ax=ax[1], **options)\n", - "nx.drawing.nx_pylab.draw_networkx_edge_labels(G, pos=pos, ax=ax[1], edge_labels=nx.get_edge_attributes(G, '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.864346Z", - "start_time": "2021-05-17T08:02:14.576418Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "上面给出的左图展示了参数化量子电路找到的旅行商问题的最优解，右图展示了经典暴力算法找到的最优解。我们不难看出，即使旅行商访问每个城市的绝对顺序不一样，但路线是一致的，即相对顺序一样。这说明在这个例子中，参数化量子电路找到了旅行商问题的最优解。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## 实际应用\n", - "\n", - "旅行商问题可以直接应用在很多交通和物流规划中，例如规划校车接送学生的路线。管理科学领域的先锋 Merrill Flood 在上世纪40年代就受到校车问题的启发，展开了对于旅行商问题的早期研究。更多近期的应用包括了路线规划 [1] 和电线公司对于电力传输的规划 [2]。\n", - "\n", - "除了交通运输问题，旅行商问题同样在管理问题中有很广泛的应用，比如计划机器在电路板上钻孔的顺序 [3]、重构 DNA 上的不明片段 [4] 以及规划最佳建筑路线 [5]。 一些咨询公司，比如 [Nexus](https://nexustech.com.ph/company/newsletter/article/Finding-the-shortest-path-Optimizing-food-trips) 也通过旅行商问题给外界提供管理咨询服务。\n", - "\n", - "同时作为最著名的组合优化问题之一，旅行商问题为很多用于解决组合问题的通用算法提供了测试平台。它经常被作为研究者测试他们提出的新的算法的首选例子。\n", - "\n", - "对于旅行商问题更多的应用和解法，详见 [6]。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "_______\n", - "\n", - "## 参考文献\n", - "\n", - "[1] Bräysy, Olli, et al. \"An optimization approach for communal home meal delivery service: A case study.\" [Journal of Computational and Applied Mathematics 232.1 (2009): 46-53.](https://www.sciencedirect.com/science/article/pii/S0377042708005438)\n", - "\n", - "[2] Sloane, Thomas H., Frank Mann, and H. Kaveh. \"Powering the last mile: an alternative to powering FITL.\" [Proceedings of Power and Energy Systems in Converging Markets. IEEE, 1997.](https://ieeexplore.ieee.org/document/646046)\n", - "\n", - "[3] Onwubolu, Godfrey C. \"Optimizing CNC drilling machine operations: traveling salesman problem-differential evolution approach.\" [New optimization techniques in engineering. Springer, Berlin, Heidelberg, 2004. 537-565.](https://link.springer.com/chapter/10.1007/978-3-540-39930-8_22)\n", - "\n", - "[4] Caserta, Marco, and Stefan Voß. \"A hybrid algorithm for the DNA sequencing problem.\" [Discrete Applied Mathematics 163 (2014): 87-99.](https://www.sciencedirect.com/science/article/pii/S0166218X12003253)\n", - "\n", - "[5] Klanšek, Uroš. \"Using the TSP solution for optimal route scheduling in construction management.\" [Organization, technology & management in construction: an international journal 3.1 (2011): 243-249.](https://www.semanticscholar.org/paper/Using-the-TSP-Solution-for-Optimal-Route-Scheduling-Klansek/3d809f185c03a8e776ac07473c76e9d77654c389)\n", - "\n", - "[6] Matai, Rajesh, Surya Prakash Singh, and Murari Lal Mittal. \"Traveling salesman problem: an overview of applications, formulations, and solution approaches.\" [Traveling salesman problem, theory and applications 1 (2010).](https://www.sciencedirect.com/topics/computer-science/traveling-salesman-problem)" - ], - "metadata": {} - } - ], - "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.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/TSP_EN.ipynb b/tutorial/combinatorial_optimization/TSP_EN.ipynb deleted file mode 100644 index 5f61ae5..0000000 --- a/tutorial/combinatorial_optimization/TSP_EN.ipynb +++ /dev/null @@ -1,614 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# Travelling Salesman Problem\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Overview\n", - "\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}$. " - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Use QNN to solve TSP\n", - "\n", - "To use QNN to solve travelling salesman problem, we need to first encode the classical problem to quantum. \n", - "The encoding consists of two parts:\n", - "\n", - "1. The route how the salesman visits each city is encoded in quantum states -- ${\\rm qubit}_{i,t} = |1\\rangle$ corresponds to salesman visiting city $i$ at time $t$. \n", - " 1. As an example, if there are two cities $\\{A,B\\}$, visiting $A$ then $B$ will be in state $|1001\\rangle$, as the salesman visits the city $A$ at time $1$ and the city $B$ at time $2$.\n", - " 2. Similary, $|0110\\rangle$ means visiting $B$ then $A$.\n", - " 3. Note: $|0101\\rangle$ means visiting $A$ and $B$ both at time $2$, so it is infeasible. To aviod such states, a penalty function will be used (see the next section for details.)\n", - "\n", - "2. The total distance is encoded in a loss function: \n", - "\n", - "$$\n", - "L(\\psi(\\vec{\\theta})) = \\langle\\psi(\\vec{\\theta})|H_C|\\psi(\\vec{\\theta})\\rangle,\n", - "\\tag{1}\n", - "$$\n", - "\n", - "where $|\\psi(\\vec{\\theta})\\rangle$ is the output state from a parameterized quantum circuit. \n", - "\n", - "The details about how to encode the classical problem to quantum is given in detail in the next section. \n", - "After optimizing the loss function, we will obtain the optimal quantum state. Then a decoding process will be performed to get the final route." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "### Encoding the TSP\n", - "\n", - "To transform the TSP into a problem applicable for parameterized quantum circuits, we need to encode the TSP into a Hamiltonian. \n", - "\n", - "We realize the encoding by first constructing an integer programming problem. Suppose there are $n=|V|$ vertices in graph $G$. Then for each vertex $i \\in V$, we define $n$ binary variables $x_{i,t}$, where $t \\in [0,n-1]$, such that\n", - "\n", - "$$\n", - "x_{i, t}=\n", - "\\begin{cases}\n", - "1, & \\text {if in the resulting Hamiltonian cycle, vertex } i \\text { is visited at time } t\\\\\n", - "0, & \\text{otherwise}\n", - "\\end{cases}.\n", - "\\tag{2}\n", - "$$\n", - "\n", - "As there are $n$ vertices, we have $n^2$ variables in total, whose value we denote by a bit string $x=x_{1,1}x_{1,2}\\dots x_{n,n}$. Assume for now that the bit string $x$ represents a Hamiltonian cycle. Then for each edge $(i,j,w_{i,j}) \\in E$, we will have $x_{i,t} = x_{j,t+1}=1$, i.e., $x_{i,t}\\cdot x_{j,t+1}=1$, if and only if the Hamiltonian cycle visits vertex $i$ at time $t$ and vertex $j$ at time $t+1$; otherwise, $x_{i,t}\\cdot x_{j,t+1}$ will be $0$. Therefore the length of a Hamiltonian cycle is\n", - "\n", - "$$\n", - "D(x) = \\sum_{i,j} w_{i,j} \\sum_{t} x_{i,t} x_{j,t+1}.\n", - "\\tag{3}\n", - "$$\n", - "\n", - "For $x$ to represent a valid Hamiltonian cycle, the following constraint needs to be met:\n", - "\n", - "$$\n", - "\\sum_t x_{i,t} = 1 \\quad \\forall i \\in [0,n-1] \\quad \\text{ and } \\quad \\sum_i x_{i,t} = 1 \\quad \\forall t \\in [0,n-1],\n", - "\\tag{4}\n", - "$$\n", - "\n", - "where the first equation guarantees that each vertex is only visited once and the second guarantees that only one vertex is visited at each time $t$. Then the cost function under the constraint can be formulated below, with $A$ being the penalty parameter set to ensure that the constraint is satisfied:\n", - "\n", - "$$\n", - "C(x) = D(x)+ A\\left( \\sum_{i} \\left(1-\\sum_t x_{i,t}\\right)^2 + \\sum_{t} \\left(1-\\sum_i x_{i,t}\\right)^2 \\right).\n", - "\\tag{5}\n", - "$$\n", - "\n", - "Note that as we would like to minimize the length $D(x)$ while ensuring $x$ represents a valid Hamiltonian 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 TSP. Each variable $x_{i,j}$ 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 TSP.** Similar as in the Max-Cut problem, we consider the Pauli $Z$ operator as it has two eigenstates, $|0\\rangle$ and $|1\\rangle$. Their corresponding eigenvalues are 1 and -1, respectively.\n", - "\n", - "Now we would like to consider the mapping\n", - "\n", - "$$\n", - "x_{i,t} \\mapsto \\frac{I-Z_{i,t}}{2}, \\tag{6}\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}|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" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Paddle Quantum Implementation\n", - "\n", - "To investigate the TSP 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 related modules from Paddle Quantum and PaddlePaddle\n", - "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "\n", - "# Functions for Salesman Problem\n", - "from paddle_quantum.QAOA.tsp import tsp_hamiltonian # Get the Hamiltonian for salesman problem\n", - "from paddle_quantum.QAOA.tsp import solve_tsp_brute_force # Solve the salesman problem by brute force\n", - "\n", - "# Create Graph\n", - "import networkx as nx\n", - "\n", - "# Import additional packages needed\n", - "from numpy import pi as PI\n", - "import matplotlib.pyplot as plt\n", - "import random\n", - "import time" - ], - "outputs": [], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:24:17.197426Z", - "start_time": "2021-05-17T08:24:12.896488Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "### Generate a weighted complete graph" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "Next, we generate a weighted complete graph $G$ with four vertices. For the convenience of computation, the vertices here are labeled starting from $0$." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 2, - "source": [ - "# n is the number of vertices in the graph G\n", - "n = 4\n", - "E = [(0, 1, 3), (0, 2, 2), (0, 3, 10), (1, 2, 6), (1, 3, 2), (2, 3, 6)] # Parameters for edges: (vertex1, vertex2, weight(distance))\n", - "G = nx.Graph()\n", - "G.add_weighted_edges_from(E)\n", - "\n", - "# Print out the generated graph G\n", - "pos = nx.spring_layout(G)\n", - "options = {\n", - " \"with_labels\": True,\n", - " \"font_weight\": \"bold\",\n", - " \"font_color\": \"white\",\n", - " \"node_size\": 2000,\n", - " \"width\": 2\n", - "}\n", - "nx.draw_networkx(G, pos, **options)\n", - "nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=nx.get_edge_attributes(G,'weight'))\n", - "ax = plt.gca()\n", - "ax.margins(0.20)\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:24:24.302458Z", - "start_time": "2021-05-17T08:24:24.060967Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "### Encoding Hamiltonian\n", - "\n", - "In Paddle Quantum, a Hamiltonian can be input in the form of ``list``. Here we construct the Hamiltonian $H_C$ of Eq. (4) with the replacement in Eq. (5). It can be realized with a build-in function \"tsp_hamiltonian(G, A, n)\".\n", - "\n", - "**Note:** For the salesman problem, the number of qubits can be reduced to $(n-1)^2$ since we can always select city $0$ to be the first city." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 3, - "source": [ - "# Construct the Hamiltonian H_C in the form of list -- with build-in function tsp_hamiltonian(G, A, n)\n", - "A = 20 # Penalty parameter\n", - "H_C_list = tsp_hamiltonian(G, A, n)" - ], - "outputs": [], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:24:25.956145Z", - "start_time": "2021-05-17T08:24:25.950463Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "### Calculating the loss function \n", - "\n", - "In the [Max-Cut tutorial](./MAXCUT_EN.ipynb), we use a circuit given by QAOA to find the ground state, but we can also use other circuits to solve combinatorial optimization problems. For the TSP, we adopt a parametrized quantum circuit constructed by $U_3(\\vec{\\theta})$ and $\\text{CNOT}$ gates, which we call the [`complex entangled layer`](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html).\n", - "\n", - " \n", - "
Figure 1: Parametrized Quantum Circuit used for TSM Problem
\n", - "\n", - "After running the quantum circuit, we obtain the output state $|\\psi(\\vec{\\theta})\\rangle$. From the output state of the circuit we can calculate the objective function, and also the loss function of the TSP:\n", - "\n", - "$$\n", - "L(\\psi(\\vec{\\theta})) = \\langle\\psi(\\vec{\\theta})|H_C|\\psi(\\vec{\\theta})\\rangle.\n", - "\\tag{7}\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": [ - "# In this tutorial we use build-in PQC: complex_entangled_layer()\n", - "def cir_TSP(N, DEPTH, theta):\n", - " cir = UAnsatz(N)\n", - " cir.complex_entangled_layer(theta, DEPTH)\n", - " return cir" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 5, - "source": [ - "class Opt_TSP(paddle.nn.Layer):\n", - " def __init__(self, G, DEPTH, H_ls, dtype=\"float64\",):\n", - " # Input: Graph, G; PQC Layer number, DEPTH; Hamiltonian in Pauli list form, H_ls\n", - " super(Opt_TSP, self).__init__()\n", - " self.DEPTH = DEPTH\n", - " self.theta = self.create_parameter(shape=[self.DEPTH, (len(G.nodes) - 1) ** 2, 3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * PI),\n", - " dtype=dtype, is_bias=False)\n", - " self.H_ls = H_ls\n", - " self.num_qubits = (len(G) - 1) ** 2 # Total qubits number: (city number-1)**2\n", - "\n", - " def forward(self):\n", - " # Define a circuit with complex entangled layers\n", - " cir = cir_TSP(self.num_qubits, self.DEPTH, self.theta)\n", - " # Run the quantum circuit\n", - " cir.run_state_vector()\n", - " # Calculate the loss function\n", - " loss = cir.expecval(self.H_ls)\n", - "\n", - " return loss, cir" - ], - "outputs": [], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:24:26.790290Z", - "start_time": "2021-05-17T08:24:26.768068Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "### Training the quantum neural network\n", - "\n", - "After defining the quantum neural network, we use gradient descent method to update the parameters to minimize the expectation value in Eq. (7). " - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 6, - "source": [ - "DEPTH = 2 # Number of layers in the quantum circuit\n", - "ITR = 120 # Number of training iterations\n", - "LR = 0.5 # Learning rate of the optimization method based on gradient descent\n", - "SEED = 1000 # Set a global RNG seed " - ], - "outputs": [], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:24:27.958085Z", - "start_time": "2021-05-17T08:24:27.952965Z" - } - } - }, - { - "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", - "# Record run time\n", - "time_start = time.time()\n", - "\n", - "myLayer = Opt_TSP(G, DEPTH, H_C_list)\n", - "# Use Adam optimizer\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=myLayer.parameters())\n", - "# Gradient descent iteration\n", - "for itr in range(1, ITR + 1):\n", - " # Run the network defined above\n", - " loss, cir = myLayer()\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(), \"run time:\", time.time()-time_start)\n", - " \n", - "# The final minimum distance from QNN\n", - "print('The final minimum distance from QNN:', loss.numpy())" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "iter: 10 loss: 46.0232 run time: 7.641107082366943\n", - "iter: 20 loss: 22.6648 run time: 15.020977258682251\n", - "iter: 30 loss: 16.6194 run time: 22.464542627334595\n", - "iter: 40 loss: 14.3719 run time: 30.163496732711792\n", - "iter: 50 loss: 13.5547 run time: 38.4432737827301\n", - "iter: 60 loss: 13.1736 run time: 46.77324390411377\n", - "iter: 70 loss: 13.0661 run time: 55.22942876815796\n", - "iter: 80 loss: 13.0219 run time: 63.490843057632446\n", - "iter: 90 loss: 13.0035 run time: 72.72753691673279\n", - "iter: 100 loss: 13.0032 run time: 82.62676620483398\n", - "iter: 110 loss: 13.0008 run time: 91.19076180458069\n", - "iter: 120 loss: 13.0004 run time: 99.36567878723145\n", - "The final minimum distance from QNN: [13.00038342]\n" - ] - } - ], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:26:08.098742Z", - "start_time": "2021-05-17T08:24:28.741155Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "Note that ideally the training network will find the shortest Hamiltonian cycle, and the final loss above would correspond to the total weights of the optimal cycle, i.e. the distance of the optimal path for the salesman. If not, then one should adjust parameters of the parameterized quantum circuits above for better training performance." - ], - "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 TSP, it is necessary to decode the solution to the classical optimization problem from the quantum state $|\\psi(\\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, where a measurement result is a bit string that represents an answer for the TSP: \n", - "\n", - "$$\n", - "p(z) = |\\langle z|\\psi(\\vec{\\theta})^*\\rangle|^2.\n", - "\\tag{8}\n", - "$$\n", - "\n", - "Usually, the greater the probability of a certain bit string, the greater the probability that it corresponds to an optimal solution of the TSP.\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", - "reduced_salesman_walk = max(prob_measure, key=prob_measure.get)\n", - "print(\"The reduced bit string form of the walk found:\", reduced_salesman_walk)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "The reduced bit string form of the walk found: 010001100\n" - ] - } - ], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:26:08.152206Z", - "start_time": "2021-05-17T08:26:08.103516Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "As we have slightly modified the TSP Hamiltonian to reduce the number of qubits used, the bit string found above has lost the information for our fixed vertex $n-1$ and the status of other vertices at time $n-1$. So we need to extend the found bit string to include these information.\n", - "\n", - "We need to add a $0$ after every $(n-1)$ bits to represent $x_{i,n-1} = 0$ for $i \\in [0, n-2]$. Then at last, we need to add the bit string representation for vertex $n-1$, i.e. '00...01' with $n-1$ 0s to represent $x_{n-1,t} = 0$ for all $t \\in [0,n-2]$. \n", - "\n", - "After measurement, we have found the bit string with the highest probability of occurrence, the optimal walk in the form of the bit string. Each qubit contains the information of $x_{i,t}$ defined in Eq. (1). The following code maps the bit string back to the classic solution in the form of `dictionary`, where the `key` represents the vertex labeling and the `value` represents its order, i.e. when it is visited. \n", - "\n", - "Also, we have compared it with the solution found by the brute-force algorithm, to verify the correctness of the quantum algorithm." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 9, - "source": [ - "# Optimal walk found by parameterized quantum circuit\n", - "str_by_vertex = [reduced_salesman_walk[i:i + n - 1] for i in range(0, len(reduced_salesman_walk) + 1, n - 1)]\n", - "salesman_walk = '0'.join(str_by_vertex) + '0' * (n - 1) + '1'\n", - "solution = {i:t for i in range(n) for t in range(n) if salesman_walk[i * n + t] == '1'}\n", - "distance = sum([G[u][v][\"weight\"] if solution[u] == (solution[v] + 1) % n \n", - " or solution[v] == (solution[u] + 1) % n else 0\n", - " for (u, v) in G.edges])\n", - "print(\"The walk found by parameterized quantum circuit:\", solution, \"with distance\", distance)\n", - "\n", - "# Optimal walk found by brute-force algorithm for comparison\n", - "salesman_walk_brute_force, distance_brute_force = solve_tsp_brute_force(G)\n", - "solution_brute_force = {i:salesman_walk_brute_force.index(i) for i in range(n)}\n", - "print(\"The walk found by the brute-force algorithm:\", solution_brute_force, \"with distance\", distance_brute_force)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "The walk found by parameterized quantum circuit: {0: 1, 1: 2, 2: 0, 3: 3} with distance 13\n", - "The walk found by the brute-force algorithm: {0: 0, 1: 1, 2: 3, 3: 2} with distance 13\n" - ] - } - ], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:26:08.169372Z", - "start_time": "2021-05-17T08:26:08.156656Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "Here, we draw the corresponding optimal walk in the form of graph representation suggested to the salesman:\n", - "* The first number in the vertex represents the city number.\n", - "* The second number in the vertex represents the order the salesman visits the corresponding city.\n", - "* The red edges represent the found optimal route for the salesman." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 10, - "source": [ - "label_dict = {i: str(i) + \", \" + str(t) for i, t in solution.items()}\n", - "edge_color = [\"red\" if solution[u] == (solution[v] + 1) % n\n", - " or solution[v] == (solution[u] + 1) % n else \"black\"\n", - " for (u, v) in G.edges]\n", - "label_dict_bf = {i: str(i) + \", \" + str(t) for i, t in solution_brute_force.items()}\n", - "edge_color_bf = [\"red\" if solution_brute_force[u] == (solution_brute_force[v] + 1) % n\n", - " or solution_brute_force[v] == (solution_brute_force[u] + 1) % n else \"black\"\n", - " for (u, v) in G.edges]\n", - "\n", - "# Draw the walk corresponding to the dictionary presented above 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(G, pos=pos, labels=label_dict, edge_color=edge_color, ax=ax[0], **options)\n", - "nx.drawing.nx_pylab.draw_networkx_edge_labels(G, pos=pos, ax=ax[0], edge_labels=nx.get_edge_attributes(G, 'weight'))\n", - "nx.draw(G, pos=pos, labels=label_dict_bf, edge_color=edge_color_bf, ax=ax[1], **options)\n", - "nx.drawing.nx_pylab.draw_networkx_edge_labels(G, pos=pos, ax=ax[1], edge_labels=nx.get_edge_attributes(G, '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:26:08.431841Z", - "start_time": "2021-05-17T08:26:08.172882Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "The left graph given above shows a solution found by the parameterized quantum circuit, while the right graph given above shows a solution found by the brute-force algorithm. It can be seen that even if the order of the vertices are different, the routes are essentially the same, which verifies the correctness of using parameterized quantum circuit to solve the TSP." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Applications\n", - "\n", - "The TSP naturally applies in many transportation and logistics applications, for example, the problem of arranging school bus routes. The school bus application provides the motivation for Merrill Flood, a pioneer in the field of management science, to study TSP research in the 1940s. More recent applications involve food delivery route management [1] and power delivery for cable firms [2]. \n", - "\n", - "Other than those transportation applications, TSP also has wide usefulness in other management problems like scheduling of a machine to drill holes in a circuit board [3], reconstructing an unknown fragment of DNA [4] and scheduling optimal route in construction management [5]. Some consulting companies like [Nexus](https://nexustech.com.ph/company/newsletter/article/Finding-the-shortest-path-Optimizing-food-trips) have utilized this to provide management service.\n", - "\n", - "The TSP, as one of the most famous optimization problems, also provides a platform for the study of general methods in solving combinatorial problem. This is usually the first several problems that researchers give a try for experiments of new algorithms.\n", - "\n", - "More applications, formulations and solution approaches can be found in [6]." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "_______\n", - "\n", - "## References\n", - "\n", - "[1] Bräysy, Olli, et al. \"An optimization approach for communal home meal delivery service: A case study.\" [Journal of Computational and Applied Mathematics 232.1 (2009): 46-53.](https://www.sciencedirect.com/science/article/pii/S0377042708005438)\n", - "\n", - "[2] Sloane, Thomas H., Frank Mann, and H. Kaveh. \"Powering the last mile: an alternative to powering FITL.\" [Proceedings of Power and Energy Systems in Converging Markets. IEEE, 1997.](https://ieeexplore.ieee.org/document/646046)\n", - "\n", - "[3] Onwubolu, Godfrey C. \"Optimizing CNC drilling machine operations: traveling salesman problem-differential evolution approach.\" [New optimization techniques in engineering. Springer, Berlin, Heidelberg, 2004. 537-565.](https://link.springer.com/chapter/10.1007/978-3-540-39930-8_22)\n", - "\n", - "[4] Caserta, Marco, and Stefan Voß. \"A hybrid algorithm for the DNA sequencing problem.\" [Discrete Applied Mathematics 163 (2014): 87-99.](https://www.sciencedirect.com/science/article/pii/S0166218X12003253)\n", - "\n", - "[5] Klanšek, Uroš. \"Using the TSP solution for optimal route scheduling in construction management.\" [Organization, technology & management in construction: an international journal 3.1 (2011): 243-249.](https://www.semanticscholar.org/paper/Using-the-TSP-Solution-for-Optimal-Route-Scheduling-Klansek/3d809f185c03a8e776ac07473c76e9d77654c389)\n", - "\n", - "[6] Matai, Rajesh, Surya Prakash Singh, and Murari Lal Mittal. \"Traveling salesman problem: an overview of applications, formulations, and solution approaches.\" [Traveling salesman problem, theory and applications 1 (2010).](https://www.sciencedirect.com/topics/computer-science/traveling-salesman-problem)" - ], - "metadata": {} - } - ], - "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.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/locc/parameters/QT_LOCCNET_Trained.npy b/tutorial/locc/parameters/QT_LOCCNET_Trained.npy deleted file mode 100644 index 3b55921..0000000 Binary files a/tutorial/locc/parameters/QT_LOCCNET_Trained.npy and /dev/null differ diff --git a/tutorial/machine_learning/QClassifier_CN.ipynb b/tutorial/machine_learning/QClassifier_CN.ipynb deleted file mode 100644 index 577da6f..0000000 --- a/tutorial/machine_learning/QClassifier_CN.ipynb +++ /dev/null @@ -1,1430 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 量子分类器\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 概览\n", - "\n", - "本教程我们将讨论量子分类器（quantum classifier）的原理，以及如何利用量子神经网络（quantum neural network, QNN）来完成**二分类**任务。这类方法早期工作的主要代表是 Mitarai et al.(2018) 的量子电路学习 [(Quantum Circuit Learning, QCL)](https://arxiv.org/abs/1803.00745) [1], Farhi & Neven (2018) [2] 和 Schuld et al.(2018) 的中心电路量子分类器 [Circuit-Centric Quantum Classifiers](https://arxiv.org/abs/1804.00633) [3]。这里我们以第一类的 QCL 框架应用于监督学习（Supervised learning）为例进行介绍，通常我们需要先将经典数据编码成量子数据，然后通过训练量子神经网络的参数，最终得到一个最优的分类器。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 背景\n", - "\n", - "在监督学习的情况下，我们需要输入 $N$ 个带标签的数据点构成的数据集 $D = \\{(x^k,y^k)\\}_{k=1}^{K}$，其中 $x^k\\in \\mathbb{R}^{m}$ 是数据点，$y^k \\in\\{0,1\\}$ 是对应数据点 $x^k$ 的分类标签。**分类过程实质上是一个决策过程，决策给定数据点的标签归属问题**。 对于量子分类器框架，分类器 $\\mathcal{F}$ 的实现方式为一个含参 $\\theta$ 的量子神经网络/参数化量子电路, 测量量子系统以及数据后处理的组合。一个优秀的分类器 $\\mathcal{F}_\\theta$ 应该尽可能的将每个数据集内的数据点正确地映射到相对应的标签上 $\\mathcal{F}_\\theta(x^k) \\rightarrow y^k$。因此，我们将预测标签 $\\tilde{y}^{k} = \\mathcal{F}_\\theta(x^k)$ 和实际标签 $y^k$ 之间的累计距离作为损失函数 $\\mathcal{L}(\\theta)$ 进行优化。对于两分类任务，可以选择二次损失函数\n", - "\n", - "$$\n", - "\\mathcal{L}(\\theta) = \\sum_{k=1}^N 1/N \\cdot |\\tilde{y}^{k}-y^k|^2. \\tag{1}\n", - "$$\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 方案流程\n", - "\n", - "这里我们给出实现量子电路学习 (QCL) 框架下量子分类器的一个流程。\n", - "\n", - "1. 将经典数据编码$x^k$为量子数据$\\lvert \\psi_{\\rm in}\\rangle^k$。本教程采用角度编码。关于编码方式的具体操作，见[量子态编码经典数据](./DataEncoding_CN.ipynb)。用户也可以尝试其他编码，如振幅编码，体验不同编码方式对分类器学习效率的影响。\n", - "2. 构建可调参数量子电路，对应幺正变换(unitary gate)$U(\\theta)$。\n", - "3. 对每一个量子数据$\\lvert\\psi_{\\rm in}\\rangle^k$，通过参数化量子电路$U(\\theta)$，得到输出态$\\lvert \\psi_{\\rm out}\\rangle^k = U(\\theta)\\lvert \\psi_{\\rm in} \\rangle^k$。\n", - "4. 对每一个量子数据得到的输出量子态$\\lvert \\psi_{\\rm out}\\rangle^k$，通过测量与数据后处理，得到标签 $\\tilde{y}^{k}$。\n", - "5. 重复以上步骤，得到数据集内所有点的标签，并计算损失函数 $\\mathcal{L}(\\theta)$。\n", - "6. 通过梯度下降等优化方法不断调整参数 $\\theta$ 的值，从而最小化损失函数。记录优化完成后的最优参数 $\\theta^*$, 这时我们就学习到了最优的分类器 $\\mathcal{F}_{\\theta^*}$。\n", - "\n", - " \n", - "
图 1：量子分类器训练的流程图
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Paddle Quantum 实现\n", - "\n", - "这里，我们先导入所需要的语言包：" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T09:15:03.419838Z", - "start_time": "2021-03-02T09:15:03.413324Z" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\yeruilin\\Anaconda3\\envs\\paddle_quantum_env\\lib\\site-packages\\matplotlib_inline\\config.py:66: DeprecationWarning: InlineBackend._figure_formats_changed is deprecated in traitlets 4.1: use @observe and @unobserve instead.\n", - " def _figure_formats_changed(self, name, old, new):\n" - ] - } - ], - "source": [ - "# 导入 numpy 与 paddle\n", - "import numpy as np\n", - "import paddle\n", - "\n", - "# 构建量子电路\n", - "from paddle_quantum.circuit import UAnsatz\n", - "# 一些用到的函数\n", - "from numpy import pi as PI\n", - "from paddle import matmul, transpose, reshape # paddle 矩阵乘法与转置\n", - "from paddle_quantum.utils import pauli_str_to_matrix,dagger # 得到 N 量子比特泡利矩阵,复共轭\n", - "\n", - "# 作图与计算时间\n", - "from matplotlib import pyplot as plt\n", - "import time" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "分类器问题用到的参数" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# 数据集参数设置\n", - "Ntrain = 200 # 规定训练集大小\n", - "Ntest = 100 # 规定测试集大小\n", - "boundary_gap = 0.5 # 设置决策边界的宽度\n", - "seed_data = 2 # 固定随机种子\n", - "# 训练参数设置\n", - "N = 4 # 所需的量子比特数量\n", - "DEPTH = 1 # 采用的电路深度\n", - "BATCH = 20 # 训练时 batch 的大小\n", - "EPOCH = int(200 * BATCH / Ntrain)\n", - " # 训练 epoch 轮数，使得总迭代次数 EPOCH * (Ntrain / BATCH) 在200左右\n", - "LR = 0.01 # 设置学习速率\n", - "seed_paras = 19 # 设置随机种子用以初始化各种参数" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 数据集的生成\n", - "\n", - "对于监督学习来说，我们绕不开的一个问题就是——采用什么样的数据集呢？在这个教程中我们按照论文 [1] 里所提及方法生成简单的圆形决策边界二分数据集 $\\{(x^{k}, y^{k})\\}$。其中数据点 $x^{k}\\in \\mathbb{R}^{2}$，标签 $y^{k} \\in \\{0,1\\}$。\n", - "\n", - " \n", - "
图 2：生成的数据集和对应的决策边界
\n", - "\n", - "具体的生成方式和可视化请见如下代码：" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "数据集生成函数 " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T09:15:04.631031Z", - "start_time": "2021-03-02T09:15:04.617301Z" - } - }, - "outputs": [], - "source": [ - "# 圆形决策边界两分类数据集生成器\n", - "def circle_data_point_generator(Ntrain, Ntest, boundary_gap, seed_data):\n", - " \"\"\"\n", - " :param Ntrain: 训练集大小\n", - " :param Ntest: 测试集大小\n", - " :param boundary_gap: 取值于 (0, 0.5), 两类别之间的差距\n", - " :param seed_data: 随机种子\n", - " :return: 四个列表：训练集x，训练集y，测试集x，测试集y\n", - " \"\"\"\n", - " # 生成共Ntrain + Ntest组数据，x对应二维数据点，y对应编号\n", - " # 取前Ntrain个为训练集，后Ntest个为测试集\n", - " train_x, train_y = [], []\n", - " num_samples, seed_para = 0, 0\n", - " while num_samples < Ntrain + Ntest:\n", - " np.random.seed((seed_data + 10) * 1000 + seed_para + num_samples)\n", - " data_point = np.random.rand(2) * 2 - 1 # 生成[-1, 1]范围内二维向量\n", - "\n", - " # 如果数据点的模小于(0.7 - gap)，标为0\n", - " if np.linalg.norm(data_point) < 0.7 - boundary_gap / 2:\n", - " train_x.append(data_point)\n", - " train_y.append(0.)\n", - " num_samples += 1\n", - "\n", - " # 如果数据点的模大于(0.7 + gap)，标为1\n", - " elif np.linalg.norm(data_point) > 0.7 + boundary_gap / 2:\n", - " train_x.append(data_point)\n", - " train_y.append(1.)\n", - " num_samples += 1\n", - " else:\n", - " seed_para += 1\n", - "\n", - " train_x = np.array(train_x).astype(\"float64\")\n", - " train_y = np.array([train_y]).astype(\"float64\").T\n", - "\n", - " print(\"训练集的维度大小 x {} 和 y {}\".format(np.shape(train_x[0:Ntrain]), np.shape(train_y[0:Ntrain])))\n", - " print(\"测试集的维度大小 x {} 和 y {}\".format(np.shape(train_x[Ntrain:]), np.shape(train_y[Ntrain:])), \"\\n\")\n", - "\n", - " return train_x[0:Ntrain], train_y[0:Ntrain], train_x[Ntrain:], train_y[Ntrain:]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "数据集可视化函数" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "# 用以可视化生成的数据集\n", - "def data_point_plot(data, label):\n", - " \"\"\"\n", - " :param data: 形状为 [M, 2], 代表M个 2-D 数据点\n", - " :param label: 取值 0 或者 1\n", - " :return: 画这些数据点\n", - " \"\"\"\n", - " dim_samples, dim_useless = np.shape(data)\n", - " plt.figure(1)\n", - " for i in range(dim_samples):\n", - " if label[i] == 0:\n", - " plt.plot(data[i][0], data[i][1], color=\"r\", marker=\"o\")\n", - " elif label[i] == 1:\n", - " plt.plot(data[i][0], data[i][1], color=\"b\", marker=\"o\")\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "此教程采用大小分别为 200, 100 的训练集，测试集，决策边界宽度为 0.5 的数据，用以训练与测试量子神经网络训练效果：" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T09:15:06.422981Z", - "start_time": "2021-03-02T09:15:05.043595Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "训练集的维度大小 x (200, 2) 和 y (200, 1)\n", - "测试集的维度大小 x (100, 2) 和 y (100, 1) \n", - "\n", - "训练集 200 个数据点的可视化：\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "测试集 100 个数据点的可视化：\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD4CAYAAADhNOGaAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAh60lEQVR4nO3de8wd9X3n8ffHpia1UBvbeAkB/Bi2pAltuiQ86yQbaZsLCYSVMNmSxKmTddJEXtKQlTbaFUZIm4hda2n3D9SqUbsWSXDwswFKFeFuyLJct380pDxI3AwCGwgXlwTHTiJZUK7f/WPmxOPjc33O3OfzkkbnnJk55/zOzJz5/uZ3G0UEZmbWXcuqToCZmVXLgcDMrOMcCMzMOs6BwMys4xwIzMw67riqE7AUJ554Yqxfv77qZJiZNcp99933s4hY2z+/kYFg/fr1LC4uVp0MM7NGkfT0oPkuGjIz6zgHAjOzjnMgMDPrOAcCM7OOcyAwM+u4XAKBpG9JekHSw0OWS9KfS9on6UFJ784s2yJpbzptySM9ZjabhQVYvx6WLUseFxaqTpEVKa8rgmuB80cs/xhwZjptBf4SQNJq4GvAe4ANwNckrcopTWa2BAsLsHUrPP00RCSPW7c6GLRZLoEgIv4OODRilY3AdyJxD/BmSScD5wG3RcShiPg5cBujA0rtOSdlTXfFFfDii0fPe/HFZL61U1kdyk4Bns28fi6dN2z+MSRtJbmaYN26dcWkcka9nFTvT9TLSQFs3lxdusym8cwz08235mtMZXFE7IiI+YiYX7v2mB7StdCUnJSvWqpV9+0/LJ9V0/zXzKrYH3U7Bsq6ItgPnJZ5fWo6bz/wgb75d5eUptw1ISflq5Zq1X37LyzA4cPHzl+5ErZvLz89Ratif9TyGIiIXCZgPfDwkGX/BvgBIOC9wD+k81cDTwGr0ukpYPW47zrnnHOijubmIpLqtaOn5csjdu2qOnWJYWmcm8v3e3btSj5TSh7r8vurVtb2X4pduyJWrjw2bWvWtHf/TbI/8jqWe58z6PvKOgaAxRh0jh40c9oJ+C7wPPAqSTn/F4BLgEvS5QK+ATwBPATMZ977R8C+dPr8JN+XRyAo4kQ17I8Eyfw6/JmkwemT8vuOQduhLr+/amVs/6Wqc5Ca1bD/+7j9kdexPOrcUOYxUGggKHuaNRAUeaLatSu5AqjrH6qMP3ubTyizqvO2qXOQmsWo//u4/ZHX/hp1JdCaK4Kyp1kDQdF/xjr/ocrIrdf591etzldLdQ5Ssxj1u8btj7yO5WGfU/Yx4ECQUfSJqu5/qKLL7+v++6tW1/qTooNUVb97kuKfYekq44qgzG3hQJBR9Imqzrm+MnT99zdZUSfrKo+JWf7vRdYRVPGfcCDIKGOn1DXXV5au/347WpVXibP+3/NuNVTlf2JYIFCyrFnm5+dj1ltVLiwkHb2eeSbpKHPBBXDLLUdeb99ej3bdZm2wbFlyCu4nwRtvFP/9/f/3rv6/Jd0XEfP98xvTszhvmzfDj3+cHITbt8POnfkOslVGz8G69U40G6bq3srZ//uPf9zNIDBKZwNBVt5DQ5QxeqNHiLQm2b496Z2cNai3sjM3FRlUXlT3Ke+exXm3Ilpqeeg0ZYhumWNNM+74rkuFapvhOoLh1q9PctT95uaSy8hpLaU8tH/8EUhyTDt2DL6MrbrM1Sxvef8P7ViuIxhh0svWSS2lPHTa4qmqy1zN8taEQRvbyoGAJMe9Y0eS85CSx2E58UksJbBM+yfIO3iZVc2Zm+o4EKTybFWwlMAy7Z8g7+BlVrWiMjeugJ7AoIqDuk91HYZ6Fq4oM8u/05X/V0djSGWxrwhqwjl8s/zb+1d518AmXYm41ZCZtVZVreumbQVYFrcaMrPOqaoCuin3L+/JJRBIOl/SY5L2Sdo2YPnVku5Pp8cl/SKz7PXMst15pMfMDKprXde0prAz37xe0nKS21B+hOQ2lfdK2h0Rj/TWiYj/mFn/K8C7Mh/xUkScPWs6zMz69Yphyh5wbt26wZ3j6toUNo8rgg3Avoh4MiJeAa4HNo5Y/9Mk9ziutSIreppUiWTWdFUMONe0fj55BIJTgGczr59L5x1D0hxwOnBnZvabJC1KukfSRcO+RNLWdL3FAwcO5JDs4Yoc0M2DxZm1X9NaAc7cakjSxcD5EfHF9PVngfdExKUD1r0MODUivpKZd0pE7Jd0BkmA+HBEPDHqO4tuNVTkmCceT8XMqlJkq6H9wGmZ16em8wbZRF+xUETsTx+fBO7m6PqDUvWKbAadqCGfip6mVSKZWfvlEQjuBc6UdLqkFSQn+2Na/0h6O7AK+GFm3ipJx6fPTwTeDzzS/94yZItshsmjosfjqZhZ3cwcCCLiNeBS4FbgUeDGiNgj6UpJF2ZW3QRcH0eXRb0DWJT0AHAXcFW2tVGZBrX7zcqroqdplUhmVp2yGpbM3HwUICJuAW7pm/df+l5/fcD7/h54Zx5pmNWoopm5uXybnP36rx8JOmvWwJ/9WX0rkcysGv29k3sNSyD/84V7FqeGFc30KnHz2PC9HXvw4JF5L700++eaWfuU2TvZgSBVRpFN07qdm1l1ymxY4kCQKqPdr1sMmdmkymxY4kCQUXQPRLcYMrNJldmwxIGgRG4xZGaTKrN3ci6thmwyVQ2AZWbNtHlzOecHXxGUrIoBsMysHE0dUNJXBGZmOSiz3X/efEVgZpaDJjcPdyAwM8tBk5uHOxCYmeVg9erp5teJA4GZWcc5EJiZ5eDQoenm14kDgZlZDiYdOaCOTUwdCMzMcjDJyAF1vWe5A8GU6hjNzax6kwwJUdcmprkEAknnS3pM0j5J2wYs/5ykA5LuT6cvZpZtkbQ3nbbkkZ6i1DWam1k9jBs5oK5NTGcOBJKWA98APgacBXxa0lkDVr0hIs5Op2vS964Gvga8B9gAfE3SqlnTVJS6RnMza4a6jkCcxxXBBmBfRDwZEa8A1wMbJ3zvecBtEXEoIn4O3Aacn0OaClHXaG5mzVDXEYjzCASnAM9mXj+Xzuv3B5IelHSTpNOmfC+StkpalLR44MCBHJI9vbpGczNrhjKHlp5GWZXFfwusj4jfI8n175z2AyJiR0TMR8T82rVrc0/gJOoazc2sOeo4AnEegWA/cFrm9anpvF+JiIMR8XL68hrgnEnfWyd1jeZmZrPIIxDcC5wp6XRJK4BNwO7sCpJOzry8EHg0fX4r8FFJq9JK4o+m82qrjtHcasjtjK1BZr4fQUS8JulSkhP4cuBbEbFH0pXAYkTsBv6DpAuB14BDwOfS9x6S9F9JggnAlRHRgA7ZZiM0eWB66yRFRNVpmNr8/HwsLi5WnQyzwdavT07+/ebmkstIs4pIui8i5vvnu2exWd7cztgaxoHALG9uZ2wN40Bglje3M7aGcSAwy5vbGVvDOBCYFWFUO2M3LbWambn5qJlNwU1LrYZ8RWA2Tp45eA9hazXkQGA2St43oRjXtNTFRlYBBwKzUfLOwY9qWuo7H1lFHAismcrKOefdOWxU01IXG1lFHAisecrMOefdOWxU01L3SLaKOBBY85SZcy6ic9iwpqXukWwVcSCw5ikz51xE57BhxVrukWwVcT8Ca5516waP7llUznnz5vza+E/Sj+CKK5Kgtm5dEgTcv8AK5isCa4ZsLvrwYVix4ujlTck5jyvW8p2PLKOsNhEOBFZ//ZXDBw8mj2vWHCmu2bIlOZnWvf29K4RtQmW2icglEEg6X9JjkvZJ2jZg+VclPSLpQUl3SJrLLHtd0v3ptLv/vWYDc9GvvgonnJDknLdvh507m9H+vogKYXdCa6VSWxNHxEwTye0pnwDOAFYADwBn9a3zQWBl+vxLwA2ZZYen/c5zzjknrEOkiOQUf/QkJcvn5gYvn5urMtWD7doVsXLl0elcuTKZP+3n9H53//ZZyudZ7Yw77JeC5PbBx5xT87gi2ADsi4gnI+IV4HpgY1+wuSsierHtHuDUHL43V85U1di4XHSTilvyaIWULTOA5PyQ5U5orVBma+I8AsEpwLOZ18+l84b5AvCDzOs3SVqUdI+ki4a9SdLWdL3FAwcOzJTgfu7ZX3PjmlU2rf39rBXCg8oM+k0bBJ0Tqp1SWxMPukyYZgIuBq7JvP4s8BdD1v0MyRXB8Zl5p6SPZwA/Bv75uO/Mu2ioSSULndUrCpGSx2zRR17FLWWkNQ/DygyWevAO2n4QsWaNi5gqlvehxJCioTwCwfuAWzOvLwcuH7DeucCjwD8b8VnXAheP+868A0ERZXFWsqJPvtOko+igNCznstTvG/V5rm+oXJ6HdpGB4DjgSeB0jlQW/07fOu8iqVA+s2/+qt7VAXAisJe+iuZBk68IrLbKOJgGBZtebmYpZ4pxVxj+I1Qm73zFsEAwcx1BRLwGXArcmub4b4yIPZKulHRhutr/AE4A/rqvmeg7gEVJDwB3AVdFxCOzpmla7tlvuSmj4npQhfN11yXniaXUOYyrS6ljpXtHlNWEVEmQaJb5+flYXFzM9TMXFtyz33Kwfv3g4S/m5pKTdB31D3vRr85pb7lly45tFAZJ/H/jjek/T9J9ETF/zPcsJXFt5J79losmXl72rjDWrDl2Wd3T3nJlNYhzIDDryaMJZRGjlZZh82b42c9g167mpb3FyspXuGjIDAYXj6xc6ROhVS7PYuthRUMOBGbQzLJ9sym5jsBslCYNU2GWMwcC67ZevcCwK+O6DlPRz0NE2Ax8hzLrrnHNJpvSYmaSu56ZjeArAuuuUYO3NanFTKkD11sb+YrAumtY+b/UrApi12/YjHxFYN3VtOGrh2nL77DKOBBYdzWxF/Agk/wOVybbCA4E1l159wKu6mQ77nf4zks2hjuUmeWhzj2T3VnOUu5QZlakOrfccWWyjeFAYJaHOp9sXZlsYzgQmOWhzifbKirFXTndKLkEAknnS3pM0j5J2wYsP17SDenyH0lan1l2eTr/MUnn5ZEes9LVuQVS2UNju3K6cWauLJa0HHgc+AjwHHAv8OnsLScl/THwexFxiaRNwMcj4lOSzgK+C2wA3grcDrwtIl4f9Z2uLLZa8m3uEq6crq0iK4s3APsi4smIeAW4HtjYt85GYGf6/Cbgw5KUzr8+Il6OiKeAfennmTWPb3OXqHN9iQ2URyA4BXg28/q5dN7AddKb3f8SWDPhewGQtFXSoqTFAwcO5JBsswZoYll7netLbKDGVBZHxI6ImI+I+bVr11adHLPiNbWsvc71JTZQHoFgP3Ba5vWp6byB60g6DvhN4OCE77Wua2KuOA917pswSlPv29xheVQWH0dSWfxhkpP4vcAfRsSezDpfBt6ZqSz+txHxSUm/A/wvjlQW3wGc6cpi+5U699gt2rJlg2+YIyX1EGZTKqyyOC3zvxS4FXgUuDEi9ki6UtKF6WrfBNZI2gd8FdiWvncPcCPwCPB/gC+PCwLWMU3NFefBZe1WEo81ZPXW5Vxxl6+GrBAea8iaqcu5Ype1W0kcCKzeBrVA+bVfg8OHu1F57L4JVgIHAqu3/lzxmjXJ48GDzWpSaTaBqhrIORBY/WVzxSecAK+8cvTyulQed7WZq+Wiym4jDgTWLHUbvqB38pfgs59tXuevaTjQFarKBnIOBNYsdao8zmbh4NjWTXW5UslDU3s5N8igcfpGzc+TAwHO6DRKnYYvGJSF69eWgda63J+jJMuXTzc/T50PBM7oNMywJpVQfjSf5CTflmaudSuSa6HXh3SlHTY/T50PBM7oNFB/k0qoJpqPO8m3aaC1OhXJtdTc3HTz89T5QOCMTgtUFc0HFVNJyWPbOn/VqUiupS644Mjh01PWJu58IHBGpwWqiuaDiqmuuy65Kmlb5y/3ci7UwgLs3Hl0ewMJtmwpZxN3fqwhD+fSAr41ojVcWYewxxoawhmdFnCxhTVc1UXUnQ8E4OFcGs/R3Bqu6iJqBwJrB0dza7CqL2pnCgSSVku6TdLe9HHVgHXOlvRDSXskPSjpU5ll10p6StL96XT2LOkxK5V7IlpOqr6onamyWNKfAoci4ipJ24BVEXFZ3zpvAyIi9kp6K3Af8I6I+IWka4H/HRE3TfO9vjGNVc6tDKyBiqos3gjsTJ/vBC7qXyEiHo+IvenzfwReANbO+L1m1XJPRGuRWQPBSRHxfPr8J8BJo1aWtAFYATyRmb09LTK6WtLxM6bHrBxVN/Mwy9HYQCDpdkkPD5g2ZteLpIxpaDmTpJOB64DPR0TvZrOXA28H/iWwGrhsyNuRtFXSoqTFAwcOjP9lZkWqupmHWY7GBoKIODcifnfAdDPw0/QE3zvRvzDoMyT9BvB94IqIuCfz2c9H4mXg28CGEenYERHzETG/dq1LlqxiVTfzMMvRrEVDu4Et6fMtwM39K0haAXwP+E5/pXAmiIikfuHhGdNjVo6qm3lYq5XdIG3WVkNrgBuBdcDTwCcj4pCkeeCSiPiipM+Q5Pb3ZN76uYi4X9KdJBXHAu5P33N43Pe61ZCZtVWRDdKGtRrq/FhD4ywsJA1BnnkmKf7dvt2ZPjMrTpHjDnmsoSXwTWtawh2/rEGqaJDmQDCCm4q3gKO5NUwVDdIcCEZwU/EWcDS3hqmiQZoDwQhuKl5zkxT5tCmau4irE6pokOZAMIKbitfYpEU+bYnmLuLqlLIH03UgGMFNxWts0iKftkRzF3FZgdx81Jpp2bKjb/DaIyXZqKw2tAGe5veaDTGs+ehxVSTGbGbr1g1ubD2oyGfz5uad+PtN83vNpuSiIWumthT5TKprv9dK5UBgzdS1Cpyu/V4rlesIctCGImgzaz8PMdEnrybZbtVnZk3XyUCQ58nbrfrMrOk6GQjyPHm3qeOqmXVTJwNBnifvtnRcNbPu6mQgyPPk7VZ9ZtZ0MwUCSasl3SZpb/q4ash6r0u6P512Z+afLulHkvZJuiG9rWXh8jx5u1WfmTXdrFcE24A7IuJM4I709SAvRcTZ6XRhZv6fAFdHxG8BPwe+MGN6JpL3ybvsAaLMzPI06z2LHwM+EBHPpzeivzsifnvAeocj4oS+eQIOAG+JiNckvQ/4ekScN+5769aPwMysCYrqR3BSRDyfPv8JcNKQ9d4kaVHSPZIuSuetAX4REa+lr58DTpkxPWZmNqWxg85Juh14y4BFRzW2jIiQNOzyYi4i9ks6A7hT0kPAL6dJqKStwFaAdW6SY2aWm7GBICLOHbZM0k8lnZwpGnphyGfsTx+flHQ38C7gb4A3SzouvSo4Fdg/Ih07gB2QFA2NS7eZmU1m1qKh3cCW9PkW4Ob+FSStknR8+vxE4P3AI5FUTtwFXDzq/WZmVqxZA8FVwEck7QXOTV8jaV7SNek67wAWJT1AcuK/KiIeSZddBnxV0j6SOoNvzpgeMzOb0kyBICIORsSHI+LMiDg3Ig6l8xcj4ovp87+PiHdGxL9IH7+Zef+TEbEhIn4rIj4RES/P9nOqMckAdr7vuJnVle9QNqPeAHa9sYt6A9jBkf4Ek6xjZlaVzgwxUVSOfJIB7DxCqZnVWSeuCIrMkU8ygJ1HKDWzOuvEFUGROfJJBrDzCKVm7dWG+r9OBIIic+TjBrBbWIDDh499n0coNWu+ttyhsBOBoMgc+agB7HoHycGDR79nzRqPUGrWBm2p/+vEzev76wggyZEXfTJevz7JIfSbm0tGKTWzZlu2LLkS6CcloxHXTadvXl/VPQNcSWzWbm2p/+tEIIBq7hnQloPEzAab9iZXS61YLrpCujOBoAq+jaVZu01T2rDUiuUyKqQ7UUdQpYWFpOLomWeSK4Ht211JbNZFS60zzLOucVgdgQOBmVkJllqxnGeFdKcri9ukDZ1XzLpoqXWGZdQ1OhA0SFs6r5h10VLrDMuoa3QgaJC2dF4x66KlNmMvo/m76wgapGmdV8ysXgqpI5C0WtJtkvamj6sGrPNBSfdnpn+SdFG67FpJT2WWnT1LetrO/RLMrAizFg1tA+6IiDOBO9LXR4mIuyLi7Ig4G/gQ8CLwfzOr/Ofe8oi4f8b0tJr7JZhZEWYNBBuBnenzncBFY9a/GPhBRLw4Zj0boKqhMsys3WYNBCdFxPPp858AJ41ZfxPw3b552yU9KOlqScfPmJ7Wq2KoDDNrt7F3KJN0O/CWAYuOaqsSESFpaM2zpJOBdwK3ZmZfThJAVgA7gMuAK4e8fyuwFWCdC8XNzHIz9oogIs6NiN8dMN0M/DQ9wfdO9C+M+KhPAt+LiFczn/18JF4Gvg1sGJGOHRExHxHza9eunfT3mZktWVc6cM5aNLQb2JI+3wLcPGLdT9NXLJQJIiKpX3h4xvSYmU1s1Im+Sx04Zw0EVwEfkbQXODd9jaR5Sdf0VpK0HjgN+H9971+Q9BDwEHAi8N9mTI+N0JXcjdkkxp3ou9SB0x3KxuiNHvr007B8Obz+etJap2mjiFZ1lzazuho3qmcbO3B60LklyOYYIAkC0MxLxC7lbswmMeoOggsLSSAYpKi2KlVesfuKYIRhOYaeJt17uI25G7NZDPt/r1kDL710bMYJiruKLuuK3VcESzDu3sJNuvewh6cwS/Ry3k8/nWSEsno99wcFgeXLiwsCW7ZUe8XuQDDCUscJryMPT2F2bHFvxJFg0Oupf+jQ4Pe+8cZ0QWCSop5eenrFzv1Ky2xGROOmc845J8qwa1fEypURyeFy9LRyZbK8SXbtipibi5CSx6al32xWc3OD/89zc9OtM86gc8egc8aw71rKd04CWIwB59TKT+pLmcoKBBFHTp4QsXz5kZ1T1UnUJ3OzpZMGn3ClI+tMehIfZdJgMiw9RWU2HQhaII8DtGoOZFalSU/Qsx6nkwScUelZvryY/4YDQQvkccmaVfZJuQ2BzJqtrGNwmoBT5n/CgaAFJs1lTKKKk3LegcxsKcrIAE3z/yozQzYsELgfQYOM6wlZ1WdNyn0ZrEt6oxI880zSwrAOoxG4H0EL5NkEdFSvyqK4L4N1SZPuHeJA0CB53qGsipPyoEAmwQUXFPedZjaeA0HD5JXLGHd1UcS4J5s3Jz0os705I2DnzmaN29QGHonWjjKo4qDuU1cri/M2rJKqyIrkulQYd7kZaxtbb3V5f04DtxoqXlsOxiJP1nm2fFqqNp4Ip1GXYJyXru/PaQwLBC4aykmb7mZUZEVyHSqMuz4k97T7t+7FSG3cn6Vv80HRYdIJ+ASwB3gDmB+x3vnAY8A+YFtm/unAj9L5NwArJvneOl4RtCmXVeRvqUPurQ5XJVWaZv/WYX+N07b9WeQ2p4iiIeAdwG8Ddw8LBMBy4AngDGAF8ABwVrrsRmBT+vyvgC9N8r11DARtOhiL/vNXXYTWpqC9FNPs3yZsqyakcRpF/p5CAsGvPmR0IHgfcGvm9eXpJOBnwHGD1hs11TEQtO1grPpkXaQm5HKLNun+bUIGp237s8htPiwQlFFHcArwbOb1c+m8NcAvIuK1vvmN1Lbx/pvUGWZaefbHaKpJ928d6nTGadv+rGKbjw0Ekm6X9PCAaWNxyRqYjq2SFiUtHjhwoMyvnkjbDsa2a3Ogy1NTMjht2p9VbPPjxq0QEefO+B37gdMyr09N5x0E3izpuPSqoDd/WDp2ADsgGWtoxjQVYvPmZh+AZv16x3Pdxsxpsyq2+dhAkIN7gTMlnU5yot8E/GFSFqa7gIuB64EtwM0lpMfMpuAMTvnK3uYz1RFI+rik50gqer8v6dZ0/lsl3QKQ5vYvBW4FHgVujIg96UdcBnxV0j6SOoNvzpIeMzObnoehNjPrCA9DbWZmAzkQmJl1nAOBmVnHNbKOQNIBYMCNFidyIkmP5rpxuqZT13RBfdPmdE2vrmlbarrmImJt/8xGBoJZSFocVFlSNadrOnVNF9Q3bU7X9OqatrzT5aIhM7OOcyAwM+u4LgaCHVUnYAinazp1TRfUN21O1/TqmrZc09W5OgIzMztaF68IzMwsw4HAzKzjWhkIJH1C0h5Jb0ga2sRK0vmSHpO0T9K2zPzTJf0onX+DpBU5pWu1pNsk7U0fVw1Y54OS7s9M/yTponTZtZKeyiw7u6x0peu9nvnu3Zn5VW6vsyX9MN3fD0r6VGZZrttr2PGSWX58+vv3pdtjfWbZ5en8xySdN0s6lpCur0p6JN0+d0iayywbuE9LTNvnJB3IpOGLmWVb0n2/V9KWktN1dSZNj0v6RWZZYdtM0rckvSDp4SHLJenP03Q/KOndmWVL316DblvW9ImK7qU8Qbr+FNiWPt8G/MmY9VcDh4CV6etrgYsL2F4TpQs4PGR+ZdsLeBtwZvr8rcDzwJvz3l6jjpfMOn8M/FX6fBNwQ/r8rHT944HT089ZXmK6Ppg5hr7US9eofVpi2j4H/MWA964GnkwfV6XPV5WVrr71vwJ8q6Rt9q+BdwMPD1l+AfADklv9vhf4UR7bq5VXBBHxaEQ8Nma1DcC+iHgyIl4huSfCRkkCPgTclK63E7gop6RtTD9v0s+9GPhBRLyY0/cPM226fqXq7RURj0fE3vT5PwIvAMf0nMzBwONlRHpvAj6cbp+NwPUR8XJEPAXsSz+vlHRFxF2ZY+gekptAlWGSbTbMecBtEXEoIn4O3AacX1G6Pg18N6fvHiki/o4k8zfMRuA7kbiH5OZeJzPj9mplIJhQFfdSPikink+f/wQ4acz6mzj2ANyeXhJeLen4ktP1JiW3C72nV1xFjbaXpA0kObwnMrPz2l7DjpeB66Tb45ck22eS9xaZrqwvkOQoewbt07xMmrY/SPfRTZJ6dzOsxTZLi9FOB+7MzC5ym40zLO0zba8y7lBWCEm3A28ZsOiKiKjsTmej0pV9EREhaWjb3TTKv5Pkhj49l5OcEFeQtCO+DLiyxHTNRcR+SWcAd0p6iORkt2Q5b6/rgC0R8UY6e8nbq40kfQaYB34/M/uYfRoRTwz+hEL8LfDdiHhZ0r8nuaL6UInfP84m4KaIeD0zr+ptlrvGBoKoyb2Up0mXpJ9KOjkink9PXC+M+KhPAt+LiFczn93LHb8s6dvAfyozXRGxP318UtLdwLuAv6Hi7SXpN4Dvk2QC7sl89pK31wDDjpdB6zwn6TjgN0mOp0neW2S6kHQuSXD9/Yh4uTd/yD7N66Q2Nm0RcTDz8hqSeqHeez/Q9967y0pXxibgy9kZBW+zcYalfabt1eWioV/dS1lJK5dNwO5Ial5691KGfO+lvDv9vEk+95hyyfRk2CuXvwgY2LKgiHRJWtUrWpF0IvB+4JGqt1e6775HUm56U9+yPLfXwONlRHovBu5Mt89uYJOSVkWnA2cC/zBDWqZKl6R3Af8TuDAiXsjMH7hPc0rXpGk7OfPyQpLb2UJyJfzRNI2rgI9y9NVxoelK0/Z2korXH2bmFb3NxtkN/Lu09dB7gV+mGZ7ZtldRtd9VTsDHScrIXgZ+Ctyazn8rcEtmvQuAx0mi+RWZ+WeQ/FH3AX8NHJ9TutYAdwB7gduB1en8eeCazHrrSSL8sr733wk8RHJC2wWcUFa6gH+VfvcD6eMX6rC9gM8ArwL3Z6azi9heg44XkqKmC9Pnb0p//750e5yRee8V6fseAz6W8/E+Ll23p/+D3vbZPW6flpi2/w7sSdNwF/D2zHv/KN2W+4DPl5mu9PXXgav63lfoNiPJ/D2fHtPPkdTpXAJcki4X8I003Q+RaRU5y/byEBNmZh3X5aIhMzPDgcDMrPMcCMzMOs6BwMys4xwIzMw6zoHAzKzjHAjMzDru/wPTby8hcT1iEgAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " 读者不妨自己调节数据集的参数设置来生成属于自己的数据集吧！\n" - ] - } - ], - "source": [ - "# 生成自己的数据集\n", - "train_x, train_y, test_x, test_y = circle_data_point_generator(Ntrain, Ntest, boundary_gap, seed_data)\n", - "\n", - "# 打印数据集的维度信息\n", - "print(\"训练集 {} 个数据点的可视化：\".format(Ntrain))\n", - "data_point_plot(train_x, train_y)\n", - "print(\"测试集 {} 个数据点的可视化：\".format(Ntest))\n", - "data_point_plot(test_x, test_y)\n", - "print(\"\\n 读者不妨自己调节数据集的参数设置来生成属于自己的数据集吧！\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 数据的预处理\n", - "\n", - "与经典机器学习不同的是，量子分类器在实际工作的时候需要考虑数据的预处理。我们需要多加一个步骤将经典的数据转化成量子信息才能放在量子计算机上运行。此处我们采用角度编码方式得到量子数据。\n", - "\n", - "首先我们确定需要使用的量子比特数量。因为我们的数据 $\\{x^{k} = (x^{k}_0, x^{k}_1)\\}$ 是二维的, 按照 Mitarai (2018) 论文[1]中的编码方式我们至少需要2个量子比特。接着准备一系列的初始量子态 $|00\\rangle$。然后将经典信息 $\\{x^{k}\\}$ 编码成一系列量子门 $U(x^{k})$ 并作用在初始量子态上。最终得到一系列的量子态 $|\\psi_{\\rm in}\\rangle^k = U(x^{k})|00\\rangle$。这样我们就完成从经典信息到量子信息的编码了！\n", - "\n", - "给定 $m$ 个量子比特去编码二维的经典数据点，采用角度编码，量子门的构造为：\n", - "\n", - "$$\n", - "U(x^{k}) = \\otimes_{j=0}^{m-1} R_j^z\\big[\\arccos(x^{k}_{j \\, \\text{mod} \\, 2}\\cdot x^{k}_{j \\, \\text{mod} \\, 2})\\big] R_j^y\\big[\\arcsin(x^{k}_{j \\, \\text{mod} \\, 2}) \\big],\\tag{2}\n", - "$$\n", - "\n", - "**注意** ：这种表示下，我们将第一个量子比特编号为 $j = 0$。更多编码方式见 [Robust data encodings for quantum classifiers](https://arxiv.org/pdf/2003.01695.pdf)。读者也可以直接使用量桨中提供的[编码方式](./DataEncoding_CN.ipynb)。这里我们也欢迎读者自己创新尝试全新的编码方式。\n", - "\n", - "由于这种编码的方式看着比较复杂，我们不妨来举一个简单的例子。假设我们给定一个数据点 $x = (x_0, x_1)= (1,0)$, 显然这个数据点的标签应该为 1，对应上图**蓝色**的点。同时数据点对应的2比特量子门 $U(x)$ 是\n", - "\n", - "$$\n", - "U(x) = \n", - "\\bigg( R_0^z\\big[\\arccos(x_{0}\\cdot x_{0})\\big] R_0^y\\big[\\arcsin(x_{0}) \\big] \\bigg)\n", - "\\otimes \n", - "\\bigg( R_1^z\\big[\\arccos(x_{1}\\cdot x_{1})\\big] R_1^y\\big[\\arcsin(x_{1}) \\big] \\bigg),\\tag{3}\n", - "$$\n", - "\n", - "\n", - "把具体的数值带入我们就能得到：\n", - "$$\n", - "U(x) = \n", - "\\bigg( R_0^z\\big[0\\big] R_0^y\\big[\\pi/2 \\big] \\bigg)\n", - "\\otimes \n", - "\\bigg( R_1^z\\big[\\pi/2\\big] R_1^y\\big[0 \\big] \\bigg),\n", - "\\tag{4}\n", - "$$\n", - "\n", - "以下是常用的旋转门的矩阵形式：\n", - "\n", - "\n", - "$$\n", - "R_x(\\theta) :=\n", - "\\begin{bmatrix}\n", - "\\cos \\frac{\\theta}{2} &-i\\sin \\frac{\\theta}{2} \\\\\n", - "-i\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2}\n", - "\\end{bmatrix}\n", - ",\\quad\n", - "R_y(\\theta) :=\n", - "\\begin{bmatrix}\n", - "\\cos \\frac{\\theta}{2} &-\\sin \\frac{\\theta}{2} \\\\\n", - "\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2}\n", - "\\end{bmatrix}\n", - ",\\quad\n", - "R_z(\\theta) :=\n", - "\\begin{bmatrix}\n", - "e^{-i\\frac{\\theta}{2}} & 0 \\\\\n", - "0 & e^{i\\frac{\\theta}{2}}\n", - "\\end{bmatrix}.\n", - "\\tag{5}\n", - "$$\n", - "\n", - "那么这个两比特量子门 $U(x)$ 的矩阵形式可以写为：\n", - "\n", - "$$\n", - "U(x) = \n", - "\\bigg(\n", - "\\begin{bmatrix}\n", - "1 & 0 \\\\ \n", - "0 & 1\n", - "\\end{bmatrix}\n", - "\\begin{bmatrix}\n", - "\\cos \\frac{\\pi}{4} &-\\sin \\frac{\\pi}{4} \\\\ \n", - "\\sin \\frac{\\pi}{4} &\\cos \\frac{\\pi}{4} \n", - "\\end{bmatrix}\n", - "\\bigg)\n", - "\\otimes \n", - "\\bigg(\n", - "\\begin{bmatrix}\n", - "e^{-i\\frac{\\pi}{4}} & 0 \\\\ \n", - "0 & e^{i\\frac{\\pi}{4}}\n", - "\\end{bmatrix}\n", - "\\begin{bmatrix}\n", - "1 &0 \\\\ \n", - "0 &1\n", - "\\end{bmatrix}\n", - "\\bigg)\\, .\\tag{6}\n", - "$$\n", - "\n", - "化简后我们作用在零初始化的 $|00\\rangle$ 量子态上可以得到编码后的量子态 $|\\psi_{\\rm in}\\rangle$，\n", - "\n", - "$$\n", - "|\\psi_{\\rm in}\\rangle =\n", - "U(x)|00\\rangle = \\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "1-i &0 &-1+i &0 \\\\ \n", - "0 &1+i &0 &-1-i \\\\\n", - "1-i &0 &1-i &0 \\\\\n", - "0 &1+i &0 &1+i \n", - "\\end{bmatrix}\n", - "\\begin{bmatrix}\n", - "1 \\\\\n", - "0 \\\\\n", - "0 \\\\\n", - "0\n", - "\\end{bmatrix}\n", - "= \\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "1-i \\\\\n", - "0 \\\\\n", - "1-i \\\\\n", - "0\n", - "\\end{bmatrix}.\\tag{7}\n", - "$$\n", - "\n", - "接着我们来看看代码上怎么实现这种编码方式。需要注意的是：代码中使用了一个张量积来表述\n", - "\n", - "$$\n", - "(U_1 |0\\rangle)\\otimes (U_2 |0\\rangle) = (U_1 \\otimes U_2) |0\\rangle\\otimes|0\\rangle\n", - "= (U_1 \\otimes U_2) |00\\rangle.\\tag{8}\n", - "$$" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T09:15:06.589265Z", - "start_time": "2021-03-02T09:15:06.452691Z" - } - }, - "outputs": [], - "source": [ - "# 构建绕 Y 轴，绕 Z 轴旋转 theta 角度矩阵\n", - "def Ry(theta):\n", - " \"\"\"\n", - " :param theta: 参数\n", - " :return: Y 旋转矩阵\n", - " \"\"\"\n", - " return np.array([[np.cos(theta / 2), -np.sin(theta / 2)],\n", - " [np.sin(theta / 2), np.cos(theta / 2)]])\n", - "\n", - "def Rz(theta):\n", - " \"\"\"\n", - " :param theta: 参数\n", - " :return: Z 旋转矩阵\n", - " \"\"\"\n", - " return np.array([[np.cos(theta / 2) - np.sin(theta / 2) * 1j, 0],\n", - " [0, np.cos(theta / 2) + np.sin(theta / 2) * 1j]])\n", - "\n", - "# 经典 -> 量子数据编码器\n", - "def datapoints_transform_to_state(data, n_qubits):\n", - " \"\"\"\n", - " :param data: 形状为 [-1, 2]，numpy向量形式\n", - " :param n_qubits: 数据转化后的量子比特数量\n", - " :return: 形状为 [-1, 1, 2 ^ n_qubits]\n", - " 形状中-1表示第一个参数为任意大小。在此教程实例分析中，对应于BATCH，用以得到Eq.(1)中平方误差的平均值\n", - " \"\"\"\n", - " dim1, dim2 = data.shape\n", - " res = []\n", - " for sam in range(dim1):\n", - " res_state = 1.\n", - " zero_state = np.array([[1, 0]])\n", - " # 角度编码\n", - " for i in range(n_qubits):\n", - " # 对偶数编号量子态作用 Rz(arccos(x0^2)) Ry(arcsin(x0))\n", - " if i % 2 == 0:\n", - " state_tmp=np.dot(zero_state, Ry(np.arcsin(data[sam][0])).T)\n", - " state_tmp=np.dot(state_tmp, Rz(np.arccos(data[sam][0] ** 2)).T)\n", - " res_state=np.kron(res_state, state_tmp)\n", - " # 对奇数编号量子态作用 Rz(arccos(x1^2)) Ry(arcsin(x1))\n", - " elif i % 2 == 1:\n", - " state_tmp=np.dot(zero_state, Ry(np.arcsin(data[sam][1])).T)\n", - " state_tmp=np.dot(state_tmp, Rz(np.arccos(data[sam][1] ** 2)).T)\n", - " res_state=np.kron(res_state, state_tmp)\n", - " res.append(res_state)\n", - " res = np.array(res)\n", - "\n", - " return res.astype(\"complex128\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "测试角度编码下得到的量子数据" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "作为测试我们输入以上的经典信息:\n", - "(x_0, x_1) = (1, 0)\n", - "编码后输出的2比特量子态为:\n", - "[[[0.5-0.5j 0. +0.j 0.5-0.5j 0. +0.j ]]]\n" - ] - } - ], - "source": [ - "print(\"作为测试我们输入以上的经典信息:\")\n", - "print(\"(x_0, x_1) = (1, 0)\")\n", - "print(\"编码后输出的2比特量子态为:\")\n", - "print(datapoints_transform_to_state(np.array([[1, 0]]), n_qubits=2))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 构造量子神经网络\n", - "\n", - "那么在完成上述从经典数据到量子数据的编码后，我们现在可以把这些量子态输入到量子计算机里面了。在那之前，我们还需要设计下我们所采用的量子神经网络结构。\n", - "\n", - " \n", - "
图 3：参数化量子神经网络的电路结构
\n", - "\n", - "为了方便，我们统一将上述参数化的量子神经网络称为 $U(\\boldsymbol{\\theta})$。这个 $U(\\boldsymbol{\\theta})$ 是我们分类器的关键组成部分，需要一定的复杂结构来拟合我们的决策边界。与经典神经网络类似，量子神经网络的的设计并不是唯一的，这里展示的仅仅是一个例子，读者不妨自己设计出自己的量子神经网络。我们还是拿原来提过的这个数据点 $x = (x_0, x_1)= (1,0)$ 来举例子，编码过后我们已经得到了一个量子态 $|\\psi_{\\rm in}\\rangle$，\n", - "\n", - "$$\n", - "|\\psi_{\\rm in}\\rangle =\n", - "\\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "1-i \\\\\n", - "0 \\\\\n", - "1-i \\\\\n", - "0\n", - "\\end{bmatrix},\\tag{9}\n", - "$$\n", - "\n", - "接着我们把这个量子态输入进我们的量子神经网络，也就是把一个酉矩阵乘以一个向量。得到处理过后的量子态 $|\\psi_{\\rm out}\\rangle$\n", - "\n", - "$$\n", - "|\\psi_{\\rm out}\\rangle = U(\\boldsymbol{\\theta})|\\psi_{\\rm in}\\rangle,\\tag{10}\n", - "$$\n", - "\n", - "如果我们把所有的参数 $\\theta$ 都设置为 $\\theta = \\pi$, 那么我们就可以写出具体的矩阵了：\n", - "\n", - "$$\n", - "|\\psi_{\\rm out}\\rangle = \n", - "U(\\boldsymbol{\\theta} =\\pi)|\\psi_{\\rm in}\\rangle =\n", - "\\begin{bmatrix}\n", - "0 &0 &-1 &0 \\\\ \n", - "-1 &0 &0 &0 \\\\\n", - "0 &1 &0 &0 \\\\\n", - "0 &0 &0 &1 \n", - "\\end{bmatrix}\n", - "\\cdot\n", - "\\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "1-i \\\\\n", - "0 \\\\\n", - "1-i \\\\\n", - "0\n", - "\\end{bmatrix}\n", - "= \\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "-1+i \\\\\n", - "-1+i \\\\\n", - "0 \\\\\n", - "0\n", - "\\end{bmatrix}.\\tag{11}\n", - "$$" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T09:15:06.795398Z", - "start_time": "2021-03-02T09:15:06.782149Z" - } - }, - "outputs": [], - "source": [ - "# 模拟搭建量子神经网络\n", - "def cir_Classifier(theta, n, depth): \n", - " \"\"\"\n", - " :param theta: 维数: [n, depth + 3] -- 初始增加一层广义旋转门\n", - " :param n: 量子比特数量\n", - " :param depth: 电路深度\n", - " :return: U_theta\n", - " \"\"\"\n", - " # 初始化网络\n", - " cir = UAnsatz(n)\n", - "\n", - " # 先搭建广义的旋转层\n", - " for i in range(n):\n", - " cir.rz(theta[i][0], i)\n", - " cir.ry(theta[i][1], i)\n", - " cir.rz(theta[i][2], i)\n", - "\n", - " # 默认深度为 depth = 1\n", - " # 对每一层搭建电路\n", - " for d in range(3, depth + 3):\n", - " # 搭建纠缠层\n", - " for i in range(n-1):\n", - " cir.cnot([i, i + 1])\n", - " cir.cnot([n-1, 0])\n", - " # 对每一个量子比特搭建Ry\n", - " for i in range(n):\n", - " cir.ry(theta[i][d], i)\n", - "\n", - " return cir" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 测量\n", - "\n", - "经过量子神经网络$U(\\theta)$后，得到是量子态$\\lvert \\psi_{\\rm out}\\rangle^k = U(\\theta)\\lvert \\psi_{\\rm in} \\rangle^k$。要想得到该量子态的标签，我们需要通过测量来得到经典信息。然后再通过这些处理后的经典信息计算损失函数 $\\mathcal{L}(\\boldsymbol{\\theta})$。最后再通过梯度下降算法来不断更新 QNN 参数 $\\boldsymbol{\\theta}$，并优化损失函数。\n", - "\n", - "\n", - "这里我们采用的测量方式是测量泡利 $Z$ 算符在第一个量子比特上的期望值。 具体来说，\n", - "\n", - "$$\n", - "\\langle Z \\rangle = \n", - "\\langle \\psi_{\\rm out} |Z\\otimes I\\cdots \\otimes I| \\psi_{\\rm out}\\rangle,\\tag{12}\n", - "$$\n", - "\n", - "复习一下，泡利 $Z$ 算符的矩阵形式为：\n", - "\n", - "$$\n", - "Z := \\begin{bmatrix} 1 &0 \\\\ 0 &-1 \\end{bmatrix},\\tag{13}\n", - "$$\n", - "\n", - "继续我们前面的 2 量子比特的例子，测量过后我们得到的期望值就是：\n", - "$$\n", - "\\langle Z \\rangle = \n", - "\\langle \\psi_{\\rm out} |Z\\otimes I| \\psi_{\\rm out}\\rangle = \n", - "\\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "-1-i \\quad\n", - "-1-i \\quad\n", - "0 \\quad\n", - "0\n", - "\\end{bmatrix}\n", - "\\begin{bmatrix}\n", - "1 &0 &0 &0 \\\\ \n", - "0 &1 &0 &0 \\\\\n", - "0 &0 &-1 &0 \\\\\n", - "0 &0 &0 &-1 \n", - "\\end{bmatrix}\n", - "\\cdot\n", - "\\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "-1+i \\\\\n", - "-1+i \\\\\n", - "0 \\\\\n", - "0\n", - "\\end{bmatrix}\n", - "= 1,\\tag{14}\n", - "$$\n", - "\n", - "好奇的读者或许会问，这个测量结果好像就是我们原来的标签 1 ，这是不是意味着我们已经成功的分类这个数据点了？其实并不然，因为 $\\langle Z \\rangle$ 的取值范围通常在 $[-1,1]$之间。 为了对应我们的标签范围 $y^{k} \\in \\{0,1\\}$, 我们还需要将区间上下限映射上。这个映射最简单的做法就是让\n", - "\n", - "$$\n", - "\\tilde{y}^{k} = \\frac{\\langle Z \\rangle}{2} + \\frac{1}{2} + bias \\quad \\in [0, 1].\\tag{15}\n", - "$$\n", - "\n", - "其中加入偏置（bias）是机器学习中的一个小技巧，目的就是为了让决策边界不受制于原点或者一些超平面。一般我们默认偏置初始化为0，并且优化器在迭代过程中会类似于参数 $\\theta$ 一样不断更新偏置确保 $\\tilde{y}^{k} \\in [0, 1]$。当然读者也可以选择其他复杂的映射（激活函数）比如说 sigmoid 函数。映射过后我们就可以把 $\\tilde{y}^{k}$ 看作是我们估计出的标签（label）了。如果 $\\tilde{y}^{k}< 0.5$ 就对应标签 0，如果 $\\tilde{y}^{k}> 0.5$ 就对应标签 1。 我们稍微复习一下整个流程，\n", - "\n", - "\n", - "$$\n", - "x^{k} \\rightarrow |\\psi_{\\rm in}\\rangle^{k} \\rightarrow U(\\boldsymbol{\\theta})|\\psi_{\\rm in}\\rangle^{k} \\rightarrow\n", - "|\\psi_{\\rm out}\\rangle^{k} \\rightarrow ^{k}\\langle \\psi_{\\rm out} |Z\\otimes I\\cdots \\otimes I| \\psi_{\\rm out} \\rangle^{k}\n", - "\\rightarrow \\langle Z \\rangle \\rightarrow \\tilde{y}^{k}.\\tag{16}\n", - "$$\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 损失函数\n", - "\n", - "相比于公式(1)中损失函数，需要在每次迭代中对所有 Ntrain 个数据点进行测量计算，在实际应用中，我们将训练集中的数据拆分为 \"Ntrain/BATCH\" 组，其中每组包含BATCH个数据。\n", - "\n", - "对第 i 组数据，训练对应损失函数：\n", - "$$\n", - "\\mathcal{L}_{i} = \\sum_{k=1}^{BATCH} \\frac{1}{BATCH} |y^{i,k} - \\tilde{y}^{i,k}|^2,\\tag{17}\n", - "$$\n", - "并对每一组训练 EPOCH 次。\n", - "\n", - "当取 \"BATCH = Ntrain\"，此时仅有一组数据点，Eq. (17)重新变为Eq. (1)。\n" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T09:15:07.667491Z", - "start_time": "2021-03-02T09:15:07.661325Z" - } - }, - "outputs": [], - "source": [ - "# 生成只作用在第一个量子比特上的泡利 Z 算符\n", - "# 其余量子比特上都作用单位矩阵\n", - "def Observable(n):\n", - " r\"\"\"\n", - " :param n: 量子比特数量\n", - " :return: 局部可观测量: Z \\otimes I \\otimes ...\\otimes I\n", - " \"\"\"\n", - " Ob = pauli_str_to_matrix([[1.0, 'z0']], n)\n", - "\n", - " return Ob" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "# 搭建整个优化流程图\n", - "class Opt_Classifier(paddle.nn.Layer):\n", - " \"\"\"\n", - " 创建模型训练网络\n", - " \"\"\"\n", - " def __init__(self, n, depth, seed_paras=1, dtype='float64'):\n", - " # 初始化部分，通过n, depth给出初始电路\n", - " super(Opt_Classifier, self).__init__()\n", - " self.n = n\n", - " self.depth = depth\n", - " # 初始化参数列表 theta，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " self.theta = self.create_parameter(\n", - " shape=[n, depth + 3], # 此处使用量子电路有初始一层广义旋转门，故+3\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype,\n", - " is_bias=False)\n", - " # 初始化偏置 (bias)\n", - " self.bias = self.create_parameter(\n", - " shape=[1],\n", - " default_initializer=paddle.nn.initializer.Normal(std=0.01),\n", - " dtype=dtype,\n", - " is_bias=False)\n", - "\n", - " # 定义前向传播机制、计算损失函数 和交叉验证正确率\n", - " def forward(self, state_in, label):\n", - " \"\"\"\n", - " 输入： state_in：输入量子态，shape: [-1, 1, 2^n] -- 此教程中为[BATCH, 1, 2^n]\n", - " label：输入量子态对应标签，shape: [-1, 1]\n", - " 计算损失函数:\n", - " L = 1/BATCH * (( + 1)/2 + bias - label)^2\n", - " \"\"\"\n", - " # 将 Numpy array 转换成 tensor\n", - " Ob = paddle.to_tensor(Observable(self.n))\n", - " label_pp = reshape(paddle.to_tensor(label), [-1, 1])\n", - "\n", - " # 按照随机初始化的参数 theta \n", - " cir = cir_Classifier(self.theta, n=self.n, depth=self.depth)\n", - " Utheta = cir.U\n", - "\n", - " # 因为 Utheta是学习到的，我们这里用行向量运算来提速而不会影响训练效果\n", - " state_out = matmul(state_in, Utheta) # [-1, 1, 2 ** n]形式，第一个参数在此教程中为BATCH\n", - "\n", - " # 测量得到泡利 Z 算符的期望值 -- shape [-1,1,1]\n", - " E_Z = matmul(matmul(state_out, Ob), transpose(paddle.conj(state_out), perm=[0, 2, 1]))\n", - "\n", - " # 映射 处理成标签的估计值 \n", - " state_predict = paddle.real(E_Z)[:, 0] * 0.5 + 0.5 + self.bias # 计算每一个y^{i,k}与真实值得平方差\n", - " loss = paddle.mean((state_predict - label_pp) ** 2) # 对BATCH个得到的平方差取平均，得到L_i：shape:[1,1]\n", - "\n", - " # 计算交叉验证正确率\n", - " is_correct = (paddle.abs(state_predict - label_pp) < 0.5).nonzero().shape[0]\n", - " acc = is_correct / label.shape[0]\n", - "\n", - " return loss, acc, state_predict.numpy(), cir" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 训练过程\n", - "\n", - "好了， 那么定义完以上所有的概念之后我们不妨来看看实际的训练过程！" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# 用于绘制最终训练得到分类器的平面分类图\n", - "def heatmap_plot(Opt_Classifier, N):\n", - " # 生成数据点 x_y_\n", - " Num_points = 30\n", - " x_y_ = []\n", - " for row_y in np.linspace(0.9, -0.9, Num_points):\n", - " row = []\n", - " for row_x in np.linspace(-0.9, 0.9, Num_points):\n", - " row.append([row_x, row_y])\n", - " x_y_.append(row)\n", - " x_y_ = np.array(x_y_).reshape(-1, 2).astype(\"float64\")\n", - "\n", - " # 计算预测: heat_data\n", - " input_state_test = paddle.to_tensor(\n", - " datapoints_transform_to_state(x_y_, N))\n", - " loss_useless, acc_useless, state_predict, cir = Opt_Classifier(state_in=input_state_test, label=x_y_[:, 0])\n", - " heat_data = state_predict.reshape(Num_points, Num_points)\n", - "\n", - " # 画图\n", - " fig = plt.figure(1)\n", - " ax = fig.add_subplot(111)\n", - " x_label = np.linspace(-0.9, 0.9, 3)\n", - " y_label = np.linspace(0.9, -0.9, 3)\n", - " ax.set_xticks([0, Num_points // 2, Num_points - 1])\n", - " ax.set_xticklabels(x_label)\n", - " ax.set_yticks([0, Num_points // 2, Num_points - 1])\n", - " ax.set_yticklabels(y_label)\n", - " im = ax.imshow(heat_data, cmap=plt.cm.RdBu)\n", - " plt.colorbar(im)\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "通过 Adam 优化器不断学习训练" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "def QClassifier(Ntrain, Ntest, gap, N, DEPTH, EPOCH, LR, BATCH, seed_paras, seed_data):\n", - " \"\"\"\n", - " 量子二分类器\n", - " 输入参数：\n", - " Ntrain, # 规定训练集大小\n", - " Ntest, # 规定测试集大小\n", - " gap, # 设定决策边界的宽度\n", - " N, # 所需的量子比特数量\n", - " DEPTH, # 采用的电路深度\n", - " BATCH, # 训练时 batch 的大小\n", - " EPOCH, # 训练 epoch 轮数\n", - " LR, # 设置学习速率\n", - " seed_paras, # 设置随机种子用以初始化各种参数\n", - " seed_data, # 固定生成数据集所需要的随机种子\n", - " \"\"\"\n", - " # 生成训练集测试集\n", - " train_x, train_y, test_x, test_y = circle_data_point_generator(Ntrain=Ntrain, Ntest=Ntest, boundary_gap=gap, seed_data=seed_data)\n", - " # 读取训练集的维度\n", - " N_train = train_x.shape[0]\n", - "\n", - " paddle.seed(seed_paras)\n", - " # 初始化寄存器存储正确率 acc 等信息\n", - " summary_iter, summary_test_acc = [], []\n", - "\n", - " # 一般来说，我们利用Adam优化器来获得相对好的收敛\n", - " # 当然你可以改成SGD或者是RMSprop\n", - " myLayer = Opt_Classifier(n=N, depth=DEPTH) # 得到初始化量子电路\n", - " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=myLayer.parameters())\n", - "\n", - "\n", - " # 优化循环\n", - " # 此处将训练集分为Ntrain/BATCH组数据，对每一组训练后得到的量子线路作为下一组数据训练的初始量子电路\n", - " # 故通过cir记录每组数据得到的最终量子线路\n", - " i = 0 # 记录总迭代次数\n", - " for ep in range(EPOCH):\n", - " # 将训练集分组，对每一组训练\n", - " for itr in range(N_train // BATCH):\n", - " i += 1 # 记录总迭代次数\n", - " # 将经典数据编码成量子态 |psi>, 维度 [BATCH, 2 ** N]\n", - " input_state = paddle.to_tensor(datapoints_transform_to_state(train_x[itr * BATCH:(itr + 1) * BATCH], N))\n", - "\n", - " # 前向传播计算损失函数\n", - " loss, train_acc, state_predict_useless, cir \\\n", - " = myLayer(state_in=input_state, label=train_y[itr * BATCH:(itr + 1) * BATCH]) # 对此时量子电路优化\n", - " # 显示迭代过程中performance变化\n", - " if i % 30 == 5:\n", - " # 计算测试集上的正确率 test_acc\n", - " input_state_test = paddle.to_tensor(datapoints_transform_to_state(test_x, N))\n", - " loss_useless, test_acc, state_predict_useless, t_cir \\\n", - " = myLayer(state_in=input_state_test,label=test_y)\n", - " print(\"epoch:\", ep, \"iter:\", itr,\n", - " \"loss: %.4f\" % loss.numpy(),\n", - " \"train acc: %.4f\" % train_acc,\n", - " \"test acc: %.4f\" % test_acc)\n", - " # 存储正确率 acc 等信息\n", - " summary_iter.append(itr + ep * N_train)\n", - " summary_test_acc.append(test_acc) \n", - "\n", - " # 反向传播极小化损失函数\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - "\n", - " # 得到训练后电路\n", - " print(\"训练后的电路：\")\n", - " print(cir)\n", - " # 画出 heatmap 表示的决策边界\n", - " heatmap_plot(myLayer, N=N)\n", - "\n", - " return summary_test_acc" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "训练集的维度大小 x (200, 2) 和 y (200, 1)\n", - "测试集的维度大小 x (100, 2) 和 y (100, 1) \n", - "\n", - "epoch: 0 iter: 4 loss: 0.1547 train acc: 0.8500 test acc: 0.6400\n", - "epoch: 3 iter: 4 loss: 0.1337 train acc: 0.9500 test acc: 0.8800\n", - "epoch: 6 iter: 4 loss: 0.1265 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 9 iter: 4 loss: 0.1247 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 12 iter: 4 loss: 0.1261 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 15 iter: 4 loss: 0.1268 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 18 iter: 4 loss: 0.1269 train acc: 1.0000 test acc: 1.0000\n", - "训练后的电路：\n", - "--Rz(0.542)----Ry(3.458)----Rz(2.692)----*--------------x----Ry(6.191)--\n", - " | | \n", - "--Rz(3.514)----Ry(1.543)----Rz(2.499)----x----*---------|----Ry(2.968)--\n", - " | | \n", - "--Rz(5.947)----Ry(3.161)----Rz(3.897)---------x----*----|----Ry(1.579)--\n", - " | | \n", - "--Rz(0.718)----Ry(5.038)----Rz(1.348)--------------x----*----Ry(0.036)--\n", - " \n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "主程序段总共运行了 6.890974283218384 秒\n" - ] - } - ], - "source": [ - "def main():\n", - " \"\"\"\n", - " 主函数\n", - " \"\"\"\n", - " time_start = time.time()\n", - " acc = QClassifier(\n", - " Ntrain = 200, # 规定训练集大小\n", - " Ntest = 100, # 规定测试集大小\n", - " gap = 0.5, # 设定决策边界的宽度\n", - " N = 4, # 所需的量子比特数量\n", - " DEPTH = 1, # 采用的电路深度\n", - " BATCH = 20, # 训练时 batch 的大小\n", - " EPOCH = int(200 * BATCH / Ntrain), \n", - " # 训练 epoch 轮数，使得总迭代次数 EPOCH * (Ntrain / BATCH) 在200左右\n", - " LR = 0.01, # 设置学习速率\n", - " seed_paras = 19, # 设置随机种子用以初始化各种参数\n", - " seed_data = 2, # 固定生成数据集所需要的随机种子\n", - " )\n", - " \n", - " time_span = time.time() - time_start\n", - " print('主程序段总共运行了', time_span, '秒')\n", - "\n", - "if __name__ == '__main__':\n", - " main()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "通过打印训练结果可以看到不断优化后分类器在测试集和数据集的正确率都达到了 $100\\%$。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 研究不同的编码方式\n", - "\n", - "监督学习的编码方式对分类结果有很大影响 [4]。在量桨中，我们集成了常用的编码方式，包括振幅编码、角度编码、IQP编码等。 用户可以用内置的 ``SimpleDataset`` 类实例对简单分类数据（不需要降维的数据）进行编码；也可以用内置的 ``VisionDataset`` 类实例对图片数据进行编码。编码的方法都是调用类对象的 ``encode`` 方法。" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "(100, 4)\n" - ] - } - ], - "source": [ - "# 使用前面构建的圆形数据集研究编码\n", - "from paddle_quantum.dataset import *\n", - "\n", - "# 用两个量子比特编码二维数据\n", - "quantum_train_x = SimpleDataset(2).encode(train_x, 'angle_encoding', 2)\n", - "quantum_test_x = SimpleDataset(2).encode(test_x, 'angle_encoding', 2)\n", - "\n", - "print(type(quantum_test_x)) # ndarray\n", - "print(quantum_test_x.shape) # (100, 4)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "这里我们对上面的分类器进行化简，之后的所有分类都采用这个分类器。" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "# 简化的分类器\n", - "def QClassifier2(quantum_train_x, train_y,quantum_test_x,test_y, N, DEPTH, EPOCH, LR, BATCH):\n", - " \"\"\"\n", - " 量子二分类分类器\n", - " 输入：\n", - " quantum_train_x # 训练特征\n", - " train_y # 训练标签\n", - " quantum_test_x # 测试特征\n", - " test_y # 测试标签\n", - " N # 使用的量子比特数目\n", - " DEPTH # 分类器电路的深度\n", - " EPOCH # 迭代次数\n", - " LR # 学习率\n", - " BATCH # 一个批量的大小\n", - " \"\"\"\n", - " Ntrain = len(quantum_train_x)\n", - " \n", - " paddle.seed(1)\n", - "\n", - " net = Opt_Classifier(n=N, depth=DEPTH)\n", - "\n", - " # 测试准确率列表\n", - " summary_iter, summary_test_acc = [], []\n", - "\n", - " # 这里用 Adam，但是也可以是 SGD 或者 RMSprop\n", - " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", - "\n", - " # 进行优化\n", - " for ep in range(EPOCH):\n", - " for itr in range(Ntrain // BATCH):\n", - " # 导入数据\n", - " input_state = quantum_train_x[itr * BATCH:(itr + 1) * BATCH] # paddle.tensor类型\n", - " input_state = reshape(input_state, [-1, 1, 2 ** N])\n", - " label = train_y[itr * BATCH:(itr + 1) * BATCH]\n", - " test_input_state = reshape(quantum_test_x, [-1, 1, 2 ** N])\n", - "\n", - " loss, train_acc, state_predict_useless, cir = net(state_in=input_state, label=label)\n", - "\n", - " if itr % 5 == 0:\n", - " # 获取测试准确率\n", - " loss_useless, test_acc, state_predict_useless, t_cir = net(state_in=test_input_state, label=test_y)\n", - " print(\"epoch:\", ep, \"iter:\", itr,\n", - " \"loss: %.4f\" % loss.numpy(),\n", - " \"train acc: %.4f\" % train_acc,\n", - " \"test acc: %.4f\" % test_acc)\n", - " summary_test_acc.append(test_acc)\n", - "\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - "\n", - " return summary_test_acc" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "现在可以开始用不同编码方式对上面产生的圆形数据进行编码。这里我们采用五种编码方法：振幅编码、角度编码、泡利旋转编码、IQP编码、复杂纠缠编码。然后我们绘制出测试精度曲线以便分析。" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Encoding method: amplitude_encoding\n", - "epoch: 0 iter: 0 loss: 0.3066 train acc: 0.4000 test acc: 0.5400\n", - "epoch: 0 iter: 5 loss: 0.2378 train acc: 0.7000 test acc: 0.7000\n", - "epoch: 0 iter: 10 loss: 0.2308 train acc: 0.8000 test acc: 0.6700\n", - "epoch: 0 iter: 15 loss: 0.2230 train acc: 0.8000 test acc: 0.6100\n", - "Encoding method: angle_encoding\n", - "epoch: 0 iter: 0 loss: 0.2949 train acc: 0.5000 test acc: 0.3600\n", - "epoch: 0 iter: 5 loss: 0.1770 train acc: 0.7000 test acc: 0.7000\n", - "epoch: 0 iter: 10 loss: 0.1654 train acc: 0.8000 test acc: 0.7000\n", - "epoch: 0 iter: 15 loss: 0.1966 train acc: 0.7000 test acc: 0.5800\n", - "Encoding method: pauli_rotation_encoding\n", - "epoch: 0 iter: 0 loss: 0.2433 train acc: 0.6000 test acc: 0.7000\n", - "epoch: 0 iter: 5 loss: 0.2142 train acc: 0.7000 test acc: 0.7000\n", - "epoch: 0 iter: 10 loss: 0.2148 train acc: 0.7000 test acc: 0.7000\n", - "epoch: 0 iter: 15 loss: 0.2019 train acc: 0.8000 test acc: 0.7600\n", - "Encoding method: IQP_encoding\n", - "epoch: 0 iter: 0 loss: 0.2760 train acc: 0.6000 test acc: 0.4200\n", - "epoch: 0 iter: 5 loss: 0.1916 train acc: 0.6000 test acc: 0.6200\n", - "epoch: 0 iter: 10 loss: 0.1355 train acc: 0.9000 test acc: 0.7300\n", - "epoch: 0 iter: 15 loss: 0.1289 train acc: 0.9000 test acc: 0.6700\n", - "Encoding method: complex_entangled_encoding\n", - "epoch: 0 iter: 0 loss: 0.3274 train acc: 0.3000 test acc: 0.2900\n", - "epoch: 0 iter: 5 loss: 0.2120 train acc: 0.7000 test acc: 0.7000\n", - "epoch: 0 iter: 10 loss: 0.2237 train acc: 0.7000 test acc: 0.7000\n", - "epoch: 0 iter: 15 loss: 0.2095 train acc: 0.8000 test acc: 0.7200\n" - ] - } - ], - "source": [ - "# 测试不同编码方式\n", - "encoding_list = ['amplitude_encoding', 'angle_encoding', 'pauli_rotation_encoding', 'IQP_encoding', 'complex_entangled_encoding']\n", - "num_qubit = 2 # 这里需要小心，如果量子比特数目取 1，可能会报错，因为有 CNOT 门\n", - "dimension = 2\n", - "acc_list = []\n", - "\n", - "for i in range(len(encoding_list)):\n", - " encoding = encoding_list[i]\n", - " print(\"Encoding method:\", encoding)\n", - " # 用 SimpleDataset 类来编码数据，这里数据维度为 2，编码量子比特数目也是 2\n", - " quantum_train_x= SimpleDataset(dimension).encode(train_x, encoding, num_qubit)\n", - " quantum_test_x= SimpleDataset(dimension).encode(test_x, encoding, num_qubit)\n", - " quantum_train_x = paddle.to_tensor(quantum_train_x)\n", - " quantum_test_x = paddle.to_tensor(quantum_test_x)\n", - "\n", - " acc = QClassifier2(\n", - " quantum_train_x, # 训练特征\n", - " train_y, # 训练标签\n", - " quantum_test_x, # 测试特征\n", - " test_y, # 测试标签\n", - " N = num_qubit, # 使用的量子比特数目\n", - " DEPTH = 1, # 分类器电路的深度\n", - " EPOCH = 1, # 迭代次数\n", - " LR = 0.1, # 学习率\n", - " BATCH = 10, # 一个批量的大小\n", - " )\n", - " acc_list.append(acc)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 绘制五种编码方法的训练曲线\n", - "x=[2*i for i in range(len(acc_list[0]))]\n", - "for i in range(len(encoding_list)):\n", - " plt.plot(x,acc_list[i])\n", - "plt.legend(encoding_list)\n", - "plt.title(\"Benchmarking different encoding methods\")\n", - "plt.xlabel(\"Iteration\")\n", - "plt.ylabel(\"Test accuracy\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 用内置的 MNIST 和 Iris 数据集实现量子分类\n", - "\n", - "量桨将常用的分类数据集进行了编码，用户可以使用 `paddle_quantum.dataset` 模块获取编码的量子电路或者量子态。目前集成了4个数据集，包括 MNIST, FashionMNIST, Iris 和 BreastCancer。下面展示如何用这些内置数据集快速实现量子监督学习。\n", - "\n", - "我们从 Iris 数据集开始。Iris 数据集包括三种类别，每种类别有50个样本。数据集中只有四个特征，是比较简单且容易编码的数据集。" - ] - }, - { - "cell_type": "code", - "execution_count": 32, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 0 iter: 0 loss: 0.3543 train acc: 0.0000 test acc: 0.0000\n", - "epoch: 0 iter: 5 loss: 0.2697 train acc: 0.5000 test acc: 0.5000\n", - "epoch: 0 iter: 10 loss: 0.2139 train acc: 1.0000 test acc: 0.9000\n", - "epoch: 0 iter: 15 loss: 0.1989 train acc: 0.7500 test acc: 0.9000\n", - "epoch: 1 iter: 0 loss: 0.0859 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 1 iter: 5 loss: 0.0432 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 1 iter: 10 loss: 0.0432 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 1 iter: 15 loss: 0.0531 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 2 iter: 0 loss: 0.0374 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 2 iter: 5 loss: 0.0356 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 2 iter: 10 loss: 0.0377 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 2 iter: 15 loss: 0.0440 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 3 iter: 0 loss: 0.0317 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 3 iter: 5 loss: 0.0344 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 3 iter: 10 loss: 0.0384 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 3 iter: 15 loss: 0.0412 train acc: 1.0000 test acc: 1.0000\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Iris 数据集二分类\n", - "\n", - "test_rate=0.2\n", - "num_qubit=4\n", - "\n", - "# 获取 Iris 数据集的量子态\n", - "iris =Iris (encoding='angle_encoding', num_qubits=num_qubit, test_rate=test_rate,classes=[0, 1], return_state=True)\n", - "\n", - "quantum_train_x, train_y = iris.train_x, iris.train_y\n", - "quantum_test_x, test_y = iris.test_x, iris.test_y\n", - "testing_data_num = len(test_y)\n", - "training_data_num = len(train_y)\n", - "\n", - "acc = QClassifier2(\n", - " quantum_train_x, # 训练特征\n", - " train_y, # 训练标签\n", - " quantum_test_x, # 测试特征\n", - " test_y, # 测试标签\n", - " N = num_qubit, # 使用的量子比特数目\n", - " DEPTH = 1, # 分类器电路的深度\n", - " EPOCH = 4, # 迭代次数\n", - " LR = 0.1, # 学习率\n", - " BATCH = 4, # 一个批量的大小\n", - " )\n", - "plt.plot(acc)\n", - "plt.title(\"Classify Iris 0&1 using angle encoding\")\n", - "plt.xlabel(\"Iteration\")\n", - "plt.ylabel(\"Testing accuracy\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "第二个例子为 MNIST 数据集。 MNIST 是手写数字数据集，有 0-9 十个类别（每一类训练集中有 6000 个样本，测试集中有 1000 个样本）。所有的图片都是 $28\\times28$ 的灰度图，所以需要使用 ``resize`` 或 ``PCA`` 降维到目标维度 ``target_dimension`` 。" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 0 iter: 0 loss: 0.3237 train acc: 0.3250 test acc: 0.5450\n", - "epoch: 0 iter: 5 loss: 0.2124 train acc: 0.7500 test acc: 0.6500\n", - "epoch: 0 iter: 10 loss: 0.2294 train acc: 0.6500 test acc: 0.6850\n", - "epoch: 1 iter: 0 loss: 0.1970 train acc: 0.7250 test acc: 0.7850\n", - "epoch: 1 iter: 5 loss: 0.1521 train acc: 0.8500 test acc: 0.8150\n", - "epoch: 1 iter: 10 loss: 0.1726 train acc: 0.7750 test acc: 0.8900\n", - "epoch: 2 iter: 0 loss: 0.1742 train acc: 0.7250 test acc: 0.8650\n", - "epoch: 2 iter: 5 loss: 0.1167 train acc: 0.9000 test acc: 0.8900\n", - "epoch: 2 iter: 10 loss: 0.1654 train acc: 0.8000 test acc: 0.8950\n", - "epoch: 3 iter: 0 loss: 0.1609 train acc: 0.8000 test acc: 0.8850\n", - "epoch: 3 iter: 5 loss: 0.1148 train acc: 0.9250 test acc: 0.8850\n", - "epoch: 3 iter: 10 loss: 0.1649 train acc: 0.8000 test acc: 0.8750\n", - "epoch: 4 iter: 0 loss: 0.1629 train acc: 0.8250 test acc: 0.8750\n", - "epoch: 4 iter: 5 loss: 0.1112 train acc: 0.9000 test acc: 0.8700\n", - "epoch: 4 iter: 10 loss: 0.1630 train acc: 0.8500 test acc: 0.8850\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 使用 MNIST 进行分类\n", - "\n", - "# 主要参数\n", - "training_data_num = 500\n", - "testing_data_num = 200\n", - "qubit_num = 4\n", - "\n", - "# 选择3和6两个类，将 MNIST 从 28*28 重采样为 4*4，再用振幅编码方式进行编码 \n", - "train_dataset = MNIST(mode='train', encoding='amplitude_encoding', num_qubits=qubit_num, classes=[3,6],\n", - " data_num=training_data_num,need_cropping=True,\n", - " downscaling_method='resize', target_dimension=16, return_state=True)\n", - "\n", - "val_dataset = MNIST(mode='test', encoding='amplitude_encoding', num_qubits=qubit_num, classes=[3,6],\n", - " data_num=testing_data_num,need_cropping=True,\n", - " downscaling_method='resize', target_dimension=16,return_state=True)\n", - "\n", - "quantum_train_x, train_y = train_dataset.quantum_image_states, train_dataset.labels\n", - "quantum_test_x, test_y = val_dataset.quantum_image_states, val_dataset.labels\n", - "\n", - "acc = QClassifier2(\n", - " quantum_train_x, # 训练特征\n", - " train_y, # 训练标签\n", - " quantum_test_x, # 测试特征\n", - " test_y, # 测试标签\n", - " N = num_qubit, # 使用的量子比特数目\n", - " DEPTH = 3, # 分类器电路的深度\n", - " EPOCH = 5, # 迭代次数\n", - " LR = 0.1, # 学习率\n", - " BATCH = 40, # 一个批量的大小\n", - " )\n", - "plt.plot(acc)\n", - "plt.title(\"Classify MNIST 3&6 using amplitude encoding\")\n", - "plt.xlabel(\"Iteration\")\n", - "plt.ylabel(\"Testing accuracy\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "\n", - "## 参考文献\n", - "\n", - "[1] Mitarai, Kosuke, et al. Quantum circuit learning. [Physical Review A 98.3 (2018): 032309.](https://arxiv.org/abs/1803.00745)\n", - "\n", - "[2] Farhi, Edward, and Hartmut Neven. Classification with quantum neural networks on near term processors. [arXiv preprint arXiv:1802.06002 (2018).](https://arxiv.org/abs/1802.06002)\n", - "\n", - "[3] Schuld, Maria, et al. Circuit-centric quantum classifiers. [Physical Review A 101.3 (2020): 032308.](https://arxiv.org/abs/1804.00633)\n", - "\n", - "[4] Schuld, Maria. Supervised quantum machine learning models are kernel methods. [arXiv preprint arXiv:2101.11020 (2021).](https://arxiv.org/pdf/2101.11020)" - ] - } - ], - "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.8.12" - }, - "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": true - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/tutorial/machine_learning/QClassifier_EN.ipynb b/tutorial/machine_learning/QClassifier_EN.ipynb deleted file mode 100644 index a0740c4..0000000 --- a/tutorial/machine_learning/QClassifier_EN.ipynb +++ /dev/null @@ -1,1451 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Quantum Classifier\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Overview\n", - "\n", - "In this tutorial, we will discuss the workflow of Variational Quantum Classifiers (VQC) and how to use quantum neural networks (QNN) to accomplish a **binary classification** task. The main representatives of this approach include the [Quantum Circuit Learning (QCL)](https://arxiv.org/abs/1803.00745) [1] by Mitarai et al. (2018), Farhi & Neven (2018) [2] and [Circuit-Centric Quantum Classifiers](https://arxiv.org/abs/1804.00633) [3] by Schuld et al. (2018). Here, we mainly talk about classification in the language of supervised learning. Unlike classical methods, quantum classifiers require pre-processing to encode classical data into quantum data, and then train the parameters in the quantum neural network. Using different encoding methods, we can benchmark the optimal classification performance through test data. Finally, we demonstrate how to use built-in quantum datasets to accomplish quantum classification.\n", - "\n", - "### Background\n", - "\n", - "In the language of supervised learning, we need to enter a data set composed of $N$ pairs of labeled data points $D = \\{(x^k,y^k)\\}_{k=1}^{N}$ , Where $x^k\\in \\mathbb{R}^{m}$ is the data point, and $y^k \\in\\{0,1\\}$ is the label associated with the data point $x^k$. **The classification process is essentially a decision-making process, which determines the label attribution of a given data point**. For the quantum classifier framework, the realization of the classifier $\\mathcal{F}$ is a combination of a quantum neural network (or parameterized quantum circuit) with parameters $\\theta$, measurement, and data processing. An excellent classifier $\\mathcal{F}_\\theta$ should correctly map the data points in each data set to the corresponding labels as accurate as possible $\\mathcal{F}_\\theta(x^k ) \\rightarrow y^k$. Therefore, we use the cumulative distance between the predicted label $\\tilde{y}^{k} = \\mathcal{F}_\\theta(x^k)$ and the actual label $y^k$ as the loss function $\\mathcal {L}(\\theta)$ to be optimized. For binary classification tasks, we can choose the following loss function,\n", - "\n", - "$$\n", - "\\mathcal{L}(\\theta) = \\sum_{k=1}^N 1/N \\cdot |\\tilde{y}^{k}-y^k|^2. \\tag{1}\n", - "$$\n", - "\n", - "### Pipeline\n", - "\n", - "Here we give the whole pipeline to implement a quantum classifier under the framework of quantum circuit learning (QCL).\n", - "\n", - "1. Encode the classical data $x^k$ to quantum data $\\lvert \\psi_{\\rm in}\\rangle^k$. In this tutorial, we use Angle Encoding, see [encoding methods](./DataEncoding_EN.ipynb) for details. Readers can also try other encoding methods, e.g., Amplitude Encoding, and see the performance.\n", - "2. Construct the parameterized quantum circuit (PQC), corresponds to the unitary gate $U(\\theta)$.\n", - "3. Apply the parameterized circuit $U(\\theta)$ with the parameter $\\theta$ on input states $\\lvert \\psi_{\\rm in} \\rangle^k$, thereby obtaining the output state $\\lvert \\psi_{\\rm out} \\rangle^k = U(\\theta)\\lvert \\psi_{\\rm in} \\rangle^k$.\n", - "4. Measure the quantum state $\\lvert \\psi_{\\rm out}\\rangle^k$ processed by the quantum neural network to get the estimated label $\\tilde{y}^{k}$.\n", - "5. Repeat steps 3-4 until all data points in the data set have been processed. Then calculate the loss function $\\mathcal{L}(\\theta)$.\n", - "6. Continuously adjust the parameter $\\theta$ through optimization methods such as gradient descent to minimize the loss function. Record the optimal parameters after optimization $\\theta^* $, and then we obtain the optimal classifier $\\mathcal{F}_{\\theta^*}$.\n", - "\n", - " \n", - "
Figure 1: Flow chart of quantum classifier training
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Paddle Quantum Implementation\n", - "\n", - "Here, we first import the required packages:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\yeruilin\\Anaconda3\\envs\\paddle_quantum_env\\lib\\site-packages\\matplotlib_inline\\config.py:66: DeprecationWarning: InlineBackend._figure_formats_changed is deprecated in traitlets 4.1: use @observe and @unobserve instead.\n", - " def _figure_formats_changed(self, name, old, new):\n" - ] - } - ], - "source": [ - "# Import numpy and paddle\n", - "import numpy as np\n", - "import paddle\n", - "\n", - "# To construct quantum circuit\n", - "from paddle_quantum.circuit import UAnsatz\n", - "# Some functions\n", - "from numpy import pi as PI\n", - "from paddle import matmul, transpose, reshape # paddle matrix multiplication and transpose\n", - "from paddle_quantum.utils import pauli_str_to_matrix, dagger # N qubits Pauli matrix, complex conjugate\n", - "\n", - "# Plot figures, calculate the run time\n", - "from matplotlib import pyplot as plt\n", - "import time" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Parameters used for classification" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# Parameters for generating the data set\n", - "Ntrain = 200 # Specify the training set size\n", - "Ntest = 100 # Specify the test set size\n", - "boundary_gap = 0.5 # Set the width of the decision boundary\n", - "seed_data = 2 # Fixed random seed required to generate the data set\n", - "# Parameters for training\n", - "N = 4 # Number of qubits required\n", - "DEPTH = 1 # Circuit depth\n", - "BATCH = 20 # Batch size during training\n", - "EPOCH = int(200 * BATCH / Ntrain)\n", - " # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n", - "LR = 0.01 # Set the learning rate\n", - "seed_paras = 19 # Set random seed to initialize various parameters" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Data set generation\n", - "\n", - "One of the key parts in supervised learning is what data set to use? In this tutorial, we follow the exact approach introduced in QCL paper to generate a simple binary data set $\\{(x^{k}, y^{k})\\}$ with circular decision boundary, where the data point $x^{k}\\in \\mathbb{R}^{2}$, and the label $y^{k} \\in \\{0,1\\}$. The figure below provides us a concrete example.\n", - "\n", - " \n", - "
Figure 2: Generated data set and the corresponding decision boundary
\n", - "\n", - "For the generation method and visualization, please see the following code:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Generate a binary classification data set" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T04:03:35.707224Z", - "start_time": "2021-03-09T04:03:35.691351Z" - } - }, - "outputs": [], - "source": [ - "# Generate a binary classification data set with circular decision boundary\n", - "def circle_data_point_generator(Ntrain, Ntest, boundary_gap, seed_data):\n", - " \"\"\"\n", - " :param Ntrain: number of training samples\n", - " :param Ntest: number of test samples\n", - " :param boundary_gap: value in (0, 0.5), means the gap between two labels\n", - " :param seed_data: random seed\n", - " :return: 'Ntrain' samples for training and\n", - " 'Ntest' samples for testing\n", - " \"\"\"\n", - " # Generate \"Ntrain + Ntest\" pairs of data, x for 2-dim data points, y for labels.\n", - " # The first \"Ntrain\" pairs are used as training set, the last \"Ntest\" pairs are used as testing set\n", - " train_x, train_y = [], []\n", - " num_samples, seed_para = 0, 0\n", - " while num_samples < Ntrain + Ntest:\n", - " np.random.seed((seed_data + 10) * 1000 + seed_para + num_samples)\n", - " data_point = np.random.rand(2) * 2 - 1 # 2-dim vector in range [-1, 1]\n", - "\n", - " # If the modulus of the data point is less than (0.7 - gap), mark it as 0\n", - " if np.linalg.norm(data_point) < 0.7-boundary_gap / 2:\n", - " train_x.append(data_point)\n", - " train_y.append(0.)\n", - " num_samples += 1\n", - "\n", - " # If the modulus of the data point is greater than (0.7 + gap), mark it as 1\n", - " elif np.linalg.norm(data_point) > 0.7 + boundary_gap / 2:\n", - " train_x.append(data_point)\n", - " train_y.append(1.)\n", - " num_samples += 1\n", - " else:\n", - " seed_para += 1\n", - "\n", - " train_x = np.array(train_x).astype(\"float64\")\n", - " train_y = np.array([train_y]).astype(\"float64\").T\n", - "\n", - " print(\"The dimensions of the training set x {} and y {}\".format(np.shape(train_x[0:Ntrain]), np.shape(train_y[0:Ntrain])))\n", - " print(\"The dimensions of the test set x {} and y {}\".format(np.shape(train_x[Ntrain:]), np.shape(train_y[Ntrain:])), \"\\n\")\n", - "\n", - " return train_x[0:Ntrain], train_y[0:Ntrain], train_x[Ntrain:], train_y[Ntrain:]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Visualize the generated data set" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "def data_point_plot(data, label):\n", - " \"\"\"\n", - " :param data: shape [M, 2], means M 2-D data points\n", - " :param label: value 0 or 1\n", - " :return: plot these data points\n", - " \"\"\"\n", - " dim_samples, dim_useless = np.shape(data)\n", - " plt.figure(1)\n", - " for i in range(dim_samples):\n", - " if label[i] == 0:\n", - " plt.plot(data[i][0], data[i][1], color=\"r\", marker=\"o\")\n", - " elif label[i] == 1:\n", - " plt.plot(data[i][0], data[i][1], color=\"b\", marker=\"o\")\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In this tutorial, we use a training set with 200 elements, a testing set with 100 elements. The boundary gap is 0.5." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T04:03:37.244233Z", - "start_time": "2021-03-09T04:03:35.719425Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The dimensions of the training set x (200, 2) and y (200, 1)\n", - "The dimensions of the test set x (100, 2) and y (100, 1) \n", - "\n", - "Visualization of 200 data points in the training set: \n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Visualization of 100 data points in the test set: \n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - " You may wish to adjust the parameter settings to generate your own data set!\n" - ] - } - ], - "source": [ - "# Generate data set\n", - "train_x, train_y, test_x, test_y = circle_data_point_generator(\n", - " Ntrain, Ntest, boundary_gap, seed_data)\n", - "\n", - "# Visualization\n", - "print(\"Visualization of {} data points in the training set: \".format(Ntrain))\n", - "data_point_plot(train_x, train_y)\n", - "print(\"Visualization of {} data points in the test set: \".format(Ntest))\n", - "data_point_plot(test_x, test_y)\n", - "print(\"\\n You may wish to adjust the parameter settings to generate your own data set!\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Data preprocessing\n", - "Different from classical machine learning, quantum classifiers need to consider data preprocessing heavily. We need one more step to convert classical data into quantum information before running on a quantum computer. In this tutorial we use \"Angle Encoding\" to get quantum data.\n", - "\n", - "First, we determine the number of qubits that need to be used. Because our data $\\{x^{k} = (x^{k}_0, x^{k}_1)\\}$ is two-dimensional, according to the paper by Mitarai (2018) we need at least 2 qubits for encoding. Then prepare a group of initial quantum states $|00\\rangle$. Encode the classical information $\\{x^{k}\\}$ into a group of quantum gates $U(x^{k})$ and act them on the initial quantum states. Finally we get a group of quantum states $|\\psi_{\\rm in}\\rangle^k = U(x^{k})|00\\rangle$. In this way, we have completed the encoding from classical information into quantum information! Given $m$ qubits to encode a two-dimensional classical data point, the quantum gate is:\n", - "\n", - "$$\n", - "U(x^{k}) = \\otimes_{j=0}^{m-1} R_j^z\\big[\\arccos(x^{k}_{j \\, \\text{mod} \\, 2}\\cdot x^{k}_{j \\, \\text{mod} \\, 2})\\big] R_j^y\\big[\\arcsin(x^{k}_{j \\, \\text{mod} \\, 2}) \\big],\n", - "\\tag{2}\n", - "$$\n", - "\n", - "**Note:** In this representation, we count the first qubit as $j = 0$. For more encoding methods, see [Robust data encodings for quantum classifiers](https://arxiv.org/pdf/2003.01695.pdf). We also provide several built-in [encoding methods](./DataEncoding_EN.ipynb) in Paddle Quantum. Here we also encourage readers to try new encoding methods by themselves!\n", - "\n", - "Since this encoding method looks quite complicated, we might as well give a simple example. Suppose we are given a data point $x = (x_0, x_1)= (1,0)$. The label of this data point should be 1, corresponding to the **blue** point in the figure above. At the same time, the 2-qubit quantum gate $U(x)$ corresponding to the data point is,\n", - "\n", - "$$\n", - "U(x) =\n", - "\\bigg( R_0^z\\big[\\arccos(x_{0}\\cdot x_{0})\\big] R_0^y\\big[\\arcsin(x_{0}) \\big] \\bigg)\n", - "\\otimes\n", - "\\bigg( R_1^z\\big[\\arccos(x_{1}\\cdot x_{1})\\big] R_1^y\\big[\\arcsin(x_{1}) \\big] \\bigg),\n", - "\\tag{3}\n", - "$$\n", - "\n", - "Substituting in specific values, we get:\n", - "\n", - "$$\n", - "U(x) =\n", - "\\bigg( R_0^z\\big[0\\big] R_0^y\\big[\\pi/2 \\big] \\bigg)\n", - "\\otimes\n", - "\\bigg( R_1^z\\big[\\pi/2\\big] R_1^y\\big[0 \\big] \\bigg),\n", - "\\tag{4}\n", - "$$\n", - "\n", - "Recall the matrix form of rotation gates:\n", - "\n", - "$$\n", - "R_x(\\theta) :=\n", - "\\begin{bmatrix}\n", - "\\cos \\frac{\\theta}{2} &-i\\sin \\frac{\\theta}{2} \\\\\n", - "-i\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2}\n", - "\\end{bmatrix}\n", - ",\\quad\n", - "R_y(\\theta) :=\n", - "\\begin{bmatrix}\n", - "\\cos \\frac{\\theta}{2} &-\\sin \\frac{\\theta}{2} \\\\\n", - "\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2}\n", - "\\end{bmatrix}\n", - ",\\quad\n", - "R_z(\\theta) :=\n", - "\\begin{bmatrix}\n", - "e^{-i\\frac{\\theta}{2}} & 0 \\\\\n", - "0 & e^{i\\frac{\\theta}{2}}\n", - "\\end{bmatrix}.\n", - "\\tag{5}\n", - "$$\n", - "\n", - "Then the matrix form of the two-qubit quantum gate $U(x)$ can be written as\n", - "\n", - "$$\n", - "U(x) = \n", - "\\bigg(\n", - "\\begin{bmatrix}\n", - "1 & 0 \\\\ \n", - "0 & 1\n", - "\\end{bmatrix}\n", - "\\begin{bmatrix}\n", - "\\cos \\frac{\\pi}{4} &-\\sin \\frac{\\pi}{4} \\\\ \n", - "\\sin \\frac{\\pi}{4} &\\cos \\frac{\\pi}{4} \n", - "\\end{bmatrix}\n", - "\\bigg)\n", - "\\otimes \n", - "\\bigg(\n", - "\\begin{bmatrix}\n", - "e^{-i\\frac{\\pi}{4}} & 0 \\\\ \n", - "0 & e^{i\\frac{\\pi}{4}}\n", - "\\end{bmatrix}\n", - "\\begin{bmatrix}\n", - "1 &0 \\\\ \n", - "0 &1\n", - "\\end{bmatrix}\n", - "\\bigg) \\, .\n", - "\\tag{6}\n", - "$$\n", - "\n", - "After simplification, we can get the encoded quantum state $|\\psi_{\\rm in}\\rangle$ by acting the quantum gate on the initialized quantum state $|00\\rangle$,\n", - "\n", - "$$\n", - "|\\psi_{\\rm in}\\rangle =\n", - "U(x)|00\\rangle = \\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "1-i &0 &-1+i &0 \\\\\n", - "0 &1+i &0 &-1-i \\\\\n", - "1-i &0 &1-i &0 \\\\\n", - "0 &1+i &0 &1+i\n", - "\\end{bmatrix}\n", - "\\begin{bmatrix}\n", - "1 \\\\\n", - "0 \\\\\n", - "0 \\\\\n", - "0\n", - "\\end{bmatrix}\n", - "= \\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "1-i \\\\\n", - "0 \\\\\n", - "1-i \\\\\n", - "0\n", - "\\end{bmatrix}.\n", - "\\tag{7}\n", - "$$\n", - "\n", - "Then let us take a look at how to implement this encoding method in Paddle Quantum. Note that in the code, we use the following trick: \n", - "\n", - "$$\n", - "(U_1 |0\\rangle)\\otimes (U_2 |0\\rangle) = (U_1 \\otimes U_2) |0\\rangle\\otimes|0\\rangle\n", - "= (U_1 \\otimes U_2) |00\\rangle.\n", - "\\tag{8}\n", - "$$" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T04:03:37.354267Z", - "start_time": "2021-03-09T04:03:37.258314Z" - } - }, - "outputs": [], - "source": [ - "# Gate: rotate around Y-axis, Z-axis with angle theta\n", - "def Ry(theta):\n", - " \"\"\"\n", - " :param theta: parameter\n", - " :return: Y rotation matrix\n", - " \"\"\"\n", - " return np.array([[np.cos(theta / 2), -np.sin(theta / 2)],\n", - " [np.sin(theta / 2), np.cos(theta / 2)]])\n", - "\n", - "def Rz(theta):\n", - " \"\"\"\n", - " :param theta: parameter\n", - " :return: Z rotation matrix\n", - " \"\"\"\n", - " return np.array([[np.cos(theta / 2) - np.sin(theta / 2) * 1j, 0],\n", - " [0, np.cos(theta / 2) + np.sin(theta / 2) * 1j]])\n", - "\n", - "# Classical -> Quantum Data Encoder\n", - "def datapoints_transform_to_state(data, n_qubits):\n", - " \"\"\"\n", - " :param data: shape [-1, 2]\n", - " :param n_qubits: the number of qubits to which\n", - " the data transformed\n", - " :return: shape [-1, 1, 2 ^ n_qubits]\n", - " the first parameter -1 in this shape means can be arbitrary. In this tutorial, it equals to BATCH.\n", - " \"\"\"\n", - " dim1, dim2 = data.shape\n", - " res = []\n", - " for sam in range(dim1):\n", - " res_state = 1.\n", - " zero_state = np.array([[1, 0]])\n", - " # Angle Encoding\n", - " for i in range(n_qubits):\n", - " # For even number qubits, perform Rz(arccos(x0^2)) Ry(arcsin(x0))\n", - " if i % 2 == 0:\n", - " state_tmp=np.dot(zero_state, Ry(np.arcsin(data[sam][0])).T)\n", - " state_tmp=np.dot(state_tmp, Rz(np.arccos(data[sam][0] ** 2)).T)\n", - " res_state=np.kron(res_state, state_tmp)\n", - " # For odd number qubits, perform Rz(arccos(x1^2)) Ry(arcsin(x1))\n", - " elif i% 2 == 1:\n", - " state_tmp=np.dot(zero_state, Ry(np.arcsin(data[sam][1])).T)\n", - " state_tmp=np.dot(state_tmp, Rz(np.arccos(data[sam][1] ** 2)).T)\n", - " res_state=np.kron(res_state, state_tmp)\n", - " res.append(res_state)\n", - " res = np.array(res)\n", - "\n", - " return res.astype(\"complex128\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "quantum data after angle encoding" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "As a test, we enter the classical information:\n", - "(x_0, x_1) = (1, 0)\n", - "The 2-qubit quantum state output after encoding is:\n", - "[[[0.5-0.5j 0. +0.j 0.5-0.5j 0. +0.j ]]]\n" - ] - } - ], - "source": [ - "print(\"As a test, we enter the classical information:\")\n", - "print(\"(x_0, x_1) = (1, 0)\")\n", - "print(\"The 2-qubit quantum state output after encoding is:\")\n", - "print(datapoints_transform_to_state(np.array([[1, 0]]), n_qubits=2))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Building Quantum Neural Network \n", - "After completing the encoding from classical data to quantum data, we can now input these quantum states into the quantum computer. Before that, we also need to design the quantum neural network.\n", - "\n", - " \n", - "
Figure 3: Parameterized Quantum Circuit
\n", - "\n", - "\n", - "For convenience, we call the parameterized quantum neural network as $U(\\boldsymbol{\\theta})$. $U(\\boldsymbol{\\theta})$ is a key component of our classifier, and it needs a certain complex structure to fit our decision boundary. Similar to traditional neural networks, the structure of a quantum neural network is not unique. The structure shown above is just one case. You could design your own structure. Let's take the previously mentioned data point $x = (x_0, x_1)= (1,0)$ as an example. After encoding, we have obtained a quantum state $|\\psi_{\\rm in}\\rangle$,\n", - "\n", - "$$\n", - "|\\psi_{\\rm in}\\rangle =\n", - "\\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "1-i \\\\\n", - "0 \\\\\n", - "1-i \\\\\n", - "0\n", - "\\end{bmatrix}.\n", - "\\tag{9}\n", - "$$\n", - "\n", - "Then we input this quantum state into our quantum neural network (QNN). That is, multiply a unitary matrix by a vector to get the processed quantum state $|\\varphi\\rangle$\n", - "\n", - "$$\n", - "|\\psi_{\\rm out}\\rangle = U(\\boldsymbol{\\theta})|\\psi_{\\rm in}\\rangle.\n", - "\\tag{10}\n", - "$$\n", - "\n", - "If we set all the QNN parameters to be $\\theta = \\pi$, then we can write down the resulting state:\n", - "\n", - "$$\n", - "|\\psi_{\\rm out}\\rangle =\n", - "U(\\boldsymbol{\\theta} =\\pi)|\\psi_{\\rm in}\\rangle =\n", - "\\begin{bmatrix}\n", - "0 &0 &-1 &0 \\\\\n", - "-1 &0 &0 &0 \\\\\n", - "0 &1 &0 &0 \\\\\n", - "0 &0 &0 &1\n", - "\\end{bmatrix}\n", - "\\cdot\n", - "\\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "1-i \\\\\n", - "0 \\\\\n", - "1-i \\\\\n", - "0\n", - "\\end{bmatrix}\n", - "= \\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "-1+i \\\\\n", - "-1+i \\\\\n", - "0 \\\\\n", - "0\n", - "\\end{bmatrix}.\n", - "\\tag{11}\n", - "$$" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T04:03:37.426687Z", - "start_time": "2021-03-09T04:03:37.374976Z" - } - }, - "outputs": [], - "source": [ - "# Simulation of building a quantum neural network\n", - "def cir_Classifier(theta, n, depth):\n", - " \"\"\"\n", - " :param theta: dim: [n, depth + 3], \"+3\" because we add an initial generalized rotation gate to each qubit\n", - " :param n: number of qubits\n", - " :param depth: circuit depth\n", - " :return: U_theta\n", - " \"\"\"\n", - " # Initialize the network\n", - " cir = UAnsatz(n)\n", - " \n", - " # Build a generalized rotation layer\n", - " for i in range(n):\n", - " cir.rz(theta[i][0], i)\n", - " cir.ry(theta[i][1], i)\n", - " cir.rz(theta[i][2], i)\n", - "\n", - " # The default depth is depth = 1\n", - " # Build the entangleed layer and Ry rotation layer\n", - " for d in range(3, depth + 3):\n", - " # The entanglement layer\n", - " for i in range(n-1):\n", - " cir.cnot([i, i + 1])\n", - " cir.cnot([n-1, 0])\n", - " # Add Ry to each qubit\n", - " for i in range(n):\n", - " cir.ry(theta[i][d], i)\n", - "\n", - " return cir" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Measurement\n", - "After passing through the PQC $U(\\theta)$, the quantum data becomes $\\lvert \\psi_{\\rm out}\\rangle^k = U(\\theta)\\lvert \\psi_{\\rm in} \\rangle^k$. To get its label, we need to measure this new quantum state to obtain the classical information. These processed classical information will then be used to calculate the loss function $\\mathcal{L}(\\boldsymbol{\\theta})$. Finally, based on the gradient descent algorithm, we continuously update the PQC parameters $\\boldsymbol{\\theta}$ and optimize the loss function. \n", - "\n", - "Here we measure the expected value of the Pauli $Z$ operator on the first qubit. Specifically,\n", - "\n", - "$$\n", - "\\langle Z \\rangle =\n", - "\\langle \\psi_{\\rm out} |Z\\otimes I\\cdots \\otimes I| \\psi_{\\rm out}\\rangle.\n", - "\\tag{12}\n", - "$$\n", - "\n", - "Recall that the matrix of the Pauli $Z$ operator is defined as:\n", - "\n", - "$$\n", - "Z := \\begin{bmatrix} 1 &0 \\\\ 0 &-1 \\end{bmatrix}.\n", - "\\tag{13}\n", - "$$\n", - "\n", - "Continuing our previous 2-qubit example, the expected value we get after the measurement is\n", - "\n", - "$$\n", - "\\langle Z \\rangle =\n", - "\\langle \\psi_{\\rm out} |Z\\otimes I| \\psi_{\\rm out}\\rangle =\n", - "\\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "-1-i \\quad\n", - "-1-i \\quad\n", - "0 \\quad\n", - "0\n", - "\\end{bmatrix}\n", - "\\begin{bmatrix}\n", - "1 &0 &0 &0 \\\\\n", - "0 &1 &0 &0 \\\\\n", - "0 &0 &-1 &0 \\\\\n", - "0 &0 &0 &-1\n", - "\\end{bmatrix}\n", - "\\cdot\n", - "\\frac{1}{2}\n", - "\\begin{bmatrix}\n", - "-1+i \\\\\n", - "-1+i \\\\\n", - "0 \\\\\n", - "0\n", - "\\end{bmatrix}\n", - "= 1. \\tag{14}\n", - "$$\n", - "\n", - "This measurement result seems to be our original label 1. Does this mean that we have successfully classified this data point? This is not the case because the range of $\\langle Z \\rangle$ is usually between $[-1,1]$. \n", - "To match it to our label range $y^{k} \\in \\{0,1\\}$, we need to map the upper and lower limits. The simplest mapping is \n", - "\n", - "$$\n", - "\\tilde{y}^{k} = \\frac{\\langle Z \\rangle}{2} + \\frac{1}{2} + bias \\quad \\in [0, 1].\n", - "\\tag{15}\n", - "$$\n", - "\n", - "Using bias is a trick in machine learning. The purpose is to make the decision boundary not restricted by the origin or some hyperplane. Generally, the default bias is initialized to be 0, and the optimizer will continuously update it like all the other parameters $\\theta$ in the iterative process to ensure $\\tilde{y}^{k} \\in [0, 1]$. Of course, you can also choose other complex mappings (activation functions), such as the sigmoid function. After mapping, we can regard $\\tilde{y}^{k}$ as the label we estimated. $\\tilde{y}^{k}< 0.5$ corresponds to label 0, and $\\tilde{y}^{k}> 0.5$ corresponds to label 1. It's time to quickly review the whole process before we finish discussion,\n", - "\n", - "$$\n", - "x^{k} \\rightarrow |\\psi_{\\rm in}\\rangle^{k} \\rightarrow U(\\boldsymbol{\\theta})|\\psi_{\\rm in}\\rangle^{k} \\rightarrow\n", - "|\\psi_{\\rm out}\\rangle^{k} \\rightarrow ^{k}\\langle \\psi_{\\rm out} |Z\\otimes I\\cdots \\otimes I| \\psi_{\\rm out} \\rangle^{k}\n", - "\\rightarrow \\langle Z \\rangle \\rightarrow \\tilde{y}^{k}.\\tag{16}\n", - "$$\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Loss function\n", - "\n", - "To calculate the loss function in Eq. (1), we need to measure all training data in each iteration. In real practice, we devide the training data into \"Ntrain/BATCH\" groups, where each group contains \"BATCH\" data pairs.\n", - "\n", - "The loss function for the i-th group is \n", - "$$\n", - "\\mathcal{L}_{i} = \\sum_{k=1}^{BATCH} \\frac{1}{BATCH} |y^{i,k} - \\tilde{y}^{i,k}|^2,\\tag{17}\n", - "$$\n", - "and we train the PQC with $\\mathcal{L}_{i}$ for \"EPOCH\" times. \n", - "\n", - "If you set \"BATCH = Ntrain\", there will be only one group, and Eq. (17) becomes Eq. (1)." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T04:03:37.439183Z", - "start_time": "2021-03-09T04:03:37.432202Z" - } - }, - "outputs": [], - "source": [ - "# 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", - " r\"\"\"\n", - " :param n: number of qubits\n", - " :return: local observable: Z \\otimes I \\otimes ...\\otimes I\n", - " \"\"\"\n", - " Ob = pauli_str_to_matrix([[1.0,'z0']], n)\n", - "\n", - " return Ob" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T04:03:37.503213Z", - "start_time": "2021-03-09T04:03:37.473028Z" - } - }, - "outputs": [], - "source": [ - "# Build the computational graph\n", - "class Opt_Classifier(paddle.nn.Layer):\n", - " \"\"\"\n", - " Construct the model net\n", - " \"\"\"\n", - " def __init__(self, n, depth, seed_paras=1, dtype='float64'):\n", - " # Initialization, use n, depth give the initial PQC\n", - " super(Opt_Classifier, self).__init__()\n", - " self.n = n\n", - " self.depth = depth\n", - " # Initialize the parameters theta with a uniform distribution of [0, 2*pi]\n", - " self.theta = self.create_parameter(\n", - " shape=[n, depth + 3], # \"+3\" because we add an initial generalized rotation gate to each qubit\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype,\n", - " is_bias=False)\n", - " # Initialize bias\n", - " self.bias = self.create_parameter(\n", - " shape=[1],\n", - " default_initializer=paddle.nn.initializer.Normal(std=0.01),\n", - " dtype=dtype,\n", - " is_bias=False)\n", - "\n", - " # Define forward propagation mechanism, and then calculate loss function and cross-validation accuracy\n", - " def forward(self, state_in, label):\n", - " \"\"\"\n", - " Args:\n", - " state_in: The input quantum state, shape [-1, 1, 2^n] -- in this tutorial: [BATCH, 1, 2^n]\n", - " label: label for the input state, shape [-1, 1]\n", - " Returns:\n", - " The loss:\n", - " L = 1/BATCH * (( + 1)/2 + bias - label)^2\n", - " \"\"\"\n", - " # Convert Numpy array to tensor\n", - " Ob = paddle.to_tensor(Observable(self.n))\n", - " label_pp = reshape(paddle.to_tensor(label), [-1, 1])\n", - "\n", - " # Build the quantum circuit\n", - " cir = cir_Classifier(self.theta, n=self.n, depth=self.depth)\n", - " Utheta = cir.U\n", - "\n", - " # Because Utheta is achieved by learning, we compute with row vectors to speed up without affecting the training effect\n", - " state_out = matmul(state_in, Utheta) # shape:[-1, 1, 2 ** n], the first parameter is BATCH in this tutorial\n", - "\n", - " # Measure the expectation value of Pauli Z operator -- shape [-1,1,1]\n", - " E_Z = matmul(matmul(state_out, Ob), transpose(paddle.conj(state_out), perm=[0, 2, 1]))\n", - "\n", - " # Mapping to the estimated value of the label\n", - " state_predict = paddle.real(E_Z)[:, 0] * 0.5 + 0.5 + self.bias # |y^{i,k} - \\tilde{y}^{i,k}|^2\n", - " loss = paddle.mean((state_predict - label_pp) ** 2) # Get average for \"BATCH\" |y^{i,k} - \\tilde{y}^{i,k}|^2: L_i：shape:[1,1]\n", - "\n", - " # Calculate the accuracy of cross-validation\n", - " is_correct = (paddle.abs(state_predict - label_pp) < 0.5).nonzero().shape[0]\n", - " acc = is_correct / label.shape[0]\n", - "\n", - " return loss, acc, state_predict.numpy(), cir" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Training process\n", - "\n", - "After defining all the concepts above, we might take a look at the actual training process." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "# Draw the figure of the final training classifier\n", - "def heatmap_plot(Opt_Classifier, N):\n", - " # generate data points x_y_\n", - " Num_points = 30\n", - " x_y_ = []\n", - " for row_y in np.linspace(0.9, -0.9, Num_points):\n", - " row = []\n", - " for row_x in np.linspace(-0.9, 0.9, Num_points):\n", - " row.append([row_x, row_y])\n", - " x_y_.append(row)\n", - " x_y_ = np.array(x_y_).reshape(-1, 2).astype(\"float64\")\n", - "\n", - " # make prediction: heat_data\n", - " input_state_test = paddle.to_tensor(\n", - " datapoints_transform_to_state(x_y_, N))\n", - " loss_useless, acc_useless, state_predict, cir = Opt_Classifier(state_in=input_state_test, label=x_y_[:, 0])\n", - " heat_data = state_predict.reshape(Num_points, Num_points)\n", - "\n", - " # plot\n", - " fig = plt.figure(1)\n", - " ax = fig.add_subplot(111)\n", - " x_label = np.linspace(-0.9, 0.9, 3)\n", - " y_label = np.linspace(0.9, -0.9, 3)\n", - " ax.set_xticks([0, Num_points // 2, Num_points - 1])\n", - " ax.set_xticklabels(x_label)\n", - " ax.set_yticks([0, Num_points // 2, Num_points - 1])\n", - " ax.set_yticklabels(y_label)\n", - " im = ax.imshow(heat_data, cmap=plt.cm.RdBu)\n", - " plt.colorbar(im)\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Learn the PQC via Adam" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T04:03:38.325454Z", - "start_time": "2021-03-09T04:03:38.299975Z" - } - }, - "outputs": [], - "source": [ - "def QClassifier(Ntrain, Ntest, gap, N, DEPTH, EPOCH, LR, BATCH, seed_paras, seed_data):\n", - " \"\"\"\n", - " Quantum Binary Classifier\n", - " Input:\n", - " Ntrain # Specify the training set size\n", - " Ntest # Specify the test set size\n", - " gap # Set the width of the decision boundary\n", - " N # Number of qubits required\n", - " DEPTH # Circuit depth\n", - " BATCH # Batch size during training\n", - " EPOCH # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n", - " LR # Set the learning rate\n", - " seed_paras # Set random seed to initialize various parameters\n", - " seed_data # Fixed random seed required to generate the data set\n", - " plot_heat_map # Whether to plot heat map, default True\n", - " \"\"\"\n", - " # Generate data set\n", - " train_x, train_y, test_x, test_y = circle_data_point_generator(Ntrain=Ntrain, Ntest=Ntest, boundary_gap=gap, seed_data=seed_data)\n", - " # Read the dimension of the training set\n", - " N_train = train_x.shape[0]\n", - " \n", - " paddle.seed(seed_paras)\n", - " # Initialize the registers to store the accuracy rate and other information\n", - " summary_iter, summary_test_acc = [], []\n", - "\n", - " # Generally, we use Adam optimizer to get relatively good convergence\n", - " # Of course, it can be changed to SGD or RMSprop\n", - " myLayer = Opt_Classifier(n=N, depth=DEPTH) # Initial PQC\n", - " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=myLayer.parameters())\n", - "\n", - "\n", - " # Optimize iteration\n", - " # We divide the training set into \"Ntrain/BATCH\" groups\n", - " # For each group the final circuit will be used as the initial circuit for the next group\n", - " # Use cir to record the final circuit after learning.\n", - " i = 0 # Record the iteration number\n", - " for ep in range(EPOCH):\n", - " # Learn for each group\n", - " for itr in range(N_train // BATCH):\n", - " i += 1 # Record the iteration number\n", - " # Encode classical data into a quantum state |psi>, dimension [BATCH, 2 ** N]\n", - " input_state = paddle.to_tensor(datapoints_transform_to_state(train_x[itr * BATCH:(itr + 1) * BATCH], N))\n", - "\n", - " # Run forward propagation to calculate loss function\n", - " loss, train_acc, state_predict_useless, cir \\\n", - " = myLayer(state_in=input_state, label=train_y[itr * BATCH:(itr + 1) * BATCH]) # optimize the given PQC\n", - " # Print the performance in iteration\n", - " if i % 30 == 5:\n", - " # Calculate the correct rate on the test set test_acc\n", - " input_state_test = paddle.to_tensor(datapoints_transform_to_state(test_x, N))\n", - " loss_useless, test_acc, state_predict_useless, t_cir \\\n", - " = myLayer(state_in=input_state_test,label=test_y)\n", - " print(\"epoch:\", ep, \"iter:\", itr,\n", - " \"loss: %.4f\" % loss.numpy(),\n", - " \"train acc: %.4f\" % train_acc,\n", - " \"test acc: %.4f\" % test_acc)\n", - " # Store accuracy rate and other information\n", - " summary_iter.append(itr + ep * N_train)\n", - " summary_test_acc.append(test_acc) \n", - "\n", - " # Run back propagation to minimize the loss function\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - " \n", - " # Print the final circuit\n", - " print(\"The trained circuit:\")\n", - " print(cir)\n", - " # Draw the decision boundary represented by heatmap\n", - " heatmap_plot(myLayer, N=N)\n", - "\n", - " return summary_test_acc" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T04:04:19.852356Z", - "start_time": "2021-03-09T04:03:38.709491Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The dimensions of the training set x (200, 2) and y (200, 1)\n", - "The dimensions of the test set x (100, 2) and y (100, 1) \n", - "\n", - "epoch: 0 iter: 4 loss: 0.1547 train acc: 0.8500 test acc: 0.6400\n", - "epoch: 3 iter: 4 loss: 0.1337 train acc: 0.9500 test acc: 0.8800\n", - "epoch: 6 iter: 4 loss: 0.1265 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 9 iter: 4 loss: 0.1247 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 12 iter: 4 loss: 0.1261 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 15 iter: 4 loss: 0.1268 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 18 iter: 4 loss: 0.1269 train acc: 1.0000 test acc: 1.0000\n", - "The trained circuit:\n", - "--Rz(0.542)----Ry(3.458)----Rz(2.692)----*--------------x----Ry(6.191)--\n", - " | | \n", - "--Rz(3.514)----Ry(1.543)----Rz(2.499)----x----*---------|----Ry(2.968)--\n", - " | | \n", - "--Rz(5.947)----Ry(3.161)----Rz(3.897)---------x----*----|----Ry(1.579)--\n", - " | | \n", - "--Rz(0.718)----Ry(5.038)----Rz(1.348)--------------x----*----Ry(0.036)--\n", - " \n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The main program finished running in 8.05081820487976 seconds.\n" - ] - } - ], - "source": [ - "def main():\n", - " \"\"\"\n", - " main\n", - " \"\"\"\n", - " time_start = time.time()\n", - " acc = QClassifier(\n", - " Ntrain = 200, # Specify the training set size\n", - " Ntest = 100, # Specify the test set size\n", - " gap = 0.5, # Set the width of the decision boundary\n", - " N = 4, # Number of qubits required\n", - " DEPTH = 1, # Circuit depth\n", - " BATCH = 20, # Batch size during training\n", - " EPOCH = int(200 * BATCH / Ntrain),\n", - " # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n", - " LR = 0.01, # Set the learning rate\n", - " seed_paras = 19, # Set random seed to initialize various parameters\n", - " seed_data = 2, # Fixed random seed required to generate the data set\n", - " )\n", - " \n", - " time_span = time.time()-time_start\n", - " print('The main program finished running in ', time_span, 'seconds.')\n", - "\n", - "if __name__ == '__main__':\n", - " main()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "By printing out the training results, you can see that the classification accuracy in the test set and the data set after continuous optimization has reached $100\\%$." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Benchmarking Different Encoding Methods\n", - "\n", - "Encoding methods are fundemental in supervised quantum machine learning [4]. In paddle quantum, commonly used encoding methods such as amplitude encoding, angle encoding, IQP encoding, etc., are integrated. Simple classification data of users (without reducing dimensions) can be encoded by an instance of the ``SimpleDataset`` class and image data can be encoded by an instance of the ``VisionDataset`` class both using the method ``encode``." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "(100, 4)\n" - ] - } - ], - "source": [ - "# Use circle data above to accomplish classification\n", - "from paddle_quantum.dataset import *\n", - "\n", - "# The data are two-dimensional and are encoded by two qubits\n", - "quantum_train_x = SimpleDataset(2).encode(train_x, 'angle_encoding', 2)\n", - "quantum_test_x = SimpleDataset(2).encode(test_x, 'angle_encoding', 2)\n", - "\n", - "print(type(quantum_test_x)) # ndarray\n", - "print(quantum_test_x.shape) # (100, 4)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we define an ordinary classifier, and it will be used by different data afterwards." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "# A simpler classifier\n", - "def QClassifier2(quantum_train_x, train_y,quantum_test_x,test_y, N, DEPTH, EPOCH, LR, BATCH):\n", - " \"\"\"\n", - " Quantum Binary Classifier\n", - " Input：\n", - " quantum_train_x # training x\n", - " train_y # training y\n", - " quantum_test_x # testing x\n", - " test_y # testing y\n", - " N # Number of qubits required\n", - " DEPTH # Circuit depth\n", - " EPOCH # Number of training epochs\n", - " LR # Set the learning rate\n", - " BATCH # Batch size during training\n", - " \"\"\"\n", - " Ntrain = len(quantum_train_x)\n", - " \n", - " paddle.seed(1)\n", - "\n", - " net = Opt_Classifier(n=N, depth=DEPTH)\n", - "\n", - " # Test accuracy list\n", - " summary_iter, summary_test_acc = [], []\n", - "\n", - " # Adam can also be replaced by SGD or RMSprop\n", - " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", - "\n", - " # Optimize\n", - " for ep in range(EPOCH):\n", - " for itr in range(Ntrain // BATCH):\n", - " # Import data\n", - " input_state = quantum_train_x[itr * BATCH:(itr + 1) * BATCH] # paddle.tensor\n", - " input_state = reshape(input_state, [-1, 1, 2 ** N])\n", - " label = train_y[itr * BATCH:(itr + 1) * BATCH]\n", - " test_input_state = reshape(quantum_test_x, [-1, 1, 2 ** N])\n", - "\n", - " loss, train_acc, state_predict_useless, cir = net(state_in=input_state, label=label)\n", - "\n", - " if itr % 5 == 0:\n", - " # get accuracy on test dataset (test_acc)\n", - " loss_useless, test_acc, state_predict_useless, t_cir = net(state_in=test_input_state, label=test_y)\n", - " print(\"epoch:\", ep, \"iter:\", itr,\n", - " \"loss: %.4f\" % loss.numpy(),\n", - " \"train acc: %.4f\" % train_acc,\n", - " \"test acc: %.4f\" % test_acc)\n", - " summary_test_acc.append(test_acc)\n", - "\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - "\n", - " return summary_test_acc" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Now we can test different encoding methods on the circle data generated above. Here we choose five encoding methods: amplitude encoding, angle encoding, pauli rotation encoding, IQP encoding, and complex entangled encoding. Then the curves of the testing accuracy are shown below." - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Encoding method: amplitude_encoding\n", - "epoch: 0 iter: 0 loss: 0.3066 train acc: 0.4000 test acc: 0.5400\n", - "epoch: 0 iter: 5 loss: 0.2378 train acc: 0.7000 test acc: 0.7000\n", - "epoch: 0 iter: 10 loss: 0.2308 train acc: 0.8000 test acc: 0.6700\n", - "epoch: 0 iter: 15 loss: 0.2230 train acc: 0.8000 test acc: 0.6100\n", - "Encoding method: angle_encoding\n", - "epoch: 0 iter: 0 loss: 0.2949 train acc: 0.5000 test acc: 0.3600\n", - "epoch: 0 iter: 5 loss: 0.1770 train acc: 0.7000 test acc: 0.7000\n", - "epoch: 0 iter: 10 loss: 0.1654 train acc: 0.8000 test acc: 0.7000\n", - "epoch: 0 iter: 15 loss: 0.1966 train acc: 0.7000 test acc: 0.5800\n", - "Encoding method: pauli_rotation_encoding\n", - "epoch: 0 iter: 0 loss: 0.2433 train acc: 0.6000 test acc: 0.7000\n", - "epoch: 0 iter: 5 loss: 0.2142 train acc: 0.7000 test acc: 0.7000\n", - "epoch: 0 iter: 10 loss: 0.2148 train acc: 0.7000 test acc: 0.7000\n", - "epoch: 0 iter: 15 loss: 0.2019 train acc: 0.8000 test acc: 0.7600\n", - "Encoding method: IQP_encoding\n", - "epoch: 0 iter: 0 loss: 0.2760 train acc: 0.6000 test acc: 0.4200\n", - "epoch: 0 iter: 5 loss: 0.1916 train acc: 0.6000 test acc: 0.6200\n", - "epoch: 0 iter: 10 loss: 0.1355 train acc: 0.9000 test acc: 0.7300\n", - "epoch: 0 iter: 15 loss: 0.1289 train acc: 0.9000 test acc: 0.6700\n", - "Encoding method: complex_entangled_encoding\n", - "epoch: 0 iter: 0 loss: 0.3274 train acc: 0.3000 test acc: 0.2900\n", - "epoch: 0 iter: 5 loss: 0.2120 train acc: 0.7000 test acc: 0.7000\n", - "epoch: 0 iter: 10 loss: 0.2237 train acc: 0.7000 test acc: 0.7000\n", - "epoch: 0 iter: 15 loss: 0.2095 train acc: 0.8000 test acc: 0.7200\n" - ] - } - ], - "source": [ - "# Testing different encoding methods\n", - "encoding_list = ['amplitude_encoding', 'angle_encoding', 'pauli_rotation_encoding', 'IQP_encoding', 'complex_entangled_encoding']\n", - "num_qubit = 2 # If qubit number is 1, CNOT gate in cir_classifier can not be used\n", - "dimension = 2\n", - "acc_list = []\n", - "\n", - "for i in range(len(encoding_list)):\n", - " encoding = encoding_list[i]\n", - " print(\"Encoding method:\", encoding)\n", - " # Use SimpleDataset to encode the data\n", - " quantum_train_x= SimpleDataset(dimension).encode(train_x, encoding, num_qubit)\n", - " quantum_test_x= SimpleDataset(dimension).encode(test_x, encoding, num_qubit)\n", - " quantum_train_x = paddle.to_tensor(quantum_train_x)\n", - " quantum_test_x = paddle.to_tensor(quantum_test_x)\n", - " \n", - " acc = QClassifier2(\n", - " quantum_train_x, # Training x\n", - " train_y, # Training y\n", - " quantum_test_x, # Testing x\n", - " test_y, # Testing y\n", - " N = num_qubit, # Number of qubits required\n", - " DEPTH = 1, # Circuit depth\n", - " EPOCH = 1, # Number of training epochs\n", - " LR = 0.1, # Set the learning rate\n", - " BATCH = 10, # Batch size during training\n", - " )\n", - " acc_list.append(acc)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Benchmarking different encoding methods\n", - "x=[2*i for i in range(len(acc_list[0]))]\n", - "for i in range(len(encoding_list)):\n", - " plt.plot(x,acc_list[i])\n", - "plt.legend(encoding_list)\n", - "plt.title(\"Benchmarking different encoding methods\")\n", - "plt.xlabel(\"Iteration\")\n", - "plt.ylabel(\"Test accuracy\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Quantum Classification on Built-In MNIST and Iris Datasets\n", - "\n", - "Paddle Quantum provides datasets commonly used in quantum classification tasks, and users can use the `paddle_quantum.dataset` module to get the encoding circuits or encoded states. There are four built-in datasets in Paddle Quantum at present, including MNIST, FashionMNIST, Iris and BreastCancer. We can easily accomplishing quantum classification using these quantum datasets.\n", - "\n", - "The first case is Iris. It has three types of labels and 50 samples of each type. There are only four features in Iris data, and it is very easy to fulfill its classification." - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\yeruilin\\Anaconda3\\envs\\paddle_quantum_env\\lib\\site-packages\\paddle\\fluid\\dygraph\\math_op_patch.py:237: UserWarning: The dtype of left and right variables are not the same, left dtype is paddle.float64, but right dtype is paddle.int32, the right dtype will convert to paddle.float64\n", - " warnings.warn(\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 0 iter: 0 loss: 0.3113 train acc: 0.0000 test acc: 0.0000\n", - "epoch: 0 iter: 5 loss: 0.4818 train acc: 0.0000 test acc: 0.3500\n", - "epoch: 0 iter: 10 loss: 0.2171 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 0 iter: 15 loss: 0.1688 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 1 iter: 0 loss: 0.1350 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 1 iter: 5 loss: 0.1110 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 1 iter: 10 loss: 0.0879 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 1 iter: 15 loss: 0.0490 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 2 iter: 0 loss: 0.0733 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 2 iter: 5 loss: 0.0740 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 2 iter: 10 loss: 0.0660 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 2 iter: 15 loss: 0.0394 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 3 iter: 0 loss: 0.0654 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 3 iter: 5 loss: 0.0557 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 3 iter: 10 loss: 0.0602 train acc: 1.0000 test acc: 1.0000\n", - "epoch: 3 iter: 15 loss: 0.0397 train acc: 1.0000 test acc: 1.0000\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Using Iris\n", - "test_rate = 0.2\n", - "num_qubit = 4\n", - "\n", - "# acquire Iris data as quantum states\n", - "iris =Iris (encoding='angle_encoding', num_qubits=num_qubit, test_rate=test_rate,classes=[0, 1], return_state=True)\n", - "\n", - "quantum_train_x, train_y = iris.train_x, iris.train_y\n", - "quantum_test_x, test_y = iris.test_x, iris.test_y\n", - "testing_data_num = len(test_y)\n", - "training_data_num = len(train_y)\n", - "\n", - "acc = QClassifier2(\n", - " quantum_train_x, # training x\n", - " train_y, # training y\n", - " quantum_test_x, # testing x\n", - " test_y, # testing y\n", - " N = num_qubit, # Number of qubits required\n", - " DEPTH = 1, # Circuit depth\n", - " EPOCH = 4, # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n", - " LR = 0.1, # Set the learning rate\n", - " BATCH = 4, # Batch size during training\n", - " )\n", - "plt.plot(acc)\n", - "plt.title(\"Classify Iris 0&1 using angle encoding\")\n", - "plt.xlabel(\"Iteration\")\n", - "plt.ylabel(\"Testing accuracy\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The second case is MNIST. It is a handwritten digit dataset and has 10 classes. Each figure has $28\\times28$ pixels, and downscaling methods such as ``resize`` and ``PCA`` should be used to transform it into the target dimension." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "epoch: 0 iter: 0 loss: 0.3237 train acc: 0.3250 test acc: 0.5450\n", - "epoch: 0 iter: 5 loss: 0.2124 train acc: 0.7500 test acc: 0.6500\n", - "epoch: 0 iter: 10 loss: 0.2294 train acc: 0.6500 test acc: 0.6850\n", - "epoch: 1 iter: 0 loss: 0.1970 train acc: 0.7250 test acc: 0.7850\n", - "epoch: 1 iter: 5 loss: 0.1521 train acc: 0.8500 test acc: 0.8150\n", - "epoch: 1 iter: 10 loss: 0.1726 train acc: 0.7750 test acc: 0.8900\n", - "epoch: 2 iter: 0 loss: 0.1742 train acc: 0.7250 test acc: 0.8650\n", - "epoch: 2 iter: 5 loss: 0.1167 train acc: 0.9000 test acc: 0.8900\n", - "epoch: 2 iter: 10 loss: 0.1654 train acc: 0.8000 test acc: 0.8950\n", - "epoch: 3 iter: 0 loss: 0.1609 train acc: 0.8000 test acc: 0.8850\n", - "epoch: 3 iter: 5 loss: 0.1148 train acc: 0.9250 test acc: 0.8850\n", - "epoch: 3 iter: 10 loss: 0.1649 train acc: 0.8000 test acc: 0.8750\n", - "epoch: 4 iter: 0 loss: 0.1629 train acc: 0.8250 test acc: 0.8750\n", - "epoch: 4 iter: 5 loss: 0.1112 train acc: 0.9000 test acc: 0.8700\n", - "epoch: 4 iter: 10 loss: 0.1630 train acc: 0.8500 test acc: 0.8850\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# using MNIST\n", - "\n", - "# main parameters\n", - "training_data_num = 500\n", - "testing_data_num = 200\n", - "qubit_num = 4\n", - "\n", - "# MNIST data with amplitude encoding, resized to 4*4\n", - "train_dataset = MNIST(mode='train', encoding='amplitude_encoding', num_qubits=qubit_num, classes=[3, 6],\n", - " data_num=training_data_num, need_cropping=True,\n", - " downscaling_method='resize', target_dimension=16, return_state=True)\n", - "\n", - "val_dataset = MNIST(mode='test', encoding='amplitude_encoding', num_qubits=qubit_num, classes=[3, 6],\n", - " data_num=testing_data_num, need_cropping=True,\n", - " downscaling_method='resize', target_dimension=16,return_state=True)\n", - "\n", - "quantum_train_x, train_y = train_dataset.quantum_image_states, train_dataset.labels\n", - "quantum_test_x, test_y = val_dataset.quantum_image_states, val_dataset.labels\n", - "\n", - "acc = QClassifier2(\n", - " quantum_train_x, # Training x\n", - " train_y, # Training y\n", - " quantum_test_x, # Testing x\n", - " test_y, # Testing y\n", - " N = qubit_num, # Number of qubits required\n", - " DEPTH = 3, # Circuit depth\n", - " EPOCH = 5, # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n", - " LR = 0.1, # Set the learning rate\n", - " BATCH = 40, # Batch size during training\n", - " )\n", - "\n", - "plt.plot(acc)\n", - "plt.title(\"Classify MNIST 3&6 using amplitude encoding\")\n", - "plt.xlabel(\"Iteration\")\n", - "plt.ylabel(\"Testing accuracy\")\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "_______\n", - "\n", - "## References\n", - "\n", - "\n", - "[1] Mitarai, Kosuke, et al. Quantum circuit learning. [Physical Review A 98.3 (2018): 032309.](https://arxiv.org/abs/1803.00745)\n", - "\n", - "[2] Farhi, Edward, and Hartmut Neven. Classification with quantum neural networks on near term processors. [arXiv preprint arXiv:1802.06002 (2018).](https://arxiv.org/abs/1802.06002)\n", - "\n", - "[3] Schuld, Maria, et al. Circuit-centric quantum classifiers. [Physical Review A 101.3 (2020): 032308.](https://arxiv.org/abs/1804.00633)\n", - "\n", - "[4] Schuld, Maria. Supervised quantum machine learning models are kernel methods. [arXiv preprint arXiv:2101.11020 (2021).](https://arxiv.org/pdf/2101.11020)" - ] - } - ], - "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.8.12" - }, - "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": true - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/tutorial/machine_learning/QKernel_CN.ipynb b/tutorial/machine_learning/QKernel_CN.ipynb deleted file mode 100644 index 2ebeb72..0000000 --- a/tutorial/machine_learning/QKernel_CN.ipynb +++ /dev/null @@ -1,751 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "instructional-length", - "metadata": {}, - "source": [ - "# 量子核方法\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "id": "desirable-compatibility", - "metadata": {}, - "source": [ - "## 概览\n", - "\n", - "在量子机器学习中，参数化量子电路（parameterized quantum circuit）扮演着重要的角色。在很多场景中，为了类比经典机器学习领域中的神经网络方法，我们也经常会把参数化量子电路称为量子神经网络。但是实际上，在量子机器学习的相关应用中，人们发现参数化量子电路的数学原理更类似于经典机器学习中的核方法（kernel methods）[1]。这种通过将量子计算和经典核方法相结合的思路以及研究方法，就被称为量子核方法（quantum kernel methods）。这两种方法的结合对于量子计算如何更好的解决一系列机器学习问题提供了全新的视角，因此在近年来收到了极大的关注 [2-7]。在本教程中，我们将探究如何用量子核方法结合支持向量机来实现数据分类。\n", - "\n", - "### 理论背景\n", - "\n", - "在经典机器学习中，核方法一般指的是将低维的数据向量通过特征映射（feature map）映射到高维的特征空间（feature space）中，来识别低维数据中难以分辨的模式的方法。如图1的例子所示，通过将一维的线性不可分数据映射到二维，映射后的数据在二维空间中是线性可分的。\n", - "\n", - "![feature map](./figures/Qkernel-fig-featuremap.png \"图1：核方法中的特征映射\")\n", - "
图1：核方法中的特征映射
\n", - "\n", - "不过，在实际应用中，由于特征空间的维数可能会十分巨大，我们往往并不希望直接对映射后的特征向量进行分析。相反，通过核方法中的另一个核心概念-核函数（kernel function），我们可以隐式地引入特征映射在模式识别上的优势。核函数的定义为数据向量在特征空间里的内积，其具体形式为\n", - "\n", - "$$\n", - "K(\\mathbf{x}_i, \\mathbf{x}_j) = \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i),\n", - "\\tag{1}\n", - "$$\n", - "\n", - "其中 $\\phi()$ 就代表着特征映射。需要注意的是，在核方法中我们并不需要显式地写出特征映射，而只需要定义核函数的形式即可。\n", - "\n", - "在经典机器学习中，核方法最具代表性的应用就是支持向量机（support vector machine, SVM）。简单的来说，支持向量机解决的是线性分类问题：以一个二分类的问题举例，我们的数据集为 $T = \\{ (\\mathbf{x}_1, y_1), ..., (\\mathbf{x}_m, y_m) \\} \\subset \\mathcal{X}\\times\\mathbb{Z}_2$，通过一个超平面 $(\\mathbf{w}, b)$，支持向量机可以通过如下决策函数的正负来预测每个数据点 $\\mathbf{x}$ 的标签：\n", - "\n", - "$$\n", - "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}, \\mathbf{x} \\rangle + b).\n", - "\\tag{2}\n", - "$$\n", - "\n", - "但是对于在原始数据空间中线性不可分的数据而言，这样的做法往往并不可行。所以如图1所示，通过引入我们上文中提到的特征映射，我们可以将原始数据空间中的数据向量映射到特征空间中来进行分类，从而得到更好的分类效果。此时，我们标记特征空间中的超平面为 $(\\mathbf{w}', b')$, 我们的决策函数就变成了：\n", - "\n", - "$$\n", - "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}', \\phi(\\mathbf{x}) \\rangle + b').\n", - "\\tag{3}\n", - "$$\n", - "\n", - "更进一步的是，我们可以通过对偶化的方法，引入拉格朗日乘子 $\\alpha_i$ 来表示此时的分割超平面 $\\mathbf{w}' = \\sum_i \\alpha_i \\phi(\\mathbf{x_i})$ [8]。此时，我们可以在 $\\alpha_i \\geq 0$，$\\sum_i y_i \\alpha_i=0$ 的约束下，通过最大化\n", - "\n", - "$$\n", - "\\sum_i \\alpha_i - \\frac{1}{2} \\sum_{i, j} \\alpha_i \\alpha_j y_i y_j \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i)\n", - "\\tag{4}\n", - "$$\n", - "\n", - "来计算最优参数 $\\alpha_i^*$。不难发现，此时我们只需要计算数据向量在特征空间里的内积 $\\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i) = K(x_i, x_j)$，正是我们上文中提到的核函数。换言之，在支持向量机中，我们不需要显式地知道特征映射的形式，而只需要计算原始数据在特征空间里的内积，就可以实现在特征空间中对数据进行分类。并且，对于任何新的数据向量 $\\mathbf{x}'$，我们只需要通过核函数 $K(,)$ 计算\n", - "\n", - "$$\n", - "y_{\\rm pred} = {\\rm sign}(\\sum_i \\alpha^*_i \\langle \\phi(\\mathbf{x_i}), \\phi(\\mathbf{x}' \\rangle + b') = \n", - "{\\rm sign}(\\sum_i \\alpha^*_i K(\\mathbf{x}_i, \\mathbf{x}') + b'),\n", - "\\tag{5}\n", - "$$\n", - "\n", - "就可以对数据的标签进行预测。\n", - "\n", - "借助这种思想，我们就可以很简单的理解量子核方法的内涵。首先，我们引入量子特征空间的概念，即我们认为我们通过一个编码电路 $U(\\mathbf{x}) $ 将经典数据向量 $\\mathbf{x} $ 编码到某个量子态 $| \\phi(\\mathbf{x}) \\rangle$ 上：\n", - "\n", - "$$\n", - "U(\\mathbf{x}) | 0^{\\otimes N} \\rangle = | \\phi(\\mathbf{x}) \\rangle.\n", - "\\tag{6}\n", - "$$ \n", - "\n", - "关于编码电路的具体形式我们这里不做展开，感兴趣的读者可以阅读我们的[编码教程](./DataEncoding_CN.ipynb)来了解不同的量子编码电路形式。此时我们的量子特征映射就是从经典数据空间到量子态所处的希尔伯特空间的一种特殊特征映射。在这个基础上，我们将量子核函数（quantum kernel function）定义为经典数据向量在量子特征空间的内积，其具体形式就为\n", - "\n", - "$$\n", - "K^Q_{ij} = |\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2,\n", - "\\tag{7}\n", - "$$\n", - "\n", - "上式可以进一步写为\n", - "\n", - "$$\n", - "|\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2 = |\\langle 0^{\\otimes N} | U^\\dagger(\\mathbf{x}_j) U(\\mathbf{x}_i) | 0^{\\otimes N} \\rangle |^2.\n", - "\\tag{8}\n", - "$$\n", - "\n", - "不难发现，通过运行如图2中所示的量子电路，并在统计其测量结果为 $| 0^{\\otimes N} \\rangle $ 的概率，我们就可以估计式（8）中的量子核函数。这种方法也被称为量子核估计（quantum kernel estimation, QKE）方法。也就是说，如果我们通过量子核估计方法来计算式（4-5) 中的核函数的话，我们就可以利用支持向量机的方法在量子特征空间来完成数据分类。借助量子特征映射的量子性，人们希望这种量子核方法可以更好地分类具有复杂模式的数据。人们已经证明，通过精心设计量子特征映射，量子核方法就可以用来分辨任何经典方法都无法识别的数据模式 [3]。\n", - "\n", - "![QKE](./figures/Qkernel-fig-QKE.png \"图2：量子核估计电路\")\n", - "
图2：量子核估计电路
\n", - "\n", - "![illustration](./figures/Qkernel-fig-illustrationCN.png \"图3：经典核方法和量子核方法的对比示意图\")\n", - "
图3：经典核方法和量子核方法的对比示意图
" - ] - }, - { - "cell_type": "markdown", - "id": "willing-shopping", - "metadata": {}, - "source": [ - "### 拓展：量子机器学习和核方法的联系\n", - "\n", - "在量子机器学习中，往往我们量子电路中的一部分需要将经典的数据编码到其对应的量子态上，其数学形式为：\n", - "\n", - "$$\n", - "| \\phi(x) \\rangle = U (x) | 0^{\\otimes N} \\rangle,\n", - "\\tag{9}\n", - "$$\n", - "\n", - "其中 $U(x)$ 是一个取决于经典数据 $x$ 的参数化电路。正如我们上文中提到的，这种编码的过程可以被考虑成是一种从经典数据空间到量子特征空间的特殊特征映射。同时，考虑一个作用在编码量子态上的量子神经网络电路，其数学形式为：\n", - "\n", - "$$\n", - "| \\psi \\rangle = U_{\\rm QNN}(\\theta)U (\\mathbf{x}) | 0^{\\otimes N} \\rangle,\n", - "\\tag{10}\n", - "$$\n", - "\n", - "其中 $U_{\\rm QNN}(\\theta)$ 为代表量子神经网络的参数化量子电路，$\\theta$ 为其中的参数。我们在电路的最后进行测量，该测量用 $\\mathcal{M}$ 表示。这时，我们测得的期望值为\n", - "\n", - "$$\n", - "\\langle \\mathcal{M} \\rangle = \\langle \\psi | \\mathcal{M} | \\psi \\rangle = \\langle \\phi(\\mathbf{x}) | U^\\dagger_{\\rm QNN}(\\theta) \\mathcal{M} U_{\\rm QNN}(\\theta)| \\phi(\\mathbf{x}) \\rangle.\n", - "\\tag{11}\n", - "$$\n", - "\n", - "我们不妨将测量写成算符的形式 $| \\sigma \\rangle \\langle \\sigma |$ ，那么式（11）就可以进一步被写为\n", - "\n", - "$$\n", - "\\langle \\phi(\\mathbf{x}) | \\sigma'(\\theta) \\rangle \\langle \\sigma' (\\theta) | \\phi(x) \\rangle = \n", - "|\\langle \\sigma' (\\theta) | \\phi(\\mathbf{x}) \\rangle|^2,\n", - "\\tag{12}\n", - "$$\n", - "\n", - "其中 $| \\sigma'(\\theta) \\rangle = U^\\dagger_{\\rm QNN}(\\theta) | \\sigma \\rangle$。这样的话，我们发现我们这种基于量子神经网络的测量结果也可以被认为是量子特征空间中两个量子特征向量的内积：$|\\langle \\sigma' (\\theta) | \\phi(\\mathbf{x}) \\rangle|^2$。\n", - "而该内积，正是我们前文中提到的量子核函数，只不过其中一个特征向量是由一个参数化的测量所描述的。这也就是我们在本教程的一开始提到，量子神经网络模型的数学形式实际上更接近于经典机器学习中的核方法的原因。" - ] - }, - { - "cell_type": "markdown", - "id": "tutorial-vocabulary", - "metadata": {}, - "source": [ - "## 示例：利用量子核方法来解决分类问题\n", - "\n", - "> 本教程需要使用 [`sklearn`](https://scikit-learn.org/stable/install.html) 中的相关函数来实现支持向量机的功能。需要的读者可以运行下面的代码块来安装相关模块：" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "informative-miami", - "metadata": {}, - "outputs": [], - "source": [ - "from IPython.display import clear_output\n", - "\n", - "!pip install scikit-learn\n", - "clear_output()" - ] - }, - { - "cell_type": "markdown", - "id": "emerging-anxiety", - "metadata": {}, - "source": [ - "下面，我们用一个简单的例子来展示如何在 Paddle Quantum 中模拟量子核估计电路，并将其应用在一个实际的分类任务上。" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "acting-nursery", - "metadata": {}, - "outputs": [], - "source": [ - "import time\n", - "import matplotlib\n", - "import numpy as np\n", - "import paddle\n", - "from numpy import pi as PI\n", - "from matplotlib import pyplot as plt\n", - "\n", - "from paddle import matmul, transpose\n", - "from paddle_quantum.circuit import UAnsatz\n", - "\n", - "import sklearn\n", - "from sklearn import svm\n", - "from sklearn.datasets import fetch_openml, make_moons, make_circles\n", - "from sklearn.model_selection import train_test_split\n", - "\n", - "from IPython.display import clear_output\n", - "from tqdm import tqdm" - ] - }, - { - "cell_type": "markdown", - "id": "fluid-rating", - "metadata": {}, - "source": [ - "首先，我们生成两类线性不可分的二维圆形数据点作为我们的训练集和测试集。" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "turkish-energy", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "先来看一下我们的训练集和测试集:\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 生成训练集和测试集\n", - "X_train, y_train = make_circles(10, noise=0.05, factor=0.2)\n", - "X_test, y_test = make_circles(10, noise=0.05, factor=0.2)\n", - "\n", - "# 将生成的数据集进行可视化\n", - "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n", - "ax[0].scatter(X_train[:,0], X_train[:,1], \n", - " marker='o', c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)))\n", - "ax[0].set_title('Train')\n", - "ax[1].set_title('Test')\n", - "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)))\n", - "\n", - "print(\"先来看一下我们的训练集和测试集:\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "federal-representation", - "metadata": {}, - "outputs": [], - "source": [ - "# 初始化进度条\n", - "bar_format_string = '{l_bar}{bar}|[{elapsed}<{remaining}, ' '{rate_fmt}{postfix}]'\n", - "pbar = tqdm(total=100, bar_format=bar_format_string)\n", - "pbar.close()\n", - "clear_output()" - ] - }, - { - "cell_type": "markdown", - "id": "educated-permission", - "metadata": {}, - "source": [ - "下面，我们来用 PaddleQuantum 来搭建量子核函数的计算电路：" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "every-competition", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "检查是否满足 K(x, x) = 1？ True\n" - ] - } - ], - "source": [ - "# 初始化一个用来更新进度条的全局变量\n", - "N = 1\n", - "\n", - "# 通过 paddle quantum 模拟的 QKE 电路\n", - "def q_kernel_estimator(x1, x2):\n", - " \n", - " # 将数据类型转换为 tensor\n", - " x1 = paddle.to_tensor(x1)\n", - " x2 = paddle.to_tensor(x2)\n", - " \n", - " # 创建电路\n", - " cir = UAnsatz(2)\n", - " \n", - " # 添加对应第一个数据的编码电路\n", - " cir.iqp_encoding(x1, pattern=[[0, 1]])\n", - " \n", - " # 添加对应第二个数据的编码电路的逆电路\n", - " cir.iqp_encoding(x2, pattern=[[0, 1]], invert=True)\n", - " \n", - " # 用态矢量模式运行电路\n", - " fin_state = cir.run_state_vector()\n", - " \n", - " # 更新进度条\n", - " global pbar\n", - " global N\n", - " pbar.update(100/N)\n", - " \n", - " # 返回测量结果为 0...0 的概率\n", - " return (fin_state[0].conj() * fin_state[0]).real().numpy()[0]\n", - "\n", - "# 按照规范定义需要传入的 Kernel 矩阵函数\n", - "# 按照规范，输入应为两个数据列表\n", - "def q_kernel_matrix(X1, X2):\n", - " return np.array([[q_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])\n", - "\n", - "# 可视化决策函数（预测值），以及决策边界\n", - "def visualize_decision_bound(clf):\n", - " \n", - " # 创建一个 10x10 的网格\n", - " x_min, x_max = X_train[:,0].min(), X_train[:,0].max()\n", - " y_min, y_max = X_train[:,1].min(), X_train[:,1].max()\n", - " XX, YY = np.meshgrid(np.linspace(-1.2, 1.2, 10), \n", - " np.linspace(-1.2, 1.2, 10))\n", - " \n", - " # 计算分类器该网格上的预测值\n", - " Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()])\n", - " Z_qke = Z.reshape(XX.shape)\n", - " \n", - " # 可视化决策函数，以及决策边界\n", - " clear_output()\n", - " plt.contourf(XX, YY, Z_qke ,vmin=-1., vmax=1., levels=20,\n", - " cmap=matplotlib.cm.coolwarm, alpha=1)\n", - " plt.scatter(X_train[:,0], X_train[:,1], \n", - " c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)),\n", - " edgecolor='black')\n", - " plt.scatter(X_test[:,0], X_test[:,1], marker='v', \n", - " c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)),\n", - " edgecolor='black')\n", - " plt.contour(XX, YY, Z_qke, colors=['k', 'k', 'k'], linestyles=['--', '-', '--'],\n", - " levels=[-.2, 0, .2])\n", - "\n", - "# 作为检查量子核函数是否运行正常，我们可以检查 K(x, x) 是否等于 1\n", - "# 提示：根据内积的定义 = 1\n", - "print('检查是否满足 K(x, x) = 1？',\n", - " bool(abs(q_kernel_estimator(np.array([1. ,1.]), np.array([1., 1.])) - 1) < 1e-8))" - ] - }, - { - "cell_type": "markdown", - "id": "requested-cameroon", - "metadata": {}, - "source": [ - "接下来，让我们尝试用量子核支持向量机（QKE-SVM）来进行数据分类：" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "caring-daily", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "让我们看一下量子核支持向量机的分类效果如何:\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 创建进度条，并设置所需要的量子核函数计算数量 N\n", - "pbar = tqdm(total=100, \n", - " desc='训练 QKE-SVM 并分类中', \n", - " bar_format=bar_format_string)\n", - "N = len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test)\n", - "\n", - "# 创建一个具有量子核函数的支持向量机\n", - "svm_qke = svm.SVC(kernel=q_kernel_matrix)\n", - "\n", - "# 根据训练数据计算支持向量机的决策平面\n", - "svm_qke.fit(X_train, y_train)\n", - "\n", - "# 计算支持向量机分别对于训练数据和测试数据的分类预测值\n", - "predict_svm_qke_train = svm_qke.predict(X_train)\n", - "predict_svm_qke_test = svm_qke.predict(X_test)\n", - "\n", - "# 计算准确率\n", - "accuracy_train = np.array(predict_svm_qke_train == y_train, dtype=int).sum()/len(y_train)\n", - "accuracy_test = np.array(predict_svm_qke_test == y_test, dtype=int).sum()/len(y_test)\n", - "\n", - "# 可视化分类预测结果\n", - "pbar.close()\n", - "clear_output()\n", - "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n", - "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n", - " c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_train, dtype=np.float32)))\n", - "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n", - "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n", - " c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_test, dtype=np.float32)))\n", - "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n", - "print(\"让我们看一下量子核支持向量机的分类效果如何:\")" - ] - }, - { - "cell_type": "markdown", - "id": "distinguished-dependence", - "metadata": {}, - "source": [ - "更进一步的，我们还可以检查此时的决策函数平面以及决策边界：" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "universal-genome", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "计算 QKE-SVM 的决策函数中: 100%|█████████████████████████████████████████████████████████████▉|[01:26<00:00, 1.16it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 创建进度条，并设置所需要的量子核函数计算数量 N\n", - "pbar = tqdm(total=100, \n", - " desc='计算 QKE-SVM 的决策函数中', \n", - " bar_format=bar_format_string)\n", - "N = 10 ** 2 * len(X_train)\n", - " \n", - "# 可视化决策函数平面\n", - "visualize_decision_bound(svm_qke)\n", - "pbar.close()" - ] - }, - { - "cell_type": "markdown", - "id": "transsexual-swift", - "metadata": {}, - "source": [ - "可以看到，量子核函数可以很好的学习到数据中的非线性特征。实际上，量子核方法的表现取决于量子特征映射的设计。并且，对于如何设计更好的量子核函数的探究才刚刚开始：一方面，我们可以尝试不同的数据编码方式；另一方面，我们可以尝试通过训练量子特征映射的方式提升分类效果 [5-6]；最后，我们还可以尝试一些不同的量子核函数形式 [7]。\n", - "\n", - "下面，作为拓展，我们也将展示一种特殊的量子核函数:投影量子核函数（projected quantum kernel）。" - ] - }, - { - "cell_type": "markdown", - "id": "scenic-circuit", - "metadata": {}, - "source": [ - "### 拓展：投影量子核函数\n", - "\n", - "上文中已经提到，量子核方法通过将经典信息映射到潜在的高维量子特征空间来分辨在经典空间不可分的信息。但是，当我们的量子特征空间-希尔伯特空间的维度太大的时候，所有映射到希尔伯特空间的量子态都会接近于相互垂直的状态，此时的核矩阵将会近似的变成一个单位矩阵 $K_{ij} = K(\\mathbf{x}_j, \\mathbf{x}_i) \\sim {I}$。为了避免这种维度问题的出现，我们需要首先从高维希尔伯特空间提取出足够的低维信息。投影量子核方法就是遵循了这个思路，即将量子态投影到新的经典空间，再在这个新的经典空间使用核方法。我们可以认为每一个投影是从不同的角度去观测希尔伯特空间的量子态，从足够多的角度测量这个量子态可以使我们获得足够重构这个态的经典信息。但在实际应用中，通常只需要从几个角度测量就能得到比较好的结果 [5]。 由于这个经典空间保留了部分希尔伯特空间中的重要特征，所以信息在这个经典空间的可分性优于原来的经典空间。\n", - "\n", - "投影量子核函数有很多不同的形式，这里我们举一个最为代表性的作为例子：\n", - "\n", - "$$\n", - "K^{PQ}(x_i,x_j) = \\exp\\left(-\\gamma\\sum\\limits_{k}\\sum\\limits_{P\\in \\mathcal{M}}( {\\rm Tr} (P\\rho(x_i)_k)-{\\rm Tr}(P\\rho(x_j)_k))^{2}\\right),\n", - "\\tag{13}\n", - "$$\n", - "\n", - "其中 $k$ 是用来标记多量子比特约化密度矩阵的下标，$\\mathcal{M}$ 是一个作用在多量子比特约化密度矩阵上的测量的集合。在这里，我们取 $k = 0, 1$，即两个单量子比特的约化密度矩阵，$M = \\{X, Y, Z \\}$，即一组 Pauli 测量。\n", - "\n", - "我们先尝试用 Paddle Quantum 来实现对应的投影量子核电路：" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "artificial-hierarchy", - "metadata": {}, - "outputs": [], - "source": [ - "# 因为这次我们的特征映射的特征空间也是经典的，我们不妨先把该映射写出来\n", - "def projected_q_feature_map(x):\n", - " cir = UAnsatz(2)\n", - "\n", - " # 将经典数据转换为 Tensor\n", - " x = paddle.to_tensor(x)\n", - " \n", - " # 编码经典数据到对应的量子态上\n", - " cir.iqp_encoding(x, pattern=[[0, 1]])\n", - " \n", - " # 运行电路\n", - " cir.run_state_vector()\n", - " \n", - " # 更新进度条\n", - " global N\n", - " pbar.update(100/N)\n", - " \n", - " # 进行投影测量，返回其期望值作为经典特征向量\n", - " return [cir.expecval([[1.0, op_pauli]]).numpy()[0] \n", - " for op_pauli in ['z0', 'z1', 'x0', 'x1', 'y0', 'y1']]\n", - "\n", - "# 按照上文公式计算投影量子核函数\n", - "def p_quantum_kernel_estimator(x1, x2):\n", - " \n", - " # 分别得到特征向量，并计算核函数\n", - " p_feature_vector_1 = np.array(projected_q_feature_map(x1))\n", - " p_feature_vector_2 = np.array(projected_q_feature_map(x2))\n", - " \n", - " return np.exp(-((p_feature_vector_1 - p_feature_vector_2) ** 2).sum())\n", - "\n", - "# 类似地，按照规范定义传入支持向量机的核函数\n", - "def p_quantum_kernel_matrix(X1, X2):\n", - " return np.array([[p_quantum_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])" - ] - }, - { - "cell_type": "markdown", - "id": "baking-bridges", - "metadata": {}, - "source": [ - "接下来，让我们看一下如何用投影量子核支持向量机（PQK-SVM）来进行数据分类：" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "chronic-terrorist", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "让我们看一下投影量子核支持向量机的分类效果如何:\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 创建进度条，并设置所需要的量子核函数计算数量 N\n", - "pbar = tqdm(total=100, \n", - " desc='训练 PQK-SVM 并分类中', \n", - " bar_format=bar_format_string)\n", - "N = 2 * (len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test))\n", - "\n", - "# 创建一个具有投影量子核函数的支持向量机\n", - "svm_pqk = svm.SVC(kernel=p_quantum_kernel_matrix)\n", - "\n", - "# 根据训练数据计算支持向量机的决策平面\n", - "svm_pqk.fit(X_train, y_train)\n", - "\n", - "# 计算支持向量机分别对于训练数据和测试数据的分类预测值\n", - "predict_svm_pqk_train = svm_pqk.predict(X_train)\n", - "predict_svm_pqk_test = svm_pqk.predict(X_test)\n", - "\n", - "# 计算准确率\n", - "accuracy_train = np.array(predict_svm_pqk_train == y_train, dtype=int).sum()/len(y_train)\n", - "accuracy_test = np.array(predict_svm_pqk_test == y_test, dtype=int).sum()/len(y_test)\n", - "\n", - "# 可视化分类结果\n", - "pbar.close()\n", - "clear_output()\n", - "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n", - "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n", - " c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_train, dtype=np.float32)))\n", - "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n", - "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n", - " c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_test, dtype=np.float32)))\n", - "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n", - "print(\"让我们看一下投影量子核支持向量机的分类效果如何:\")" - ] - }, - { - "cell_type": "markdown", - "id": "irish-embassy", - "metadata": {}, - "source": [ - "同样的，我们检查一下此时的决策函数平面以及决策边界：" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "chief-beach", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "计算 PQK-SVM 决策函数中: 100%|███████████████████████████████████████████████████████████████▉|[02:49<00:00, 1.69s/it]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 创建进度条，并设置所需要的量子核函数计算数量 N\n", - "pbar = tqdm(total=100, \n", - " desc='计算 PQK-SVM 决策函数中', \n", - " bar_format=bar_format_string)\n", - "N = 2 * 10 ** 2 * len(X_train)\n", - " \n", - "# 可视化决策函数平面\n", - "visualize_decision_bound(svm_pqk)\n", - "pbar.close()" - ] - }, - { - "cell_type": "markdown", - "id": "continuous-chance", - "metadata": {}, - "source": [ - "## 总结\n", - "\n", - "在量子机器学习的研究中，研究者们希望借助量子力学的特点设计出可以超越经典机器学习方法的模型。随着该领域的研究越发深入，人们发现量子机器学习和传统机器学习可以通过核方法建立起深入的联系。相比“传统”的量子神经网络，量子核方法把研究的重点放在了从经典数据空间到量子希尔伯特空间的特征映射，而不是变分量子电路。这为量子机器学习带来了新的研究思路，并为设计出实用的量子算法带来了新的可能性。因此，我们鼓励读者一起来思考如何设计出更好的量子核函数，并将其应用在更多样的数据集上。" - ] - }, - { - "cell_type": "markdown", - "id": "intimate-bible", - "metadata": {}, - "source": [ - "---\n", - "\n", - "## 参考资料\n", - "\n", - "[1] Schuld, Maria. \"Supervised quantum machine learning models are kernel methods.\" arXiv preprint [arXiv:2101.11020 (2021)](https://arxiv.org/abs/2101.11020).\n", - "\n", - "[2] Havlíček, Vojtěch, et al. \"Supervised learning with quantum-enhanced feature spaces.\" [Nature 567.7747 (2019): 209-212](https://arxiv.org/abs/1804.11326).\n", - "\n", - "[3] Liu, Yunchao, Srinivasan Arunachalam, and Kristan Temme. \"A rigorous and robust quantum speed-up in supervised machine learning.\" arXiv preprint [arXiv:2010.02174 (2020)](https://arxiv.org/abs/2010.02174).\n", - "\n", - "[4] Schuld, Maria, and Nathan Killoran. \"Quantum machine learning in feature Hilbert spaces.\" [Phys. Rev. Lett. 122.4 (2019): 040504](https://arxiv.org/abs/1803.07128).\n", - "\n", - "[5] Hubregtsen, Thomas, et al. \"Training Quantum Embedding Kernels on Near-Term Quantum Computers.\" arXiv preprint [arXiv:2105.02276(2021)](https://arxiv.org/abs/2105.02276).\n", - "\n", - "[6] Glick, Jennifer R., et al. \"Covariant quantum kernels for data with group structure.\" arXiv preprint [arXiv:2105.03406(2021)](https://arxiv.org/abs/2105.03406).\n", - "\n", - "[7] Huang, Hsin-Yuan, et al. \"Power of data in quantum machine learning.\" arXiv preprint [arXiv:2011.01938 (2020)](https://arxiv.org/abs/2011.01938).\n", - "\n", - "[8] Schölkopf, Bernhard, and Alexander J. Smola\"Learning with kernels: support vector machines, regularization, optimization, and beyond.\" [MIT Press(2002)](https://mitpress.mit.edu/books/learning-kernels)." - ] - } - ], - "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" - }, - "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 - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorial/machine_learning/QKernel_EN.ipynb b/tutorial/machine_learning/QKernel_EN.ipynb deleted file mode 100644 index b30991c..0000000 --- a/tutorial/machine_learning/QKernel_EN.ipynb +++ /dev/null @@ -1,748 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "white-energy", - "metadata": {}, - "source": [ - "# Quantum Kernel Methods\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "id": "perfect-marker", - "metadata": {}, - "source": [ - "## Introduction\n", - "\n", - "One of the most important learning models for quantum machine learning applications in the noisy intermediate-scale quantum (NISQ) era is the parameterized quantum circuit. Although given its obvious analogy to classical neural networks, many refer to such quantum models as \"quantum neural networks\", it was shown that the mathematical form of such quantum machine learning models is actually much closer to kernel methods, a different kind of classical learning approach [1]. By combining classical kernel methods and the power of quantum models, quantum kernel methods can shed new light on how to approach a variety of machine learning problems, thus raising great interest in the field of quantum machine learning [2-7]. In this tutorial, we will introduce the basic ideas of quantum kernel methods and demonstrate how to classify data with two different quantum kernels.\n", - "\n", - "### Background\n", - "\n", - "In classical machine learning, kernel methods' basic idea is to map a low-dimensional data vector into a potentially high-dimensional feature space via a feature map, thus giving us the possibility to use linear methods to analyze non-linear features in the original data. As shown in Fig. 1, by mapping linearly inseparable 1D data into a 2D feature space, the feature vectors of the original data become linearly separable.\n", - "\n", - "![feature map](./figures/Qkernel-fig-featuremap.png \"Figure 1. feature map in kernel methods\")\n", - "
Figure 1. feature map in kernel methods
\n", - "\n", - "In practice, the feature space's dimensionality sometimes can be extremely large (even goes to infinity). So we do not wish to tackle these feature vectors directly. Another key idea in kernel methods is that we can implicitly analyze these feature vectors by only accessing their inner products in the feature space, which is noted as kernel functions $K(,)$:\n", - "\n", - "$$\n", - "K(\\mathbf{x}_i, \\mathbf{x}_j) = \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i),\n", - "\\tag{1}\n", - "$$\n", - "\n", - "with $\\phi()$ being the feature map. We note that in kernel methods, we do not need to express the feature map explicitly. Instead, we only need to compute the kernel function. This approach can introduce non-linearity into our models, giving us the ability to recognize intractable patterns in the original data space. \n", - "\n", - "The arguably most famous application of kernel methods is the support vector machine (SVM), which solves linear classification problems. Take a 2-classification problem as an example: Given data set $T = \\{ (\\mathbf{x}_1, y_1), ..., (\\mathbf{x}_m, y_m) \\} \\subset \\mathcal{X}\\times\\mathbb{Z}_2$, with a hyperplane $( \\mathbf{w}, b)$, a support vector machine can assign labels via the signs of the decision function, as:\n", - "\n", - "$$\n", - "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}, \\mathbf{x} \\rangle + b).\n", - "\\tag{2}\n", - "$$\n", - "\n", - "But for linearly inseparable data, such linear classification schemes do not work. So again, as shown in Fig. 1, we can potentially find a better separation by mapping them into a feature space. For example, if we note the separating hyperplane in the feature space as $(\\mathbf{w}', b')$, then the decision function becomes:\n", - "\n", - "$$\n", - "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}', \\phi(\\mathbf{x}) \\rangle + b').\n", - "\\tag{3}\n", - "$$\n", - "\n", - "Furthermore, by duality, we can write the hyperplane as $\\mathbf{w}' = \\sum_i \\alpha_i \\phi(\\mathbf{x_i})$ with Lagrangian multipliers $\\alpha_i$ [8]. Then, under the constraints $\\alpha_i \\geq 0$ and $\\sum_i y_i \\alpha_i=0$, we can compute the optimal $\\alpha_i^*$, thus the optimal hyperplane by maximizing \n", - "\n", - "$$\n", - "\\sum_i \\alpha_i - \\frac{1}{2} \\sum_{i, j} \\alpha_i \\alpha_j y_i y_j \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i).\n", - "\\tag{4}\n", - "$$\n", - "\n", - "Notice that in Eq. (4), we only need the inner products of feature vectors $\\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i) = K(x_i, x_j)$, which is the above mentioned kernel function. As a result, we are able to find the optimal separating hyperplane in the feature space with SVM by only accessing the feature space through the kernel function. Furthermore, we can compute the predicted label as follows:\n", - "\n", - "$$\n", - "y_{\\rm pred} = {\\rm sign}(\\sum_i \\alpha^*_i \\langle \\phi(\\mathbf{x_i}), \\phi(\\mathbf{x}' \\rangle + b') = \n", - "{\\rm sign}(\\sum_i \\alpha^*_i K(\\mathbf{x}_i, \\mathbf{x}') + b').\n", - "\\tag{5}\n", - "$$\n", - "\n", - "Again, only kernel function is needed. \n", - "\n", - "Given the idea of classical kernel methods, we can easily understand the essential idea of quantum kernel methods. First, consider a quantum feature space, where we map a classical data vector $\\mathbf{x}$ into a quantum state $| \\phi(\\mathbf{x})\\rangle$ by a encoding circuit $U(\\mathbf{x})$ as follows:\n", - "\n", - "$$\n", - "U(\\mathbf{x}) | 0^{\\otimes N} \\rangle = | \\phi(\\mathbf{x}) \\rangle.\n", - "\\tag{6}\n", - "$$\n", - "\n", - "There are many discussions about how to best design an encoding circuit. We refer to our [data encoding tutorial](./DataEncoding_EN.ipynb) for a more detailed explanation. The encoding can also be regarded as a quantum feature map from classical data space to the Hilbert space. Based on this idea, we define a quantum kernel function as the inner products of two quantum feature vectors in the Hilbert space, which is\n", - "\n", - "$$\n", - "K^Q_{ij} = |\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2,\n", - "\\tag{7}\n", - "$$\n", - "\n", - "which can be further formulated as\n", - "\n", - "$$\n", - "|\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2 = |\\langle 0^{\\otimes N} | U^\\dagger(\\mathbf{x}_j) U(\\mathbf{x}_i) | 0^{\\otimes N} \\rangle |^2.\n", - "\\tag{8}\n", - "$$\n", - "\n", - "By running the quantum circuit as shown in Fig. 2, and measure the probability of observing $| 0^{\\otimes N} \\rangle $ at the output, we can estimate the quantum kernel function in Eq. (8). This way of constructing quantum kernels is also known as quantum kernel estimation (QKE). By replacing the classical kernel function in Eq. (4-5) with QKE, we can classify data in the quantum feature space with SVM. Given the potentially non-simulatable nature of such quantum kernels, there might exist a quantum advantage in recognizing classically intractable patterns. Such an advantage has been rigorously shown, with a constructed classically hard classification problem and a carefully designed quantum feature map [3].\n", - "\n", - "![QKE](./figures/Qkernel-fig-QKE.png \"Figure 2. Quantum kernel estimation circuit\")\n", - "
Figure 2. Quantum kernel estimation circuit
\n", - "\n", - "![illustration](./figures/Qkernel-fig-illustrationEN.png \"Figure 3. Classical kernel methods and quantum kernel methods\")\n", - "
Figure 3. Classical kernel methods and quantum kernel methods
" - ] - }, - { - "cell_type": "markdown", - "id": "parental-tampa", - "metadata": {}, - "source": [ - "### Connections between quantum machine learning and kernel methods\n", - "\n", - "In quantum machine learning models, a quantum encoding circuit is often used to encode classical data into a quantum state\n", - "\n", - "$$\n", - "| \\phi(x) \\rangle = U (x) | 0^{\\otimes N} \\rangle,\n", - "\\tag{9}\n", - "$$\n", - "\n", - "where $U(x)$ is a parameterized quantum circuit depending on the data vector $x$. Like we mentioned above, such quantum encoding circuit can be considered as a quantum feature map. Then, consider a \"quantum neural network\" is applied to the encoding state, in which the quantum circuit is composed of a set of parameterized gates with variational parameters. We have the final state as\n", - "\n", - "$$\n", - "| \\psi \\rangle = U_{\\rm QNN}(\\theta)U (\\mathbf{x}) | 0^{\\otimes N} \\rangle,\n", - "\\tag{10}\n", - "$$\n", - "\n", - "where $U_{\\rm QNN}(\\theta)$ is the quantum neural network with parameters $\\theta$. Finally we perform a measurement $\\mathcal{M}$ on the final state as the output of our model, its expectation value can be computed as\n", - "\n", - "$$\n", - "\\langle \\mathcal{M} \\rangle = \\langle \\psi | \\mathcal{M} | \\psi \\rangle = \\langle \\phi(\\mathbf{x}) | U^\\dagger_{\\rm QNN}(\\theta) \\mathcal{M} U_{\\rm QNN}(\\theta)| \\phi(\\mathbf{x}) \\rangle.\n", - "\\tag{11}\n", - "$$\n", - "\n", - "Suppose we write the measurement in its operator form $| \\sigma \\rangle \\langle \\sigma |$, then Eq. (11) can be further reformulated as \n", - "\n", - "$$\n", - "\\langle \\phi(\\mathbf{x}) | \\sigma'(\\theta) \\rangle \\langle \\sigma' (\\theta) | \\phi(x) \\rangle = \n", - "|\\langle \\sigma' (\\theta) | \\phi(\\mathbf{x}) \\rangle|^2,\n", - "\\tag{12}\n", - "$$\n", - "\n", - "where $| \\sigma'(\\theta) \\rangle = U^\\dagger_{\\rm QNN}(\\theta) | \\sigma \\rangle$. From Eq. (12), QNN together with a measurement can also be seen as a parameterized measurement operator, which is used to compute the inner product with the data encoding state in the Hilbert space, which is, the kernel function. This is why we mentioned in the introduction that the mathematical form of parameterized quantum circuits is closely related to kernel methods." - ] - }, - { - "cell_type": "markdown", - "id": "adequate-association", - "metadata": {}, - "source": [ - "## Kernel-based Classification with Paddle Quantum\n", - "\n", - "> It is required to have [`sklearn`](https://scikit-learn.org/stable/install.html) packages installed for the support vector machine. Readers may run the following block to install the relevant packages:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "automatic-timeline", - "metadata": {}, - "outputs": [], - "source": [ - "from IPython.display import clear_output\n", - "\n", - "!pip install scikit-learn\n", - "clear_output()" - ] - }, - { - "cell_type": "markdown", - "id": "existing-devon", - "metadata": {}, - "source": [ - "In this tutorial, we will demonstrate how to classify data using a support vector machine with a kernel computed by Paddle Quantum." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "literary-feature", - "metadata": {}, - "outputs": [], - "source": [ - "import time\n", - "import matplotlib\n", - "import numpy as np\n", - "import paddle\n", - "from numpy import pi as PI\n", - "from matplotlib import pyplot as plt\n", - "\n", - "from paddle import matmul, transpose\n", - "from paddle_quantum.circuit import UAnsatz\n", - "\n", - "import sklearn\n", - "from sklearn import svm\n", - "from sklearn.datasets import fetch_openml, make_moons, make_circles\n", - "from sklearn.model_selection import train_test_split\n", - "\n", - "from IPython.display import clear_output\n", - "from tqdm import tqdm" - ] - }, - { - "cell_type": "markdown", - "id": "imperial-license", - "metadata": {}, - "source": [ - "For the training and testing set, we generate some 2D circle data that has 2 classes." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "literary-district", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Let's first see our training and testing set:\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Generate data set\n", - "X_train, y_train = make_circles(10, noise=0.05, factor=0.2)\n", - "X_test, y_test = make_circles(10, noise=0.05, factor=0.2)\n", - "\n", - "# Visualize respectively the training and testing set\n", - "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n", - "ax[0].scatter(X_train[:,0], X_train[:,1], \n", - " marker='o', c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)))\n", - "ax[0].set_title('Train')\n", - "ax[1].set_title('Test')\n", - "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)))\n", - "\n", - "print(\"Let's first see our training and testing set:\")" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "explicit-wayne", - "metadata": {}, - "outputs": [], - "source": [ - "# Initialize the progress bar\n", - "bar_format_string = '{l_bar}{bar}|[{elapsed}<{remaining}, ' '{rate_fmt}{postfix}]'\n", - "pbar = tqdm(total=100, bar_format=bar_format_string)\n", - "pbar.close()\n", - "clear_output()" - ] - }, - { - "cell_type": "markdown", - "id": "asian-preliminary", - "metadata": {}, - "source": [ - "Now, let's see how to implement a quantum kernel with Paddle Quantum:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "ideal-jaguar", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Check if K(x, x) = 1? True\n" - ] - } - ], - "source": [ - "# Global variable for manual updates of the progress bar\n", - "N = 1\n", - "\n", - "# The QKE circuit simulated by paddle quantm\n", - "def q_kernel_estimator(x1, x2):\n", - " \n", - " # Transform data vectors into tensors\n", - " x1 = paddle.to_tensor(x1)\n", - " x2 = paddle.to_tensor(x2)\n", - " \n", - " # Create the circuit\n", - " cir = UAnsatz(2)\n", - " \n", - " # Add the encoding circuit for the first data vector\n", - " cir.iqp_encoding(x1, pattern=[[0, 1]])\n", - " \n", - " # Add inverse of the encoding circuit for the second data vector\n", - " cir.iqp_encoding(x2, pattern=[[0, 1]], invert=True)\n", - " \n", - " # Run the circuit with state vector mode\n", - " fin_state = cir.run_state_vector()\n", - " \n", - " # Update the progress bar\n", - " global N\n", - " pbar.update(100/N)\n", - " \n", - " # Return the probability of measuring 0...0 \n", - " return (fin_state[0].conj() * fin_state[0]).real().numpy()[0]\n", - "\n", - "# Define a kernel matrix function, for which the input should be two list of vectors\n", - "# This is needed to customize the SVM kernel\n", - "def q_kernel_matrix(X1, X2):\n", - " return np.array([[q_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])\n", - "\n", - "# Visualize the decision function, boundary, and margins of +- 0.2\n", - "def visualize_decision_bound(clf):\n", - " \n", - " # Create a 10x10 mesh in the data plan \n", - " x_min, x_max = X_train[:,0].min(), X_train[:,0].max()\n", - " y_min, y_max = X_train[:,1].min(), X_train[:,1].max()\n", - " XX, YY = np.meshgrid(np.linspace(-1.2, 1.2, 10), \n", - " np.linspace(-1.2, 1.2, 10))\n", - " \n", - " # Calculate the decision function value on the 10x10 mesh\n", - " Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()])\n", - " Z_qke = Z.reshape(XX.shape)\n", - " \n", - " # visualize the decision function and boundary\n", - " clear_output()\n", - " plt.contourf(XX, YY, Z_qke ,vmin=-1., vmax=1., levels=20,\n", - " cmap=matplotlib.cm.coolwarm, alpha=1)\n", - " plt.scatter(X_train[:,0], X_train[:,1], \n", - " c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)),\n", - " edgecolor='black')\n", - " plt.scatter(X_test[:,0], X_test[:,1], marker='v', \n", - " c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)),\n", - " edgecolor='black')\n", - " plt.contour(XX, YY, Z_qke, colors=['k', 'k', 'k'], linestyles=['--', '-', '--'],\n", - " levels=[-.2, 0, .2])\n", - "\n", - "# To make sure we didn't make any mistake, check if the kernel function satisfies K(x, x)=1\n", - "print('Check if K(x, x) = 1?',\n", - " bool(abs(q_kernel_estimator(np.array([1. ,1.]), np.array([1., 1.])) - 1) < 1e-8))" - ] - }, - { - "cell_type": "markdown", - "id": "close-description", - "metadata": {}, - "source": [ - "Then, let's try to use a support vector machine with a quantum kernel (QKE-SVM) to classify our data:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "driving-belize", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Let's see how the QKE-SVM performs on the training on both the training and testing data:\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Create the progress bar and the total kernel evaluation number N needed for training and prediction\n", - "pbar = tqdm(total=100, \n", - " desc='Training and predicting with QKE-SVM', \n", - " bar_format=bar_format_string)\n", - "N = len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test)\n", - "\n", - "# Create a support vector machine with a quantum kernel\n", - "svm_qke = svm.SVC(kernel=q_kernel_matrix)\n", - "\n", - "# Train the svm with training data\n", - "svm_qke.fit(X_train, y_train)\n", - "\n", - "# See how the svm classifies the training and testing data\n", - "predict_svm_qke_train = svm_qke.predict(X_train)\n", - "predict_svm_qke_test = svm_qke.predict(X_test)\n", - "\n", - "# Calculate the accuracy\n", - "accuracy_train = np.array(predict_svm_qke_train == y_train, dtype=int).sum()/len(y_train)\n", - "accuracy_test = np.array(predict_svm_qke_test == y_test, dtype=int).sum()/len(y_test)\n", - "\n", - "# Visualize the result\n", - "pbar.close()\n", - "clear_output()\n", - "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n", - "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n", - " c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_train, dtype=np.float32)))\n", - "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n", - "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n", - " c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_test, dtype=np.float32)))\n", - "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n", - "print(\"Let's see how the QKE-SVM performs on the training on both the training and testing data:\")" - ] - }, - { - "cell_type": "markdown", - "id": "radio-freeze", - "metadata": {}, - "source": [ - "We can also visualize the decision function, also the decision boundary with margins of $\\pm 0.2$:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "dynamic-colonial", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Calculating the decision function of QKE-SVM: 100%|██████████████████████████████████████████▉|[01:24<00:00, 1.18it/s]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Create the progress bar and the total kernel evaluation number N needed for visualizing the decision function\n", - "pbar = tqdm(total=100, \n", - " desc='Calculating the decision function of QKE-SVM', \n", - " bar_format=bar_format_string)\n", - "N = 10 ** 2 * len(X_train)\n", - " \n", - "# Visualize the decision function\n", - "visualize_decision_bound(svm_qke)\n", - "pbar.close()" - ] - }, - { - "cell_type": "markdown", - "id": "quantitative-reliance", - "metadata": {}, - "source": [ - "We can see that the quantum kernel has the ability to learn non-linearity correctly. As a matter of fact, the performance of quantum kernel methods in classification depends on whether the quantum feature map can distinguish non-trivial patterns hidden in the data. Currently, people are still exploring how to design a good quantum kernel: First, we may try different designs of encoding circuits; Second, we can train the quantum feature map to improve its classification accuracy [5-6]; Finally, we can also try variants of the quantum kernels [7]. \n", - "\n", - "In the following part, we will introduce another special kind of quantum kernel - projected quantum kernel. " - ] - }, - { - "cell_type": "markdown", - "id": "residential-williams", - "metadata": {}, - "source": [ - "### Projected quantum kernel\n", - "\n", - "It was mentioned above that quantum kernel methods can potentially distinguish intractable patterns by mapping classical data vectors into a quantum feature space via a quantum feature map. However, as the quantum feature space - the Hilbert space's dimensionality grows exponentially with the number of qubits, nearly all quantum states will be perpendicular to each other when we have a large number of qubits. Then the kernel matrix will just become an identity matrix $K_{ij} = K(\\mathbf{x}_j, \\mathbf{x}_i) \\sim {I}$, and the kernel methods would fail. To avoid this problem caused by extra dimensionality, we first need to extract features from the Hilbert space and then construct the kernel function with these extracted features. Following this idea, a variant of quantum kernel - projected quantum kernel is proposed : By projecting the quantum feature vectors back into the classical space with a set of measurements, the dimensionality problem is mitigated [7]. Also, as the projection can preserve important features of the quantum feature space, the projected kernel can still gain a quantum advantage. \n", - "\n", - "There are several kinds of projected quantum kernels, here we choose the most rudimentary one:\n", - "\n", - "$$\n", - "K^{P}(x_i,x_j) = \\exp\\left(-\\gamma\\sum\\limits_{k}\\sum\\limits_{P\\in \\mathcal{M}}( {\\rm Tr} (P\\rho(x_i)_k)-{\\rm Tr}(P\\rho(x_j)_k))^{2}\\right),\n", - "\\tag{13}\n", - "$$\n", - "\n", - "where $\\rho(x_i)_k$ is the reduce density matrix of qubits $k$, $\\mathcal{M}$ a set of measurements on the reduce density matrix. Here we take $k = 0, 1$ and $M = \\{X, Y, Z \\}$, which means using Pauli measurements to measure every single qubit at the output.\n", - "\n", - "Let's first try to implement a projected quantum kernel circuit with Paddle Quantum:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "acute-environment", - "metadata": {}, - "outputs": [], - "source": [ - "# First we can create a circuit to calculate the feature map \n", - "def projected_q_feature_map(x):\n", - " cir = UAnsatz(2)\n", - "\n", - " # turn data into tensor\n", - " x = paddle.to_tensor(x)\n", - " \n", - " # encode the classical data into a quantum state\n", - " cir.iqp_encoding(x, pattern=[[0, 1]])\n", - " \n", - " # run the circuit with state vector mode\n", - " cir.run_state_vector()\n", - " \n", - " # Update the progress bar\n", - " global N\n", - " pbar.update(100/N)\n", - " \n", - " # to measure the final state with Pauli measurement on every single qubit\n", - " return [cir.expecval([[1.0, op_pauli]]).numpy()[0] \n", - " for op_pauli in ['z0', 'z1', 'x0', 'x1', 'y0', 'y1']]\n", - "\n", - "# to compute the projected quantum kernel based on the feature vectors\n", - "def p_quantum_kernel_estimator(x1, x2):\n", - " \n", - " # compute the feature vector of each data and return the kernel function value\n", - " p_feature_vector_1 = np.array(projected_q_feature_map(x1))\n", - " p_feature_vector_2 = np.array(projected_q_feature_map(x2))\n", - " \n", - " return np.exp(-((p_feature_vector_1 - p_feature_vector_2) ** 2).sum())\n", - "\n", - "# similarly, define the kernel matrix as required \n", - "def p_quantum_kernel_matrix(X1, X2):\n", - " return np.array([[p_quantum_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])" - ] - }, - { - "cell_type": "markdown", - "id": "round-bandwidth", - "metadata": {}, - "source": [ - "Then, we replace the quantum kernel in the support vector machine with a projected quantum kernel, and see how the projected kernel performs on this classification task:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "alert-royal", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Let's see how the PQK-SVM performs on the training on both the training and testing data:\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Set the progress bar and the total kernel evaluation number N needed for training and prediction\n", - "pbar = tqdm(total=100, \n", - " desc='Training and predicting with PQK-SVM', \n", - " bar_format=bar_format_string)\n", - "N = 2 * (len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test))\n", - "\n", - "# Create a support vector machine with a quantum kernel\n", - "svm_pqk = svm.SVC(kernel=p_quantum_kernel_matrix)\n", - "\n", - "# Train the svm with training data\n", - "svm_pqk.fit(X_train, y_train)\n", - "\n", - "# See how the svm classifies the training and testing data\n", - "predict_svm_pqk_train = svm_pqk.predict(X_train)\n", - "predict_svm_pqk_test = svm_pqk.predict(X_test)\n", - "\n", - "# Calculate the accuracy\n", - "accuracy_train = np.array(predict_svm_pqk_train == y_train, dtype=int).sum()/len(y_train)\n", - "accuracy_test = np.array(predict_svm_pqk_test == y_test, dtype=int).sum()/len(y_test)\n", - "\n", - "# Visualize the result\n", - "pbar.close()\n", - "clear_output()\n", - "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n", - "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n", - " c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_train, dtype=np.float32)))\n", - "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n", - "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n", - " c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_test, dtype=np.float32)))\n", - "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n", - "print(\"Let's see how the PQK-SVM performs on the training on both the training and testing data:\")" - ] - }, - { - "cell_type": "markdown", - "id": "unavailable-stretch", - "metadata": {}, - "source": [ - "Let's also check the decision function given by the PQK-SVM:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "connected-final", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Calculating the decision function for PQK-SVM: 100%|█████████████████████████████████████████▉|[02:37<00:00, 1.58s/it]\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Set the progress bar and the total kernel evaluation number N needed for visualizing the decision function\n", - "pbar = tqdm(total=100, \n", - " desc='Calculating the decision function for PQK-SVM', \n", - " bar_format=bar_format_string)\n", - "N = 2 * 10 ** 2 * len(X_train)\n", - " \n", - "# Clear the progress bar and visualize the decision function\n", - "visualize_decision_bound(svm_pqk)\n", - "pbar.close()" - ] - }, - { - "cell_type": "markdown", - "id": "italic-failing", - "metadata": {}, - "source": [ - "## Conclusion\n", - "\n", - "In quantum machine learning, people hope the design learning models which can gain quantum advantage by exploring the nature of quantum mechanics' laws. Recently, many connections are made between these quantum models and kernel methods, one of the most important classical machine learning approaches. In comparison to considering a parameterized quantum circuit as a \"quantum neural network\", where we focus on the variational ansatz $U(\\theta)$, the quantum kernel methods emphasize the importance of quantum feature map $U(x)$, which describes how the classical data vectors is mapped to the quantum states. This brings new perspectives to how we can design novel quantum machine learning algorithms. Therefore, we encourage readers to together explore the performance of various quantum kernel designs on different data sets.\n" - ] - }, - { - "cell_type": "markdown", - "id": "external-sterling", - "metadata": {}, - "source": [ - "---\n", - "\n", - "## References\n", - "\n", - "[1] Schuld, Maria. \"Supervised quantum machine learning models are kernel methods.\" arXiv preprint [arXiv:2101.11020 (2021)](https://arxiv.org/abs/2101.11020).\n", - "\n", - "[2] Havlíček, Vojtěch, et al. \"Supervised learning with quantum-enhanced feature spaces.\" [Nature 567.7747 (2019): 209-212](https://arxiv.org/abs/1804.11326).\n", - "\n", - "[3] Liu, Yunchao, Srinivasan Arunachalam, and Kristan Temme. \"A rigorous and robust quantum speed-up in supervised machine learning.\" arXiv preprint [arXiv:2010.02174 (2020)](https://arxiv.org/abs/2010.02174).\n", - "\n", - "[4] Schuld, Maria, and Nathan Killoran. \"Quantum machine learning in feature Hilbert spaces.\" [Phys. Rev. Lett. 122.4 (2019): 040504](https://arxiv.org/abs/1803.07128).\n", - "\n", - "[5] Hubregtsen, Thomas, et al. \"Training Quantum Embedding Kernels on Near-Term Quantum Computers.\" arXiv preprint [arXiv:2105.02276(2021)](https://arxiv.org/abs/2105.02276).\n", - "\n", - "[6] Glick, Jennifer R., et al. \"Covariant quantum kernels for data with group structure.\" arXiv preprint [arXiv:2105.03406(2021)](https://arxiv.org/abs/2105.03406).\n", - "\n", - "[7] Huang, Hsin-Yuan, et al. \"Power of data in quantum machine learning.\" arXiv preprint [arXiv:2011.01938 (2020)](https://arxiv.org/abs/2011.01938).\n", - "\n", - "[8] Schölkopf, Bernhard, and Alexander J. Smola\"Learning with kernels: support vector machines, regularization, optimization, and beyond.\" [MIT Press(2002)](https://mitpress.mit.edu/books/learning-kernels)." - ] - } - ], - "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" - }, - "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 - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorial/machine_learning/VQSVD_CN.ipynb b/tutorial/machine_learning/VQSVD_CN.ipynb deleted file mode 100644 index e66328d..0000000 --- a/tutorial/machine_learning/VQSVD_CN.ipynb +++ /dev/null @@ -1,960 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "# 变分量子奇异值分解\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 概览\n", - "\n", - "在本教程中，我们一起学习下经典奇异值分解（singular value decomposition, SVD）的概念以及我们自主研发的量子神经网络版本的量子奇异值分解（variational quantum SVD, VQSVD）[1] 是如何运作的。主体部分包括两个具体案例：\n", - "- 分解随机生成的 $8\\times8$ 复数矩阵；\n", - "- 应用在图像压缩上的效果。\n", - "\n", - "## 背景\n", - "\n", - "奇异值分解有非常多的应用，包括主成分分析（principal component analysis, PCA）、求解线性方程组和推荐系统。其主要任务是给定一个复数矩阵 $M \\in \\mathbb{C}^{m \\times n}$, 找到如下的分解形式：$M = UDV^\\dagger$。其中 $U_{m\\times m}$ 和 $V^\\dagger_{n\\times n}$ 是酉矩阵（Unitary matrix）, 满足性质 $UU^\\dagger = VV^\\dagger = I$。 \n", - "\n", - "- 矩阵 $U$ 的列向量 $|u_j\\rangle$ 被称为左奇异向量（left singular vectors）, $\\{|u_j\\rangle\\}_{j=1}^{m}$ 组成一组正交向量基。这些列向量本质上是矩阵 $MM^\\dagger$ 的本征向量。\n", - "- 类似的，矩阵 $V$ 的列向量 $\\{|v_j\\rangle\\}_{j=1}^{n}$ 是 $M^\\dagger M$ 的本征向量也组成一组正交向量基。\n", - "- 中间矩阵 $D_{m\\times n}$ 的对角元素上存储着由大到小排列的奇异值 $d_j$。 \n", - "\n", - "我们不妨先来看个简单的例子（为了方便讨论，我们假设以下出现的 $M$ 都是方阵）：\n", - "\n", - "$$\n", - "M = 2*X\\otimes Z + 6*Z\\otimes X + 3*I\\otimes I = \n", - "\\begin{bmatrix} \n", - "3 &6 &2 &0 \\\\\n", - "6 &3 &0 &-2 \\\\\n", - "2 &0 &3 &-6 \\\\\n", - "0 &-2 &-6 &3 \n", - "\\end{bmatrix}, \\tag{1}\n", - "$$\n", - "\n", - "那么该矩阵的奇异值分解可表示为:\n", - "\n", - "$$\n", - "M = UDV^\\dagger = \n", - "\\frac{1}{2}\n", - "\\begin{bmatrix} \n", - "-1 &-1 &1 &1 \\\\\n", - "-1 &-1 &-1 &-1 \\\\\n", - "-1 &1 &-1 &1 \\\\\n", - "1 &-1 &-1 &1 \n", - "\\end{bmatrix}\n", - "\\begin{bmatrix} \n", - "11 &0 &0 &0 \\\\\n", - "0 &7 &0 &0 \\\\\n", - "0 &0 &5 &0 \\\\\n", - "0 &0 &0 &1 \n", - "\\end{bmatrix}\n", - "\\frac{1}{2}\n", - "\\begin{bmatrix} \n", - "-1 &-1 &-1 &-1 \\\\\n", - "-1 &-1 &1 &1 \\\\\n", - "-1 &1 &1 &-1 \\\\\n", - "1 &-1 &1 &-1 \n", - "\\end{bmatrix}. \\tag{2}\n", - "$$\n", - "\n", - "我们通过下面几行代码引入必要的 library和 package。\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:47:34.433321Z", - "start_time": "2021-03-09T03:47:28.730090Z" - } - }, - "outputs": [], - "source": [ - "import time\n", - "import numpy as np\n", - "from numpy import pi as PI\n", - "from matplotlib import pyplot as plt\n", - "from scipy.stats import unitary_group\n", - "from scipy.linalg import norm\n", - "\n", - "import paddle\n", - "from paddle import matmul, transpose, trace\n", - "from paddle_quantum.circuit import *\n", - "from paddle_quantum.utils import *\n", - "\n", - "\n", - "# 画出优化过程中的学习曲线\n", - "def loss_plot(loss):\n", - " '''\n", - " loss is a list, this function plots loss over iteration\n", - " '''\n", - " plt.plot(list(range(1, len(loss)+1)), loss)\n", - " plt.xlabel('iteration')\n", - " plt.ylabel('loss')\n", - " plt.title('Loss Over Iteration')\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 经典奇异值分解\n", - "\n", - "那么在了解一些简单的数学背景之后， 我们来学习下如何用 Numpy 完成矩阵的奇异值分解。" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:47:34.469286Z", - "start_time": "2021-03-09T03:47:34.440399Z" - }, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "我们想要分解的矩阵 M 是：\n", - "[[ 3.+0.j 6.+0.j 2.+0.j 0.+0.j]\n", - " [ 6.+0.j 3.+0.j 0.+0.j -2.+0.j]\n", - " [ 2.+0.j 0.+0.j 3.+0.j -6.+0.j]\n", - " [ 0.+0.j -2.+0.j -6.+0.j 3.+0.j]]\n" - ] - } - ], - "source": [ - "# 生成矩阵 M\n", - "def M_generator():\n", - " I = np.array([[1, 0], [0, 1]])\n", - " Z = np.array([[1, 0], [0, -1]])\n", - " X = np.array([[0, 1], [1, 0]])\n", - " Y = np.array([[0, -1j], [1j, 0]])\n", - " M = 2 *np.kron(X, Z) + 6 * np.kron(Z, X) + 3 * np.kron(I, I)\n", - " return M.astype('complex64')\n", - "\n", - "print('我们想要分解的矩阵 M 是：')\n", - "print(M_generator())" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:47:34.541244Z", - "start_time": "2021-03-09T03:47:34.489833Z" - }, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "矩阵的奇异值从大到小分别是:\n", - "[11. 7. 5. 1.]\n", - "分解出的酉矩阵 U 是:\n", - "[[-0.5+0.j -0.5+0.j 0.5+0.j 0.5+0.j]\n", - " [-0.5+0.j -0.5+0.j -0.5+0.j -0.5+0.j]\n", - " [-0.5+0.j 0.5+0.j -0.5+0.j 0.5+0.j]\n", - " [ 0.5+0.j -0.5+0.j -0.5+0.j 0.5+0.j]]\n", - "分解出的酉矩阵 V_dagger 是:\n", - "[[-0.5+0.j -0.5+0.j -0.5+0.j 0.5+0.j]\n", - " [-0.5+0.j -0.5+0.j 0.5+0.j -0.5+0.j]\n", - " [-0.5+0.j 0.5+0.j 0.5+0.j 0.5+0.j]\n", - " [-0.5+0.j 0.5+0.j -0.5+0.j -0.5+0.j]]\n" - ] - } - ], - "source": [ - "# 我们只需要以下一行代码就可以完成 SVD \n", - "U, D, V_dagger = np.linalg.svd(M_generator(), full_matrices=True)\n", - "\n", - "# 打印分解结果\n", - "print(\"矩阵的奇异值从大到小分别是:\")\n", - "print(D)\n", - "print(\"分解出的酉矩阵 U 是:\")\n", - "print(U)\n", - "print(\"分解出的酉矩阵 V_dagger 是:\")\n", - "print(V_dagger)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:47:34.600873Z", - "start_time": "2021-03-09T03:47:34.565570Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[ 3.+0.j 6.+0.j 2.+0.j 0.+0.j]\n", - " [ 6.+0.j 3.+0.j 0.+0.j -2.+0.j]\n", - " [ 2.+0.j 0.+0.j 3.+0.j -6.+0.j]\n", - " [ 0.+0.j -2.+0.j -6.+0.j 3.+0.j]]\n" - ] - } - ], - "source": [ - "# 再组装回去，能不能复原矩阵？\n", - "M_reconst = np.matmul(U, np.matmul(np.diag(D), V_dagger))\n", - "print(M_reconst)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "那当然是可以复原成原来的矩阵 $M$ 的！读者也可以自行修改矩阵，试试看不是方阵的情况。\n", - "\n", - "---\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 量子奇异值分解\n", - "\n", - "接下来我们来看看量子版本的奇异值分解是怎么一回事。简单的说，我们把矩阵分解这一问题巧妙的转换成了优化问题。通过以下四个步骤：\n", - "\n", - "- 准备一组正交向量基 $\\{|\\psi_j\\rangle\\}$, 不妨直接取计算基 $\\{ |000\\rangle, |001\\rangle,\\cdots |111\\rangle\\}$ （这是3量子比特的情形）\n", - "- 准备两个参数化的量子神经网络 $U(\\theta)$ 和 $V(\\phi)$ 分别用来学习左/右奇异向量\n", - "- 利用量子神经网络估算奇异值 $m_j = \\text{Re}\\langle\\psi_j|U(\\theta)^{\\dagger} M V(\\phi)|\\psi_j\\rangle$\n", - "- 设计损失函数并且利用飞桨来优化\n", - "\n", - "$$\n", - "L(\\theta,\\phi) = \\sum_{j=1}^T q_j\\times \\text{Re} \\langle\\psi_j|U(\\theta)^{\\dagger} M V(\\phi)|\\psi_j\\rangle, \\tag{3}\n", - "$$\n", - "\n", - "其中 $q_1>\\cdots>q_T>0$ 是可以调节的权重（超参数）, $T$ 表示我们想要学习到的阶数（rank）或者可以解释为总共要学习得到的奇异值个数。\n", - "\n", - "\n", - "\n", - "### 案例1：分解随机生成的 $8\\times8$ 复数矩阵\n", - "\n", - "接着我们来看一个具体的例子，这可以更好的解释整体流程。" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:47:34.656799Z", - "start_time": "2021-03-09T03:47:34.620380Z" - }, - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "我们想要分解的矩阵 M 是：\n", - "[[6.+1.j 3.+9.j 7.+3.j 4.+7.j 6.+6.j 9.+8.j 2.+7.j 6.+4.j]\n", - " [7.+1.j 4.+4.j 3.+7.j 7.+9.j 7.+8.j 2.+8.j 5.+0.j 4.+8.j]\n", - " [1.+6.j 7.+8.j 5.+7.j 1.+0.j 4.+7.j 0.+7.j 9.+2.j 5.+0.j]\n", - " [8.+7.j 0.+2.j 9.+2.j 2.+0.j 6.+4.j 3.+9.j 8.+6.j 2.+9.j]\n", - " [4.+8.j 2.+6.j 6.+8.j 4.+7.j 8.+1.j 6.+0.j 1.+6.j 3.+6.j]\n", - " [8.+7.j 1.+4.j 9.+2.j 8.+7.j 9.+5.j 4.+2.j 1.+0.j 3.+2.j]\n", - " [6.+4.j 7.+2.j 2.+0.j 0.+4.j 3.+9.j 1.+6.j 7.+6.j 3.+8.j]\n", - " [1.+9.j 5.+9.j 5.+2.j 9.+6.j 3.+0.j 5.+3.j 1.+3.j 9.+4.j]]\n", - "矩阵的奇异值从大到小分别是:\n", - "[54.83484985 19.18141073 14.98866247 11.61419557 10.15927045 7.60223249\n", - " 5.81040539 3.30116001]\n" - ] - } - ], - "source": [ - "# 先固定随机种子， 为了能够复现结果\n", - "np.random.seed(42)\n", - "\n", - "# 设置量子比特数量，确定希尔伯特空间的维度\n", - "N = 3\n", - "\n", - "# 制作随机矩阵生成器\n", - "def random_M_generator():\n", - " M = np.random.randint(10, size = (2**N, 2**N)) + 1j*np.random.randint(10, size = (2**N, 2**N))\n", - " M1 = np.random.randint(10, size = (2**N, 2**N)) \n", - " return M\n", - "\n", - "M = random_M_generator()\n", - "M_err = np.copy(M)\n", - "\n", - "# 打印结果\n", - "print('我们想要分解的矩阵 M 是：')\n", - "print(M)\n", - "\n", - "U, D, V_dagger = np.linalg.svd(M, full_matrices=True)\n", - "print(\"矩阵的奇异值从大到小分别是:\")\n", - "print(D)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:47:34.692350Z", - "start_time": "2021-03-09T03:47:34.671114Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "选取的等差权重为：\n", - "[24.+0.j 21.+0.j 18.+0.j 15.+0.j 12.+0.j 9.+0.j 6.+0.j 3.+0.j]\n" - ] - } - ], - "source": [ - "# 超参数设置\n", - "N = 3 # 量子比特数量\n", - "T = 8 # 设置想要学习的阶数\n", - "ITR = 100 # 迭代次数\n", - "LR = 0.02 # 学习速率\n", - "SEED = 14 # 随机数种子\n", - "\n", - "# 设置等差的学习权重\n", - "weight = np.arange(3 * T, 0, -3).astype('complex128')\n", - "print('选取的等差权重为：')\n", - "print(weight)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "我们搭建如下的量子神经网络结构：" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:47:34.725007Z", - "start_time": "2021-03-09T03:47:34.702861Z" - } - }, - "outputs": [], - "source": [ - "# 设置电路参数\n", - "cir_depth = 20 # 电路深度\n", - "block_len = 2 # 每个模组的长度\n", - "theta_size = N * block_len * cir_depth # 网络参数 theta 的大小\n", - "\n", - "\n", - "# 定义量子神经网络\n", - "def U_theta(theta):\n", - "\n", - " # 用 UAnsatz 初始化网络\n", - " cir = UAnsatz(N)\n", - " \n", - " # 搭建层级结构：\n", - " for layer_num in range(cir_depth):\n", - " \n", - " for which_qubit in range(N):\n", - " cir.ry(theta[block_len * layer_num * N + which_qubit], \n", - " which_qubit)\n", - " \n", - " for which_qubit in range(N):\n", - " cir.rz(theta[(block_len * layer_num + 1) * N \n", - " + which_qubit], which_qubit)\n", - "\n", - " for which_qubit in range(1, N):\n", - " cir.cnot([which_qubit - 1, which_qubit])\n", - " cir.cnot([N - 1, 0])\n", - "\n", - " return cir.U" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "接着我们来完成算法的主体部分：\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:49:24.011232Z", - "start_time": "2021-03-09T03:47:40.712257Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 0 loss: 259.1903\n", - "iter: 10 loss: -1672.2268\n", - "iter: 20 loss: -2097.8083\n", - "iter: 30 loss: -2242.9914\n", - "iter: 40 loss: -2310.1948\n", - "iter: 50 loss: -2340.2588\n", - "iter: 60 loss: -2357.5961\n", - "iter: 70 loss: -2369.2625\n", - "iter: 80 loss: -2376.9403\n", - "iter: 90 loss: -2373.7986\n" - ] - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZMAAAEWCAYAAACjYXoKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAodklEQVR4nO3de3xcdZ3/8ddnZnK/NG2T3i8ptEVbpBTDXZAfoBQFqy4isApedllc8bK6u4K4v119yO+Bq7teFldFZUVXQRZEWe6giIAWSAFLS62EttD0mrRpmzb3zOf3x/mmnYa0JJlMJpl5Px+Pecyc7zkz53M6MO+c7znne8zdERERSUcs2wWIiMj4pzAREZG0KUxERCRtChMREUmbwkRERNKmMBERkbQpTERkSMxsn5kdle06ZGxRmMi4Y2YbzezcLK37NDP7jZm1mtkeM/tfM1s0ius/sO1m9iEzeyLD6/utmf1Vapu7l7v7+kyuV8YfhYnIIJnZqcBDwK+AGcA84I/AkyP9l7pFMvr/p5klMvn5kl8UJpIzzKzIzL5hZlvC4xtmVhTmVZvZPWa228x2mdnjfT/WZvY5M9sc9jbWmdk5h1nFvwI/dvdvunuru+9y9y8AK4B/CZ+11swuSKkpYWZNZnZCmD7FzH4f6vijmZ2Vsuxvzex6M3sSaAMOG1Bm9kbgu8Cpodtpd8q/wdfM7FUz225m3zWzkjDvLDNrDNu7DfgvM5sY/l2azKwlvJ4Vlr8eOAO4MazjxtDuZjY/vJ5gZj8O73/FzL6Q8u/6ITN7ItTTYmYbzOz8QX+hMq4oTCSXXAecAhwPLAFOAr4Q5n0WaARqgKnA5wE3s2OAq4ET3b0COA/Y2P+DzawUOA34nwHWezvwtvD6VuDSlHnnAc3u/qyZzQTuBb4MTAL+HrjTzGpSlv8gcCVQAbxyuA1197XAVcAfQrdTVZh1A7Aw/BvMB2YC/zflrdPCuueG9cSA/wrTc4B24MawjuuAx4GrwzquHqCU/wAmEAXfW4HLgQ+nzD8ZWAdUE4XxD83MDrddMn4pTCSX/CXwJXff4e5NwBeJfpwBuoHpwFx373b3xz0amK4XKAIWmVmBu29095cH+OxJRP+/bB1g3laiH0uAnwHvCuEDcBlRwAB8ALjP3e9z96S7PwzUA+9I+awfufsad+9x9+6hbHz4kb4S+Luw19QK/D/gkpTFksA/u3unu7e7+053v9Pd28Ly1xOFwmDWFw+ffW3YU9sI/BsH/80BXnH377t7L3AL0XcwdSjbJeODwkRyyQwO/Wv+ldAG8FWgAXjIzNab2TUA7t4AfJqom2qHmd1mZjN4rRaiH+LpA8ybDjSnfN5a4MIQKO8iChiI/vp/X+ji2h26pt7S7zM3DWWD+6kBSoGVKZ//QGjv0+TuHX0TZlZqZt8LXVR7gd8BVSEoXk81UMBr/81npkxv63vh7m3hZfkQtknGCYWJ5JItRD/YfeaENsJfzp9196OIfuA/03dsxN1/5u5vCe914Cv9P9jd9wN/AN43wHovBn6dMt3X1bUceDEEDERB8RN3r0p5lLn7DamrGsL29l+2maibanHK509w9/IjvOezwDHAye5eCZwZ2u0wy/dfXzev/TffPIRtkByhMJHxqsDMilMeCaIf8S+YWY2ZVRMdK/hvADO7wMzmh66gPUTdW0kzO8bMzg4H6juIfoyTh1nnNcAVZvZJM6sIB6+/DJxK1KXW5zbg7cDHOLhXQqjlQjM7z8zioe6z+g54D8N2YJaZFQK4exL4PvB1M5sStnummZ13hM+oINrm3WY2CfjnAdYx4IkAoevqduD68O8xF/hM2E7JMwoTGa/uI/oR7Hv8C9GB7XpgFfAC8GxoA1gAPALsI9rD+E93f5ToeMkNRH9lbwOmANcOtEJ3f4LogPp7iY6TvAIsBd7i7i+lLLc1rOM04Ocp7ZuI9lY+DzQR7an8A8P///A3wBpgm5k1h7bPEXXnrQjdVo8Q7XkczjeAEqLtX0HULZbqm8BF4Wysbw3w/k8A+4H1wBNE4XnzsLZGxjXTzbFERCRd2jMREZG0KUxERCRtChMREUmbwkRERNKWtwO9VVdXe21tbbbLEBEZV1auXNns7jX92/M2TGpra6mvr892GSIi44qZDThmnLq5REQkbQoTERFJm8JERETSpjAREZG0KUxERCRtChMREUmbwkRERNKmMBmiu55r5L9XHPbW3CIieUlhMkT3vbBNYSIi0o/CZIhqKopoau3MdhkiImOKwmSIasqL2NXWRXfv4e7sKiKSfxQmQ1RTUYQ77Nrfle1SRETGDIXJENVUFAGoq0tEJIXCZIgUJiIir6UwGaKacoWJiEh/CpMhOrBnsk9hIiLSR2EyRMUFcSqLE9ozERFJoTAZBl1rIiJyKIXJMChMREQOpTAZhpqKYna0dmS7DBGRMUNhMgw15dozERFJpTAZhpqKIvZ39bK/syfbpYiIjAkKk2HoOz24WacHi4gACpNh0VXwIiKHypkwMbNlZrbOzBrM7JpMrktXwYuIHConwsTM4sC3gfOBRcClZrYoU+ubUqmr4EVEUuVEmAAnAQ3uvt7du4DbgOWZWtnE0kLiMdOeiYhIkCthMhPYlDLdGNoyIh4zJpcVKkxERIJcCZNBMbMrzazezOqbmprS+ixdBS8iclCuhMlmYHbK9KzQdgh3v8nd69y9rqamJq0V1lQU6ZiJiEiQK2HyDLDAzOaZWSFwCXB3JldYU17Ejr0KExERgES2CxgJ7t5jZlcDDwJx4GZ3X5PJddZUFNG8r5Nk0onFLJOrEhEZ83IiTADc/T7gvtFaX01FET1JZ3d7N5PKCkdrtSIiY1KudHONOl0FLyJykMJkmHQVvIjIQQqTYTp4L3jd10RERGEyTFMqiwHtmYiIgMJk2MoK45QUxBUmIiIoTIbNzHQVvIhIoDBJg66CFxGJKEzSoKvgRUQiCpM0TKksYvtenc0lIqIwScPUymL2dvTQ3tWb7VJERLJKYZKGaeH04G3aOxGRPKcwScO0CSFM9ihMRCS/KUzSMDXsmei4iYjkO4VJGg7smShMRCTPKUzSUF6UoLwooT0TEcl7CpM0TdXpwSIiCpN0Ta0s1gF4Ecl7CpM0TassZruugheRPKcwSdPUCcVs39tBMunZLkVEJGsUJmmaVllMT9LZub8r26WIiGSNwiRNutZERERhkjZdBS8iojBJm8bnEhFRmKSturyQmKmbS0Tym8IkTYl4jJqKInVziUheU5iMgGmVxermEpG8pjAZAVMri9XNJSJ5TWEyAqZN0JAqIpLfFCYjQLfvFZF8N+bCxMz+xcw2m9nz4fGOlHnXmlmDma0zs/NS2peFtgYzu2a0a9aFiyKS7xLZLuAwvu7uX0ttMLNFwCXAYmAG8IiZLQyzvw28DWgEnjGzu939xdEqNvVak9rqstFarYjImDFWw2Qgy4Hb3L0T2GBmDcBJYV6Du68HMLPbwrKjFyYTigDtmYhI/hpz3VzB1Wa2ysxuNrOJoW0msCllmcbQdrj21zCzK82s3szqm5qaRqzYvm4uHYQXkXyVlTAxs0fMbPUAj+XAd4CjgeOBrcC/jdR63f0md69z97qampqR+lgqigsoK4zrWhMRyVtZ6eZy93MHs5yZfR+4J0xuBmanzJ4V2jhC+6jpu6+JiEg+GnPdXGY2PWXyPcDq8Ppu4BIzKzKzecAC4GngGWCBmc0zs0Kig/R3j2bNEK6CVzeXiOSpsXgA/l/N7HjAgY3A3wC4+xozu53owHoP8HF37wUws6uBB4E4cLO7rxntoqdVFvPUhl2jvVoRkTFhzIWJu3/wCPOuB64foP0+4L5M1vV6ZlSVsG1vB929SQriY26HT0Qko/SrN0LmTi6lN+k0trRnuxQRkVGnMBkh88LFihub92e5EhGR0acwGSF9V75v3KkwEZH8ozAZIZPLCqkoSmjPRETyksJkhJgZc6tL2bCzLduliIiMOoXJCKqdXKY9ExHJSwqTETSvuozGlja6epLZLkVEZFQpTEZQ7eQykg6NLerqEpH8ojAZQTqjS0TylcJkBNVOLgVgQ7P2TEQkvyhMRtCkskIqinV6sIjkH4XJCDIz5lWXqZtLRPKOwmSE1U5WmIhI/lGYjLDayaVsbmnX6cEiklcUJiOstjo6PfjVXToILyL5Q2Eywmo1erCI5CGFyQibN1nXmohI/lGYjLCJZYVMKClQmIhIXlGYZEDt5FI26sJFEckjCpMMqK0uY4OOmYhIHlGYZMC86jK27Gmnrasn26WIiIwKhUkGHDdrAu6wqnFPtksRERkVCpMMWDp7IgDPvtqS5UpEREaHwiQDJpYVclR1Gc++sjvbpYiIjAqFSYYsnTOR515twd2zXYqISMYpTDJk6Zwqdu7vYtOu9myXIiKScQqTDDlhjo6biEj+UJhkyDHTKigrjCtMRCQvZCVMzOx9ZrbGzJJmVtdv3rVm1mBm68zsvJT2ZaGtwcyuSWmfZ2ZPhfafm1nhaG7L4cRjxpLZVQoTEckL2dozWQ28F/hdaqOZLQIuARYDy4D/NLO4mcWBbwPnA4uAS8OyAF8Bvu7u84EW4KOjswmv74Q5E1m7tZX2rt5slyIiklGDChMz+5SZVVrkh2b2rJm9fbgrdfe17r5ugFnLgdvcvdPdNwANwEnh0eDu6929C7gNWG5mBpwN3BHefwvw7uHWNdKWzqmiN+msatyd7VJERDJqsHsmH3H3vcDbgYnAB4EbMlDPTGBTynRjaDtc+2Rgt7v39GsfkJldaWb1Zlbf1NQ0ooUPZOmBg/C7M74uEZFsGmyYWHh+B/ATd1+T0jbwG8weMbPVAzyWp1NwOtz9Jnevc/e6mpqajK9vUlkh86rLdNxERHJeYpDLrTSzh4B5wLVmVgEc8Sbn7n7uMOrZDMxOmZ4V2jhM+06gyswSYe8kdfkxYemcKn7352bcnahXTkQk9wx2z+SjwDXAie7eBhQAH85APXcDl5hZkZnNAxYATwPPAAvCmVuFRAfp7/bo8vJHgYvC+68AfpWBuoatbu4kmvd18tKOfdkuRUQkYwYbJqcC69x9t5l9APgCMOwhcc3sPWbWGD73XjN7ECB0n90OvAg8AHzc3XvDXsfVwIPAWuD2sCzA54DPmFkD0TGUHw63rkx426KpxAzu+eOWbJciIpIxNpixo8xsFbAEOA74EfAD4GJ3f2tGq8uguro6r6+vH5V1Xfb9FWzb08GvP/tWdXWJyLhmZivdva5/+2D3THpCl9Jy4EZ3/zZQMZIF5rILl8xgffN+1mzZm+1SREQyYrBh0mpm1xKdEnyvmcWIjpvIICxbPI1EzLhn1dZslyIikhGDDZP3A51E15tsIzpr6qsZqyrHTCwr5PT51dyzaouGpBeRnDSoMAkB8lNggpldAHS4+48zWlmOuXDJDBpb2nl+0+5slyIiMuIGO5zKxUSn6L4PuBh4yswuOvK7JNXbF0+lMB5TV5eI5KTBdnNdR3SNyRXufjnRWFn/lLmyck9lcQFnLqzh3lVbSSbV1SUiuWWwYRJz9x0p0zuH8F4JLlwynW17O/jD+p3ZLkVEZEQNNhAeMLMHzexDZvYh4F7gvsyVlZvOWzyNCSUF/OzpV7NdiojIiBrU2Fzu/g9m9hfA6aHpJne/K3Nl5abigjh/ccIsfrJiI837OqkuL8p2SSIiI2LQXVXufqe7fyY8FCTDdNnJs+nude5Y2ZjtUkRERswRw8TMWs1s7wCPVjPT5dzDMH9KBSfNm8StT7+qA/EikjOOGCbuXuHulQM8Kty9crSKzDWXnTSHV3a26UC8iOQMnZGVBcuOncbE0gJ+9pQOxItIblCYZEHfgfgH12yjqbUz2+WIiKRNYZIll548h56k8z8rN73+wiIiY5zCJEuOrinn5HmTuO3pTToQLyLjnsIkiy47eQ6v7mrjyZebs12KiEhaFCZZtOzYaUwqK9SBeBEZ9xQmWVSUiHPRm2fx8Ivb2dHake1yRESGTWGSZZecODs6EF+vK+JFZPxSmGTZUTXlnHrUZG57RlfEi8j4pTAZAy47eQ6bdrXzeIMOxIvI+KQwGQPevngqE0sLuL1e15yIyPikMBkDihJx3r10Jg+v2U7L/q5slyMiMmQKkzHi/SfOpqs3yV3Pbc52KSIiQ6YwGSPeMK2SJbMmcHv9Jtx1IF5ExheFyRhy8Ymz+dO2Vl7YvCfbpYiIDInCZAy5cMkMigti/PwZHYgXkfFFYTKGVBYX8I5jp3P381to7+rNdjkiIoOWlTAxs/eZ2RozS5pZXUp7rZm1m9nz4fHdlHlvNrMXzKzBzL5lZhbaJ5nZw2b2UniemI1tGikXnzib1s4e7l+9NduliIgMWrb2TFYD7wV+N8C8l939+PC4KqX9O8BfAwvCY1lovwb4tbsvAH4dpsetk+dNonZyKbc9ra4uERk/shIm7r7W3dcNdnkzmw5UuvsKj051+jHw7jB7OXBLeH1LSvu4ZGZcctIcnt64i4YdrdkuR0RkUMbiMZN5ZvacmT1mZmeEtplA6kiIjaENYKq79/UJbQOmHu6DzexKM6s3s/qmpqYRL3ykXPTmWRTETXsnIjJuZCxMzOwRM1s9wGP5Ed62FZjj7kuBzwA/M7PKwa4z7LUc9iINd7/J3evcva6mpmbQ2zLaqsuLeNuiqdz5bCOdPToQLyJjXyJTH+zu5w7jPZ1AZ3i90sxeBhYCm4FZKYvOCm0A281surtvDd1hO9KrfGy49KQ53PfCNh5cs513LZmR7XJERI5oTHVzmVmNmcXD66OIDrSvD91Ye83slHAW1+XAr8Lb7gauCK+vSGkf104/uprZk0q4VXdhFJFxIFunBr/HzBqBU4F7zezBMOtMYJWZPQ/cAVzl7rvCvL8FfgA0AC8D94f2G4C3mdlLwLlhetyLxYxLTpzDH9bvZEPz/myXIyJyRJav40DV1dV5fX19tss4oh17Ozj1ht/wkdNrue6di7JdjogIZrbS3ev6t4+pbi451JTKYpYtnsbt9Y26Il5ExjSFyRh3xWm17Gnv5pfPa2h6ERm7FCZj3Im1E3nj9Ep+9ORGDU0vImOWwmSMMzM+dNpc1m1vZcX6Xa//BhGRLFCYjAPLj59JVWkBt/x+Y7ZLEREZkMJkHCguiPP+E2fz0Ivb2Ly7PdvliIi8hsJknPjgKXMBtHciImOSwmScmDWxlAuXzOAnf3iFnfs6s12OiMghFCbjyCfOXkBHTy/ff3xDtksRETmEwmQcmT+lnAuPm8GP/7CRXfu7sl2OiMgBCpNx5pPnzKe9u5fvP74+26WIiBygMBln5k+p4ILjZnDL77V3IiJjh8JkHPrk2dHeyfceeznbpYiIAAqTcWnB1Areu3QWNz+5gfVN+7JdjoiIwmS8+tz5x1CUiPOle17UmF0iknUKk3FqSkUxnz53Ab9d18Sv1+bEnYpFZBxTmIxjV5xWy4Ip5XzxnjV0dOt+JyKSPQqTcawgHuOL71rMpl3tfOe3OhgvItmjMBnnTptfzfLjZ3Djow0892pLtssRkTylMMkBX1p+LNMqi/nkbc/R2tGd7XJEJA8pTHLAhJICvnnJ8Wxuaeeffrk62+WISB5SmOSIutpJfOqchfzy+S384tnGbJcjInlGYZJDrj57PifNm8R1d63mxS17s12OiOQRhUkOiceMGy9byoSSAq78ST0tGrtLREaJwiTHTKko5nsffDM7Wju5+tZn6elNZrskEckDCpMctGR2Fde/+1iebNjJl+9dq+FWRCTjEtkuQDLjfXWzWbu1lZuf3EB1eSFXn70g2yWJSA5TmOSwL7zzjexu6+JrD/2ZsqIEHz59XrZLEpEclZVuLjP7qpn9ycxWmdldZlaVMu9aM2sws3Vmdl5K+7LQ1mBm16S0zzOzp0L7z82scJQ3Z8yKxYx/veg4zls8lS/+74vc/symbJckIjkqW8dMHgaOdffjgD8D1wKY2SLgEmAxsAz4TzOLm1kc+DZwPrAIuDQsC/AV4OvuPh9oAT46qlsyxiXiMb516VLOWFDN536xip899Wq2SxKRHJSVMHH3h9y9J0yuAGaF18uB29y90903AA3ASeHR4O7r3b0LuA1YbmYGnA3cEd5/C/DuUdqMcaMoEef7l9dx1sIaPn/XC/xA948XkRE2Fs7m+ghwf3g9E0jti2kMbYdrnwzsTgmmvvYBmdmVZlZvZvVNTU0jVP74UFwQ53sfrOP8Y6fx5XvX8o1H/qyzvERkxGQsTMzsETNbPcBjecoy1wE9wE8zVUcqd7/J3evcva6mpmY0VjmmFCZi/MelS3nvCTP5xiMv8ZEfPUPzvs5slyUiOSBjZ3O5+7lHmm9mHwIuAM7xg38ibwZmpyw2K7RxmPadQJWZJcLeSeryMoBEPMa/vW8Jx8+u4sv3ruX8bz7Ov1+8hDMW5F+4isjIydbZXMuAfwTe5e5tKbPuBi4xsyIzmwcsAJ4GngEWhDO3CokO0t8dQuhR4KLw/iuAX43WdoxXZsblp9byq4+fzoSSAj74w6f5xK3PsXl3e7ZLE5FxyrLRb25mDUAR0Z4FwAp3vyrMu47oOEoP8Gl3vz+0vwP4BhAHbnb360P7UUQH5CcBzwEfcPfX7bupq6vz+vr6kdyscam9q5fvPPYy33ssulPjX59xFJefOpcplcVZrkxExiIzW+nuda9pz9eDsAqTQzW2tPGVB9bxv3/cQjxmnLWwhotPnM1Zx9RQlIhnuzwRGSMUJv0oTAa2oXk/t9dv4o6VjTS1dlJRlODcRVN5x5umc8aCaooLFCwi+Uxh0o/C5Mh6epM83tDMfau28tCL29nT3k1ZYZz/84YpnH/sdM554xQFi0geUpj0ozAZvK6eJL9/uZkH12zjoTXb2bm/i8riBO9ZOpP3nziHRTMqs12iiIwShUk/CpPh6U06K9bv5Pb6Tdy/ehtdPUlOmjeJj731aM46poZoUAIRyVUKk34UJunb3dbFHSsbufmJDWzZ08EbplXwsbOO5p1vmk4iPhYGVxCRkaYw6UdhMnK6e5Pc/fwWvvvYy7y0Yx9zJ5dy1VuP5r0nzNSZYCI5RmHSj8Jk5CWTzkMvbufbjzbwwuY91FQUccWpc/nLk+cysUx3BhDJBQqTfhQmmePuPNHQzE2/W8/jLzVTUhDnguOmc8GSGZx29GQK1AUmMm4dLkx0p0UZcWbGGQtqOGNBDeu2tXLzExu474Wt/M/KRqpKCzj7DVM4/ehqTp9fzbQJutJeJBdoz0RGRUd3L4+/1My9q7bw2J+baGnrBuCo6jJOrJ1EXe1ETp43mTmTS7NcqYgcibq5+lGYZE8y6azdtpcnG5p5esMuntnYwp72KFxmTyrhLfOrOXNBDWcurKGsSDvPImOJwqQfhcnYkUw6DU37WLF+J0+81MwfXt5Ja2cPRYkYb11Yw/lvmsbZb5jKhJKCbJcqkvcUJv0oTMaunt4k9a+0cP8LW3lgzTa27+2kIG6cenQ15y2eypkLapg9Sd1hItmgMOlHYTI+JJPOc5t289Cabdy/ehuv7opufzOvuozT50/muJlVLJpRycKpFRQmdJaYSKYpTPpRmIw/7s5LO/bx+EvNPPFSE09t2EVbVy8AiZgxbUIxsyaWMLOqlBlVxUyfUML0vraJJZQW6viLSLp0arCMe2bGwqkVLJxawUffMo/epPPKzv2s2bKXP23bS2NLO5tb2vn9y81s39tBst/fSZPKCpk9qZTayaXMnVTK3Mll1FZHz5PLCjWumEgatGciOamnN8mO1k627mmnsaXv0caru9rY2NzG1j3th4RNSUGcGVXFzKgqYVplMVMqi6gpL2JKZTHV5UXUVBRRXV5IeVFCoSN5TXsmklcS8RgzqkqYUVXCm+e+dn5nTy+NLe28urONjTv3s7mlnc2729myu50/b2+leV8Xvf13bYCiRIzq8iImlxcyuayQSWXR60llhUwqLaSqtICq8DyhpICK4gQlBXEFkOQ8hYnkpaJEnKNryjm6pnzA+b1JZ9f+LppaO2ned/Cxc18XTfs6aQ7P67a10ry/i66e5GHXFY8ZFcUJKooTVBYXHHieUBI9qkoLmFBaGL1ObSspoLwooRGYZVxQmIgMIB4zaiqi7q3X4+60d/eya38XLfu72dPeze72Lna3ddPa0UNrx8HnvR097G3vZuPO/ext72FPezft3b1H/PyywjjlxQnKihKUFyUoLYxTWhjt8RQVxCguiFOciFMcXhclYpQUhrbCOCUFcUoL4xSH59LCOCWhvaQgrrCSEaEwEUmTmVFamKC0MMGsiUN/f2dPL3vau9nTFgXRnvZudrd1s7ej+0Dg7O/sYV94tHf1sqO1g7auXjq7k3T29NLRnaSju5eeAbrmXk9hPHYgiIpDwBQXxCgK08WJ8DoRo6ggRlEiCqyiRDxMxyhMxCiMR88Hp+MUJmIUxO3A/IKwTEE8TCeMgniMRMzGXVfgnrZu1m1vZd32VrbsbqeiOMHE0kKmVBRxylGT8270hvzaWpExqCgRZ0pFnCkV6Q962dObpKMnCpa+R1tXL+1dvbR1R88HX/fQ0Z2kPbR3dPfSfuB90WfsaetiR0+SzvCZnT1JOrt76ehJDnhMabjMOBgw8Shg+oInEeubNhLxg9OJuJGIHdqeiEWvC8K8aJmU+XGjIBYjHl7HzIjHjLgZZtEfBn2R1pt0et3p6O49sGfZvK+LV3bu55Wdbezc33Wg/phxyAkdRYkYZy6s4W2LpjJ9QjGlhQkK4saftrXyx027eXHrXhIxC12dhRxVU8aSWVW8adYEEjFjR2snTa2d7Nrfxe62Lna3d1NWGOfoKeUsmFJBdfnBsw87e3ppau1kR2snnd3JA3vUlcWvPVmkuzdJS1sXk0oLR3yPVGEikkMS8Rjl8Rjlo/BXcU9vkq7eJJ3d0XNXCJ2unoPT3b2vne4+8NoPtEef5dHr5MH39PT6gfd09zo9yei5rauHnqRHbb3J8DoKuL7lenud7mT0GcPZY+uvuCDGpNJC5k4u4+2Lp1I7uYyF0yo4ZmoF0ycU09Ed/VC/srONB9ds44HV23j4xe2v+ZyK4gSLZ1QSM2PL7g7WbNnLnc82DrkeMzB4zSnwfRIxO9A1mogbLfu72NvRA8Cjf38W86rLhrzOI1GYiMiwJOIxEvEYpePgvmfuTm8yCpWepB8ImmTY++hNOu5ED6Jf53gs2rspTMSoKE687n14SgrjlBRGZxCeevRk/u8Fi2ho2negm7KzJ8nRNeUcVV1GLHboHsPuti5e2LyH1Zv3YgY14XT0SWWFTCwrZGJpAXvbe2jYsY+XdrTSsr8LJ6q3KBGLTmWvKKIoEad5X7RXs3N/F22dPezr7KW7N8nE0gImlkVnIVZlYJw7XWciIiKDdrjrTHQah4iIpE1hIiIiaVOYiIhI2rISJmb2VTP7k5mtMrO7zKwqtNeaWbuZPR8e3015z5vN7AUzazCzb1k4583MJpnZw2b2Ungexpn+IiKSjmztmTwMHOvuxwF/Bq5Nmfeyux8fHleltH8H+GtgQXgsC+3XAL929wXAr8O0iIiMoqyEibs/5O49YXIFMOtIy5vZdKDS3Vd4dPrZj4F3h9nLgVvC61tS2kVEZJSMhWMmHwHuT5meZ2bPmdljZnZGaJsJpF7V0xjaAKa6+9bwehswNaPViojIa2TsokUzewSYNsCs69z9V2GZ64Ae4Kdh3lZgjrvvNLM3A780s8WDXae7u5kd9sIZM7sSuBJgzpw5g/1YERF5HRkLE3c/90jzzexDwAXAOaHrCnfvBDrD65Vm9jKwENjMoV1hs0IbwHYzm+7uW0N32I4j1HQTcFNYf5OZvTKETaoGmoewfC7Ix22G/NzufNxmyM/tTnebB7hDUJaGUzGzZcA/Am9197aU9hpgl7v3mtlRRAfa17v7LjPba2anAE8BlwP/Ed52N3AFcEN4/tVganD3miHWXD/QVZ+5LB+3GfJzu/NxmyE/tztT25ytsbluBIqAh8MZvivCmVtnAl8ys24gCVzl7rvCe/4W+BFQQnSMpe84yw3A7Wb2UeAV4OLR2ggREYlkJUzcff5h2u8E7jzMvHrg2AHadwLnjGiBIiIyJGPhbK7x4qZsF5AF+bjNkJ/bnY/bDPm53RnZ5rwdNVhEREaO9kxERCRtChMREUmbwuR1mNkyM1sXBpjM2XG/zGy2mT1qZi+a2Roz+1Roz/mBNM0sHkZduCdMzzOzp8J3/nMzGwf3EhwaM6syszvCgKtrzezUXP+uzezvwn/bq83sVjMrzsXv2sxuNrMdZrY6pW3A79Yi3wrbv8rMThjuehUmR2BmceDbwPnAIuBSM1uU3aoypgf4rLsvAk4BPh62NR8G0vwUsDZl+ivA18NZhy3AR7NSVWZ9E3jA3d8ALCHa/pz9rs1sJvBJoM7djwXiwCXk5nf9Iw4OhNvncN/t+RwcPPdKogF1h0VhcmQnAQ3uvt7du4DbiAaWzDnuvtXdnw2vW4l+XGaS4wNpmtks4J3AD8K0AWcDd4RFcnGbJxBd0/VDAHfvcvfd5Ph3TXQpRImZJYBSouGbcu67dvffAbv6NR/uu10O/NgjK4CqMJLIkClMjmwmsCllOnWAyZxlZrXAUqLRBnJ9IM1vEI3GkAzTk4HdKaNa5+J3Pg9oAv4rdO/9wMzKyOHv2t03A18DXiUKkT3ASnL/u+5zuO92xH7jFCZyCDMrJ7pw9NPuvjd1XhhDLWfOJTezC4Ad7r4y27WMsgRwAvAdd18K7Kdfl1YOftcTif4KnwfMAMp4bVdQXsjUd6swObLNwOyU6dQBJnOOmRUQBclP3f0XoXl7327v6w2kOQ6dDrzLzDYSdWGeTXQsoSp0hUBufueNQKO7PxWm7yAKl1z+rs8FNrh7k7t3A78g+v5z/bvuc7jvdsR+4xQmR/YMsCCc8VFIdMDu7izXlBHhWMEPgbXu/u8ps/oG0oQhDKQ5Hrj7te4+y91rib7b37j7XwKPAheFxXJqmwHcfRuwycyOCU3nAC+Sw981UffWKWZWGv5b79vmnP6uUxzuu70buDyc1XUKsCelO2xIdAX86zCzdxD1q8eBm939+uxWlBlm9hbgceAFDh4/+DzRcZPbgTmEgTRTBt/MGWZ2FvD37n5BGLH6NmAS8BzwgXB7hJxhZscTnXRQCKwHPkz0x2XOftdm9kXg/URnLj4H/BXR8YGc+q7N7FbgLKKh5rcD/wz8kgG+2xCsNxJ1+bUBHw7jIA59vQoTERFJl7q5REQkbQoTERFJm8JERETSpjAREZG0KUxERCRtChORNJnZ78NzrZldNsKf/fmB1iUy1ujUYJERknqtyhDek0gZG2qg+fvcvXwEyhPJKO2ZiKTJzPaFlzcAZ5jZ8+HeGXEz+6qZPRPuFfE3YfmzzOxxM7ub6CpszOyXZrYy3G/jytB2A9Eot8+b2U9T1xWuWP5quDfHC2b2/pTP/m3KvUp+Gi5ME8moxOsvIiKDdA0peyYhFPa4+4lmVgQ8aWYPhWVPAI519w1h+iPhiuQS4Bkzu9PdrzGzq939+AHW9V7geKJ7kVSH9/wuzFsKLAa2AE8SjUH1xEhvrEgq7ZmIZM7bicY9ep5oWJrJRDchAng6JUgAPmlmfwRWEA28t4Ajewtwq7v3uvt24DHgxJTPbnT3JPA8UDsC2yJyRNozEckcAz7h7g8e0hgdW9nfb/pc4FR3bzOz3wLFaaw3dWypXvT/uYwC7ZmIjJxWoCJl+kHgY2Fof8xsYbgJVX8TgJYQJG8gum1yn+6+9/fzOPD+cFymhujOiU+PyFaIDIP+YhEZOauA3tBd9SOie6PUAs+Gg+BNDHxb2AeAq8xsLbCOqKurz03AKjN7NgyP3+cu4FTgj0Q3OvpHd98Wwkhk1OnUYBERSZu6uUREJG0KExERSZvCRERE0qYwERGRtClMREQkbQoTERFJm8JERETS9v8Bb+rX1oZ3hjIAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "class NET(paddle.nn.Layer):\n", - " \n", - " # 初始化可学习参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " def __init__(self, shape, dtype='float64'):\n", - " super(NET, self).__init__()\n", - " \n", - " # 创建用来学习 U 的参数 theta\n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype,is_bias=False)\n", - " \n", - " # 创建用来学习 V_dagger 的参数 phi\n", - " self.phi = self.create_parameter(shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # 将 Numpy array 转换成 Paddle 支持的 Tensor\n", - " self.M = paddle.to_tensor(M)\n", - " self.weight = paddle.to_tensor(weight)\n", - "\n", - " # 定义损失函数和前向传播机制\n", - " def forward(self):\n", - " \n", - " # 获取量子神经网络的酉矩阵表示\n", - " U = U_theta(self.theta)\n", - " U_dagger = dagger(U)\n", - " \n", - " V = U_theta(self.phi)\n", - " V_dagger = dagger(V)\n", - " \n", - " # 初始化损失函数和奇异值存储器\n", - " loss = 0 \n", - " singular_values = np.zeros(T)\n", - " \n", - " # 定义损失函数\n", - " for i in range(T):\n", - " loss -= paddle.real(self.weight)[i] * paddle.real(matmul(U_dagger,matmul(self.M, V)))[i][i]\n", - " singular_values[i] = paddle.real(matmul(U_dagger, matmul(self.M, V)))[i][i].numpy()\n", - " \n", - " # 函数返回两个矩阵 U 和 V_dagger 学习的奇异值以及损失函数 \n", - " return U, V_dagger, loss, singular_values\n", - " \n", - "# 记录优化中间过程\n", - "loss_list, singular_value_list = [], []\n", - "U_learned, V_dagger_learned = [], []\n", - "\n", - "import time\n", - "start = time.time()\n", - " \n", - "# 确定网络的参数维度\n", - "net = NET([theta_size])\n", - "\n", - "# 一般来说，我们利用 Adam 优化器来获得相对好的收敛\n", - "# 当然你可以改成 SGD 或者是 RMS prop.\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", - "\n", - "# 优化循环\n", - "for itr in range(ITR):\n", - "\n", - " # 前向传播计算损失函数\n", - " U, V_dagger, loss, singular_values = net()\n", - "\n", - " # 反向传播极小化损失函数\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - "\n", - " # 记录优化中间结果\n", - " loss_list.append(loss[0][0].numpy())\n", - " singular_value_list.append(singular_values)\n", - " \n", - " if itr% 10 == 0:\n", - " print('iter:', itr,'loss:','%.4f'% loss.numpy()[0])\n", - " \n", - "# 绘制学习曲线\n", - "loss_plot(loss_list)\n", - "\n", - "# 记录最后学出的两个酉矩阵 \n", - "U_learned = U.numpy()\n", - "V_dagger_learned = V_dagger.numpy()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "接着我们来探究下量子版本的奇异值分解的精度问题。在上述部分，我们提到过可以用分解得到的更少的信息来表达原矩阵。具体来说，就是用前 $T$ 个奇异值和前 $T$ 列左右奇异向量重构一个矩阵：\n", - "\n", - "$$\n", - "M_{re}^{(T)} = UDV^{\\dagger}, \\tag{4}\n", - "$$\n", - "\n", - "并且对于一个本身秩 (rank) 为 $r$ 的矩阵 $M$, 误差随着使用奇异值的数量变多会越来越小。经典的奇异值算法可以保证：\n", - "\n", - "$$\n", - "\\lim_{T\\rightarrow r} ||M - M_{re}^{(T)}||^2_2 = 0, \\tag{5}\n", - "$$\n", - "\n", - "其中矩阵间的距离测量由 Frobenius-norm 来计算,\n", - "\n", - "$$\n", - "||M||_2 = \\sqrt{\\sum_{i,j} |M_{ij}|^2}. \\tag{6}\n", - "$$\n", - "\n", - "目前量子版本的奇异值分解还需要很长时间的优化，理论上只能保证上述误差不断减小。" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:49:24.407257Z", - "start_time": "2021-03-09T03:49:24.027591Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "singular_value = singular_value_list[-1]\n", - "err_subfull, err_local, err_SVD = [], [], []\n", - "U, D, V_dagger = np.linalg.svd(M, full_matrices=True)\n", - "\n", - "# 计算 Frobenius-norm 误差\n", - "for i in range(T):\n", - " lowrank_mat = np.matrix(U[:, :i]) * np.diag(D[:i])* np.matrix(V_dagger[:i, :])\n", - " recons_mat = np.matrix(U_learned[:, :i]) * np.diag(singular_value[:i])* np.matrix(V_dagger_learned[:i, :])\n", - " err_local.append(norm(lowrank_mat - recons_mat)) \n", - " err_subfull.append(norm(M_err - recons_mat))\n", - " err_SVD.append(norm(M_err- lowrank_mat))\n", - "\n", - "\n", - "# 画图 \n", - "fig, ax = plt.subplots()\n", - "ax.plot(list(range(1, T+1)), err_subfull, \"o-.\", \n", - " label = 'Reconstruction via VQSVD')\n", - "ax.plot(list(range(1, T+1)), err_SVD, \"^--\", \n", - " label='Reconstruction via SVD')\n", - "plt.xlabel('Singular Value Used (Rank)', fontsize = 14)\n", - "plt.ylabel('Norm Distance', fontsize = 14)\n", - "leg = plt.legend(frameon=True)\n", - "leg.get_frame().set_edgecolor('k')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "### 案例2：图像压缩\n", - "\n", - "为了做图像处理，我们先引入必要的 package。" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:50:17.225100Z", - "start_time": "2021-03-09T03:50:17.151352Z" - } - }, - "outputs": [], - "source": [ - "# 图像处理包 PIL\n", - "from PIL import Image\n", - "\n", - "# 打开提前准备好的图片\n", - "img = Image.open('./figures/MNIST_32.png')\n", - "imgmat = np.array(list(img.getdata(band=0)), float)\n", - "imgmat.shape = (img.size[1], img.size[0])\n", - "imgmat = np.matrix(imgmat)/255" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:50:18.337792Z", - "start_time": "2021-03-09T03:50:17.231211Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 然后我们看看经典奇异值的分解效果\n", - "U, sigma, V = np.linalg.svd(imgmat)\n", - "\n", - "for i in range(5, 16, 5):\n", - " reconstimg = np.matrix(U[:, :i]) * np.diag(sigma[:i]) * np.matrix(V[:i, :])\n", - " plt.imshow(reconstimg, cmap='gray')\n", - " title = \"n = %s\" % i\n", - " plt.title(title)\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:50:18.966739Z", - "start_time": "2021-03-09T03:50:18.950606Z" - } - }, - "outputs": [], - "source": [ - "# 然后我们再来看看量子版本的分解效果：\n", - "\n", - "# 超参数设置\n", - "N = 5 # 量子比特数量\n", - "T = 8 # 设置想要学习的阶数\n", - "ITR = 200 # 迭代次数\n", - "LR = 0.02 # 学习速率\n", - "SEED = 14 # 随机数种子\n", - "\n", - "# 设置等差的学习权重\n", - "weight = np.arange(2 * T, 0, -2).astype('complex128')\n", - "\n", - "\n", - "def Mat_generator():\n", - " imgmat = np.array(list(img.getdata(band=0)), float)\n", - " imgmat.shape = (img.size[1], img.size[0])\n", - " lenna = np.matrix(imgmat)\n", - " return lenna.astype('complex128')\n", - "\n", - "M_err = Mat_generator()\n", - "U, D, V_dagger = np.linalg.svd(Mat_generator(), full_matrices=True)\n", - "\n", - "# 设置电路参数\n", - "cir_depth = 40 # 电路深度\n", - "block_len = 1 # 每个模组的长度\n", - "theta_size = N * block_len * cir_depth # 网络参数 theta 的大小" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:50:19.553293Z", - "start_time": "2021-03-09T03:50:19.531180Z" - } - }, - "outputs": [], - "source": [ - "# 定义量子神经网络\n", - "def U_theta(theta):\n", - "\n", - " # 用 UAnsatz 初始化网络\n", - " cir = UAnsatz(N)\n", - " \n", - " # 搭建层级结构：\n", - " for layer_num in range(cir_depth):\n", - " \n", - " for which_qubit in range(N):\n", - " cir.ry(theta[block_len * layer_num * N + which_qubit],\n", - " which_qubit)\n", - "\n", - " for which_qubit in range(1, N):\n", - " cir.cnot([which_qubit - 1, which_qubit])\n", - "\n", - " return cir.U" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:50:21.636509Z", - "start_time": "2021-03-09T03:50:21.593577Z" - } - }, - "outputs": [], - "source": [ - "class NET(paddle.nn.Layer):\n", - " \n", - " # 初始化可学习参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " def __init__(self, shape, dtype='float64'):\n", - " super(NET, self).__init__()\n", - " \n", - " # 创建用来学习 U 的参数 theta\n", - " self.theta = self.create_parameter(shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # 创建用来学习 V_dagger 的参数 phi\n", - " self.phi = self.create_parameter(shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # 将 Numpy array 转换成 Paddle 支持的 Tensor\n", - " self.M = paddle.to_tensor(Mat_generator())\n", - " self.weight = paddle.to_tensor(weight)\n", - "\n", - " # 定义损失函数和前向传播机制\n", - " def forward(self):\n", - " \n", - " # 获取量子神经网络的酉矩阵表示\n", - " U = U_theta(self.theta)\n", - " U_dagger = dagger(U)\n", - " \n", - " \n", - " V = U_theta(self.phi)\n", - " V_dagger = dagger(V)\n", - " \n", - " # 初始化损失函数和奇异值存储器\n", - " loss = 0 \n", - " singular_values = np.zeros(T)\n", - " \n", - " # 定义损失函数\n", - " for i in range(T):\n", - " loss -= paddle.real(self.weight)[i] * paddle.real(matmul(U_dagger,matmul(self.M, V)))[i][i]\n", - " singular_values[i] = paddle.real(matmul(U_dagger, matmul(self.M, V)))[i][i].numpy()\n", - " \n", - " # 函数返回两个矩阵 U 和 V_dagger 学习的奇异值以及损失函数 \n", - " return U, V_dagger, loss, singular_values" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:59:58.649381Z", - "start_time": "2021-03-09T03:54:30.126561Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 0 loss: 11569.3661\n", - "iter: 10 loss: -84679.3080\n", - "iter: 20 loss: -103418.2506\n", - "iter: 30 loss: -120854.8849\n", - "iter: 40 loss: -130997.4657\n", - "iter: 50 loss: -140376.4574\n", - "iter: 60 loss: -146738.7417\n", - "iter: 70 loss: -149536.6623\n", - "iter: 80 loss: -151092.6062\n", - "iter: 90 loss: -152296.0673\n", - "iter: 100 loss: -153290.4326\n", - "iter: 110 loss: -154112.8803\n", - "iter: 120 loss: -154812.4464\n", - "iter: 130 loss: -155384.0762\n", - "iter: 140 loss: -155814.4174\n", - "iter: 150 loss: -156132.5890\n", - "iter: 160 loss: -156377.1011\n", - "iter: 170 loss: -156571.0730\n", - "iter: 180 loss: -156728.6039\n", - "iter: 190 loss: -156859.1820\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 记录优化中间过程\n", - "loss_list, singular_value_list = [], []\n", - "U_learned, V_dagger_learned = [], []\n", - " \n", - "net = NET([theta_size])\n", - "\n", - "# 一般来说，我们利用 Adam 优化器来获得相对好的收敛\n", - "# 当然你可以改成 SGD 或者是 RMS prop.\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", - "\n", - "# 优化循环\n", - "for itr in range(ITR):\n", - "\n", - " # 前向传播计算损失函数\n", - " U, V_dagger, loss, singular_values = net()\n", - "\n", - " # 反向传播极小化损失函数\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - "\n", - " # 记录优化中间结果\n", - " loss_list.append(loss[0][0].numpy())\n", - " singular_value_list.append(singular_values)\n", - " \n", - " if itr% 10 == 0:\n", - " print('iter:', itr,'loss:','%.4f'% loss.numpy()[0])\n", - "\n", - "# 记录最后学出的两个酉矩阵 \n", - "U_learned = U.numpy()\n", - "V_dagger_learned = V_dagger.numpy()\n", - "\n", - "singular_value = singular_value_list[-1]\n", - "mat = np.matrix(U_learned.real[:, :T]) * np.diag(singular_value[:T])* np.matrix(V_dagger_learned.real[:T, :])\n", - "\n", - "reconstimg = mat\n", - "plt.imshow(reconstimg, cmap='gray')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "_______\n", - "\n", - "## 参考文献\n", - "\n", - "[1] Wang, X., Song, Z., & Wang, Y. Variational Quantum Singular Value Decomposition. [Quantum, 5, 483 (2021).](https://quantum-journal.org/papers/q-2021-06-29-483/)" - ] - } - ], - "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" - }, - "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": true - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/tutorial/machine_learning/VQSVD_EN.ipynb b/tutorial/machine_learning/VQSVD_EN.ipynb deleted file mode 100644 index deb5f6c..0000000 --- a/tutorial/machine_learning/VQSVD_EN.ipynb +++ /dev/null @@ -1,962 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Variational Quantum Singular Value Decomposition\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Overview\n", - "\n", - "In this tutorial, we will go through the concept of classical singular value decomposition (SVD) and the quantum neural network (QNN) version of variational quantum singular value decomposition (VQSVD) [1]. The tutorial consists of the following two parts: \n", - "- Decompose a randomly generated $8\\times8$ complex matrix; \n", - "- Apply SVD on image compression." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Background\n", - "\n", - "Singular value decomposition (SVD) has many applications, including principal component analysis (PCA), solving linear equations and recommender systems. The main task is formulated as following:\n", - "> Given a complex matrix $M \\in \\mathbb{C}^{m \\times n}$, find the decomposition in form $M = UDV^\\dagger$, where $U_{m\\times m}$ and $V^\\dagger_{n\\times n}$ are unitary matrices, which satisfy the property $UU^\\dagger = VV^\\dagger = I$.\n", - "\n", - "- The column vectors $|u_j\\rangle$ of the unitary matrix $U$ are called left singular vectors $\\{|u_j\\rangle\\}_{j=1}^{m}$ form an orthonormal basis. These column vectors are the eigenvectors of the matrix $MM^\\dagger$.\n", - "- Similarly, the column vectors $\\{|v_j\\rangle\\}_{j=1}^{n}$ of the unitary matrix $V$ are the eigenvectors of $M^\\dagger M$ and form an orthonormal basis.\n", - "- The diagonal elements of the matrix $D_{m\\times n}$ are singular values $d_j$ arranged in a descending order.\n", - "\n", - "For the convenience, we assume that the $M$ appearing below are all square matrices. Let's first look at an example: \n", - "\n", - "$$\n", - "M = 2*X\\otimes Z + 6*Z\\otimes X + 3*I\\otimes I = \n", - "\\begin{bmatrix} \n", - "3 &6 &2 &0 \\\\\n", - "6 &3 &0 &-2 \\\\\n", - "2 &0 &3 &-6 \\\\\n", - "0 &-2 &-6 &3 \n", - "\\end{bmatrix}, \\tag{1}\n", - "$$\n", - "\n", - "Then the singular value decomposition of the matrix can be expressed as:\n", - "\n", - "$$\n", - "M = UDV^\\dagger = \n", - "\\frac{1}{2}\n", - "\\begin{bmatrix} \n", - "-1 &-1 &1 &1 \\\\\n", - "-1 &-1 &-1 &-1 \\\\\n", - "-1 &1 &-1 &1 \\\\\n", - "1 &-1 &-1 &1 \n", - "\\end{bmatrix}\n", - "\\begin{bmatrix} \n", - "11 &0 &0 &0 \\\\\n", - "0 &7 &0 &0 \\\\\n", - "0 &0 &5 &0 \\\\\n", - "0 &0 &0 &1 \n", - "\\end{bmatrix}\n", - "\\frac{1}{2}\n", - "\\begin{bmatrix} \n", - "-1 &-1 &-1 &-1 \\\\\n", - "-1 &-1 &1 &1 \\\\\n", - "-1 &1 &1 &-1 \\\\\n", - "1 &-1 &1 &-1 \n", - "\\end{bmatrix}. \\tag{2}\n", - "$$\n", - "\n", - "Import packages." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:44:34.008567Z", - "start_time": "2021-03-09T03:44:29.796997Z" - } - }, - "outputs": [], - "source": [ - "import time\n", - "import numpy as np\n", - "from numpy import pi as PI\n", - "from matplotlib import pyplot as plt\n", - "from scipy.stats import unitary_group\n", - "from scipy.linalg import norm\n", - "\n", - "import paddle\n", - "from paddle import matmul, transpose, trace\n", - "from paddle_quantum.circuit import *\n", - "from paddle_quantum.utils import *\n", - "\n", - "\n", - "\n", - "# Draw the learning curve in the optimization process\n", - "def loss_plot(loss):\n", - " '''\n", - " loss is a list, this function plots loss over iteration\n", - " '''\n", - " plt.plot(list(range(1, len(loss)+1)), loss)\n", - " plt.xlabel('iteration')\n", - " plt.ylabel('loss')\n", - " plt.title('Loss Over Iteration')\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Classical Singular Value Decomposition\n", - "\n", - "With the above mathematical definition, one can realize SVD numerically through NumPy." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:44:34.056721Z", - "start_time": "2021-03-09T03:44:34.012222Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The matrix M we want to decompose is: \n", - "[[ 3.+0.j 6.+0.j 2.+0.j 0.+0.j]\n", - " [ 6.+0.j 3.+0.j 0.+0.j -2.+0.j]\n", - " [ 2.+0.j 0.+0.j 3.+0.j -6.+0.j]\n", - " [ 0.+0.j -2.+0.j -6.+0.j 3.+0.j]]\n" - ] - } - ], - "source": [ - "# Generate matrix M\n", - "def M_generator():\n", - " I = np.array([[1, 0], [0, 1]])\n", - " Z = np.array([[1, 0], [0, -1]])\n", - " X = np.array([[0, 1], [1, 0]])\n", - " Y = np.array([[0, -1j], [1j, 0]])\n", - " M = 2 *np.kron(X, Z) + 6 * np.kron(Z, X) + 3 * np.kron(I, I)\n", - " return M.astype('complex64')\n", - "\n", - "print('The matrix M we want to decompose is: ')\n", - "print(M_generator())" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:44:34.093725Z", - "start_time": "2021-03-09T03:44:34.063353Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The singular values of the matrix from large to small are:\n", - "[11. 7. 5. 1.]\n", - "The decomposed unitary matrix U is:\n", - "[[-0.5+0.j -0.5+0.j 0.5+0.j 0.5+0.j]\n", - " [-0.5+0.j -0.5+0.j -0.5+0.j -0.5+0.j]\n", - " [-0.5+0.j 0.5+0.j -0.5+0.j 0.5+0.j]\n", - " [ 0.5+0.j -0.5+0.j -0.5+0.j 0.5+0.j]]\n", - "The decomposed unitary matrix V_dagger is:\n", - "[[-0.5+0.j -0.5+0.j -0.5+0.j 0.5+0.j]\n", - " [-0.5+0.j -0.5+0.j 0.5+0.j -0.5+0.j]\n", - " [-0.5+0.j 0.5+0.j 0.5+0.j 0.5+0.j]\n", - " [-0.5+0.j 0.5+0.j -0.5+0.j -0.5+0.j]]\n" - ] - } - ], - "source": [ - "# We only need the following line of code to complete SVD\n", - "U, D, V_dagger = np.linalg.svd(M_generator(), full_matrices=True)\n", - "\n", - "\n", - "# Print decomposition results\n", - "print(\"The singular values of the matrix from large to small are:\")\n", - "print(D)\n", - "print(\"The decomposed unitary matrix U is:\")\n", - "print(U)\n", - "print(\"The decomposed unitary matrix V_dagger is:\")\n", - "print(V_dagger)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:44:34.112670Z", - "start_time": "2021-03-09T03:44:34.098847Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[[ 3.+0.j 6.+0.j 2.+0.j 0.+0.j]\n", - " [ 6.+0.j 3.+0.j 0.+0.j -2.+0.j]\n", - " [ 2.+0.j 0.+0.j 3.+0.j -6.+0.j]\n", - " [ 0.+0.j -2.+0.j -6.+0.j 3.+0.j]]\n" - ] - } - ], - "source": [ - "# Then assemble it back, can we restore the original matrix?\n", - "M_reconst = np.matmul(U, np.matmul(np.diag(D), V_dagger))\n", - "print(M_reconst)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Surely, we can be restored the original matrix $M$! One can further modify the matrix, see what happens if it is not a square matrix.\n", - "\n", - "---" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Quantum Singular Value Decomposition\n", - "\n", - "Next, let's take a look at what the quantum version of singular value decomposition is all about. In summary, we transform the problem of matrix factorization into an optimization problem with the variational principle of singular values. Specifically, this is achieved through the following four steps:\n", - "\n", - "- Prepare an orthonormal basis $\\{|\\psi_j\\rangle\\}$, one can take the computational basis $\\{ |000\\rangle, |001\\rangle,\\cdots |111\\rangle\\}$ (this is in the case of 3 qubits)\n", - "- Prepare two parameterized quantum neural networks $U(\\theta)$ and $V(\\phi)$ to learn left/right singular vectors respectively\n", - "- Use quantum neural network to estimate singular values $m_j = \\text{Re}\\langle\\psi_j|U(\\theta)^{\\dagger} M V(\\phi)|\\psi_j\\rangle$\n", - "- Design the loss function $\\mathcal{L}(\\theta)$ and use PaddlePaddle Deep Learning framework to maximize the following quantity, \n", - "\n", - "$$\n", - "L(\\theta,\\phi) = \\sum_{j=1}^T q_j\\times \\text{Re} \\langle\\psi_j|U(\\theta)^{\\dagger} MV(\\phi)|\\psi_j\\rangle. \\tag{3}\n", - "$$\n", - "\n", - "Where $q_1>\\cdots>q_T>0$ is the adjustable weights (hyperparameter), and $T$ represents the rank we want to learn or the total number of singular values to be learned.\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Case 1: Decompose a randomly generated $8\\times8$ complex matrix\n", - "\n", - "Then we look at a specific example, which can better explain the overall process." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:44:34.132465Z", - "start_time": "2021-03-09T03:44:34.116446Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The matrix M we want to decompose is:\n", - "[[6.+1.j 3.+9.j 7.+3.j 4.+7.j 6.+6.j 9.+8.j 2.+7.j 6.+4.j]\n", - " [7.+1.j 4.+4.j 3.+7.j 7.+9.j 7.+8.j 2.+8.j 5.+0.j 4.+8.j]\n", - " [1.+6.j 7.+8.j 5.+7.j 1.+0.j 4.+7.j 0.+7.j 9.+2.j 5.+0.j]\n", - " [8.+7.j 0.+2.j 9.+2.j 2.+0.j 6.+4.j 3.+9.j 8.+6.j 2.+9.j]\n", - " [4.+8.j 2.+6.j 6.+8.j 4.+7.j 8.+1.j 6.+0.j 1.+6.j 3.+6.j]\n", - " [8.+7.j 1.+4.j 9.+2.j 8.+7.j 9.+5.j 4.+2.j 1.+0.j 3.+2.j]\n", - " [6.+4.j 7.+2.j 2.+0.j 0.+4.j 3.+9.j 1.+6.j 7.+6.j 3.+8.j]\n", - " [1.+9.j 5.+9.j 5.+2.j 9.+6.j 3.+0.j 5.+3.j 1.+3.j 9.+4.j]]\n", - "The singular values of the matrix M are:\n", - "[54.83484985 19.18141073 14.98866247 11.61419557 10.15927045 7.60223249\n", - " 5.81040539 3.30116001]\n" - ] - } - ], - "source": [ - "# First fix the random seed, in order to reproduce the results at any time\n", - "np.random.seed(42)\n", - "\n", - "# Set the number of qubits, which determines the dimension of the Hilbert space\n", - "N = 3\n", - "\n", - "# Make a random matrix generator\n", - "def random_M_generator():\n", - " M = np.random.randint(10, size = (2**N, 2**N)) + 1j*np.random.randint(10, size = (2**N, 2**N))\n", - " return M\n", - "\n", - "M = random_M_generator()\n", - "M_err = np.copy(M)\n", - "\n", - "\n", - "# Output the matrix M\n", - "print('The matrix M we want to decompose is:')\n", - "print(M)\n", - "\n", - "# Apply SVD and record the exact singular values\n", - "U, D, V_dagger = np.linalg.svd(M, full_matrices=True)\n", - "print(\"The singular values of the matrix M are:\")\n", - "print(D)" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:44:34.147570Z", - "start_time": "2021-03-09T03:44:34.138265Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The selected weight is:\n", - "[24.+0.j 21.+0.j 18.+0.j 15.+0.j 12.+0.j 9.+0.j 6.+0.j 3.+0.j]\n" - ] - } - ], - "source": [ - "# Hyperparameter settings\n", - "N = 3 # Number of qubits\n", - "T = 8 # Set the number of rank you want to learn\n", - "ITR = 100 # Number of iterations\n", - "LR = 0.02 # Learning rate\n", - "SEED = 14 # Random seed\n", - "\n", - "# Set the learning weight \n", - "weight = np.arange(3 * T, 0, -3).astype('complex128')\n", - "print('The selected weight is:')\n", - "print(weight)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We design QNN with the following structure:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:44:34.245692Z", - "start_time": "2021-03-09T03:44:34.226859Z" - } - }, - "outputs": [], - "source": [ - "# Set circuit parameters\n", - "cir_depth = 20 # circuit depth\n", - "block_len = 2 # length of each block\n", - "theta_size = N * block_len * cir_depth # size of the network parameter theta\n", - "\n", - "\n", - "# Define quantum neural network\n", - "def U_theta(theta):\n", - "\n", - " # Initialize the network with UAnsatz\n", - " cir = UAnsatz(N)\n", - " \n", - " # Build QNN\n", - " for layer_num in range(cir_depth):\n", - " \n", - " for which_qubit in range(N):\n", - " cir.ry(theta[block_len * layer_num * N + which_qubit], which_qubit)\n", - " \n", - " for which_qubit in range(N):\n", - " cir.rz(theta[(block_len * layer_num + 1) * N + which_qubit], which_qubit)\n", - "\n", - " for which_qubit in range(1, N):\n", - " cir.cnot([which_qubit - 1, which_qubit])\n", - " cir.cnot([N - 1, 0])\n", - "\n", - " return cir.U" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Then we complete the main part of the algorithm:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:46:12.944634Z", - "start_time": "2021-03-09T03:44:50.626213Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 0 loss: -235.9752\n", - "iter: 10 loss: -1635.7805\n", - "iter: 20 loss: -1967.8480\n", - "iter: 30 loss: -2154.2274\n", - "iter: 40 loss: -2257.8776\n", - "iter: 50 loss: -2311.8162\n", - "iter: 60 loss: -2342.3099\n", - "iter: 70 loss: -2358.9515\n", - "iter: 80 loss: -2369.3172\n", - "iter: 90 loss: -2375.9682\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "class NET(paddle.nn.Layer):\n", - " \n", - " # Initialize the list of learnable parameters, and fill the initial value with the uniform distribution of [0, 2*pi]\n", - " def __init__(self, shape, dtype='float64'):\n", - " super(NET, self).__init__()\n", - " \n", - " # Create the parameter theta for learning U\n", - " self.theta = self.create_parameter(shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # Create a parameter phi to learn V_dagger\n", - " self.phi = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # Convert Numpy array to Tensor supported in Paddle\n", - " self.M = paddle.to_tensor(M)\n", - " self.weight = paddle.to_tensor(weight)\n", - "\n", - " # Define loss function and forward propagation mechanism\n", - " def forward(self):\n", - " \n", - " # Get the unitary matrix representation of the quantum neural network\n", - " U = U_theta(self.theta)\n", - " U_dagger = dagger(U)\n", - " \n", - " \n", - " V = U_theta(self.phi)\n", - " V_dagger = dagger(V)\n", - " \n", - " # Initialize the loss function and singular value memory\n", - " loss = 0\n", - " singular_values = np.zeros(T)\n", - " \n", - " # Define loss function\n", - " for i in range(T):\n", - " loss -= paddle.real(self.weight)[i] * paddle.real(matmul(U_dagger,matmul(self.M, V)))[i][i]\n", - " singular_values[i] = paddle.real(matmul(U_dagger, matmul(self.M, V)))[i][i].numpy()\n", - " \n", - " # Function returns two matrices U and V_dagger, learned singular values and loss function\n", - " return U, V_dagger, loss, singular_values\n", - " \n", - "# Record the optimization process\n", - "loss_list, singular_value_list = [], []\n", - "U_learned, V_dagger_learned = [], []\n", - "\n", - " \n", - "# Determine the parameter dimension of the network\n", - "net = NET([theta_size])\n", - "\n", - "# We use Adam optimizer for better performance\n", - "# One can change it to SGD or RMSprop.\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", - "\n", - "# Optimization cycle\n", - "for itr in range(ITR):\n", - "\n", - " # Forward propagation to calculate loss function\n", - " U, V_dagger, loss, singular_values = net()\n", - "\n", - " # Back propagation minimizes the loss function\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - "\n", - " # Record optimization intermediate results\n", - " loss_list.append(loss[0][0].numpy())\n", - " singular_value_list.append(singular_values)\n", - " \n", - " if itr% 10 == 0:\n", - " print('iter:', itr,'loss:','%.4f'% loss.numpy()[0])\n", - "\n", - "# Draw a learning curve\n", - "loss_plot(loss_list)\n", - "\n", - "# Record the last two learned unitary matrices\n", - "U_learned = U.numpy()\n", - "V_dagger_learned = V_dagger.numpy()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We now explore the accuracy of the quantum version of singular value decomposition. In the above section, we mentioned that the original matrix can be expressed with less information obtained by decomposition. Specifically, it uses the first $T$ singular values and the first $T$ left and right singular vectors to reconstruct a matrix:\n", - "\n", - "$$\n", - "M_{re}^{(T)} = UDV^{\\dagger}, \\tag{4}\n", - "$$\n", - "\n", - "For matrix $M$ with rank $r$, the error will decreasing dramatically as more and more singular values are used to reconstruct it. The classic singular value algorithm can guarantee:\n", - "\n", - "$$\n", - "\\lim_{T\\rightarrow r} ||M-M_{re}^{(T)}||^2_2 = 0, \\tag{5}\n", - "$$\n", - "\n", - "The distance measurement between the matrices is calculated by the Frobenius-norm,\n", - "\n", - "$$\n", - "||M||_2 = \\sqrt{\\sum_{i,j} |M_{ij}|^2}. \\tag{6}\n", - "$$\n", - "\n", - "The current quantum version of singular value decomposition still needs a lot of efforts to be optimized. In theory, it can only guarantee the reduction of accumulated errors." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:46:13.453107Z", - "start_time": "2021-03-09T03:46:12.949847Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "singular_value = singular_value_list[-1]\n", - "err_subfull, err_local, err_SVD = [], [], []\n", - "U, D, V_dagger = np.linalg.svd(M, full_matrices=True)\n", - "\n", - "\n", - "# Calculate the Frobenius-norm error\n", - "for i in range(T):\n", - " lowrank_mat = np.matrix(U[:, :i]) * np.diag(D[:i])* np.matrix(V_dagger[:i, :])\n", - " recons_mat = np.matrix(U_learned[:, :i]) * np.diag(singular_value[:i])* np.matrix(V_dagger_learned[:i, :])\n", - " err_local.append(norm(lowrank_mat - recons_mat)) \n", - " err_subfull.append(norm(M_err - recons_mat))\n", - " err_SVD.append(norm(M_err- lowrank_mat))\n", - "\n", - "\n", - "# Plot\n", - "fig, ax = plt.subplots()\n", - "ax.plot(list(range(1, T+1)), err_subfull, \"o-.\", \n", - " label = 'Reconstruction via VQSVD')\n", - "ax.plot(list(range(1, T+1)), err_SVD, \"^--\", \n", - " label='Reconstruction via SVD')\n", - "plt.xlabel('Singular Value Used (Rank)', fontsize = 14)\n", - "plt.ylabel('Norm Distance', fontsize = 14)\n", - "leg = plt.legend(frameon=True)\n", - "leg.get_frame().set_edgecolor('k')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "---\n", - "### Case 2: Image compression\n", - "\n", - "In order to fulfill image processing tasks, we first import the necessary package.\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:47:14.486390Z", - "start_time": "2021-03-09T03:47:14.466171Z" - } - }, - "outputs": [], - "source": [ - "# Image processing package PIL\n", - "from PIL import Image\n", - "\n", - "# Open the picture prepared in advance\n", - "img = Image.open('./figures/MNIST_32.png')\n", - "imgmat = np.array(list(img.getdata(band=0)), float)\n", - "imgmat.shape = (img.size[1], img.size[0])\n", - "imgmat = np.matrix(imgmat)/255" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:47:15.837676Z", - "start_time": "2021-03-09T03:47:14.960968Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Then we look at the effect of the classic singular value decomposition\n", - "U, sigma, V = np.linalg.svd(imgmat)\n", - "\n", - "for i in range(5, 16, 5):\n", - " reconstimg = np.matrix(U[:, :i]) * np.diag(sigma[:i]) * np.matrix(V[:i, :])\n", - " plt.imshow(reconstimg, cmap='gray')\n", - " title = \"n = %s\" % i\n", - " plt.title(title)\n", - " plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:47:15.858695Z", - "start_time": "2021-03-09T03:47:15.847413Z" - } - }, - "outputs": [], - "source": [ - "# Hyper-parameters\n", - "N = 5 # Number of qubits\n", - "T = 8 # Set the number of rank you want to learn\n", - "ITR = 200 # Number of iterations\n", - "LR = 0.02 # Learning rate\n", - "SEED = 14 # Random number seed\n", - "\n", - "# Set the learning weight\n", - "weight = np.arange(2 * T, 0, -2).astype('complex128')\n", - "\n", - "# Convert the image into numpy array\n", - "def Mat_generator():\n", - " imgmat = np.array(list(img.getdata(band=0)), float)\n", - " imgmat.shape = (img.size[1], img.size[0])\n", - " lenna = np.matrix(imgmat)\n", - " return lenna.astype('complex128')\n", - "\n", - "M_err = Mat_generator()\n", - "U, D, V_dagger = np.linalg.svd(Mat_generator(), full_matrices=True)\n", - "\n", - "# Set circuit parameters\n", - "cir_depth = 40 # Circuit depth\n", - "block_len = 1 # The length of each module\n", - "theta_size = N * block_len * cir_depth # The size of the network parameter theta" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:47:16.002083Z", - "start_time": "2021-03-09T03:47:15.993385Z" - } - }, - "outputs": [], - "source": [ - "# Define quantum neural network\n", - "def U_theta(theta):\n", - "\n", - " # Initialize the network with UAnsatz\n", - " cir = UAnsatz(N)\n", - " \n", - " # Build a hierarchy:\n", - " for layer_num in range(cir_depth):\n", - " \n", - " for which_qubit in range(N):\n", - " cir.ry(theta[block_len * layer_num * N + which_qubit], which_qubit)\n", - "\n", - " for which_qubit in range(1, N):\n", - " cir.cnot([which_qubit - 1, which_qubit])\n", - "\n", - " return cir.U" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:47:16.619406Z", - "start_time": "2021-03-09T03:47:16.600512Z" - } - }, - "outputs": [], - "source": [ - "class NET(paddle.nn.Layer):\n", - " \n", - " # Initialize the list of learnable parameters, and fill the initial value with the uniform distribution of [0, 2*pi]\n", - " def __init__(self, shape, dtype='float64'):\n", - " super(NET, self).__init__()\n", - " \n", - " # Create the parameter theta for learning U\n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # Create a parameter phi to learn V_dagger\n", - " self.phi = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # Convert Numpy array to Tensor supported in Paddle\n", - " self.M = paddle.to_tensor(Mat_generator())\n", - " self.weight = paddle.to_tensor(weight)\n", - "\n", - " # Define loss function and forward propagation mechanism\n", - " def forward(self):\n", - " \n", - " # Get the unitary matrix representation of the quantum neural network\n", - " U = U_theta(self.theta)\n", - " U_dagger = dagger(U)\n", - " \n", - " \n", - " V = U_theta(self.phi)\n", - " V_dagger = dagger(V)\n", - " \n", - " # Initialize the loss function and singular value memory\n", - " loss = 0\n", - " singular_values = np.zeros(T)\n", - " \n", - " # Define loss function\n", - " for i in range(T):\n", - " loss -= paddle.real(self.weight)[i] * paddle.real(matmul(U_dagger,matmul(self.M, V)))[i][i]\n", - " singular_values[i] = paddle.real(matmul(U_dagger, matmul(self.M, V)))[i][i].numpy()\n", - " \n", - " # Function returns two matrices U and V_dagger, learned singular values and loss function\n", - " return U, V_dagger, loss, singular_values" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-09T03:53:07.440520Z", - "start_time": "2021-03-09T03:47:21.094099Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 0 loss: 1537.4504\n", - "iter: 10 loss: -90754.6659\n", - "iter: 20 loss: -118936.4569\n", - "iter: 30 loss: -135978.2444\n", - "iter: 40 loss: -142946.4453\n", - "iter: 50 loss: -147064.3601\n", - "iter: 60 loss: -149600.0237\n", - "iter: 70 loss: -151044.1873\n", - "iter: 80 loss: -152079.2783\n", - "iter: 90 loss: -152850.4454\n", - "iter: 100 loss: -153473.4505\n", - "iter: 110 loss: -154018.4474\n", - "iter: 120 loss: -154517.7508\n", - "iter: 130 loss: -154952.2068\n", - "iter: 140 loss: -155299.7216\n", - "iter: 150 loss: -155558.2483\n", - "iter: 160 loss: -155750.0483\n", - "iter: 170 loss: -155900.1620\n", - "iter: 180 loss: -156023.2654\n", - "iter: 190 loss: -156125.9570\n" - ] - }, - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Record the optimization process\n", - "loss_list, singular_value_list = [], []\n", - "U_learned, V_dagger_learned = [], []\n", - " \n", - "net = NET([theta_size])\n", - "\n", - "# We use Adam optimizer for better performance\n", - "# One can change it to SGD or RMSprop.\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", - "\n", - "# Optimization loop\n", - "for itr in range(ITR):\n", - "\n", - " # Forward propagation to calculate loss function\n", - " U, V_dagger, loss, singular_values = net()\n", - "\n", - " # Back propagation minimizes the loss function\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - "\n", - " # Record optimization intermediate results\n", - " loss_list.append(loss[0][0].numpy())\n", - " singular_value_list.append(singular_values)\n", - " \n", - " if itr% 10 == 0:\n", - " print('iter:', itr,'loss:','%.4f'% loss.numpy()[0])\n", - "\n", - "# Record the last two unitary matrices learned\n", - "U_learned = U.numpy()\n", - "V_dagger_learned = V_dagger.numpy()\n", - "\n", - "singular_value = singular_value_list[-1]\n", - "mat = np.matrix(U_learned.real[:, :T]) * np.diag(singular_value[:T])* np.matrix(V_dagger_learned.real[:T, :])\n", - "\n", - "reconstimg = mat\n", - "plt.imshow(reconstimg, cmap='gray')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "_______\n", - "\n", - "## References\n", - "\n", - "[1] Wang, X., Song, Z., & Wang, Y. Variational Quantum Singular Value Decomposition. [Quantum, 5, 483 (2021).](https://quantum-journal.org/papers/q-2021-06-29-483/)" - ] - } - ], - "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" - }, - "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": true - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/tutorial/machine_learning/figures/QGAN-fig-loss.gif b/tutorial/machine_learning/figures/QGAN-fig-loss.gif deleted file mode 100644 index ad68188..0000000 Binary files a/tutorial/machine_learning/figures/QGAN-fig-loss.gif and /dev/null differ diff --git a/tutorial/machine_learning/figures/loss.gif b/tutorial/machine_learning/figures/loss.gif deleted file mode 100644 index 9da8df1..0000000 Binary files a/tutorial/machine_learning/figures/loss.gif and /dev/null differ diff --git a/tutorial/qnn_research/BarrenPlateaus_CN.ipynb b/tutorial/qnn_research/BarrenPlateaus_CN.ipynb deleted file mode 100644 index 6159f81..0000000 --- a/tutorial/qnn_research/BarrenPlateaus_CN.ipynb +++ /dev/null @@ -1,1270 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# 量子神经网络的贫瘠高原效应\n", - "\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## 概览\n", - "\n", - "在经典神经网络的训练中，基于梯度的优化方法不仅仅会遇到局部最小值的问题，同时还要面对鞍点等附近梯度近似于零的几何结构。相对应的，在量子神经网络中也存在着一种**贫瘠高原效应**（barren plateaus）。这个奇特的现象首先是由 McClean et al. 在 2018 年发现 [[1]](https://arxiv.org/abs/1803.11173)。简单来说，就是当你选取的随机电路结构满足一定复杂程度时优化曲面（optimization landscape）会变得很平坦，从而导致基于梯度下降的优化方法很难找到全局最小值。对于大多数的变分量子算法（VQE等），这个现象意味着当量子比特数量越来越多时，选取随机结构的电路有可能效果并不好。这会让你设计的损失函数所对应的优化曲面变成一个巨大的高原，让从而导致量子神经网络的训练愈加困难。你随机找到的初始值很难逃离这个高原，梯度下降收敛速度会很缓慢。\n", - "\n", - "![BP-fig-barren](./figures/BP-fig-barren-cn.png)\n", - "\n", - "图片由 [Gradient Descent Viz](https://github.com/lilipads/gradient_descent_viz) 生成\n", - "\n", - "\n", - "基于梯度变化对这类变分量子算法训练的影响，我们在量桨（Paddle Quantum）平台提供了梯度分析工具模块，辅助用户对 QML 模型进行诊断，便于贫瘠高原等问题的研究。\n", - "\n", - "本教程主要讨论如何在量桨（Paddle Quantum）平台上展示贫瘠高原现象，以及如何使用梯度分析工具对用户自定义量子神经网络中的参数梯度进行分析。其中并不涉及任何算法创新，但能提升读者对于量子神经网络训练中梯度问题的认识。\n", - "\n", - "首先我们先引入必要的 library 和 package：\n" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 55, - "source": [ - "# 需要用的包\n", - "import time\n", - "import numpy as np\n", - "import random\n", - "import paddle\n", - "from paddle import matmul\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import dagger\n", - "from paddle_quantum.state import density_op\n", - "# 画图工具\n", - "from matplotlib import pyplot as plt \n", - "# 忽略 waring 输出\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\")" - ], - "outputs": [], - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T12:20:39.463025Z", - "start_time": "2021-03-02T12:20:36.336398Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "## 随机的网络结构\n", - "\n", - "这里我们按照原作者 McClean (2018) [[1]](https://arxiv.org/abs/1803.11173) 论文中提及的类似方法搭建如下随机电路：\n", - "\n", - "![BP-fig-Barren_circuit](./figures/BP-fig-Barren_circuit.png)\n", - "\n", - "首先作用在所有量子比特上绕布洛赫球的 Y-轴旋转 $\\pi/4$。\n", - "\n", - "其余的结构加起来构成一个模块（Block）, 每个模块共分为两层：\n", - "\n", - "- 第一层搭建随机的旋转门, 其中 $R_{\\ell,n} \\in \\{R_x, R_y, R_z\\}$。下标 $\\ell$ 表示处于第 $\\ell$ 个重复的模块， 上图中 $\\ell =1$。第二个下标 $n$ 表示作用在第几个量子比特上。\n", - "- 第二层由 CZ 门组成，作用在每两个相邻的量子比特上。\n", - "\n", - "在量桨中, 我们可以这么搭建。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 56, - "source": [ - "def rand_circuit(theta, target, num_qubits):\n", - " # 我们需要将 Numpy array 转换成 Paddle 中的 Tensor\n", - " const = paddle.to_tensor(np.array([np.pi/4]))\n", - " \n", - " # 初始化量子电路\n", - " cir = UAnsatz(num_qubits)\n", - " \n", - " # ============== 第一层 ==============\n", - " # 固定角度的 Ry 旋转门\n", - " for i in range(num_qubits):\n", - " cir.ry(const, i)\n", - "\n", - " # ============== 第二层 ==============\n", - " # target是一个随机的数组,用来帮助我们抽取随机的单比特门 \n", - " for i in range(num_qubits):\n", - " if target[i] == 0:\n", - " cir.rz(theta[i], i)\n", - " elif target[i] == 1:\n", - " cir.ry(theta[i], i)\n", - " else:\n", - " cir.rx(theta[i], i)\n", - " \n", - " # ============== 第三层 ==============\n", - " # 搭建两两相邻的 CZ 门\n", - " for i in range(num_qubits - 1):\n", - " cir.cz([i, i + 1])\n", - " \n", - " return cir" - ], - "outputs": [], - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T12:20:39.972053Z", - "start_time": "2021-03-02T12:20:39.962259Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "## 损失函数与优化曲面 \n", - "\n", - "当我们确定了电路的结构之后，我们还需要定义一个损失函数（loss function）来确定优化曲面。按照原作者 McClean (2018) [[1]](https://arxiv.org/abs/1803.11173) 论文中提及的，我们采用 VQE算法中常用的损失函数：\n", - "\n", - "$$\n", - "\\mathcal{L}(\\boldsymbol{\\theta})= \\langle0| U^{\\dagger}(\\boldsymbol{\\theta})H U(\\boldsymbol{\\theta}) |0\\rangle,\n", - "\\tag{1}\n", - "$$\n", - "\n", - "其中的酉矩阵 $U(\\boldsymbol{\\theta})$ 就是我们上一部分搭建的带有随机结构的量子神经网络。对于其中的哈密顿量 $H$ 我们不妨先取最简单的形式 $H = |00\\cdots 0\\rangle\\langle00\\cdots 0|$。设定好这些后，我们就可以从最简单的两个量子比特的情形开始采样了 -- 生成300组随机网络结构和不同的随机初始参数 $\\{\\theta_{\\ell,n}^{(i)}\\}_{i=1}^{300}$。每次计算梯度都是按照 VQE 的解析梯度公式计算关于 **第一个参数 $\\theta_{1,1}$** 的偏导数。然后统计得到的这300个梯度的平均值和方差。其中解析梯度的公式为：\n", - "\n", - "$$\n", - "\\partial \\theta_{j} \n", - "\\equiv \\frac{\\partial \\mathcal{L}}{\\partial \\theta_j}\n", - "= \\frac{1}{2} \\big[\\mathcal{L}(\\theta_j + \\frac{\\pi}{2}) - \\mathcal{L}(\\theta_j - \\frac{\\pi}{2})\\big].\n", - "\\tag{2}\n", - "$$\n", - "\n", - "具体推导请参见：[arXiv:1803.00745](https://arxiv.org/abs/1803.00745)" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 26, - "source": [ - "# 超参数设置\n", - "np.random.seed(42) # 固定 Numpy 的随机种子\n", - "N = 2 # 设置量子比特数量 \n", - "samples = 300 # 设定采样随机网络结构的数量\n", - "THETA_SIZE = N # 设置参数 theta 的大小\n", - "ITR = 1 # 设置迭代次数\n", - "LR = 0.2 # 设定学习速率\n", - "SEED = 1 # 固定优化器中随机初始化的种子\n", - "\n", - "# 初始化梯度数值的寄存器\n", - "grad_info = []\n", - "\n", - "paddle.seed(SEED)\n", - "\n", - "class manual_gradient(paddle.nn.Layer):\n", - " \n", - " # 初始化一个可学习参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " def __init__(self, shape, param_attr=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),dtype='float64'):\n", - " super(manual_gradient, self).__init__()\n", - " \n", - " # 将 Numpy array 转换成 Paddle 中的 Tensor\n", - " self.H = paddle.to_tensor(density_op(N))\n", - " \n", - " # 定义损失函数和前向传播机制 \n", - " def forward(self):\n", - " \n", - " # 初始化三个 theta 参数列表\n", - " theta_np = np.random.uniform(low=0., high= 2 * np.pi, size=(THETA_SIZE))\n", - " theta_plus_np = np.copy(theta_np) \n", - " theta_minus_np = np.copy(theta_np) \n", - " \n", - " # 修改用以计算解析梯度\n", - " theta_plus_np[0] += np.pi/2\n", - " theta_minus_np[0] -= np.pi/2\n", - " \n", - " # 将 Numpy array 转换成 Paddle 中的 Tensor\n", - " theta = paddle.to_tensor(theta_np)\n", - " theta_plus = paddle.to_tensor(theta_plus_np)\n", - " theta_minus = paddle.to_tensor(theta_minus_np)\n", - " \n", - " # 生成随机目标，在 rand_circuit 中随机选取电路门\n", - " target = np.random.choice(3, N) \n", - " \n", - " U = rand_circuit(theta, target, N).U\n", - " U_dagger = dagger(U) \n", - " U_plus = rand_circuit(theta_plus, target, N).U\n", - " U_plus_dagger = dagger(U_plus) \n", - " U_minus = rand_circuit(theta_minus, target, N).U\n", - " U_minus_dagger = dagger(U_minus) \n", - "\n", - " # 计算解析梯度\n", - " grad = (paddle.real(matmul(matmul(U_plus_dagger, self.H), U_plus))[0][0] \n", - " - paddle.real(matmul(matmul(U_minus_dagger, self.H), U_minus))[0][0])/2 \n", - " \n", - " return grad\n", - "\n", - "# 定义主程序段\n", - "def main():\n", - " \n", - " # 设置QNN的维度\n", - " sampling = manual_gradient(shape=[THETA_SIZE])\n", - "\n", - " # 采样获得梯度信息\n", - " grad = sampling() \n", - " \n", - " return grad.numpy()\n", - "\n", - "\n", - "# 记录运行时间\n", - "time_start = time.time()\n", - "\n", - "# 开始采样\n", - "for i in range(samples):\n", - " if __name__ == '__main__':\n", - " grad = main()\n", - " grad_info.append(grad)\n", - "\n", - "time_span = time.time() - time_start \n", - "print('主程序段总共运行了', time_span, '秒')\n", - "print(\"采样\", samples, \"个随机网络关于第一个参数梯度的均值是：\", np.mean(grad_info))\n", - "print(\"采样\", samples, \"个随机网络关于第一个参数梯度的方差是：\", np.var(grad_info))" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "主程序段总共运行了 5.709956169128418 秒\n", - "采样 300 个随机网络关于第一个参数梯度的均值是： 0.005925709445960606\n", - "采样 300 个随机网络关于第一个参数梯度的方差是： 0.028249053148446363\n" - ] - } - ], - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T12:20:52.236108Z", - "start_time": "2021-03-02T12:20:40.850822Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "## 优化曲面的可视化\n", - "\n", - "接下来我们试着利用 Matplotlib来可视化这个优化曲面（optimization landscape）。在**两个量子比特**的情况下，我们只有两个参数 $\\theta_1$ 和 $\\theta_2$, 并且第二层的随机电路电路总共有9种情况。这个很容易画出来：\n", - "\n", - "![BP-fig-landscape2](./figures/BP-fig-landscape2.png)\n", - "\n", - "可以看到的是最后一张图中 $R_z$-$R_z$ 结构所展示出的平原结构是我们非常不想见到的。在这种情况下，我们不能收敛到理论最小值。如果你想自己试着画一些优化曲面，不妨参见以下代码：" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 4, - "source": [ - "# 引入必要的 package\n", - "from matplotlib import cm\n", - "from mpl_toolkits.mplot3d import Axes3D\n", - "from matplotlib.ticker import LinearLocator, FormatStrFormatter\n", - "\n", - "time_start = time.time()\n", - "N = 2\n", - "\n", - "# 设置图像比例 竖：横 = 0.3 \n", - "fig = plt.figure(figsize=plt.figaspect(0.3))\n", - "\n", - "# 生成 x, y 轴上的点\n", - "X = np.linspace(0, 2 * np.pi, 80)\n", - "Y = np.linspace(0, 2 * np.pi, 80)\n", - "\n", - "# 生成 2D 网格 (mesh)\n", - "xx, yy = np.meshgrid(X, Y)\n", - "\n", - "\n", - "# 定义必要的逻辑门\n", - "def rx(theta):\n", - " mat = np.array([[np.cos(theta/2), -1j * np.sin(theta/2)],\n", - " [-1j * np.sin(theta/2), np.cos(theta/2)]])\n", - " return mat\n", - "\n", - "def ry(theta):\n", - " mat = np.array([[np.cos(theta/2), -1 * np.sin(theta/2)],\n", - " [np.sin(theta/2), np.cos(theta/2)]])\n", - " return mat\n", - "\n", - "def rz(theta):\n", - " mat = np.array([[np.exp(-1j * theta/2), 0],\n", - " [0, np.exp(1j * theta/2)]])\n", - " return mat\n", - "\n", - "def CZ():\n", - " mat = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]])\n", - " return mat\n", - "\n", - "# ============= 第一张图 =============\n", - "# 我们可视化第二层是 kron(Ry, Ry) 的情况\n", - "ax = fig.add_subplot(1, 2, 1, projection='3d')\n", - "\n", - "# 向前传播计算损失函数：\n", - "def cost_yy(para):\n", - " L1 = np.kron(ry(np.pi/4), ry(np.pi/4))\n", - " L2 = np.kron(ry(para[0]), ry(para[1]))\n", - " U = np.matmul(np.matmul(L1, L2), CZ())\n", - " H = np.zeros((2 ** N, 2 ** N))\n", - " H[0, 0] = 1\n", - " val = (U.conj().T @ H@ U).real[0][0]\n", - " return val\n", - "\n", - "# 画出图像\n", - "Z = np.array([[cost_yy([x, y]) for x in X] for y in Y]).reshape(len(Y), len(X))\n", - "surf = ax.plot_surface(xx, yy, Z, cmap='plasma')\n", - "ax.set_xlabel(r\"$\\theta_1$\")\n", - "ax.set_ylabel(r\"$\\theta_2$\")\n", - "ax.set_title(\"Optimization Landscape for Ry-Ry Layer\")\n", - "\n", - "# ============= 第二张图 =============\n", - "# 我们可视化第二层是 kron(Rx, Rz) 的情况\n", - "ax = fig.add_subplot(1, 2, 2, projection='3d')\n", - "\n", - "\n", - "def cost_xz(para):\n", - " L1 = np.kron(ry(np.pi/4), ry(np.pi/4))\n", - " L2 = np.kron(rx(para[0]), rz(para[1]))\n", - " U = np.matmul(np.matmul(L1, L2), CZ())\n", - " H = np.zeros((2 ** N, 2 ** N))\n", - " H[0, 0] = 1\n", - " val = (U.conj().T @ H @ U).real[0][0]\n", - " return val\n", - "\n", - "Z = np.array([[cost_xz([x, y]) for x in X] for y in Y]).reshape(len(Y), len(X))\n", - "surf = ax.plot_surface(xx, yy, Z, cmap='viridis')\n", - "ax.set_xlabel(r\"$\\theta_1$\")\n", - "ax.set_ylabel(r\"$\\theta_2$\")\n", - "ax.set_title(\"Optimization Landscape for Rx-Rz Layer\")\n", - "\n", - "\n", - "plt.show()\n", - "\n", - "time_span = time.time() - time_start \n", - "print('主程序段总共运行了', time_span, '秒')" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAApoAAAEBCAYAAADYRQXiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9d5wl2V3YDX9PhRs73c5penIOuxNXCANCZNtYtnkdwOAX8AsGzCPgASwbHkA2+AWcwIAMBhuDLEBgjEGYKKGExK5mdndy6umc482h4jnPH3Xvndu93dNhZnZmV/X9fO6n+96qOnUqnfOrXxRKKUJCQkJCQkJCQkKeNNqz7kBISEhISEhISMjbk1DQDAkJCQkJCQkJeSqEgmZISEhISEhISMhTIRQ0Q0JCQkJCQkJCngqhoBkSEhISEhISEvJUCAXNkJCQkJCQkJCQp8IzETSFEENCiKIQQt/l9kUhxIHnqU/PA0IIJYQ49Kz7sR2EED8hhFgRQiw8676EhIS89QnnladDOK+EPC7bEjSFEN8shLgphCgLIRaEEL8ohGjb7k6EEBNCiC+vfVdKTSmlmpRS/i76THXbsd1s+7T6tMW+3jIP6puBEGII+H7ghFKq9wm1qYQQpeqgPiuE+I+7GdyFEPuqbRWrnwkhxL/YZZ/eL4T40G62DQl5uxPOK49HOK+s5XmeV6ptvUsIIattFYQQ94UQ37LLttbcZ887WwqaQojvB34a+EGgFXgHsBf4qBAi8nS7F/I2ZQhYVUot7XRDIYTxiMUvKKWagC8B/gHwrbvsH0Bbta3/D/AjQoiveIy2nglbnKuQkGdGOK+EPAXeCvPKXLWtFuD7gF8RQhx9jPaeCTueW5RSm34ITkYR+Pvrfm8CloFvrX5/P/C7wG8DBeB1gosD8D8ACVSqbf1zYB+gAKO6zieBnwD+qrrOHwIdwG8AeeAKsK9h/wo4BPRX1699ysEhKYCDwMeBVWCl2lbbDvrUD3wESAMjwLc17P/9wO8AH6we723gwiPOowIObfD7pn2sLp8AfgC4AeSq5zfWsPwHgXlgjuDmr+8H+OvAnWr/ZoEfaNjuPcC16rkdBb66+vu3AHer24wB/7Rhm3cBM8APVfs6AfyjhuVR4N8DU8Ai8EtAfINj/vLqeZfVc/9r1d//VvU8Zqv3w/F15+F91fNg167Ro85x9fp8AIhUr+HphmXd1Xula4N21twH1d8uV891b3W7joZl5wieBXODtt4PfGiTe+JfVM99oXqd/k719y37C/zN6vXLEjwzZ3ZyrsJP+HmWH8J5JZxXHm7zLt6C80r1//Zq37+24f4dAf7xJtfrXcDMut+WgL9X/f+fs/a+c2vHsUFbE8CXb/B7Cvg/BM9Rpvr/YHXZ3wNeW7f+/w38wVbnuuE6vQ9YAP7Hjp75LQaErwa8TS7ArwO/1fCAuATaH5PgJh6nOvmuPylsPCCMEDwgrQQ38nD15jEIHrz/vo0H7Dca+nQI+IrqyesCPg387GYXaoM+fRr4z0AMeLF64d7dcLwWwUOnAz8JvLKLAWE7fbxMMDi1Ezys39FwbRaBU0AS+E3WDgjzwBc13Hznqv9fIhhcvoJAoz0AHKsu+xvVayAI3t7KDdu9q3ov/Mdqf78EKAFHq8t/hmAAbQeaCQb1n9zOAwccqbb1FQT3zz+v3g+RhvNwDdjDBoPM+nMMHKse//dVv/9n4Kcb1v0e4A83aWf9ffCO6nmoCYJ/DHxnw/o/A/z8Jm29n80Fzb9Xva4awVtyCejbqr/AWYLB6SWCe+//Wz0/0e2eq/ATfp7lh3BeCeeVt8G8Uv3tKwkEr27gV4DffcT1qveveo7+FoFgfHaDdfcQCPpfs0lbE2wsaHYAXwckqufrfwK/X10WJXjBaRS2rwJft9W5brhOP11tZ0dzy1YDwjcCC5ss+yngow0PyCsNy7R1N+Sak8LGA8IPNyz/D8CfNHz/WuDaox4wAkn7tUfcMH8buLqdAaF6kX2guWH5T/LwLen9wMcalp0AKjsdELbZx29s+P5vgV+q/v+rwE+te6gaH4op4J8CLev28V+An9nWzQG/D3zPuhst2bD8d4AfIRhASsDBhmVfAIxv9cBVv/8I8Dvr7p9Z4F0N5+Fbt+irIniTLlX//y0eCl8vVc+HqH5/lXXalA3ugyzBG7IieMurbfsPgM9W/9cJBplLm7T1fjYRNDdY9xrwnq36C/wi8OPrtr0PfMl2z1X4CT/P8kM4r4TzyttgXmlY5+eBm9W2Ox7R1rsIBMssgQbVB753g/Xi1XvufY9oa8199oj1XgQyDd9/Efg31f9PEmg9o1ud62rfHRo03zv5bOWjuQJ0bmKP76surzFd+0cpJQnUrP1btN/IYsP/lQ2+N222oRDiawi0Pn9bKVWp/tYjhPhw1YE3D3wI6NxmX/qBtFKq0PDbJMFbWo3GqLYyENup38I2+7h+P7Xz0E/DOa/2r5GvI3gznhRCfEoI8QXV3/cQmDU26s/XCCFeEUKkhRDZ6vaN/ckopUrr9tlP8NacAF4TQmSr2/5p9fft0N/Y/+r9M83a8z29fqMNOEdwfv4BgbCWrLb3OYJz9y4hxDGCN/6PVI+52PAZamirs9rW9xM8ZGb19z8ATggh9hO8KeeUUpe3eZx1hBD/WAhxreF8naru85H9JfBj+/7adtVt97D2WdvOuQoJeVaE88pDwnnlLTqvNPDLBOP3rymlVmFNtoGiEKLYsO6cUqqNwH3k54B3b7C//wbcV0r99Db6tgYhREII8V+EEJPVa/9poK0hgOnXgW8QQgjgmwgEcZvtnetlpZS10z7B1sFALxNI3n933cE0AV8D/EXDz3salmvAIIHqF4I3gadC1ZH21wk0Po03zf+/ut/TSqkWgrdo0bD8UX2aA9qFEM0Nvw0RvLE8Sbbq46OYp+GcE/SvjlLqilLqPQQq/d8neEuE4ME6uL4xIUQU+F8E2rue6sPwx+v6kxJCND5kQwTnaoVg0D6plGqrflpV4PS8HeYIBKhaX0T12BrP97buIRXwOwT37o82LPp1gvP7TQTmDau6flPDZ2pdW75S6j8SmLO+q/qbRXAua239j20eYx0hxF4CM8t3E7wBtwG3WHuuN+wvwfX7Nw3nuU0plVBK/VZj13fap5CQN5FwXnlIOK+8heeVqgD3ywRuGN9VywKgHmYbaNqov1Xh7n3AaSHE325o718QaJH/yTaPcT3fDxwFXqpe+y+uNV3d7ysEmskvAr6Bh/PXds71rp+3RwqaSqkc8K+AnxdCfLUQwhRC7CO4uWZYO8meF0L83erb1/cSDCSvVJctAk80PxmAEKKFQMP0w0qpz6xb3EzgUJsTQgwQODg3smmfqgPLXwE/KYSICSHOEFz4x0lVE6m2Vfvo2+jjo/gd4JuFECeEEAngx2oLhBARIcQ/EkK0KqVcAtW/rC7+b8C3CCG+TAihCSEGqlqzCIEKfRnwqm/zX7nBfv9Vtf0vIghK+Z/VN8VfAX5GCNFd7cOAEOKrdnAsf6PaJ5PgYbEJrsFu+Sng24QQtTQXHwL+DsGg+8FdtPXPhRCx6vcPAt9M4GOzlaCprbvuUYI3YkVwrhFBiotT67bbrL+/AnyHEOIlEZAUQvyNdZNXSMhzSzivhPPKBvt9q84rP0Qwln8r8O+AD4ptpj9SSjkE7hw/CnUN+nsJ4gEq22jCXHftDYJrXwGyQoh2Gq5fAx8EfgFwa/f3EzjXj2TL9EZKqX9LcDL/PcGN9TmCt5cvq0rlNf6AQLWcIdDC/N3qzQiBH8r/U1XJ/sCT6HiVcwTS+8+IN6qp/1V1eQ74I+D31m27VZ++nsC/Zg7438CPKaU+9hh9vU1wA9Q+37KNPm6KUupPgJ8liC4cqf5t5JuACRGoz78D+EfV7S5X9/0z1f1+CthbNee8l+DhzBC87XxkXZsL1WVzBA7y36GUuldd9r5qP16p7vNjBNdmO8dyn0Cg+nmCN6uvJYjkc7az/SZt3iQwG/xg9fs0QdSqAv5yh839EcFxf1u1rc8SDLCvK6XWm5bW8/Wsve6jSqk7BAPMywQT02ngs+v6v2F/lVKvVvvxC9U+jRAIvSEhbxnCeSWcVxp4S84rQojzBFHb/1gFeVJ/mmC83kne5V8FhoQQX0twn3cBdxvuu196xLZ/zNpr/36CaxcnON5XCMzf6/kfBIqN9S84uz7XW1ELNni8RoR4P4Gz8Dc+dmMhzyVCiHcRBLYMPuOu7BohxK8S+Mj8P0+grY8Dv6mU+q+P37NN9/HE+hsS8lYjnFfe/rwd5pW3GkKIOEHmknNKqQdvxj7DhM4hnxdUTXN/lyA90OO2dZFAY/Cex23rEfvYxxPqb0hISEhISJXvBK68WUImPKNa5yEhbyZCiB8nCLb5d0qp8cds69cJTArfuy569InxJPsbEhISEhICQelKgkwK3/+m7vdJmM5DQkJCQkJCQkJC1hNqNENCQkJCQkJCQp4KoaAZEhISEhISEhLyVHjSwUChHT4k5Omy3cTLISFvF8J5JSTk6fJU55VQoxkSEhISEhISEvJUCAXNkJCQkJCQkJCQp0IoaIaEhISEhISEhDwVQkEzJCQkJCQkJCTkqRAKmiEhISEhISEhIU+FUNAMCQkJCQkJCQl5KoSCZkhISEhISEhIyFMhFDRDQkJCQkJCQkKeCqGgGRISEhISEhIS8lQIBc2QkJCQkJCQkJCnQihohoSEhISEhISEPBVCQTMkJCQkJCQkJOSpEAqaISEhISEhISEhT4VQ0AwJCQkJCQkJCXkqhIJmSEhISEhISEjIU8F41h0IeTRKKXzfp1KpYJomhmGg6zpCiGfdtZCQkJCQtyBKKVzXxbbtcF4JeeqEguZzjFIKx3Hwfb/+qaHrejhAhISEhITsCCklruvieV79U5s/DMPANE10XQ/nlZAnhlBKPcn2nmhjn89IKXEcB6UUQggcx6k/9EoplFJIKRFCMDc3x549e0LB8/OD8MKGfL4RzitPgJp1zHXd+m+O46BpWn157eP7PsvLywwODtbnFU3Twnnl7ctTvbChRvM5Qym15i1T0zTWvwwIIerLAObn5xkYGKBSqdQHglDjGRISEhICD03lvu/X5w8p5Zp1ar9DoOhYWlqir68Pz/Pqyw3DqH9CwTNku4SC5nNEzVRe01Ru9yGuCZ2Nb6ZSyjWCZ+MAEQqeISEhIZ8frLeObWfsF0KglKrPKfBQCVLTiIaCZ8h2CQXN5wTLsnAcB9M0dyRkbsR6jWfNFFJ7M4WHvjjhABESEhLy9kMpRaVSwfd9TNNcIzTuhvXzUk1Lul7wrPl4hvNKSI1Q0HzG1N4S5+fnqVQqHDx48InvY6MBolHwXF5epq+vLxQ8Q0JCQt4G1KxjIyMjpFIpuru71yyXUjIyMsLq6iqpVIpUKkVLSwu6rgMPNZqPQghRX7+2z0bBc2lpicHBwboVLZxXPn8JBc1nSC36T0r52G+bO2G94Dk9PU1XV1foixMSEhLyFqfRVL7RvFKpVLhx4wYdHR2cPHmSfD5PPnOdlflpivYJ2traaW1t3VLQXM96wXN6epru7m5s267POTVlhmEYj225C3nrEAqaz4D10X81Qe4JZwDYEY3CZOiLExISEvLWYqNA0vXzyuLiIiMjI5w4cYLW1lZc16U/dQWj6TdRIgby/7BQ/nYWFvspFotcu3atrvFsbm7e0bi/kcbTcZw3CJ41U3soeL59CQXNN5mNov9ge6aKN4vQFyckJCTkrUOjdWyjeUVKyb1797Asi4sXLxKJRJB+kYj979HVOJqaQskKrv4SnfGfJXXgaymVznHs2DEymQwzMzMUi0VisVhd8Ewmk7sWPGtzneM4OI4DBMqO9fNKyNuDUNB8E3lU9N/zJGiuZytfHMuyiEajJJPJ0CQSEhIS8iax3jq20bxiWRaXL1+mr6+P48ePB8v9YYzyLyH819FYxWMIV+tH8/8SSKJ5H2Wo6wGx2AX6+vro6+urBxdls1kmJycpFoskEom64JlIJHaUKQV4pOBZKpVobm4mHo+HgudbnFDQfBPYyKSxno3yZT6vrBc8l5eXicVi9e+apoUmkZCQkJCnyPp5ZaMxtlAokM1mefHFF2ltbQVA2H+AXvkVhJpEEcHRvhDp30JTo0jtApp8FSWnwNSxrV8mGvv2YDshSCQSJBIJ+vv7UUpRLpfJZDKMjY1RLpdpamqqC547mc82EjynpqbYu3dvPd9nqPF86xIKmk+Z7ebG3CiB7luJ2iDQ+GZa88UJB4iQkJCQJ8dmpvIanudx9+5dSqUS+/fvD4RMVUQr/yy689soBL52Fs/XUP6nQTuMkjaafBVPvIMyS0TiwzjuErp+EMP8sjf0QQhBMpkkmUwyODiIUopisUg2m+XBgweUy2Xu3LlTFzwblRFb0Sh46rper1i03tTeWJQknFeeX0JB8yni+z7pdJqpqSlOnjz5SK3e82w634qaKwBszyQSCp4hISEhO6dmKp+amsLzPPbu3fuGdQqFAjdv3mRoaIiWlpZgfPXuYJR+ACGnkfpxpFT45FGsgNiHkPdRYj+23EtF3USIA+h6CUEHlcr7Seqn0LSeR/ZNCEFzczPNzc3s2bOHy5cvMzg4SCaT4d69eziOQ0tLS13wjEQiWx5r47yyPm5AKYVt29i2DTyshqfret2FK+T5IBQ0nwLrTRq1t85H8biCZuND+Sy234ztCp5SSpLJZCh4hoSEhGxAo3UMeIMFTCnF9PQ0s7OznDlzhqamJqampmjWfw+j8GugDSG140il8NUCiCEE91CqjOQwFZJ4Io+SeZS6imUNEYtNoWkXKVofoCXxr3fUXyEELS0ttLS01E3g+XyeTCbD3NwcnufR2tpKKpWira0N0zR31PZ6wVNKiWVZ9d9qQao1H89Q8Hx2hILmE2a9SaMmRG3Fs9RovpkP4EaCp1KK1157jfPnzwOhSSQkJCSkkfWBpLqur5lXXNfl1q1bRCIRLl26FIyvMkdv/McxxSxKPwneDTzjRRQ+qAz4y0jtAkqOUkbHl/MoNYWmX0D6r6IbeWCAonSw/Ntg/29aon9n18egaRptbW20tbUBgcUvl8uRzWaZmppCKbVG8NwJGwmelmVx//59Tp8+DTzUeIZlmN98QkHzCbFZ9N92BcjHETRr2z6rB+dx9t14nhp9cRpNIo2CZ2gSCQkJ+Xxhs0DSxvkim81y+/ZtDh48SG9vb7Dcu4pW/hk04WJqcyi/jGucBW8YSIN+AvxRPJnHEvvx/ZcRog9oQfqvomkv4Hmr2MY+iv4rGFo/K+WfI2l+KbrW9kSOTdd12tvbaW9vBwK/0lwuRyaTYWJignK5zNTUFF1dXbS2tq4JQN2KxjLMtXllvcYzFDzfPEJB8wmwWW5M2H40+ZMwnb8dCH1xQkJCQh4dSFpzyRofH2dpaYmzZ8+SSCRAKTTrvyO8zyD8e8T1CgXnDJGYDd4rILqAAZR3F9v4a1TcTwIKTTuJlLfRtBeQ8gYuSTJiGs1/hah2AlveIW5cZNX6AN2JH34qx2sYBh0dHXR0dABw7do1mpubWV1dZXR0FF3XaWtrI5VK0drauqWlaysfTykllUpljZUtFDyfDqGg+Zg8KjcmbD+a/HE1ms+Sp6lN3Y4vTjhAhISEvJ1YX5lt/Zjm+z7z8/P09vZy8eLFQOiSq2iVD6A5f4KgiKSbgnuKiPEy+BHQXwD/OlLbT1l7Adf9GJp2ASlfRcpZoB0px7DEl5J1P410D6EZeXyVAQws7xaOP0NL5BuJGW8MQnrSCCHo6Oigv78fCPz6s9ksS0tLjIyMYBjGmqpF6wXPR81LjRrP2rqh4Pn0CAXNXdJoKt8sNyZsX4B81Hr5fJ6RkRGamppob29/w0P1Vo5Y3ymbCZ7ZbJaZmRkOHToUDhAhISFvSbaTG3N1dZXh4WFaWlo4evRo8KN7BaP0owg1g6IZT3sJXy0SNf6KinuKuHkL/Nu4xhdScq8hRBlIIuWraPpZpH8V9C8g7U3hyatopDDiI3VtZky/gCOHscUL3C/9N15o3Vlg0G5pPP5IJEJ3dzfd3d0A2LZdDywqFApEo9G64NnU1LQjBchmgufc3ByWZdHf37+mDHM4r+yMUNDcBUop0uk0hUKB3t7eR95wjxMM1BhFeOjQISqVypqHqr29fceJcZ8Gz9I/tHEw9jyvfr7DN9OQkJC3ElJK5ufn6ybi9eOUlJLR0VGy2SzHjh1jdXUVlI9W+WU0+5eAGFK/gC9tpLwB2l6kihM3b6H0i1j4WM7L6PoefH8YOAXcwvfu44t3suq8TlQ/jZRXiekvYvkZJEVAw1cVlv39FP3XiGo95N1hWswjT/V8bDWvRaNRent7636ptapF09PTFAoFIpEInudRLBZ3VS6zNif7vo+mafi+j+d59XVqKfoMwwjLMG9BKGjukJoWs1KpkMvl6Ovre+T6u9Voep7H7du30XWdixcvIqWktbV1zUOVTqeZmJigUChw9+5dOjo6SKVSxOPxxzvIN5knISg3ui6EJpGQkJC3Co3WsZqAlEql1qxTqVS4efMmHR0dXLhwgVwuhyFW0Yv/BOHdRxnnwBvBw0eRBpLg30SyH8cv4oo0iCaggpQrSNWGJm7h+WcpejYlfwk96mG5D0C0YPnX8OwBiE6ha1/JiH2dNvMUyp8hqnUwWvpVzrb91FM/LzshHo8Tj8fr5TJXVlaYmppiYmKCUqlEMpmsazzj8fi2xn0pZV2IXG9JaxQ8hRBrNJ6h4LmWUNDcJutNGoZhbEtTuRuNZi3h7r59++qlvta3EY/HGRgYYGBggNdff509e/aQz+cZHh7Gtm2am5vrGs+tEuM+Ls9DDs/agLCe7QieoUkkJCTkWbA+kHSj4NGlpSUePHjAiRMn6gJohFc42PEfQfUDBvjTuFpfkLZIToBoB7EHV2oUvFZMcQ+QaNoZpLyB5x0iEklR1Aq4ZhndWCKqvYjNNXBPgHkH6WvknBcpiFFAI+fexRQpct4d4loPBW+UZuPgUz0/j5PNJBqNkkwmOXbsGEopSqUSmUyG0dHRN5TL3Ew5s9W8UqMmHzT61YaC50NCQXMbbFTuayfR5NuhJpBOT08zMzNTT7hb41HCmKZpJBIJ2traGBoaQkpJoVAgnU4zOzuL7/v1aL22tjYM4/m67E9C0NxuGxsJnjVtgu/7rKysMDg4GJpEQkJCniobBZI2KiaklNy/f59KpcLFixcDhYFy0Sq/QEJdRYkymv8ann4WXynwrwAm6GdQ3k0s4zAV/x6muYRhXMLzLuO6o2haikisnbyvY8krRPVT+P4SnppCkECZ94no55kjg04Mj2n0ygH8+BhRfz+uliGidTJR+g1Ot/7osz2Jj2B91HlTUxNNTU3s2bOnXi4zk8msUc7UBM9oNPqGNh7FowTPcrmMbdt0d3d/3gqez5fE8ZyxWW7M2v9Psja553kUCgVisdjDhLu7RNM0WltbaW1tZf/+/fi+TzabrecnE0LUH6jW1tbH7vvzrNHcisYB3nVd0uk0fX19a0wijab2z7cBIiQk5MmyWW5MoD4OlUolbt68SW9vL8eOHQvGHH8GzfoAmvMyOqu4IoljfAnK/ViwsXERvCtIf56K/hKO+ykEQ0gVxfMuU6kcIh6fxdXPsep8Ck00odGB7d8iqp/C9m8R0y/goVjyEzjmBHG9CXyBllhBqiiWGEfIJLnKLGOuTqx4i8H2g0/FXetpzitCPCyX2aicyWQy3LlzB9d1aW1txfd9mpubd7zvRlnBsiyKxSKpVOoNGs/GMsxv53klFDQ3Yavov+2axLdDoVDgxo0bGIYRVDHwbcTk76MtfgaVPIg/9Lch0rXp9lv5geq6viY/meu6ZDKZukmmUqkwNTVVj2h/s2/4N1Oj+ShqwmrjwB/64oSEhDwpHpUbE4J5JZvNMjc3x8mTJ+uKAOF8Ar38kwg1jyKKzUtY3jgx7WOgvwj+LfCu4BpfTMl9DeW9iqbtRcpJrMphEokHJJIGeXWEkvMp4uY5Ku7rRPWD2P4qvkojSFKSURbdJRw1gWb3UonO0mqcIufdos18gax7nZbIJW6VZmiJtvLA/STlYR/btndUx/zNYCdzQqNyZt++fUgpyeVyTE5OMjs7y8LCwq7LZdbmlUblUc1lwnGc+n2wvijJ22leCQXNDdjIVL6eJyVozszMMDU1xalTp7h37x64BfRXvwfhFRGFGaTnoF+5jHbw25G9F5/IzWea5po0EZcvXyYSiTAzM0OhUCCRSNQHjEQiseU+38oaza3aCH1xQkJCngQ169hmOZc9z2N6ehrXdXnppZcCFyfloJX/I7rzGygiSOM8vu+h5Oso1Qm0gn8NpZ3BIoLl/AWGcRbPew0pW5EyQiLxAIwvY8H+HDEjSIfkeGMIWrD960S0w/iqQIUvZMF5jTbzDI6bBgLByFEZACr+LKZ4iZvleVwlSfvTFPRlvuz0t2ISq9cxr7lrWZbFysrKrt21nuW8omkaqVSKXC5HIpGgo6OjXrWoVi6zMXn8o45vs3llveDpOM4bquHVNJ5vdcEzFDQbqF3sWjqDRwku2/XR3AzP87hz5w4Aly5dCgRX30e/9n6EW0BUppGtxxGlEbB9IsMfwo6moP3wG9p63DyamqbR29tbDzyqRbSPjY1RLpfX+K7EYrFd72cznjeN5qPYSPB0XXeN4Ol5Hs3NzZ8XJpGQkJBHU6tsVhujNhpjagGgqVSqXvEMfwKj9IPgTyONC+CN4ikPxRLQRjw6VU1h1EpJlUEASDzvJlIOoWlTKF4kZ3s48gaCCBXvOjHjDJZ3g4R5kbJ7BSV6mXIsYASNGDn3NlGtBzs6S1I/QMkfo804y4Kn4ag4lizRHz3GnH2PLnMfd0uf4MXmv1GvY15z17p8+TLZbHZDd63HVQps97w/qXllo3KZ2WyWdDrN+Pg4Qog1gmejELndeaW2TW0udxwHx3Hqyz3Po6WlpT6vvJUIBc0qNSHz5s2bDA0Nbem7+Dg+msVikRs3bjA0NMTAwEBdUOy1X0bLvoxMnUZUpkFIhFtAtZ8Fq4x5+4O47/hhMJ+8sFdDCEEikSCRSDA4OFh3mk6n09y7dw/HceomhFQqhWmab2uN5lZs9GZ67do1zp8/X1/emEopFDxDQj5/qFnHXn75Zd7xjne84dlvzJV85swZLMtidXUVYf8fdOsDKNGLQIA/j6t1g8yCnALaqDg9GLE4lgDPuwfY6MZFfO8KUtpo+gEK5KioCEJliJvnqbiv4ctlwKTi3gDxpTywbtBqHCfn3SVlvkjGvUZc78GWi+giQlw/wKyXZMYepdUI0usVvJXgr7/MzcJHeaHpr685tpqwfOjQIeCN7lq1FE7t7e00NTVtOCY+z/OKYRh0dnbS2dkJBMeXzWZZWVmpl8uszZG+7+/I1N6Yhq92HL7vc+PGDc6ePQsEyqH1Pp7PM6Ggydrov+2axHdrOp+dnWVycpLTp0+vcTIWXokOK9BwiuxdVLQdrXAfldiDsBfQCksow0e783vIF75hTZuPq9F8FI1O03v37q37rmQyGaanp+sPQTKZJJlM7iqI6a0saK6npvFsHCQ2Mom8XX1xQkJC3hhIquv6G8Zo13W5ffs2pmnWA0AdJ09v8pfR7DTILBozuPolpCqCfx2IgH4K5d0m5xwhZi6j1ByGcQ7Pex3XuQYMYka7yasElnoFtHYE8apP5iFsf4S48ddY8crYMvA9d1QeEBS80apW8y54zbh6kiknSdobpcPYw6o3TZe5n2V3nG7zAEvuGN3mAaasm+yNn9n0fKx317Isq26GLhaLdXet9vb2bee43M41eLMsZaZp0tXVRVdXEEvhOA6ZTIaFhQVWVlaIRCLYtl0XrHcyz9Tmd13X19xHjRrP513w/LwWNDeK/tN1/akImr7vc/fuXXzf59KlS2/w6dBGPkyrPYFKNCO8AjK5D5FNo+IdaKs3kG3HECqCkbmBk/tSaH10ovinRc13pZbPzfM8bt68ST6fZ2FhYc2bXEtLy7Zu+LeS6XynPMoXp9EJ/Nq1a7zzne98ovsOCQl581mfG7M2t/i+Xx8Lstkst2/f5uDBg/UiHPgPaBU/jxn/LJrvIOnB0V8E7xOABsYF8F5FyiXK2iWiiU8jxF6USuJ5r1MuHyWRGMfTD7HkvAJIDHEQTx8lbl6i7F4GBKZ2gik3g+0V8Zgioe+h7E/Tapwk592mzXyBvHufYvko9/1Z+iKBX6ehBSl/BOsCmOjiY6uX+SeDmwua64nFYvT19dWTq5fLZTKZDCMjI1iWRVNTU12Q2q271rOcEyKRCD09PfT09DA+Pk4sFkMIwezs7IblMrfqZ+O9s5HGszavNAqemqZx+/ZtXnrppR33/0nzeStobhb9txON5na1iDV/lcHBQQYHB994U3kVxNjvoeEgkyfQc68h8mMoEQGvgmdewC8KwEPIPPq9P8B/6Tvqmz9NjeZWGIZBLBZjcHCQ5ubmNW9yw8PD23qgntSA8LhtND7Mj8OjrsVmvjjf+Z3fybVr10LtZkjIW5iNcmPCw3lFKcXExARLS0ucPXuWRCIRbGj/H4zyv8akgqtaUPpZfDkZCJnVtEV4r+IZX0zRfR3FVRyni0hkEsc5TiRyl2STTUG9SNH5DIm6YOmhFFTc6xiiD090seqblLxbpCJnyThXMUQSAFflgr+yTNo/xrK5RIQEi84ocdHKkjNKUmtn2R2nSe8g482RFJf4y+wkrUYrWTdLm9m243MmhKhbxGruWrU80Hfv3sXzvF1FfD9PCoxayejGyn4baXQ3C8B91Ny0UdxArTLS+973Pj75yU8+Vv+fBJ+Xgub6qOHGi/Q4tck3Ym5ujkqlwjve8Q5aWlo2Xmni4ygpEYDITaCEgXDz+O1fhLx/Hbo70ZZuI6Pd+Mk+RH4R0hPQvq/exLOsd974MDa+ycEbH6iNyoA9qQHhcYXEJ2V+3+6xNE5CoQk9JOStS6OpfKOAH03TsCyL27dv09TUxMWLF4N1ZBG9/K/R3D9BiS5cdYiSaxHXXgXjJMh58K6g9AvYSCrOJ9H14/j+DSCOlBEikbtgfBlLzmsYelDko+Jew9T6ceUkyjmGiM1jay8yXblMXO8HNPLuXQxayHv3SOhDlP0pWswv4nppmg4zhdQW6YwcZs65Q8rsZ87J0Wr0UHLStOqDDNsWcc1Eoeg0O3k59zJf0/k1j30uhRC0tLQQjUY5e/Ysvu+/IeK7MbBos3H/ebFybdRGrVxmLQC3ptEdHx/fsFzmTvpRm0sqlQrJZPKx+v6k+LwSNLfKjQlPLm2R7/vcu3cP13VJJpOPTPoqhn8fmo5B7jWEk0V1nkT5BeRCBqEkqrSMQEFLF1pmGmmbiHufRL3zm4Ptn2MBZf0DVSsDVjORNDc31x+kx+F5GlR266caEhLy1mOr3JgQ+GPevHmTY8eO1f348G4HUeXoSP1MUKtc+EjlAgK810A/g/TnKclstVa5i++PolQvkcgCcA5Pj5B2rgEmtnePuHGBivcqhtaFK+eQ+Kz4Q+SdKySNIUreFKnIGTLODdrMo2Td6xiiBUN7iTHbxVE2JT8NCrLeHAKNtDeDhsGqO0WncYzrhTJ5r0xUd9HQWHQWSbtpvqrjq9DEk3U/2ijiO5PJ1ANvDMOoC2XNzc1rqr49LxrNR80rG2l018+TkUgEpRSWZW3blaAmsD4PfN4ImtvJjQlPRtAslUrcuHGDgYEB9uzZw+c+97nNb9j0MCI7hqq04GsmunDBLuHnNUR2EtW2F5GbRKYOouUmkI4LbYeRSzOwMoHo3Ac8PxrNRyHE2jJgtWoMCwsLZLNZrly58thJcR8HKeVjl+fcjaDpOM6OjjUkJOT5YDNTeePy0dFRSqUSp0+frkcpa9ZvIJw/RtGMJu8gtb14+jGEf4tkrAT6IfAXcJWNre3B814GBLp+Bt+/geelUKoDJ1rGkz5S5YibZ6m4GRx/FEGSincdTXs3M+IW7fpe8OfqZnLLXwYEOec+Jr3MOyZZWabor9BuDJL2Zki6PZTEIj3mYRbdB/RFjlGRMRbsGGlvnP2x/Yxb4+yL7WPCmmAoOsT98n2OJ48/1XNuGMaawBvbtslkMszNzdWr66VSKTzPeyLj+ePOK7V0idulNk8mEx77el9D+HcpFm0sq8zw/a/DssWG5TLXEwqabyK1t4B8Pr+t4JSa0/ZumZ+fZ2xsjFOnTj2s6lBNhbTRvsX4R4O/dp5ccoiUGkWKDpSyApfrSFUTqpsIpwidJxCuhW5V8K59AvHl3/JcazQfRa0aQ41Dhw6tMZEAm+YmW8/zEnW+00EFnq8BISQkZGuUUuTzeTzPI5lMbvjMW5bFjRs3aG9vr9e5RubQKj+H8K6gyXEAHOOLUO4NYATEAI5rYKpRbOMLqbh/BVQwjJfwvM/hOKMIEdQqn86Aod/B1PqAGBX3KlH9GLZ/j4T5DvK+IONlQfjk3WEM0UzOvUuTsY+iN4Fu7UWLaixZfSxp4zQ7gxABTQYvvTXVhYdNVGsi77VxtTBOXyQIRLWUFSxXD6umfS77uacuaK4nGo3S29tLb29vPQ90TeNp2zb5fL4e0b7TwKJnYSmTsgjubxGVr6DLByjtKG2xESYq/5wzL7z0hnKZtfyajSkHIUij2NTUtOP+CiG+GvhPBBn7/6tS6qfWLf8Z4EurXxNAt1Kq7VFtvq0FzVr0Xz6fZ3p6OijvuAW6rtf9N3eClJJ79+5h2zaXLl1ao6HaLHBIKYlKL1ITn6J2ARlPIKdmILU3+HF1BGXEIT2Cp8WRTgEjO4cf6UesjiOXZ59pMFBwHI+370clxd2OiaSxjW3uEKk+AuJlEIugzYOK0dMXxXO/DKW+FSF292jsJqCoVCrtakAICQl586lZx5aXl/F9f8Nnt5Yv8vjx47S3t3Pv3j00eRO98AtoMkhj5+vn8VDgfhxEDzCIUDM43h6cyBCu+xcP0xa5V7DtIWKxWaTxBczbn0JPaJjaEK6cqgf/KGwMbR+zbhnLd7DlMoazFy8ySXvkLGnnKp5jgAaR5CA3yhNEjVU0aVCJLGGSYNWfxJQJyuYicZXC8T2K3hHGK+N0mV3MO/PBX3ueDrODWXuWNqONaWsaQYSCV6HZePK1z7dDYx7o2pzQ0tJCJpOp54FuaWmhvb2dtra2LUtlvtkKDN+7gXD+K1HhoMkiSjsFQmO29NM4KggkWl8u0/f9elWm6elppJQUi0VefvnlHVvKhBA68AHgK4AZ4IoQ4iNKqTu1dZRS39ew/v8FnN2q3betoNlo0thuyiLYnem8XC5z48YN+vr6OH78+BsEnk2Tu8/fgek7yKYmNK9IzMviJ16CueuwNIJMtKA5ebKRPbR5U7jtR/AqNjnjEEroxGQZ//WPovZc2lF/nwZPI7Hudk0ktaS4Wz7MSqH8nwPjj0DPgOdBRAPNA9/AjJhEIx9Eid8E77sQxt/f8bHsZmAKNZohIc8/G+XGXK+UkFJy//59yuUyFy9eDAQZpehM/iHt/AZIkPo5pKwEUeXKA+0AyDEQ7TjiPBXtFlGlAyae9zqOc4pI5BbxRJSSeoG8/Unixnkq3mtoWhwkVNwbGKIbJTpI+y3k3OukIi9gO8tIrQxAzr0PMoYtZkH7Eq6Vh+s5MfsiR5l37tMfOcScc4euxD7m7DvE5BCv5ZdI+Q4YEJOBRrDFaGHZXSZlpFh1V+k0O2nWe1iqJPn06m3+Rs+FN/XabERt7q/lgR4aGkJKST6fJ51OMzMzg5SS1tbWuuC5XknwZgqavvPnCOd3ieoaQvkorRtBDCfyg9i+h6ZtLJc0phSEQNlx/fp17ty5w7Vr13jllVd43/vex3ve857tdPcSMKKUGgMQQnwYeA9wZ5P1vx74sa0afdsJmo+TGxN2LmguLCwwOjq6xlS+nk01juOfBbeCSp6E3GtINGROogFIj0pkiKSTp8WUyMheVDaCNjtP08Ax/MVZ/LZO1OQtCqKH++Uy3d3dtLe3k0wm31Lm9O1qIzczkUxMTJDJZCiVSlQqlXqk3hq8CTTnB/DNNIgC+BqYGqAQdhI8Cy3qgOYgXID/gKh8DBX5SdA7tn0su9VohoJmSMjzy0aBpOvnlVKpxM2bN+nt7eXYsWPBmCZX0Us/THfiGrY6SVSM4qOQaikI7lEjoCoo7RAWzdj+BCDx/fto2nmkfA3THAb9nSy7w5hGMBbZ/gjST2Jzn7hxFsu7ja+fZ7xymZjWhcAg69wipvViGQs0accoynskxXkmVYWorAbMVPtellkAcv48IMi686jSQa5rWRAa+UgeU5os+AvoSmeqPIUmNOasOSJEKHkJPrM6R39U8Rcr158bQXP9vKJpWr1UJgRWs1wuVy8l2ZgnuqWl5U0xnSul8OzfxPA/Q0QrI5SGEEGGGjv2oyCa8f3pbfub6rrOuXPn+Iqv+Aq+9Eu/lG/91m+lXC5vt7sDwHTD9xlgw0ScQoi9wH7g41s1+rYSNDeL/tN1fdt+l9sVNKWUWJbF3NzcG0zl225z8nPB3+VJZDxGQXQTn76H7OxDK85jlDJIJRBoWJlmWJ6A9gHIzCHsMrqKoDWlGKosYOy9gOu6TExM1E2xNTP0Zs7CT4pnUSqs0UQyMDDA3bt3SaVSOI7D8PAwtm3X/Vbam8eJ8T6U5kK0WjtWGcF3QHgaKqKBrSN0iebEAQ+0W2j230Ea/wEiF7fVr934aO7WlyYkJOTps1kgaeO8Mjc3x8TEBCdPnnzom+9eRqv8DBBDCBuDURz9CKgMqAVQUdBOIOUCZaJ4cgal5vC8IXS9jJSvAWdQZoKsl8ZTeTz3tbofpnSOoMWH8ZVNTp0kXWmMKn+RjHONuNGN5SxQttPEoy/wwKlQ8osICsS1VlbccVqNXnLeAp3mPlbcCfojpxiv+JQ9HctY5kD8AGOVsYd/E8HfPcYe0l4aWdjDZ9Qcg3qKGTvNgOhgurLyjK7WQ7YzrxiGQUdHBx0dgQC/Pg+0ZVnMzs4+slTmVjxK0PQ8F8f6VyS1NFFuo1QLmtCQYgA7+q9ABKZ93/d3PI8Xi0W6urpoaWnZPLXi4/EPgd9VSm0pXL1tBM2aSWOj6L8nLWjWTOVCCF588cUtBYuNNJpydRJRWAy+2EXoOo5azgCQs6OkANPOQO9xnPkKJKuCSKIJ0nOI3gPgu8ilOUxRwnynpKu/v55GqFafvOYs3GgeeNxIvCfNk3hrBEgmk/T29q4xkTi5P8GMfwBl2OAptHwczSujTBflJJHCQ0UDp3YR8dGKCoFCRVzwQOk+mvtDKPXDqOi7tuzDbqLOQx/NkJDnj+3kxvQ8j1u3bq2t+KZ8NOu/IdxPIfzbCBQl7zi+kES5DJigvwD+dVwhqIg+fO91NG0QRTOx2BQV6wTx+DwVEaHgjCJVZo0fJmjosREixhcxbk3QbPYDU/Wo8rI3jcAkY98CJ4WI72fONyj4Y/THjjNn3aUjMsiMlSOhtZFjAV0YtBsHmLWTTFoTpERgii375TV/LRmMlxEjyWRe0pNoglKOmB4BH3RL8uE7H+Odzh5KpdKGCcjfDHYzr6zPA/25z30O0zQfmQd6t/1wnQwV+/to06OYTKFEB5oq4ul/Czfy3dCwzW5M+OVyeTfzyiywp+H7YPW3jfiHwD/bTqPPl8SxCzYyla9nJ+bwrdZdXFxkZGSEkydPcu/evW0FwmwUDCRHriKaBtCKwTWUxRLRXCBoNldWULEYwrPwVAcycxPKNmgGrEyDZiB0DTU/DtFONOmibt+EdwUPx/r65LWEt+l0momJibp5oL29/ZH5PbfLs9Bormf9g6hpGu36x9ETPweOjnJNVJOLwAIlUFEFWJhFwAIvAcqo+ppqFsIOFA64EYSbQdg/ja91gPnogLLQdB4S8tZnO7kxbdtmYWGBo0ePMjAwUDWVL6GV/x26+6cA+GI/vtaHLj8bBH3q58B/HeXdwTa+hIr7MYRoRYhepJyhYh0mHiuQSApy/n7K3rV62qKKdxNddOL44yTMiyxkLbJJhavKFLwxdOLk3Lsk9f2U/HEM6wAqmmXFOsgSU3RHDgBQ9FYBWHGm0DBYdseIiiZcmeRuqULemyRlpMiQocPoYMFZoMvsYsFZoNPsZM6eY3/0NB9fXqDFaGKsPE+zHmfGSxMTJlnd5o5Y5AsYZGxsjEqlUk/H097evmUAzpO8ho87rwgh6G9Q4GyUB3qrNEO1dhqxnREs6/tp07swRAnFPjSVxTW/ES/ydW/Y/k2cV64Ah4UQ+wkEzH8IfMP6lYQQx4AU8PJ2Gn1LC5rbzY25k6jszQTNjZy8a+tudQNsFAwkx18H2tGqLwtFx8Qxe2lz5xCejUodA2sV5+4DtGgSYZeg7yAsjEDvIViagGgcvbMTPVuGB3dRX/xuxAaC9vpo7pp5oBZUUzMPdHR0bPst7UnyNBLritJHMYr/DmUKMCogkoCL8kDFquu5VWFSE2iuwMkl0FtLwTJDQzg6mgPCEQhtCX31+3E6fwOMrk37sdtgoFCjGRLyfLBVbkylFDMzM0xOTtLW1sbg4CAAwvkMevmHECqD1E8gfQdfGOC9jCOPEtVvg38NX3uJslrFc/8STduPlKMotR/QiMdGWMldwGu6QUTfAxhU3KvEjFNY3i0i5nEcH9J+hLQxA+4czcZBCt5oPaocGUzrkXgLw45GJbpATDSx5IyRMvrJeHP0RA+xaI/QGznKqjtJXHuRV3IPOBg/SM7L0W62k/EytBqtrHqr9eCfNqMN6XexYJl4StEfayddKLA30c2twiQnmvZwpzhNT6KPebPEXzv919aUlKxpf9va2jYNwHlSPClLWY3N8kA3phnajuXQsi5jOT9Ei94bhAnQjsDFNb8Z3/yqDbd5syxlSilPCPHdwJ8RpDf6VaXUbSHEvwZeVUp9pLrqPwQ+rLYpWL0lBc3a2+bS0hKdnZ1blu/byc22UeBQpVLhxo0bdHd3P3TyZvv1ztcLusqpoGaHQfr4fQPopVmMsofvNaxTyOPrneBOIvoPwNwdqPVLSfA9RP8gKrNINFfCMTzcO7eInDqzZX8azQNKKS5fvgyw5i2tvb2dVCq1rbfP502jKSp3iWR/GoSJMkooaaKiZURZgGxDaRkwBXoZVPU5FEhiooTIKfxWAZpEZEEYNkRAuQmEliey/N04fb+9aT9839/xG3upVHpYLSQkJOSZUHM5KpVKtLW1bfjC6Lout2/fxjAMXnjhBUZGRkC5aJWfR7N/G2UcAw+kcvFFHugGHKL6bSz3FHrUpeTfRdO6gQpKFZCyCU0bR2jvoEwFN34fQ6Rw/Mm6udxXOUDHlzar/hGy3j0M5yBebBSqlXgK7iioKCU1Ssz4Iq6VR+mNHqEk79MZ3cuMdZu43kLGm0NVw4CkglVniDkZ+FQuOUsIBPP2PEIJ5p15dHTm7DnajU6mSgbDxRWazQQCWLKzAGTd4AXdloHfu6Hp3PcCC10txVBLS0s9HU82myWdTjM2NlZPW1ezsD0p4fBJaTQ3Y6M0Q7U80BMTEwghaGtrw/O8ukayVPlzXOcnadKTxIQPKoauJrBjP4LUN48D2I3v/y5N5yil/hj443W//ei67+/fSZtvOUGzlhvTcRzGx8fp7u5+ou2vT9hey4d24sSJevqAGpumLdqgzcb15PRtkEGS23zJpDXRiTazShxQ/XsR2UmQErcYbCOL+SASfWkS4s2wPInq3ItHEyoWoZxyiBg6/t2bsA1Bc/0x6Lper2JUe0tLp9PMzs4ipay/fW6VNH23PFGNpqwQWfwhhJbBjyUQlQSaVYGkAqFQfgbdUpADSSvIHGgCYbUizCwKDeRxfOUTNe5RsveSSEyCqKAAIccwVn8Wr+N7N+zHbk0c+/bte6zjDwkJ2T015UWhUGBxcfENYz1ANpvlzp077N+/n76+PizLwtCW0IvfA6oCSHBfxzUuolQF5CwwC8ZFpPMqFSXRVQSllpHSAvpQah4pj6GbirQ3DaIZoVeI6EepeKt1c7nrz6CbX82D8qs0m0GwkR+ZRaeJgvuAJv0gRX+UmH+SvJmg4BsoFLYMBMBVZxoNg0VnNNBu2mP0Rs5xObdEm9FBxltgMDrIjD3D3theJq1JumQXy2KZfbF9OFKSsVLcLc5yJNnPcGmOQ4k+Rsrz7I13MVlZpi+aYry8SH80RbYc4fVCmvdJH1NbOx7qur4mAKeWtm5mZoZCoUAikaC9vf25KEu8E9ZbDl3XJZvNMjc3x+uvv04y9af0tn+UNtMnIXIocQ5NjWDFfx6lHX5k27vRaNZ8Sp8H3lKC5m5zY+6EmlAopeTBgwcUi8WH+dA2WXcr1ms05cSN+v/J/BKq6xS1NFVSNKEDntED0WqFhtV5VFcfIjsP7QP4roFdiOHfHoGWTlwzhnQlMW8Rf24Ovb//sY6/9pa2f/9+PM8jm82uSZpee5hqUXjPk0YzMv59aNo0ytHRPQdhusioBgKUJaCpeh1UBN3IQiaK29oGkSRCZhFINHscwSEAktFJfHEKzbiFV+7CsPOoyv9iemkv0Y4vXFOJobEfOyE0nYeEPDs8z6vnwzQM4w1julKKiYkJFhcXefHFF0kkEgCY8tMc6PwVhDeMQCHFflytF7xPAwKMi+BdQXqj5NQFMD6D70fR9cP4/gNsu4Vo1ECPtZHzFLYcJaLHUEqj4l0jZpzA8u4QMU+T8Q+QtoYRRMm792kxj5B3h2kxXyTjXqNctohGh1jU4yxZ8wAk9RRpd4aE20XZXKY/eow5+x59saMUvQjzTgJLusS1IBWcLgJBRlJVcIjgr0Yrn12Z5UBibfq+mgDZVE3O3hFpQaARc3v47MosB/VmPrs8wbt6Dj7y/K9PW1cul0mn01iWxeXLl+sJ1tePtVvxZgua6zFNk66uLiYmJjh87E8R/seIagpTQbG0H00vsGj9JC1t/SQSj+7rbivOPYkYjCfBW0LQ3Cz672lUw9E0Ddd1uXLlCl1dXZw7d+6x66I3mtht2yYzMcbD92WFZz0si6Xmx1FdvThjs4CGFokhXAsVb0Nk5/FkEuvmKFp3tUpARwpzYhrf1bGjg4jrN0juQtDc7FwahkFnZ2e9Rq9lWfUSkbU3Jtu2sW17107eT0qjGV387+jOLZSRQLgVaPZQtgatwbEJX0MRaKuFQ3D3mzZ6JYkyo1DrgtiHUVpFGlGEsNH8eZR+kqgzATRj+EUOyV/ibu4E09PTKKXqpTJd1w2jzkNC3gJslhuz0aLlOA43b94kmUxy6dKlYO5RDpr1i5j2fyWWAKXtx6UDKYdBjtQFTLwreMYXU3RfB/EyrnsI0xzBdTMoFScazePo7yZtfxxdtKLRhuNP4ltHMeL3kaqEqR1hys6BSODIbN0Ps2b6zjnDoKJEE93MuCYr7nQ9qjxl9lPyMwgVjEeWLBLTWlh24twqTBPTYhgYzNgzxEWcaWuapJZkxpqhRW8hr/J0cIq/WJqjzWxmrLxAykgyWl6gWY8zWl4gJkwmy0voaEipcWdR0R0PtKgukj+Zv7+loNmIEIJkMkkymWRhYYHz58/XE6zXxtpa8M1m7g2N1/dZ55OWUtLZ8/NocgJdM9FFAsPoRY8MkPO/E7/iMjY2RrlcXhNYtL5U5m4tZaGguU22E/23k7a22j6dTlMoFDh//nxdBb4ZO/HRlFKSyWS4f/U1js0uQ1sS7BLEmrHvDhPpTCHKmcBvM74f3EDDqe05hJq5i1qew+85SuXqGFpnF3JpAZHqQKWXwXUQfXvRNEHlzgzxL7HQEtuv6bqTcxqLxejr66Ovr68ehXfz5k1GRkZwXbcucKVSqW2nUXoSA4LhLRHL/CZKVwivjEqYCHyUFgWCdBwq1uADG48hsAEQohW9eIMce2lqnkQ4Ppo/gzLOAtcAH63UhCZL+JE9aHIFzTc5Ln4F+/y/r2t90+k0y8vL5PN5urq66kl/t3oT3a0vTUhIyO7YTm7M1dVV7t27x5EjRx76UPuTGKUfBP8+Uj+NXZnFiKeQ3utgnAZvNdBiahexhY/lfBzDOIPnraLr83heG4axgmZ8MavuKLbzaUx9H64/Qdw8T8V9DT06iUYKKfpI+wlK/nVazaB+eN4dRidJwX2AsHqR0VWikXdxrXSLvugRAEpeGoAlexyDKCVzkSa9A4VO2TvKSGWKvfG9TFYm67kxh+JDjFZG6Y32Vv8OcDWfR4+ZSBT9sRRpt8BAvINMYYq9iS5uFaY40bSHe8UZTieO8afTcxxu6uRBcYWBeCszlTxWZo6S55A0dqeE2CjBemNZYtM069rO9Xkun7Wg6XkVCuXvojU5hiFMJCZxfRAlunCi/5K4iDKYhMHBwXrAVGOpzNbW1vpcuhtLWaVSqWvfnzXPtaD5qNyYO2UrE2/NVJ7P5+s+Ittpc7vm+4WFBcrlMqfb4niWhUwdQFu4CW2DMDeNTB5ALwfO0+6qgxIaQklksVxXtFnZwEQhWtpQq8toqXb8sRH8zi506eDNr+CrBKVXbtD87qdflrIWhReLxTh16hSaptWdoScnJxFC1J28HyVwKaUeu8zXKfFfUJ6GMIooIgjdBk+AZaLlJVKLoEUFSlSQqU40sfDwONxZBB7NahapzqFbrwOg2dfw40cQXhy9/BrS7Ed37uFHjyG0HHrlClr+KkbL2brW13EcBgYG6qlPhoeHiUaj9QFjo6S/YXqjkJA3h/VlJNePO7qu43keDx48IJvNcv78+bp2STh/hF75BZToRZAAf4ayl6RJOYAN3quBP6Y3QkllgRjg43l3kXIQTZtBaIdR2hHm7ctEjRMgF9Gq03DFfZ2ofghLTuPrX8BY5XNEtQ4EEXLu3Xp0eatxhpx3A1SSjOyiaAX+lwv2CM16Jzlvke7IQZacUQZix5m17tJiHOUzmQn2xqvuWFWNaKacAQFZJxt89zIMRvdxK+ux4Nt4Tg6AJTv4u+oUAMi7QU5NV/p0a/uYLQTzYJMZCJS9sSZmKzkGEq18YnGUvzlw/Ilcv/VliS3LIp1O1y1sTU1N9TnnWQqajrNCqfLtmGRJmC6W0mnTHTR9P07kB+oBXDUaA6b27t2LlLI+l05PT1MsFhkbG6trcrej3fR9/7nJmf189GId28mNuVNqb6obtWVZFjdu3KCjo4Pz58/zyiuvbKvN7ZjOPc9jaWmJWCzGxYsXsf/PbwDgjEwT625FOkF/vOlpVCKK3tKO82CKyMEDqPkR5NIcek8vnt6JLAbryuUlFAKVqVZfiEZgbhEt1oqease5PwpvgqBZo/ZAb+QM3VhlIRaL1d8+G5P4Pu6AoE3/LhE/C7qBEOB7SbRVHSE0jFgR4qDsJJoeCPJYQyhjAPSbKL0Pw5kAQBcuWCaCFJBGoBCuiVa4g8BDau3gzyFw0OQ8MjJEZOY/YJ34UL0vtQoObW1t9aS/tVKZmyX9LRaLOzZxCCG+GvhPBCko/qtS6qfWLR8Cfh1oq67zL6rRhCEhn5fUAkl9399UceG6Lvl8nvb2di5cuBCsoypolf+E8G6CnENjBk9/EV9JmuKvgU/dXO7KPJZ2EM/7LGCi60fx/ft4nouut+CZLdjoKDxcOYcgie2P1GuXC9HOgq1w/FeJ671U/IW6uVwTgZCYtx8QN05zR+RIKJOyv0J/9Dhz9l1azG4K/kpdOVH28/ilg1y25kEJpipTJLQE05VpEjJBRsuQ0lKs+qu0eq1IJ8moZzLjZeilhQU3z/54N+OVpXrQz2CsgylrhSOJQcazipJjUfByJHWTkcIqBhqzlTwARc/mz+bvPzFBcz2xWGxNnstisVjXCubzeTzPo6enZ0cWthq7dc2znWHKle8hikWrXiDjJkmZNsr8pzjRb9lWG42lMAEuX75MW1tbPVK/Vt+8Fqm/Xq55Gm6Fj8NzJ2huNzdmje0KKZsJhSsrK9y/f59jx47Vo+C2y1aCZrFY5MaNGzQ1NdHT0xNUkpi4Hyx0XWTTAdzJqmbNsSh39JMwE0AJ6Tx0GaSpl8prk6Dp6Ik4qpBH6x9Azc+g9fRhZFdQmsDo68QvVPBmKlTujBE/cWBHx/OkMU2T7u5uuru767XJaw9KYxJf13V35OS9hsoKkekPoksb1VRCFlvQVRER85F2FFH1IBCyWN9E81bRymPIyB68pj5gAgClBHppEqV1oYwsQkiEo6PMM+C+hm7fwo/sQ3PHcaNfhGZbaN4SxvSH8PZ8I7BxdGA8Hicej2+Y9PcnfuInmJ2d5U//9E/5m3/zb9Lb27vlIQshdOADwFcQ1KK9IoT4iFLqTsNq/w/wO0qpXxRCnCBIV7FvN6c4JOStzla5MeFhhpFIJMKhQ0EwIN4oeuUn0bygXHAtAbvy/hKAXOkIrclhlPsqtvkuKs5HAYGun8L3b2HbS2hakkgkznxpAMF1hIhjiF48uUDCvEjZvYLjj2Po72DEmgK/F2VkiepdVPwFit54Vat5D93rR4vuYcVvwhErtGlJ8KHkB+byZXsckxiLzhjdkcNMVUwKvqRMJigdWR6jV+tlmmn6kn2MVkZpj7ZTsSs0xw7zqfQEByPBS6/uAzoY1broTXowmLaZSWIijlVuYao4y7nUAK9nZjmR6uFaZo6TrT3czi3Sp8cZKaxieR5Z26Itun13rt3QWKhkaGiI27dvk0qlyOfzO7Kw1diNAqRU+SSe+xOYQmLgseh1EaXCkvhnpKLf9FjH1hgrsT4Xds1q1t7eXreO7cYKvJUCo7rO3wfeDyjgulLqDQnd1/PcCJpKKSzLqpsRt3OStpswHd5YhlIpxcjICNlslgsXLuyqHvijBM35+XnGx8c5ffo0q6urKKVQlRJycaa+jpu2wYgClaCP2QJOLjDpeDPTmN0dUFjFLekooSN8H61nD3JyBBGJogAtmYR8HnfwIEJEUMoB38G6dvdNEzS380A21iYfHBxck0ZpYWEBIQTFYnFHpgGA6NUfRpN5PC2CnjEQuIi26nU2TcBCeQKSQToppbUiqhpMzZlGzyaQicNoPKDs9tHsLgCLeJGzICbRMncQWhwVa0XIwClfihfRS0sY5VH8yEmMpb/AG/gHoJlbOm2vT/r7oQ99iHe/+93Mzc3xTd/0TfzBH/zBdvxqLgEjSqmxapsfBt5DLXVBgAJqBW5bgbltndCQkLcRNS2X53nE4/ENhQspJcPDw5RKJS5evMirr74KgLB+D73yk4CN1M+gZAlPKPBerpaQvEprchipfwEluYznfBTdOI3vXcf3p3DdVkwzA8ZXsGh/FqKzRPVD2P4IpnEYz1ug7F7F1PdhM0BRJvCUja4XAY2sc4u4PkjFn8G0DyIjy6joCW6Vb5PU20FpLLtjNOkd68zlJ7Cly6rbw5T1gE4C4aTiB/NMzg/M4MvuMgJB2bcoWv2MOXNEhM6slyUqDJb1EhF0puwVDASjxXkMNBxL568Wc3RWfd5XncCMXvGCuUuvzgVNwiAVSTAgOvnzqTH+/uETT+06b0Zrayv91eDY9Ra2aDRat8BtVCZzp36Rxcr/xHd/AR0TgSAnmxFKcSX7hbxr/+6FzI1YXyqzZjWbmJggn8/zcz/3c/i+z/j4OPv3799Wm9tRYAghDgP/EvhCpVRGCLGt/JLPhaBZM5XncjlmZ2c5derUtrarCY/bEUoahcKaqXyNeWQXbFjDvFpByLKseu3bdDodvFFPTEA0BlbwwBNrQ0XaoJAFwDdiaGYngjwoBS29CF1QujmJsW8ANTOFLAWBLf7CHBgGnh8lN5NAk1Aam0Hr7sLs6kEspvFzRfTW5zPIpDGNkhCCaDSKaZprkviuT6P0hjZm/hxRmUOLO6iKgRb38D0dASgPRCzQYkoviRYNfIuksRfDvRn8r3WiW8MoO4bfdhDPfXgf6cXbeMmzmFwGWcLXzqLL10DGEJU8ujOBHz8UmNWwMe/9Iu6J9+54cKpF6v/Ij/zITu7DAWC64fsM8NK6dd4P/LkQ4v8CksCXb7tTISFvA2qBpIuLi0gp2bt37xvWKZfL3Lhxg56eHo4ePRq4AGkWeul9CPcVlHEK4d0MErCTB9oBB/xrYJwnW1iE2C10fRCQ+N4DfNmDri0SiZ7GIkbG/gRR/Qy2fwOFB2hUvBtEjZP4MkNJHWXOfhVdxDFFK66xSqtxipx3C10F2kUjGmXCGyTr3KHV6CbnLdEq95DTp2kzeyj6q1ULmMCRTbycmSSmuZiYrGqrNGlNzNvzpLQUGZlhIDbArDXLodhp/nJlmaFECxUrz/GmQe4WZ+oVfo4m+rlfnuNYcpCJyiJDcj+fWlxhSEswZRXZG21hspRhT7yVB4UV2iNxhvMrxDQDVypkIcK0UeRP7JE3XdBcrwBptLABayxstajvmmtXNBrdkUYzV/pl8H6DqAAdm6xsok0r8ke5d9FZ+ZqncXhraLSa1eSc9773vbz3ve8lmUzy4Q9/eDvNbEeB8W3AB5RSGQCl1NJ2Gn7mgmajqdwwjDVax63YSQ3zmlBaiyTcjal8q/1blsX169ffUEGoJpDawyPQcQBmbwPgFmzcuRUSXS2oYh5Xb0IvS2pGZG9+AdHdB2qaUqFMAvDnF6CtBb1UwBs6Q+nKFPR2oOaWEbEIZiqBNbVCoeBjnBim/avOPdYxbocnkUdzfRol27bXOHknk8n6IBCPx0H6mPd/DWF6+OVORDQbNFa1zkgrgp6wUQpU617wblX39lAIVMYeYBWhLLR8Gl22UD/5ykUrPry2eul2ELC1OoKKB+k6vLYvxev4W+CXMe98AOyHlTB2cuxPia8Hfk0p9R+EEF8A/A8hxCml1JNPPhsS8pzRGEhqGAaVSuUN69SsTidPnqS1tZoj0rvLiYH/Ar6GUGmUm8M1LqDkAsg5YAH0cyjvKpZSlKRGQq3geSWE2IdSEyjZAfoBsrKA0IIXfU/OomQMhwni5gUq7qsoUkw6BVz1Kk3GAYreGK2Ro6Sda9j+CihB0b9PXH8nNyqT9EaPkvUzJI0Oct4SngiOadmZwCBK1lskoV3ks5lJ9sT2MG1NczBxkNHyKEknSdEo0hHvIFPKENNiDEZPMlnWKUsPXwbzrlMtJGJVK/zUvutCB7uHXDV3ZqqllalsmaQeDJgxVyFRDESaueks8UWpA/zl6BwH21q5l1nF8yVL5RLdiTcv6HGreSkejzMwMMDAwMCaMpm1cpLNzc1rqvpsRqbwIxjyL2nRbUxcVv12WrQKv5P7apR3iuP61oHFj6LmRrhdNE3j6NGj9Pf384d/+Ic7mWO2o8A4AiCE+CyBef39Sqk/3arhZyZobpQbc6eC5npz+KMQQjA1NYVlWWsiCR+HRkGzJsAeP378DRHrtWpD7ugYztgUyb3dqEIWd3YZPB/VtheKdyBtIbNpxFBfkKTddSgsehhANJOHZAIqZWRzirLZRmWqQBSQmkD3fKIHB3DmV/BzNtGBPgqvTZH6yrPPPJfYVmw0IESj0TekUUqn0wwPD2PbNsfKf0Z3JYNyNPCL6AkPJTVE1MFPx1FeAuVoaIaEeAWl70c2dyD8wsOdVAdRAKW1EClIVFsMgYWMHMFYuobXdgrdvYVQDsrfgyanUaU72EPfg9f90DXFeeHH0ac/CmztY7meXfjSzAJ7Gr4PVn9r5J8AXw2glHpZCBEDOoFtvYGGhLwV2SiQdP084fs+d+/exfM8Ll68WPcPF/bvoVd+kfamBfDB18/jKQe8zwBR0M+AfwPpT1IxvgDH/QSxaARNO4SUI9h2GdOMYsZ6yPsxKv4raDKDIbrx1BK+fQwjfg/HGwX9ixmu3CYVOUPGuYFWTZaede4gZBOWtkDUP0ol0saSiiGRdT/MRXuEuNZCiRVS+iAZf4Y9sfPcKuRpqUZ915KvZytZAOyYDR7MWXM0682sWDHu5jO4yqOpmhMzZSQZKy/QbjYxUV6kmSgT1jInEvt4db6EQGfWX6HZiDBcWCGq6cy6JXQEeUOCB1m7zCHZxsRMDldBpBpd3Zts4s+mRvmmYzurXPc47EQBslGZzKWlJTKZDFevXkXTtLqio6WlpZpxxidX/A4Mholo4CmDokxSkAn+qPDFLNhNfFPqLG7Geqzj2G0OzVrKvCc8/xvAYeBdBPPOp4UQp5VS2Udt9Pjh3LukFgHYOMkahoHneVts+ZDtCpq2bbO8vIyUcttC5nbeAmoC5NjYGKOjo5vm3hRCoDwPZ3ISpMLTU2id/eAFfbdG59F6BhHZwNdFRdsAKDd14TnVRnwfrbsPAEOL4g8XiaSLqFgEbSWL0gTlfA6ZL2EOdaLFdNz5VQqvT255HI/L064MVPNrHBoa4oUXXuDCyf105K4hXdBEGVl9q3aKLaiVZnRPoGkumiGRZgrNmkEvzaGnV9Dnp/G18yiRRLPG6/uQoou4WkbJk8EPfvDmrZWzKAyk0YGxcgOpp/BbLuB1ff3aThoxZNtxNG9ng4pSajdazSvAYSHEfiFEBPiHwEfWrTMFfBmAEOI4ga53eac7Cgl5KyGlXJOAHdbOK4VCgcuXL9Pa2soLL7wQCJnKQS9+H0b5x0CtkC0dxhFn8Pw7IMdAPwrY4N/B1d9JXtk47sto+iE0zcHzsvh+nEgkh29+CfP2NUreq5j6viDpuh74COqxB0SME+TVfvIyEAjL3jwCk7z7gGbjEBIHrE4M2UPe7OJBZYpF6wFxrZWct0hP5DC+cumIBO+ZOhG6Iie5W/RYdPLMVGYwMJiqTBFXcVbVKs1+M1kvy1BsiKTejCYP83p2kYPJPjwl2RfvCrSR8Q4U0B/rQKLo0po5GBkiU06QdR32N7XjSJ+DTZ1UfJejzV3kXIsjLV0sWkVOtHSTUC1kbYNpp0JcaIzmMmjAVDbDHz64h2U9ntC1Ex5nXtJ1ndbWVpqbm7lw4QKnTp0iFosxNzfHlStXuH7zsyyl/wG6GkZDx5Zxsn4Ti16KP8h9FQtOE6dbDtMsEo+dNWe31eZ2kTJvOwqMGeAjSilXKTUODBMIno/kmQmamqahadqaG2EnGsrtrr+6usqrr75KKpWir69vWxdsI9/LjZBSMjU1heM4XLhwYVMBVtM0WFyEau42e2QW33wokCrbwTUfasLsiRk8PYLMC7TFDKI5iOmQxTKYJoUJG6O3C1yP6GAvmuOhDXZhruYRTTE85WGNz2EvZZj/i2sbmo2eJ3Y6IOiXfwUNC80I0hlpEYWz1ISyNDRcfN9AM4MBTcYGHu4n2oNQEmPpFtI+itIfllQTTuDPqedu4utn0HMTAGjOAjJyBqXtQ/hlZOQg9tAPwAb9ValDRJ3Mjo7dcZwdB6IppTzgu4E/A+4SRJffFkL8ayHE36qu9v3AtwkhrgO/BXyzet5yXoSEPGFqWsz184rneUxPT3Pz5k1OnTrFnj17Hq4jIvjx9yIj70EpgY9EqgWgFVQW/EmUdpyKfoai+zmElgIslMzheQk0bQUzeo4cg6zYnyCqHwM8tKofTsW7RlQ/jmvvIeP3sexOknXvENXaseUyqUjwcutVFQ/oMSa9FBPWKN3Rg/h4dEQGAZAEAnPanUFTJiU3ya2Cy5y9wEBsgIqsMBgdRCLpjgS+iAmC4MKYluJ6WlCoCt1FPxgjM14w9tVyZK44eaKaiW3H+MuFLCtWUOknUw36KfuB9sOrDicRTacv1kKT08ytxTQDTc24UjIYjVPyPY63d7HkWORdm7+8cZ0rV64wPDzMysrKjub7nfIkFSCRSITe3l6OHz/Oiy/0s2fPTxHXVzCVj+tKlHRIu0l+L/slzDkSTQm+rOOlXQmJ69mtRnMXguZ2FBi/T6DNRAjRSWBKH9uq4Wfuo9nIdivt1HiUoKmUYmxsjNXVVc6fP8/c3Ny2b+qaSfxRN0gtZUJHRwfHjh17ZHtCCMTs2hcDp7Q2nY+dVUhNR5N+IJAePIy8GkSoa119+IU8/sIS2uFjuJdniR3vAJaRToMGWCpie7qwxhbwNJ34gU6cpSz3X72JE4W2tjba29tpa2t7oolcH1d+2cmAoBYfYK5cQzoGZkcR6RmoChiGRFYrAPleHEME/xeKpXq5T+m71B9XP4rIuciuAwhvEaMwVd+HKGvgPzwmrThPtfwvKrYXFRva9Dg8swl8B/TtVcKo+Z/ulGpOzD9e99uPNvx/B/jCHTccEvIWZqNxRCnF6uoqQgheeumljSdtfT9+8idQ5nuI+v8MofIgWkDbj5RZyoDvLwBllMwBrSi1jOsdRDObWXZuYuqHAIVURcDA9h8QN89Rca/iiX7mtGvgXKv7YybM49hOmqI3DUqnwhQR40u5yT169CMUvRxKBXPWsjOBToRlZ5w2ow9HVZD2aa77sxxOHibn5YhqwQtrppwBHXIE0eUZLUO/cZKPLS4Q1SKMluZpjzQzUV6kN9LGrJWmP9rOnJ1mMNZJxXfolPt4tbDEUKyVqXKWPfFWxksZ+mPNPCis0BlNMFxYptmIIqWitCq4RxoBLJYDwdSuuoOb1Xm0r7mVqWSUdx87TS6XI51OMz4+vq3Az93wuILmRjKA7d6jbL2XuObSrudY9dvoNMq8XjnOby+exPVsULDXGMLN23ie90w0mrXk9TtBKeUJIWoKDB341ZoCA3hVKfWR6rKvFELcIcgg+4NKqdWt2n5mGk14fN+BzQRNx3F47bXX8H2/rmncSeDQVuvOzs5y+/ZthoaGtnUxNU1DLDa4xkUiFG5OYQwFaQdELEb5/hyVtoZMATKGqsYRuosZFAKRTGLlAwHGmV1BCQ13egGViMH8CiIeRZYr6G0tRI/uRTc0WMzRtyA4f/48nZ2dZLNZrl69ytWrV5mcnKRQKDy2oPhmlAatoX/uV0FpiKiG8sEtNqMbEt/T0OOBxlg0lDtrjT7U5qrSQ2HSt/IIt4hYzuNHzyB4eL2ViuHrDxMMK7MHqe9FCR1n4Bs37ZuUEj/aSkMG1C0J65yHhDw9crkct27dIhKJcOrUqS01QyJykQfzP4EUg6DyuKKFomjH9a6hKAMplFrGsjqAKA5xsr6Or8p4ch5BElfOkDCDIExPprHFOxmtXEO39wX7qPtj3iYiOnDkKgl1kpI4w7IfKA6y/iw6JsvOBCljAFuW6I0FuT2Tej8T5RRpGZTQXbAW0NCYKE8QUzFyeo7uSDdZN8vBxCHsSg+rTgRX+exPdiNRDMaCQNiuaGDVaTeDMajbTDGTiSFVoIhIRYJqdN2xYHlfvAUFDCVSeEpytnmQ6xNZBppaWbUqHE11MF3Ms6ephRm7QioaYzibJqJppK0Kd2eX64U9Dh06xMWLFzlx4gSRSISpqSkuX77M7du3mZ+f3/Z8vRlPQqPZKOCVrD+nUvlnRIRLTFgsel3EhcPHSxf548I7iUSbMOMxYpFB3t11jpWVFcbHx5mbm3usufZxfTR3glLqj5VSR5RSB5VS/6b6249WhUxUwP+tlDqhlDqtlNpWOPszFTQfl40EzXQ6zZUrV9i7dy9Hjhyp3yg7MctvJmj6vs+tW7dYWVnh4sWLJBKJbT0MQgicORuqN4vR3Qu+pLLighBo1e8q61C7DUujGczBwFzirWbR+/qRHYNYM4HQKfNlzKFekAq62sDzMQ8dIDtrkllsojAnmP9sEb9jD8Xhpboz80YPd7FY5O7du8zPz+M4zsYH8RTZ7oCgZm5AdhzhlpBSw8u3IozgnMrG1ESp6m9GG5o9H/wf6SVCYCJSGBiVQFss3BKVBYmnNZjRc4toq7fxzX3B+g6Iwgxex5ehYn2b9q8+IOjbTz4flp8MCXnyKKUYHx/n7t27nD59ekcFISS92MYvYRvvpui+ShDn0IqSizhOO0pBPG5R1t9JxbyHq8bQRApPLhM3gxQ+lnebqPEic66JTSCsSSML6BSq/pgKF7/SQkwcZlZEmLEXWbBHSagObFWiNxa4vsWNIMVR0VulM/ICL2eXsaViRa3QrrVT8At0yA4kkj3JwMWu1WylJ9JH2mpjzKtgyWBcz7iBtnHRzgIwawVayGlrhaOx/bwyX6DgOIwVA9/KyUo28LEsB+vPW0HFn6xT4Ux8kJkVKzD+VCeuhBGc555EEgkcaGmj7Llc6OrDTUsmlnJMZnJrznct8PPkyZNcunSJoaEhbNvGsiyuXLnCgwcPWF1d3bGZ/UloNGvb58u/hu/8BDoCgWDVb8dROh8rfQGfzB+n5NpoyqBktXKkeR8Hegc5cuQIe/fupa+vb40gfevWLebm5rbt0vYmms6fGm8bQVMpxejoKA8ePODcuXP1Wqg1dpoKaf265XKZK1eu0NzczJkzZzAMY9ttqkIZObqMticYOJQZDDzOfAYxMEQuHwwCer6C6hlE7+3DWS4ixUPNnIokyd1O42eLgYAJiJpAU3Gwe/aSnZDYixVifc2UR1cwWmIopZMdtUlfXmu6b3y4m5qaGBwcxLZtbt26xZUrVxgZGann/3zabLu608u/hlJBfjNV8tCUgyaqFX+0IPWoq/pQWj+ucR7XfBEvfgE/fggZ7am3I+P70HDr36PWMpVCG1LpVEQXmrWCQKKcJpTegpYdRXMyuF1/95H9exOdtkNCQjZACIHjOLz++uvYts2lS5fqaWq2i6ZpeLILM/F9CJFEyjkQAygFkcgomvnlLPlliu7rIFMoCkSNwDpVdq9iaoNo+mlWvA5Kfpq8ex9DNKOMLO2R00BgdUMJzGQ3DxyDJWeWvugRQBEjECwLXmCRXLRGaNI7cWQ/0xUTS9oMxgMlRLwqxBqRQAOZdoPIdE8aXE8LruWmiWMyXl6kM9LCTGWFgVgHi3aWfYke0m6BQ4k+UqKPxaLBqlPhaEsXWbfCXrOFrGtxpLmLZbvE4aYO5ioFTrX2IEsmCxmbB7k0HbE49zKrNBkmD7JpdCGYLVZrojsOp1JdeDnFYq5EKhbjz4ZHH3n9mpub2bt3L4lEgnPnztHe3k46neb111/n6tWrdeXIVtrBJ2U6z5X+E8r9b0TQiOBSlFFatBKvWO/gM/l9CAziepKpooEndb6274U1bawXpPft24fneQwPD3P58mXu37/P8vIyrus+sh874XmzlD1TH83Ngm52UlbS8zwcx+HmzZs0NTVx8eLFDS+KruvbjnirRZPXWF5eZnh4mJMnT9LW1rZl/9fjTy4CkL+5RMueFG7hodYwP1vE1Exqe/NsHaOtCShRGZ0j3tGMLBTw/Qi19wIRCXxx7MlFNNPAppnylI/MraC3xnFXCiAVif1tWHM5SvMOS38xQcdLgxv2r/Zwt7W11R+CbDbL8vIyIyMjW1ZQeFy2c73l2FXEagYzkccptxNrSuO7OpEWC+ULbK8FliPQ2YuYuBckbe86hUjfC7bvOouXOItevoHSWh62a3ZiVlYwgVLyKJGoCQRv7Xp+hGzTcdrUHfz4ADL16NQcb6aJIyQk5I34vs9rr73GwYMH64m5YWd+5DUFhmEcJtn0MxTy34bgDpp2EVfTWbU/h6GlglrlagBFhop7lYh+BFfO4IhTTFauINCJ631U/Pl6vfKSNwtKwxUrYLyL6+V7DMZOUrayWNUyuVkxQ4QkeW+R7sgBKrKIL49yvTDMvvg+ANJOGhQs+otERIQFb4GUmSLrZdkbOc/HFic53ryHu4Vp9og2xtUq/bF2Vpw8HZFmZq1VmowYKaMJzUnx8tIsL7RVs5pUUxIZWjAmx/RATGgyo+xPtBOrJLm6OseF7j5mSwX2t7Tx6tI8Jzs6ubq8yKn2Lm6ll+k3o7TpUebni0xaOeKGwVQ2T7Zi8e0vbZ3fWQiBrut0dHTUc15blkU6nWZiYoJSqVRPst7e3l4vftF4zR9L0FSSSNPPIrybpHQbHZ9Vv52UVuZ/F76ae5U2FBJPCZbLMXQhudi+j9aqIgneKCQ2VoYbGhpCSln3V52aCly7ajXOW1tb67LIbuaV7ZQzfrN4roKBoPEh37prhmGQy+W4cuUKhw8fXjOwrGc3Ppo1LWkmk+HixYtvuJG326Y/EZhvlePhRXqxpxbry0wtht6Wwl8NBhl/ZpmyrGYY8CVaTx+yXCI/UsAc7MUZmcKaWESPGCjbQT9zjMLHF4kc7URmKsSH2inenCU21IGfq+AsFWk60I09n8deLRPt2LK84RuSp6+vUd7S0lLPKbbrGuUNbEvQfPl/oePj2UlENYWQxMDJx/EKMeKtJRCgzIfXSLjZh//n5xELS/gdR1D+w2smI/3oVaf5RHocv2ttVaqoH0cqwbQ6zWQ1e0F7e3t9EFjTx106bYcazZCQJ4Ou67z00kuPFYBRm4M8z+PevU7a2r6W5qbPUaSM5ZVQVNC1fbhyDqUPo6uj+OI+mmhl1TfIO1doNg5T8B4Q1Tuo+PPk3LvgJ7BZpklcYNwvYVb9MZedoD55xp2ly9zHsjtBq9jHshrB0Nq5k3MxtQUEgqnKFC16C6vuKimZIqNn6knZuyO9lNwuFuxAqHareYILBL6cc1ag7ZwsL6EhKNsO8ysRRuU8ETTu5ZeIawb3CyskNJMpp0hU6AwXVogIDU1qzMw7rBoZBDBXCuasdLXSnV2Nmtc1DVPT6FExrj9Y4txAL0vFBc70dXNjfolUPMbw8ipHujYvmLLZi0EsFqO/v5/+/v41SdZv3bqF7/v18bmmENqtoOn7Hor30hKZJiYEjjKxZBNFGeN3Cl/JhBVHIDFFkumChisd4rq5RpsJW88JmqbVBUt4WCZzaWmJBw8eEI1G0XWdeDy+I8H5ebOUPXem8+3m0lRKsby8zPLyMufOnXukkAk799G0bZvXXnsNKSUXLlx4g5BZW287gqZXFTQBnLzEbX2oUdPb26ksu/V0OaIzhS8e3iD2bAZjaAhnpYJXDFTrynKJDPWjd6UozAeX0M8ED7tXCISwSCqONZ0h1t+M2axjTWWY/6ORbR3/emoVFE6fPs2FCxfo7e2lWCxy48YNXnvtNWzbJpfL7drMvtUD5F3/LFpmPljPddGT1WNWTWDpYDxMKyXcwGSj9AiiGLgLqEgLWrkajLU6B3M5/EQ19ZdsqBQkTFgpobRAeFZGksjyPWTiJN3n/jEvvPACLS0tLC0t8eqrr3L9+vU1ZpxQoxkS8uzZ6TO40fbFYpHLly/T1dXF0NC/I8cQBe8+WnVstry7xM2zAEhyGNolRqwZNK3mshWMhVnnNnF9EF9ZCKubmPYCY1KS9nIs2qO0Gr3YskxPLKg2pmuBgiWvFknpZ/nU6jRxvYm8l2dfYh8SScIJlAWJSPC35JfojQ5wLye5n88wWpojrkUYKy3QGWlhRRXpj6ZYcfIcSPSS88ocM/bxufky/U0d2EgON3VgS58BLY4tPfZEmrCVz6FkO5bvcallP6+MrXCgJVUP+pkrFTjQ0sZYPktfsonh7CptkShL5RLHjE6m08FclC5X56bq/NAUNfmz4S0z4mxJLcn6vn37OHfuHGfPnqWtrY2VlRVeffVVyuUy09PTlEqlHWm0PXeFQunriWgz6JpORcbJ+C2s+O38r8y7mbaaiAiTiGhlLK8w0EnqEc63HKI9sla426nyoVYm8+jRo1y6dIkjR44AQezJ5cuXuXPnDvPz89i2/ch2nrd55bmLOt+OQFjzwfE8j56enqAk4RbsRKPpui737t1jaGiII0eObCoEbadNpRTu5EL9e0FKvLwJenDqPVtgzWSJ7A9S5viJFkr3F9CSwSDipfPYbnDz2pMr6J1twXqOpOKlKN1fhoSJv1Qi2t+GNbGK2dmEPZsGDaI9TVRGV/CKNvkbC48dYa5pGm1tbRw4cIDz589z5swZhBD1RLY3b95kdnZ2R4l5txI05csfQcgKQgEodKOMlW1Dd0oIIfCrKZ6UpteFS9k0gKimBpGJ/of7aupHlDOoqRX85DFE+WE2ADsygJafx0+crm63H6F8lGpBJfoxTZOurq41g4BhGExMTHD58mXGx8epVCpbDgKNPG8DQkjI5zuFQoGpqSnOnDlDf38/QkToafkhQMP275MwLwDg+jOgmin7A6RVM55ysOUqoFHwRmkxjwEK3zIRyqQkmrlbKZJx5+mNBqmQknqgycq6C4Bg0R6jmT5KzgDLXgwFdESqZmM3GFOLZhGBYMFfIEaMiGhlutjMWHmVw8l+bOlxsKkPiaI/FuRrThnBGBPXI/T5/UzlfDxAVM3ksmomNxPBXOpXh+NSucwer435lSCISK8KTbWgn1QsWH8g2YynFKfbu9GygojSybsehzvamcjk6GtO8mA5TXMkwng6y8cePFrQ3I3Zu2aJO3LkCJcuXapnmxkbG+Py5cvcvXuXxcXFRwa82vYYxfK3YKgV4poPUiMiHAoyzh/kvpy0H8dVHspPsFDSMYVByXfATvLX+95Yy/1x82jG43Gam5sZGhri0qVL7NmzB8dxuHPnzpp8pOuVc7uZV4QQXy2EuC+EGBFC/IsNln+zEGJZCHGt+vn/bbft59Z0vhnZbJbbt29z6NAhotEos+vyU+62XQhu7pmZGdLp9JameNhe3k9nbhXlPdxvTE9QWVwmcnE/zsgY5cksAFZGogH2ioNyffT+QeSDB+ipFuz8w8ukt6fwV7IoEaGy4KA8SWSgHffBCkZ7EnsuS7SvleLNWRIHunEzJYz2BNFUC16+Qvpzc3S8Y4AnhWmaRCIRjh8/jlKKcrlcL8fpui6tra11M/tmmoZHDSru5b9Ac/I4bhtxcwVPxXGWohimjm4G59Vsq2ogm/sR5Wq1n0jDQ6Y9TIiuIikE8wjp4S/YaG3N1ArmqGpiY2ZHkN3dKFcgCPw7NyIejxOPx+tmnOnpaVZXV+u1ctva2kilUo/MW1oqlejr2zySPSQkZGds5Dtf++1Rwovv+9y5cwfLsti7d++aiTphvkh74ptIl38d2xtB0AyY5L1TpLlBxGtDI07FnycVeYGMcx2vmhBdGUUs8RLT+ij9kePMOXdxZbBs0X5AXGuh6K/SGz2MJS2ypV7G3Cn69UCIm6nMoKMz786TMlJkvAx743uZqczQ6h/kE0uLnG7ZB5WV+vEVvEq1/SwQRJWnjCRTiw4Tlo3QBE16hHv5JZqNKMOFZdrMGMOFZVJmnHEry5DZhFWKkrNcKl6euNC4t7pMRAiGM6sYQjBVCNyOFsslTqe6Kaw4LBfK9FRrmjdFg7G5v6WZ+UKJkx0prs0vsj/Vxu3ZZU4OrA3afZJomramlnk+nyedTjMzM4NS6g1uUJZ9jYr1A8SET0rLsuq1kjJLXHeO8ZHsJUqeiykMlNfKpCWRyiauRZBOkgOt3fQlmt/QBynlY2vYa8JqLZaiFizl+37dv3NiYqJuhvc8b8eCpghybn0A+AqC6j9XhBAfqeZjbuS3lVLfvdNjeMuYzpVSTExMcO/ePc6ePUtPT88TSVlUw/d9bt68STabZWBgYFu+h0G900drNPO35rA7HkY8uwuBX0v+QR5zsA+/EGi/KpNp5NAA7mywvDyZQWkaWlc3xftLaK1VreZMBkyD1VGPyGDwtuqXg/Nlz+dQgLtaJLq/GzfWwfRVyFdSpOdN5u/A7Kce+oc+aYQQJJNJhoaGePHFFzl37lw9d2ctYnCjfGKPmgC8Vz6O9EBV7wmnHCdieDjlYHslwdCC4B1iDQ+6fKhRrVX9CX5vuF7Rbvz5MjIWvFBoVrCekB6+6kVkghRI/sDWec+FEEQiETo6Ojh79mw9WjKbzXLt2jVef/11xsfHyeVya469XC7v2JdmqzfP6jp/XwhxRwhxWwjxmzvaQUjI24yt5oqaqTyVSjE0NLShAqE7+T3oWge+yhIxX2LS0ckyjKaacGSWtkiQe7fizwM6ZTlBk/YORr1mnGoGkbQ3i4bJqjtNR2SoWvUn8MkXpHg95zPpLWJgMGfN0R3ppiIrdBOMUZ2RwG9ex8RzhnhgBdV6xsuLGOiMlOZpMRJMlpfojbaxaGfp1VpJijheupVhq8LxVC+29DnS2oWnJIeaOvCV4kBTO75S7G9q50iyi1g5wXShxKG2dlwlOdbZja0kh1pSFD2XwUiM5UqZA8lmuvU4lRWXu4srdCbiDK+kiWqCsXQWTcBCIdCIVjyPPa0tJGyDP7v+YNPr8biBPOsRQtDa2sr+/fs5f/48L7744ho3qLvDP0+59F5MfEzhMuf1oAvFX+TP8bvp87hSJ6JHyFkJlqxAM9xmJlnKCoqOz9/eu3HRFt/3n1ploMZ8pLUymYlEgg9+8IN84hOf4H3vex//+T//ZwqFwnZ2cwkYUUqNKaUc4MPAex6r4w08d4LmRgOC67pcvXqVSqXCpUuXSCQSm667k3ZrlEolLl++THt7ez3n2nbM7FsJr67rMvHZm1h3injdKYzONrxc1V8lW8GPda5Z33YeugB4mRKRfUMUJy2UL4n0ddd/Nw8fwl60cFYDYcqbySNSMdyVEvH9nchkitX5OCuvptFMHbPJIH8/C7pG+laB8sKbU5Jyq8S8d+7cYWFhAd/3NxxU7Jc/AcU80pIYMYVVTqH7Qd+FFpx3P9GFUB6O2YYUzbitZ3FbziJpQTbtQwmjbk4HEKWH5b6VMhBWCb/Ygqe3YBYbkupXfPxIL7JlH6rpoen9UTQOCLVoycZBIB6PMzc3x+XLl7l58yaf+MQnWFlZ2ZGg2fDm+TXACeDrhRAn1q1zGPiXwBcqpU4C37vtHYSEvA2plaHciLm5OW7cuMGpU6cYHBzcML0dgK4105P8foT+hQyXb6GLZiQWERlYiPLuMDpJLH+JiLOfqP4SU76gIissWg+IyCSWzNMXDRKvmyLwLc+48zRp5/hUepKU2Y6tbHpEVTlRHapFNBgf5+w5BqJ7uZpxWHU8lv0CexNdFL0KR5r78ZTPvkQwV3RH2wBochPcWPKJJgMNl1et2FPyAhNywQuUHbmqaT6qItyeypN3g/my6AbrWV4QI6BVcxe3NrcQ0TR6SHBzbIWo9INa6U0JHN9nMBknZ9kc7epkNl9gb1srBgI9I7kztcRn7k3ivwnp8zbCMIy6G9TRk9fp7/kddBFc92UriZQ+H8+d4BPZY/hKx5IuZasFW5pIFJ6vyGQ1mowYL7T3cqA5teF+nkQJyu1qRSORCD09Pfz4j/84J06c4Md+7MeAbQdEDQDTDd9nqr+t5+uEEDeEEL8rhNizwfINee59NHO5HJcvX6a/v5/jx4+vuWhPQqO5uLjItWvXOHHiBIPVBOlCiG21+yhBs1gscuXKFSKLwUhRXtDRO9dG2ZVXQW99KGQ4OQE9D2uge55JZS7QslVm8yhAGDqlbPB2XJnOEulvAwV6ZxNoAtncwexn8kQ7E3hFl9ZjKQrDGfSIRsu+JKWZIqO/M77lsT0N1ucTGxwcxLIsCoUCN27cqEf41yL+3b/6JNIHDRtZcVC2ixkPBr1Is49SoFJ7KbsHkDMSOTmHHB7Dn80g7z7AfZDF9k7jNZ1AGfHAbF5pqJZVqSYOzixS9A+uqecjjWaUFcHve8e2j+9Rg0pjrdxLly5x4MAB5ufn+cxnPsP3fu/38u3f/u1MT09vuO06tvPm+W3AB5RSGQCl1BIhIZ8nbNf3v1aAY3l5uZ5vEx6mzduItvjXseK7KFziRiDQWdooUa0TTxURVi+aasKO9XOjPM2yM0G7uQcfj6QKzMQlPwPAoj1CZ2Q/GbeXnB8Ina1mUDiiJAMNYM7IERER5uxAu9lhDrFitbPilOmPBnNFs1H156/6pKerNcvnrDQDsp9XczYCjeHCCk16hPu5JdrMOMP5ZbqiSUaKq/REm5gu57iQ3MunR+fpTjQxXSnRHY3zIJumO5bgfjZNezTO/cwqzWaEpXKJI0YHI0sFNAH56lS4WlobhV5zGtrf3MrY8Ao9LU2UbZf25gSvjc9teJ6ftEZzM7Klf4vwPkSTJmkxKrgixkAsz1+VLvIX6X3kbAu7aLOcjTJTKlHxXJpEnHIxSsHzKHoOX7vnyKbtP6la5ztto1Kp8MILL/Bd3/VdTzIG4A+BfUqpM8BHgV/f7obPpUbT87y6qfzu3bucPXt2w5xQj6PRlFJy//59ZmZmuHjxIq2trWvW3a5GcyMTy8LCQvCGfOwE7nQwqKisiy0b/QYFhdEMek/w5ipMncpECU80aDVllMhAIJw6y0VUbxsMdpN+fRk9GQibRipo009bmIf2svi5HOiC8lRgThYo/LJH24kU5ZkClfkSq1dXkf7jBQU9Lo0Rg83NzZw6dWqNKWP4tz6MzGbQdQepxVFSR3oaQoDnavi+QcXag8zaaOkVvEgCUQrSd9DcoCnWYsjhcexcJ17L0frP0khA4WGQlioJ7KYDD7crFRHpKbyed277mLYbdV5zMfiGb/gGXnjhBT70oQ/xzd/8zfWJbgu28+Z5BDgihPisEOIVIcRXb/cYQkLejhiGsWb8r1mxWltb6wU4GtfdbPwXQuNoy3cAkHFuEaMfhEeEYBw34wZLcj/DlQfVBOwQ0YIxvaDNoxMh6y3QHTlAu7mfrDPIRGWVStVSM12ZxsQkK7L0RHqwlc1QfAhTmCS1fXxiaRm3Vv/cDcb40dI8UWEwUlwgZSaZsVY5GO+jkouzahlU8Dnc3Pn/svffUbKt6Vkn+Ns2Yoe36TNP5jmZx59zzz3m3jKSpkpdCCGQStMgQA0tmGk1zWqBxII1dNMzUz2DmrVgmGFYjSToxUwPRoMRjJqWQMiVqlRSVd063rv0PjO8j9j2mz/2zow8PvPcW1WXSz7/RGTkji+2fb/ne83zPhMuPxbP+q0koykAJqNpRrwcds+nBKNR3xaNRGP+dokknhBMJVPYnsc72UGoQliou17L7VabY5k06+0Ow/EoGz2TuK4xX6lyQo/w6MkWnge1gIhKwG/efbV4+7cTnudRbf40svtrxGULQ+rR8uIk5S6/1Pgit7pjGGqYeChBwUvioaK7EqLh8nSjRbtnElVULiVHOJsZfO3vfLtC569Dp9PZV5H0HqwDez2UY8FnuxBClIUQO5Wu/y/g0n4H/9gRTVVVsSyL27dv0+l0ngmVP4+37V++I12kKAoXL158a33M53M0hRA8ffqU9fV1rly5glLsIuw93tm5LqEj/ipYH8nitmwqt4touQT62ADC9DDnaqj5NMgStdkWRPrkVNGjNNYEwvZwsv4KuL1URQAialBbFdgNi8TJNGaxS/x4msbjClpSR1g2ve0uqVMpvLbN+m+/fCX5NviwlexCiBcqugeW53EdBRmLXk9DlgSEVISArpnFa0hIzTpS0w+Fu7FUf0BF3Ts4AFKrgVOWsRMXEJKMiI4iif61kzttvEIXoUYQWhSqG4hQDHLT+z6Ot+3gkE6n+cxnPvNMM4APCRWYAT4H/DjwDyVJ+sgGP8Qh/kPD3tD55uYmd+7c4cyZM4yPj7/gOXu+YcfzGDS+l7R+HhBoQfOHpvsEQ36fe702YdUnHjsC7Num39nHkUyyyhH/N6RBvlVrs9Rb8/MxzQ2fWHomOeEvlONB60lbuNjOET6obKKiMN/aJKvHKTlNRpUUXdfiWGzEb0Fp5BnWM9RKCnPdHknDj5iJ58LlNcsne8Vem6lIhkrFY7ZcZzPQxtzq+K+FIAe01PVf62aP8+kB2iWLcquLG9hXPSBCybBfeDmciOMJODmQ42goRUSJUutajKWiLJXqpA2dJxtlrs6t0bNe7Ijz7fRouk6PRutPo4k7qEh0RZiCk6XqRvhntR/hQSeJKRxsF4qdCCElhCNLJMJpLDlBPuqTbqdqMVyzdjv7vMwL/p0Mne+FEOKg37kGzEiSNCVJkg78SeBX9m4gSdLeqtUfAR7td/CPXejcNE2Wl5cZGhri9OnTbxQ73S/J2dm2Wq1y/fp1pqammJ6efuk+7Jdo7t3Osixu3LiBJElcvHgRTdNoP+3rZwpdob3aoFXRQZGRA++VcAQkswg9WH0IIJElNDGAWepRe1gAwyfCwlVw2oEMheN/5tR6OONxCvc8RMy/seRAOkmNqgjHIzGdpPG0RigXQo/IVB9UWP7VfYVpvyN43qi0fu8DpE4LxVDo9HKoQd8kgaBezeJ2BZIEXjQBnSD8re5ZLFjt/vtOtf++28KdXcA2ziHkfsqC0Ay0VgW508IxjuPFxpGEQIxcAGn/j8jbrDxbrdZBQxtvXHniezl/RQhhCyEWgaf4xPMQh/jE41Whc9u2efDgAdvb27z33nskEomXfHt/kbLjif8S8AmmZA2BcomiiOHiUrXXkVGo2usM6FMIPJJaEGb3WujSBX6vskhKS9NxOxyJ+ORTBAWOtuYTr5XeChPho9woW/RchZbTZSY+godgNOxHunTJL1q1PP87lulxf8tjzbORgSeNIiFkZtsVklp4N1w+3yozaiRIqxHsusrDcpnJeJL1dpPJRIq1VpPRcISNTpsj8QRLzTpj0TgZxaC63eNRoUzGMHhaLBPTNWZLFXRZZqnq90bfarbJ6hpySzC7Ut7thZ5N+LZuIp/G8TzSYZV/9Gu/w4MHD9jc3Hyt9NBHActcp9n+0yhiEwUJV6h0vBA9EeJ/rf9veNoLgQBDSrLeDtNwLTzPI06SQsOj6zqYwmVITTGZHuI//9znGBgYoNFocPv2bW7cuPFM0ed3I3T+No4fIYQD/AXgN/AJ5C8JIR5IkvTXJUn6kWCznw6KS+8APw382f2O/7HxaAohWFlZYX19nYGBgY9c8kUIgWmaPHnyZLca+lU4KNFsNBpcv36diYkJZmZmdg1dd63e//2MAR60lpuEZiZxuv2boXKnSHcPH2o8KGAqgRfXFhiTfjGKaYYIHwm69SzV0Yd9QymHsnhd6K50EBLUHpWRDJnG0yqSLmPX/STvxKkMrqKSuDCA1RPUF/dUY38X8TzR7P3O1/B6DnbLhW4PXe/iODJmRUX3LLSoT+as8B5Pd0AuhSRB3Q+JC82Ahu/x9CQZ6n7Fvbe4iGPFEAGJFPHR3fxMd2keV/iLAG/swoGO421DHPsMme/gjStP4N/gezORJCmHH0r/8ArJhzjEf6BwXZcnT54Qi8V45513Xtt5bj9EU7dOoPamUMlTtY7wpLtCwZwnJEXpuDWGwn7Y3K/dg4K5QEwMs9KL0nR1BGJXH7Nu+vNETasRkkKUnBIZMgzpxyj20tQdk4weeDeDbj9bpj9hrDtVQpLfy3yScb6yWWckmqJm9ziVHKTr2kyFk351eRAuPxJLIyMxEx7i+mKFTMi3oznDf80G2pipINKXM6KEFIXj4Qy3Z7cZTcTxhGAyk8T2PKazGTq2zfGBHJVuj+P5LDFNI9GWuTO/RT4eYXarQiyksVisocgShUZgrxWNkhdmYmIC0zS5f/8+169fZ2lpCcdx3roJyMtgWrN0ej+JLlUYUGuoeMTlNm3P4F/Vfoi6G0NBQSHGQkOgSyoxJYTdC7Net5CAjG4Q6moU6l2+/8gkiqKQTqc5duwYly9f5ty5c0Qikd2iz06nw+bmJt3u2xfgvs28IknSgT3CQohfE0IcF0IcE0L8jeCzLwkhfiV4/9eEEGeEEO8IIT4vhHi837E/FkTTcRzu3LlDs9l8oxfzw4zveR7vvffeG3MXDhI6t22b+/fvc/78+Rd0N9e/ViI85X/m7ZFLKt6u0630V25aOorp7vGwOS7lSv/3W2st1FyM0t0mnfVO/3vZBJHjgxSvdpDCCm7dJnEyC7YgciyB23aQx3S6kkcvm2X5hsnT32zSbimsXGtz+/+9/MZj3A8+bIhjL9HsfOsWot1CeA6K7CEkFc+TaLcHCYdtPE9Ck/1k90gi8AoDoZ5veHt6EimoohSJQaSdpXRiCIKwkUDCnVvCSfjC7ELu3w+SALclI5AQoxcOdBxvs3o9aC7NPleevwGUJUl6CHwF+D8IIcovH/EQh/hkY2tri62tLYaHhzly5Mgb7dWbiOba2hoPHjzgZPanmbMjbKurxJUctjDJhyYB6Dg1ALbNeRLqACltipI5TMFpIgKbtKOPWXJLDOqDWMJiPDKOLukIM89XCkUa9rPyRfPtLbJ6nIJZ50g4j4XDidgo0W6eRtefY7Jhfy5R5WBBHoTNd6rK61aP49oIDzZ9m7na8nM9lxp1JGA5eN3odpDww+VHRJL5Tf+Yii1/n2pdf7zuTsg48KQNhCOszVcxVBUBjGYS2K7LscEMja7J8eEsm7UWk/kUMVXj8b1NPEnb7fBz4cIFYrEYpmly/fp17t69y/r6+ociax3z63R7/xW6ZBKROpScNLpkc7t3nF+q/UG2LZuO20Ny42x2FGQJ2q6N2zUQrkZc05GQ6FRdcCQmkyk+f+TIC7+zU/m9U/Sp6zqe5/H06VOuXr36SoH11+GgaQRCiA+dzvZR47seOm80Gly9epWBgQHOnDmDpmn7LvDZD/a2EjMMY19EYD9E0/O8XVHy995774Xwp9O1ac1VqCxKqAkDZ88zomViCKMvh6APpancKSLnfQ+lNBjFXRbIYd9wmNst5KER8KC32SZyzPdqdpYbVDYUPNMjNOkbFymQnpAtCTWmoaeGWP9AQgqrtNd6GEcUGutN2hs9SnfrWK393/DfTuw8SI1f+12wTayegSxcf79rKdy2Tx69cBwpWNVLQXWlF0mjuP7/Q+l+YnbL7N9H7l4B9/ggWD3cp0u4mXOITv/iCCOJtziHO/5ZiPQVAPaDt1l5vkUuzX5WnkII8ZeFEKeFEOeEEP/iQD9wiEN8AuB5Ho8ePWJzc5OjR4++tI3wy/AqorlTpV6pVLhy5QpH0p8mqY2BJEgEofGytYqMSs3ZZEA/ioREWD7B16sVap5vr1a7q6TVNF2vuytjtJuP6bm0rVHumjUMWWelW2Q0nN0Nm4s9YXND1skQZW3T5kmnR13y7eJ8s4yCxON6gYiisWQ2SKoh5pplziaHaVYlGm2HjXaTY4k0hW6H48kMpV6HmZT/ejydpWpbXEzlaW9bqJ7EZrPFVDrJar3BeDLBQqXGUCzGbKlC2ggzW67w/sAw9x9tISNRbJtIQKnpE9NOkIupSDIScCQR58m9LfKpGL9zo98eWVVVMpkM8XicK1euMD09/QJZK5fL++YJrc4/xzH/Gorw55iim8YUIa72LvC/VN+h7XgYioFtJVlo23Qci5Cko3Zj1EyHmtXDdj2MXggVlZ7j8H0T47tdkl4FSZJQFIXx8XHeeecdLl26tKsrvaOtvLS0RKPReCMxPAjRNE2TcDj85g2/g/iuEs1er8eDBw92W33BwSrJd/Cqi7RT/X3u3DlGR/ffDedNRHMnH1PTNAzDeGkYpvmohHAFvbKJmxjELfYTnrV0jML1CsZRX+7CtmQQ0AqEIIxsDrthYUwH6QOyRKve94gKzTeY2nAaaadVZTtYtT6uIkdUzFIXK5Vn8ctVQhkda91GkgWpoTjdNZvYlE6j1ODL/8+rmKb5oVaLHxXaNx9jl5p4qKiG/2CZVQ8FG1X374nQSED+ZBkhJJz8OdrKOE1zgo55BKuXxk6ew82dJBbth9Z73b6Au6n0Sac9t4Vw+kRPJHzD7yqv7wr1Mhw0afvjtuo8xCE+CZAkiU6nw7Vr1zAMgwsXLqDr+oeSwtsZL5FIcO7cuV2bfyX1vwX8gp+wFKPrNRgK++nQihRCcIZr9WVCUoiGaDAkDyEQaL3Angfcd7W3ypHwDNdKJp6nY+FyLOrb/52wueP5+78TNrcsj5WKziOrTT4UZa1T52gsS83qcio1iOk5nEjm8RAcMVKcTgwR7kVYrTcZCIpMo7stJf3jiQVzS1TVOBlJIjUlyu0e8ZBPXNJB9CUf2NaRZAxPCI5l05yIZPDaHm3T5vhwlobpMD2UYa3SYDyTYG6rQi5usFSqcXFggMcPt5ElKFZb/NbVPtF8/lpGIpEXyFqlUuHmzZvcvn2blZWVF/qZ77xvdP4Bnv33CQGG3KPr6QyrZW6bM/xW4x1kKYwlHOo9g4atkFDDJNQImzVB3XLRZYWhcBypIVNudXE8l/FYgh88tv8i0R28TGA9HA6ztrbG1atXuX//PhsbGwdq3/wytFqtAzcB+Xbju9qCMhwO86lPfeoZtv6qzkCvwo5R2DvB70gX9Xo9rly58kyXn/24oV8nb1Sv17l//z7Hjx8nn8+zvf3yTjv1h33pwk7Rxc3HUJb9XBzH8n+/XVeRZYnarL/SdRZNmIxRX/VvtOZKB1mWiE7nWfmgRHIihrXdovG4QiRjsP3QJjzkG4becpfYcITedof0+QG25gVaKIxwWqSOx9n+oEz2XIrKgwZqVCE5GGXjapXmVUHi+2Fubg7LskilUmSzWVKp1IdunXVQ1H7195AlF7cLerJHx80R0isIIQhH/bC3rHiIwWlsK4b3aBZoIEZHkaoNPADNwC0GRVi5QUKD51Gqj4mKPtHfK+1khZOwbRMK6SieBcJ/JKSJUwfe/7fRO3ubXJpDHOIQr0aj0eDWrVucOXNmV8nheXmj1+H557FQKDA7O/vMeDuYiX6KsJOmp1YZCs+w1ntAx6mR0Y5wv2khANMzmY5MM9eZ8/dBgpbeQvGUXX3MkJSj0AvTdKtMGBHWzDLNQPJoqbONisx8e5OMFqNoNjguHeFrhSrHtCRzdoMjsTRFs006ZEDL9xoC9Fx/Lg15GrdXSwxF/XOw3Kz5Y7caSMBsreIXD1VKqJKE7io8XmsTVk0USWKxUkWWYKnmh9XXGv6ctd1sk4tEUNtwb7HI8SHf27rD+Qw9COfHI6xWGkzl0zS2O8gWNNomJyZyPFkpoakKS5tVJofTwfdfPk/vkLVMxnc49Ho9KpUKi4uLu/nu2WyWZDJJKvePwL5LXHYwpB6bTp68UudXmj/AB80BbGGiSzqOnaNmufRcGyFCWC2VpKpRl1tEJJ1ioUtU1UmGNWKofDo/SugjmBt3tJWHhoYQQtBut6lUKjx69Gi3hXEmkzmwQ+Jt+px/u/FdD50/fzMd1KP5/Pa9Xo9r164RCoW4cOHCMyTzIEU+L9uH9fV1Hj58yLvvvks+//oerfUH/Q40Wi5G474gPJYCoLkctKGcb6GdGsOuByRIgG3Eaa/6oYbeVpvoiWFsEQYB2kBQpGJ5aFPDdAoW1Qc1lJQGAsKjCZCg64YpP+3RWvMNVbfgE1dVk3A6LvlzCUr3amgxFVWS6NyVOHfuHJcuXSKbze6uFu/cucPq6iqdTue1N/tH4Zlr3VnEWd9GoCBkhV5Lp1f2kCQwrTCy5EAijdnQad8rIfZcHimQ6kBWEJWgb7kRRRQL9O6v0DHHEGrfuxly9lQ2GgmkRpOa8D2ZdqXkyx+Nvbyl2OvwNtWBh17NQxzio0UsFuPKlSvPkMLXdQZ6FXbk6lZWVl4YbweyrDDUuQhAxV5DRkGT82z08pTtFhndJ0RV2/dCliiRVJN0PL/aPCSHMKRJvlos0LB9O7YQEMvlToHhcIam02UmNoqHYNzIkzIH2W5LCCRsf3nNVtcnfnvD5lFFY7FV4awyyDdWSgxF46y3mhxNpCh02kxF4zQcm5PpLG3X4WQmhyME72gZbs5uMRIJ07JtZrJpaj2Tk/kslU6X47kshVab6WwKXVEYcsPcmttkKBVlbrtCOhpmdqtCWJWZ366gKTKr5TqjqTh2xWJltUqnF3QZCuxlMhbmN7719EDXB3xn1cjICGfPnuXy5cuMjIzQajXYKv0E2dhNJCFjCp0NZwBL6Pzrxg/zQXMITQ4RVxKsNDW2ej0QkFbjdFthGrZFzeoRchXsJkQUnbZtE/NUvIbLHz77aoH2t4UkScRiMSYmJp5pYVypVOh0Oq9s3/wytNvtj51H82NRDLQXb0M0d8hjpVLhxo0bTE9Pc/To0Zfqo71Na0nP83j48CHFYpErV668UtdzL+oP+h5NgQwOdLoG4dEkZtnc/V+15KIYfcey4yqEx/ri8WZLonDHNyK1xw3ksIqkSFRWg17frsAY9wloa6VF7PwQ879ZJToSprXaIXkiTmOhTeJYjPL9OnpSw6rZuD2PwcspXAHbH/R2cwWz2SwzMzNcuXKF48ePI8syc3NzXLt2jSdPnlAqlT7SHFrwDXrpX/wOwhModgdXqHiujKwH108PYUYm6NTi2IuBko8UPGyyhNrwjbiUyUGwgpdTe0XbDdqP6rgDZxFqGGr9a6Pgr0wjpRp2/iRKs0Yvnuf63Qc8fvz4lfpor8JBiGav1zuoqO4hDnGIN0BRlBfyMQ86r3iex/Xr15EkiUuXLr02vzPfPUtIjmF5XVLap/l6dRs5qDZf766joVG2y+TIISTBQGgnLUehaY7yrcoGuqTu5mN2PYsR/Dkgr/t5+x4eeS3JwqbJw3aXVaeNLims2C1yrwibn0uNMOTlcEx/X0Zj/lia7duzTCDKHgp0h6OqxrhIgPCPNRQ4aZxAcmjnNaz5441E45SWG7vh9uGkX41+JJfCdl1GEuEgjJ4jF42Qc3WeLBQZH0yxuFkhl4wwt1YmZugsblT43ZvzuK4/776NjqYsy0QjkMl/iUxsC11VEcjU7DCea/O/FC5xsxbD9hxsT7DR0ogoESKyTkSKslS2sVyXhB5iQInRbnjULQshBENKhFbN5NPTE0R07c07w4dzwOzMxceOHSMajb7QvnlHDso0zRe+e0g0X4KXkcGDXKCddmGLi4vMzs7ueuVehv0am+fF3a9fv45hGG+UxdiBWTNxu/1QbSfwKNbn2kgDz3YRUOwI0RP9rkfdinhGpJ1QCGPcNzpO0yY6kyN2aoDinQbxEyl//HUTASiGSmXTz/eMT/g3mp7wjYCR0/Esj9zZBEpKR38nw8LDLne/VqOw4LL1sPnCcRiGwejoKOfPn+fy5csMDAxQq9W4efMmt27demluzNtAXqrglitYdhgQOG2Bgodu2AgBva6BtVJHSe45Lx2/UlLOZJECcilF98gE6XuSocNR8ATdu+vY6Xd2Nd0AvEq/GNtth0ELETl+kcuXLzM0NPSCPtp+Erf3i4+jQTjEIT6JOAjRrFardDodJicnn5Gre+XY6Lyb+CItZ5qlwLO40l0hqSbpel3Sjh8ONjR/UbllbjEeOsY3ii0sT6Ht9piOPZuPaQXawSvdIjISluWxWdJ5arY5Fs/SdixOJvIIYDLmj58O+eMrkszRaJZuU2a2VKMW9CpfrvkL8oLnBOHyMook8bRW4UQyy/ZGm0KtzWypgqGqrDRbhBWZ9U6PsKqw2uqgSRJPCyVOGVEePNzEcTxWyn44fbPmR+oqLd8z27P9OTSl66w/LaMF4eZULIwQMJpPYjsuUyMZWl2L0XySWw/W9nWNXgbbXqfV+QlUscmA2sCQbQzZRVdk/mXzh1j0Ujieg9uWWNwWlNotKr0WumdQbUJKC+MJCDsa9ZqNISukQ2HClkK90iWsqvzI+RNv3pEAH4Xo/E5a4PPtm3fkoB4+fMi1a9eYm5ujUqnguu5bhc4lSfpBSZKeSJI0J0nSf/ua7f6oJElCkqTLBxn/u5qj+bbYewElSeLhw4e7FWpvEng/iEezVqvx4MEDTpw48VrdzedRvlOmQ4qQ4YDUD5UDNIoe8mAIb9tE1hWqT/z/ZUYjOD2HxqJJF5vsTILeeoNOHTy5v5puFyxMJ8gjDFZWva0eseMRas0QStz/rL7UBgkqDxsoYZnqoybpcylKVVi+Vmf802lqK11GzieobLX4+s8v8Sf+p34l/MvOSTqdJp32t9nJjVlYWKDb7fL48WOy2SzpdHpfZHwv1K8u4poymmbSsdMYRh3PkwhJHerNQSIpD9ogh9UgD1NFVEr+OYjFEbWdPNk9BNDuh8eF07/mVh3U3Gm00kOIJqHcJ9jCU3HT02jjJ5FkmVQqtRsusyyLarXK2toazWaTaDS6myu0U+F3UAL6cUzaPsQhPonYT47mjpbz5uYmkUjkQDb/ZPz7+cX138HDYzg0zKa5SUIkqFMHA7Bhw94gQoSkMsFmV6Xt1jkaTbJtVukFgus7+ZhbNMjpCUpWg5PKJF/dqvBuepRidYNUQFidwN4Vuv4cshCEzRVPZnvbYdbaIhc2WO20GNTDbPc6TCfTzNWrnM7meVguci47gOJJKE2JxXqN88MD3N0s8M7QAHe2CpzKpnlUru5+fmF4EKkHXtuhZbY5koqwXOswno6yWvUli5aKNUYzCTarDT49PsLdW+tEwzrza2XCusryVhVFltgo+c6CeqvH+EASqWbza7/5gMvnJw5M0nrWA3q9n0GTPMKSRdVJouAwZw3yO63PU3UUIqqHokR53LMIGSoRT6LbkZhvNnAkCKkaw0oSyxQokkzNdsiZCq7tEdY13pscJRF0PtoPvl1dgSRJIh6PE4/HmZycxHVdqtUqpVKJX/7lX+af/JN/Qj6f5/79+5w5c+aN5zF4Ln4e+AP4zT6uSZL0K0KIh8/9bhz4GeBbBz2O77pH860QPFjNZpNSqUQmk+HUqVNvvKgH8Wh2u93dPuuvMziSJL1AMEq3y1SftpGGBolMpGAPty3PN7HtOJIiEZ1M4fY83J6Hmk8THk+CJyE8gRSLo2cMCncblO5UCI/4KxQ5pO4Sz/K9OlrKf+9Gw5QedyndraMnVTqbPTJnktgth8y5FLETSWqOyuq1OgOn42zdaaDHFRRVorvtUZnvUF/ff+X5Tm7MjkDtXu/fzZs3951P0ry/ilzp4vUscF2ctoMsebiKQb2eAdeGtm+QCHIxlVwWdhYM8p6HqNMn9F69svteNPYI59suvYdrOANnIPHsdXWbbcyn64jRF1etO/pop0+f5r333mNychLHcXj8+DHXrl1jdnYWx3EOFJ77OCZtH+IQ/6HjVUUkr0uB2dFabrVavPfeeweW2Utrac4nzgNgBLq8RbeIjEzBLjAUGkKTNELWBL9b3N5dEq90iyjILLS3GNBTNJ0u0zFfgWU0nCVnDbPWEAgkyoH9e9osokoyTxoF4pLKSqfGZDRN3erx2dQxvrVQ4mgy44uqJwJvp+o7IFKBGHtYUZGAvBLh4Vxpd4pygtC1FdhXO3h1XI9UOETcUXk4t40SdJ+Lx337FTf8xbbs+oQ5FVKYChl4bRfH9ZgcStOzHI6NZmm0TWbGcxRrbY6NZojoKkZD8OjxFksrFcrVPZ3d9oFW99exej+FEsw1NTdOywtxvz3KrzY+x4bp0HK64EbZ6CjE1TACcN0ILTdEKh5nOJbE6GqsbtfZqlZxej0ypkq7bdK2LMKSwhfP7d+bCW/XOvJ57CfvX1EUcrkcx48f5yd/8if58R//ceLxOD/7sz/LP/2n//SNv3H16lWAOSHEghDCAv4F8MWXbPqzwN8CDlwW/10nmm/lWlY1Nucec+/ePQYGBvbdI/pt9DHflI/5fL9zgPJdn+RsXm8804NbTig4JY/GQpf4uRHkSD+8u3W1iuX2cz9KtyqEjw0gPPxCoNxOSCWECHJqPNsjdiyFltLYuOkQSqm4pkfqpB9qV3T/8nqGzv3fqeN0/f0MJ1TsjsvIuQSbt+tEBmXspsvX/t7ia4/1decglUrtdkc4c+YMuq6zvLzM1atXefToEdvb29j2iz1t1//RN8EDSVOwbRUpEkIIieJaCA2L8HiQBiGBV/a9mHJszzXpBh0mZBlR9f8vIjEIRIhFyEDU+22XvKr/vnt/FXtP+29XUfGKReSBYeTwm6/5TuL2hQsXuHjxIul0Gtd1n0kraLVaryXah6HzQxziO4PXORn2ai2fOXMGWZYPFGrfcTZ8Pvd5AJY6SxgY9OhxxPBFvRNqhkpvgHnTL/Sca22S1mLU7TYzAbEcCqcA8BAkRJiFzR73Wh2W7SZxNcRyu8qRaJqmbXI6OYgrBENBkeNAOM5xbYRKwyfTvYBUr9X8uagUEMD5WgUFiZVmnUvxEa7NbmCoym4rySelMolQiKelMnFNY6HWIBUO0bZsBhyDm083iRs6Tzf9Tj9zWxUMTWWp3EBXZUpdh0w0jNT02NjosLrppyaV6r4TYKev+Y5ZHIxHWblbIBH3w+kD+Ri/9dXHu+f1TWh2/jme9TcJSw4JpYntKYyoZZbtcf556R3ajoShhJHcNIstl5rVo+c6RNwUjq0RkhVs18NpySiSzlAqyXgmi9SSaXcdzG6PkOUwE4qgS96BolZvo0LysjEOSlY1TePzn/88//Jf/kt+4id+4o3br6+vA+ztSb0GPKMHKUnSRWBcCPHvDrQzAb7rRPNVeBUh9DyPR3ML1NaXuXLlCoZh7NsgvMl47FSsx2IxwuHwvi7wy8hr+U4/76+84qJP+yQxMdXPHV37ZoNuY89NK0s092pleoKuuYd43q4QnUywfq1J8U6d8IC/Mm0sdZBHElhVj9QJn2C2N/0E4dK9OplP57n378qkJg227zVJjofZul0nnFRpbvQQHsSGFAqPWqx8UKVd/vC9ZnfySc6ePct7773HyMgI7Xabu3fvPpPrWLm1hrlYQMOk2wshuw6S1aXSzBMJ2hBrQY6pkk1Br+frZ6oG7shpzOQJ2uUwNXOEbuIUdvo4YvQ4cq7fvlRK5fpWLRJHNBq7/+uu2ZDznyczkgJPoEy9vT6aYRhcuXKFU6dOoaoqS0tLXL16lYcPH7K1tfVCH9+PYy7NIQ7xScB+c/83NzdfqrV8EKK5Mwdke1mSbhJP8hiLjgFgC5vx8DTfLDWpWjZV0eFYdAgPj3HDj6h4u52CykiAZbtUajGemh1OJPJYnsvxhK9ykg+6/uwcSdOzGTWSVKsuD7bKPKqUMBSVx5USCVlly+oxYkQomT2Op7JUzR6XB0dI9UJggum4HM9l/VaSuQyu52tiup5gIuFrZJ4bGKCx1iYVDuN4HkfzaWzX5ehghp7tMDOUpWPaHB/KkgiHOBZKML9SYyQTptq2GR+Is1FqkY3rLKxXyMTDzK+XuTw5xINrqxghlaWVMrqmsLZR47e++nhf577e+jsI+xcwZJe41KHqphlQ6/y71qf4jfolECEsYdPoGRS6EFVDDOhxeu0wq40OVasDAlJ2FFXIOEJg2S5uzSUdiaCrCiOpDCErxBfeOcLS0hLXrl3j0aNHFAqFlzpO9uLbFTp/E96irfFrIUmSDPwd4K+87RgfS6L5qnyabrfL1atXiUQinPj055C3l97KILwM1WqVGzduMDMzw+Tk5L49rc+P2Vpr0yv6nmUBVOcabN8VyAM6QurfMLIm02r3cxkTMymKNxsoR/wVqjEUYfG3y0RGfMPimh5SLolwg0rzMZ+gSKpMo+5fxmYQ+q4vtkkdj5M+n6LZ8Y8jMep7T5MTEZyex9DZBLWlLiPvJOhsuYx+bxIvJfObf39+X8e9gzdJ9EiSRDKZ5OjRo1y6dIlz585hGAZra2s8+Xu/je1JdCwDTXHwhITtGSh2h7AehE+6vgdASSVh4iRtc5DmbJPmrU3suou9UUWqdvEshc6DLRo3S7RrCZz8aUhmkEJ7qrpT/U4/QlZwtgt0NgSEo7hBOoIyeexAx7+DvSvPvZIb7733HmNjY3S73d0+vvPz82xublKv1w/k0dyTS/OHgNPAj0uSdPr57T5MLs0hDvEfA3a6Bm1tbXHlypUXJuaDzisLCwssLi7yheEvAFC2ykhICC/J47pEze5yNOIXgoZk34GwI7w+19okpUWp2E1OqpN8a7NDSvHtdUT17VJ9R/qo6etdPm4UiKshdKGgtSM8LJY5mcnTcx2OxRN4CGayPpHNBxGaRCjE8VQWra2wUuoXNZrBce507mkGlcxN2+ZcOkN5vUXHdGh0/M9bpr9g7gbb73hPo5pOZ72N6/jjakF4PRX3bdzoQAYBDKajHDHCNLfqWJbL2EiSdsfi2FSeWr1LMmlw8+76K8+3EIJq8y8ju7+MLOk4QmPVHsDxFH619Qf4SuMYNafnt/p08jRtGQ+B5bhs1QV4CumQwUg4gVeXKDTbtG2bpKoT66nYtkuzZxHxJKyKxXsnJzgzc/Q5CaXWC46T5+fBj4Jovo1XtNPp7EsZZwfBAmt8z0djwN4LEAfOAl+VJGkJ+BTwKwdxYnzXiear8mmef8hLpRI3b97kxIkTTE5OIushRKuK4rkfyqO5kwD+5MmTXe2qg+D5lfJeb6aaU3FbHp4paNR0OqW+Ryt+LMnWrSaZi77UhRTxk4w7dRkkifBoAs8RaPkdQimx9dhEMfxLVn7QQDEURDKK5wXtG5e7ZE77rsDQQJiHHzSpBVqahYctZF2i8KCJEpKoLXcIp1X04RArVZuWENz7SpF7v1mgVT2YV/Mg6Q87IrXDbhq94YIrcLoyutSh0YygeiaOFEaRPJAlvHIZeXKabi9G/eYWbs/FLdcAUBJ7HqY9+yBMm/a9TerzEo4Uh50VodpPVZAzebAd3FobKzSGZPv3hTJ5cI8mvHrlKUkSiUSCqamp3T6+iUSCr371q3zpS1/il3/5l/mFX/gFNjY23vgb34lcmkMc4pOOnchVOBx+QWt5B69r2rEXjuPQarWwLItLly7xPfnvQZd0ep7JgPouXyttMxDyI01N138c59qbROUQBbPO0cggHh5HjAEGnBFW6wIPiXpQHPSkXiAsq8w1y4waCSpWh1PJQWzP5VJygsWiTSpYTO+IiLcDoli1/Nf1jr9oVz2JreUm9za2CasKj4slYrrWbyFZqpCLGMyXqwzFYySFRnmrw3yhylAyxmLRf13YrjKQiDK3VSGfiDC3VeG9I8M8uruBrqjMrZaIGToblS5GSGV+vYyuyixtVknHDfSezOZKk26gzFOt+c6EcsXPpbdMmw+uLb10XnGcLrXWn0MTNwjLAh2LrquTVZv8fvdTfKMxjCEbxOUom60QK50OXcciLOl43RgqKqbnInkSpWKPkKySNgwGQ1Ga2z3apk1IVckqIXp1FySJH/5UX1NZluVnHCfnz58nEonsdvfZKzv0URHNg3o0W63WgTyaV65cAZiRJGlKkiQd+JPAr+z8XwhRF0LkhBCTQohJ4APgR4QQ1/f7G991ovky7CWEQgjm5+dZXFzk8uXLu1XPAPKxC4QX7ry1R3Ond229Xt8Nwx8Uz+doVhfau2c1Npra/dxuS1h7RMMJKrPX73bQkzq1Fd8I9dZsEucHaGz5hmbrepXwUJT0mQzVuQ7ps/7xWw2HzKU8S9+sU7rfJjQUVKKHFLSYysqsiRpSqC13GTiXoFe1GXk3Ra9mM/xukshQCOV4hGu/sU0kp7D1uIUaktB0md/8uf17Nd9W6mfxF67htGwEIeSQhCUiSJpPtr1Ap81JJWireao3ioimbyy1wdRuKFxS9hYCdXbfuoHBwvFoP6nSVY9AIoUw9xDoSP9BNOe2sb0wUjaPHE+81fHsd+Wpqir5fJ4f//Ef56d/+qf5sR/7MYQQLCwsvPG734lcmkMc4pOAVy1+y+XybuRqamrqldu9qmnHXuzkdhqG4Ts/ZBlDMfje7PdT6uSo2r6dWu4UUJBZ7ZXIEcXyHI7GfEk7QwmR0WKsbJncabRZsVtEFY2C12MqlqHj2pxM+s6I4SCfSJdV3olMsFRo4yGxEhQ7PioX0CWJlV6HbNhgoV5lPJagYnZ5LzbAzcdbTGczdG2HEwM5bNfjeD6LKwRT6RQCmEgnieoaJyIpni5VGYz7c+JQynd4DKdjCGA0HUcAY5kE7w4PIjU9bNvjyFAK2/WYGslgu4Jjo1k6PZuZ8TzRsM7RaJynj7aYnspTLLU4eiRHsdxhYixNodRlMB/Fsy3mrq+wML/1jG6zY9dotf8MmjdHWm4TkiwcoWIoJv+8/sPcamfpeTYdx2GzHULDIKVGyKgJNipQ6HUwHYesGoGWgi6rtGwbQyi0i11SkTCaJGPYMk7TJaTKfOrEGNn4q72DmqY9UyQ6MTGBZVk8fPiQR48e0Wg0qFar+1q0vAxvQ1Y7nc6BUrIClZi/APwG8Aj4JSHEA0mS/rokST9yoB9/BT6WRHOnDaVt29y8eRPHcbh06RKh0LPSArKmIxwJr1F9xUjPYi+B7Xa7XLt2jWQyydmzZ9+6OmwveRVCcPtfL8ORKJIMktwfUx/WWPlmg8xl32jU1/3lXK/qEDqWo77Yr/hulT0qiz7x9ByBPhij2/UvVXWhAwHBavckhJBAgD7gr8qLt+tEz6QoLnQYOOeTKSUctCNr2EgykFC5db2K1fUQAuI5hVbZZupShqXrVe7+5jb1wv6dYQct6Kre2qC7UsX1JBSrDYqg09AQwSo+fSSMemQMjEHslSZCBmvLL/TxQv10A9H2yaWQwSsHou3RCF7QHg0jjFupY61WaG2HEd4er+fezkKZDO5yD+X42QMdx168zcqz2+1y9OhRfuqnforv+Z7veevf3sFHkUtziEN8EiGEwDRN5ubmuHTp0hsjV28KnW9vb+/mdsZisWe2PRe/zKbZZra1QUKNUHc6HI/568EY/hxWs33b1bEstothHvbaHI1lgv7k/hyR0X2CY3p+aHq1XSejR2g1BA83K8zWKmRUje1Om3HdoOd5nMn7RUJHk75DYiye4JSWwWoFEZsgnL1TXb4TBq92d7QvHXJ2mNVNn7wWm/48sBVoZG5Wg9dai7CmEjIlHt7fpFjzHQGVRpC+1fK/1+r644cUGWujg9UJNI+DOUPT/P2JRvwUgcnhDNuPqmRzCe5cL/V1m+/+e6rNP07b67HsjvN183v5963v5YF1lH9S+2Eetg0kIZFQUlS7CRq2TcMzkT2NjbpLOmSQ1SNklSjFYo9at4sQgmEtilWzsT1B27RICx2362G7LhFk/siV/XeI25EdOnLkCO+++y5Hjx4lHA5TKBS4fv06d+/eZW1tjW53/+oubzOvvE3uvxDi14QQx4UQx4QQfyP47EtCiF95ybafO4g3Ez4GRPNVofNGo8HVq1cZGxvjxIkTr2T10rn30G7tLxVthxTutFg8ceIEExMTH0pUdWdMx3G4ce0G9UddCjddYueG6GzvIWvBAzX/9Sbpc1lqC30PXK8nkwjE1wHUZIjU+X7hUH25Q23Tf2DbmybZ8yliEwaPf6tM7h2fTNafWqhRhczZBG3HP576ag8BbNyqEx0MUZ1vk/u+DNd+s8DI6ThrdxsMTkcpPbaJ5XRKix1kVUJXZf7d/2P2rc/Jm/Dk791Esh0kPQQS2D0VGY9oKMjHjMco327u8GlCwxmkwDDapv+QCgnsgp+m4Mbj4ASGNNv3eCu5vTmZOrVHPaQRPxXFrfX1M6V4HNly8TJH3vqY3mbl2W63P3a5NIc4xCcNtm1z69YtJEniwoULu7q3r8OriOZOW8q1tbXd3M7nI2Un42McjQzhCJfJiE8a3UCAfZsmKjKr3SIntEm+tdllNO7nUqYDYtm0fSfETjvJJ/Ui2VCEqKIz5GR5WKhwMuMXB+WCHM5sECq1AztZ6XUZjsQwaw6zW3VWGi0USeJJoYyhqjwplkmGQ7vh8sVqnYtDQxSWG8gurFebjKSiFFtdpvIptuotpvJptuotjg6ksRyXc8ksdx5sMDmUZrPUZGIwxVqxzvhgipXtGtm4ztJmlcszI8ze3CQa1llYKpFNR5hfKpJKGcwvlkgmDOaXSlyYHuL+1xeJRkMsL5Z5+rDM0OAYZ84pZCd+icfmNNcbY9woD/BBNcpcN84HrSsUrSiKpKBKER5WXUzXJaLoJL045ZaE5XqUzA6Gp9Go2WTCBqmwQdzVKBfbOJ4gaYSJ9RTq1S6eEKRknePpGKnE23du21EnOXHiBO+99x7T035a1tOnT7l69SpPnz59Y6e9t51XPm6yed91ovkytNttFhcXuXDhAoODg6/dVjEMhCMwl94cepRlmVKptNtBaG8Y/mXYT1hYlmU6nY5fpNRK4fb876zebKHm+xe7V/ENgNsTdDBQwv1VSq/l0WwIJDXItSw6bNxpoCV9L2VkPEZouF800i46SBkDhMRO4ZvTEWTfSbG6YrL9qImsSdRWugxf8HM9M8ejhM/GaXT9m1qP+L8fz+m4Nowcj1Hb7DH96SxEZe7c2mZ97sVuQS87Rwch6sWrW7SXm9giBGaXajuOgUXXVpElgXpimsoHW+CBW/MrxNVU/2EPWf6KWMmlkIIkdFvfs+LT+uL20p4JRU6nEKZN/VEPaWwKr7JH8sj1r5l+7O2J5icll+YQh/gkYMcm7TgsRkZGiMfj+071eRnRtCyLGzduIMsyFy9e3M3tfFk+5x8a8td2BdP3DM61tkhrMbrYHI+PMeSOsFUTuEBX+HZstllEk2RmmyUykk7N7nIyNYiH4Fx8hMX1LqrsR3R6jm/4S0FjivlGDU2WeVwpkQqF0SSFVDfE/bUiU6kELdvh1GCenuOHzR3P42gmjQCOpFO8OzhEqCPR7FgMJPy5JqoGWplh36YmDP81H4sQbgqk4PTEo76XNhnz7W0qeE1ENN6dHEKqOzi2y2Deb1E5PJTEdQVjwykc1+PIWJrpfAqp62BbLkcms1imSzYf4ctf+besm7/IqpvDVGPY+ii2kSWixdlqR5itVSi3qjhdhbWGQkLzf9uzQqw3PUzHIabqjMpJ2k0X2/Mod3tEHRWv45E0QoRVFbtsIXsSRkgjLlRUEy6f3r9g/8vwPEmMRCKMjY3xzjvvcPnyZXK53Aud9p6XxPtOeTS/3fhYEU3Xdbl37x6maTI9Pb2vilxFUWhduELnV//NG8deW1vDNE2uXLnyxlXty4TYX4Zer8fTp085e/Ys9kL/dCaOxXn85Sq59wbQoiqtlb5YsGUKkmd9b5sSktl60KQ63yb5ThYto7D1oIlZd4jOpAAoLvZYu1YjOuoTLrvj0jZ9Q1q41yRyxDd4tipT37bolG2G3/XzeQSABB0J5u/XWb5VJ5bXWblVJzUSZul6jUhOZu1eg6Pfl2F5q8mta9v0Wh7/6L+/+8bjPyie/NxtZARu18GTVeTA06tGVJzcBHZQbC5HdJxizX8f9DWXwvpuIZCW6hM0eU8nolattvveM/fITyj+ORKWQ6tsIO8R4XerLbxwCHUo/9bH9TYG4eOYS3OIQ3xSsLa2xoMHD7hw4QJDQ0MHqiR/fttGo8G1a9eYmJhgenr6mcX1y/I5vzDwDiFZY8usMmn4BT9jRo6I0KkUPW7V22wLEwWJ2UaR4XCchm3u5mPmgsJFVZK5GD/C7GYLy/V4WimjSQGhVDUqrs2xZJqmbXE6m8cRHpezIywv1kgH1eaxoE+7EuyzGSzQG6aJBESEysOHW2xUgvaZZZ8cb7d6yBIsleooksRCocrp4Rxrs2WaTZOF9QqaKrOw8ezr4kaFsK6gmYK5O5ssr1ZQFImVdb8j0Op6DUWWWNuokUyE8eomiw82WV+toigS62v+azj9iF7s/8umrdARUHGyVF1wcCm5cfRQinw8S1gdZKEtUWjXKTZq0FJptT0SqkZE1fDaElvlNj3HIabpjGDQbpq0LRvLdgl1JDRJxnJcYkLFbTp87v1jhPS3S6fbweu8kbIsk8lkmJ6e5sqVK5w+ffoZSbwdCSXLst6KaH6U8kYfBb7rRHPngd3xCiaTSUZHR/edPKsoCo6mIxkG7W9+8NJtdsZOJBJks9l9uaLfJO4uhGBxcZFms8nx48dJJBJsXO13o1ENn/w8/J0qmfcGYU9+YHmxw9zXquTezZA+mdwVUl+/0UQeC/lxYWD9ap38e1kqyz08RxAaCaSPpqJ0m33DFslFSRyJcP+rZUYvpQBoV3xjsnmnwfDn0tz9WokjF5O4lsfQiTieK8hORvAcQeqIin5Epy0c1uaanLicZeVRg0bJ5OZvb732PB3Eo7n25XWac3XsrodQJKy2hKo4CAEiEqEzW0dRfVIZGknsisV5jRZIoI4No0wdRToygy2n8IaPw/hxLELIgwMgSRh72k2a5b7X0mrtyYvRDZrbKlI8jhQx8Cp1vJH8h0qheNsQx0EF27/duTSHOMQnAQsLC1QqFd57773dZ2wn938/2Es019fXdwnrwMDAC9u+bK6IqQafzZ4CfP1GANOyKdei3Om0yOgGVavLqeSgX1wTTQF9fcySaxJTddyOwsP1KkuNGpOJFE3bYiIcwQOms/7COB3uR3zeT4+ysdHE9QRrdT8itFSr+5JIxRIRTeVpsUzGMNioN3kvO8zVe6uMZxNs1VtM5pKUW12O5pI0ejbHR3I0uiYnRnLM5DKEWlCpd5key9LuWUyPZml3LabHcrS7FjPjOYQQvDs8yOp8k+mpPM2WyczUAI1mj5mjA9QbXWaODqCpCkeTcZ7e3WD6+CC1aofpE0PUqh0+/YMNjn/mMb14kq2CxboZpeE6aJJBsZehbts03DamFaNkKuSMBOPJPBFpgJIlUTa7VHtdnJKF13VJhULENB2ralGt95CRGIhG0FvQapnIkkTCUehWeqQSYb7wmeP7uk9eh4PMCaFQaFcS78qVK7sSStvb27vSWS+TUHoZut3uvtJDvpP4rhNNgEKhwK1btzh9+jQTExP76ku7gx2DEP3ij9H58m+/8MCXSiVu3brFqVOnGBgYOBCBfdW2O57XTqfD8PDw7opj82pf2qhbC7xpQqJU8YhOB+GHiQjNQFB97XEXjL60ht1xae+xg67lYe/prbp2tUbqRJyFG3UKj1ukz/jEc/1GHWkwhOuAGYTGS7NtBs8lGLmSomH6x9Es+GGW1ft19IjMys0ak59OMr/YoVTsMn+rSjyrs/KoTiShUlzp8P/57+/sjvlh8ejn7uN6EqpnIiQFSXiEpC4FJ4HW8vMzvZ3q8lgQlsokcCMZWs4wnXaU0rcqVK6X6Kx3qd0pUblZwn7Uo3TXpi1PIJKDyIkYGCGU5p5K9MA7CtBrdrArXXrkkPN5EBLe2OtTNN6Etw1xfNxWnoc4xCcBk5OTnDt37pln8m08mg8fPqRYLHLlypVXLgpfNe4PDl4CYKG9xTF1lK9vtIjIITwER2N+Dr4cLG7X2jUAHtcLJLUwsiRxRAxya6PI8bS/bUb35wI95M8lpUBjeL5WIaHryG2ZudUKc+UKw/EYW80W07k0TctmMhHbFWd3heBELsOoFEMKhDhygdalEnQQigVd6zRZQZEl8iGDR3c3d4/NCwiPs9Oq0g6KfATkhU6j7O+bFaQ6mcH/zeBvTZVxt9s0a74DoN32d6TZ6DEyU2Do3F16iSjtjsvdFQ/H01GkGI+bYHoeUcVAsvMUuh49z6Zpm5Rq0LUFyZDBaCRJzovjoFG3LMrNFr3tJorlElYkoqpGY6uDJsvEjRBywwVLEAlr/KHPnkSW397psHuO3lLeaK+EUj6f59ixY89IKN2/f39XQul1Y3yc8F3fm1qtxsrKCleuXCGZDFonvoVB0PI53HCG+r/9DaDvcVxYWODy5cukUqmPRNy91+tx/fp1UqkUZ86cQVEUhBC0iibKgIGsSsiaTHm233e7VbLYXHaJTRhER/vFH52yTdPuXwIjr7NxzSI04xtHJSzz5PfKpE/64VXhChjQMFvBfgUC8APn4vSC52LzQZOBMz550RIq9+/XWLxZI5rRKC50mLiQpFtzGLuQZPhigobi0K65jByLYnZcJk4kaFVtps6lqG33yE9F+MW/c++V52m/Hs2F/98S3c0WEoK2nEB1etiaRs1NYERVhOkgGyrWZuCFlCUYP0bHyVP+Vgmr3IOdaycJ7O0aAPpAEskOzkfIoHy1RHnFQBo/jqT7ZFVOp5D2hNG9ik9mu4tVar2gV/zIi56Kg+CTkrR9iEN8EqAoygt26SD2fyfVyjAM3nnnnZ20lZfiVVJIF5JHGQ1nyTh5CjUFB4hIgVh7z58fHgXC61u9Jsfjfuj7neQo9YqM5Pn2vRXkYc5V/c5Bc40aCU1nqVFjQNUxVI3TWp4HqwWmcz4pHU36qVOJkE8YpcBXWmu3mUjE6ZUtVrdqbAZFkYsFPxpX6DqossTsVpmQqrBSrnM+k+PWrVVikRCzqyWS0TBza2XS8TDzaxWyyQjzGxXOHMlTnq/h9lwWV8ok4xqLK2UGcjEWl8sMDyRYXCnz7ukRFq6vkUiEWVkqMz6RYW2lwpGpLO3eKp/5sWXa4TCWqbHSi6HEFUrbNuvdMCE5jITMckNmvWvhCJeEEiFsp1HQkCQJSUCpZNLuOYRUlfFEiiE5gSyH6HkCxfZorNVwTItWu4fadFA9CQWJqVScSxcmDlx78DJ8VDqaoVDoGQmlycnJXQml69evMzc3tyuh9LZyg2/qOCdJ0p+XJOmeJEm3JUn6/Zc1CnkdvutEM5lMcunSJXS9X8TxtiGO1Bd/iOZXr2G22ty5c4der8fly5d3ZZH20+t8By8zHrVabVeDbWJiAujraC5/s8zDr1UwTqfInkng9Pzf0aIKpact7Jag1hFYVv9GSE1FmP1qiYFP+8YhOR1DeBJmU0MJS8SP6/SaLg3Tr16XFJi/Vyd1zA+VbN1rkj+foNxyWLpeI5b3z6EcVlDDMmvbHRJDYeyex3Ag5O4FXRtEWOL2zQILt2oYCZn5WzXSQyGeXquQHzcornaY+p4UX/7NFb7671a5d7W4r/P2MgghuPsPZnEsGQ8Py3SREbRNFb3tEs77BtUYTyDJMvqJKYp3TCo3qmjx/n3hVH2CqA8k8Xo+cVTSfS+DHCSrC8ulU5FpWoMooyPIqWR/m0QcWn01AK+qYA4OsKWI3YTsdrt94Af20KN5iEN8vLHfSFm1WmVubo5kMvlarc0dvCr6Zds2x9rjXK+1IPBCrjotwrLKWqfG0VgW23OZCdpLxjSdS8kJlre7dByP2XoFTZJ5Wi2TUXUarsOpTB7b85jJ+Dnmw1oYs+DsduNpB21uNwKJt7lSBUWSWGv3iGgqEVXHLlg8XC2Si4bYqrUYTUaodUyOD2Vo9ixOjOToWg7nJ4bIeTqaK2O7HkdH/BaVkyNpPE8wMZTGE4LxgRQnx/PETJl6rcvgQBwhIJ+L+a9ZfzGdThucnR7Eq5rYpkMi0OiMBMVEelhw/keeYhkq5W2JLS+KZ8tUSxoPyhYNq43rCTpmmpAcJa6GSCpRVsoe6+0WNauHhoLe0UlpYcKKSkzVKG+2MU2HSEhnJJJAaiuoukEqFiXakWhUW5itJk6xyWc/O4Hruh8bovn8GDuV7DsSShcuXCCVSlEoFLh27Rp//I//cTzPY3Fxcd+/sc+Oc/9MCHFOCHEB+L/hy+jtG991oinL8odaee4lj+GZSQQSj//Hf0w+n+fUqVPPXKQP49FcX1/n0aNHvPvuu89osO1st/yBvyJcuF7HSeqEM/7KNTUT2yV3jS2Lhg2y5h/vTnHP4vU60QmDTpB32VjvkbmYwRVB+7F5h+gpDWNaplUQuEafBGlZnc3ZNo7pkT3hP9BrN2sMfTbF2lyL2EBg4O7VCcUU1u43mPmDGb711U1GToWxuh5T5zI4psfQkRiuLRg5FWel2qRc7SFcgW25/M2/+A2a9Rc7Bu3ngbz1c08wyx2Ea+OYKrohaCoRIjHfSyC7/qJCTRqYxhDV2R5OLSCDgeClbGjYRT9JXc30yaWk9q+v2JOfKRyBVehQvNPD1VP965Xpv0eScLeb2N0EY1OTuz3KFxYWuHbtGo8fP6ZYLO5r0fO2Opoft1yaQxzik4BXyea97lne2yXu5MmTL+0Y9DK8bF5pNptcv36dLx69iIRfUT4UjmPi7Rb8pHXf/jfsLrqsgKlya6nMXK3CgB6mZVtMGlEEcCxoJxkOPKtNy+RKboStokWzZ+3KFs0WywzEomw0mhzNpGiYJicHcpiuy/tDo8zPVTiS9+evkUwgAC/tJMPvNEmByVwKqe6ysVHf1cKsNf0wdynQzNwq+2RWQ2L5zjar6zUkCRaXS8gybBc7aKrM0mqFUEhFc2Hl7ibzT7eJxULMPd0mmTKYfbJFLh8jcvabJKckNragnUrgKi42KUqWRsgNY27DWivMWqdFyWwieQqFhkQmFCEfjjIWTmLVodDqUDNNNCREzSNjGCiyREyodComEUMnEzUQFRtD1xnJZkhg8NnPTKPrLjdv3uTOnTtYlvVWTocdfCc6A6mqSi6X48SJE7z//vt86Utfotfr8TM/8zP8qT/1p/b1G/vpOCeEaOz5M0o/nXhf+K4TzZfhoIRw50YoFouUTh0ltrhJPvpih5eDejQ9z8PzPB4/fkyhUODKlSsv6B7ubLf0jX4hULXsYMY1ooMh1Gg/5JKcjjB/tUrusi+r1Kr4D7DddREJnY1H/WtZXGzTrPfDva2yAM3/7e37PeLHdCQVHj8skzvlG6ylmzUiWY2h8wnKQc7L4vUq6dEwnbrN+IUkR743zca2nz9TW3dQdYnZGxVSQ2EW79Y49YUcX/3tVY4cT7D4sM7Fz2ZQeuscn27xC1/6fWzbPlCXA6tj8/gfLyE7LpasoToOQnaxmwohs+ffgaUOxqlRmgWJ1lIbY6hPJJ2KH2IKDfeLgySlf9t67X6eilPtpyvYwffwoLFkI8amQZFB7U8e2kAKr2uhTPgFYjs9ys+dO8fly5cZGhqi0Whw+/Ztbt68yfLyMs1m86WG58Pk4xziEIf49uN188pO3n2j0di182/rlNja2uLevXucP3+e8+NHeS834XfRCQp+zGBhPdcsoUoyVavHcXWUb61scyoo8MkF+ZiKGuT/t3179rhSIqpqpAmztdGmatocz2V2ZYsEMB6EzVNGULkuy1zKDFHcaoGAUpC7vhzkrZdMD1WWWK600BWJbrNFd73F/blNMkmDxY0Kg5kYK9s1xgaSrBcbTA6nKVbbfHZ6jPsfrHDsSJZqrcPIQIRO1+H4sUG/COjoALbt8u7RQR59a4Wj0wNYlsvEVBbH8RgZS+F5gqnLLUZOtak0otT0CMJWKVWilBUZKQG9nsNs2UV1VXKhGENahnpLo2s7lHsdNE9hc7uFLsnkIgZDmoFX96h3TVo9k4wUxm46IEDyBF7FQlMUwoqKXe6Sz8b4kS9e2q0Cn5mZQZZl5ufnuXbtGk+ePHmj5uXz+HZ4NN+Eo0ePksvl+NVf/VV+8Rd/cV/f2U/HOQBJkn5KkqR5fI/mT+97p/gYE839hs6h36ZyaWmJsz/xx1BDMlv/8H996bgHMR6WZXHz5k1UVeXChQsvzdORZRmr67B2swaAJEPhaYvCQoemItFr939PT/vff/T7FUa/L8vmw75OpRJRGHiv7ylNTkZwDQURsKtwPATJPklSjDAj76dpbLtYO2LmHZf4MZW1Upv561VykwauI0hP+ETUU+HOzQKLd+uMnozRKNkcv5LF7nmMHY8TndLZ2GoR0h0+c/Qq//P/5d/y13/8F/g3f/df8Tf/zD/kZ/6T/zvdf/8TKCv/Crtbx7KsN57Pr/4397B7LrYnowuHrizhtVWy0zGE7REejWLn0qx/vYG57nssFV0KzomGVQi0NPeE0L1OQC4lgV0IzruhYRcbL7wXgLnVoHqzjJudwu30ybuS9D3A8uSLSgSyLJNKpTh27BiXL1/mzJkz6LrO8vLyM/ITdiBkelCP5kcRmjnEIQ6xf7wqdN7pdLh27RrpdHq3S9xB6wR28uNmZ2dZX1/nypUru/nXPzrudxxbDQp+njSK5EJR6naP97NHcGo6qufb9p3imvWu7zWcazVI6CHWWg2OJtMoksSVxAi35rYYCwhlJPC87sgWbbd8UrpQrpExwngNh8WVMnPbZfLxCKvlOgNRnXrPZmYoSzOoKjcdl89MjbO93GUsn0IISAVd5VLRQBg+4Ts7ktEwZwaydKuBLQ4W3+GgjfNOEZBlO0wkYmwuBDmgWw0kCdZXa2iazNJCmaHxMJmLN9msGBRt0AyFtbqGHY3gtDy0XoJiJ4KHxOp2CcnReVrq0XMcDFVlTE9iNyGqhei5LhFPpVrqokgSmahBytOpljpYtktC15AqfqqBIcl4NZNYWOOP/qfvomn9+V3TNAzD4Pz581y+fJmBgYFdzcvbt2+zurr6Rm+n53lv3XFwBwedV/YqmXzU84sQ4ueFEMeA/wb4Px3ku991ovmyk3GQqnPHceh2u9i2vdumMnT5fey5BTpzm89sexCPpuM4PHr0iPHx8Rd0057f/61bLVzLHzd3PIbZ8h+ydsNhfbtLYtx/+FrlPnmudF0yp/v5ed2ux+w3KmRP+Z9trXbYeNBk8EoQ3sjrLN2uE835D3xhtkUzCHUUZ3uMvuvnIdqKRKdnITxQE/4+zV+rMvO5LN/8vQ0Gpv2HaWelvPygzviZBI8XK5jCZTp2i3/0N36LP/+jX+PcsQKbxURw7mBhNcZwfJ3w/N8ncesvEi78FpVyGUVRsG0bx3GeOb+VuSbrv1dEklwsV0J2Xdx4BMUSGGkFJaIh5VI071hERmM4Td8L67Z84xUei/cd9HsLgQJyqWUTeB3/O/pAenfbve+1geTuNrX7FUw7BsGxi0BGSjqSe+OqMRQKMTw8zNmzZ3nvvfd25Sfu3r3LjRs3qNfr9Hq9A4VZDsnmIQ7xncPLyOOOKsnJkycZHx9/7bavgizLu92HhBDPiLkDfGH4OFFVZ7vXZFyN4iGYjKa5kBylXvUodbqsNGsAPKoUickKdddhOpHC8bzdqvNhI0bWjFBv+PZxq+k7KmbLFXRF5kkgW7RWbzKZThEP6cxoKZ6ulJkeyiIEDAZEcShIIYroO+RK4tLwEKV1XzC82fUX0G3bt09blTYS8HSlQDKi0yu0WZsvM7dYJGKoLKxUSCYMFpcr5LIxFpbLnJgepLvZAtNlc6PG0ZkBSsUmx08OU691mDk5TCwW4vQfWmStq+NlwriORLmRwZI1PNnDdQxWXQlLEfRaJu46bKz3yIcihBSVsK2zVmhT6fUwHYcRNYrTcomqGo4nkFoenukRM3TSegiraKIqMklFQWq5RFSZy++MMTH1bDGo53m7tlmWZdLp9K638+TJk/vydrqu+x33aLZarQNL5u2j49zz+BfAjx7kN77rRPNl2O9D3mq1uHr1Kpqm7V58gPyf+AJmS2LjH/ybtxq3UChQKpWYnJx8Y2ciWZbZeNQmPuyHKSL5vhxR9niM8lqPquWROKZTmtsjtyNgc71LdDREOKWxcq+O5wrqLZvs6QilJT8fZvNpl/SUweytKmbLIXXcNxSjl1OUtno7hee02zYDJ2M8vFpj7LQfmt940CM1oREblFmtlhACiksu0YTG0v06xy6lSQ8ZyAMytVKNv/RHfoP/63/xdVq1PvmZGa9jO/55ncg3gmP22ChrGI//NomFv8ep41O7VZ6u62LbNpZl8Wt/6Q52w8GyJRRD0AjHGAx6suM42JE0dsMn35GhoDpSAXOjBvQljrR8HKGGCJ04gn5qBnVshNDMOOpozg+HA3K0f973vlfT/apufSBB9VYZBo+AJGFXO/7/U8aBVo2SJO3KT1y6dIlz584hyzLb29tcvXqVhw8fsrW1hWW9mNO6g72G7BCHOMRHizflaAohWFhYeEaV5Plt90s0TdNke3ubkZERjh8//sJvG6rGD4ycACAsq8hI6G6Iawtl7peKJPQQ2502U5EYrhCczPmkJxKk+dTNHmfSedbXGmzXWjwulEgZYdbrTUYiYdqWzcl8Dk8IpgICOR6P09ro7hYJdYKe5ptV34avVprIEjzdKpOJhlE6HmtLFRY2ygykY6xu1xgfSLJdaXFsNEO9bXJiIk86HmEqEmNlscpANoRtu+QzYb84aMwvDhoeSDAxmibuQHG9jhF4Q3eknNpBupPneij6Fpu63ymuVfIohOI0ZBs1LGNVI7Qx8MoOBiq9lkYjpLNcqVDstEl6YeyuYCASIWcYJFydYrFFtdPF9TxyXggsgWW7xCQVt2YjyxJRFJymRUiCkWycL/zIhReuqRDilQQvHA4zOjr6Rm/nR0E04WCeybfRZn5Tx7lgH2b2/PmHgQP1qP5YEM23KQYqFArcvXuXc+fOoWnaM54kxdDRj0zSW6tS+kpfmudNF2zH+CwvLzM2NrZbrf46yLLMg6/U2OqajF5O0ev091sO+ae3utXDTMoYeX/1KCmw+bhJu2JjRxQGziV2DUJlpYuZ6Id3u3Wb2IkYdlDFPv9BhaF34izN1SkudZj6lB9uLy50UEdUhIC5axXSo2GEB+mRGA3hsvrAIj8Rptt0SB/xz4NQPOa2ayzfXeJv/YVv8anj8wDMDFXoWv6xx0I9nq77eUP5lMnsup+Urti+t3jQuk707s+iiQ66rqPrOpqmcf9fb1B/2sJRQO+4qKkQoY5Ld6lBeNCgsuxRn+tgbfohIlnxjz8ylkA4AmNmEFNEqTuDFJYNVr/SYO1rLVolhfXfa7L2+x0aJYNyOUsjPoDQI0jB6lw4e7yKUp9AqmnfW1y9XUWeOoa1VcM4PvKhc2l2jnmnp+3Y2Bi9Xo/79+9z/fp1FhYWqNfrz9yj3W73QH3OAX7913+dN0hQ/GVJkh5KknRXkqQvS5L09j01D3GITxh25hXHcbh9+zaWZT2jSrIX+41+FQoFZmdnSSaTDA0NvXK7L46fAaDodDmpjfC7C+scTab9CvKUb8MNxbdf1UBlZL5RQ5dl0qpBu2ixUW9xciCHKwTTWf878UDCzQ1sS6nT4dLgEHNzJXqmzZPNEtGQxtxWhbShU+5YTA2kqba7nBjOEw+HOBlPMztXZGokgxAwkvPtZCbwfhpBxXzc0DHXO9hBm+VeoKDSCua8xaUCkgS2adFaqvL4/gaxWIjZx1tkslHmnm4zMpZmbaXCxcsTrNxYYuA/q+BGPbRQmM1eDMUKIboSHTvGtizR0m1EUqG24aFqEajapGwV80mLWt2kaVkUOx20Lrgdl6RhMBiPITcEtbqJEIKMotMu9vCEIOJKuC0LQ5JJaip//H/3mZfygv1Gm17n7axUKiwtLR04t/PD4G0k8/bZce4vSJL0QJKk28BfBv7MQX7jY0E0n8feAp/nsZMHs7KywuXLl4nH4y81CsM/+QcRtsf2L319X+FM13W5e/cuvV6PS5cuoWnavm4Oz4G1O23adYc7d8rICQVZ8W/Q8krfg+nJKnUc9IxEclqnW/dX1oXZNmZ0TzszDTYeO4xe8UPhkgxz92uMXUoGxw9aXqNe8leFqw/rhJMqk59Ks/ikgRaWcSyP9KiBJEGh2UCLSwgPElk/hL/xxGb6/SS37xeZOdHjf/xzXyUd6kv+hHSP+/MpCo0kH9wZprUdp7WexCvG6JZSPLg3yMJSnPlCHgmXrY0yyjf+CtgtXxbKFnzjb88jXA8he2iTEdylHpkTUfR8GHkwSXu9R2QkjB3k+NjlNkpMRx7M0vByrHzTpPqwhVW1MfaE0OU9bcHcto1nephzLoV7FtVGDu34FE6j3wXIbfW9ikLuf7ddkNGnJzFOjH6kSduSJJFIJJicnOTixYu88847xGIxNjY2dsV219fXmZ2dPdDK03VdfuqnfgpeL0FxC7gshDgP/Gv8pO1DHOIQ+ETTNE2uXr3K0NDQM1Gw57Efp8T8/DzLy8ucP3/+jRGRS5kxLqbHkFsGwvJ/MxN09Nmq+drBy70OuiwzX68yFI5gug7fk5vg9pMtRgIZNDWI4FQ6QcSra/pdfwol4rpGBo3aVodKs8vx4RyW4zIUCyGAycFARs/wiXU8rCNVHJpBKL5c9+ertUIdCVjYqKAqMrOrRd49OsTTG+voqsLCcol0UqdQ6jA+mqZc7TI9lafVcbhwfJDFGxuk0zqW6TAynsTzBMMjKQASiTBnTg/TWK5gXKphuzbtUojFno6UAVOx8EhTLrtEXR15y0FuxLBVDVv20NJhakWTjidRLjRI6iEmpBhuz8PxPBzHxSqaGIpKLKxh2DJO0yES0giZAtnyiMoSEQn+5E9+llii31VpL952Ttjr7UwkEs/0M799+/Zby+ftF2+rzfymjnNCiJ8RQpwRQlwQQnxeCPHgION/LInmq2DbNjdv3kQI8Yz25ss8oNGjA0ipDFaxzdo/+f3Xjtvtdrl27RrZbJbTp08jy/K+V7Rrd1o4wQpv+ESCG7+7TfxclIGTMSorAeGRBMXFLq2CixPXCGf7K2gtLnH7y1ukLvir2bELKVo1m/X5JrFBnbGLKcobXQrrHUIJBVWXmX1Q4+hn/BVtu2ozeiHJowcVqls9pq74n89erTD8qRALj9tIsgaSYO5WlemLaYaOxmhLHrrU46987rcZz7eYylTZqvn5mMVGhE7VIN31uDTU5my+jCf8/RuNVTiaNnl/qE2jkODq/RGsTg21Ncudf/iX+G//ym/xs5/7LcqbXVpdl3w+TGo4BgIiGY1aSd296aIjQbg8IiNnElTKMdpFQa9ooad0zKJv+LRYP0nbbfeJY2/Tz1ESmkRvs4Vdt9m63qG8bhCaGUNIEuZmfXd7p9GvUJejIba+1SB0fPzbKkOhaRoDAwOcOnVqV2y3WCzy0z/909y5c4f/7r/777h58+Ybx7969SrT09O8QYLiK0KIndXNB/i5Noc4xH90eBlRrFarVKtVzp07x/Dw8FuP7TgOd+7c2a0LCIfDb3RKSJLEldhRtrsmVpBbP1spIQPrVo/RaJy2bXE664fNh8IGx6QUtWAhvtEIqs4LfhvJhUqV0WSchmlxajBPWFM5E0nzcK5ECN+J4QXV7W5gcbdq/hjzhSrnxwZZfFjAsz3m18vkU1HWCnUmBlOU6h1mxnM0O364/MxoHrXl6x+PDvsOj4GcP1fEY0F1vCLxzvQQrc0OwhNYpn/+N9ZqyAo8fbxJJKqheC6VhSLLi5sM/9EWtbpMO5HAa8roHYNOJ03V8/Ai0LNsmnqMmuuixnTCQiVUALUjoGlhbrcozdcoVNv0bIe4rhPpSHiuoGvaRGwJqechPIHedZFtD90RhCWJP/ZnPs3AaL/49nm8LnS+XwghnulnfvLkSRRF+VCV7G/C24TOvxP4WBDN/biom80m165dY3R09IU8mFcJ5g78ie9Fcky2fuUudvfl+XLVapWbN29y4sQJxsb68/J+iebc12u77yNZn/jO363hDatkZvzQw8DJOK2y//vllS4NW2AEOpv5k1E8B1bvmSROqDSClWq7ahMa0ukGN2F922TwbILxyymq2z0W7taIBxqZHcchMeg/8LM3KiSHdDKTKsWqDQhWnzY4+alccGASq7UGj25s8X/+s084MrAjqSRRbye5uzSM3lJ5f7TJYsFfGWkq3Fv23ycNl4cb/up6LF7nQq5JtONxeynHheE5vl/793QeddGjMscvpum1Zby2SWQsSuGRSbdo41T8Y5QVD3nCgLFBVr7axG66mCWfJ0XH9zwsTv9B7G345FLPR3aLh5RcCLyg6nEkQa9gsvb7XeSpmV0pJCHLmBt9+SjXdP3e6McGPhKiuZ9Qy47Y7oULF/j5n/95Pve5z/H++++zsrLyxvHX19efKVbgFRIUe/BfAP9+H7t+iEN8IrHzPAohePr0KVtbW8RisQ/VJGGnQj2fz+96RPebz/nFYycBmK1XSesh6rbF6YyfljQS8/fJ8TzGYwm6NZfFYoPHhRLJcIiNRpPpXNpvI5n3PZNDgefKUFUGHINaw0+5qpoCCVgs1gkpEsvlBtloiM1ak2ODaY5nM6gNj1bH4uhoEC7PB5JIsUASSZVRFZmUqvPoxjrVmm+XV1b9Nstrmw10TWFuoUg6GUGzBMWFCsuLJcaPZNjeajBzYpBW0+LkqRE8D2aOpHjyzUV0AzI/2KBWjVANRbAkF8KwJcI0XYHVdYg6IdoFlaino3U8oj2JXsWjgYecj+AASlvCLnaQmhaD0RidbZOu6aIrMqGWg9l0kSSJcM9D2C665RFV4Y/9xKcZn3597cVHkUP//LzyptzO572db+P1bLVaH8tucx8Lovkm7NUle1kezKtagA38wDkkVQHbZP7vfuWF/6+urvLkyRMuXrxIOp1+Ycx9Ec3fr+2+b1b6HrN2y2Zls8Xw5QSRXL8CcfBEjPkbVaQBFT0uUw3Eb4UHXVOitafZeb3cwQn3j2v+RpU2/t/dpkPyiMHwyTi3v7mN73AUWF0XPSeoWi5rTzuc+pRvyJaf1hmejjK/UWN8JsFf+kMPOB7fxLR9L5zrSRTXYELrYWhBDg79jjrJaP+m1wMJi7TRY7GSIhu2cVtJ5rbHmE4U+PwPzBNp+1XdZt3CbDi4WojWaodQWqW13ESNa5SqNtt3VPQg6V2Lq3Q3/POhGP1bc8ezGRqM4gSh8NDAHtH2aP/87pVB6rZU6mYWfTRDaCiJZ/bPbW+zRXQ6ixJSPxKiCQdP2k6n03zxi1/kR3/0Rz/0bz+3H38auAz87Y904EMc4j8wWJbFjRs3kCSJixcvfqiQ5U6F+unTp3cqdYH9zxUTiSQnY0lcIRjWfEKnBAvh1WZQaCkklJrEYrnJ0VQCx/OYzvmet512kt2gb/hqrc5MJs3GUp16o8tiscpIOk6l3WU0aWB7glNjgwhgMBFFliRipsPDuxu7vclrQZe09WIDCZhfr6CrChvFBmeyGW59a4nBfIz1zTr5bJhm2+b4sQHaHYuZowNomsKJoRRPb60xOBzILQXFmJYVOEnqXY6OJFm8vUkkFmKrWEWcVikJGVWWcSoKrW6KXtFC8ySoCQo9FSer01AdjGiIWskmJCmobQfWW6TtEEKR6Hgu9ZUK89dWiYdDGJpCZ71BPBQlm4qiNmw0SSJkeyimyX/6n73P4EQa13Vfe82+3c6Hl+V2Pu/tLBaLBya7H9e2xh9borlTwfzkyRM2Njae0SV7Hq9bUcY+92mE5VD/5gKdLd8b5rouDx8+pFKpcOXKFQzjxTyN/RiPTsOm7TnEB1WMpMrGY398RZNYfdzA7Lg8uFXGi/Rvlmjghdx42kQaFzS3+oYvMRHBlCXCST9UnBgzeHqjRnLSJ4PD5wyWF+oYwf/nb1TRRhQEsPKozlQghaREQ6SGfW/q8pM68YyOY3vEp8IUtjqM9W7yhy+ukgjbLJWHsF2ZB/M5Lg51ebTWF7rPan0P4JFEi7V6itlikm6rS6Xtk7uu6x/PkXSDGb2GIof54R/9Csd/wKNws8bAuQT1CkQCDdHMdJTYTJK6pNO4618zt+2vxONHYru5mKIXdAuKaZjbPvkM5fvXSdH33Lp7LtMzhUCyTHezx9YTBWUwt/uxmoliV7vET/thqo+KaB4EBzUIo6OjrK7u1dR9uQSFJElfAP6PwI8IIczn/3+IQ/zHgkajwbVr15iYmGBmZgZFUQ5MNIUQCCFYWlrarVBPJpPPbPO6moK9sG2by2H/mW8HWTaPyiUSms5Wp8XnByd5OldiJO7b4HAgw1br+mRwrlRGlSWeFsvkoxFGYwnCTYlyo8P0Tv5lyLez6YTvIW32/IV523Y5lUizttFFV2UWNipEwworWzWGMlFKtTYz4znaPYvzx4ZIWgohSUEISMZ94pjL+sftBdEj23FJC4XFxwUURWJhtkAkojP7eItcLs7yYokTp4dR2ia6BJ22ydSJQfgDNqahgyThdXWKkSh1xcZLK3RKNrYRR266xB2VRA3MdZuQptC1bWJ6CFk3MF0HTZJRCh3sup+bOXt7idK9LSJaGE1RoWoiuYL2cpnGapmf+EtfYOrM2G4E1HVdLMt6QZZv57p/FKog+x3jZd7OarVKu90+UG5np9P5WLY1/lgQzZddDEmSuHnzJoqi8O677762HdjriObE//5T2J6BZ5k8+NJvAXDjxg3C4fBrk7hfFY7fi7u/u82jW1XW610mvzfDDksaOR3HDITaUyNhrv72JqOfTSIrUNhTIBTLxIhPG6gh//iLGx0Kyx3iRw2iaY35Bw08F3qmTCynsbHeoV4wiQQR/snLSZ7crxJL+2Rv4X6dE9+b4fa1EsXtDqGIQrNqMTITJzNt8PUvr/H575X4iz9wv78PUo/FrUFOZP1wdnpPe8t02OR3HuR5sDJCq5hieSHJmCtxKiRT2BpmaSlHrSJT7hikjQ7b5QxTA1sUCuNcufgbhPMajiPR2TYRpoMkgxdRWbpuEc/7BldSoL0ctDKL969Fb8PPJ4qM9x8aeQ+5dPYIr3vNvqfSLPULgeygZabbdaltqRinfS+EPuCPGT/jh0++W0TzILk0V65cYXZ2ljdIULwL/E/4JLPwke7wIQ7xHxCEEKyurnLhwgUGBgbe/IWXQFEULMvi3r17tNvtV1ao7wetVotr167x/cMT6LLMcqPOZCKF5bmcyOS4khyhW3fwRL/QZ7HWJKQozJerjCZifj7mgL9gPpfJ8/DhFuGg6ry1I19UD/QuN8tEdI357Qonh3PIdQ/Jgk7PZmYijydgesw/LwkjEHzvdRnNRLFLPQqbDbaLvl1e26yjqjJziyVi0RDzS0XOnBiiMlcmoqtUK21mTgzR7dpMTefxPMHAcILBoQRhy2Fjvkil0PQLW1c3UN51MT0LxYlQ7OkYXRW54hGqhei6YSxXQELDKvXoKBqWoeAqMuGOQDQ8Ysi4bQtrs4URi2PEQpibDZSKjdmyKc0XWfn6HMt3V1m9tojUNvlrf/fHmZwZQVEUdF0nHA6j6/puE5YdWT7btnFd9yOTJnob7Hg7JyYmyGQyB8rtbLfbB1Yz+U7gY0E0n0ej0aDVajE8PPxasfQdvI5oahEdfWocyzFoz25S+91NxsbGOHr06GvHlSTpjUTz5m/7Ej+2JShWu4SOhcjNRNH3FK/kp3wy8eCbJYa/J0Wt2CdC9arF4t0a2bMxRs/H2V70PXcLd2qMfDqFGchGVLd6DF9MUC34xmT9ocnk+3EWFqs0yibRIZ8cGjGduuNvU9rocuyCH3JxVYGngSp7/MDQXXTVPy5PwNq6Qb3cvw0mkm02mxHuriVYWsuiW1GmQm0MxSNm9IngZgkGww6X0l0a2zkWVqYw7Sgg0d4EXW0z8+49yg8bKCGJXrGHMplg814TPIlwxD9HyakoTidIXg+8mOEhA8VQiZ3MoWbjxM6PEjs3CiGD6PE8ej6KuR20mNRkvJK/4pcNld5m8Lks0Vnrd17qlUxWvtbGOD2GCGREEt9FonnQXBpVVfm5n/s5eL0Exd8GYsC/kiTptiRJv/KK4Q5xiE80JEni7NmzH7ow4saNG6TTac6cOfPWNqJYLO5K8Q1nMnw67xci5Y0IqVCYsKlwZ2Gbp8UyuiKzUKkyHI3QdRxODgT5mPFgYY7EO8kBlpb9SvW5rQohVWFhu0I2FqbWtZgZymI6LjNDWY7l02Rcla3tBkbg7TSDrj3bQZvejYrfkzxqRHCLFk+fFvyq8mKTkcGo31IyaCU5NZFlZjJPqOPRqHTQA0m5VtMPnqytVNE0GbNrobVMHlxbYuJYnuJmnZPnx3E+10JzVOxWlG2h0wu7NDUbbJ2CkFGTYRRFJl6Xcbsyctkk4krIW10URcdSBQ3LIulphNBRXIFb6xJWwmiygtq16a7WkV0PqWkyOhDjZ//xT5IbfjY1DnxCp2kaoVBol3TuRDK73S5CiDeG2L+d2JmXDpLb2Wq1DuzR/E7I5n3siObGxgb3798nlUq9IKL7KrwpGfvkX/keZLODaSooX6mRSr553P0keF//9Q0ABIK1pw3WZ5ssLNdww4IdJZ12vV+EVG00UAdl4oM62SMGa4/90PTcrSrh8dDud5AEj+9XmP6sTxRlRWLuSY0Tn83ujiUbKuEgH3HtscnEhQhy2ubuB0VmLvk32t1vFLj4g0N86xsbLM/W+S8/v86loQrzZX8le30ux6mMier2CXfXVniwlGE6BENhh8lkf/9HQ3VM19/Jo/m+F9FxYwzrVUI9h0oly+B4BcPrcvTEIhG9QvSYRrnmUV3rYW/757QXeB53BO5DuTAYYdRjwzjpPEv3FOa+ZlFeEcx9ucXc77RY+GqLud+3KZTilCoJpMlRvMkYkurfxuHhvgxSeCSOZ/q/JYUUOmu+UV35WgtPCaFlDMIjfojqwxLNt0kc73Q6B86l+aEf+iHeIEHxBSHEYCBBcUEI8SOvH/EQhzjEy1CpVGg2m0xNTT1fhLdvCCFYXFxkcXHxGSm+PzA8AUDHtkm0db41v8FwPEbLsjg5EGgWR32vlB20F16tN8lFDKyqzdpGjfVqg6l8io5lMxz35YuO5HwyFQ7IX0RVKS7UWNn05Ypm18pEQhrz674o+1alybHRDK2uxfvTYyzd3mZ8OMgHDeYWNQjflyr+XKUIwertDWYfbxGJ6sw93WZgMM7aaoVjMwPUax0uvDvBxt01MkHUStH8MVZKW8jnXLqtMDVJw65ZxJ0Q7pKEp0TQGi6aKdBqgkbXQ84a2HEVqWIRScTxGiZ618Woe3Q7LnJUA9NBbnh4XQfN9jCLHaLREGrXYXw0yf/wT/8c8dSbFxuyLKOqKrquU6/XKZVKDA8P75LNHW/nd5J0vkzJ5HW5nX/1r/5Vbty4wZ07d2i32/v+je+EbN7HgmjueA8fP37M9vY277333r4kI3bwOlIohGBbruEkokgC3CY8/FtX3zjmm/JuFu5UKa35YfCBqRCNoKo8O27wra9sEpsJM3Y+wfLDvrxOsygoLPfoSC654333djihcuN3Nxm7nARJMHUpTWm9w/1vFZm8lOLY5TTbq23ufbPI0Ysp0kNh7lwtYLoWatAXPBQL07X8m3LhfpPsqMbQUZ1r19ZJ5UIMaRW+eHIJgLhn87g0yPkgXH4s3WOrHWWrFWazkGJccQB/3KRm8aTk50aGVVht++RswOhSMf0HOKL4HsVUrE23aNBs56mV4ySNDt//n9/C1TQ6RY/oqL9/WlymudRCUiWUqIY8OUC1F+Xpb9RZv9p8JueysxFUoY8Y2E0/XB4djtAtO2xc7eD08lSaaYwzE2iZvkFR0+Hd98ZoHOEG11KRWfm9BqnvPb77/4+CaB70+x/XpO1DHOKTjDdFqoQQrKys8PTpU7LZ7Fs/o57ncf/+fTqdDpcvX96V4pNlmcvpHJ8dHGd9uUEmHHR6C/qWe8Gcs9HyicKOPmZYlpmQ4ixuVDk26JPBaEAoNd1frK8FZPDpZpn3Jka4fWOVbDxCOZArMi2H6XG/FeVwIMpuhDQuTgxRWWsghGCr4M9XhVKPkK6wttkkk4pQLHc4O5nh4deXGBqJYvZsjkxl8TxBLr+zYBecOT3Myq0VPNdj9v4GqUyUxcdbDE4k6FxqYXfSFLoekgxChlJDopuJ0NAc5MEw1kYPBxXF8XCLHXJtFSNkYLV6KFEdr+GCJ5OIhXG32jglG1mVMYRAMT2SyQhSy+LkySH+xi/+V4TC/eLQ/WBzc5OVlRUuXrxINBp9xtu5t/PdToj920k89zOv7PV2/uzP/izpdJoHDx7wuc99jrW1tTf+xndKNu9jQTRN0+TGjRtomsaFCxdQVfVALcBete1OBwjHcZj589+HETKRHZut31mnudx4yUh9vKqSfQdXf3edqfdTSLIgN9IvoDECD/3K0wamYTF2KYaQBMMnopQ3fEJWK/RYWKgz8Y6fXD1+LonZdXl4tcTk+2naPZ9Qea5g8WmVblBp7nmC5bk6mekwZs+ltGZx7GKG7LDBvXslZE1CD8tYpkdqIErdcqlXbGIpwV/5T56iyL4RqzdlyusSO2QSJNbrSdxaiEHdYSjqstbtG1hX6xM4y+mvsFp2IIlhVOiavrHrmBGSXp1GNUoi0qRXMRk0ngKQTvpjxqbChE4Y1NGZ+3qDjZst4iP93Ccr8AKHcyG6Bf+cRYb7hUCe0n+4ZSTMhsviVxtUimEiZ8f8Hup7OgIpsf7YkfEYbteDRD+88GGlLF6lofk6fFz1zg5xiE8KXtWG8lV23fM8Hjx4QL1e58qVK+i6fiAiseOYME2Ta9eukUwmXwi5K4qCBBwPZ+lYDlpQdb5W9+ejHTmjUqfLiXwWDzibyVJZadFp+lGZcjNIsSpUUWWJ+UKNXDxCodHm5EiO05ksNF0QMJj17ZwWeCbrLT/EvbJVIxLSULoeq0+LLC6XGcjFKJXbTE1k6PYcpqcG8DzB2EiaMxN5pCDrS8bP6VxdLiPLvkZmMmUQ1RW62w3KhSbHz45hWw6D4/6EaGkC82ScbceBiILZcVCtJF4HYqZM2tJgtoemh3E7Npqho1gyliRhqRKu7SKvdohHDEJhlc5qDd1TicfDJBQNzZHQkbBqHaaOxfiTf/V7aTabByr+WltbY3Nz84WakB1v5w7p1DTtmYIi27ZfKCj6KATZDzqvhMNhZFnmS1/6EteuXXtGrvFV+E7J5n0siGa9XmdycpJjx47tGocPSzR39M4GBgY4efIko3/kBJ4agpCMXbf44K9+/bVjvq7qXAjBr/2zWa5f2yJ8VMfZQ3ya5f4NVqt0uX+9QmJGRt9TqDj5ToqNxRaPH5aZ/kyGwmbfzV2rm6hxhR0bOX42ycJcjfy4v/JNj4Z4OlcilvIfhPsfFBk+H6PdtFmdb3LsnQwhQ6Ha7pEdjgCCc8oqk4H3smPJqCJMTpN3pCeZLYeJ1Dxie+qtSs09kkG2wzcXkzzaHESp69S2UtS3UtiVECsb42xUxtkuBZWSoR4gkc93WZwdwog4TE8+QZZd2htd8u9nIRJj7VsumqZhlvwQfLvjG1FJgeai/z4+3ieXsta/VTvVfkFVt9jvaNRa77LwlSbVbhKh9vdf9KP8aEnf05k8l95dlcLBpImex9t6ND+O1YGHOMQnGa+aV3q9HteuXSMWi3H27FkURXmjs2EvJElCCEGj0eD69etMT08zMTHxwnY788oPn/Z7nz8ulIhqGlvNFjPZDI7ncSzrkzNDU7kyOExpq4vtCrbbNrois1ppkglrdGyXqVwSTwjGs0niYZ1BxeDRoy1aHX+xvrpdQ5Lg6WqJWCTE8laVsYEkAjiXz/L0/haTE36BUdAwCE0LWmHWO0QjOl7DZPH+JnNPtklnoqyuVJicytFqWpw4NYIQMDoQ5vE35rEsn8hurpbRdIWn99bJDyfpfEbCtiTkukukq9JphqgLDxFXcTWJriVhx3TMkAQhBVa7pAwDp9jG3WoSl8IQCWN5AopdYkYEPazhlTqY1S66ANVy+fz3n+Sv/8//NfF4nNXVVT744AMePHjA9vb2bp/7l2GnVeQ777yzWyD0MuzopmqatltQpCjKM97OnUr2j1qHcz/4dkbKPoxs3seCaA4ODpLP55/5TFXV194Ye/F8hXi5XObWrVucOnVqV+9MkiQyf/gK7SoYhkVztsqTfz73yjFfRjR38jWWnlSYf1Dzt1MkvvH7G6TPRjj5fVm2ln3SGM+pbC0ED92iydp2h8FTQXWf65Mj1xFUWz2SIyF2kgv1uMLdDwocez+DosHmeptGxaTnuiTyGtVOh1rBITUaRgvJnP5Mnm98eZ3jQeHPvatFzn5/noXZGvevF/m+70vxZ9/dYr7un99HGwkyqsNAxGW+kWShGiIjdAYjHo/KfWKXl7tstkPcWsuS7SgMaxHGZItBzaLuxJAlyKoN4nRIOU1cK8HTJyNEYyampRHRuyi2ghbWyaWbfOqPbVE3ZR5+pUZ7Mwi1T/Y9errphzii4zqu6Z93h35+qNXov/cCMq8YCu01/3xrMZV2EGbv1hxmf6tJ6MQoiqHS3eoTUyEkJFUmf2EARVHodDp4nvfSVel+8bYezcPQ+SEO8Z3Fy+aVWq3GjRs3mJ6eZnJycpcgqKp6IGfHTn3Bu+++Szabfel2O/PKmaEBjmWfFWCPhvz5odLposkyuiXzdLbASrnORDZJx7IZT/kOhyNDPjn0hG+vSpUaya7EnYfrGCGVxc0Kw9k4lUaXE+N5bMflWNAJZzgdJ9oSdIKGF5vbfmFRsWoR0n0R9lw2Rs+0mckmeHpnnZnjg7iux8iYT4K1oBVws9FjaijO0u0tEukIWyt1ho+kqJXb5MaiyBIMTERYGW7SCtmgKWy1JdSoAbZHDA1nvosomcRtGaXYI9aS0dMRaj2TUCKM5qp4TYuILKE1HbBlhAtuoY3btolqKnLX4Q/8kXP81//Dj6FpGkNDQ5w9e5ZPfepTjI6O0mw2uXnzJjdu3GB5eXk3h3GnlWiz2dxXK9GXXU9N09B1/RlvZ7VaRVXV78q8chAHxndKNu9jQTRfhoN4NHdWnjv5NXNzc1y6dOmFYqKTP3kOVVaptSMossvdv3uXbu3l5+x5oimEwPM8PM/jy7+8vPt5esD3kM0/rNLGYfxKgviAQn4ixI73/Ng7WbZXusw+bjPzuQybi/3Kc9PrcfPr20xdSTN0LMbjG37nhbsfFDj9/YMUAwHz4kaH2IREL3B+zj+sMfNehgf3CriuYHmuxsRMglOfyfHlX1/m/Pt+wc/73h0imsew1+YbiylOp/uyQJYZImSGCAchdV3bIcISm90U1UqKad1BkSUK3X6uS9P0CakiC6o931Wb1BsMpzqY5TCLiz6p7fZ0DLdL14szkpunudkilFCozvkeS1X1DboWVWgEBD0xvId8WcEJlAT1BT+0ZIyEsYMOGLEjMQI7S2zi/8/ef8fHdV9n/vj7lum9oVeCJMDeJIqqlnu35J7irGzHsZ3ibOJN/TlOnN0k6+/G68TJxqmb6mTjIsexJcUlki1ZskiKDSQAEgSI3qb3duvvj8EMQQokARJS5AjP68WXIHLm4s69dz7n+ZzznOdc9uD0dnswVJOZp3NU3CFEy+Uva2mphH/Aj9VlQ1EUzp8/38hgwPNtLtayQBiGsVk638QmXmJYS+l8bm6O8+fPr0oO15rRNE2TSqXC4uIihw8fvq69zMq4Us9qFpUa4RtPpLGKIulyhQO+CIOji2xvrRHKgKsWZ8xlSdB0IoMATCXz7O1oohLXcFqsVFWdZm9trQ4s+18K4rJ9XrrI9o4wi6MJCrkKE5MJfF4ryVSZLd1hSssm7IZp0t0eQEpXUco1Up5MLpfrx6I4XVbGRqNs296MUChjk0SUqkZHb+1chWVJVimj0dnp4Zg5jaMkIszp6GUXYkWAkooXK/mYitjsRvXIlHUdq8WBiYBZ0bCXdIzZci1r6LahzBfQMwoOuwU5r+C0WvHarUgVnbf/2GF+4pfe/LzrLQgCfr+frVu3cvjwYXbt2oUkSYyNjfHss89y7NgxstlsY/T0raCe7czn88zMzLBz585biis3QzSr1WpDD7wWvFi2ef8piKYkSWiaxvDwMJlMhttuuw273f6811k8Vhy3R5AlKBZlzEqF7/7M0VWPuXJBWEkyBUHg9A+iy6+B6bEaARIEmBzNcO5EnKVsBXvQgcNbS8FrKx4qRTewtVhp6XMTanMwc76WbRt+LoEcVnD4ag+WbBUYPhun90AAyQI2l8DclIIrYMXjtwIm8WyZ7t1+wKRU0LD5JBajBUwTBk/FeMu9Evf3ZgCoYkErOKjrMguKiJERKBmX9YvtUoWpoovFTJBeUydduvyQe+XLkgCHeDkjoKjLHd8WhVTRjUUykLAxNd6GJ6whizrlpEjIHWfn7kki2y6Tw9Ky/jLQ57rcrGNcJpeVhWWtZpsds7o8lst9+VrKbmnFz5dL5Vb/5c9kynZmxyW8O8NY/DbKCyWC+yMUCoWG5YjP57vC5sJisTTu/7U0OCtxM55rm6XzTWzixUc9rhiGwfnz50kkEtckh2uJQfU+AICdO3det+wKV8aVN+/YhigIjCVSNLldFBSFQ+1t+MoWRK22nlSXJ/iMLyUQBZhK5oh4nKQKZfrbwuxubcJZFikUFXye2mcQ5Nr6NxPNIgowOh3H67QSdNqR0yrJZJG+ngiGaRIJ1Ta7luXNeCpTYltPhLlzi1QKCpcuRmlq9hJdzLK1v5lyWWVLXxMtrT7cwOJEouGROTY0jy/kZGE6za5DnXhkAatVoni/Da0kkPW4yVtMzJAFQYdSCUTNRE+W8asSjqSBTTMRNAM9WQZNxh50o1dVjOkcVpsdV8CFtaRjkSQsmoFVN/jxj97H2z/yqjXc/ZqOsaOjg3379uHxeHA4HDidTo4fP87g4CDz8/NUqzc/5yIej3Pp0iUOHDiAw+G4blxRFOW6pPNmm1TX854Xyzbv+t+KFwmr7TxlWV7zDTcMg6WlJXp7e+nu7r6uNqLzoV4uHjuGYkhkEgLV0zFG/t8UO3+054rX1cvx9XJ5fVLA6aNRnnxqhoE9QdpbPTz3nZqXZt8eH6NnayWIrm1enn58Dl/Qxq5XRDj3TG0TIIgwM5EjvljCYhO589XtLDyWBwSCLXbOny7iDVgIdVpw+kXGhkoklsp0b3cRanJz8uklsqkqnX1eevf5ePbJmr3SwTtbmBvLMjmbRRCgtdPF0myet7VMND7P+JKDnT6N+aqLVmuR2ayHLrvOeNFGm71G+GbKboqKjX57bffausKbuEkuUtIknLJOQM6h6BaskopTuqwvrWg2oEDQX8CKRj5nJ1t10NyUY2kmQu+WJUrx2mttPpnsZBF7wIKjxY7FG0ZVoaiC0BWojaPMKBguDSEk4G32IgsmVrdEdGwJgFL+ckm8Wrj8rBj6ZVIs2WXUgs7YMzr9b26m9NQ8zh3uxkjTq7OK9S9pfSdZXxTqz0H957oup571WO/O82bsjTaxiU3cGmRZplKpcPLkSUKhEAMDA9eMFzcimuVymTNnztDd3b3m6UB1omGaJiGHncOdbRydmafT5yVkd6CmVaKpAkpVRxRgbCmJzyaTrWrsbI8wMh+nI+Qjni/R7HBx/Lkp2sI1ffz4bGK5bJ6mLexlIZFjR08T56dibAt7GTm9SGdbbc1JJDIAxBJlZFlkbCJGKOAk6HGgJUqkE0V27mln5Nw84SYPsWgOZXmEr6poaPEcQ+cXaOkMsjSbYsf+Ts6fmcUTsGG1yJRiWWIzcTIRCXvKS7oIPsGCUlGxaSbVooihK1jcVsxomapuIvvtFIoK1pyKx+7GUHW0TAmLKmJ1O2vNPot5EARciNgE+MCvvoG737h/HU/AZUcAt9tNb29vQ19bKpWIx+OcO3cOwzAIhUKEw2G8Xu+a9JaxWIypqalVB8xcK67UE1j156z+7/W4sp4BATc7zahum3fVsX5zxc+vWfdBr8IPfUYzl8tx4cIFXC7XFfqaa8HZ48HR70dVNVwekWpF4MRnhigmryS19RutaRqmaSKKIoIg8NW/HwXgwlCKpVQRe7tM32EvVe1yOdyxnF3LpqqUdBX/Fjs9u330HwoRX1ye222X+cH35uja58PfZKNlixtNNUjFqpQUE7vnsl6yUKwyPZfCF6qlxBVNZ3axQLil9pozx5foPRgkkyyTiJYplTXef79ENl/bKU2VfWz36IBAoSBzOuqhy1K7tl1WjZImcmLJQagiYhYv7658okpCq+2SRUEgXvURLbqZK4Q4NxFkKtVMuuxiNhGkqkpYpVpJ2y5XSWadeCwV5mYiqJoVQxGQJYOwdZzIfh/hI0GMVhfTizpLsypDj2eYGSpy6fsZFoaK6KZI7EKZxHkVUXUz+kSe4ccLzI0b5GUP7j3NuHwehOUnuDh/+frnlj0zAZTlqUGmDumYhGtPhKgtzr59+9ZUur6WBmflrlRV1XV/wddr2L6JTWxifVjtO6mqKmNjY/T09NxwaMf1YlA6nebUqVPs2LGDtra2NccrURTRNK3RLFIvn1sRmRpLMjIbI+B0kC6W6Ql6MUzoXdZj1s81nityoKmZ06dn8TitLCRy9LQGqCgaWztqr40se0cahsm+tiai0wUEYClWwm4TiacqhIM2cvkKW7qCGIZJf1eYi0enG6QoFs0hCDB2YQmf38HMVJJDh7qYOTVNW2cQ0wTPcnPl7GQM2SKCLuG1Ckyem2Prvk4yAy6SVhta0ELeYeAwLWQMEc0joztk9HgVj8ODXFLR40W8VRNUEQUTUxKwV8AsqMiGQHkui2iAUxdwyiI//98fXDfJ1HWdwcFBfD7fFfdfEIQGh7jttts4cOAAbrd7zQ1F0WiU6enpG04xXPkcrGYWX+cc9SraeuPKRo3O3Gj8UBPNxcVFhoaG2Llz55pubv24ze/qIuDSMFUNwzQpplS+/r4fNF5TL5Wbpsnw8DCxWAxN00hES3zzq5cAiDQ7GDmTYGm+yORkhtklhV33ROjY6uH86QQAVrvI2EiaqbEs54bjSH6R0DI57Nvtp1zSOD+YRPaLqOblz9ra5+LEs1EGDvsRJXB6HSxMldEEnUinBUWoMjWWRTVNurZ62XWkiSe/M0P/3jAOl4zPK3KPPEOrIDOVsWEtXj52Lidg1S7fdqtg8syMm+1WGVEQ6HXq5IzLGo+MYmM672Yi00wh48JWlPGWDVw2F35VJWiYpKNuikkfmaSduURNLF5Y1nRaZZ1C2ofktBAJlvE6pxg6kaOQNYhPlBEESF2qZUWDvZeJX7VymTiW4rVNgCBBZqJIIaYyc6bI2W8WKNh8BO5ogWXpqeyWqSzVXm8C6YnL04FKqQqz5yrc9urbbmpMV12Ds3KEmSiKxGIxHA7HujQ41Wr1psfZbWITm1g/FhcXicVidHR0PK/5dDVcKwbNzc0xOjp6RR/A9VxK6jBNE4vFQiaT4cKFCySTSe7f0s1dLe2cOjtPbziAbph0R2q6d2FZdL6UrW2cRxcTtAU8eFQJNa+gajpb2mq6Uo+ztpbkS7W1b2IhRcBtRyzopBbyJFNFeruDqJrBlp5lU/hlg/dcvkx30M7Qs5NYrRKXxqI0t/pIxPJs39GKqup0dIXYvbOV7GwKtaoxMx7D5rAwNrRApN1DIVtl3+Fe4qNzVIpVBAFOFKKYPgdiWsGvW7BPK5TTKq6ygZCsEihLOGU7pWoVwWtDKhpUiyYelx25UMVcqKCqJg6XDSFdxu1xYtcMPDaJX/7f72XvXVck4W6IusyhqamJ7u7rD7exWCw0Nzc3Goo6OjpWbSgyTZPFxUVmZ2fXTDKvxkqz+PofwzBIp9NYrdY1NxTdqk3fC4kfSqJpmiYXL15siK/dbve6Goc8h0P49jWjWk0cDgOqGtHBDN/73aEr9JiHDx+mu7ubYrHIyZMn+ePPPEH3DjdWm0hHnxd9uUS7ZXuIbLrKsWcW8LRb6bstSHOXi4GDYXLp2hd/6+4ATz8+RzRbZM8rIkyMpxvn5A3ZOXF0iYHDITq2ujh3olZfHjye4MCrm0kuT9FJJxSaev34QjWSlIyVwamQXl6Ihk7H2TLg47UtKQIWHatgEis14bfWzjOtSDRJNnTzMqG7WPXQaXez0lNzqVJbtKZLLso5F96KhYCq4NUrDQmlW7hMBK1OAVGAiEOlWvIwM9WEsSxab44UsKBQzeoIpolNUAkFcpQStesS6nM1so5W5+Xys5qtfalkh0hmspYF9ve60Mq1++zrrWUDs/MKyZhALG/Hf1sTvq3eRlOQu8uFvpyhNYUaSY0c9N3UYnAtXLhwgVAoRGtr66razuuRzv+oWbqb2MTLCaZpMjo6yuLiIr29vTfUUdZxdQyq6zqTySS33377FX0AN0qM1OOKxWLhyJEjtLS0kEwmOXvqJPZlKyKXvXZe84labJjNlPDYrSxlCmxtDtLkcdFr8zA1ncJhq23kk7na2jg+l8RulZlarNkXOawy231+psbitDbXSuuVSk0iFU/U5qGPT8aJhN34RCtWTaZS1ujo8mGaYLPVFtFctoQoCkiGwdzZOaZGo/Rsb6aQq7BloAWoyREG9rYz/OQILo+d+Usxdty2hfhdbjQZJJ+NYrSK7nFSdUtUPTL2KqimCJKAUNEwp/K47A5cThvleB49Z+JwWPHbrch5FVEUMHMlfE6ZX/jf76Bv1/o8w1VV5fTp07S3tzecaNYKQRDw+XyrNhQ9/fTTjI2NNeQTt4p6/BgaGqKvrw+/37/mhqJSqfSSbTB9SUS6a3UHrpam1jSN06dPA3DgwIGbMnc3MPDfsQVZcpHO6FhcApJV4MzfzjD5g3hjZyCKIl6vl76+PrZv28e//L9FBgeTSH6TaDZBa48Nr9/KyJlaBtPplhkZTHLi2UVmojlU2aC7f3l3KtU+Y7Wio+oGqmCy644Ibb1uzj5Xay46czyK6Vbp213baQYiNQKqmAYDB0L07vRz/AcLnD2V4MDdzfQO+BgfK3FhJMv2/W6cHpF0IsmrXDVN6ExepkutMpx1YJgwn7LjANpMjbhmYyTvoKVkEtB15sqXF18bEuO5EL6STLNWJa/XiJlDNklUahlZh6iSUWuE1CeXGgTUMGS8Dg2/qHFhsgndgETGRcijMJfsIOwvsmN7nOT4cpd5y+WsXiVdW3Alu0BhtpaiDK5oFHJFLmdarSsbgewi5YzGyHdy5AUHwQO1Xb4jcll+YG2VMKvg2WXj5MmTz7O5WC8Mw+DcuXP4/f7GIlPPdtb/SJK06gizl2p5YxOb+M8EQRBQVZWTJ08iSRIHDhzAZrOtL1YsB3NVVTl16hRWq3VVG5wb+S7XiYEgCEiSRDAYpL+/nyNHjvDOO/cBMLqQQBYgXqzSFfKh6Dp9LTVLoojbibJUIZaoJRXG5hI4bRbmYlm6W/yUqyrbOmtl87agBxIK+UyNWE5MxRFFWIqVCYfcxJMFtm1twu2ysSXgYXJkCduytVIupyIIsDBXwOuzE1vKsaXDycj3x2jrra2rxvJYzPHhBTx+B0G/C7NQolKoEmypxbtzySUIWJBECXdKwFQEhKyCqwrWqTJOuwPyFZR0CbthQXY5MSwSlUQBNzacdisWw6QSLSKaAvaqQWvEw3/7g3egmEWOHj3KyMgI8Xj8hvezWq1y+vRpenp6aGlpWdO9vx7qDUXhcBin08nAwADJZJJjx45x5syZW2ooqhPi3t5eIpHI80rs1zOLfyk7mbwkmoHgsuFtHat5mBWLRQYHB+nt7aW1tbXx92spW1z92v4f38Kp/z2CLewhn9GQ0VBLJv/yUyf56LOvwO6+sqz5B79zjFKxRnyDTTLnh2pf+IO3B1DKGql56N3m4/SxGuncfSjC0e/XmnXuflU7uVSNRPmCNkbOJijmVeLREne8sg3ZLjJxPkPndjvnBwtAgQOHm5EkkVNHlwAVRdXZeSiMZUpEL+uMXUjR3uclGLazOFfk0miRnbeFua8yhkM2MUwQRBsiBiFV5Piigz2uy1nLi3EbO20GdWf4iuAEcsxpboSkgN19eXJQRrfjWdZf5koiTcv8rWw68FPFbjFI5O1EvBVsci3TKYmAKpNKhSiUTZoBragTK/vY0p3ixHEDEDDVZU9MCyTHamXu8HYPiXO1bn67f0X2cYXWXl0hB6jkLm9ISimNS6cL9BwOwwpbI3+7j/Jsmt1v6qf5QIBKpUIikWBsbIxKpUIgECAcDhMIBG64M72aZF6N+vvr/61nyFfqOpPJ5CbZ3MQmXkDUTdj7+vpobm4Grp3AWA31BEbdoWLlca712qthmmbj9622rgiCwF07ttDqd7OYKbCjNcT5xSTW5Wlw8XSOPS1hxoaWMAyzQSynlzLs6Wvl3KVFvMvWR7lihV1dTcwMRVHKKpPZJKGgg2SqzI5tzZwfi9La5CWRLGCTJSwZhYlEFFkWGb8YJdLsIR7N07+zldGRRbp7w5SiOdTlSW2To0s4XBZmLsVp6fYQnS0wsLOV5x47gy/sxuGyMT44y/YD3Xx3ewGPIZNbrJA1RCxeG0pJQSqBHHSTqShYHBZcBdCqCi6PA6GoIGgyqq5jN3Sq6SpOhxVLUaG51cN//5sP4XTXgo9hGI2Z5JcuXcJmsxEOh4lEIldkmsvlMoODg2zfvp1gMLim+74WzMzMkEwm2b9/P5Ik0dTUtGpDUTAYJBKJrKmh6GqSeTVWNhRZLJbnNarOzMyQyWQ27DNuJF4SGc3VcPUXN5FIcObMjAPdwAAAecBJREFUGXbt2nUFyYQbzyVf7bj2oI2t7+zCLZpIRZ2SLlMVTNSMxt+967krjnf02XlODUfZcShIe4+NsQvLXdltbobO5hgaylMRdRLFIl0DNhxOgYmxemncZGmxyOBgjLbtHnYfjlAq1Ejbjv1hnv7uHMMXkvTsdWJ3XdYN6oLJ8Pk4++5sQhCgp9/H09+dwxO2MbAvRKDFwanjS6RSFW6/u4XuHT7Gj88S0Q0MEyZVN+HloeElwYJFvNx4EtdlWjUnlRX7jICmMa4EcGclXLLETPryl0JSL5N4j+PyPRGqKwieWcs2ei0VikrtuKouYkfFYgjEsl48tiIhRwVTsNDZVvMLTYwv+2N2SBjLnux27+Xz0qqXf3chenkKUHq5nM5ySfzqv586nmd2WsG+vXZepg6yUyKyp7bjru9K9+/fz+23304oFCIej3Ps2LHr2lzUSabP57uhzqeOlRocURT5yEc+whve8IY1vXcTm9jEzcFms7F///4ryOF6/ZlLpRKDg4Ps2bPnmiSz/tqrkx31xo56dexaWFxc5EBzbX2un1m0qGCRRMJWB9m5PMWySluwFh/qxDJbqG3q62XzoMOBEi2TzVboW9ZhBnw1YlYs1xbXiekE/VuamD2ziNNuIZsts22gBcMwiSzPLM/nKgRDLvJzadKLWeankmzd1YZa1enYUsuaqlWT1lY7z/3bGVp6Q2QTBXp2tgEwFU9gbnWRiVaRvE4Mi4haVgiUZFyCjJgu4ykbyAsVdARsQReVpRzVhIJkgMsUsCjg9zkQClX6toT4vX/8aINk1q93IBBg27ZtHDlyhP7+/kZPxbFjxxgfH2dpaYkzZ86wY8eODSWZU1NTpNNp9u3bd0Vme7WGopUTioaGhohGo6iq+rxj3ohkroaVjarFYpFf/dVf5d3vfveGfc6NxEsmo3k16guCaZpMT08Ti8W47bbbbrmBYuWCsOtD2xj9x0ma9vuZGytiVEQ0q0FsMM3ffvAEH/ib21mYz/MzH/4WCwsFZBm29AXYus+F3SIhaLC4UMts9mwN8NyxmtXRnXe3UC4pSFYDf8DK6HCNdOq6wePfmaKlw0VXp5elhcsEyeV1cep4lAN3NZNNVhkbTZHLKhx/dpF7X9vJwlwt27cwW6C5w4loyviDNrLpKmVVo1hU+cgukT6LxPmCn4hZBQk0E6oVOy26ScIq4xANqnk7XmCqaGGXW6eqw6LiRclohB01gh12W2B5Mk9IqlI1JRJ5CVW0E004CbolBMNgKm/HNEzyKgiEcQgFTJsdF1nc9tr7/S6VYsVJxSZhCjoOocqeO7KomW0UYmU0j44SMtGRsNkslG0CoTuDyGIt4epqsaGWdLJTNRLp7XSQnV2eLrTFRapehu90kJ6pLb4Wt0j8Qom4CQOvCFNYLNF8KIAoP3/BlySJcDhMOBzGNE2KxSKJROJ5Nhdut5vh4WF8Ph89PT3rfvY0TeNDH/oQd9xxB7/+67++7vdvYhObWDsEQXhe099aiaZpmiwsLJDP57n33ntvaIK98rhX+y5fK5NVn0pTLBb5yTe9gn+7+EXGlpJEPC6y5Qp3drTx3OlZ9m1tJZ5bRFk+7YszMSySwEw0Q2eTj/lEjru3dXLiB5PsGmhlbiFDbNm+aG4xj8NuYWYuTVdHAI/DirWoUypW6e4NsTCfIb1sxj42uoQ/4MA0TNq8Di6cmmbHgS5y6RmKuQoIcGl4ifbeELKq4XLZWTBBV3UEEc4/N0lnf4SZ3VYs8yaGYmIkSvgcdioZBd0poptmzVe6KmH3OhFUHW0mh1WwYvPZsVU0zKqORRQwcxV272nnE3/20A2rTE6nk66uLrq6utA0rWHEb7VamZubo1qtEgwG16zPvRYmJyfJ5/Ps2bPnhudUbyhqbm5ujCeNx+NMT08jSRKhUIhIJILFYuHMmTPrIpkrkc1mee9738snPvEJ3v72t9/sR3tB8ZIhmleXzleKYgVB4LbbbtsQse1KAuvb7qHl7gilxTK2ooHmkFA10C0ik4/H+Mufe45/HZ+kqcWKxeogEvFyYllPeedd7Zw4vciugxEiIQcnj9e8HXt6vZx4LoaqGPgDNrwWmR0HfUyN5lC0CrpuMj9boKXTRTSTZ/ftfkxN5uTRJXTd5MSzi+w4GGLb7iBjQynCLU6e/v4sqqJz8I4WnE4L3/9ebWSUx2Plvjd28eQT07SKGgd21zJw+YxMAYO9QZVJ1U2rAQgC0Yodo2LQvqwXjRgieV0gUXITVCEmWoBaltKnq+RkC4KmM19wopRFup0mNqAsWXBoNaKXE+34xTIuycQoCAiSi2zZTlkWafNnqWoWbKJK0bThryos5W30NWUoxUtUtCozw8vkMeRjYSIDaMRmKqhFE0+LheJSbffXd1cQF2DDxGKTGkTT1WRrEE13m71BNG2tIuWLtQ3F3GgZV8jCrvubbvh8CIKA2+3G7XbT09ODqqokk0lmZmZIJBI4nU6am5vRNG1di5au63z0ox9l165d/Pqv//pm2XwTm3iBcS1/5huVzg3DYHh4GNM08Xg8a5q0IooiqqqumWTqus7w8DAOh4O9e/fWYlxvO89NzNMT8ZOLlsgsN4FOLKSQJYHZWK7hj7mzO8LIdBxZ0Oh22JkdqzWQjk/EsVoEEqkK3Z1BpmdT7N7RxtD5BdqCHk59d4ymZu+ybVEUf8DB0mKWbQPNjF2IsnVrE6M/uIQlVMuwjg/P4w+7WZxN0bE1QCGtEPJYOfvUJDaHlUCTl/hchp2HtzAxNIdoFZiI1LTpssuBkVOoZDTsHgeVdAlZMQgIDqpKFRMNMafidDgQdRM9XqCsGHgcVsSyxoE7evn4Z370htf+ahSLxSumNGWzWeLxOJOTk1gsFiKRCOFwGIfDceODLcM0TSYmJiiXy+zevXvdXKTeUOTz1SpqdenWxYsXSaVSBIPBBudZz7Hz+Tzvec97+IVf+IWXLMmElxDRvBqVSoVSqURHRwddXV0bFpjrN7P+Z+dP9vHEB4/StD+AYYosnC+SKxkkNZ34P8xi+irMOkp0dvqZmsxxx5E2HA6Jo0cXUBSDaKzIxGSGUlll721N+H02kqkKqqLQ2+fn9IllYnpvO5WKhsVhQasqnDi2iGHA8HCa5nY3e+6IEJsr0dbl5tlnaqNG2zrchNscROMFMlUdTTd49ug8t93VytR4hu5tfr75bxM0NTv52R4T0YSFikC7KWIIDqZNK00Vs6HDTOetNNlN6mRSFESmy2Ha1VrmMWwYFA0Bl2hS1EQWVDfhkk5YEEhYRWC5lKybsCydrCoCWGs+mznBToAyNk3FYQrEk0FSFZ2B1ixaWUNyg1W0EU07sUoGfmUe8CEA8WWLo/AWJ8mJGvn0tdkaRLNcKTNxqkYut9wbxHPQj900r5RMiJefEV+Th8zFWibZ2+Vg9ngG/57Aup8Xi8VCU1MTsViMnp4eAoEAiUSCqakpZFluZEKvJ8LWdZ2PfexjdHd386lPfWqTZG5iEy8Srk5g3CijWa1WOXPmDC0tLbS3t3PixIk1/R5JkqhUKlcM97jW97xarXL27Fna2tqu6IB+y8F+FtN5yvEKs7MpECDsc5LIltjZ28zIZJSw38VCIkdJ0Qh4HNirFpaiWSpVjUjQTjxVYUuXn4mZDE7Hcmd6qsCenibOfv8S/qCTWDTHtoEWxi4s0d4ZIpOeo1JWGRhoYfTZS1gsEgvTSbbtbl+e9mMnkyhgkaxY9SJnnxpl275OxgZnae9rIh3LsTARo7e/iR8oCTxVO5WigqAY+CUHmqGhpIp4ZStlTackGVjdNuR4ueYK4rZgxIqgm3gdNihq3POq7Xzkt9+xpmu/EqlUiosXL7J///4GkfT7/Q0bqnK5TCKR4Pz586iq2tBQ+ny+62aex8fHURSFXbt2bcj6bbfbaW5uZmFhgd27dyPLMvF4nIsXL+JwOBpxZbUJh3UUi0Xe+9738pGPfIT3vOc9t3xOLyRekkQzm80yNDSEzWZbsw4O1mZWKooixWKRYrFYS7e/rg3PHa2IIhg5FX+Hg6agjVBa4dJsjpaSCx0Jp9VCV5cHSRZ48nuzOJ0W7ntFG4IIp09G0XUDBHj8iWksFpFXvr6LfFbB47PS2uri2NEFVNXA47UQDlvYd7iJmYkc4WYrI+cyTIxn6N/lJ1OqsmtfhNGRBG6flae+N4vTKXPfa7oYu5imWtE59oMFjtzbjqrptHe68efzbF+ec6+KDiTBBBMmpyzsD9VI5Sw2OlSZuGAStmkUNEirLqolDbzL1waBlOggrpjYClZEQ0C21rKCXk1Hl0ASICBp6Eat4ccpr/To1An4wCHppCsSAbuOVrYzk7DisOYwTfDKJQolOxabQqclySl8RLY4SV6q7d59rfYG0bQ7LmcSjOplLUx8Kktutva5ug75aLkrSOJ0hsz8ZSlCNXf5vESLiCgLdB5eP9GsZ9W9Xm+jXF6fnbuWhiLDMPj4xz9OMBjkd3/3dzdJ5iY28R+I6xHNXC7HuXPnGBgYIBQKNbKTa4EoiuRyOSqVynUzZfl8nuHh4VWbU165q5f/+5WjXEpl2dYZZmw2QXuTj0S2hKrVznliPolFFtE0g3bJwaVLcXYNtDJ8YRGHoxbOc4Va4mB0PErQb8elm+gFpfaejiCZVIlqpbaBH78Yxe224XPZUFIFyvkqvQe7GEnPkE0Xa9PsLibZfaiLyROX6O5vJTaVILGYxeGyMTE0x757tjF/fp7F8SjZ97agCwZ+h52yACVAttpgqUClouByWjAVDW1JxUTE7XMi5xQEpw1ZNRDKKm981yF+7Bdev6brvhLxeJyJiYmGu8BqcDgcdHZ20tnZiaZppFIp5ufnOX/+PB6Ph0gkQigUalSr6laKhmGwc+fODVu/VVXlzJkz9PT00NRUq7TVn7l6Q9Hw8DC6rq/aUFQqlfiRH/kRHnroId73vvdtyDm9kHjJEc2FhYWGw359huxaUM9UXm8UYH10YEdHBxcvXkRRlJoH4isCfP+T43i3u5FdFkxDp5go0tPtwXRZacoXyRQU4g6T8ZE0dx9px2ITGT6fJBYt4XLJ3PeKTioVneZmJ+0dHh5/fBpdN2nvcOPwWdl/qJnR8wkiTRYujZWYnChx5K42CgWVg4dbiEcLzM4WyOdqC8DhOyMIpozbayUYtPPciUWKBZX9tzfj81p54vEZAJxOmfdvtVMwFOZLAh1Cbfc+ZVjZKsvMCTr2aglbSQJRIKLAjCghGg48ioBHlkmJEDQ0ioLIzIzEdmftsfBhkkfEg4FVFEhhIYKKDCyVJdpdOi4UirqES9LxWC8vymXTQgAdv0PDYYBSdDFb0ukKF8lXrHhlAY+1iCzp+FodDaJpaJezD7nFWgZTEAUy07WfbR6J/Pyy76ZXYOpklinA1y4T9htIiwKGbjbskwAKsSqt+3xYXet73Osk0+PxrKrJrDcUdXR0oOs66XS6sSuVJIlnnnmGyclJ7HY7n/nMZzZ9Mzexif9gXItoLi0tMTExwf79+xvVibWSCl3X8Xq95PN5hoaGAIhEIjQ1NV2hEa3Pwd6zZ8+qFRCbReauXd386/dHsMi1ODYXq40VHp9L0BR0E0sVuHNHJxdOztPaXWvMicWzACzGynjcdhKpEtu2RIgnCnT7XQyfnKeppXYel8aiOBwWZqaS9PSFmZlMcmBPFye+PdJo9BkbWiAQcRObz7BlZxMSEsVYmmK2zOipKVp6QixNJRk41EMuVWBueBaLVWbSYWA3BbSkgqmDzyZTyBShZOB2ujHdUFVU5KSC025DFsBMlTBMAZsOVt3gwYeO8OBPrW1u+dX3b3Z2loMHD67ZJ1mWZZqamhod41drKMPhMPl8vuYTep1RpetFvfFnJcmso95QVG8qUlWVVCrF7Ows+XyefD7P9PQ0jzzyCO95z3t4//vfvyHn9ELjJUU0L1y4QLlc5vbbb0eWZQRBWLNmob6AXIto1n3MRFFskANN00gmk+TvXEJ2C4gWlYWTBWxdEp4uL6IsUkqpOA0Jl9dDR8RHR9hDIl8hES+jljRe+9peNM3gxIkF8nmVI3e2kUyWOXykjVyuSj6n8NzxWpPQ7j1eRMHG7Ud8GLrBc8cW0XUTr89GU6uT/tYwxaKCx23h+LM1zWdzqxVfWEK2Oxi7UEWyiHzniWn6tvlpjjjxJLNsLxos5l1IbsDQSZkiobIIAlhTAgnRSefyNVQRSKteutW6TkkgljEpOmTkgoNOUaAgG7i12sjKHBY8yyXzXN4k4oVMVSSjSGiGjKqB3WcnlS3htGkUVAm3RcfpqH0p3VadnGrHJamkSm6mohKSpOMUdeYzDnqasujVcOM+JZcbfpwBC8nlDvLIVhfxizXiGOlzMXumtrA2b/cxfSJT+xQOg/HTGt4mid4dHuafqnWz27wyqUtF7vy5LTd8hlZiJcns7e294euvbihaWlri6NGjDA4O0t7ezj/90z/9UOw8N7GJ/0xYTfu/8v/rZdFcLsftt9++rmEOK/WYsizT09NDT08P1WqVeDzO6OhoI5lhGAa5XI5Dhw5d93e8+e4d/Ov3RxibieN22khmS/R3RRididMa9NDidZGdzVMpq4xPJbBZReLJEr3dISankwxsa+bcyAIOmwVbQWM6kcRqk4gtlWjr8LMwl6Grx8vMlIqha2ztCjD8zDguj525iQRbd7UxPryA0yOTjoPLbmfixCWKuTL9h7oZPVkjYaIkUClV8TgtzA+liHQEyb2qGTNaxub1oCgqZUMjINmpWGsSJ7Ok4K4K6BYrkiihzGWRJRG7LCPrGne+qZetdzYRjUavyCreCPPz8ywtLTV8tW8GV2soy+UyQ0NDVKtVZFlmbGysUWK/lYTBapnM6+HqhqJz587x2c9+ltnZWb70pS8xMDDAK17xips+nxcLLxmiOTY2hizL7N+/v7FzqJPHtRLN1coc1xNny7LcuImZn7Jw7A8v4WgRkG2w8FwWe5cNb4cDj8WKoZsU4hqRoAOXz0rAYcNttaAWNGbmc/R0+QkE7SiqTiJRxjQhn1eQJYG9+3w4HDLPHU9iGLBzV4iZmTz9u0N43BaqVZ2TJ2taziN3tTE5meWOu9vI5xVSqTInT9asgA4c8lKulIhE7CTiZRSlyocMA6wiFZsTa8Ig6i6Sq0q01efVinasugByBd00WdTthHIii1aFVqtYG8FZseLRLFiXfTMXswbbljfcYklHcQrM5iUUVWJekbAi4pAEHJqGA0jFBCKyE6MK85IFp1XF6jWoomBDpyJZcJkqdoeBR5coWK1AFY9Hos8tcEmU6LzdDybEL9S66yN9LmaXSaQnYmsQTav78iNrsV/eVASb/aTHU+RiOtFOBXGbiDUn4IpYKA1p9NwTuuEzVEe9GWCtJHM1/MVf/AWhUIjJyUkKhQLxePymjrOJTWzihYGmaZw7dw6n08nBgwfXlbG6Xlyx2WyNZIaiKJw7d45yuYwkSVy6dImmpib8fv+qcW17V6RRNt/ZHmRwbBFBqMnsbYbIyJl5dN2krcXHwlKWrVuCjE+ksFpq6+LcfIatPWFmBhfwuu2k8wV27mln5Nw8bndN75dJq/j8Dox8hXxZoVxU2LKziYmRCrl0EQRYmMpy4HA3p799jh2393L+uUnmx2N4g07mL8W47VUDnP72WWRZoqkrxIxaxK5HMF1WtGwZh9WCkahQVQRcfidCVaeSN6notWYfLVrA7rBirRo4RIGf+v89wOFX72pkFaemptbUuHO1n+VGoO4GEAgE6OvrwzAMUqkUi4uLXLhwAbfb3Sixr2djUieZ3d3dayKZV0PTND796U/zwAMP8PGPf5zFxcV1H+M/Ci8Zorl169bneWHWieZah9RfXRKpLwZ1snqthcQwDPyv1RH/RKClx8/E0TSRHU40Q2f6WBopJODpsmP32dHLJpIg4HPYkYIChapGd7OPdKaCoEFiqcTOgRD5nEI45GB6KomqypwdTOIP2Lj99lYymSqaqjM5kaGr28uF8yl27Q7T1u5m8HSUWKyMoRvYbDI2m8ydd7VjtQk8+d05AAJBKy2tMgMI9ClQFgQcGRO7KDGv+WmRVTBMLpYNWjUREBi3g8PuwJ+vLW6mzYFiVpkpW2lSrczrVfpstesTFCQMNFK6QE61U8lKeJatvxQLWFUdu25SkEXcpoEbA92s6TfLRZWADpRFxqo+fBETpVIi5AWPqaDoEu6KzoWcn+3hDNWqyHPHF9BNgYE7w8yWKoTbHYhNMl33BlEzKrq2oiSfvexBllosXP77FabtFtHG1FgJi0NkYKeEIEHCPoV8qUg4HL6ueW6dZLrd7psimaZp8ulPf5q5uTn+/u//HkmSrtgpb2ITm/iPR7lc5syZM3R1da17JGHdIPtGTT+qqjI0NEQwGKSnpwfTNEmn00SjUUZHR/F4PDQ1NREKha4gSW+5ewd/8M/fJ5aqrW+Ti2kOdbRw7rkZdmxr4fzYErJUi3WFQm3dG5uIEfQ7aQl7sBRUZvJVurtDLC1miUdztS7z0SWaW32oikZPs5ezz4zTs72ZOHnmLqVweq3EFrJ094ewmAKJydqEuQsnp+jc1szsWJStezvp2NLEyX87Q8/OdibOzuL2O1EONiOaIoZuYIoCaqKCbLdj8VgoJgvYMho2iwW3y4aZ07C57ZiZKl6nhY/9ztvZfbgPoLFWbt26lXK5TDwebzTu1O2AvN5aU0F9E79v374NkyXV13+Xy8WWLbUqmCRJRCIRIpEIpmmSz+eJx+PMzMwgimKDDF+vIXQjSOZP/uRPcscdd/Dxj38cQRBoa2u76c/5YuMlQzRXm9iwFiuKle9fSTRXLgbXI5mqqnLu3DkC7QF2v7eDc/80h6/Tjk2SiY2U6Drop6rpzJ/PozmLWMMCriY7piEhGgIeuxWLJGC3SYhWgVyyQijgwG6ticOrKhiGyJG72rBZZZ5Yod3s6fGhqgZenxWv18p3vjWFIMAdd7TicFoYHU0xO5uhucXFk9+dY9v2AE1NdhYWsly8UOKhdhvYRBY0gVZRpICJMy0xh4HHpRAxnNSn+yiGC29avzzSPGswrMp0ibWGG7deG80pIlBCYCZjoV234UZg0ajistUWwkROw71cFk+VDdx2avpNHSKySdBSG+AjAKopYMuBaDi4qBh0B0okqxKtTg2lbGE87sUbEOn2lZnIOBujJhOLZSxuicWxAgIQbrPTdMiN0yaTXW4UkuyQma6V9GWbQOziMukUTOITtZ/VssHSoknr65s4fO9BkslkQ+vi8/kIh8NXLPIbQTL/4A/+gNHRUf7pn/5pw3bYm9jEJjYOmqZx6tQpdu3a1ehGvh5WNpmulWSWy2XOnj1LT09Pw+hdEARCoVCj6SOXyxGLxZiYmMBut9PU1EQ4HOY1t2/jT//lWRaTeXb2NGOkq4jV2tpYLNW06tF4BZfTylIsx9beCOOTcQa6w5z47hgdHbUmo/HRKD6/g3gsz8DOVi6MLNLa4mP27CzTqQIWq8TUxSi9/c1MjkaJdPjRqgYWA+ZGZqkUVbp2NjEzEqNaVrDYZKxWEbOqYGgGsZkkTZ1BFlI5lI521IqKoeh48iaSbEVGpDyXxiU5kHw2rAaosRKyLCGpOj6vlV/+7I/SM7A6YXI4HFd4Y65cvwGsVuuGk8z6MI5r+SQLgoDX622Mpq7LJFY2hEYikSsy1rdKMuvWeHv27OHXfu3XfigbSoW1TtRZI276YPUpCisxNDREZ2fnmrJBIyMjtLa2EggEbnoxSIwV+PKHT2MLWChlVWx+GUOH1EIZ2SNTLmnMzRYQPCaizwSHiWkRsXqslKs6WARUw8AQdS5NJkindQZ2hdEMnVJFY+hcgi1b/PT0ekmnK5w+Vdsx3nV3O5lMFZ/PRrGosLRYJBYrIQjwild2oVR1FhbygEk6VSab1Xhjd4A32jUMRcdelhEFkUtVaNFtGJgsOqF7eXFatAo4Uxbi9ipbZYG8RaCYt1C1m7SsmPozTwVdlQlpdmKodC2Ty7yhEV5u4ssbOqFlx4W0aRKRa+/P2GRCyzZJeVHGY2ikNQgsb2VSpozd0CiKCtsCVWJFC34r5KwiqazBNy+F8Yft5BJVnD6Zcl7DNKC510V8slY279zlY+FCjs7tDrx+iejxKrpq0rbHy/zyyMrwFifR5dfb3BLlssGrfmYL7/6fuxuf0zTNhrdaKpVqlGiSySRer7exk10PTNPkT/7kT3j22Wf54he/uCbvvZvED98qs4lN3BpuOq5omnZFAqJu5H333Xc/z8x9NRw7doxDhw41RiLfyB8TIJPJcP78eXbu3LnmSkaxWCQWi5FIJBAEgW+cWOL8TJo+j5czZ+bw+xzk8hUMw6S12ctiNMeeHa2cO7/Itr4m7KbA3PkomqZTrWj09kWYvBRn194Ohs/O0drux2G3kLi4hNttJ7aQYefBLkZOzdDc4SM6l8Xjd9DZ4mHk6HijXO5w25CtEoVMma17m7j4zCSSRaK9r5mZCwuE2vzk7mlhVqlgk2UERUBXavZF1oKCnjMRVB2HKKKkKjhsMpaqTtDv4JN/+l9o7li7pAlq6+zIyAiapuFwOEilUtjt9kZW8WYHuhiGwdmzZwkEAutyulmJlQ2hmUwGl8tFMBhkfn7+ig3Heo/5sY99jLa2thfateQFjSsvmYzmaljPuLD6a1cuBtfb6ay2GIS3ubG32hl+NIqj2YolKTE/nqf37iCTozn8XXa23hVEV03mZnIIooAomSyN5SgqKoFWO7MLRfwRiWLC5M67OtAxePK7M4QjTu69uwPZKvL9p+ZQVYO+rQF6en3Mz+W4cD7Fzt1h5mfzBEN27trWjs0u8d3l7vLt/T5KJYUdOyPk0lXuTFjQMxYu6CX2eEUyFomWUu12LsgivoSFMXsBv0vCnrIAAqGKlXF7GWfOgR0Ri2KQtOoEJJF5QNdcRLTaNQsLFlTZxKKZeESZos3AVTXwiBJZwUA2TSwWiahiIgKCaFLSwSlBvmzgsdVIZkUHuwSiRcKmGKiqnam8hTZHAUWz4qroFAVo7XMRvVTLVrZu83DpRM0DM9hqbxBNl9+CrptMnS8xcE+Ykr/KtoEANvly5tDbZm8Qzcg2N1Onswy84nKzEdR2pSu91UqlEmfPnkXTNKrVKoZhrHk+LdQWv7/8y7/kqaee4uGHH34hSeYmNrGJm4BhGIyOjlKtVvF6vWvW1tUrbfXG1BuRzMXFRWZnZzlw4MB1PRCvhsvlore3l97eXqrVKhXTzrljc5ydzONyWshky3S0uphbLBIMuFiM5liK5XHYZeSyTiZRpFioNvSY4rKn8KWxKC63Fb/XDrkypVyFzp4wsYUM02Mx7E4L0bksew73EL0wTyFdqwZdODlFV38LM6NLbN3bSVOLysVnJujZ08bUuQVicwmCbT48zU6G3AKiZkOLqUiShNttp7KQQ6kISDYZpyhCxcDvtVNNlmlp8/Jbf/lBfCH39S7J81CvODkcjiushorFYmO+uGmajZnnLpdrTeu3ruucPXuWcDhMZ2fnus5pJa5uCM1ms5w7dw5RFJmdnaVcLjdK7Gs5r7o1XigU4nd+53d+KDOZdbxkiObNTnGooz6Z4VYXg9f88jbO/esSkS4XF59NsvVIkNmzOUQb2G0ypx+PEt7ixOGzMjGeoXevn84tQcqaimpUiIQlTIuA328lmypx7nSSLb1+2ns8zMzlGLuYpqfXR/cWL6lUhce/MwXAfa/oRFV1pG4vs7M5XC4LQ88kaG52sq3fQyxaZGmxSiad4A1hPx4VEjaBnpyP6YyCLmi4ZEhYwZep3VYbTuIJhfZ6Y5CgU604CFIjZgIicc2kpMo4qzJgkrNpeE0J0RRYLCt0WWSqEkynVGymhEu2kUhV6ZBq1y2OSqtU+32zgoFTEijKKqqgEXSBZgG7qmJdnuLrliFXtjFXEXH6dIKCgq5YafGXiS7fA4v18gZBUy8nM9Lxy5rMfEohm1Q48UyMngM+2u72U5quoCqXM7RWl4woC2y969q75vrEh6amJrZs2dIo0czNzZHL5fB6vY0S+2odjaZp8rd/+7d885vf5Gtf+9otj0jdxCY2sbFQVZXBwUECgQADAwOcPn16zdr/OtGUJOmG4yQnJibI5/McPHjwlkYd2mw27rl9N19qOc/YRIxIyEGxpKIsV5/GLsVwu20oqsbO1hDnTsywc3cb0cUs0aUsoihwaSxGR2eAudk0Rw73cOLbw7R2BBEEuDg0T2tXkMWZFD0DYZSSQWoiSj5ZIFassuO2Hs6fmKJcqBJo8qDkS7i9tfV+cTxBZ38ri5NxgmEnF+w6YrSItSpid9nRgcpMFtliw+G3YK0aUNaQJREzp9DX4+e3/vqncDjXt07qus65c+fw+/3PK2uvtANSFIVEIsGlS5colUoND8prNV/pun6FQf9GQdd1xsbG2L59O83NzVSrVZLJZOO86iX2lZ7LK2EYBr/6q7+K3W7n93//93/orfFeMqVzwzCeN2x+YmICh8NBa2vr9X+paTIzM8PS0hIdHR2Ew+FrkoKJiQlyuRx79uy55mLw5w8cZex7CZxtNgzNJJ2q0HnQz8jRBJ2H/KTjFVKZMr37/FwcSuEMWxGsOtPTefoPhBk8EWP7fj9zi1kCzTKIAqdPZ7A7ZPbsj2C1SXz/yTk0zWDHrhCtnW7OnokRjZZoa3Pj89twu61ouoFpVDk7mMEwoLvHS0+7h9ed17BqJnkkHIrIJV0lrNsQmjWEhIAdiapski6AJAsE7SY5q4mZlJEQKXsqNKsyE1oVt2ZHtpk41dqDnHVpNKsiqmgyoyg4kHFrVioYuMWaqXvR1PEtzwxPmCoty9dxydCWSaeJIpjYEYibCsGQSYAquiHikmCmJNJmE8g5ZEL2AioyednB9y5ZqeR0vM0yuaiGKILTU5MxSFYAAV0xsTpFVNVEV01km4AJqFUD2SKw984ImQslctEqoW0u3CEbv/Lv917zuRkeHsbpdK5aLq/vShOJBMlkEovF0tgt17sgv/CFL/ClL32Jr3/962sqxW0Afni3tZvYxM3hpuNKNpvl1KlT9PX1NUqXg4OD9PX14XZfP6NWXx80TaO1tbUxJvBq6LrOyMgIVquV7du3b1jm6ZuPD/O5v/geXo+NQlGplc2b3CzGCvR1echOF/C47MzPZrBYJBxOK7lsmYFdbVwYXmD7jlaspsHM2XkEEYr5Kv17Oxg9O0dLt4+l6Sx9O1qoxrLMXYqy8/AWRo5P4HTbsTmtmKZJ95YQZ54YQRQFevd0cGlwllCbn5Z2P2e/f57Mu3cg2pwYVQ1JAGtGwWJImCaIOQWzrOF12xFKGn19IT75lx9YNwnXdZ3BwUGampro6OhY8/sMw2iUstPpNC6Xq1Fit1gsaJrGmTNnaGtr29DGGk3TOH36NF1dXauWy68+L6fT2Tgvq9WKYRh88pOfpFwu8/nPf/7FIpkvaFx5SRPNunHq9R6uuh7TMIyGziWZTGK1WmlqaiISiWC1Wte1GEweTfHHr36G7jsCjB1LseWeIBeeSdC8x0M6VqFQVWkf8DJ0PM72O4PMzWWwekSCrR4qmoYpQq6kMD2RpWe7j+eOLRGIWGjtsrKwWGFpoVrzwWx1kcxWOHc2jiDAffd3YhpwfiRBPF5m7z4fF87n2bkrgttjIRYt0TVV4c12D0sOAX9GImMHOSNhAjO6itVq0ClbSSFgK9Ye0FlbmbaqHZHa/5fsGlV03KXarjIhVuhebgqKmQqST0ZMikiI4Ad7TXuN5jVxFmq3uGo3cKkCOiaiZGJBICvp+I1atrToAk/JpGqaWAUBwzRIyVW2BgzSFZOwLFE1QNUERE8JuynwF1M2+veHcFgkzKqOVtGIXajpPlv67SyN1oTwPQf8TJzOANC918fk2drPrdvdzI3lsdol9h+OMH8qx6t/po+3/cbAqs9NvQzT19d3zWdhJerjy+LxOF/4whdYWFhgdnaWJ598stEJ+SJgk2hu4uWGm44rsVgMURTxeDyNv1uL9r8eV3RdbzTtpNNp3G53o2lHkiQURWFwcJCWlpZbKrteDUVROHHyNJ/9i0GKJZWBbc1cGIuyq7+FUklFT5SILWYxdJNwk5NErMT2gQgXL8RpafWRShXZ0uqjkCiwNJti16Fuhk9OE2rykE7mMXQ4eOcWBh8/R/e2FiaG5xElkfYtEWbHouy+Ywvz5+dILWbYcbiP88cvYXNa6epvIR/PkolmkQ52MOOSsFos2BwWlEQFVLBYZYREEVEHm0VCLKvs2dfBJz7//nWT8HojTUdHxw0TTteDaZoNm7m6DrZSqdDV1XXTmszVcCOSudp51Uv/iUSCz33uc5RKJWw2Gw8//PAtZcbXiZeHRnO1B3C1TvSVuLqzvN4NtnXr1gbpPHPmDIIgUK1WaWtrW1OjR++RINvuDxO9WGDrK4LoIvTcH6Cq6IiaSFvEy8VzKbbeE+DM8RgtWx3EYypltUA+r+AKWFiYzbN9f4hTx5e471WdVA2dp783SyBo59BtYSpqleeOL2CacNvBJrwBO08/PYdSNbDbJfYf9CEIMsGQg3JZZWoqg5bVeH0gQsYCroyAYhqoBQkZgahdJ5y3Y1YNzlaL9FHbrcccGp6Cg5RXJ1wUWaIKBRnBd/nWhwwrUZdOqWDg1m0kMlVaqZVK0nmFVmokNJNXcAq1cpNiEXCpICGQt5oEFPDqEhUM7IKIuXzbbIJATjTxGiKibiMeE6jYK/hlsImQ0QX8JRc5qUyzzcTilDn9g1qT1J67I8gVhXDAit12+fkQrZfjjsNzufzla7IxN5ZHqehkKgoFu8bO10VWfW7WSzLhyvFlo6Oj/NVf/RV79uzh7rvv5pvf/OaGll42sYlN3DpCodDzYsiNtP91SzyoybeCwSDBYPCK6TGTk5PIsky5XG6URzcKdc349m1beeNrdL7y9dNUqrUkjGBCZS5LMlFsZC6DQS+JWInpqTQ2m0g2U2Rru4eLJ2fYuquWqRsfWcATcJCM5dm2pxWLKDJ7bhrBhInhebYf6Obi6WmqFZWeHW1Mnp6ge6CN1GKGsTNT9O7uoJAuUEzmsNpkirkyWb8Nq9eOpmiYc3lEJDweB0JRQ3TYkXUT8hV2HWjl9R/Yw3PPPdewCVqLTlFRlHWZm18PgiDg8XjweDx0dnZy6tQpQqFQwx+zbp10vZnnN8J6SWb9vNxuN263m56eHrZu3crJkyfxer3ce++9PPPMMz/0ZXN4CWU0TdNEUZQr/m5paYlisbgqGahnMYHr3ohCocDZs2cJBoMUi0V0XW+MB7ue79XY0SS//don6TngZ+x0iv47QwwfjbPzngiDT8fYeruf0TMpmrc6ic1X8LXYSMYrBNvszE7m2HE4jGLoVFWdubkciwtFdu+PgGSiaAZjF1Ps2RchFi9gdwkMDWUJBK309/splSqcHax1UR842Ey5rBEM2mk7p7MtY2PaqGIXBewRiUBSIm3VkYsSIiJTlAnrdoSwiaoZWLISIGCIJnGxTFitlXcNTAxRw5ChbEJZM2gzaxlOXTKxArIhYGCCZGATRDKmhoaGzWkhV1CxSGC1ypSqKk6LgN0qIVkF/IaARTURBJBMWNI1WiQZXQBdA0kQKPnArZcoagKtFpH5qkHU1ClsDXPxdAqA5h4b0amahVF7nwc0k9ZmB0peZWG4lt0M99qITdZ+7trvY3IwA0D/kRAz57P87eQDSPLl5+NmSeZKPPLII/zhH/4hjz76KIFAYE264A3EZkZzEy83bGilbGxsDL/fTyRy5Sb0eibsVyOZTHLhwgVCoRC5XA5JkhrjDG9Fp11vUt29ezcej4dYIs8HPvYPGIbJ4d0dnHnqErv2XO4kX5zPIAjQ3OJjaTHL/oNdLI0ugqaTWKqVoprafcTms7T3+ViYyLJ7XwdTg1Pk0yV23rGFkWMTuH0ORFkk0hbAJpkMPzOGIAhsPdDN2Kkpune0YpUFRo9fwmK3ELp3GxMBK3pJQS4Y2B12EATERBHBEHDLEpQ1XvH6nfzkJ94G0NBPxuPxG+onK5UKZ86cYdu2bYRC6+tMvx7q5LW3t7dx/3VdJ5lMEo/HG7r8SCRCMBhcc0axXobv6OigpaVl3edVt8Y7d+4c//iP/4gsy2ueirhBeHmUzlcjmnUNw/bt26943XoWg7GxMXbv3t3Q49Qf9mg0SrVaJRwO09TUhMfjed6x/tc7nuHsd6J07PMydTZDy4CbpckCnhYbmXgZm9+CqpiYVlAVnUCnHbvPAlaT7z8+x4E7mzlzKoooiuw5FEFF5/SpKAM7Q+RyVcplDZtDRpIEPH4rsXiBXLZCMqnS1Gxn584gi4sVRi+k6HI7+dFcmJRFx12xUHSDmBNIiGWsskiTZiPtNbCkaw/mvFRGMKHddKBZTdJoGFXwSzKyLpARFFS3gDsvIyw/Y4LLwLFcbi8FdMo5FdEuITkkLAkBAYGKS8VTrGURVXft9QYmggySJpBBIYQVDZ2crNASsCKqGkF9WQNqEXBXIS2Du2pStCl026Gkm1RNgUcqoFR0nB6RctHANCDYYie1VCOTwRY76WiFbTsCBLw2pk5mUKsmsg10QFNqj6Cv2Ub/HSF+5Qt3X/HsjIyMYLfbb5pkfutb3+LTn/40jz322IYugOvAJtHcxMsNL7j2fz1xZXZ2lmg0yt69exsOE3Vz8Vgshmmaq846vxGi0ShTU1Ps27fviibV3/uDb5GN5TGLKqMji7jdNlRVp1rV2Lq9mfGLUQZ2tZHPliFTIpcqUC4qDT1ma7efxekMkizSs8XLpeMz9B/sZvTUNBarTKjVx9J0kkOv6OfUtwcxNIMdd/Rx/tglLDYLO27vYfToRTRVp3dPJxefm6D67v21JETBwCjruOwW1MU8oinisclYNIM3vfMg7/3Y61b9rLquk0qliMfjZLNZPB5PY9qOoiicPXuWgYGBNfmcrhXVapUzZ87Q19dHOBxe9TVXW99ZrdaGLv9aLgIbQTLr1nhf+tKX1jVtaAPx8iidr4bVTNjXsxgsLS1x8ODBK+xmrFZrQ/xb7zCenp6mUCgQDAYb48EEQeDdn9zJ2e9E0Uu1zKmgC+iqAaaKVoVmvx3DYuKO2JiZz7G0VERMCcQWi9x2pIUTzy7R1ecl3OZgYiKLbBHZvj3I6ZNRDh5uweU1UFWDobNxdu4Jkk6X6esL0tZh4rALfO+7CwD0bnHx6lQAUwCzKqBLUM7pOJCwOGyIBYFRW5mmdG0nvWCp4FWXu8L9KmQErMu3OuvUayPNcjJyAZaECq1mrbGlJBmUfSZqxURPm9ixIBVFtKKBCMgISIqEiYmAgKrrOBAREchLGj5NxosFVTCwmBKCKaPEJUBkzKHhQMPUTNyiFZduIggi7qqdKUGjzaqiyTKufBUFaNvqZvx0Lavb1utpEM36zxdH0uw8EqboMtl5exAJk5FnaplQf7tEer5C/13exq5wI0jmE088we/93u/x6KOP/keRzE1sYhO3iJuNK6ZpcvHiRRRF4cCBA1cMZFhpLq4oyhWzzuvJDLfbveqxTdNkenqaVCrV8OxciXe8fi+/+vP/D0kSCYZcpJJFdu1tZ/jsPIpSkwXoioaUK7Mwm2LXwS6GT82QjOWQJIHF6Qz9e9tRMkUqyTIAo6emad0SZHEihSiJ7Ly9hxOPnWbXndsYfnaMi6em6NvbhSiajB0fp31bC+Onprj43AR9b9vPGU1DilUBEa/XgZGp4nI5EEsqsmLw7g/ezVvev3oTZv0erJy2U9fBXrp0qaGdvNbYyZtBPUO6fft2gsHgNV+3mvVdIpFgeHgYXdcbJfZ6YmojSOZf/uVf8v3vf5+vfOUr/1Ek8wXHS4ZoXkujWV8Q1mrCvnIxOHjw4HWns6ycdX71PFOfz0dTZxOHH2zj+NcW2HFnmJFnE3QdcCCKNtr22DjxzCK9u/w8/cQc/fuDzIxnCUTsNLe7OftsjPte38n0XJYTx5bYf3szJ44uYo2JvPLVXczO5RkdrRGjO+9tIZ0poOsCZ07HOXRbC+Njae440gYCqBdLRFISU2aFFtNJwqrhUmVSHg1bTiYhVHFUbRTsoLt0PMmaaXvKrmDLSBguA1kRScsqUkGkbNEICzVS6nRayNo0Kmkda16iZFXwKzZEAVSfiZwBGZGkUKHZdGBRRZJClbBpw16WqYo6NlNCXr4dIgIpUyWCFZ9pQcdEQkCyWhCzFkqoJMMC3pJJ2tQICjL5kklMteJoEdjVauG5tI4sXf7CKdXLQWGlfZGhQy5T5egPFtl7d4T2O7xoaZ1gxE5mIUHrHpNjx47hdrsb/nk3Y8YO8NRTT/Fbv/VbPProo7esF7oWMpkMH/rQhxgaGkIQBP76r/+aO++88wX5XZvYxMsBGxVX6nPRfT7fDZtJrVYr7e3ttLe3o2kaiUSCyclJisUioVCIpqamhhbQNE1GR0fRdZ39+/evWiod2NlK/85WRkcWaW0PkEoWWZirZShnppLcdlsX5747ytadNT3mpQtLuL0OEks5urYFySQqUKkyd2EeVdEZuK2HCyemKOcVbE4LoqhSSNZ8i0eOjbPtYA9jp6awO2RKmQLFbImJwRl239OPrmk8F0sjulxYfS6sgoiQKmNBxKboWGWBh37hNdz31kPrukf165FIJNizZw+lUummfTGvRp1k9vf3EwgE1vVep9PZ2ECoqnpFYsrr9ZLL5eju7r5pkvliWOO9FOLKS6Z0DrWy9srzKRaLjI2NsW/fvnUtBnVCcbOaOdM0yWQyxGIxJodi/NOH4oR6LeCF6GKtqzwZK9O23c3E+Qy7jkQYPBpj9+EI556LMXBbCNEt8Mz35hnYEyK6WCSZKHP4nlaqhs6xZ2uZyn0Hm7C54OmnlwAIBu3s3ddELltleDhO39YA8zN57ssE8bosCIgUVBWzbGJ1iNiLVnIWFUmTEERISQp2Rcb0m6glHbsqYwomis8kmanQJDgQEDBsJhWbjpYzsCFTQcOLBdEUMEUT0zCxIGE4TUolBcki4vDImBqUiiqGaGA1JHTdxJAMXJIFTdGRBBOv1QKCSbBSyyKnBIWgaaUs6zi05UlDso5Ng4pVoUeykNZ1fFgomioVu8KTVo3OXh8el5XCUpXkXAWlomNz1Oa2V8s6kixgdcoUc7WyWLDFTnKptlu//ZWt+N02fv0L92AYBoODg2iahmEYyLLc2Emvdcf8gx/8gF/+5V/mkUceeUEbfh566CHuvfdePvShD6EoCqVSabXS0WbpfBMvN7wg2v+6by5cX+dfqVQ4e/YsXV1dN0Uo6qiXi2OxGLlcDp/PR6FQIBQK3TBePfv0GJ/+1Dew2S1YZJFCocqO3W3IhkkpmmN6PIYgCjS3+1maTdMzEGHqQpzOLWEolJi9uMSuO7YwfGwCp8eO1W6hkCmx784tnPi3QQC6d7cyPbSIbJXYfrCdoe+OIltlth3q5fyzY+y6axtT0QzZrS0YFQ2H1UI1VkSWRFymiMsi8tHfeAsHX7Fj3dcmnU4zOjrKvn37rliXV+o6y+XyFbrOtcT3crnM4ODghpfhFUXh5MmT2Gw2qtXq8yyK1oJ/+Id/4Mtf/vILbo33UogrL2miWalUGB4eZu/evcDaFoPOzs5bskG4Gpqm8blffILH/z5J524bU0MVuna4mTyfJ9zmJFesUK3otG/zUtV0mrqdPPmdGRwume5tPs6eiROK2NlxMMwTT0yjaQaHbm8hl69S1RXGx/P0bfXT3OIil60ydC4BwOE7WtF1g6ZFCy2XZPI2A71qYiAguAWUogF+0HUDsQQlXceJBcVnoBQMEE0kt4CaN5EMEUM0kUMCasnAWPY9t/hExCwYdqhKGoIuUKlqiBZwq7XdVUFQCBi1nzNClZBpr91lF0hFAdMColrLZOo+E2u2do90h4Fe1jElnTaLDXtFoiIb2DWReF3HaTFRNB2XRccpSdh0kYShkthl4dhw7TrsuT1CNlWltcWNU5YZ/F6tI71vX4CxwdouvGObh9mxWpndH7aRTlb4wCf28RO/tIeRkRFsNht9fX0NS4t4PE48HkdV1UYp5FpTgI4fP84v/MIv8PWvf52urq4Ne66uRjabZf/+/UxMTNxoAd0kmpt4uWFDiWbdqqhO7q73fctms4yMjLBjx44NJSqVSoVTp05hs9lQFAWPx0NTUxOhUGjVKpxhmPzcT/4t87Npdu3t4PzQPPt3tTH8zBi6brJlRwsT55fYurOV8ZFFRElgYG8HM2em6OiLcOHEVE2P2eJjaSbJ9v1dqMUyE2em2XlkKyNHx5GtEl39rcgSjJ+apKk3yMKFGGCy/9W7mBmeZb6rCVx2nJKInqrisMqYuSpBr41f/J/vpP9g77qvRd1g/Wpt6tW4WtdZb9q51jUrlUoMDg6uaxToWnB1ufxqiyKgkcxwOp2rPl9f/OIX+bu/+zseffTR6zYl3ypeKnHlJUs0TdNEVVWOHj1KKBSiubn5mruYF2oxqHuk+T1N/OabT5JLVmnb7mZmNE/XHjsT58r07HZTKmu4m2wsRIvMTeU5cKSZ08drc25uv7+VmYUsY6NpDh5uYWIig9dvJV0o0dTsoFgwMXQTRTVIJcvs3BUmGLJz9kycQqzKu5QOcnYdV1mm5DQQDYGyZqCIOhgCJVPDME3sPgnNNKAqoMs6hgaaCoqs4fXZqKRrpSLNouOwW1A1A1M30QUTubxM4F1gKdR+LqISpEYqRY+AlAcdA9kiIqoCeRT89S51r4k1J6ILJqJZK7WXHBrOslxrFJLA0HWqaLTbbFg0AVGvNRdl0PAgofp0IiWImzo0WfhOrPaF3XUowvDJOAB7DzeRS1dpjrhwyDJnnqyRzr13NzH4TO16774zwtlnY/z1s2+hbC5cQTKvRl2jG4/Hyefz+Hy+RrehJEmcOnWKn/3Zn+VrX/savb3rX0DXgzNnzvDhD3+YnTt3Mjg4yKFDh/jc5z632iK0STQ38XLDLcWVarV6+UDLesDBwcGGbOpa2sl6c87evXs3VC9YKBQYGhpq6AVXahSTySQOh6Ph1blSs/fEt4f53P/6Fv6Ak9aAk7GT0+zY38n5M7O094SYn0oC0N4bwG6zIVYqjJ2ZQRAEuvpbmL6wSHtfE8VsCZddxhd0MfzsGJJFonugjekLC2zb00alUGVicBpBENhx5zYq5RKXTkxjBF1wZDt2U4CijiSAkKsQ8Nj4tT/8Mbq2rz/BE41GmZ6eZv/+/esa3buyaSeZTGKz2RrXzGazUSwWOXv2bKN7f6NQJ5nt7e3XTGhdnYWtTwGqd9d/9atf5c///M957LHHNvTcVsNLJa68pIhmfYTkSnG2aZqk02lisRjZbBa/309TU1NjdNMLtRgUi0XOnTvXsFf41t9f4nMfO05rr5ul+QKCINC500PFVKmYZS6cLRKI2BAlgXi0wu7bwoh2gVMnomzfEWR6Nks6WeHQnS0UK0XOX8hRqRjs3BXCYpGw2yVGL6TYsSvMs8/MIwjwTnc3toIAZci7daSKSE5XMWQQDYGcoGBFAq9ApaQhOEHVdJx+K7JdwOYEw9Sx2CWsditOl41iTqNc0hBEqBZ0inmFUl7FZpPRVRNEqGRVLLKE02tBLehUqjqiAC67BUMGiylgaCYIoFdMTMMg4nagF00kl4CzIKMLJpg1n80MVYLY0GQDSRNQ0LHaDMJVG1mril+xUrEZmBUTh0PHqon8KyncXgvVqo5SNbA5JERBoFyqTQzyhxy0tLtwWSwUUyrz4zUrj759ASoljV/7u63XJZlXY+XC9fjjj/PFL36RWCzGF77wBe6+++4bvv9WceLECY4cOcIzzzzDHXfcwX/9r/8Vr9fL//gf/+Pql24SzU283LAhRHNlXKlb2sRiMUqlUkM7WR+8MDU1RTqdZs+ePRvaoJFKpbh48eIVTigrUc+OxWIxEokEsiw3Bo/IsoVf+tl/wsiW8HlsDJ+cIRB2U8iVURWd9i1+5icy7D/czbnvjqCrOtsPdHHx9AyR9gC5VAGP30Vbp4/B756vTfvZ3cmlszP4wm66tzdx5vFhZKvM9tu2cOnMFO1bm4lOx2jqCTMZ8kNVR8ur2C0ilqpB0Gfnt/7yAzS1X7vB5lpYWFhgYWGBffv23fI1XplR1DSNarXKzp07n2dhdSuoj6tsa2tbc9VU1/XGFKAvfOELnDp1isXFRb7zne9sqFH8tfBSiSsvOaJZ98dcrQPQMIyGdjKdTjf+7cCBAxsqpL3aywxqC8CvvPFxhp+Ns/cVTZQ1jflYgfhSkVJBY9ftIQafixOMWLB5RXRZwDAECnmVeLRMIGhj1+1hvvPtaQD8ARuHDrcycj7B3GweUYTDR9rJpCsEAnZcaRHLBYNiRUNyi+h5KIkaNo9MtaCj2w2sTgnJKdK9y0e4Dfbd4+GN7zh8RRnBNE3y+fwVE5Pqaf36NTNNk+hCgR88Mc+JpxeJLRRJLVTIxitUKhoWQcRmk6EIaKBZDWyKhCGbWHUJDMij4MWKhoEgCpi6idMp4TOtmKqJdXnEZW75dYrHgLyJjkabaEfUBfKihsMQEYMm59UioYM+Tv+glqnce7iJs8drGcyBfSEuDNZ2791bvSSTFQZ2BlGzBlMjWd7wUAvv+NmeNZPMqzEyMsLP/MzPcP/993PixAkeeughHnrooZt7mNaIpaUljhw5wtTUFADf//73+fSnP82jjz569Us3ieYmXm645UpZnVyupvNfSTrz+TymaeJyudi9e/d1m0nXi8XFRebm5ti7d++a41W5XCYWixGPx2sjlM9m+dLnn8XutCLLEoVcmYF97VwYnMcXdNLZFWToeyPsuL2X889N4gu50TWdQrbMgfu2M/7cOPlkseGPaXNa6dzeQimVIz6TpGtHO2OnJnH7nPTu7WBhMkpiOoVroI1C2I9ZUHG5bJi5Ki3Nbv7LJ+5H0cq43e6GRnEt3pOzs7PE43H27du3odc4n89z7tw5WlpayOVyVCqVhpvMrZix3wzJvBrf/OY3+cxnPsM999zDU089xR/+4R9y5MiRmzrWWvFSiSsvKaKpKAqqqt6w6ccwDEZGRtA0DYfDQSqVet5osJvF0tISMzMz7N2793l6kZnRLH/08ec4fzFBoMnO2HCa3bdFOHcihmQR2bLLj+gQWVjKoxs6czNFXB6Jrl4nFQNGhtP0bfXictmwuywcPTqPKArs2RshHHYyMZFhajLDnQfbcT4DBUHF7bJSLepoNgPRLqJoBs39LnYdCfPAB/vp3ubj/PnzyLK8pjm7pVKpsXAB1/V7m59b5NGvDpFecHLuRJzYYolqTkOvGDjcFpSijstlQUka2EQRWRJBhbyg4DNtYAVBMdFNA7vfgl0TkRGw5kV0TDRMLIhk5SoOTUACIqadmFChKOmYd8pYBAsLY3la2tyMnq2Ry713NHH2WI10Hri7mZPP1JqpDt7VTCpe4Bd/bxf3vmbPTS0qo6OjPPTQQ/zjP/4je/bsWff7bwX33nsvf/VXf0V/fz+f+tSnKBaL/P7v//7VL9skmpt4ueGWM5p1L83r6fzr/o1Op7NRzr66gnYzME2TyclJcrkce/bsuen4VK1WWVqK8j8++mXSsRJbdjYxMRLDapew2qx0dfoRVJXhYxM43DZsDiuZeJ7tB7pQqxqL5+foGmhl9MQkdpeNUJufcr6Cwy4higLTw3MIgsDe+3eQnEsye6HWtNp/5zbmbQ5UQ8CCiZ4p090V5L//zU9ic9gayYx6RnG1ZMZKrLwWG2lIXpfQ7du3rxHPrmXGfi1d52rYCJL5xBNP8Nu//ds89thjG5plXQteCnHlJUM0VVXlzW9+M695zWt48MEHaW9vX5UoKIrCuXPniEQidHZ2Niwi6lm7RCLR0LjUyg1rc3Ba6WW2d+/ea77v7z57lj/776cItTioVjRyGYUDdzczPpomssVFRdEYHkzg9ljp2eojnSmTq1ZweyARU8lmVfbf3kQyWaW52cXiYh6n08r5kSSiIHDXnW0IJwzsSIiaQFnSMZ1gyCY77w3z0H/bx9adtTKFrusMDQ3h9Xrp6elZN7Gq+73FYjEURWmUjzweD0tLS8zPzz+vrKEoGg///QVOPbvEhTNJkrNlLHYJNWsg2MCsmlhliYDdhlkwKQkqHsOKIutYNQnDMJHcJg5DxmKRsWQFsii4sYDFxFA1QqYVTYZvCouogklTixWP10Yk4CYXU4gvlFAqOqIE3qCdVLzWbd7e68DukPnyM++5KZJ56dIlfvzHf5y///u/Z//+/et+/63izJkzjc7ALVu28Dd/8zer2XFsEs1NvNxw03FlbGyMn//5n+eBBx7gLW95yzU9FOtSqb6+vgYRqFfQotEomUwGr9fbaNhZK0EyDIPz588jSRL9/f0bMj3sqcfO8blPfg1JFnG4ZcoFjW39AS48M4lskQi2+IjNptiyu4OJoTm27+9E1DTOH6vNKw+1BVgYj7JldwfoKuOnprA6LPTt7yG5kEItK5SLFTp3tCHLMnOpCnm3E4/NglHS2L69iU/82X+5ZowslUqNhsuV5vUOh4Px8fFGWXsjSWYmk+HChQvP61pfibo8KhaLkUqlsNvtDUJ8LX3oRpDMp556ik984hM8+uijt+RacLN4KcSVlwzRBJibm+OrX/0q//Iv/0K1WuUtb3kLDzzwQINE1UXUKxeD553AssYlGo02dld10nmth8kwDEZHRzFNk4GBget+AXTd4KNv/DeGjsfZvi9Ym3l+IIjkFjj61AJWm8TAniBnTsTYfVsY06pz+kQMVQWv18q+Q2GGRxLEY1WCISsulxVRFGlr9eB1W1DGVawLAorVpKhoOEIy9zzQyU/9xgHs9suET9O0hqC9o6PjVi5743j18lFdljAwMHDDRbWQr/L1L47x+COTTJ3PYWomatpAQUfWRUQRgj47Yhkqio5Tlxvlcw0DUzQJmDYki4BYEcgKVWymiNdt4VIpzyWpwKEjzZw8WiuhD+xxoZQFwkEXTtnCyeUmoOYOO9G5Cr/+mbt4z4d2rvvzT09P8yM/8iP83//7f7nttttu7iK+ONgkmpt4ueGW4srw8DAPP/wwjzzyCD6fjwceeIC3vvWthMNhBEFoTJDbtWvXNZsz6iQlGo2uuYKmaRpnz54lFArR1dW1YSNqTdPkF977p8xdStK/r51KIsfM+QXC7V7is1maewJEp9Ngwu2vHuC5R04jW2QinUEWxqN4Q27a+yJMnp4EoLk7zOS5Wdq3teBwW8kks8QnU2w92Mv0hQWq27rwuGyIJY19Bzr4pT9635o/y8pkRjabxW63s2PHjmu6fNwM6tZI+/fvv27X+tWo6zpXVvfqfp2wMSTzBz/4Ab/yK7/CN77xjRfUGm8D8PIhmo2DmCaxWIyvfvWrfPWrX2206J8/f54vf/nLDcH2WlAXVsfj8VXn0da9N/1+/5qzgoszBd7/im9QLWvsf3Uz33xsEkGAA3c0c+poFFGEe97QyTe/NYFumLR3uGlrd5HJK1w4n0IQ4K672wGDeLxAIacQ9NnIzGt0Vb0YJthCEm/8L338l1/e+zyiV5/X2t3dTXNz87qu7Y0wNTVFJpOhvb2dRCJBJpO5ofXGSly6mOaLfzPMyaeXyCcV1JxOpaIhayKCBHarhFO0YJRNLJpIFgWPaUXyC5gZA6so4tRldKtJyVCZDpUplhQqFR1JEog0O1laKALQ0+dAliXssojTZmF6tMy3z/8oLs/auxehtsF5z3vew5/+6Z++oEa2PT09eDweJElClmVOnDhxM4fZJJqbeLlhw+LK+Pg4Dz/8MF//+tex2Wx0dnaiKAqf//zn10xS6hW0aDR6RZf4ygpapVJhcHCQnp6eDV2jTdNkYmKCoRNTfOOvz2LTVZxOCxPDC7RtibA0ncDQTXp3t6BWqywMLxHpDLA0kcDfVCN3oWYP6YUUkkViaSKGKAocfM1uRp+7RC5Ra6rc98pdVIoVklY7FUPALFS56/5+fu733r3uc65L3SwWCz6fj0QiQT6fJxAINCbx3Wx2M5VKNby210Myr0a1WiWRSBCLxahWqwQCAdLpNJ2dnTdNEOvWeN/4xjfo7Oy86XO7HjYopsDLkWhejc997nP8n//zf9i2bRuxWIw3vvGNPPDAA+zYsWNdu6KVwmqAYDBILBaju7t73TuWZ/99jt/9tWeYvJTltrtbOPbMIoIAh+9pJVOucvpklC1bXZTKyxdFFpAkgZZWF9WKxsSlLNlsle4uL2iQmC+x1x5CE3X2vM7NR35rHy0tLc/TuNQNaOvd8BsF0zQb479WljXqWqW6/sZutzd28jeyo9B1g69/+SL/+v9GmR1LoxVENMVAqoiIDpAMAbfNipAD0wAFHRFw2WU8JQsZScFz0EHBrjFxPs22HUFOHq3pMXu3+ZkcywDgdImIksCb397Gz/3qoefZglwPi4uLvOtd7+Jzn/sc9913301fv7Wgp6eHEydOXHPO7hqxSTQ38XLDhscVXdf52Z/9WY4ePYrX68U0Td761rdeV7a16omtUkHzer1Eo1F27ty5oXZ7hmFw4cIFRFGkv7+fP/rlL/LUv5wk0h4gHcuhqTq77tjC+RNT9O/rIB/NMHtxCW/YharqlLMVBg53ER2LkVxI4/Q66BxowzQMLp2exGKX6dnVhcNtZ2F8CewWKsEQVDVe9cbdPPSrb7mpc64PUVlpEWcYRqMbO51ON2adr6fHIplMMj4+zv79+ze0Gbhuxi7LMpqmPc/2bi14sazxNiimwMudaJqmyec//3k+8IEP4HQ6SafTfOMb3+Dhhx9mZmaG1772tbz97W9ft7A4lUoxNDSE1VorXdcznetx6P/bPznL7//GUQAO3d3C9FQO02bi8sDYaA6latK/K4QvbGNsNEU0WuLgwWaGRxL4vDZ27QpTyCjIgoA0JdC81clv/MV9+MPSFZ2GdY1L/Uu70Qa09TFodenA9RbZleUGQRCu0N+shkKhwLlz59izZw9z0xW+8BdDDJ2Ik12soikGQgEUScchyrgdFsSMQAkV2RRxuyxoRYPjcgyP10L/jjBWSWTmUo72djdnT9U2DIfvbuXk0SX+9ckHsDrKJBKJK2bpXuvcotEo73znO/nMZz7Dq171qlu/kDfAJtHcxCZuChseV8rlMn/913/NT//0TyMIAgsLCzz88MP8y7/8C5VKpSHb6u3tXVcyY25ujkuXLmGz2a6Qbd0qEdJ1vTECs155Sy5m+PnXf4ZKscrOO7YwcmwCu8vG9l1tDH53mECzD1XRKKSLtG6J4As5GHlqFHfQic1lJTmbYeCOPsqFEsV8ifhkit33DDD09AVsbhuO/i0IArz1PYd558+sf33UdZ3BwUHC4fB1h12slsy4kXYyHo8zOTm5bv/NtZzzmTNnaG1tpa2trTElMB6Pk0qlcDgcN5wAdPbsWT784Q/z8MMPs23btg07t9WwSTRfBORyOR599FEefvhhxsbGePWrX82DDz7IwYMHr0s6r/Yyu7oppk6eVvM5uxqf+eRR/ub/nGXb3gCOgMwPvj+PaUJru5ut/X6ePbZAqaQhigKvelUXpbKGquq4HNZa97ZdRlvUec9P7+DB/zLwvONXq1Xi8TgLCwvk8/nGDN1rmQyvF6ZpMjIygtVqZevWres6Zv3cYrEYqqoSDocb100QBHK5XGOy09UGselUiX/48yF+8Pg8sakCehWMvEkFDbdoweO0Qg7Kssq8UWTHPWGO/qDWBbl7b5hcoUzQZ6WaF0hGK7z+bVv49B+/snH8qycA1eflejyexkzdd7zjHfzu7/4ur3/962/5Oq4Fvb29BAIBBEHgIx/5CB/+8Idv5jCbRHMTLze8aHFlNdnWm970Jh588EG2bdt23fVxbm6OpaUl9u7di9VqbVTQYrEYgiA0khnrLfHWB4e0t7fT1tZ2xb898jff529+5+uIksiW3e1Us0UKyTxKRaWQKdG5vZXYXJItO1tJL6YpZktk43ksNpntR3o4//QYumKAALvu6a91obsdJIs6FVHmvT91L2963/p9hFVVZXBwkLa2tued841wo2RGLBZrmLxvpMfp1STzalw9AUgQhEbMqyeoRkZG+OAHP8iXvvQlBgaeH883GhsUU2CTaK4NpVKJxx57jK985SsMDw9z//338+CDD3L48JW+kgsLC8zPz1/Ty0xV1YZWo1wuNx6kOkFZDX/+B6f4//7ns2iayfYdPrIplY4tPo4/t8CWPj/BkAO7TeLJ780CcN9dHUyMZhjoD9LfE+Rjv307/uC1zebrI7p27drV6K6vz329FX8wwzAYGhrC4/HcVNf6Smia1rhuxWIRl8tFLpfjwIEDNxyxVa1q/PPfnOfxr0+wNFlAyRmoRQPDNHEi4/ZYYI/I1ESWakXD5hKJRisAHLmzjWJB5R/+6a20tK2+MVBVtWFxMTQ0xGOPPcb4+Dif+tSnePvb337Tn3m9mJ+fp729nVgsxmtf+1r++I//+GbK9ZtEcxMvN/yHxZVEIsHXvvY1vvrVrxKLxXjDG97Agw8+eIVsqy47KpVK7Nq1a9XyarVabZBOwzCuayu3EnWp1NatW1fNWhmGwW/9+J+zOBUnGHSwOB6jmC3Ru7uDmdFFME323r2Voe+fp1pUCDT78Dd7cbjsDD99AVfQSfdAO4IsEJ1OIDtk3OEAGUXig7/0eu5+0/51X7ON7CG4Oplht9splUocOnRowzOZg4ODtLS0rJkY188tHo/zve99j5GREY4fP87DDz/cGJv9QmODYgpsEs31o1Kp8O1vf5svf/nLnD59mnvuuYe3ve1tfO973+P+++/n3nvvXZPWQtd1EokE0WiUYrHYsP+5mthVq1X+1+99h7/9sxlU1eDIfW2ohsn54QS5XJXb72jj2LML+HxWDu5p5vy5JK+4r4t3/sgA973h+vOz6ya/+/btu+KLdbXJ8Hr93nRdv6IjciORSqUYGRnB5/NRKBTW5V1mmiYP/+MFHvnncaLTRQpLCgYGOVWl4Fbp3+EBE9IpHV/AzrnBGL/76VfwwQ/tW9O5RaNRPvjBD+J0Opmbm+OjH/0oP/3TP70RH3td+NSnPoXb7eaXfumX1vvWTaK5iZcbXhJxZTXZ1pve9Cb++Z//mQ996ENr7hlYWUG7uhK0Evl8nqGhoRtKpWJzKf77j/wJC+NL9O3rYuLsDKYJOw73US0UGT85SWd/G/lskXwiz7aDPZSKZYq5EvlYgY7+Ni6dnqKltwlPxEfJauXVP7qL9v7QFROT1vLZqtUqZ86coa+vbyPKuVdgbm6OmZkZXC4XpVKJYDB4xWjHm0WdZDY3N99048/g4CC/+Iu/SCQSYWpqis9+9rO89rWvvelzuhncQkyBTaJ5a1AUhW9+85v80i/9EhaLhTvuuIO3v/3t3HfffetKu+u6TiqVIhaLkcvlGh1zVquVoaEh+vv7WVrQ+fz/OcWXv3QBALfbwsHbWmpaRBG8FiuaanLb7S184Of24fVfX7czMzNDIpG4rq8nrC6svl6XeN0aqaWlZcMtF662mrh6Jm1d4xKJRG54/U3T5Gv/PMq//uNFliaLmA6NWKXM4mKFHTtDaJrBG964hU/85tpKO7lcjne96138/M//PO95z3sapZC1SCRuFcViEcMw8Hg8FItFXvva1/Kbv/mbvOENb1jvoTaJ5iZebnjJxZVcLscXv/hFPvnJT9Ld3c3dd9/NAw88wKFDh9ZFeq5VQVMUhfHxcfbu3bumvoHj3zrL//f+v8A0TXbc0cfMhQUCAQd2l43JczOoVY1As4/evZ2c+vYgpgEun5O2rS1oqoYv7CU2n8Hf08QHP/V2tu3paiRa4vH4mrrE69nX/v7+1Xwabwnz8/MsLS2xf/9+JEnCMIxGPM5mszdlxA4bQzKvtsbTNA1VVTd0JPZq2MCYAptE89bxR3/0RxiGwc/8zM/w1FNP8ZWvfIWnn36aQ4cO8cADD/DKV75yXWLtOrGbnZ0lmUwSDodpb28nGAwiiiJPPD7FV754gUSizFNPztIUdnL7vla29gd470/sYMv2638J6xYWxWKR3bt3r2vhqgur6yMn69Yb9U7sut6nq6trw62RbtQFuFLjUrebqpeQrqdbqulIz/Pdx6IkkiIzM3l002TfwWZ+4b/djije+DtSKBR497vfzU/91E/xvve975Y+581gYmKiUabXNI0f+7Ef4xOf+MTNHGqTaG7i5YaXZFz52Mc+xutf/3pe9apX8dhjj/Hwww8zNDTE/fffzwMPPMAdd9yxbtKTSCSYnp4mn883/BvXKo360mf/jX/+X48QaPLStS3C6X8fAqBjeyuiJIJhMD0yR6DVR9eODgQgHcviDniQrDL+9hA/+qtvoa37+R7V9ZgXjUYbxG6leX2xWOTs2bMb3qgKNx5XebPJjI0gmXVrvD/7sz97wcdJXo0NjCmwSTRvHfWRliuh6zpPP/00X/nKV/jud7/Lnj17ePDBB3nNa16zpp1ILBZjcnKSvXv3UqlUiEajq2YT69d3PXYZFy7UMqI36gBfy7FWWm9IkkS5XGbr1q03bUB7LdR1pAcOHFizdqbesBOLxdB1vbGbd7lcV+ifRkdHEQRhTSM2V0OpVOI973kPP/ETP8EHPvCBdb//JYZNormJlxt+aOLKarKtBx98kLvuumtNU+qmpqZIp9Ps3LmTXC5HNBq9IptYb/y4Fv7+f/wL3/3CU6SXsgwc2crE4DROjwOX145kF8nHCsgWGV03SM6n2X54K5JFpntfNz/+aw/gDV5fT1//3PUJO8lkEpvNRqFQYN++fRtOMmdmZhrT+taacCkUCs9LZlztPrIRJPPFtMZ7EbBJNF9o6LrO0aNHefjhh/n3f/93tm/fztvf/nZe97rXrdrIUu8uvHo8Yz2bWDfydblcNDc3EwqF1rTI1JtzXC4XW7Zs2bDJCVAra5w+fZpAIEChUFiTNdFasRFWE1eXkOr6m6WlJURRvGmSWalU+JEf+RHe+c538uEPf3hDr+nV0HWd2267jfb2dh555JEX6tdsEs1NvNzwQxlXFEXh8ccf5ytf+QpHjx7lyJEjPPjgg6vKtkzT5OLFi2iaxo4dO64gVVdnE30+H83NzdfU4//tJ7/E1/7omwBsv60XSRIZ+cFFANq3tYJgYrVZCbYHmbsU5b5338l7/tubsNrW38GdTqcZGRkhFAqRzWbXNIlvrZiamiKbzd7STPTVkhmhUIjx8fFbko69WNZ4L1JMgU2i+eLCMAxOnTrFl7/8Zb71rW/R09PDAw88wBvf+EbcbjdHjx7F5XKxe/fu65ZFTNOkUCg0sol2u53m5uZrmonXx5XdyHPsZlCf47tjx47GjnNlN5+maatmE9eCaDTKzMzMhlpN1PWwY2NjKIrSWLjWY5gLtc/4vve9jze84Q383M/93AtKMgE++9nPcuLECXK53CbR3MQmNg4/9HFFVVWefPLJhmzr4MGDPPjgg7zyla/EMAyOHz9Oe3s7fX19112nTNMknU43RgV7PB6am5uftzY++aVn+fqffJvoVIx8skD79haau5so5csoJQV/awDDMLjnXUd47Y+v374IaIzuXDn6caU0ShTFNUmjVsPExASFQmHd0rHrQVVVYrEY4+PjCIJAS0vLTbm2vJjWeC9STIFNovkfh7pB+pe//GUee+wxqtVqbSLDH/0RwWBwXccqFArEYjESiQSyLNPc3NzY9dV1kx0dHRte0q53Lu7Zs+eaTS9XZxPX2mm4uLjI/Pw8+/fvX1PGdq2o7+4Btm3b1tDfpFIpnE5nwzD3esRWURTe//73c++99/Lxj3/8BSeZc3NzPPTQQ3ziE5/gs5/97CbR3MQmNg7/qeLKStnWv//7v6OqKm9961v5jd/4jXVVl64uYdcraPXpOvOTC/z1b/4To09O0LKlmamhWdSKysHX7SPSFeadv/hGmlfRY64FsViMqamp61axrs4m1knn9ezuVk6o27Vr14au2/VyeVNTE62traRSKeLxeCNLvJZkRiqV4h3veAe/9Vu/xZvf/OYNO7fV8CLGFNgkmv/x0DSNd7zjHfT19eH3+3n00UcJBAK87W1v4y1veQuRyPq+rKVS6YrJP9Vq9QXRTWYyGS5cuMCePXtu6GVZx9W2SdfqNFxYWGBxcZF9+/a9ICTTNE36+/uvWGjqWeK6Ya4syw39zcods6ZpfPCDH+TQoUP82q/92gtOMgHe9a538eu//uvk83k+85nPbBLNTWxi4/CfMq4kEgne/OY388ADD5BIJBqyrQcffJDXve5163LDqM9fX5nMKJVK7N27F4/Hy9zFRbKxHJ6Ak84d7ciWm1+z65Z766liKYrSSGZUKpVV/anrs+hVVV33eOkboW7nF4lE6OjouOLfVhL26yUzMpkM73znO/mVX/mVF8V/+UWMKbBJNF8aOHXqFAcPHgQufyG+8pWv8PWvfx2Hw8Hb3vY23va2t9Hc3LzmL0ixWGRwcJBQKEQ+n8c0zcb0iFvVTdanH60sa6wXdW1QLBYjk8k0Og3L5dqYx2t1Ad4srkcyV0O5XG6UaQzDQFVVrFYrf/qnf8rAwAC/+Zu/+aKQzEceeYTHHnuMz3/+83zve9/bJJqb2MTG4j9lXNE0jZGRkYa592qyrbe97W288Y1vXFeTTTKZ5MKFC4TDYbLZLBaLZcN0k3Nzc0Sj0VtKMGia1khmFAqFhh4/FoutaQzyenE9knk16g20Kwl7NpslEonw8Y9/vGGN90LjRY4psEk0X9owTZOpqanGnFxJknjrW9/Kgw8+SFtb2zW/MNlslpGRkStK2lfrJtdSalgN9eacffv23fKM3Trqu75Lly6RzWYJhUKNMs1GZDTXSzKvhqIoPPHEE/z2b//2/7+9ew+K8rr/B/5+BFEJcpdFIRUJUQw3I6hDQlBzIVHAXQxm1MlXIsRMq0nQYKP9kUmL04xJ2thaGW2JqY2JadXlorKIGDIqOorGhnRQTEHBAZSLgVXAhb2d3x/4POWqu8uz7LL7ec3sTCBy9uC6z+ez55zn80FzczNSUlKQmpqKWbNmjXhuj/Kb3/wGX331FRwdHdHd3Y179+5h+fLl+Prrr83xdJRoEntjd3GFP7Yll8tRVFQEiUQCqVSKhISEh9aobG5uFtoz8kll3x20cePGCYsZxsaGuro6KJVKhIWFibbAoNfrhbOe/Hl8Hx8foVSgGOP/+OOPBiWZQ1GpVDhw4AB27twJBwcHvPHGG0hLSxO9NOBAoxxTAEo0xw7GGBobG4WkU61WIzExEVKpFNOnTxeSJ/6NFRERMezKpUajQWtrK5qbm6FWqwf1ER9OU1MT6uvrRe8DC/QWpm1vb0dYWJhw8bpz586I7zQcaZIJ9F5QNm7cCDc3N2RlZaG0tBR+fn6IiooyeqyRoBVNQkRn93GlqqoKcrkchYWFcHd3F5LOvse2DFlt7O7uFlphGrqDxtd15ltsinVzDj/21atX4eTkhCeeeKLfFraLi4tQKtCUxYyRJplA/9J4y5Ytg0KhwOLFi/H444+bNJ4paEVzMLu+IPTFGENzczPy8vKQl5eHjo4OxMfHw9HREWq1Ghs3bjQ4KeP7iDc3Nz/0Zh0xtjWGU1tbi46OjiHvAuz7iZnjOOHiZciWPWMM1dXV0Ov1I0oy33//fTg4OGDnzp2iXgiNRYkmIaKjuPLAUMe2EhMTUV1djfnz5+PVV181eLXRkB00fhFAp9OJfm5Sr9fj6tWrmDRp0qByfgPPnE6cOFFYzDBkAYVPMr29vU1OCvnSeMnJyVi3bt2oHMMaCiWag5k8WHFxMdLT06HT6fDmm29i69atYs7L4lpbW5GRkSGstL3yyitYtmyZ0W9e/mad5uZm4XyLRCKBUqlEe3s7wsPDRT83acynWWPuNOSTTJ1OZ/K5HL1ejw8++ADd3d3YvXu3RZPMUUKJJrE3FFeGwF+b165di6amJvj6+hp0bGsow+2g3bx5E05OTnjyySdFTzIrKyvh4uKCwMDAR/55/twkX4SdTzqHWswQI8nkS+MtWbIEGzZssFiSOYpsP9HU6XSYOXMmTp48CX9/f8ybNw///Oc/8dRTT4k5N4tqamrC5s2bsXfvXqhUKhw9ehS5ubloaGjASy+9hKSkJKNrhvHnW65fvw6VSgWJRAJfX99he9Eaiy810dPTg6eeesroNxt/8RrqTkMAI04yGWPIyspCa2sr9u7dK2qCzevu7kZsbCx6enqg1WqRnJyMrKws0Z/HCDZ/xSNkAIorwzh79iwUCgU++ugj3Lp1q9+xrYSEBEilUgQEBBh1fdVqtUK9ScYYpk2bBolE0u8O8ZHgz5+6ubkhICDA6J/nt//5m0D5xQxnZ2dRkky1Wo2UlBQsXLgQmzZtMkuSaW9xxSoSzfPnz+N3v/sdTpw4AQDYvn07gN4DsbaOL8Sam5uLmpoavPjii5DJZHj66acfmSzyK4JarRazZs2CUqnsd4c4X8jXlKSz79hibJnwfXz5Ow05jsPEiRONai02cH7bt29HXV0dvvzyS7MkmfzzdHV1wcXFBRqNBjExMdi5c+eo97XtgxJNYm8orhhh4LGte/fuIT4+HjKZDEFBQY+8lvN3aXt6esLf37/fdZvfQTO2yPnAsb28vERpTKJWq4XFjJ6eHuh0Ovj4+Bj0ew5Fo9EgLS0NUVFR2LJli9lWMu0troh7kM9EjY2N/T59+Pv7o7y83IIzGj2urq5YvXo1Vq9ejc7OThw/fhzZ2dmoqqrCokWLIJPJMG/evEGJFH9A3MHBQUgEvby84OXlBcaYkHRWV1cP6r/+KHx/cQCinctxcHCARCKBj48Pqqur0dXVBScnJ5SXlwvFcr28vAxKOhlj2LFjB6qrq3HgwAGzJZlAb496viqARqOBRqOxh20UQsY8e40rfNeb9evXY/369WhtbUVBQQG2bt2K1tZWLFmyBFKpdMhru1arFXqA8zfQSCQSSCQSYQetsbERVVVVw9ZYHk7fgumm3pwzkJOTE/z8/DB16lRUVFRgwoQJUKlUuHDhgnAvg6FJsVarxS9/+UuEhYWZNckE7C+uWEWiSXq5uLhgxYoVWLFiBVQqFUpKSrBv3z68++67eO655yCTyRAdHQ2dTofvv/8evr6+Q/ZE5zgOHh4e8PDwEPqvt7S04MaNG3B2doaPj8+wZYn4BNbR0VH0czn8QXatVos5c+aA47h+SXFNTc0j7zRkjCE7Oxv//ve/cejQIdFvehqKTqdDZGQkampqsGHDBixYsMDsz0kIIWKYMmUK1q1bh3Xr1qG9vR1Hjx7Ftm3bUF9fj7i4OOHYFl8NJTAwEL6+voPG4VtKTpkypV//9Z9++umRO2g6nQ4VFRUj6i8+HL1eL9TJ5D9Y8G2M+aTY3d0dPj4+w/aH1+l0eOeddzBjxoxRq79sT3HFKhJNPz8/1NfXC183NDSI/o9xrJk0aRKkUimkUil6enpQWlqKgwcPCmdGXn75Zfz2t7995BuC4zi4ubnBzc0NQUFBQitM/pA33wpz/PjxQqmJCRMmPLLnrrGG6/owMCnm7zSsra3FhAkThFqdTk5OYIwhJydHaN8mdvmm4Tg4OKCiogJKpRJJSUmorKxEaGjoqDw3IcQ0FFcG8/DwQEpKClJSUoRjW3/4wx9QVVWF7u5uZGRkGLR9O27cOIN30LRaLSoqKoSVRzHxSaanp2e/1WsHB4d+STE/v//+97+D5qfX67Fp0yZMmTIFv//970dtZdGe4opVnNHUarWYOXOmcEf2vHnz8M033yAkJMTgMVJTU1FYWAgfHx9UVlaaMg2r19XVBZlMhpCQEHR3d+Ps2bOIioqCVCrFokWLjC7AO/BOPq1WCw8PD7OtZBrbWqzv/L744gvo9Xo0NjaiuLjY5G5HI7Vt2zY4Oztj8+bNFnl+0BlNYn8sElfsIaYAQH19vdDZ7tq1a7h69SoWL14MqVSK+fPnG3U0qe8O2s8//4yJEyeiq6sLAQEBZlvJ9PT0NPi8Z9/5tba24k9/+hPGjRsHX19f/O1vf7NY1RJbjytWkWgCQFFRETZu3AidTofU1FRkZmYa9fNnzpyBi4sL1qxZY7MXBY1Gg7KyMjz//PMAei+k/OreqVOnEB4eDplMhhdeeMGoFpb8nXqMMeh0OqNrYT6MWP1rs7OzcejQIUyePBkajQYKhcKotmymam1txfjx4+Hu7g6VSoW4uDhs2bIFCQkJZn/uYVCiSeyNReKKPcQUoLeBSG1trdDcoru7GydOnIBcLscPP/yAmJgYyGQyPPPMM0YdVVKr1bh8+TIee+wxqFQqTJgwwahamA/D37nu4eFh8k1Fer0e7733Hq5evQqdTodp06ZBLpePyoqmvcUVq0k0xVBXV4eEhASbvigMR6fT4cKFC5DL5fj2228RHBwMmUyGuLi4h7aw5D8Venh4YPr06QD618Lky0dIJBKj+6/z5ZHUavWIksyDBw/iyy+/hEKhwGOPPYa2tjZ4eHiMygXhP//5D1JSUqDT6aDX6/Haa6/hww8/NPvzPgQlmsTeWCyu2HNMASAc25LL5SgvL0d0dDRkMhmee+65hyaLarUaFRUVmDFjhtC9qO8OlaOjo7CYYWw3OVNWMgcaqjReW1sbPD09TRrPWPYWVyjRtEF6vR6XL1/G4cOHceLECQQGBkIqleKVV16Bq6ur8Of4UhMPqznWt3yERqOBt7c3JBLJI/uvi5Vk5uXlIScnBwqFQqi/aeco0ST2hhJNK6DRaHDq1Cnk5uairKwMUVFRkMlkg45t9fT0oKKiAkFBQfDy8hpyLJVKhebmZqH/Ol8L81E7aGKsZPKl8W7evIl//OMfZq1aMoZQomkouigMxn/6O3z4MI4fP45p06ZBKpVi4cKF2LdvH9auXWtwqQmNRiO0wuQLsEskkkH910da6J137Ngx/OUvf4FCoYC7u7tJY1gDvV4v5tkfSjSJvaFE08oMd2zriSeegEKhQGpqqsGrg0MVYB9qB41PMt3d3YXdN2PxpfEqKytx4MCBUalaYi5jKa5QovlAfX091qxZg+bmZnAch7feegvp6elmmKXl8HeVHzhwAJ9//jnmzJmDpKQkJCQkwNvb26ixtFqt0Arz/v37Qs2yyZMn48aNGyNOMouLi/Hpp59CoVAM+6l4pMz1miuVSuh0Ojg4OPRLkC9duoSuri7Mnz8fzs7Opg5PiSaxN2M20bSHuMIf2/r73/+O/Px8LFy4EMnJyY88tjUUtVqNlpaWQf3XJ02aJEqSmZ2djfLychw8eNBsVUsorgwxOCWavW7fvo3bt29j7ty56OjoQGRkJAoKCmyqXRlv1apVSExMRFRUFORyOY4dOyaUU0pMTIREIjGp/zp/p+H48eMRHBxs8jnK0tJSbNu2DUVFRcL5HnMwx2ve1NSExYsXIyoqCk5OTtiwYQPmzp2LI0eO4NChQ4iOjoanpydWr15t6lNQoknszZhNNO0lrmi1WsTGxuKzzz6Do6MjDh8+jJKSEsyYMQPLli3DkiVL+h3bMkTf/ut8t7uZM2cO2kEzBF8a77vvvkNubq7R50KNQXFliMFtJdFctWoVTp06hTt37kAikSArKwtpaWkmjyeVSvH222/jpZdeEnGW1kGlUvXblmCMoba2Frm5uSgoKICjoyMSExMhk8kwdepUg97U/HZ5d3c3fH190dLSgrt378LNzQ0SiWTYQrkDnTlzBpmZmVAoFEMWDTankb7mer0e6enp8PPzw6ZNm/DXv/4V5eXleOedd3DlyhXEx8ejsbERNTU1WLlyJTQajSmfqinRJPbGInFF7JgC2Fdc4Y9tyeVyFBUVYerUqZBKpYiPj4eHh4dBY/Lb5a6urpg0aRJaWlr67aC5uro+Mj4xxrBv3z4oFArk5+ePemk8iis2lGiKqa6uDrGxsaisrDT6U9hYxxhDQ0MDcnNzkZ+fD61Wi8TEREilUvziF78Y9k3NJ5l9t8sZY2hvb0dLSwva29vh6uoqFModKuk8d+4c3n//fRQWFo56YWWxXvPPPvsMS5cuxezZs7Fs2TI0Njbirbfewtq1a+Hk5ITa2lqcO3cOd+/eRUhICBYtWmTsU1CiSewNxZUxjj+2JZfLUVhYCE9PT0il0oce2+KTTDc3NwQEBAjf77uD1tHRAU9PT6EV5lDxaf/+/f127kYTxZUHg1Oi2V9nZycWLlyIzMxMLF++3NLTsSjGGJqampCXl4f8/Hx0dnYiPj4eUqm0X+egoZLMoca6e/eusL3Ot5r09vaGg4MDLl68iI0bN+LYsWPD3gFvLmK85owxcByH7du3Q6PRoK2tDSqVCgsXLsSuXbtQXFwMNzc3XLlyBStWrEBaWhoyMjJMeSpKNIm9obhiQxhjqK6ufuixLb1eLyRnfZPMgfR6Pdra2oQdtIGtJv/1r39h//79Qmm80URxpc/glGj+j0ajQUJCAl5++WW89957lp6O1WltbUV+fj7y8vLw888/Y+nSpaivr8eCBQvw+uuvG3xupm+ryfz8fJSUlODWrVsoKChARESEmX+L/sR+zZVKJWJiYiCRSFBaWgoAWLFiBV599VWsXLkSVVVVOHnyJN59910A/7uQGIESTWJvKK7YqIHHthwcHBAfH4/Tp09jy5YtmDdvnsFj9W01uWfPHtTU1KClpQWnT582+mbXkaK4MmBwSjR7McaQkpICT09P/PnPfzZpjO7ubsTGxqKnpwdarRbJycnIysoSd6JWoq2tDWlpaaisrMTkyZMRFxeHpKQkhISEGFVy4ccff0R6ejqio6Nx/vx5/OpXv8LatWvNOPP/EeM1Hzgex3HIycnBnTt3sHz5cgQHB+Pjjz9GUFAQkpOT+/15/g5CI1GiSeyN3cYVe4opjDHU1dUJq3/Ozs5ISEiAVCrF9OnTjUqcjhw5gl27dmHu3LkoKyvD7t278eyzz5pr6v1QXBkCY0zMx5hVVlbGALCwsDAWERHBIiIimEKhMGoMvV7POjo6GGOMqdVqNn/+fHb+/HlzTNfirl+/ztatW8e0Wi1TKpXs66+/ZklJSSwiIoJlZGSwsrIy1tHRwbq6uoZ9XLp0iYWGhrKqqiphXI1GM2q/gxiv+VCqq6tZeno6y8jIYDt27GChoaGsqKhIhBkzxsR9v9KDHmPhMWaN9BpjTzGFMcaOHz/OPvnkE6bX69mtW7dYdnY2e/7559n8+fNZVlYWq6ioYJ2dnQ+NK7m5uWzBggXszp07jLHev0OtVjtqvwPFlcEPWtE0k/v37yMmJgZ79uzBggULLD2dUdPZ2YmioiLI5XJcu3YNixcvhkwmw7x58/qtdF67dg1vvPEGvvnmG4SGhlpwxuZx/fp1XLhwAaWlpXjmmWfw5ptvijU0rWgSe0NxBfYbU4DeY1sFBQXIzc3FnTt3sHTpUkilUgQHB/db6Ryt0niWMlbjCiWaItPpdIiMjERNTQ02bNiATz75xNJTshiVSoUTJ05ALpejoqICsbGxkMlk8PHxwZo1a7B//37MmTPH0tMcNYwZfW5mKJRoEntj13GFYkp/bW1tOHr0KHJzc9HY2Cgc22pra8MHH3xgkdJ4ljQW4golmmaiVCqRlJSEXbt22eSKnbF6enrw7bff4vDhwzhy5AhKSkqMOuhtrNTUVBQWFsLHx8fW2sdRoknsDcUVUEwZyt27d1FYWIiDBw/iwoULqKiowLRp08z2fBRXTBycEk3z2bZtG5ydnbF582ZLT8WqaLVas/eYPXPmDFxcXLBmzRq6IBAytlFceYBiyvAoroyIWeOKaB3ZSe85EqVSCaB32/jkyZMIDg42ehydToenn34aCQkJIs/QOpj7YgAAsbGx8PT0NPvzEEKIuYgVUwCKK2KguGIa878yduT27dtISUmBTqeDXq/Ha6+9ZtKbeufOnZg9ezbu3btnhlkSQggZC8SKKQDFFWI5lGiKKDw8HD/88MOIxmhoaIBCoUBmZiZ27Ngh0swIIYSMNWLEFIDiCrEs2jq3Mhs3bsSnn35qVNFzQgghZDgUV4gl0b86K8LfzRYZGWnpqRBCCLEBFFeIpVGiaUXOnTuHo0ePIiAgACtXrsR3332H119/3aSxAgICEBYWhjlz5iAqKkrkmVq/VatWITo6Gj/99BP8/f3xxRdfWHpKhBAy6iiuiIfiimmovJEJRCqQ+lCnTp3CH//4RxQWFpr08wEBAfj+++/h7e0t8syIhVF5I2JvKK6IhOIKGQaVN7I2HMfh5s2blp4GIYQQG0FxhdgqSjQNxK/8Xrt2Dbt378b69evx5JNP4vPPPzfL8y1atMjkT51A70UrLi4OkZGRyMnJEXFmlldcXIxZs2YhKCgIH3/8saWnQwghJqG4Yj0orpgRY0zMh81LTk5meXl5jDHGDh06xH79618zlUpl4VkN1tDQwBhjrLm5mYWHh7PTp09beEbi0Gq1LDAwkF2/fp319PSw8PBwduXKFUtPazSJ/Z6lBz2s/WHzKK5YFsUV876HaUXTQPfv30dOTg6KiorAGENbWxtCQkJw8+ZNdHV1WXp6g/j5+QEAfHx8kJSUhIsXL1p4RuK4ePEigoKCEBgYCCcnJ6xcuRJHjhyx9LQIIcRoFFesA8UV86JE00Bnz55FTU0NMjMzcfLkScTExCAtLQ2+vr7w8vISOjdYg66uLnR0dAj/XVJSgtDQUJPGUiqVSE5ORnBwMGbPno3z58+LOVWjNTY24vHHHxe+9vf3R2NjowVnRAghprHHuGJtMQWguGJuYt91brM4jtsKQAsgmzHWzXHcWwBefPD1GcvOrj+O4wIB5D/40hHAN4yxj0wc60sAZYyxvRzHOQFwZowpxZmpSfNJBvAKY+zNB1//H4AFjLG3LTUnQggxhT3GFWuLKQ/mRHHFjKgFpQG43poTSgBTH1wMJAAyAGwB8BPHcR8A8AHwoaXfMADAGLsBIGKk43Ac5wYgFsAbD8ZVA1CPdNwRagTweJ+v/R98jxBCxgx7jCtWGlMAiitmRYmmARhjjOO4WwAyOY6bDMAFQC5jrAAAOI7bDeAra7gYiGwGgFYA+ziOiwBwGUA6Y8ySh4cuAXiS47gZ6L0QrASw2oLzIYQQo9lpXLHGmAJQXDErOqNpIMbYUQBSALcA7GaM/b8+//tZAD8CAMdxtvR36ghgLoA9jLGnAXQB2GrJCTHGtADeBnACQBWAQ4yxK5acEyGEmMIO44rVxRSA4oq50RnNEeA4bjwAPYCPABxmjF3mOI5jNvKXynGcL4ALjLGAB18/B2ArYyzeohMjhBAbZctxhWKKfbKVT0mjgnugz7dcAewBsAbANKB3O8QSczMHxlgTgHqO42Y9+NYLAK5acEqEEGJT7CmuUEyxT7SiKQKO454C8Bhj7JKl5yI2juPmANgLwAnADQBrGWPtFp0UIYTYOFuNKxRT7A8lmiNgK9sZhBBCrAPFFWJrKNEkhBBCCCFmQWc0CSGEEEKIWVCiSQghhBBCzIISTUIIIYQQYhaUaBJCCCGEELOgRJMQQgghhJgFJZqEEEIIIcQsKNEkhBBCCCFmQYkmIYQQQggxi/8Pag8GyxVm2AQAAAAASUVORK5CYII=" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "主程序段总共运行了 1.7720370292663574 秒\n" - ] - } - ], - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T12:21:49.972769Z", - "start_time": "2021-03-02T12:21:45.792119Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "## 梯度分析工具\n", - "\n", - "基于梯度在贫瘠高原等现象中的表现出的重要作用，我们在量桨平台开发了一个简单的梯度分析工具，辅助用户查看电路中各参数的梯度情况，方便对量子神经网络做后续研究。\n", - "\n", - "需要注意的是，我们使用梯度分析工具时仅需用户**单独定义传入的电路和损失函数，不需要用户自己写网络训练**，减少使用负担" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "### 应用 一：无监督学习\n", - "\n", - "对于该类情况，主要关注类似变分量子本征求解器（VQE）的变分量子算法。该类变分算法要优化的目标函数通常是量子电路关于哈密顿量 $H$ 的期望值，即 $O(\\theta) = \\left\\langle0\\dots 0\\right\\lvert U^{\\dagger}(\\theta)HU(\\theta) \\left\\lvert0\\dots 0\\right\\rangle$，这里的 $U(\\theta)$ 表示的就是参数化量子电路，其中 $\\theta = [\\theta_1, \\theta_2, \\dots, \\theta_n]$ 是电路中的可训练参数，$H$ 是哈密顿量。 \n", - "\n", - "这里我们就以 VQE 做代表，演示该梯度分析工具的用法。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### Paddle Quantum 实现\n", - "\n", - "首先导入该问题需要的包：" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 22, - "source": [ - "# 需要用的包\n", - "from paddle_quantum.utils import pauli_str_to_matrix, random_pauli_str_generator\n", - "# 导入梯度工具包\n", - "from paddle_quantum.gradtool import random_sample, show_gradient, plot_distribution, plot_loss_grad" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### 定义量子电路\n", - "\n", - "接着，构造目标函数 $O(\\theta) = \\left\\langle00\\right\\lvert U^{\\dagger}(\\theta)HU(\\theta) \\left\\lvert00\\right\\rangle$ 中的参数化量子电路 $U(\\theta)$。这里我们还是采用上文中定义的随机电路。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### 定义目标函数\n", - "\n", - "之后给出要优化的目标函数（这里需要注意的是，在梯度分析模块中我们是以 ``loss_func(circuit, *args)`` 的形式调用函数计算目标函数值的。这也就是说，第二个参数是可变参数，用户可以根据需要灵活的构造自己模型的目标函数形式）：" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 24, - "source": [ - "# 要优化的目标函数，其中参数分别是电路和哈密顿量\n", - "def loss_func(circuit, H_l):\n", - " circuit.run_state_vector()\n", - " return (circuit.expecval(H_l))" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "接着设置一些应用所需的参数" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 25, - "source": [ - "# 超参数设置\n", - "np.random.seed(42) # 固定 Numpy 的随机种子\n", - "N = 2 # 设置量子比特数量 \n", - "samples = 300 # 设定采样随机网络结构的数量\n", - "THETA_SIZE = N # 设置参数 theta 的大小 \n", - "ITR = 120 # 设置迭代次数\n", - "LR = 0.1 # 设定学习速率\n", - "SEED = 1 # 固定优化器中随机初始化的种子" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "随机生成参数化量子电路，以及哈密顿量信息列表。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 26, - "source": [ - "paddle.seed(SEED)\n", - "target = np.random.choice(3, N)\n", - "# 在 0 - 2*Pi 间随机生成各参数值\n", - "theta = np.random.uniform(low=0., high= 2 * np.pi, size=(THETA_SIZE))\n", - "theta = paddle.to_tensor(theta, stop_gradient=False, dtype='float64')\n", - "cir = rand_circuit(theta, target, N)\n", - "print(cir)\n", - "# 随机生成哈密顿量列表，以 Pauli 字符串形式表现\n", - "H_l = random_pauli_str_generator(N, terms=7)\n", - "print('Hamiltonian info: ', H_l)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "--Ry(0.785)----Rx(1.153)----*--\n", - " | \n", - "--Ry(0.785)----Rz(4.899)----z--\n", - " \n", - "Hamiltonian info: [[0.7323522915498704, 'z0'], [-0.8871768419457995, 'y0'], [-0.9984424683179713, 'x0,x1'], [0.22330632097656178, 'x0'], [-0.9538751499171685, 'z1'], [-0.20027805656948905, 'z0'], [-0.8187871309343584, 'y1']]\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "``cir`` 和 ``H_l`` 就是要优化的目标函数 ``loss_func`` 所需的参数。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "用户可以通过我们提供的梯度分析工具，查看电路中各参数梯度采样的结果。同时，可以根据需求在 ``single``, ``max``, 以及 ``random`` 三种模式间选择，其中 ``single`` 会返回电路多次采样后每个参数的平均值和方差， ``max`` 模式返回每轮采样中所有参数梯度最大值的均值和方差，``random`` 则是在每轮采样得到的各参数梯度中随机选择一个后计算均值和方差。\n", - "\n", - "我们首先对该电路采样 300 次，这里我们选择 ``single`` 模式，看看电路中每个可变参数梯度的平均值和方差，同时默认 ``param=0`` 表示我们查看第一个参数的梯度分布情况。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 27, - "source": [ - "grad_mean_list, grad_variance_list = random_sample(cir, loss_func, samples, H_l, mode='single', param=0) " - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Sampling: 100%|###################################################| 300/300 [00:14<00:00, 21.14it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mean of gradient for all parameters: \n", - "theta 1 : -0.03157116754124028\n", - "theta 2 : -0.004525341240963983\n", - "Variance of gradient for all parameters: \n", - "theta 1 : 0.07237471326311368\n", - "theta 2 : 0.027855249806997346\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "用户如果想要查看该量子电路在训练过程中梯度和损失值的变化情况，还可以使用 ``plot_loss_grad`` 函数，辅助查看电路的训练效果。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 12, - "source": [ - "plot_loss_grad(cir, loss_func, ITR, LR, H_l)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Training: 100%|###################################################| 120/120 [00:03<00:00, 38.59it/s]\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "如上图所示，可以看出 iteration 在几十次后损失函数的值就基本不发生变化了，而梯度也非常的接近 0。为了更直观的看到训练得到的最优解和理论值的差距，我们计算哈密顿量 ``H_l`` 的特征值。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 13, - "source": [ - "loss, grad = show_gradient(cir, loss_func, ITR, LR, H_l)\n", - "H_matrix = pauli_str_to_matrix(H_l, N)\n", - "\n", - "print(\"最终的优化结果： \", loss[-1])\n", - "print(\"实际的基态能量：\", np.linalg.eigh(H_matrix)[0][0])" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Training: 100%|###################################################| 120/120 [00:03<00:00, 39.95it/s]" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "最终的优化结果： -1.506230314972159\n", - "实际的基态能量： -2.528866656129176\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "通过对比可以看出，该电路训练得到的最优解和我们要得到的实际值之间还存在一定的差距。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### 更多的量子比特\n", - "\n", - "由于在贫瘠高原效应中，梯度会随着量子比特数的增加呈指数级消失。所以我们可以进一步对比增加电路中量子比特的数量，看看会对我们的梯度带来什么影响 (这里我们采样时选择 ``max`` 模式，对参数列表中的最大值做计算)。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 34, - "source": [ - "# 超参数设置\n", - "selected_qubit = [2, 4, 6, 8]\n", - "means, variances = [], []\n", - "\n", - "# 不断增加量子比特数量\n", - "for N in selected_qubit:\n", - " grad_info = []\n", - " THETA_SIZE = N \n", - " target = np.random.choice(3, N)\n", - " theta = np.random.uniform(low=0., high= 2 * np.pi, size=(THETA_SIZE))\n", - " theta = paddle.to_tensor(theta, stop_gradient=False, dtype='float64')\n", - " cir = rand_circuit(theta, target, N)\n", - " H_l = random_pauli_str_generator(N, terms=10)\n", - " \n", - " grad_mean_list, grad_variance_list = random_sample(cir, loss_func, samples, H_l, mode='max') \n", - " # 记录采样信息\n", - " means.append(grad_mean_list)\n", - " variances.append(grad_variance_list)\n" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Sampling: 100%|###################################################| 300/300 [00:22<00:00, 13.28it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mean of max gradient\n", - "0.31080108926858796\n", - "Variance of max gradient\n", - "0.01671146619361498\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Sampling: 100%|###################################################| 300/300 [00:33<00:00, 8.86it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mean of max gradient\n", - "0.18860559161991128\n", - "Variance of max gradient\n", - "0.00513813734318612\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Sampling: 100%|###################################################| 300/300 [00:40<00:00, 7.45it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mean of max gradient\n", - "0.15985084804138153\n", - "Variance of max gradient\n", - "0.003425544062206579\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEICAYAAABS0fM3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAdzUlEQVR4nO3de5gcVZ3/8ffHQAgi94xKLpDghsXIqugQ8LbyIGgCmrgrSrK6clEj+zPqelvD6kY2K6vouv5A8ns0eAWEEFDWEUeDN1ZRwAwIaBIDQwgmEWQI4SZyGfz+/qgzUNOp7umZTE1npj6v5+lnqk6dPvWt0z397Tqnu1oRgZmZVdczWh2AmZm1lhOBmVnFORGYmVWcE4GZWcU5EZiZVZwTgZlZxTkRjCKSzpR0UavjaIakoyVtzq2vkXR0i2L5uqRPpuVXSVo/jG1/X9LJafkUSdcMY9tvlXTVcLU3iP2+QtJtkh6W9MaS99X04zFQ/0q6WtI7hy+66til1QHY0yQ9nFt9JvAY8GRaf/fIRzR8IuIFw9GOpDOBv4qItw0xjp8Dfz1c+4mIOUOJo2B/04A7gF0joje1/U3gm8PR/iAtBc6LiHPK3lGzj4eVy2cEO5GIeFbfDfg98IZcWSteEACQ5DcMNZQZq/8/BwFryt6Jn1c7j7H6RB7Lxku6QNJDabilvW+DpEmSviWpR9Idkt5XrxFJ+0v6rqQHJa2W9Mn8abekkPQeSbcBt6WycyRtSve5QdKrcvV3T0Mw2yStBY6o2d9GScem5WdIWizpdklbJa2UtF/aNi3t+2RJv5d0r6SPpW2zgX8FTkrDFjfXObbDJd2Y+uhSYEJuW+2Q1UclbUl110t6Tb39pKGHsyT9AngEOLhgOEKSzpP0gKTfSXpNUR+k9fxQ38/S3/vTPl9WOxQi6eXpsXog/X15btvVkv5D0i/SsVwlaWJR/6T675LULek+SR2SJqXy24GDge+mOHarud9HJV1eU3aOpHPT8qmS1qUYNkh6d67e0ZI2pzbuBr5W8Hj0PS8ekrRW0t9tH3px/xYc42kplm2SVkk6qK8BSZ+XdE96Lv9G0mH12qmEiPBtJ7wBG4Fja8rOBB4FjgfGAZ8CrkvbngHcACwBxpP9M28AXlen/RXp9kxgJrAJuCa3PYAfAvsBu6eytwH7kw0pfgi4G5iQtn0a+HmqPxX4LbC56HiA9wPXAVOA3YAvAZekbdPSvs8HdgdeRDZE9vxcH1zUoN/GA3cCHwB2BU4EngA+mbYf3RcX2ZDEJmBSbt/Pq7cf4GqyM7UXpD7YNZW9M20/BejN7fsk4AFgv6LHNL+P3HHvktt+St9jkvp1G/CPad8L0vr+udhuBw5J/XY18Ok6fXQMcC/wktT/XwB+1ui5l9t2EFkS3DOtjwPuAo5K6ycAzwMEvDrVfUmu73uBs9N+d88/HqnOm4FJZM/nk4A/AQc02b/5x2Ie0A08P/XXx4Ffpm2vI/tf2SfF+fy+fVT15jOC0eeaiOiMiCeBC8leKCF7B94WEUsj4vGI2ED2Yjq/tgFJ44A3AZ+IiEciYi3wjYJ9fSoi7ouIPwNExEURsTUieiPic2T/zH3ju28Bzkr1NwHnNjiG04GPRcTmiHiM7AXxRPUfKvj3iPhzRNwM3Jw7zoEcRfYi8X8j4omIuBxYXafuk+kYZkraNSI2RsTtA7T/9YhYk/rgiYLt9+T2fSmwnuzFcUedANwWERemfV8C/A54Q67O1yLi1vR4rQReXKettwJfjYgbU/+fAbxM2TxFQxFxJ3Aj0PdO/RjgkYi4Lm3/XkTcHpn/Ba4CXpVr4i9kz7vH+p5XNe1fFhF/iIi/pP67DZiVq9Js/55O9vxdF9mcy38CL05nBU8AewKHAkp17hro2McyJ4LR5+7c8iPAhPQCehAwSdL9fTey4Y3nFLTRRvYuaVOubFNBvX5lkj6cTrUfSO3vDfQNP0yqqX9ng2M4CLgiF+c6shflfKy1x/msBu3lTQK2RHrr1yiWiOgG/pksEd0jaUXfEEkDRf2UV7TvgdpsxiS2P447gcm59Wb7rF9bEfEwsLWmrUYuJjsjAfiHtA6ApDmSrktDTveTnb3mh6h6IuLReg1Lerukm3LPjcNq7t9s/x4EnJNr5z6yd/+TI+InwHnAMrLHfbmkvZo58LHKiWDs2ATcERH75G57RsTxBXV7yE6xp+TKphbUe+ofTtl8wL+QvfPfNyL2ITstV6pyV00bBw4Q65yaWCdExJYBjrFfTHXcBUyWpFxZ3Vgi4uKIeCXZC0eQDVs02s9A+y/a9x/S8p/IhuL6PHcQ7f4hxZh3INBMnzVsS9IeZEN+zbZ1GXC0pClkZwYXp3Z2A74F/BfwnPQc6eTp5wg0OM70bv18YBHZkNc+ZEOM+fs36t+8TcC7a55ju0fELwEi4tyIeCnZsOghwEeaPPYxyYlg7PgV8FCaiNtd0jhJh0k6orZiGlb6NnCmpGdKOhR4+wDt70mWPHqAXSQtAfLvolYCZ0jaN71AvLdBW18EzspN3rVJmtfkcf4RmKb6n9i5NsX5Pkm7Svp7+g8tPEXSX0s6Jr2APQr8mWzoopn91PPs3L7fTDb+3Jm23QTMT9vayeYv+vSkfR9cp91O4BBJ/yBpF0knkb2IXTnI+AAuAU6V9OJ07P8JXB8RG5u5c0T0kI3Hf43szce6tGk82VBbD9AraQ7w2kHEtQdZouiBbOKZ7Iwgr1H/5n2R7Pn4gtTW3qk+ko6QdKSkXcmS86M8/bhXkhPBGJFe3F9PNi58B9lk4JfJhm+KLErb7iaba7iEbFK2nlXAD4BbyU7HH6X/MMm/p/I7yMaFL2zQ1jlAB3CVpIfIJo6PbFA/77L0d6ukG2s3RsTjwN+TTSzeRzah+O06be1GNsl9L1k/PJtsvHzA/TRwPTAjtXkWcGJEbE3b/o1sInUbWX89NaQSEY+k+r9IwxlH1RzXVrLH90Nkwzj/Arw+Iu4dRGx9bf0oxfItsjOo51EwlzSAi4Fja47hIeB9ZG8KtpENG3UMIq61wOfIkvkfgb8BflFTrVH/5tu6guzsboWkB8nOLPq+87EX2ZnHNrLn7Fbgs83GORap/3CbVZWks4HnRsTJrY7FzEaWzwgqStKhkl6YPlM9C3gHcEWr4zKzkedv9lXXnmTDQZPITsM/B3ynpRGZWUt4aMjMrOI8NGRmVnGjbmho4sSJMW3atFaHYWY2qtxwww33RkRb0bZRlwimTZtGV1dXq8MwMxtVJNX9tr+HhszMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqbtR9s9jMbKRNW/y9VocAwMZPn1BKuz4jMDOrOCcCM7OKcyIwM6s4JwIzs4pzIjAzqzgnAjOzinMiMDOrOCcCM7OKKzURSJotab2kbkmLC7YfKOmnkn4t6RZJx5cZj5mZba+0RCBpHLAMmAPMBBZImllT7ePAyog4HJgP/L+y4jEzs2JlnhHMArojYkNEPA6sAObV1Algr7S8N/CHEuMxM7MCZV5raDKwKbe+GTiyps6ZwFWS3gvsARxbYjxmZlag1ZPFC4CvR8QU4HjgQknbxSRpoaQuSV09PT0jHqSZ2VhWZiLYAkzNrU9JZXnvAFYCRMS1wARgYm1DEbE8Itojor2tra2kcM3MqqnMRLAamCFpuqTxZJPBHTV1fg+8BkDS88kSgd/ym5mNoNISQUT0AouAVcA6sk8HrZG0VNLcVO1DwLsk3QxcApwSEVFWTGZmtr1Sf5gmIjqBzpqyJbnltcAryozBzMwaa/VksZmZtZgTgZlZxTkRmJlVnBOBmVnFORGYmVWcE4GZWcU5EZiZVZwTgZlZxTkRmJlVnBOBmVnFORGYmVWcE4GZWcU5EZiZVZwTgZlZxTkRmJlVnBOBmVnFlZoIJM2WtF5St6TFBds/L+mmdLtV0v1lxmNmZtsr7RfKJI0DlgHHAZuB1ZI60q+SARARH8jVfy9weFnxmJlZsTLPCGYB3RGxISIeB1YA8xrUX0D2u8VmZjaCykwEk4FNufXNqWw7kg4CpgM/qbN9oaQuSV09PT3DHqiZWZXtLJPF84HLI+LJoo0RsTwi2iOiva2tbYRDMzMb28pMBFuAqbn1KamsyHw8LGRm1hJlJoLVwAxJ0yWNJ3ux76itJOlQYF/g2hJjMTOzOkpLBBHRCywCVgHrgJURsUbSUklzc1XnAysiIsqKxczM6ivt46MAEdEJdNaULalZP7PMGMzMrLGdZbLYzMxaxInAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCqu1EQgabak9ZK6JS2uU+ctktZKWiPp4jLjMTOz7ZX2wzSSxgHLgOOAzcBqSR0RsTZXZwZwBvCKiNgm6dllxWNmZsXKPCOYBXRHxIaIeBxYAcyrqfMuYFlEbAOIiHtKjMfMzAqUmQgmA5ty65tTWd4hwCGSfiHpOkmzixqStFBSl6Sunp6eksI1M6umVk8W7wLMAI4GFgDnS9qntlJELI+I9ohob2trG9kIzczGuDITwRZgam59SirL2wx0RMQTEXEHcCtZYjAzsxFSZiJYDcyQNF3SeGA+0FFT53/IzgaQNJFsqGhDiTGZmVmN0hJBRPQCi4BVwDpgZUSskbRU0txUbRWwVdJa4KfARyJia1kxmZnZ9kr7+ChARHQCnTVlS3LLAXww3czMrAVaPVlsZmYt5kRgZlZxTgRmZhXnRGBmVnFOBGZmFedEYGZWcU4EZmYV50RgZlZxTgRmZhXnRGBmVnFOBGZmFedEYGZWcU4EZmYV50RgZlZxTgRmZhVXaiKQNFvSekndkhYXbD9FUo+km9LtnWXGY2Zm2yvth2kkjQOWAceR/TbxakkdEbG2puqlEbGorDjMzKyxMs8IZgHdEbEhIh4HVgDzStyfmZkNQZmJYDKwKbe+OZXVepOkWyRdLmlqUUOSFkrqktTV09NTRqxmZpXV6sni7wLTIuKFwA+BbxRViojlEdEeEe1tbW0jGqCZ2VhXZiLYAuTf4U9JZU+JiK0R8Vha/TLw0hLjMTOzAmUmgtXADEnTJY0H5gMd+QqSDsitzgXWlRiPmZkVaPpTQ5JeBLwqrf48Im5uVD8ieiUtAlYB44CvRsQaSUuBrojoAN4naS7QC9wHnDKEYzAzsx3QVCKQ9H7gXcC3U9FFkpZHxBca3S8iOoHOmrIlueUzgDMGFbGZmQ2rZs8I3gEcGRF/ApB0NnAt0DARmJnZzq/ZOQIBT+bWn0xlZmY2yjV7RvA14HpJV6T1NwJfKSUiMzMbUU0lgoj4b0lXA69MRadGxK9Li8rMzEZMw0Qgaa+IeFDSfsDGdOvbtl9E3FdueGZmVraBzgguBl4P3ABErlxp/eCS4jIzsxHSMBFExOvT3+kjE46ZmY20pj41JOnHzZSZmdnoM9AcwQTgmcBESfvy9EdG96L4SqJmZjbKDDRH8G7gn4FJZPMEfYngQeC88sIyM7ORMtAcwTnAOZLeO9DlJMzMbHRq9nsEX5B0GDATmJArv6CswMzMbGQ0e9G5TwBHkyWCTmAOcA3gRGBmNso1e62hE4HXAHdHxKnAi4C9S4vKzMxGTLOJ4NGI+AvQK2kv4B76//qYmZmNUgMODUkScIukfYDzyT499DDZZajNzGyUG/CMICICmBUR90fEF4HjgJPTEFFDkmZLWi+pW9LiBvXeJCkktQ8qejMz22HNDg3dKOkIgIjYGBG3DHQHSeOAZWQTyzOBBZJmFtTbE3g/cH3TUZuZ2bBpNhEcCVwr6XZJt0j6jaSBksEsoDsiNkTE48AKYF5Bvf8AzgYebTpqMzMbNs3+MM3rhtD2ZGBTbn0zWUJ5iqSXAFMj4nuSPlKvIUkLgYUABx544BBCMTOzepr9Qtmdw71jSc8A/hs4pYn9LweWA7S3t8cA1c3MbBCaHRoaii30/4jplFTWZ0/gMOBqSRuBo4AOTxibmY2sMhPBamCGpOmSxgPzgY6+jRHxQERMjIhpETENuA6YGxFdJcZkZmY1SksEEdELLAJWAeuAlRGxRtJSSXPL2q+ZmQ1Os5PFQxIRnWTXJsqXLalT9+gyYzEzs2JlDg2Zmdko4ERgZlZxTgRmZhXnRGBmVnFOBGZmFedEYGZWcU4EZmYV50RgZlZxTgRmZhXnRGBmVnFOBGZmFedEYGZWcU4EZmYV50RgZlZxTgRmZhVXaiKQNFvSekndkhYXbD9d0m8k3STpGkkzy4zHzMy2V1oikDQOWAbMAWYCCwpe6C+OiL+JiBcDnyH7MXszMxtBZZ4RzAK6I2JDRDwOrADm5StExIO51T2AKDEeMzMrUOZPVU4GNuXWNwNH1laS9B7gg8B44JiihiQtBBYCHHjggcMeqJlZlbV8sjgilkXE84CPAh+vU2d5RLRHRHtbW9vIBmhmNsaVmQi2AFNz61NSWT0rgDeWGI+ZmRUoMxGsBmZImi5pPDAf6MhXkDQjt3oCcFuJ8ZiZWYHS5ggiolfSImAVMA74akSskbQU6IqIDmCRpGOBJ4BtwMllxWNmZsXKnCwmIjqBzpqyJbnl95e5fzMzG1jLJ4vNzKy1nAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOJKTQSSZktaL6lb0uKC7R+UtFbSLZJ+LOmgMuMxM7PtlZYIJI0DlgFzgJnAAkkza6r9GmiPiBcClwOfKSseMzMrVuYZwSygOyI2RMTjZD9OPy9fISJ+GhGPpNXryH7g3szMRlCZiWAysCm3vjmV1fMO4PtFGyQtlNQlqaunp2cYQzQzs51isljS24B24LNF2yNieUS0R0R7W1vbyAZnZjbGlfnj9VuAqbn1KamsH0nHAh8DXh0Rj5UYj5mZFSjzjGA1MEPSdEnjgflAR76CpMOBLwFzI+KeEmMxM7M6SksEEdELLAJWAeuAlRGxRtJSSXNTtc8CzwIuk3STpI46zZmZWUnKHBoiIjqBzpqyJbnlY8vcv5mZDWynmCw2M7PWcSIwM6s4JwIzs4pzIjAzqzgnAjOzinMiMDOrOCcCM7OKcyIwM6u4Ur9QZmaj07TF32t1CABs/PQJrQ6hEnxGYGZWcU4EZmYV50RgZlZxTgRmZhXnRGBmVnFOBGZmFVdqIpA0W9J6Sd2SFhds/1tJN0rqlXRimbGYmVmx0hKBpHHAMmAOMBNYIGlmTbXfA6cAF5cVh5mZNVbmF8pmAd0RsQFA0gpgHrC2r0JEbEzb/lJiHGZm1kCZQ0OTgU259c2pzMzMdiKjYrJY0kJJXZK6enp6Wh2OmdmYUmYi2AJMza1PSWWDFhHLI6I9Itrb2tqGJTgzM8uUmQhWAzMkTZc0HpgPdJS4PzMzG4LSEkFE9AKLgFXAOmBlRKyRtFTSXABJR0jaDLwZ+JKkNWXFY2ZmxUq9DHVEdAKdNWVLcsuryYaMzMysRUbFZLGZmZXHicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4pwIzMwqzonAzKzinAjMzCrOicDMrOKcCMzMKs6JwMys4kpNBJJmS1ovqVvS4oLtu0m6NG2/XtK0MuMxM7PtlZYIJI0DlgFzgJnAAkkza6q9A9gWEX8FfB44u6x4zMysWJk/VTkL6I6IDQCSVgDzgLW5OvOAM9Py5cB5khQRUWJcZoWmLf5eq0Ng46dPaHUIVkFlJoLJwKbc+mbgyHp1IqJX0gPA/sC9+UqSFgIL0+rDktaXEnFzJlITX8W5P562w32hsXVO7P7or9X9cVC9DaX+eP1wiYjlwPJWxwEgqSsi2lsdx87C/fE090V/7o/+dub+KHOyeAswNbc+JZUV1pG0C7A3sLXEmMzMrEaZiWA1MEPSdEnjgflAR02dDuDktHwi8BPPD5iZjazShobSmP8iYBUwDvhqRKyRtBToiogO4CvAhZK6gfvIksXObqcYotqJuD+e5r7oz/3R307bH/IbcDOzavM3i83MKs6JwMys4iqfCNJk9vXpMheXpontonpnpDrrJb0uV154GY167Ur6W0k3SuqVdOIQY5akn0jaq1EMNfepezmPIRzbolQWkiY2iLOw3Zo69fqpMF5J+0v6qaSHJZ1X09aPJO2bW99d0v9KGifpZEm3pdvJFJC0n6Qfpjo/7Gsr9fe5KZZbJL0kd58fSLpf0pUN+qGw3YJ6hTFKOkvSJkkP19RfJOm0evtt1jD206GSrpX0mKQPN9jfSyX9JvXnuZJUUKewLUnjJf1M2acMd3r1nt81deo+p0dMRFTuBowH9kjLK4H5afmLwD8V1J8J3AzsBkwHbiebAB+Xlg9Obd4MzGzULjANeCFwAXDiEOM/Afh8Wq4bQ819/g/wxbQ8H7h0B47t8HQcG4GJdWIsbLegXr1+qhfvHsArgdOB82raOhn4WG79PcD7gf2ADenvvml534JYPgMsTsuLgbPT8vHA9wEBRwHX5+7zGuANwJUNHq/Cdmvq1I0x7fMA4OGa+zwT+PUw/D8MVz89GzgCOAv4cIP9/Sodk1K/zimoU7ct4BPAW4f7dWGIfbdd/zTz/K6pU/c5PWLH0eqOHOEH7fnA54A7yF7MRPZNv13S9pcBqwrudwZwRm59Varbr35fvWbaBb7O0BPBxcDRRW3Xxlobc1reJcWnwR5bTZsbqZ8ICtutqVO3n+rFm7vvKbX/NOnF67e59V+SJawFwJdy5V8CFhTEvB44IC0fAKwvqp+vl9aPpnEiKGy3ps6AMVKTCFLZFcCsHfy/GJZ+ym0/kzqJINX/Xb3jLqi/XVvAi4DOHTnm4bqRvcH5JnBM/vk50PO7TlvbPadH6jbmh4Yk7SHpVEnXAOeTXevohRHxa7LLWdwfEb2p+mayy17UKrpcxuQG5c22O1SvAG4YILZa/S7nAfRdzmOwx9asZu7fqJ/qxVtXRGwDdkun2uOBgyNi4yCO5TkRcVdavht4ziCOpZF67eYNdR9dwKsGEUs/w9xPzZic2h1oH438luxsYWdwCHAJsAhYK+lfJU1K28p+HRg2o2KcbQfdBdwCvDMiftfqYIbJfhHxUKuD2EndA0wi+4b6/UNtJCJC0rB/trqEdu8BDt2B+09kJ+ynAfb5pKTHJe3Z6v+DiHgSuBK4UlIb8Cng95JeTja0NiqM+TMCsm8sbwG+LWmJpPyFl7YC++QmnoougwH1L5dRr7zZdoeqV1LfY9fMpTz61VP/y3kM9tia1cz9G/XTUC8/MgH4c7pNGEQsAH+UdEDa5wFkL7KDuX899drNG+o++o53qIazn5qxJbU70D4Gshvw6BDuN+wk7S3p3WRXSpgBnEb25rPs14FhM+YTQURcFREnkZ0+PwB8J326ZFpkA3M/JUsWkE02fqegmQ5gfvoky3SyB/tX1LmMxiDaHar1ZJO41IuhzjEUXc5jUMfWKChJsyRdkNtfUbtPGaCfBn35kfTpk+cCG9Mw0ThJE8jmG14rad/0CZfXprJa+X3WxvL29Omho4AHckMj9WL5lKS/G6DdvGZjrHUI2VDJkAxzP9Ul6ceSJqd+e1DSUenxensz969pa3/g3oh4YjD3K4Oki4AbyT4Q8faIeHVEXBARj47A68DwafVkSytuZL+VMDUtH0z2AtUNXAbslsrnAktz9/kY2cTQenKfciD7RMmtaVv+Eyv12j2CbKzwT2TvGNYMIf5/IxvqGiiGpcDctDwhxdGd4jp4B47tfekYeoE/AF9O5SfSf7KxXrudwKQB+qlRvBvJLknycIqj79NM7cC3cvW+Ahyblk9LbXUDp+bqfBloT8v7Az8GbgN+RDYEB9mk37J0LL/pq5+2/RzoIXtnvRl4XSq/kqcnu+u1297XdwPE+JnU9l/S3zNz224E9t/B/4fh6qfnpvgeJBtu2gzsRfaG805g99xx/zb153k8fYWD04HTG7WVe559rtWvI7nXiV0abG/29aXwOT1SN19iYhRKp+MXRMRxrY4lT9JngQsj4pYW7f8csjOyH6f1lwAfiIh/bEEsqyKi8LsTw7iPw4EP7ujxld1Pkg4DTouIDw5Te98m+/jqrcPRnvlaQ6OWpLcAP4iIB1sdy85C0rsi4vyastOAb0Q2qTemSDoOuC2yT/zsaFujop/6hikj4oIBK1vTnAjMzCpuzE8Wm5lZY04EZmYV50RgZlZxTgRmZhXnRGBmVnH/H96hnORDzcFBAAAAAElFTkSuQmCC" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Sampling: 100%|###################################################| 300/300 [00:51<00:00, 5.86it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mean of max gradient\n", - "0.08909871218516183\n", - "Variance of max gradient\n", - "0.001158520193967305\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "接着对采样不同量子比特数量电路得到的各参数最大梯度的平均值和方差作图，方便比较。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 35, - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "means = np.array(means)\n", - "variances = np.array(variances)\n", - "\n", - "n = np.array(selected_qubit)\n", - "print(\"我们接着画出这个采样出来的梯度的统计结果：\")\n", - "fig = plt.figure(figsize=plt.figaspect(0.3))\n", - "\n", - "# ============= 第一张图 =============\n", - "# 统计出随机采样的梯度平均值和量子比特数量的关系\n", - "plt.subplot(1, 2, 1)\n", - "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 gradient\".format(samples))\n", - "plt.xlim([1,9])\n", - "plt.grid()\n", - "\n", - "# ============= 第二张图 =============\n", - "# 统计出随机采样的梯度的方差和量子比特数量的关系\n", - "plt.subplot(1, 2, 2)\n", - "plt.plot(n, np.log(variances), \"v-\")\n", - "plt.xlabel(r\"Qubit #\")\n", - "plt.ylabel(r\"$ \\partial \\theta_{i} \\langle 0|H |0\\rangle$ Variance\")\n", - "plt.title(\"Variance of {} sampled gradient\".format(samples))\n", - "plt.xlim([1,9])\n", - "plt.grid()\n", - "\n", - "plt.show()" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "我们接着画出这个采样出来的梯度的统计结果：\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "可以看出，随着量子比特数量的增加，多次采样获得所有参数梯度的最大值不断接近于 0，且方差也是呈下降趋势。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "为了进一步看看梯度随量子比特数量增加发生的变化，我们不妨可视化一下不同量子比特数量对的优化曲面的影响：\n", - "\n", - "![BP-fig-qubit_landscape_compare](./figures/BP-fig-qubit_landscape_compare.png \"(a)不固定 z 轴尺度时，采样出的优化曲面分别从左至右对应2、4和6量子比特的情形。（b）同样的优化曲面但是固定 z 轴尺度作为对比。\")\n", - " \n", - "\n", - "画图时 $\\theta_1$ 和 $\\theta_2$ 是前两个电路参数, 剩余参数全部固定为 $\\pi$。不然我们画不出这个高维度的流形。\n", - "结果不出所料，陡峭程度随着 $n$ 的增大越来越小了，**注意到 Z 轴尺度的极速减小**。相对于 2 量子比特的情况，6 量子比特的优化曲面已经非常扁平了。\n", - "\n", - "在理论上，只有当我们选取的网络结构还有损失函数满足一定条件时 (2-design)[[1]](https://arxiv.org/abs/1803.11173), 才会出现这种梯度随量子比特数增加而急剧消失的现象。\n", - "\n" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "### 应用 二：基于经典数据量子编码的监督学习\n", - "\n", - "监督学习是量子神经网络的重要应用之一，然而贫瘠高原现象同样制约着量子变分算法在此类问题上的表现。因此，如何设计更有效的电路和损失函数来避免贫瘠高原现象的出现，是当前量子神经网络的重要研究方向之一。实际上，已有学者证明，在生成模型 (generative traning) 的训练之中使用瑞丽熵 (Renyi divergence) 作为损失函数，可以有效避免贫瘠高原现象 [[3]](https://arxiv.org/abs/2106.09567)。 基于量桨的梯度分析模块，我们可以快速分析一个监督学习模型中梯度的相关信息，从而便于研究者尝试探索不同的量子电路和损失函数。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "这里，我们利用量桨的[量子态编码经典数据](./tutorial/machine_learning/DataEncoding_CN.ipynb)提供的数据集为例进行介绍。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### Paddle Quantum 实现\n", - "\n", - "首先，导入需要的包" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 14, - "source": [ - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle import matmul, transpose,reshape\n", - "from paddle_quantum.utils import pauli_str_to_matrix\n", - "import paddle.fluid as fluid\n", - "import paddle.fluid.layers as layers\n", - "\n", - "from paddle_quantum.dataset import Iris\n", - "from paddle_quantum.gradtool import random_sample_supervised, plot_supervised_loss_grad" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### 定义参数化量子电路\n", - "\n", - "接着，构建参数化量子电路 $U(\\theta)$ " - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 15, - "source": [ - "def U_theta(theta, n, depth):\n", - " \"\"\"\n", - " :param theta: 维数: [n, depth + 3]\n", - " :param n: 量子比特数量\n", - " :param depth: 电路深度\n", - " :return: U_theta\n", - " \"\"\"\n", - " # 初始化网络\n", - " cir = UAnsatz(n)\n", - "\n", - " # 先搭建广义的旋转层\n", - " for i in range(n):\n", - " cir.rz(theta[i][0], i)\n", - " cir.ry(theta[i][1], i)\n", - " cir.rz(theta[i][2], i)\n", - "\n", - " # 默认深度为 depth = 1\n", - " # 搭建纠缠层和 Ry旋转层\n", - " for d in range(3, depth + 3):\n", - " for i in range(n - 1):\n", - " cir.cnot([i, i + 1])\n", - " cir.cnot([n - 1, 0])\n", - " for i in range(n):\n", - " cir.ry(theta[i][d], i)\n", - " return cir" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### 定义目标函数\n", - "\n", - "这里定义要优化的目标函数，第二个参数仍然是可变参数 ``*args``。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 16, - "source": [ - "def loss_func(cir,*args):\n", - " #传入量子态和训练标签\n", - " state_in = args[0]\n", - " label = args[1]\n", - " # 将 Numpy array 转换成 tensor\n", - " label_pp = reshape(paddle.to_tensor(label),(-1,1))\n", - " \n", - " Utheta = cir.U\n", - " \n", - " # 因为 Utheta是学习到的，我们这里用行向量运算来提速而不会影响训练效果\n", - " state_out = matmul(state_in,Utheta)\n", - " \n", - " # 测量得到泡利 Z 算符的期望值 \n", - " Ob = paddle.to_tensor(pauli_str_to_matrix([[1.0, 'z0']], qubit_num))\n", - " E_Z = matmul(matmul(state_out, Ob), transpose(paddle.conj(state_out), perm=[0, 2, 1]))\n", - "\n", - " # 映射 处理成标签的估计值\n", - " state_predict = paddle.real(E_Z)[:, 0] * 0.5 + 0.5\n", - " loss = paddle.mean((state_predict - label_pp) ** 2)#均方误差\n", - " \n", - " return loss\n", - " " - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### 定义数据集\n", - "\n", - "接着导入量子编码后的 Iris 数据集。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 17, - "source": [ - "time_start = time.time()\n", - "\n", - "#超参数设置,这里不需要太多qubit，不然严重过拟合\n", - "test_rate = 0.2\n", - "qubit_num = 2\n", - "depth = 1\n", - "lr = 0.1\n", - "BATCH = 4\n", - "EPOCH = 4\n", - "SAMPLE = 300\n", - "# 验证数据集\n", - "iris = Iris(encoding='amplitude_encoding', num_qubits=qubit_num, test_rate=test_rate, classes=[0,1], return_state=True)\n", - "\n", - "# 获取数据集的输入和标签\n", - "train_x, train_y = iris.train_x, iris.train_y #这里的 train_x, train_y，test_x, test_y 都是 paddle.tensor\n", - "test_x, test_y = iris.test_x, iris.test_y\n", - "testing_data_num = len(test_y)\n", - "training_data_num = len(train_y)\n", - "\n", - "\n", - "# 为量子电路创建可训练的参数\n", - "theta = layers.create_parameter(shape=[qubit_num,depth+3], default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype='float64',is_bias=False)\n", - "# 创建电路\n", - "circuit = U_theta(theta, qubit_num, depth)\n", - "\n", - "print(circuit)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "--Rz(3.338)----Ry(2.554)----Rz(1.318)----*----x----Ry(4.679)--\n", - " | | \n", - "--Rz(0.246)----Ry(3.961)----Rz(5.514)----x----*----Ry(3.248)--\n", - " \n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "我们先看看在 EPOCH=4，BATCH=4 的情况下，训练过程中的损失函数值及梯度的变化情况" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 18, - "source": [ - "loss,grad = plot_supervised_loss_grad(circuit, loss_func, N=qubit_num, EPOCH = EPOCH, LR = lr,BATCH = BATCH, TRAIN_X=train_x, TRAIN_Y=train_y)" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA5EklEQVR4nO2deXhU5dn/vzchEGQRCMiSKIuigCA7IlFsBZdWBXF5lWqLttVq1dbqz9atan21ttLX2latWqvWqqBVa6lQUagKBkHCpixSA6IERHbZlyT37497ns7JyZktM5OZTL6f68p15qxzZyY533Mvz/2IqoIQQgjx0yTTBhBCCMlOKBCEEEICoUAQQggJhAJBCCEkEAoEIYSQQJpm2oBU0aFDB+3evXumzSCEkAbFwoULt6hqx6B9OSMQ3bt3R1lZWabNIISQBoWIfBZpH0NMhBBCAqFAEEIICYQCQQghJJCcyUEQQkgqOHToECoqKrB///5Mm5JSCgoKUFxcjPz8/LjPoUAQQoiHiooKtG7dGt27d4eIZNqclKCq2Lp1KyoqKtCjR4+4z2OIiRBCPOzfvx+FhYU5Iw4AICIoLCxM2CuiQBBCiI9cEgdHXX4nCkSyLFsGzJmTaSsIISTlMAeRLHfeCaxaBSxfnmlLCCE5QqtWrbB79+5Mm0EPIml27AB27sy0FYQQknIoEMmycyeQBUpPCMk9VBU333wz+vXrh/79++PFF18EAHzxxRcYNWoUBg4ciH79+mHOnDmoqqrC5Zdf/t9jf/vb3yb9/gwxJcuuXSYQqkAOJrYIadTccAOwZElqrzlwIPDQQ3Ed+uqrr2LJkiVYunQptmzZgmHDhmHUqFF44YUXcOaZZ+L2229HVVUV9u7diyVLlmD9+vVYtmwZAGDHjh1Jm5pWD0JEzhKRVSJSLiK3BOy/WkQ+EpElIvKeiPT17Ls1dN4qETkznXYmxc6dQGUlcPBgpi0hhOQY7733HiZMmIC8vDx06tQJp556KhYsWIBhw4bh6aefxt13342PPvoIrVu3Rs+ePbFmzRpcf/31eOONN9CmTZuk3z9tHoSI5AF4BMDpACoALBCRqaq6wnPYC6r6WOj4sQAeBHBWSCguAXA8gK4AZorIsapalS5764zLP+zeDTRvnllbCCGpJc4n/fpm1KhRmD17NqZNm4bLL78cN954I77zne9g6dKlmDFjBh577DG89NJLeOqpp5J6n3R6EMMBlKvqGlU9CGAKgHHeA1TVm91tCUBDr8cBmKKqB1T1UwDloetlF1VVwN699pp5CEJIijnllFPw4osvoqqqCps3b8bs2bMxfPhwfPbZZ+jUqROuvPJKfP/738eiRYuwZcsWVFdX44ILLsC9996LRYsWJf3+6cxBFAFY51mvAHCi/yARuRbAjQCaATjNc+4837lFAedeBeAqADjqqKNSYnRC7NoVfk2BIISkmPHjx+P999/HgAEDICJ44IEH0LlzZ/zlL3/BpEmTkJ+fj1atWuHZZ5/F+vXrccUVV6C6uhoAcP/99yf9/hlPUqvqIwAeEZFvAbgDwMQEzn0CwBMAMHToUI1xeOqhQBBC0oAbAyEimDRpEiZNmlRj/8SJEzFxYu1bZSq8Bi/pDDGtB3CkZ704tC0SUwCcV8dzM4N3/AMFghCSY6RTIBYA6CUiPUSkGSzpPNV7gIj08qyeDeCT0OupAC4RkeYi0gNALwAfpNHWukGBIITkMGkLMalqpYhcB2AGgDwAT6nqchG5B0CZqk4FcJ2IjAFwCMB2hMJLoeNeArACQCWAa7OygskbYvK+JoQ0aFQ15xr2qSYehU9rDkJVpwOY7tt2p+f1j6Ocex+A+9JnXQqgB0FIzlFQUICtW7fmVMtvNx9EQUFBQudlPEndoGGSmpCco7i4GBUVFdi8eXOmTUkpbka5RKBAJAM9CEJyjvz8/IRmXctl2KwvGZxANGtGgSCE5Bz0IJJh1y5rr9G2LQWCEJJz0INIhp07gTZtgFatKBCEkJyDApEMu3ZRIAghOQtDTMmwcyfQujXQsiUFghCSc9CDSAZ6EISQHIYCkQzOg6BAEEJyEApEMjBJTQjJYZiDSIZdu8yDyM+nQBBCcg4KRDI4DyIvjwJBCMk5KBB15dAhYP9+EwgR4MAB25afn2nLCCEkJTAHUVdcoz6XpAaAPXsyZw8hhKQYCkRdcX2YXJIaYJiJEJJTMMRUV7weRFVoLiMKBCEkh6BA1BWvB3HokL2mQBBCcggKRF1xHkSbNpagBigQhJCcggJRV5wH4cZBABQIQkhOQYGoK14PomnoY6RAEEJyCFYx+dmxA5gwAdiyJfpxXg+CVUyEkByEAuGntBSYMgV4773ox1EgCCE5DgXCT0WFLbdujX7crl1AixYWXqJAEEJyEAqEn3XrbBlLIFwfJsBEoqAgnJcghJAcgALhJxEPwgkEwJbfhJCcgwLhJ16BcJMFOSgQhJAcgwLhx4WY4qliogdBCMlhKBBeVBMLMdGDIITkMBQILzt2AHv32utEktQABYIQknNQILy48FL79kxSE0IaPRQILy68NGAAsG2bhZwiwSQ1ISTHoUB48QpEZWV4tLSfAweAgwfpQRBCchoKhJd164AmTYB+/Ww9UpjJO1mQgwJBCMkxKBBeKiqArl2BI46w9UgC4Z0syNGqlSW43exyhBDSwKFAeKmoAIqLgcJCW0/UgwDCVVCEENLASatAiMhZIrJKRMpF5JaA/TeKyAoR+VBEZolIN8++KhFZEvqZmk47/8u6dfEJRCQPAmCYiRCSM6RNIEQkD8AjAL4BoC+ACSLS13fYYgBDVfUEAC8DeMCzb5+qDgz9jE2Xnf/FDZI78siwQEQaTe2dLMhBgSCE5Bjp9CCGAyhX1TWqehDAFADjvAeo6tuq6mIy8wAUp9Ge6Hz1FbBnj3kQ7doBIrE9iKAQEwWCEJIjpFMgigCs86xXhLZF4nsA/uVZLxCRMhGZJyLnBZ0gIleFjinbvHlzcta6QXLFxUBenokEQ0yEkEZMVsxJLSKXARgK4FTP5m6qul5EegL4t4h8pKqrveep6hMAngCAoUOHRhnVFgduDMSRR9qysLBuSWoKBCEkR0inB7EewJGe9eLQthqIyBgAtwMYq6oH3HZVXR9argHwDoBBabQ1LBDFoShXNIFwHoQTBe9rCgQhJEdIp0AsANBLRHqISDMAlwCoUY0kIoMAPA4Th02e7e1EpHnodQcAJQBWpNHW8CC5Ll1sPZYH0aqVhaIcFAhCSI6RNoFQ1UoA1wGYAWAlgJdUdbmI3CMirippEoBWAP7mK2ftA6BMRJYCeBvAr1Q1vQJRUWHi0DQUdYvlQXjDSwAFghCSc6Q1B6Gq0wFM92270/N6TITz5gLon07bauEGyTlieRDeBDVAgSCE5BwcSe1wg+QchYVW9rp/f+1jgzyI5s2B/HwKBCEkZ6BAADZILkgggGAvwj9ZkIMN+wghOQQFAggPkjvSU3TVoYMtgwTCP92ogwJBCMkhKBBA7RJXoO4ehBsjQQghDRwKBJC4QAQlqQF6EISQnIICAYTbbHhDTJEEQjU4SQ1QIAghOQUFAjAPQiQ8SA6ILBD799t0pPQgCCE5DgUCMIHo3NnKVB0FBcBhh9UWiKA+TA4KBCEkh6BAABZi8oaXHEGD5YI6uTooEISQHIICAdQeRe0IEoigyYIcFAhCSA5BgQAiC0SHDpE9iGghJk2u8zghhGQDFIivvjKvIFKIyT/taKwQkyqwb1/q7SSEkHqGAlFdDdxyC1BSUntftBBTJA8CYJiJEJITZMWMchmlXTvg/vuD9xUWAtu3A1VV4bkfYnkQgAnEEUek3lZCCKlH6EFEo7DQQkY7doS3xUpSA/QgCCE5AQUiGkGD5bZvt0F1LVvWPp4CQQjJISgQ0QgSiDlzgBNOMJHwQ4EghOQQFIho+AViyxZg7lxg7Njg4ykQhJAcggIRDb9ATJ9uVU8UCEJII4ACEQ3/pEH//Kc19Bs8OPh4CgQhJIegQESjTRugaVMLLR04ALzxBnDuuUCTCB9bXQTi4MHk7SSEkDRAgYiGCNC+vXkQ775rN/5zz418fIsWJh7xCsTixSYqH3+cGnsJISSFUCBi4UZTT51qAjB6dORjRRJr2DdrFnDoELBiRWpsJYSQFMKR1LFwArFgAXD66SYS0UhEIMrKbPnll8nZSAghaYAeRCwKC00cPv88cvWSl1atzCPYsCH2sU4gNm5MzkZCCEkDFIhYFBYCe/bY67PPjn38mDFAaal1hz3nHODVV62Xk5/t24HVq+01PQhCSBZCgYiFGwtx4ok2LWksHnkE+M9/rEPs4sXABRcAv/xl7eMWLgy/pkAQQrIQCkQs3FiIeMJLjl69gPvus7BUSQnwyiu1j3HhpUGD6kcgVq4Eune36VUJISQOKBCxcDPNjRuX+Ll5eRaWWrq0dp6hrAw4+migd+/6EYglS4DPPrNyXUIIiQMKRCwuushCRccfX7fzzzjDljNn1txeVgYMHQp06lQ/ArFtmy2XLEn/exFCcgIKRCzy84GBA+t+/qBBFqZ6883wti1b7GneCcSePeFEeLpwArF0aXrfhxCSM1Ag0k2TJjZ+4s03rdEfEE5QO4EA0u9FeD0I1fS+FyEkJ6BA1AdnnGEC8NFHtu4S1IMH179AbNkS3xgNQkijhwJRH5x+ui1dmKmsDDj2WGsGWJ8C4ZoMMg9BCImDuARCRFqKSJPQ62NFZKyI5Mdx3lkiskpEykXkloD9N4rIChH5UERmiUg3z76JIvJJ6GdiIr9U1lFUBPTrV1Mghg611/UpEEOG2GsKBCEkDuL1IGYDKBCRIgBvAvg2gGeinSAieQAeAfANAH0BTBCRvr7DFgMYqqonAHgZwAOhc9sDuAvAiQCGA7hLRNrFaWt2csYZNl3pp58CFRVhgTjiCFvWh0B0726ltRQIQkgcxCsQoqp7AZwP4FFVvQhArLrP4QDKVXWNqh4EMAVAjcEEqvp26LoAMA9AaNABzgTwlqpuU9XtAN4CcFactmYnZ5xhc0o8+KCtO4Fo1gxo165+BKJ9e6vIYiUTISQO4hYIETkJwKUApoW25cU4pwiAd9huRWhbJL4H4F91PDf7GTUKaN4cePJJaws+aFB4X7rHQqiGBWLAAKC8HNi1K33vRwjJCeIViBsA3Arg76q6XER6Ang7VUaIyGUAhgKYlOB5V4lImYiUbd68OVXmpIcWLUwk9u8H+vQJzz4HpF8gdu8GKivDHoRquKKKEEIiEJdAqOq7qjpWVX8dSlZvUdUfxThtPYAjPevFoW01EJExAG4HMFZVDyRyrqo+oapDVXVox44d4/lVMosbVe3CS45OndLb8tuVuDqBAJiHIITEJN4qphdEpI2ItASwDMAKEbk5xmkLAPQSkR4i0gzAJQCm+q47CMDjMHHY5Nk1A8AZItIulJw+I7StYXNWKI1y4ok1t6fbg9i+3Zbt2llvqfbtKRCEkJjEG2Lqq6o7AZwHyxP0gFUyRURVKwFcB7uxrwTwUig8dY+IuNaokwC0AvA3EVkiIlND524D8L8wkVkA4J7QtoZNv37AO+8A3/1uze2dO1tOYN++9Lyv14MQMS+CAkEIiUG8U47mh8Y9nAfgYVU9JCIx+zWo6nQA033b7vS8HhPl3KcAPBWnfQ2HU0+tvc07FqJ799S/p1cgABOIRx+1vERTzjpLCAkmXg/icQBrAbQEMDs0oG1nuoxqdKR7sJxfIAYMsGT5J5+k5/0IITlBvEnq36tqkap+U43PAHw9zbY1HupbIJioJoTEQbxJ6sNF5EFXUioi/wfzJkgqiCQQa9cC06fXOjwi8+aFE9Jetm0DCgqs1BawSYqaNaNAEEKiEm+I6SkAuwD8T+hnJ4Cn02VUoyNSu4277wbGjwcOHYp9jQULgJEjgYceqr3PDZJzNGtmEyBRIAghUYhXII5W1btCbTPWqOovAPRMp2GNioIC4PDDawvE/PnAwYPAmjXRz6+qAq65xgbArV1be79fIAC23CCExCRegdgnIie7FREpAZCmmsxGin8sxFdfAR9/bK9Xrox+7hNP2CRELVoA62uNJ4wsEF9+aY0DCSEkgHhrHK8G8KyIHB5a3w6gYbfgzjb8AuEmFQLCQhHEpk3AbbcBp51mA+GWL699zLZt1sXVy0kn2fL9923ebUII8RFvFdNSVR0A4AQAJ6jqIACnpdWyxoZfIObPt2XbttE9iJ/9zOazfuQRm3ciEQ+iRQtg7txkLSeE5CgJzSinqjtDI6oB4MY02NN48QvEBx/YrHNDhkQWiNJS4JlngJtussqkoiIbkb3TN0QlSCDy84FhwygQhJCIJDPlqKTMCmICsWOHzRmhah7E8OHW+fXjj22bn5tvBo48ErjjDlsvCnVE93oR+/bZj18gAKt6WrQofS0+CCENmmQEImarDZIAbizEpk2WON640Zr69eljXsGGDTWP373bROSKK4CWoSEpQQLhxkVEEojKypr5DkIICRFVIERkl4jsDPjZBaBrPdnYOHACsXGjhZcA8yB697bX/kR1WRlQXQ2MGBHeVhyakM8rEP5R1F5cojrdYaY9ezjmgpAGSFSBUNXWqtom4Ke1qrLLWyrxjqb+4AMbzDZggHkQQO08xLx5thw+PLwtyIOIJhAdOlieI90C8dhj5g3t3Rv7WEJI1pBMiImkEq9AzJ9vVUbNm1sr8DZtagvE/PlAr15AYWF4W4sWVuoar0AAFmaaOzc4x5EqPv/cBvxt2ZK+9yCEpBwKRLbgBGLDBgsfOc9AJJyodqiaB+GfeAioXeoaj0Bs2WLzVKcLJwwUCEIaFBSIbOGww2ye6nfesZi99+bfp09ND2LdOstVePMPjqKimqOj4xEIIL1hJjdfeLbPG04IqQEFIpvo3BmYPdtee3MLvXsDX3xh7TeAcP4hyIMoLq7tQTRtauITRJ8+1gcqnQJBD4KQBgkFIpvo1MnKTtu2tfyCwyWqXZhp/nxr8HfCCbWvUVRkeQzXAdYNkpMIw1aaNLFqpvrwICgQhDQoKBDZhMtDDB9e84bur2SaNw8YPNgqnfwUFVmOYuNGWw8aRe1n5Ejr4bRjR1LmB6JKgSCkgUKByCa8AuGlRw8Tg48/tmqgRYuC8w9A7VLXeAXCjd5ONXv22OhwgDkIQhoYFIhswgmEP7fQtKmFnFauBD780OaTDso/AGGBcInqeARi+HALNaUjzOQVBXoQhDQoKBDZxPHHWzI5yDtwpa7uKT+SB+EfTR2PQLRubfkMCgQhxAMFIpu44AKrVurQofa+3r2B1autyqlzZ2vSF0RhoQ2wS0QgAPNIyspSP2DOiULXrhQIQhoYFIhsQiR6OWpVFTB1qnkPkaqSROxmvH69VTLt2hWfQBx3nCWp3biJVOE8iD59mIMgpIFBgWgouEqmaPkHhxtN7Tq5tmsX+/rHHGPLVI+odl5Dnz7A1q3WYJAQ0iCgQDQUjj02/DpS/sHhBCLWKGov6RKIzZttcqKePc0DcoP9CCFZDwWiodCyJdCtm1UbDR0a/VjXbmPrVluPRyB69LDwVDoEomNH+3HrhJAGAQWiITF4sE1BGilP4SgutlDU6tW2Ho9AFBRY4tudEw1VYMoUS6jHYssWS7q7xDsT1YQ0GCgQDYknnwRefz32cW4sxEcf2TIegQCAo4+Oz4P461+BCROAP/0p9rF+D4ICQUiDgQLRkGjfHjjiiNjH1VUgjjkmtkB8+ilw3XX22tsUMBL0IAhpsFAgchGvQIhYt9Z4OOYYe+KPlEiurAS+/W27ZlFRuN9TNJwH4QSCOQhCGgwUiFyka2i68A0brDNsXl5857lKpkh5iF//GigtBR59FOjXL3YO4tAhG1vRsaMl2Vu0CPYgHnoIeOSR+GwkhNQbFIhcpFmzcCgq3vASEL3UdcEC4O67gUsuAb71LaBLl9gC4aqonPfQoUOwQPzxj8Af/hC/nYSQeqFppg0gaaKoCNi0KTGBOPpoWwZ5ED/4gYnCo49aiKlzZwsxVVdb6W0QLpzkEtRBAlFdDaxda+Gr/futmooQkhXQg8hVXB4iEYFo2dJu/H4PYuNGYPFi4Prrw6Oyu3Sxm7rzEoJwAuH1IPw5iA0brIV5dXXNebcJIRknrQIhImeJyCoRKReRWwL2jxKRRSJSKSIX+vZViciS0M/UdNqZk9RFIIDgSqb33rPlKaeEt3XpYstoYSbnLTgPomPH2h7EmjXh167qihCSFaRNIEQkD8AjAL4BoC+ACSLS13fY5wAuB/BCwCX2qerA0M/YdNmZs6RSIObMsQTz4MHhbfEIRDwhJq9ALFuWmK2EkLSSTg9iOIByVV2jqgcBTAEwznuAqq5V1Q8BsINbqnHzQtRFIDZsAPbuDW977z3r/+Sd4tQJRLRSVycGzoYOHayE1s2XDZhANGli7cwpEIRkFekUiCIA6zzrFaFt8VIgImUiMk9Ezgs6QESuCh1Ttpn19TVJxoMAwk/2O3cCS5bUDC8B8XsQ7dpZsz4geLDcmjXW4mPwYIaYCMkysjlJ3U1VhwL4FoCHRORo/wGq+oSqDlXVoR1dGIMY3bvbsnPnxM5zlUwuzPT++5ZA9gvEYYcBbdrEFgjv9xLUbmPNGuv02r8/sG4du70SkkWkUyDWA/BOe1Yc2hYXqro+tFwD4B0Ag1JpXM5z7LHAzJnA+ecndp5fIObMsYF2QS3GO3eOnaT2zo4XyYPo2dMG3gHA8uWJ2UsISRvpFIgFAHqJSA8RaQbgEgBxVSOJSDsRaR563QFACYAVabM0Vxk9umbeIB7atbNpS70CMXhwcAfZWIPl/B6Ev93G3r3Al1/WFAjmIQjJGtImEKpaCeA6ADMArATwkqouF5F7RGQsAIjIMBGpAHARgMdFxD0+9gFQJiJLAbwN4FeqSoGoL1wl04EDwPz5wMknBx8XSyBieRCffmrLnj2Bo44yEWIegpCsIa0jqVV1OoDpvm13el4vgIWe/OfNBdA/nbaRKBxzjFUulZWZSPjzDw4nEKq158hWNSHwehCFhbZ0AuES4T16WCVTv370IAjJIrI5SU0yxTHHWMJ41ixbj+ZB7N0L7N5de58rZ/UKRH6+NQ/0C0TPnrbs1888CNXItlVUAMcfz1HXhNQDFAhSm6OPtsqlv/7VxidEqhCLVurqRMAbYnLrLgexZo2Fldwx/fpZ644vv4xs2xtvACtWAO++G//vkyrefx8oKQH27Kn/9yYkA1AgSG28XV0jhZeAcAltkED4R1E7vO02XAWTC0/Fk6guLbXlJ59EPiZdPPkkMHcu8OGH9f/ehGQACgSpjRMIILpARPMg/I36HN52G59+Gg4vATYWAshOgaiuBqaH0mkMb5FGAgWC1KZDBxsEB9RdIPyN+rzX3rLF8gzOg3AccYQdH0kgNm8OC0N9C8TixeG2IhQI0kigQJDaiJgXUVwMdOsW+bh27YDmzRMLMbkcxMaNwL59NQUCCCeqg5g715YjR9qcFVVV8f0+qWDaNPtcunalQJBGAwWCBHPHHcCkSbXLV724iYMieRAFBdaSw0vHjlY660QgSCCWL7eQjp/SUhv4d8klNodERUViv1MyTJsGDB8OnHQSBYI0GigQJJjx4+1GHIsuXYI7urpR1H6BcTmJDz6wZY8eNff3729VQp99VvuapaXAkCHhXEV9hZk2bbIpV88+26q6Vq82gSIkx6FAkOSINJra32bD4RcI11TQ4SqZ/GGm/ftt4F5JSTiJXl8C8a9/Wc7ECURVVfC0rITkGBQIkhzRQkz+CiagpkAUFdWeg/r4423pF4iFC+2pvaTE8gAtWtSfQEybZkI4aJAJBMAwE2kUUCBIcnTpAmzbZnkFL5E8CLfNNenz06aNeRGTJ9dMQnsT1E2amBdRHwJx6BAwYwbwzW9auOy442w7BYI0AigQJDkizSwXy4MAggUCAH7+c0tUT54c3lZaaqJwxBG23qtX/QhEaalNmnT22bbeurV5PhQI0gigQJDkCBoLceAAsGtXsAdx+OFA01CPyEgCceGFwMCBwF13WVhJ1TyIkpLwMb162TiKysqU/BoRmTbNekiNGRPe1rs3BYI0CigQJDmCBCLSGAjAwjTOi4gkEE2aAPfdZwLw1FPmKWzeXFsgDh0CPv+8bnarWqJ56tSaExj5mTYNGDXKPAeHE4hoTQUJyQEoECQ5gkJMkRr1OWIJBAB84xvWRfaee2xmPKC2QACJh5mefRY49VTrKnvMMcC4ccC99wYfu3YtsHJlOLzk6N3bwk5B5b2E5BAUCJIcbqxDvB4EEJ9AiAC//KVd9/bbbdS2qyAC6lbqWl0N3HijeR2XXgo88YRNzfqf/wQfv3ixLf3tzlnJRBoJFAiSHE2bWuLYKxAzZliYKJIAdOhgZaqdOkW/9imnAGedBezYYSOYm3j+XLt0AVq2rC0QL78MnH56cBuOxYutnfi99wKPPgpceaUNunMz2/lx81V4mxcCFAjSaKBAkOTxDpb78ku7+V56qVX7BHHhhcC110Zv4+G47z5bnnpqze2uX5SbO9vxwAMWknr//drXevNNW3oTzj17mkAEtfZYs8ZCUe3a1dxeVGTiRIGIza5dwMMPB3++JOuhQJDk8QrEpElWxXTHHZGPv/hiOy4eBg8GliwBrr++9j5/qeuqVdYSAwD+8Y/ax7/1FjBgQE3PpUcPszdosN/q1TZ5kh8R8yJWrYrvd2jMPP+8fXfvvZdpS0gdoECQ5HECsWlT2Hs49tjUXX/AAAtJ+enVy57+Xanr889bGGrQIOC112pWGe3ZYzepM86oeQ0XBgsKM/nbkXthqWt8lJXZ0gk3aVBQIEjydOlioaVf/Sq295BKevUycVi71sTgueeA0aMtt1BebhVIjnfftbLY00+veQ0nAC7f4KiqsutGE4jPPrM5udNBVRWwYUN6rl2fOIFwvbdIbNautfxbkFdbz1AgSPJ07mwx5j/8IfXeQzS8pa5z55oXcNllwNixtt0bZnrrLev75K9IOuooCxn5BaKiwgQlKMQEhBPVkSqgkuW550ycNm1K/lpVVcD991tLlPpk377w5E/0IOJn6lTzdqdNy7QlFAiSAtxYiOrq+vMegJoC8dxzFoYaP96SyMOG1RSIN9+0pzJ/qKp5c5sYyR9icoIRzYMA0hdmWrLEvLF585K/1vvvA7fdZiG4+mTpUhOnkSPt8402IJGEmT/fllmQt6FAkORxAlGf3gNg5bWtWlnfphdfNHFwI57HjbN/tC++ANavB1asqJ1/cPTsWduDcO28I3kQxxxj+Y50CYRLvrubRTK48Rwffpj8tRLBhZeuvrrmOomOeyiYMyezdoACQVLB4MHANdeES1LrCxHzIl54Adi+3cJLjnHjbPnPf1p4Caidf3D06FFbINassTEexcXB5xQU2FwW6RIIV74bKXY/fTrw0kvxXcsJxNKlyduVCGVlJuLnnWffFcNMsdm82f72iottmeE8FAWCJE9BgVUvHXlk/b93r17A7t12I/IKwPHHm2fwj3+YQHTqFJ6Jzk/PnvaPuH9/eNvq1TYft2ssGES6KpmqqsKC9cEHwWMIbrrJnswPHYp9PScQy5bV7zzeZWXA0KHm1fXuTYGIB/dA8OMf27K0NHO2gAJBGjouDzFhQs2buYh5ETNn2sjuMWNqjsT24vIMa9eGt61ZEzm85HBjIVJ90123zm78JSXW88mfCK+oMGHavj12GOLAAROGoiJLGvsHFqaL3butimzoUFsfNswEgg0OozNvnv2dfv/7Np97hsNMFAjSsDnhBFt+5zu1940bZ+3Ct26NnH8AwvNie8NM0cZAOPr1M6/DH55KFncTv/RSW/rzELNm2VIE+Pvfo19r+XIrBXafT32FmZYsMc/HKxAbN1o+iERm/nzzdNu2tfYyGU5UUyBIw+aCC+wmOHhw7X0lJUD79vba217Dj3+w3I4dVhIay4OINH+2Y/nyurUjdwnqs8+28Iw/DzFzpjVCPPfc2gMC/bjw0qWXAnl59ScQCxfacsgQWw4bZsuGEmbatQsYMaJ+n+Crq+27PvFEWz/5ZPu+du6sPxt8UCBIwyYvD+jbN3hf06bAt79t8zl07Rr5Gp06Wfmr8wRilbg6+va1p3hX6+9n3Djg8sujXyOI8nKzp7jYbqxeD0LVBGL0aOD88y3c5G7GQSxebCLTp4+FxOpLIMrK7DN3n/uAAfZ9NJQBc2+/bZ/7lCn1956rVgFffWXCBJhAVFcH9xWrJygQJLd56CEbRR0NkZqVTG4Zy4No2dJEJEggtm61RPfs2YkPUCsvt/du0gQYPtxu6i6BvmKFhWrGjAHOOccEMlqYafFim52vSRO7SddXqatLUDsKCiwcmG4PQtU+rwceAE47zT6/f/878eu4OUhmz06tfdFwDwLOgxgxwr7fDOYhKBCEAOGurkB4DITLTUSjf//gENOiRbasqgL+9a/EbCkvD7cYP/FEyyG4UJG7cY0ZAxQWmnf02mvB16mqspvloEG2PmCAJcD9grVmjd1QU9VxdedOexr2CgRg3lBZWfo6uy5ebMn4gQOBn/3MBuZt3Wre1sSJiQ3Uc3meZcuCz1u0yDzE3btTYjoAE4g2bcKDMFu1su8ug3kICgQhQHiwnKotO3Swf9ZY9OtnOQNviSwQDvu0b29jMeKlutoEygnE8OG2dKGZmTNtX7dutj5+vHkVQS0/ysutSaFXIIDaXsR999kN9ckn47czGosX2+cYJBBffZW+Sqq//916gj31lCXDP/zQbvC33WZjZXr3tvlCYrFhg32mbixN0A36scesJcZzz6XO/vnz7TPyVtudcoptP3gwde+TABQIQgDzFnbtCoeGYoWXHP3725O6fzzEwoUmOuefbx5EvP/g69dbaaor3+3a1XIR8+db6es779RMuLubWJAX4bwYv0B48xAHDgCvvGKvf/Yzu8Emixsx7RLUjngS1W+/XfcnZlcBdMUV4dxHixYmgIsX2/dx6aWx27Q77+GWWyw05g8zVVcDr79urx9+ODWlu3v3mqC5/IPj5JPt4SNanimNY1soEIQANSuZ4ilxdbhKJn8eYuFCu0Gee66FXOKNZbsKJu8sdsOHmwfxwQcW0vAKxFFH2fsE5SEWLwaaNQsn8Tt1suonrwfxxhv2VP/b35q3cdNNNa+xc6fNDz56dPyNA8vKzK4jjqi5vW9fu2FHE4irrwauuiq+9/HirwDy06+fPfG3aAH88IfRb+qzZln4bvhwKzX157AWLrQWLqNHW6VaUI5r0SIT7XjDaQsX2o3eb7+bhz2aaF5ySfQy7iRIq0CIyFkiskpEykXkloD9o0RkkYhUisiFvn0TReST0M/EdNpJyH8FYdUqK02N14Po1QvIz6+Zh9i2zYRmyBC7mRcU2M0pHlz4xSsQJ55oXs2UKZZQP+20muecd54NsPK3ZVi82G6M+fm2LmJehNeDmDzZbobXXmtPzM8/H85zbNli7zVzpnXLHTYsviS3P0HtaNrUypEjCYQbFLhypeVKEuGTT6w8OZJAANZ1+Fe/sqR1pMaF3iqxJk0sx7NkiYmo45//tH3PPGMhxIcfrnmNzZttqtzx401knEcSDX+C2tGpk/U3i5aoLisLl3OnmLQJhIjkAXgEwDcA9AUwQUT89YifA7gcwAu+c9sDuAvAiQCGA7hLRHzzPhKSQlxC+t137UkuXg8iP99KSL0ehAvtDB5so2FPP90EIp5QRHl5uMOsw+UhnnzSbrz+KVDHj7elV4RUTSD840MGDDBbKyvNG5k6FbjoIvs9brvNhOmHPzRBOuUUe0J+7TV7gnWdWSMlxQG7SZeXBwsEYCKzaFFwixCXiAfC08PGS6QbrJ+rrrJjbrzRRqL7WbXKwnyjR9v6qFHmBcydGz5m6lR7si8uthHPr71WU9Cuv94+h1//2sRizBgTDP/86V7mzbPeXn6vC7AwU2lpsDeyZYt1APCH81JEOj2I4QDKVXWNqh4EMAXAOO8BqrpWVT8E4P/NzwTwlqpuU9XtAN4CcFYabSWNnZYt7Z/TNfaLVyAAe0qPJBCAzU/x2WeRB9R5KS+39/YmKocOtfX9+4MH/PXtaz+//KXdkAAbH7F1azj/4BgwwPIO//mP3ej27bM2JYB5On/8o93Ijj/ebpRvvGED9oYMsSf/vn1NkJ55Jth+V7HlQiN+TjrJfo+g8Rguzt62rbVHSYT588M9n6LRpIklmLdtA269tfZ+97TvPucRI0w8XRjp88/N9nPPtfVrrrEb9+OP2/orr1hn4bvuAn76UxOc3/zGBMDbTDLIfn/+wXHyyWZvUN8v95lFEuQkSadAFAHw+okVoW0pO1dErhKRMhEp2+z+MQipKz172o0ciD/EBFhi9PPPw2GIhQvtabCw0NbPOceW8YSZvCWujlatwnmEIIEQAZ591nIEEybULIsNEgjAQkWTJ9tTsHcSpTFjbHBfmzaWMD711PC+Ll3sRjliBHDnncHJ0aeeMm/MPzGTY+RIWwY1oVu40MpUx4+3ME8iydd588w7ycuLfezAgdYM7/HHaw9CmznT7HcPCIcdZtd1OSSXnHaTUnXvbmLxxBMmqD/8oT0Y/PSntr+gwPI6994bziP5KS83QY/k/TixjfSZAcGdBFJAg05Sq+oTqjpUVYd27Ngx0+aQho67KTRvHn3ktR+XqF6+3JYuQe3o3Nn++WOVu6oGCwRgN9bDDgvfYP0MGWJPxrNmWaho0SITDterytG7tz0Rv/22PaVffHHtJoZ//rOFTILCFi1aADffbPv9M56tXWvvf/nlkRsjFhdbAjvSzW7IEODMMy38E+/8Efv2meDFCi95+cUvrPvwxReHx79UVtrn4sJLjlGjzHvau9dEvlcv4Ljjwvuvu848t5NPNruffjqc93FMnGgejj9fAVgoqlkzC/UF0auXFRcEfWZlZbb/8MPj/90TIJ0CsR6At/9zcWhbus8lpG64PESPHpFvcEG4NuIffWSx59Wra99cx461p8do8wxv2GA3O1fi6uXeey0PUFAQ+fzLL7eQx6RJlq847jgLnXlp1sxyJk8/bXkAF17y0qSJiWQkxo41AX300Zrb//IXW06MUVNSUmI3O29OZtcuC3u5xL5I7TBTZaUl0r1zjQMmhpWViQlEq1Ym2Hv2AF//unmOixaZF+j30kaNsuu/9ZYJiPMeHKNH22e9di3w85/XFmXAxGHiRAs/eavB1q61cN2VV5r3FISIPRhEEog0hZcAAKqalh8ATQGsAdADQDMASwEcH+HYZwBc6FlvD+BTAO1CP58CaB/t/YYMGaKEJMWf/6wKqH7zm4mdV12t2qqV6nXXqc6aZdeYMaPmMR99ZNsnTFCdPVv10KHa13nnHTvmzTfr/jscOKB60knh9wri29+2/b16me114e677RqffGLrVVWq3bqpnn567HMfftjO/fTT8LZ337Vtr79u68OGqY4cWfO8xx+3Y847r+b2//s/2/7FF4n/HgsXqrZtq9qjh+o119h1Nm2qecxXX6k2aaJ6wgm2/513al9n2jTViRNVDx6M/F4rV9r5990X3nbllarNmqmuWxfdzgcesHM3bgxv+/JL2/ab38T8NaMBoEwj3ccj7UjFD4BvAvgPgNUAbg9tuwfA2NDrYbD8wh4AWwEs95z7XQDloZ8rYr0XBYIkzdtv27/Eddclfu6IEaqnnhr+R96ypeb+6mq7gTRtavvbt1e97DLViorwMU8+afvWrEnil1DV9etV+/RRfe654P2/+Y29z513JvceeXmqN91k6zNn2jUnT4597uLFdqzXvgcfrHmTv+MOu/727ba+e7dq5872+YmolpeHz/2f/1E96qi6/y4LFqgefri9/8CBwccMGWL727ULFvd4GTNGtbjYrrF2rf0+P/xh7PNKS+39X301vG369MiClQAZE4j6/KFAkKRZt87+JX7/+8TPvfJK1cJC1YsvtifpSOzYofq3v5lYtGhholJVZftuuUU1Pz+5G1A8LF2qeuSRNW+ydeHCC03o9u5V/da37El8377Y51VWmsd1zTXhbZdeqtq1a3h9zhz7Ll55xdbvucfW//Y3+4x+9KPwsd26qV50UXK/y7x5JhL/+7/B+3/yE3v/Sy9N7n3+8Q+7zssvq/7gB/a7fP557PP271dt3jwsyKr2mYiYh5MEFAhC4mXGDHtaTZTf/U7/6xmcf35857iQ1m9/a+sXXqh67LGJv3em+Pe/zf6HHlItKFC99tr4zx0zRnXAgPB6796qY8eG1w8eVG3dWvWqqyyU0qqV6vjxtu+yy2x9xw4LuaQgzKKqJm5OrP24G/uLLyb3HpWVJmgnnGDicPXV8Z9bUmKeqmPcONXjjkvOHo0uEA26iomQlHPGGbUTu/HgEtXbtsU/aOmKK6wE9tZbrcb9k0+CK5iyla99zaqibr7ZxjZccUX855aUWFJ/505LUK9aVfNzy8+35O+MGVZxtG8fcP/9tu8nP7FBfn/+c/wD5OKhoCByccI551g7kwsuSO498vKsFNaNSA8aixGJkhKr9Nq3z9bTnaBGAy9zJSRrcKWuQPwCIQL86U8mSN/5jpW4BlUwZSsidrM7dMgqdxKpxS8psQFm8+ZZKwvV2p/bmWdaddEf/2gjoF1p6eDBVln0+9/bCOe8vLSNA/gvTZpYS5N4xlnE4nvfsyqq73/fSn7jpaTEPuuyMquGW7+eAkFIg6BjR+ubAyR2s+rc2W6ACxZYyWVD8iAAE7aiIuCGG0ww4mXECLvplpbWnp7UceaZtjzsMBuZ7OWGG0w8Hn3UxOmww+r6G9Q/hYVWqvvQQ4md5x1kGOkzSzFN03p1QhoT/fvb+IFEB21edJGNR5g8ueEJxOGH2yjgRGnd2m7spaU2QrtrVxNLLz162Kjq004Li69j7NjwHB6pCC/VN95eW/HSoYN5UaWl1i5FpPZI+RRDgSAkVTz4YN0nmHdPwl//emptymZKSmyQWFFR5CfhV18N3p6XB/zoR+ZJNESBqCslJeE24n36WKgqjTDEREiq6N8/cpO6WLRta6OEo41gzjVGjrSwmhtBnShXXWUNCi+8MPaxuUJJiRVCzJyZ9vASQA+CEJIpvGJal5tdixaJVQHlAu4zO3gw7QlqgB4EISRTHHVUuP9QPTwN5wTHHmu5CKBePjMKBCEkM4hYzqVbN0tUk9i4xn1Nmljb8jTDEBMhJHP87nc1p/MksfnZz6yyqy4DOhOEAkEIyRzt26dtPuWcZeTIyPOCpBiGmAghhARCgSCEEBIIBYIQQkggFAhCCCGBUCAIIYQEQoEghBASCAWCEEJIIBQIQgghgYhNSdrwEZHNAD5L4JQOALakyZxkyFa7gOy1LVvtArLXtmy1C6BtdSEZu7qpauAkJjkjEIkiImWqmv52iAmSrXYB2WtbttoFZK9t2WoXQNvqQrrsYoiJEEJIIBQIQgghgTRmgXgi0wZEIFvtArLXtmy1C8he27LVLoC21YW02NVocxCEEEKi05g9CEIIIVGgQBBCCAmk0QmEiJwlIqtEpFxEbsmwLU+JyCYRWebZ1l5E3hKRT0LLdhmw60gReVtEVojIchH5cRbZViAiH4jI0pBtvwht7yEi80Pf64si0qy+bQvZkScii0Xk9Syza62IfCQiS0SkLLQtG77PtiLysoh8LCIrReSkLLHruNBn5X52isgNWWLbT0J/+8tEZHLofyItf2eNSiBEJA/AIwC+AaAvgAki0jeDJj0D4CzftlsAzFLVXgBmhdbrm0oAN6lqXwAjAFwb+pyywbYDAE5T1QEABgI4S0RGAPg1gN+q6jEAtgP4XgZsA4AfA1jpWc8WuwDg66o60FMvnw3f5+8AvKGqvQEMgH12GbdLVVeFPquBAIYA2Avg75m2TUSKAPwIwFBV7QcgD8AlSNffmao2mh8AJwGY4Vm/FcCtGbapO4BlnvVVALqEXncBsCoLPrd/ADg922wDcBiARQBOhI0ibRr0PdejPcWwm8ZpAF4HINlgV+i91wLo4NuW0e8TwOEAPkWoWCZb7Aqw8wwApdlgG4AiAOsAtIdNGf06gDPT9XfWqDwIhD9cR0VoWzbRSVW/CL3eCKBTJo0Rke4ABgGYjyyxLRTGWQJgE4C3AKwGsENVK0OHZOp7fQjATwFUh9YLs8QuAFAAb4rIQhG5KrQt099nDwCbATwdCss9KSIts8AuP5cAmBx6nVHbVHU9gN8A+BzAFwC+ArAQafo7a2wC0aBQexzIWB2yiLQC8AqAG1R1p3dfJm1T1So1178YwHAAvTNhhxcROQfAJlVdmGlbInCyqg6GhVevFZFR3p0Z+j6bAhgM4I+qOgjAHvhCNlnwP9AMwFgAf/Pvy4RtoZzHOJi4dgXQErXD1CmjsQnEegBHetaLQ9uyiS9FpAsAhJabMmGEiOTDxOF5VX01m2xzqOoOAG/DXOq2ItI0tCsT32sJgLEishbAFFiY6XdZYBeA/z55QlU3wWLpw5H577MCQIWqzg+tvwwTjEzb5eUbABap6peh9UzbNgbAp6q6WVUPAXgV9reXlr+zxiYQCwD0CmX8m8Fcx6kZtsnPVAATQ68nwuL/9YqICIA/A1ipqg9mmW0dRaRt6HULWG5kJUwoLsyUbap6q6oWq2p32N/Vv1X10kzbBQAi0lJEWrvXsJj6MmT4+1TVjQDWichxoU2jAazItF0+JiAcXgIyb9vnAEaIyGGh/1P3maXn7yyTyZ9M/AD4JoD/wOLWt2fYlsmwOOIh2NPU92Bx61kAPgEwE0D7DNh1Msx1/hDAktDPN7PEthMALA7ZtgzAnaHtPQF8AKAcFg5onsHv9WsAXs8Wu0I2LA39LHd/91nyfQ4EUBb6Pl8D0C4b7ArZ1hLAVgCHe7Zl3DYAvwDwcejv/68Amqfr74ytNgghhATS2EJMhBBC4oQCQQghJBAKBCGEkEAoEIQQQgKhQBBCCAmEAkFIACKyO7TsLiLfSvG1b/Otz03l9QlJFRQIQqLTHUBCAuEZ0RqJGgKhqiMTtImQeoECQUh0fgXglNCcAD8JNQqcJCILRORDEfkBAIjI10RkjohMhY1shYi8FmqOt9w1yBORXwFoEbre86FtzluR0LWXheZuuNhz7Xc88yY8HxpFS0haifWkQ0hj5xYA/09VzwGA0I3+K1UdJiLNAZSKyJuhYwcD6Keqn4bWv6uq20ItQRaIyCuqeouIXKfWbNDP+bCRxQMAdAidMzu0bxCA4wFsAFAK67/zXqp/WUK80IMgJDHOAPCdULvx+bDWC71C+z7wiAMA/EhElgKYB2sS2QvRORnAZLVutV8CeBfAMM+1K1S1Gtb6pHsKfhdCokIPgpDEEADXq+qMGhtFvgZrV+1dHwPgJFXdKyLvAChI4n0PeF5Xgf+7pB6gB0FIdHYBaO1ZnwHgmlA7dIjIsaEOqX4OB7A9JA69YVO3Og65833MAXBxKM/REcAoWAM2QjICn0IIic6HAKpCoaJnYHM8dAewKJQo3gzgvIDz3gBwtYishE1TOc+z7wkAH4rIIrWW4I6/w+a2WArrpvtTVd0YEhhC6h12cyWEEBIIQ0yEEEICoUAQQggJhAJBCCEkEAoEIYSQQCgQhBBCAqFAEEIICYQCQQghJJD/D+TQ75YhpiXQAAAAAElFTkSuQmCC" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "我们可以看到在几十个 iteration 之后，损失函数的值只在一个较小的范围内波动，说明训练过程已经达到了稳定。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "接着我们再对该模型的初始参数进行随机采样 300 次，这里我们首先选择 ``max`` 模式，看看 300 次采样中每次采样中最大梯度的平均值和方差" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 19, - "source": [ - "mean, variance = random_sample_supervised(circuit,loss_func, N=qubit_num, sample_num=SAMPLE, BATCH=BATCH, TRAIN_X=train_x, TRAIN_Y=train_y, mode='max')" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Sampling: 100%|###################################################| 300/300 [00:21<00:00, 13.65it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mean of max gradient\n", - "0.19336918419398885\n", - "Variance of max gradient\n", - "0.011469917351120164\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## 总结\n", - "\n", - "可训练性问题是目前量子神经网络的研究的一个核心方向，量桨提供的梯度分析工具支持用户对模型进行可训练性的诊断，便于贫瘠高原等问题的研究。\n" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "_______\n", - "\n", - "## 参考文献\n", - "\n", - "[1] McClean, J. R., Boixo, S., Smelyanskiy, V. N., Babbush, R. & Neven, H. Barren plateaus in quantum neural network training landscapes. [Nat. Commun. 9, 4812 (2018).](https://www.nature.com/articles/s41467-018-07090-4)\n", - "\n", - "[2] Cerezo, M., Sone, A., Volkoff, T., Cincio, L. & Coles, P. J. Cost-Function-Dependent Barren Plateaus in Shallow Quantum Neural Networks. [arXiv:2001.00550 (2020).](https://arxiv.org/abs/2001.00550)\n", - "\n", - "[3] Kieferova, Maria, Ortiz Marrero Carlos, and Nathan Wiebe. \"Quantum Generative Training Using R\\'enyi Divergences.\" arXiv preprint [arXiv:2106.09567 (2021).](https://arxiv.org/abs/2106.09567)" - ], - "metadata": {} - } - ], - "metadata": { - "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": true - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - }, - "interpreter": { - "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} \ No newline at end of file diff --git a/tutorial/qnn_research/BarrenPlateaus_EN.ipynb b/tutorial/qnn_research/BarrenPlateaus_EN.ipynb deleted file mode 100644 index 36483a6..0000000 --- a/tutorial/qnn_research/BarrenPlateaus_EN.ipynb +++ /dev/null @@ -1,1272 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# Barren Plateaus\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Overview\n", - "\n", - "In the training of classical neural networks, gradient-based optimization methods encounter the problem of local minimum and saddle points. Correspondingly, the Barren plateau phenomenon could potentially block us from efficiently training quantum neural networks. This peculiar phenomenon was first discovered by McClean et al. in 2018 [[1]](https://arxiv.org/abs/1803.11173). In a few words, when we randomly initialize the parameters in random circuit structure meets a certain degree of complexity, the optimization landscape will become very flat, which makes it difficult for the optimization method based on gradient descent to find the global minimum. For most variational quantum algorithms (VQE, etc.), this phenomenon means that when the number of qubits increases, randomly choosing a circuit ansatz and randomly initializing the parameters of it may not be a good idea. This will make the optimization landscape corresponding to the loss function into a huge plateau, which makes the training of QNN much more difficult. The initial random value for the optimization process is very likely to stay inside this plateau, and the convergence time of gradient descent will be prolonged.\n", - "\n", - "![BP-fig-barren](./figures/BP-fig-barren.png)\n", - "\n", - "The figure is generated through [Gradient Descent Viz](https://github.com/lilipads/gradient_descent_viz)\n", - "\n", - "Based on the impact of gradient variation on the training of such variational quantum algorithms, we provide a gradient analysis tool module in the Paddle Quantum to assist users in diagnosing models and facilitate the study of problems such as barren plateaus.\n", - "\n", - "This tutorial mainly discusses how to demonstrate the barren plateau phenomenon with Paddle Quantum and use the gradient analysis tool to analyze the parameter gradients in user-defined quantum neural networks. Although it does not involve any algorithmic innovation, it can help readers to understand the gradient-based training for QNN.\n", - "\n", - "We first import the necessary libraries and packages:\n" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 2, - "source": [ - "# Import packages needed\n", - "import time\n", - "import numpy as np\n", - "import random\n", - "import paddle\n", - "# Import related modules from Paddle Quantum and PaddlePaddle\n", - "from paddle import matmul\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import dagger\n", - "from paddle_quantum.state import density_op\n", - "# Drawing tools\n", - "from matplotlib import pyplot as plt \n", - "# ignore waring \n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\")" - ], - "outputs": [], - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T12:20:39.463025Z", - "start_time": "2021-03-02T12:20:36.336398Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "## Random network structure\n", - "\n", - "Here we follow the original method mentioned in the paper by McClean (2018) [[1]](https://arxiv.org/abs/1803.11173) and build the following random circuit:\n", - "\n", - "![BP-fig-Barren_circuit](./figures/BP-fig-Barren_circuit.png)\n", - "\n", - "First, we rotate all the qubits around the $y$-axis of the Bloch sphere with rotation gates $R_y(\\pi/4)$.\n", - "\n", - "The remaining structure is in form of blocks, each block can be further divided into two layers:\n", - "\n", - "- The first layer is a set of random rotation gates on all the qubits, where $R_{\\ell,n} \\in \\{R_x, R_y, R_z\\}$. The subscript $\\ell$ means the gate is in the $\\ell$-th repeated block. In the figure above, $\\ell =1$. The second subscript $n$ indicates which qubit it acts on.\n", - "- The second layer is composed of CZ gates, which act on adjacent qubits.\n", - "\n", - "In Paddle Quantum, we can build this circuit with the following code:" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 3, - "source": [ - "def rand_circuit(theta, target, num_qubits):\n", - "\n", - " # We need to convert Numpy array to Tensor in PaddlePaddle\n", - " const = paddle.to_tensor(np.array([np.pi/4]))\n", - " \n", - " # Initialize the quantum circuit\n", - " cir = UAnsatz(num_qubits)\n", - " \n", - " # ============== First layer ==============\n", - " # Fixed-angle Ry rotation gates \n", - " for i in range(num_qubits):\n", - " cir.ry(const, i)\n", - "\n", - " # ============== Second layer ==============\n", - " # Target is a random array help determine rotation gates\n", - " for i in range(num_qubits):\n", - " if target[i] == 0:\n", - " cir.rz(theta[i], i)\n", - " elif target[i] == 1:\n", - " cir.ry(theta[i], i)\n", - " else:\n", - " cir.rx(theta[i], i)\n", - " \n", - " # ============== Third layer ==============\n", - " # Build adjacent CZ gates\n", - " for i in range(num_qubits - 1):\n", - " cir.cz([i, i + 1])\n", - " \n", - " return cir" - ], - "outputs": [], - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T12:20:39.972053Z", - "start_time": "2021-03-02T12:20:39.962259Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "## Loss function and optimization landscape\n", - "\n", - "After determining the circuit structure, we also need to define a loss function to determine the optimization landscape. Following the same set up with McClean (2018)[[1]](https://arxiv.org/abs/1803.11173), we take the loss function from VQE:\n", - "\n", - "$$\n", - "\\mathcal{L}(\\boldsymbol{\\theta})= \\langle0| U^{\\dagger}(\\boldsymbol{\\theta})H U(\\boldsymbol{\\theta}) |0\\rangle,\n", - "\\tag{1}\n", - "$$\n", - "\n", - "The unitary matrix $U(\\boldsymbol{\\theta})$ is the quantum neural network with the random structure that we build from the last section. For the Hamiltonian $H$, we also take the simplest form $H = |00\\cdots 0\\rangle\\langle00\\cdots 0|$. After that, we can start sampling gradients with the two-qubit case - generate 300 sets of random network structures and different random initial parameters $\\{\\theta_{\\ell,n}^{( i)}\\}_{i=1}^{300}$. Each time the partial derivative with respect to the **first parameter $\\theta_{1,1}$** is calculated according to the analytical gradient formula from VQE. Then we analyze the mean and variance of these 300 sampled partial gradients. The formula for the analytical gradient is:\n", - "\n", - "$$\n", - "\\partial \\theta_{j} \n", - "\\equiv \\frac{\\partial \\mathcal{L}}{\\partial \\theta_j}\n", - "= \\frac{1}{2} \\big[\\mathcal{L}(\\theta_j + \\frac{\\pi}{2}) - \\mathcal{L}(\\theta_j - \\frac{\\pi}{2})\\big].\n", - "\\tag{2}\n", - "$$\n", - "\n", - "For a detailed derivation, see [arXiv:1803.00745](https://arxiv.org/abs/1803.00745).\n" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 4, - "source": [ - "# Hyper parameter settings\n", - "np.random.seed(42) # Fixed Numpy random seed\n", - "N = 2 # Set the number of qubits\n", - "samples = 300 # Set the number of sampled random network structures\n", - "THETA_SIZE = N # Set the size of the parameter theta\n", - "ITR = 1 # Set the number of iterations\n", - "LR = 0.2 # Set the learning rate\n", - "SEED = 1 # Fixed the randomly initialized seed in the optimizer\n", - "\n", - "# Initialize the register for the gradient value\n", - "grad_info = []\n", - "\n", - "paddle.seed(SEED)\n", - "class manual_gradient(paddle.nn.Layer):\n", - " \n", - " # Initialize a list of learnable parameters and fill the initial value with a uniform distribution of [0, 2*pi]\n", - " def __init__(self, shape, param_attr= paddle.nn.initializer.Uniform(\n", - " low=0.0, high=2 * np.pi),dtype='float64'):\n", - " super(manual_gradient, self).__init__()\n", - " \n", - " # Convert Numpy array to Tensor in PaddlePaddle\n", - " self.H = paddle.to_tensor(density_op(N))\n", - " \n", - " # Define loss function and forward propagation mechanism \n", - " def forward(self):\n", - " \n", - " # Initialize three theta parameter lists\n", - " theta_np = np.random.uniform(low=0., high= 2 * np.pi, size=(THETA_SIZE))\n", - " theta_plus_np = np.copy(theta_np) \n", - " theta_minus_np = np.copy(theta_np) \n", - " \n", - " # Modified to calculate analytical gradient\n", - " theta_plus_np[0] += np.pi/2\n", - " theta_minus_np[0] -= np.pi/2\n", - " \n", - " # Convert Numpy array to Tensor in PaddlePaddle\n", - " theta = paddle.to_tensor(theta_np)\n", - " theta_plus = paddle.to_tensor(theta_plus_np)\n", - " theta_minus = paddle.to_tensor(theta_minus_np)\n", - " \n", - " # Generate random targets, randomly select circuit gates in rand_circuit\n", - " target = np.random.choice(3, N) \n", - " \n", - " U = rand_circuit(theta, target, N).U\n", - " U_dagger = dagger(U) \n", - " U_plus = rand_circuit(theta_plus, target, N).U\n", - " U_plus_dagger = dagger(U_plus) \n", - " U_minus = rand_circuit(theta_minus, target, N).U\n", - " U_minus_dagger = dagger(U_minus) \n", - "\n", - " # Calculate the analytical gradient\n", - " grad = (paddle.real(matmul(matmul(U_plus_dagger, self.H), U_plus))[0][0] \n", - " - paddle.real(matmul(matmul(U_minus_dagger, self.H), U_minus))[0][0])/2 \n", - " \n", - " return grad\n", - "\n", - "# Define the main block\n", - "def main():\n", - "\n", - " # Set the dimension of QNN\n", - " sampling = manual_gradient(shape=[THETA_SIZE])\n", - " \n", - " # Sampling to obtain gradient information\n", - " grad = sampling() \n", - " \n", - " return grad.numpy()\n", - "\n", - "# Record running time\n", - "time_start = time.time()\n", - "\n", - "# Start sampling\n", - "for i in range(samples):\n", - " if __name__ == '__main__':\n", - " grad = main()\n", - " grad_info.append(grad)\n", - "\n", - "time_span = time.time() - time_start\n", - "\n", - "print('The main program segment has run in total ', time_span, ' seconds')\n", - "print(\"Use \", samples, \" samples to get the mean value of the gradient of the random network's first parameter, and we have：\", np.mean(grad_info))\n", - "print(\"Use \", samples, \"samples to get the variance of the gradient of the random network's first parameter, and we have：\", np.var(grad_info))" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "The main program segment has run in total 11.881862878799438 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" - ] - } - ], - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T12:20:52.236108Z", - "start_time": "2021-03-02T12:20:40.850822Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "## Visualization of the Optimization landscape\n", - "\n", - "Next, we use Matplotlib to visualize the optimization landscape. In the case of **two qubits**, we only have two parameters $\\theta_1$ and $\\theta_2$, and there are 9 possibilities for the random circuit structure in the second layer. \n", - "\n", - "![BP-fig-landscape2](./figures/BP-fig-landscape2.png)\n", - "\n", - "The plain structure shown in the $R_z$-$R_z$ layer from the last figure is something we should avoid. In this case, it's nearly impossible to converge to the theoretical minimum. If you want to try to draw some optimization landscapes yourself, please refer to the following code:" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 5, - "source": [ - "# Introduce the necessary packages\n", - "from matplotlib import cm\n", - "from mpl_toolkits.mplot3d import Axes3D\n", - "from matplotlib.ticker import LinearLocator, FormatStrFormatter\n", - "\n", - "time_start = time.time()\n", - "N = 2\n", - "\n", - "# Set the image ratio Vertical: Horizontal = 0.3\n", - "fig = plt.figure(figsize=plt.figaspect(0.3))\n", - "\n", - "# Generate points on the x, y axis\n", - "X = np.linspace(0, 2 * np.pi, 80)\n", - "Y = np.linspace(0, 2 * np.pi, 80)\n", - "\n", - "# Generate 2D mesh\n", - "xx, yy = np.meshgrid(X, Y)\n", - "\n", - "\n", - "# Define the necessary logic gates\n", - "def rx(theta):\n", - " mat = np.array([[np.cos(theta/2), -1j * np.sin(theta/2)],\n", - " [-1j * np.sin(theta/2), np.cos(theta/2)]])\n", - " return mat\n", - "\n", - "def ry(theta):\n", - " mat = np.array([[np.cos(theta/2), -1 * np.sin(theta/2)],\n", - " [np.sin(theta/2), np.cos(theta/2)]])\n", - " return mat\n", - "\n", - "def rz(theta):\n", - " mat = np.array([[np.exp(-1j * theta/2), 0],\n", - " [0, np.exp(1j * theta/2)]])\n", - " return mat\n", - "\n", - "def CZ():\n", - " mat = np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,-1]])\n", - " return mat\n", - "\n", - "# ============= The first figure =============\n", - "# We visualize the case where the second layer is kron(Ry, Ry)\n", - "ax = fig.add_subplot(1, 2, 1, projection='3d')\n", - "\n", - "# Forward propagation to calculate loss function:\n", - "def cost_yy(para):\n", - " L1 = np.kron(ry(np.pi/4), ry(np.pi/4))\n", - " L2 = np.kron(ry(para[0]), ry(para[1]))\n", - " U = np.matmul(np.matmul(L1, L2), CZ())\n", - " H = np.zeros((2 ** N, 2 ** N))\n", - " H[0, 0] = 1\n", - " val = (U.conj().T @ H@ U).real[0][0]\n", - " return val\n", - "\n", - "# Draw an image\n", - "Z = np.array([[cost_yy([x, y]) for x in X] for y in Y]).reshape(len(Y), len(X))\n", - "surf = ax.plot_surface(xx, yy, Z, cmap='plasma')\n", - "ax.set_xlabel(r\"$\\theta_1$\")\n", - "ax.set_ylabel(r\"$\\theta_2$\")\n", - "ax.set_title(\"Optimization Landscape for Ry-Ry Layer\")\n", - "\n", - "# ============= The second figure =============\n", - "# We visualize the case where the second layer is kron(Rx, Rz)\n", - "ax = fig.add_subplot(1, 2, 2, projection='3d')\n", - "\n", - "\n", - "def cost_xz(para):\n", - " L1 = np.kron(ry(np.pi/4), ry(np.pi/4))\n", - " L2 = np.kron(rx(para[0]), rz(para[1]))\n", - " U = np.matmul(np.matmul(L1, L2), CZ())\n", - " H = np.zeros((2 ** N, 2 ** N))\n", - " H[0, 0] = 1\n", - " val = (U.conj().T @ H @ U).real[0][0]\n", - " return val\n", - "\n", - "Z = np.array([[cost_xz([x, y]) for x in X] for y in Y]).reshape(len(Y), len(X))\n", - "surf = ax.plot_surface(xx, yy, Z, cmap='viridis')\n", - "ax.set_xlabel(r\"$\\theta_1$\")\n", - "ax.set_ylabel(r\"$\\theta_2$\")\n", - "ax.set_title(\"Optimization Landscape for Rx-Rz Layer\")\n", - "\n", - "\n", - "plt.show()\n", - "\n", - "time_span = time.time() - time_start \n", - "print('The main program segment has run in total ', time_span, ' seconds')" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "The main program segment has run in total 3.772348165512085 seconds\n" - ] - } - ], - "metadata": { - "ExecuteTime": { - "end_time": "2021-03-02T12:21:49.972769Z", - "start_time": "2021-03-02T12:21:45.792119Z" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "## Gradient Analysis Tool\n", - "\n", - "Based on an important role that gradients play in phenomena such as barren plateaus, we developed a simple gradient analysis tool in Paddle Quantum to assist users in viewing gradients of each parameter in the circuit. This tool can be used to facilitate subsequent research on quantum neural networks.\n", - "\n", - "Note that the users only need to define the **circuit** and **loss function** separately when using the gradient analysis tool, and there is no need to write their networks.\n" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "### Application I: Unsupervised Learning\n", - "\n", - "For this case, we focus on variational quantum algorithms similar to the Variational Quantum Eigensolver (VQE). Suppose the objective function is the typical parameterized cost function used in VQA: $O(\\theta) = \\left\\langle0\\dots 0\\right\\lvert U^{\\dagger}(\\theta)HU(\\theta) \\left\\lvert0\\dots 0\\right\\rangle$，where $U(\\theta)$ is a parameterized quantum circuit, $H$ is a Hamiltonian and $\\theta = [\\theta_1, \\theta_2, \\dots, \\theta_n]$ is a list of trainable parameters in the circuit.\n", - "\n", - "Here we use VQE to demonstrate the usage of this gradient analysis tool.\n", - "\n" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### Paddle Quantum Implement\n", - "\n", - "Firstly, import the packages needed for the problem." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 2, - "source": [ - "# Import related modules from Paddle Quantum and PaddlePaddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import pauli_str_to_matrix, random_pauli_str_generator\n", - "# GradTool package\n", - "from paddle_quantum.gradtool import random_sample, show_gradient, plot_distribution, plot_loss_grad" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### Define Quantum Circuits\n", - "\n", - "Next, construct the parameterized quantum circuit $U(\\theta)$ in the objective function. Here we still use the random circuit defined above." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### Define Objective Function\n", - "\n", - "Note here that in the gradient analysis module we call the function in the form of ``loss_func(circuit, *args)`` to calculate the objective function value. This means that the second argument is a variable argument, and the user is able to construct their own objective function form as needed." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 4, - "source": [ - "# objective function\n", - "def loss_func(circuit, H_l):\n", - " circuit.run_state_vector()\n", - " return (circuit.expecval(H_l))" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "Then set some parameters required for the application." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 5, - "source": [ - "# Hyper parameter settings\n", - "np.random.seed(42) # Fixed Numpy random seed\n", - "N = 2 # Set the number of qubits\n", - "samples = 300 # Set the number of sampled random network structures\n", - "THETA_SIZE = N # Set the size of the parameter theta\n", - "ITR = 120 # Set the number of iterations\n", - "LR = 0.1 # Set the learning rate\n", - "SEED = 1 # Fixed the randomly initialized seed in the optimizer" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "Randomly generate quantum circuits and a list of Hamiltonian information." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 6, - "source": [ - "paddle.seed(SEED)\n", - "target = np.random.choice(3, N)\n", - "# Random generate parameters between 0 and 2*Pi \n", - "theta = np.random.uniform(low=0., high= 2 * np.pi, size=(THETA_SIZE))\n", - "theta = paddle.to_tensor(theta, stop_gradient=False, dtype='float64')\n", - "cir = rand_circuit(theta, target, N)\n", - "print(cir)\n", - "# Random generate Hamiltonian information, in Pauli string format\n", - "H_l = random_pauli_str_generator(N, terms=7)\n", - "print('Hamiltonian info: ', H_l)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "--Ry(0.785)----Rx(1.153)----*--\n", - " | \n", - "--Ry(0.785)----Rz(4.899)----z--\n", - " \n", - "Hamiltonian info: [[0.7323522915498704, 'z0'], [-0.8871768419457995, 'y0'], [-0.9984424683179713, 'x0,x1'], [0.22330632097656178, 'x0'], [-0.9538751499171685, 'z1'], [-0.20027805656948905, 'z0'], [-0.8187871309343584, 'y1']]\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "``cir`` and ``H_l`` are the parameters needed for the objective function ``loss_func``." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "Using the gradient analysis tool, we can get the results of the gradient sampling of each parameter in the circuit. There are three modes ``single``, ``max``, and ``random`` for users to choose, where ``single`` returns the mean and variance of each parameter after sampling the circuit multiple times, ``max`` mode returns the mean and variance of the maximum value of all parameter gradients in each round, and ``random`` calculates the mean and variance of random value of all parameter gradients in each round.\n", - "\n", - "We sample the circuit 300 times, and here we choose the ``single`` mode to see the mean and variance of the gradient of each variable parameter in the circuit, while the default ``param=0`` means plot gradient distribution of the first parameter.\n", - "\n" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 27, - "source": [ - "grad_mean_list, grad_variance_list = random_sample(cir, loss_func, samples, H_l, mode='single', param=0) " - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Sampling: 100%|###################################################| 300/300 [00:14<00:00, 21.14it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mean of gradient for all parameters: \n", - "theta 1 : -0.03157116754124028\n", - "theta 2 : -0.004525341240963983\n", - "Variance of gradient for all parameters: \n", - "theta 1 : 0.07237471326311368\n", - "theta 2 : 0.027855249806997346\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "The user can also use the ``plot_loss_grad`` function to show the gradient and loss values variation during the training process." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 12, - "source": [ - "plot_loss_grad(cir, loss_func, ITR, LR, H_l)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Training: 100%|###################################################| 120/120 [00:03<00:00, 38.59it/s]\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "As shown above, the loss value does not change after a few dozen times, and the gradient is very close to 0.\n", - "In order to see the difference between the optimal solution and the theoretical value clearly, we calculate the eigenvalues of the Hamiltonian ``H_l``." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 12, - "source": [ - "loss, grad = show_gradient(cir, loss_func, ITR, LR, H_l)\n", - "H_matrix = pauli_str_to_matrix(H_l, N)\n", - "\n", - "print(\"optimal result: \", loss[-1])\n", - "print(\"real energy：\", np.linalg.eigh(H_matrix)[0][0])" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Training: 100%|###################################################| 120/120 [00:02<00:00, 41.17it/s]" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "optimal result: -1.3504325097994594\n", - "real energy： -2.528866656129176\n" - ] - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "The comparison shows that there is still a gap between the optimal solution obtained from the training of this circuit and the actual value." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### More qubits\n", - "\n", - "Since in the barren plateau effect, the gradient disappears exponentially with increasing the number of quantum bits. Then, we will see what happens to the sampled gradients when we increase the number of qubits(here we sample by choosing ``max`` mode)." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 34, - "source": [ - "# Hyper parameter settings\n", - "selected_qubit = [2, 4, 6, 8]\n", - "means, variances = [], []\n", - "\n", - "# Keep increasing the number of qubits\n", - "for N in selected_qubit:\n", - " grad_info = []\n", - " THETA_SIZE = N \n", - " target = np.random.choice(3, N)\n", - " theta = np.random.uniform(low=0., high= 2 * np.pi, size=(THETA_SIZE))\n", - " theta = paddle.to_tensor(theta, stop_gradient=False, dtype='float64')\n", - " cir = rand_circuit(theta, target, N)\n", - " H_l = random_pauli_str_generator(N, terms=10)\n", - " \n", - " grad_mean_list, grad_variance_list = random_sample(cir, loss_func, samples, H_l, mode='max') \n", - " # Record sampling information\n", - " means.append(grad_mean_list)\n", - " variances.append(grad_variance_list)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Sampling: 100%|###################################################| 300/300 [00:22<00:00, 13.28it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mean of max gradient\n", - "0.31080108926858796\n", - "Variance of max gradient\n", - "0.01671146619361498\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Sampling: 100%|###################################################| 300/300 [00:33<00:00, 8.86it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mean of max gradient\n", - "0.18860559161991128\n", - "Variance of max gradient\n", - "0.00513813734318612\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Sampling: 100%|###################################################| 300/300 [00:40<00:00, 7.45it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mean of max gradient\n", - "0.15985084804138153\n", - "Variance of max gradient\n", - "0.003425544062206579\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Sampling: 100%|###################################################| 300/300 [00:51<00:00, 5.86it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mean of max gradient\n", - "0.08909871218516183\n", - "Variance of max gradient\n", - "0.001158520193967305\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "To compare the mean and variance of the maximum gradient of each parameter, we plot them." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 36, - "source": [ - "means = np.array(means)\n", - "variances = np.array(variances)\n", - "\n", - "n = np.array(selected_qubit)\n", - "print(\"We then draw the statistical results of this sampled gradient:\")\n", - "fig = plt.figure(figsize=plt.figaspect(0.3))\n", - "\n", - "# ============= The first figure =============\n", - "# Calculate the relationship between the average gradient of random sampling and the number of qubits\n", - "plt.subplot(1, 2, 1)\n", - "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 gradient\".format(samples))\n", - "plt.xlim([1,9])\n", - "plt.grid()\n", - "\n", - "# ============= The second figure =============\n", - "# Calculate the relationship between the variance of the randomly sampled gradient and the number of qubits\n", - "plt.subplot(1, 2, 2)\n", - "plt.plot(n, np.log(variances), \"v-\")\n", - "plt.xlabel(r\"Qubit #\")\n", - "plt.ylabel(r\"$ \\partial \\theta_{i} \\langle 0|H |0\\rangle$ Variance\")\n", - "plt.title(\"Variance of {} sampled gradient\".format(samples))\n", - "plt.xlim([1,9])\n", - "plt.grid()\n", - "\n", - "plt.show()" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "We then draw the statistical results of this sampled gradient:\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAygAAAEWCAYAAACNG7MFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAABbCElEQVR4nO3dd5hU5f3+8fdnO70vZalSli4dUVEQewONvfcSjZoYk6j52aKJX40aTUys2BVLFI1dI6sSpYPSEUGRBUEEpJdlP78/zkGHdRd2YWbPzO79uq65mDll5p7ZZZ59ztPM3REREREREUkGaVEHEBERERER2U4VFBERERERSRqqoIiIiIiISNJQBUVERERERJKGKigiIiIiIpI0VEEREREREZGkoQqKpDQz28/MvjCzdWY2Iuo8UTKztmbmZpZRmefGg5ndZGZPh/dbhz/P9CiyiEg0wv/3e0Wdozws8JiZrTKzCVHniZqZPW5mt1b2ufEQln0dwvsPmNn/iyqL/EQVFNmBmX1lZlvMrHGJ7VPD/8RtI4pWlluAf7h7bXcfXXKnmT1tZkvNbI2ZzTOzC0rsH2Zmc8xsg5mNMbM2MfuyzWxkeO63ZvabxL8dcfdF4c9z254+l5kVlPyZi8ieM7O3zeyWUrYPD78vK3yxI/x/vyA+CRNuf+AQoKW7Dyi508yGmtl0M1ttZt+b2Stmlhezf6fly87KJkkcd7/E3f+0p89jZkPMbHE8MlVXqqBIaRYCp25/YGY9gJrRxdmpNsDMnez/C9DW3esCxwK3mllfgLAS9jLw/4CGwCTg+ZhzbwI6hq8xFPidmR0e7zdQ1UTVCiMileoJ4AwzsxLbzwSecfei8j5Rin5ntAG+cvf1ZeyfBRzm7vWBFsAXwL9i9t9EGeVLOcomKUXYqqW/a6sI/SClNE8BZ8U8Pht4MvaA8OrPX81skZktC5tFa4T7GpjZ62b2Xdj8/bqZtYw5t8DM/mRm/zOztWb2bskWmxKvdaGZzTezlWb2mpm1CLd/CewF/CfsGpBd8lx3n+num7c/DG/tw8fHAzPd/UV330RQYOxtZp1j3vef3H2Vu88GHgbOKSNjBzP70Mx+MLMVZvZ8zL57zeyb8ErZZDMbHLPvJjN7MWzpWRtecetkZtea2fLwvENLfHZ/MbMJ4fO9amYNy8hUz8weDVuQCs3sVgu7TZlZevjzW2FmC4Cjyvr8w+P7hK1oa8O8z1vYJL/9SpGZ/d7MvgUeK8fvQLvw81prZu8BjWP27dDdbBfv4xwzGxu+l1VmttDMjgj33QYMBv4R/n78Y2fvUUQqZDTQiOD/GBB89wNHA0+a2QAz+9SCFoSlZvYPM8uKOdbN7DIz+4Lgj/eSXW2OCr9z1oTfgzfFnLv9O+LssAxaYWbXx+xPN7PrzOzL8Dtmspm1Cvd1NrP3wvJkrpmdVNYbNLMWYZmzMiyDLgy3nw88AgwKv1tuLnmuuy9z9yUxm7YBHWIe76x82VXZVDLn78PvxrXhexoWbi/Pz+CXFnSTXmtBudzezD4JP/cXth8f8z1/Xfh5f2Vmp+/kszvazKaFr/2JmfWM2dfbzKaEr/k8kLOT50k3s7vC11xoZpeXKB8KzOw2M/sfsAHYy8zONbPZ4fMvMLOLSzznNeHnscTMziuxb4fuZrt4H1+Z2W/N7HMLyv7nzSzHzGoBbwEtwt+PdRb+3SIV4O666fbjDfgKOBiYC3QB0oHFBFd5nKA1AuAe4DWCqzt1gP8Afwn3NQJ+QdDqUgd4ERgd8xoFwJdAJ6BG+Pj2MvIcBKwA+gDZwN+Bj0rm3cV7+ifBF5cDU4Da4fZ7gX+VOHZGmL1BeHzTmH0nANPLeI3ngOsJKv05wP4x+84IP5MM4GrgWyAn3HcTsAk4LNz/JEEL1vVAJnAhsLDEZ1cIdAdqAf8Gng73tQ0zZ4SPXwEeDI/LBSYAF4f7LgHmAK3Cn+GY2HNLvLcs4GvgyjDT8cAW4NZw/xCgCPi/8GdUoxy/A58Cd4fHHwCs3c33cQ6wNfyc0oFLgSWAxXxeF0T9/0o33arijeCP6kdiHl8MTAvv9wX2Cb/X2gKzgatijnXgvfD7p0bMtg7h/SFAD4Lv1J7AMmBEuG/7d8TD4ffN3sBmoEu4/xpgOpAPWLi/Ufgd8g1wbpirN0H50rWM9/cRQfmRA/QCvgMOCvedA4zdxefTGlgNFIffU+eE23davrCTsqmU18gP31OLmM+mfQV+Bq8CdYFu4Wf4X4ILf/UIWoHOjvl5FPHT9/aBwHogP9z/OD+VCb2B5cBAgu/lswnK6mx+Kk9+TVCenBB+NreW8RleEuZoGX5u77Nj+VAALArzZ4TPeRTBhUgLc24A+oTHH07wu7S9DH2WHX/vyvU+wv1fEZRHLQh+j2cDl8R8Xouj/j+ayrfIA+iWXDd+qqD8kaB71OEEhUhG+J+4bfiffv32L8HwvEHE/CFd4jl7AatiHhcAf4x5/Evg7TLOfRS4I+Zx7fDLrG1s3nK8r3SCPsN/BDJjnvv2Esf9j6DgaRW+35yYfYcQNOmX9vxPAg8R9EfeVZZVwN7h/ZuA92L2HQOsA9LDx3XCHPVjPrvbY47vSlBZSCfmD3ugKUFhUyPm2FOBMeH9D7Z/kYaPD6XsCsoBBJUii9k2lh0rKFtiP6ud/Q4QFNpFQK2Y/c9SSgWlHO/jHGB+zL6a4bnNYj4vVVB00y0Bt/A7dTU/XXD5H/DrMo69Cngl5rET/rFfYluHMs7/G3BPeH/7d0TLmP0TgFPC+3OB4aU8x8nAxyW2PQjcWMqxrQhaPerEbPsL8Hh4/xx2UUGJOa8h8Htgn5jnLrN8YSdlUynP3YHgj+iDCcu2neQo7WewX8zjycDvYx7fBfwtvD+klO/tF4D/F95/nJ/KhH8RtA7FvvZcgsrCAcRcRAr3fULZFZQPCC9IhY8P5ucVlFt28b5HA1eG90eyYxnaibIrKGW+j/D+V8AZMfvuAB6I+bxUQdmDm7p4SVmeAk4j+BJ+ssS+JgR/CE4Omz1XA2+H2zGzmmb2oJl9bWZrCK5C1bcdZ2X6Nub+BoKKR2laEFxtAcDd1wHfA3llHF8qd9/m7mMJrsJcGm5eR3DlKFZdgqv562Iel9xXmt8RVNwmmNnM2GbjsAl4dtgEvJrgylRsl7ZlMfc3Aiv8pwHiG8N/Yz+fb2Luf01wxahkF7k24falMT+jBwlaICD4XEs+T1laAIUefuuWkgHgOw+6IgC7/B1oQVBZie27Xdbr7+p9QMzvkrtvCO+W9fskInESfqeuAEaYWXtgAMHFBizoqvq6BQPA1wB/5uffUyW/R35kZgMtGBz+nZn9QHAlveT5ZZUjrQha6UtqAwzc/l0Sfp+cDjQr5dgWwEp3j/3O/5oKlj0A7r6SYMzOq2HXpF2VLzsrm0o+93yCisdNwHIzG2U/dYMuz8+gZPlT8nHsd2lp39uldV1qA1xd4nNuFR5bWnmyq/In9vektN+ZHbaZ2RFmNs6CrnmrgSP56X1XpOzb2fvYrrx/y0gFqYIipXL3rwm6Gh1JMFgv1gqCL65u7l4/vNVz9+3/Ma8maHYe6MHg9APC7SUHU5bHEoIvieAJgr6djQiu6O+ODH4agzKToOk/9rnbE/T9XQUsjd0f3i91QL67f+vuF7p7C4JuDv+0YFzKYILKy0lAAw8GTP7A7n0W27WKud+aoEVpRYljviFoeWgc8zOq6+7dwv1LS3mesiwF8sx2GAzbqsQxXuLxzn4HlgINws97V6+/q/exKyVziUh8PUkwZvEM4B133/4H7r8IupF2DL8DruPn33s7+//5LEE34lbuXg94oJTzy/INP33Pl9z+Ycx3SX0PZg67tJRjlwANzaxOzLbW7FnZkwvULUf5UmbZVNoTu/uz7r4/P3XF/r9wV3l+BhVR2vf2klKO+wa4rcTnXNPdn6P08mRX5U/LmMclyx6I+T2yYCzqv4G/EnShqw+8yU/vuyJl387ex66o7NlDqqDIzpxP0AS/wywl7l5M0Pf3HjPLBTCzPDM7LDykDkEFZrUFA7hv3IMMzwHnmlmv8Ivnz8B4d/9qVyeaWa6ZnWJmtcOBdocRdA/6b3jIK0B3M/uFmeUANwCfu/uccP+TwB8tGPDdmWCcw+NlvNaJ9tMg8FUEX07FBJ9FEUHf5Qwzu4GfXxmrqDPMrKuZ1SSYZvklLzElr7svBd4F7jKzumaWZsHgxwPDQ14ArjCzlhYMbP3DTl7vU4KuDpebWYaZDSe4UrozZf4OhJXfScDNZpZlZvsTdG37mXK8j11ZRtCfWkQS40mCbjcXErQSbFcHWAOsC78/S6sE7EwdghaMTWY2gKBFv7weAf5kZh0t0NPMGgGvA53M7Ewzywxv/c2sS8kncPdvCLoe/SUc+NyToEx8ujwBzOx4M8sPv7OaEIzdmBq2psDOy5ddlU2xr5NvZgeF5eMmgu/d4nD3nv4MSrP9e3swwYQIL5ZyzMPAJWErmJlZLQsmPahDUJ4UEZQ/mWZ2PDsvT14Argz/xqhP0FVuZ7IIxrp8BxRZMGnKoTH7XwDOiSlDd/b3yc7ex64sAxqZWb1yHCulUAVFyuTuX7r7pDJ2/x6YD4wLm47fJ7hiDkFf4RoEV/XHEXT/2t0M7xNMtfhvgisf7YFTyns6wRfyYoJKw18JBgi+Fj73dwQDuW8L9w8s8dw3EnQT+Br4ELjT3ct6L/2B8Wa2juCq35UezOf/DsH7nxc+zyZ20q2hnJ4iKMi+JRi8eUUZx51F8GU9i+D9vQQ0D/c9HGb7jGDigJKtZD9y9y0EA+PPJ+hvfgZBQb+5rHPY9e/AaQSf90qCz7lkN8Lyvo9duRc4wYIZvu4r5zkiUk7hxaJPCAYcvxaz67cE/8/XEnzfVHSa3F8Ct5jZWoI/0F+owLl3h8e/S/AH+qME49jWEvyxegrBlf9v+Wlyj9KcSjDeZQlBpeHGsEwqjzyC7721BAP2i4HjYvaXWb6Uo2yKlQ3cTvBd+y1BK8214b49/RmU9G2YZwnwDME4xp9VmsK/Gy4E/hEeP59whrKY8uQcgu//k9lJ+RPmfhf4HJhK0BpSRHDR7GfCn/EVBD//VQTv/7WY/W8RlE8fhLk+KOuFd/Y+diX8XJ4DFoTdwzSLVwVtn+lGRFKAmRUQDCZ/JOIc4wkGAz4WZQ4REUk8MxtCUPa03MWhic5xBEHZ02aXB0tKUwuKiOySmR1oZs3CLl5nE0z7udstYyIiIrtiZjXM7Miw7MkjaHl6JepckniqoIhIeeQTdAdbTTAA/oRwfIiIiEiiGHAzQRerqQRrjdwQaSKpFOriJSIiIiIiSUMtKCIiIiIikjQyog6QKPXr1/cOHTpEHaNc1q9fT61atXZ9YMSUM/5SJatyxleq5ASYPHnyCndvEnWOijKzqwlm7mvi7iXXCSIcS/XH8OGt7v5EyWNKUrkSf8oZX6mSE1Inq3LGV7nLlHgvTZ8st06dOnmqGDNmTNQRykU54y9VsipnfKVKTnd3YJInwXd6RW4EC7G9QzCFa+NS9jcEFoT/NgjvN9jV86pciT/ljK9UyemeOlmVM77KW6aoi5eIiFQ19wC/o+zVnA8D3nP3lR6s6v0ecHhlhRMRkZ2rsl28RESk+jGz4UChu39mZmUdlseOC6YuDreV9nwXARcBNGnShIKCgviFTaB169alRFbljK9UyQmpk1U5o6EKioiIpBQzex9oVsqu64HrCFYLjwt3fwh4CCA/P9+HDBkSr6dOqIKCAlIhq3LGV6rkhNTJqpzRUAVFRERSirsfXNp2M+sBtAO2t560BKaY2QB3/zbm0EJgSMzjlkBBQsKKiEiFaQyKiIhUCe4+3d1z3b2tu7cl6LrVp0TlBIIB9IeaWQMza0DQ4vJOJccVEZEyqAUlQqOnFnLnO3MpXL2RvHEfcM1h+YzoXWo3aBER2QNm1g+4xN0vcPeVZvYnYGK4+xZ3XxlhvLg48t6PmbV0zU8b3n4DgK7N6/LmlYMjSiUiUnGqoERk9NRCrn15Ohu3bgOgcPVGrn15OoAqKSIicRC2omy/Pwm4IObxSGBkBLESpk/r+nyxfC1bt/00eVlmutGnTYMIU4mIVJy6eEXkznfm/lg52W7j1m3c+c7ciBKJiEgqu2JYR9JKzFyWbsYVw1JjcUkRke1UQYnIktUbK7RdRERkZ3Lr5nBgp58WaM5MN07o14rcOjkRphIRqThVUCLSon6NCm0XERHZlVtHdCczPWhFKSp2LhzcLuJEIiIVpwpKRK45LJ8amek7bMtMN645LD+iRCIikupy6+Zwcr9WALjDtS9PZ1OJ7sQiIslOFZSIjOidx1+O70Fe2GKSk5HGtmKnVcOaEScTEZFUdsWwjnRqkMZNx3Tl0wXfc8nTk9lcpEqKiKQOVVAiNKJ3Hv/7w0E8fngtxl93MC0b1OSyZ6awYt3mqKOJiEiKyq2bw3UDa3DOfu3483E9KJj7HZc/O5Wt24qjjiYiUi6qoCSJejUz+dcZfVi1YQtXPDeVIhUkIiKyh04d0Jqbj+3Ge7OWcdWoaSpbRCQlqIKSRLq1qMetI7rzyZffc9d786KOIyIiVcDZ+7bl+iO78Mb0pfzupc8pLvZdnyQiEqFKraCY2eFmNtfM5pvZH0rZf4mZTTezaWY21sy6xuy7NjxvrpkdVpm5K9OJ/Vpx6oBWvD3jWzZsKYo6joiIVAEXHrAXvz20Ey9PLeS6V6arkiIiSa3SVpI3s3TgfuAQYDEw0cxec/dZMYc96+4PhMcfC9wNHB5WVE4BugEtgPfNrJO7V8lRfzce040t24qpmVVpPx4REaniLj+oI5u2FvOPMfPJzkjjpmO7YSUWdhQRSQaV2YIyAJjv7gvcfQswChgee4C7r4l5WAvYfolnODDK3Te7+0Jgfvh8VVJOZjp1czLZtHUb977/BRu3VMl6mIiIVLKrD+3EhYPb8cSnX/PnN2fjrpYUEUk+lXmJPg/4JubxYmBgyYPM7DLgN0AWcFDMueNKnJtXyrkXARcBNGnShIKCgnjkTrh169aVmnXuym38bcImtq74mn7Nom9NKStnskmVnJA6WZUzvlIlp1Q9ZsZ1R3Zhc1ExD3+8kJzMdK4+VOtviUhyif6v3hLc/X7gfjM7DfgjcHYFzn0IeAggPz/fhwwZkpCM8VZQUEBpWYcAhx2wnraNa1V2pFKVlTPZpEpOSJ2syhlfqZJTqiYz46ZjurGlqJi/fxB097r8oI5RxxIR+VFlVlAKgVYxj1uG28oyCvjXbp5bZWyvnExYuJLsjDT2blU/2kAiIpLy0tKM247rweaiYv767jyyM9K58IC9oo4lIgJU7hiUiUBHM2tnZlkEg95fiz3AzGIv4RwFfBHefw04xcyyzawd0BGYUAmZk0LRtmJ+99JnXPr0ZFau3xJ1HBERqQLS04w7T+jJUT2ac9ubs3ny06+ijiQiAlRiBcXdi4DLgXeA2cAL7j7TzG4JZ+wCuNzMZprZNIJxKGeH584EXgBmAW8Dl1XVGbxKk5Gext9P7cOK9Vu4ctRUtml6SBERiYOM9DT+dkovDunalBtencmoCYuijiQiUrnroLj7m+7eyd3bu/tt4bYb3P218P6V7t7N3Xu5+9CwYrL93NvC8/Ld/a3KzJ0MerSsxy3HduPjL1bwt/e1iKOIiMRHZnoa/zitNwd2asK1r0znlamLo44kItWcVpJPIacMaM1J/Vry9w/m88GcZVHHERGRKiI7I50Hz+zLoL0acfULn/HG50ujjiQi1ZgqKCnmluHd6daiLleNmsai7zdEHUdERKqInMx0Hjm7H33bNODKUVN5d+a3UUcSkWpKFZQUk5OZzr9O7wvAJU9PZtPWajMUR0REEqxmVgYjz+lPt7x6XPbsFMbMXR51JBGphlRBSUGtG9Xkb6f0YtbSNdzw6oyo44iISBVSJyeTJ88dQKemdbjkqcl8Mn9F1JFEpJpRBSVFHdS5KX84ojNH9GgedRQREali6tXM5KnzB9K2US3Of2ISE79aGXUkEalGVEFJYZcc2J6h+bkA6uolIiJx1bBWFk9fMJDm9XM497GJTF20KupIIlJNqIJSBTw7fhGH/e0jVm/QIo4iIhI/Tepk8+wF+9CwVhZnjZzAjMIfoo4kItWAKihVQNcWdenTugEZ6fpxiohIfDWrl8OzFw6kbk4mZz46njnfrok6kohUcfqLtgro1ao+95zci9rZGVplXkRE4q5lg5o8e+FAsjLSOOOR8cxfvi7qSCJShamCUoUs/WEjx/x9LAWaFlJEROKsTaNaPHPBPgCc/sg4vv5+fcSJRKSqUgWlCqlfI4tid656fhrfrNQijiIiEl8dcmvzzAX7sKWomNMeHs/iVSprRCT+VEGpQmpkpfOvM/qybZvzy2emaGYvEam2zOxqM3Mza1zG/m1mNi28vVbZ+VJZfrM6PHX+QNZu2sppD4/n2x82RR1JRKoYVVCqmHaNa3HXSXszvfAHbv7PrKjjiIhUOjNrBRwKLNrJYRvdvVd4O7aSolUZ3fPq8cR5A1i5fgunPTyO5WtVSRGR+FEFpQo6tFszLh3SnucmLOLFSd9EHUdEpLLdA/wO0KwhCdS7dQMeO7c/S3/YxBmPjGflek11LyLxkRF1AEmMqw/pxGffrOaPo2fQtUVdurWoF3UkEZGEM7PhQKG7f2ZmOzs0x8wmAUXA7e4+uoznuwi4CKBJkyYUFBTEN3CCrFu3rtKy/qpXJvdMXsdx9/6X3/XPoVbmTj/3HVRmzj2hnPGXKlmVMxqqoFRRGelp3Hdqb46+byyXPj2F/1y+P/VqZkYdS0Rkj5nZ+0CzUnZdD1xH0L1rV9q4e6GZ7QV8YGbT3f3Lkge5+0PAQwD5+fk+ZMiQ3Q9eiQoKCqisrEOArt2Xc9GTk3loXhZPnz+AOjnlK28qM+eeUM74S5WsyhkNdfGqwhrXzub+0/uw9IeNvDRlcdRxRETiwt0PdvfuJW/AAqAd8JmZfQW0BKaY2c8qM+5eGP67ACgAelfaG6iChuTn8o/TejOz8AfOfWwi6zcXRR1JRFKYKihVXN82DfjPr/bnvP3aRh1FRCSh3H26u+e6e1t3bwssBvq4+7exx5lZAzPLDu83BvYDNKvIHjq0WzPuPaU3Uxat4oInJmkmSRHZbaqgVAOdm9XFzPjyu3VMWLgy6jgiIpXOzPqZ2SPhwy7AJDP7DBhDMAZFFZQ4OKpnc+46aW/GLfyei5+azOYiVVJEpOI0BqWacHeuefEz1mwq4t2rDiAtrfyDGEVEUlHYirL9/iTggvD+J0CPiGJVecf1bsnmrcX84eXpXPbMVP51Rh8y03U9VETKTxWUasLMuPukXmRlpKlyIiIiCXXKgNZs2VbMDa/O5KpR07j3lF5kqJIiIuWkCko10rZxLQCKi50P533H0M65EScSEZGq6qxBbdlSVMytb8wmM92466RepOsCmYiUgy5nVEMvTv6Gcx+fyCtTNbOXiIgkzgWD9+Kaw/IZPW0J1708neJirZ0pIrumFpRq6Bd9WvLylEKufXk6XZrXpXOzulFHEhGRKuqyoR3YtHUbf/9gPtmZadx8bDd2sYimiFRzakGphjLS0/j7ab2pm5PJJU9NZs2mrVFHEhGRKuw3h3TiogP24slPv+a2N2bjrpYUESmbKijVVG6dHO4/vQ+LV23kty98psJCREQSxsy49ojOnD2oDY+MXchd786LOpKIJDF18arG+rdtyLVHduFPr8/iwY8WcMmB7aOOJCIiVZSZceMx3diyrZh/jJlPdkYaPdKjTiUiyUgtKNXcefu15aiezbnj7Tl88uWKqOOIiEgVlpZm3DaiB8f3zuOu9+bx1kJ1MRaRn1MFpZozM/7vFz1p17gWVzw3lW9/2BR1JBERqcLS0ow7TujJUT2b8/zcLTzxyVdRRxKRJKMKilA7O4MHz+xL1xb10MQqIiKSaBnpafzt5F70zk3nxtdm8tyERVFHEpEkojEoAkCH3Do8ed4AANxdU0CKiEhCZaan8cte2TzzdS2ue2U6Welp/KJvy6hjiUgSUAuK7GDNpq2cNXICr04rjDqKiIhUcZlpxgNn9GXf9o245qXP+M9nS6KOJCJJQBUU2UGNzHSK3dlcVBx1FBERqQZyMtN5+Kx+9GvTkKuen8Y7M7+NOpKIREwVFNlBZnoaT58/kJP6tYo6ioiIVBM1szJ49Jx+9Mirx+XPTmHMnOVRRxKRCKmCIj+zffzJq9MKuVqLOIqISCWok5PJE+cNIL9ZHS5+ejL/m6+p70Wqq0qtoJjZ4WY218zmm9kfStn/GzObZWafm9l/zaxNzL5tZjYtvL1Wmbmrq2VrNvHvKYt5dOzCqKOIiEg1UK9GJk+dN5C9Gtfi/CcmMn7B91FHEpEIVFoFxczSgfuBI4CuwKlm1rXEYVOBfu7eE3gJuCNm30Z37xXejq2U0NXchYP34vBuzfjLW3NUSIiISKVoUCuLp84fSF79Gpz3+ESmLFoVdSQRqWSV2YIyAJjv7gvcfQswChgee4C7j3H3DeHDcYDmG4yQmXHniT1p07Amlz83ldWbNHBeRPacBc4wsxvCx63NbEDUuSR5NKmTzTMX7EPjOtmcPXICMwp/iDqSiFSiylwHJQ/4JubxYmDgTo4/H3gr5nGOmU0CioDb3X10yRPM7CLgIoAmTZpQUFCwh5Erx7p165I663n5xdwybjN/n+LUzhpDRlpyr5GS7J9nrFTJqpzxlSo5E+ifQDFwEHALsBb4N9A/ylCSXJrVy+HZC/fhpAc+5YxHxzPqon3o3Kxu1LFEpBIk5UKNZnYG0A84MGZzG3cvNLO9gA/MbLq7fxl7nrs/BDwEkJ+f70OGDKmsyHukoKCAZM9ap1UhV46axrgNTfnj0SV75iWXVPg8t0uVrMoZX6mSM4EGunsfM5sK4O6rzCwr6lCSfPLq1+DZCwdy8oPjOP3h8Tx/8T50yK0TdSwRSbDK7OJVCMTOXdsy3LYDMzsYuB441t03b9/u7oXhvwuAAqB3IsPKjob3ymNY6wweGbuQNz5fGnUcEUltW8NxiQ5gZk0IWlREfqZNo1o8c+FAzIzTHh7PVyvWRx1JRBKsMisoE4GOZtYuvFJ2CrDDbFxm1ht4kKBysjxmewMzyw7vNwb2A2ZVWnIB4NTOWfRuXZ8bXp3Bxi3boo4jIqnrPuAVINfMbgPGAn+ONpIks/ZNavPMBQPZuq2Y0x4exzcrN+z6JBFJWZVWQXH3IuBy4B1gNvCCu880s1vMbPusXHcCtYEXS0wn3AWYZGafAWMIxqCoglLJMtKMf57ehyfPH0CNrPSo44hIinL3Z4DfAX8BlgIj3P3FaFNJsstvVoenzh/Ius1FnP7IeJb+sDHqSCKSIJU6BsXd3wTeLLHthpj7B5dx3idAj8Smk/JoXq8GzevVAGDcgu8Z2K7hjws7ioiUl7vPAeZEnUNSS/e8ejx5/kDOeGQ8pz88nlEX70NunZyoY4lInGkledktBXOXc8pD43hjusajiEjFmNkTZlY/5nEDMxsZYSRJIb1a1efxc/vz7ZpNnP7weL5ft3nXJ4lISlEFRXbLAR2b8NcT9+bwbs2ijiIiqaenu6/e/sDdV6GJT6QC+rVtyCNn92PRyg2c+egEftiwNepIIhJH5a6gmFm2mZ1mZteZ2Q3bb4kMJ8krLc04oW9LMtLT+G7tZr5bqytYIlJuaWbWYPsDM2tIkk57L8lr3/aNefDMvsxfvo6zRo5n7SZVUkSqioq0oLxKsPJ7EbA+5ibV2NZtxZz4wCf86rkpFG3TLKEiUi53AePM7E9mdivwCcEkKSIVMiQ/l/tP78PMJWs497GJrN9cFHUkEYmDilRQWrr7ye5+h7vftf2WsGSSEjLT0/jVQR0Zt2Ald747N+o4IpIC3P1J4DhgGcEsXseH2/aYmd1kZoXhTJDTzOzIMo473Mzmmtl8M/tDPF5bonFI16bcd2pvpixaxflPTNQ0+CJVQEUqKJ+YmWbSkp/5Rd+WnDawNQ9+uIC3Z3wbdRwRSXLhula9gLpAI+CEOHcZvsfde4W3N0vuDBeJvB84AugKnGpmXeP4+lLJjuzRnLtP6sX4hSu56KlJbNqqSopIKqtIBWV/YHJ4xelzM5tuZp8nKpiklhuP6creLevx2xc/Y8F366KOIyLJLeouwwOA+e6+wN23AKPCPJLCRvTO4/bje/DxFyu4/NkpbClSt2ORVFWRQYlHJCyFpLzsjHT+eUZfjr7vYy59egqvXLYvNbM05lVEStXS3Q9P4PNfbmZnAZOAq8NZwmLlAd/EPF4MDExgHqkkJ/dvzZaiYv7fqzO56vmp3HdKbzLSNWGpSKop91+Q7v51OOtKRyB2VaSv455KUlJe/Rrce0pvzn5sAte/MoO7T9pbiziKSGk+MbMe7j59d042s/eB0uY4vx74F/AnwMN/7wLO292gZnYRcBFAkyZNKCgo2N2nqlTr1q1LiayJyNkKOLVzFs9N/5aVK97lop7ZpO1hWVSdP89ESZWsyhmNcldQzOwC4EqgJTAN2Af4FDgoIckkJR3QqQm/PrgTd783jz6t63PmoLZRRxKR5LM/cI6ZLQQ2Awa4u/csz8nufnB5jjOzh4HXS9lVSPB37HYtw22lvdZDwEMA+fn5PmTIkPK8dOQKCgpIhayJyjkEaDlmPne+M5fWeQ25/fiepKXtfiWlun+eiZAqWZUzGhXpg3Ml0B8Y5+5Dzawz8OfExJJUdvnQDnz2zWpWrtec9CJSqoR1GTaz5u6+NHx4HDCjlMMmAh3NrB1BxeQU4LREZZJoXDa0A5u3buO+D+aTlZHGn4Z3V6u+SIqoSAVlk7tvMjPMLNvd55hZfsKSScpKSzMeOqsf6XtwtUpEqq4Edxm+w8x6EXTx+gq4GMDMWgCPuPuR7l5kZpcD7wDpwEh3nxmH15Yk8+tDOrG5qJgHP1pAdkY6fzyqiyopIimgIhWUxWZWHxgNvGdmq9D4EynD9srJ+AXf89yERdx1Ui9VWEQESGyXYXc/s4ztS4AjYx6/CfxsCmKpWsyMPxzRmc1FxTw6diHZGWlcc1i+KikiSa4ig+SPC+/eZGZjgHrA2wlJJVXG199v4PPFP7Bi3Waa1s3Z9QkiUh2oy7BUGjPjxmO6srmomH8WfElOZjpXDOsYdSwR2YmKDJI34HRgL3e/xcxaEyy0NSFB2aQKOKl/K47t1YKczPSoo4hI8lCXYalUZsZtI7qzuWgbd783j6yMNC45sH3UsUSkDBWZHPyfwCDg1PDxWoKVeEV2KicznU1bt3HjqzP4+vvKXItNRJJUyS7Dr6Iuw5JgaWnGHb/oydE9m3P7W3N47H8Lo44kImWoyBiUge7ex8ymArj7KjPLSlAuqWJWrNvM6GlLmPDVKl6+dF9qZKlFRaS6UpdhiUpGehr3nNyLLUXF3PyfWWRnpHPawNZRxxKREirSgrLVzNIJZkbBzJoAxQlJJVVOywY1+dvJvZjz7Rr+OHoG7h51JBFJAu7+obu/5u5bos4i1UNmehp/P603Q/ObcP3o6bw0eXHUkUSkhIpUUO4DXgFyzew2YCwa1CgVMLRzLr86qCP/nrKY5yZ8E3UcEalkZjY2/Hetma2Jua01szVR55PqIzsjnX+d0Zd92zfidy99xmufLYk6kojEqMgsXs+Y2WRgGMGqvyPcfXbCkkmVdOWwjkz7ZjU3vTaTbi3qsner+lFHEpFK4u77hxOudHP3RVHnkeotJzOdh8/qxzkjJ/Lr56eRlZ7G4d2bRR1LRKhYCwruPsfd73f3f6hyIrsjPc249+ReNKmTzS+fmcKq9erVIVKdeNC/842oc4gA1MzKYOS5/enZsh6/em4KY+YsjzqSiFCOCoqZvbazW2WElKqlQa0s/nl6H75bu5krn5/GtmKNRxGpZqaYWf+oQ4gA1M7O4PFzB5DfrA4XPz2ZsV+siDqSSLVXnhaUQQSr/X4M/BW4q8RNpML2blWfm47txkfzvuOJT76KOo6IVK6BwKdm9qWZfW5m083s86hDSfVVr0YmT503kL0a1+KCJycyfsH3UUcSqdbKMwalGXAIwfonpxE0zT/n7jMTGUyqvlMHtAJgeK8WEScRkUp2WNQBREpqUCuLpy8YyMkPfsp5j0/kyfMH0rdNg6hjiVRLu2xBcfdt7v62u58N7APMBwrM7PKEp5Mqzcw4bWBramVnsHHLNpat2RR1JBGpBO7+NbAGaAq0ibmJRKpx7WyevXAfGtfJ5pyRE5i++IeoI4lUS+WaxcvMsoGjCFpR2vLTlMMie8zdOfuxCWzeuo1XfrkfaWkWdSQRSSAzuwC4kqD78DSCi1+fAgdFGEsEgKZ1c3j2wn048I4xHPOPsT/teDuY26Fr87q8eeXgiNKJVA+7rKCY2ZNAd+BN4GZ3n5HwVFKtmBmXHtietDRT5USkergS6A+Mc/ehZtYZraslSSSvfg2O6tmcV6ftuD5KZrrRR92+RBKuPIPkzwA6EhQon2hhLUmEoZ1zObBTEwBWrNsccRoRSbBN7r4JghZ6d58D5EecSWQH1x/Zhaz0n/+ZdOHgdhGkEaleyjMGJc3d64S3ujG3Ou5etzJCSvXx2mdLGPx/Y5hRqH6/IlXYYjOrD4wG3jOzV4GvI00kUkJu3RxO6teSzPSfWva3bnOOuPdjfv38NArmLqdoW3GECUWqrnKvJC9SGfZr34j6NTO55OnJvP6r/alfMyvqSCISZ+5+XHj3JjMbA9QD3o4wkkiprhjWkRcnLwacnIw07jm5Fx998R1vfL6UV6YW0qhWFkf3bM7w3nn0blUfM3VTFomHCq0kL5JojWpn88/T+7BszSZ+/fw0irWIo0iVYWb3m9l+sdvc/UN3f83dt0SVS6QsuXVzOLFvSww4oV8rjujRnL8c35OJfzyYB8/sy8C9GvLcxG84/p+fMOSvBdz97ly+/G5d1LFFUp4qKJJ0erduwA1Hd2XM3O+4f8z8qOOISPzMA/5qZl+Z2R1m1jvqQCK7csWwjnRskMYVwzr8uC07I53DujXjn6f3ZdIfD+aOE3rSskEN/j5mPsPu+pBj/j6WRz5ewHJNny+yW9TFS5LSGfu0YfLXq7j7/Xns3ao+B4QD6EUkdbn7vcC9ZtYGOAUYaWY1gOcIFgCeF2lAkVLk1s3huoE1yK2TU+r+ujmZnNSvFSf1a8WyNZv4z2dLGD2tkFvfmM2f35zNvu0bM7xXCw7r3oy6OZmVnF4kNZWrBcXMGpjZWWb2ipnNNLPXzexCM8tNdECpnsyMPx/fg065dbhy1FQKV2+MOpKIxIm7f+3u/+fuvQnW1xoBzI42lciea1o3hwsG78XrvxrM+785kMuGdmDRyg1c89Ln9Lv1fX75zGTemfktm4u2RR1VJKntsoJiZi8DLwO5wO/dvRvwSyAHeNrMChKaUKqtmlkZPHBmX4q2Ob98erK+0EWqCDPLMLNjzOwZ4C1gLnB8xLFE4qpDbm2uPjSfD68Zwsu/3JdT+7di/IKVXPzUZAbc9l+ufflzxi34XmMtRUpRni5e57n76tgN7r4I+Dvw93CqSJGEaNe4FneeuDfXvzKdr1ZsIL9ZnagjichuMrNDCFpMjgQmAKOAi9x9faTBRBLIzOjTugF9Wjfgj0d3Zez8Fbw6tZBXpy3huQnf0KJeDsf0asGIXnl0aa7VG0SgHBUUd18drvI7HMgLNxcCr7n77JKVl50xs8OBe4F04BF3v73E/t8AFwBFwHcElaOvw31nA38MD73V3Z8o7+tKaju8ezP279iY2tkaMiWS4q4FngWudvdVUYcRqWyZ6WkMzc9laH4uG7YU8d6sZYyeWsgjHy/kwQ8XkN+0DsN7t+DYvVvQskHNqOOKRGaXf/GZ2e8JrniNIrjiBdASeM7MRpWsZOzkedKB+4FDgMXARDN7zd1nxRw2Fejn7hvM7FLgDuBkM2sI3Aj0AxyYHJ6rAq6aqJ2dQXGxc/+Y+Qzr0pSuLXSVSSTVuPtBUWcQSRY1szIY3iuP4b3y+H7dZt6YvpTRUwu54+253PH2XAa0bcixvVpwVI/mNKilNcGkeinPJenzgW7uvjV2o5ndDcwEylVBAQYA8919QXj+KIJWmR8rKO4+Jub4ccAZ4f3DgPfcfWV47nvA4QQzv0g18cPGrTw9/ms2FW1TBUVERKqMRrWzOWtQW84a1JZF32/g1WmFjJ5WyB9Hz+Dm/8zkwE5NGN4rj4O7NKVGVnrUcUUSrjwVlGKgBfB1ie3Nw33llQd8E/N4MTBwJ8efTzB4sqxz80qeYGYXARcBNGnShIKCggrEi866detSImsy5Ly2bxr1spZSUPBtmcckQ87ySpWsyhlfqZJTRCpf60Y1+dWwjlx+UAdmLlnDq9MKee2zJbw/ezm1stI5rHszRvTKY9/2jchI13J2UjWVp4JyFfBfM/uCnyoJrYEOwOWJCGVmZxB05zqwIue5+0PAQwD5+fk+ZMiQ+IdLgIKCAlIhazLlnL98LVO+Xs1J/Vv9bF8y5dyVVMmqnPGVKjlFJDpmRve8enTPq8cfjujC+AXfM3paIW9N/5aXpxTSuHY2x+zdnBG98ujZsh5mFnVkkbgpzyD5t82sE0EXrdhB8hPdvSLzvhYCsX9Ntgy37cDMDgauBw50980x5w4pcW5BBV5bqpiHPlrAS5MXk9egBvt1aBx1HBEpJzNrABwDHAd0AhYCrwKvuvvyODz/TcCFBBOtAFzn7m+WctxXwFpgG1Dk7v329LVFEiU9zdi3Q2P27dCYW4Z3Z8yc5YyeVsgz4xbx2P++ol3jWgzv1YJmmyvSsUUkeZVrWiR3LyYYE7InJgIdzawdQYXjFOC02APMrDfwIHB4iYLqHeDPYcEGcCjBbDBSTd14TDemLlrNFc9N5fUr9qd5vRpRRxKRXQjX1WoAvEGwrtY8M2tNMB7xaTPLcvchcXipe9z9r+U4bqi7r4jD64lUmpzMdI7o0ZwjejTnhw1beWvGUkZPK+Te/36BOzy3cCwjeudxdM8WNKmTHXVckd1Snlm8WpfzuVa7+5qydrp7kZldTlDZSAdGuvtMM7sFmOTurwF3ArWBF8OmykXufqy7rzSzPxFUcgBu2T5gXqqnWtkZ/OuMvgz/x1h++cwUnr9oEFkZ6osrkuS0rpZIHNWrmckpA1pzyoDWLP1hI/e8/DHT1zg3/2cWf3p9Fvt1aMyIXnkc1r2ZpuqXlFKe39byrDfiwOPAkzs9KGhmf7PEthti7h+8k3NHAiPLkUWqiQ65tbnzxL355TNTuO2NWdw8vHvUkURkJ+K5rtYuXG5mZwGTKHvNFQfeNTMHHgzHMIqkrOb1anBkuyzuGDKYecvW8uq0YDHIq1/8jOtHT+fgLk0Z0SuPAzo10QU9SXrlqaBcAsxzd090GJGKOrJHcy7Yvx2PjF1I79YNGNH7Z5O7iUiSiOO6Wu8DzUrZdT3wL+BPBBWQPwF3AeeVcuz+7l5oZrnAe2Y2x90/KuW1NDtkAilnfMXm7J8N/QYY81fn8OmSIgpmL+X1z5dSKxMGNMtgUIsMOtRPIy2iwfWp+Jkms1TJWV7lqaC8BLQxs3nA58D07f/GY0CjyJ76/RGd+Wzxaq558TP+/OZslq/dTN64D7jmsHxVWESSS1zW1dpZa3uJ530YeL2M5ygM/11uZq8QTATzswqKZodMLOWMr9JyDiWYNWJLUTEff/Edo6ct4b1Z3zLmm03k1a/B8F7NGd4rj/xmdSLPmoyUMxrlmcWrh5llAz0JumetB44GupkZ7l7aVSyRSpOZnsYxPZsz8atVLF8bTPxWuHoj1748HUCVFJHkEa91tcpkZs3dfWn48DhgRinH1ALS3H1teP9Q4JZ4vL5IssrKSGNYl6YM69KUdZuLeHfmt4yetoQHPvySfxZ8SedmdRjRO49j925Bi/qaeEaiVd5ZvDYDE81snbv/avv2mFm1RCL14EcLf7Zt49Zt3PnOXFVQRJLHVSR+Xa07zKwXQRevr4CLAcysBfCIux8JNAVeCSdjyQCedfe34/T6IkmvdnYGx/dpyfF9WvLd2s28/vkSRk9bwu1vzeH/3p7DgLYNGdE7jyO7N6dezcyo40o1VNEpHXYYh1LGwEORSrdk9cadbnd3LWIlErE4rqu1s9c4s4ztS4Ajw/sLgL3j8Xoiqa5JnWzO3a8d5+7Xjq9WrOfVaUt4dVoh1748nRtfncmQ/CaM6J3HQZ1zyclMjzquVBPlmWb4fmBKeNNfeJKUWtSvQWEplZTtzdSXPTuFTVuLObhLU4Z1yaVp3ZzKjigixG1dLRFJgLaNa3HlwR25YlgHphf+wOipS/jP50t4d9Yy6mRncHj3Zozoncc+ezUiPU1/EkrilKcF5TOgF3AWUMfMZhEMZpwFzHL35xMXT6R8rjksn2tfns7GrT9dhK2Rmc41h+UD0LphLd6YvoQP5iyHV6Bny3oc3KUpB3dpSpfmddS6IlIJ4rWulogklpnRs2V9erasz/VHdeGTL1cweuoS3prxLS9OXkxunWyO2bsFI3rl0T2vrspQibvyDJLfYW54M2sJ9CAYNH80oAqKRG77OJM735lL4eqN5NWvscMsXn84ojO/PzyfecvW8f7sZbw/exn3vD+Pu9+bR4t6ORzctSkn9G1Jz5b1I3wXIlVe3NbVEpHKkZ5mDO7YhMEdm3Db1u68P3sZo6cu4clPv+LRsQvZq0ktRvTKY0SvPFo3qhl1XKkiKrysqLsvBhYDb8U/jsjuG9E7jxG988qcas/MyG9Wh/xmdbhsaAe+W7uZMXOW897sZbww6Rs65NamZ8v6rFy/hTFzlnNIt6bUzdHgQJE40rpaIiksJzOdo3u24OieLVi9YQtvTF/Kq9OWcPd7wQW/3q3rM6JXHkf3bE6j2tlRx5UUVp4xKGqSlyqpSZ1sTurfipP6t2LT1m0Uh38zfThvOVe/+BmvN9uf7nn1WLhiPcXutG9SO+LEIilP62qJVBH1a2Zx+sA2nD6wDYWrN/JaOLj+xtdmcsvrsxjcsTEjeuVxSNem1Mqu8PVwqebK8xujJnmp8mJnJhm+dx4dmtShW4u6ADz44ZeMmvgN7RrX4uAuuQzr0pR+bRqQkZ4WVVyRlKR1tUSqprz6Nbh0SHsuHdKeOd+uYfTUJbw2rZCrnp9Gjcx0Du3WlBG98rjjnTnMXrr2pxPffgOArs3r8uaVgyNKL8moPGNQhlZGEJFkkZZm9GhZ78fHvxrWka4t6vLerGU8/slXPPzxQurVyOSgzrkM65LLgZ2aUEddwUTKRetqiVRtnZvV5Q9H1OV3h+Uz8auVjJ62hDfDrmDZGWmkGRTHdPLMTDf6tNF/f9lRudrczKwzMJwd561/1d3nJCqYSLLIq1+Dswa15axBbVm7aSsff7GC92ctY8zc5bwytZDMdOPk/q24dUSPqKOKpBKtqyVShaWlGQP3asTAvRpx07Fd+XDudzw/8Rv+O2fH3pzpZlwxrENEKSVZlWcMyu+BU4FRwIRwc0tglJmNcvfbE5hPJKnUycnkyB7NObJHc4q2FTNl0Wr+O3vZj+utbC7axqkPjePSIR04pGvTiNOKJBetqyVSPWVnpHNot2Yc2q0Zv3vpM16avJhihzSDX/RtSW4drU0mOypPC8r5QDd33xq70czuJlgPRRUUqZYy0tMY0K4hA9o1/HHbinVbyExPIzM9+Ntr1pI1PPnpVxzcpSn7dWhMjSytwivVmtbVEqnmfntoPq9OW8LmomKKHZas2sjmom1kZ6h8lJ+Up4JSDLQAvi6xvXm4T0RCefVr8PzFg358/OV363j986WMmvgNOZlp7N+hMQd3acpBXXJ1xUiqHa2rJSK5dXM4sW9Lnhm/iD5tGjBm3ndc9ORkHjijry7iyY/KU0G5CvivmX0BfBNuaw10AC5PUC6RKuGYvVtwWLdmjF/4Pf+dvZz3Zi3j/dlB/9u9W9Wnfc4WmnVeQ35TrWYv1Y/W1RKpnq4Y1pEJ8xbzrzP68MHs5Vz7ynTOfmwCj57dT5POCFC+WbzeNrNOwAB2HCQ/0d23JTKcSFWQlZH24yq8Nx7TlbnL1vL+rGW8N3s5L3+xlQ8fHs+E6w8m3WDBd+to2aAmWRmawliqHq2rJSIQtKJcN7AGuXVyOGVAa2pmZ/Cb56dxxiPjeeK8AdSvmRV1RIlYeQbJp7l7MTBuF/tFZBfMjM7N6tK5WV0uP6gjo9/+gGad9iY9zXB3znx0Ar1a1ef+0/sAsHbTVl1NkqpE62qJyM8cu3cLamSmc9kzUzjloXE8df5AmtTRSvTVWXm6eL1nZiuA0cAb7r7GzGoChwPHEfQf7pWwhCJVWP2cNPbZqxEA7nDzsd2oWyOokCz9YSOD/28Mfds04JCuTRnWpSntGteKMq7IHtG6WiJSlkO6NmXkOf258MlJnPTgpzx9wUDywhkypfopTxevYWbWlWAdlDfMLItgcPw7wD3uPiXBGUWqhbQ04+CYqYnT04xLh7TnvVnLuPWN2dz6xmzaN6nFwV2acnDXpvRp3YD0NI1bkdSidbVEpCz7d2zMU+cP4NzHJnLSA5/yzAUDaasLc9VSuRZqdPdZBNNA/sXMarj7xsTGEpHcOjlcfWg+Vx+az+JVG/jv7OW8P3sZI/+3kAc/WkCDmpkM7ZzL7w7rTLN6mhFMkp/W1RKRXenXtiHPXbQPZz46nhMf/JSnzx9IfrM6UceSSlauCkoJ15pZBjANmObu8+IbSURKatmgJmfv25az9w1Ws/9o3gren72MsV+s4JbhwX/j1z9fwqr1WzhjnzaaEUySldbVEpFd6p5XjxcuHsTpj4zn5Ic+5anzBtKjZb2oY0klqvBUQe5+A3Av8ANwnJk9HPdUIlKmOjmZHNWzOfec3Itx1w6jdnZQQXlrxre8OHnxj5WTV6Yu5vPFqyku9ijjisTavq5WSVpXS0R20LFpHV68ZBC1sjI47eFxTPxqZdSRpBKVZxavtsBlQHtgJUHLyX/c/R2CcSgiEpG0mDEo95/WhzWbggvTm4u2cf0rM9iwZRtN62ZzUOemHNI1l33bNyYnUwthSWSuQutqiUg5tWlUixcvGcQZj4znzEfH8/BZ/RjcsUnUsaQSlKeL16vAfcDbwEiCKSCvMbPXgd+4++YE5hORCqgbTkmcnZHO2N8fRMHcYNzKa9MKeW7CImpkprN/x8Yc0qUpQzvnahpHqVRaV0tEKqpF/Ro8f/Egznx0POc/Pom/n9abw7o1izqWJFh5Kijp7v4ogJmtdPcLwzEovwYeAs5OZEAR2T0Na2VxfJ+WHN+nJZuLtjF+wUren73sxxXtzeC+U3pzzN4t2FbspBkauyIJpXW1RGR3NKmTzaiL9uGcxybyy2emcPdJezO8V96uT5SUVZ4xKO+b2famdwdw9yJ3vxMYlLBkIhI32RnpHNCpCbcM787Y3w/lzSsG8+uDO9G3TQMA/j1lMQfcOYZlazbtcN7oqYXsd/sHnPP2eva7/QNGTy2MIr5UHe+Z2fNmdqqZ1QUws5pmdryZPQVo2noRKVX9mlk8fcFA+rdtwFXPT+PZ8YuijiQJVJ4WlN8QzNw1Ccgzs4uADQSVk+8TGU5E4s/M6NqiLl1b1P1xW/N6OfRv25DcsMvXbW/MYuJXK5m5ZA1btwWD7AtXb+Tal6cDMKK3rlxJxWldLRHZE7WzM3j83AFc8vRkrntlOhu2FHHB4L2ijiUJUJ6FGouB28zsHuBgglXj6wMzgOsTGU5EKsfgjk12GHiYnpbG54t/oOQEYBu3buPOd+aqgiK7TetqicieyMlM56Ez+3HV81O59Y3ZrN+8jSuGdVAX5SqmXOugmFk2cDWwL7COoBn+XXdfnbhoIhKVPxzRmQc//LLUfUtW6+9JiRutqyUiFZaVkcZ9p/SmRuZ07nl/Huu3FHHtEZ1VSalCyrsOyp1AG+APwGKgETDSzM5IVDARiVaL+jVK3V6/ZmYlJ5GqSutqicjuykhP484TenLWoDY89NEC/jh6htb9qkLKu5L83sBwd19tZgPcfb+wVaUAeDph6UQkMtccls+1L09n49afZn9NM1i1YSvXvjydPx/XXVerpEK0rpaIxFNamnHzsd2omZXBAx9+yYYt27jzhJ5kpFd4HXJJMuWtoNzJT60tK8zsbmAOoDVQRKqo7eNM7nxnLoWrN5JXvwZXH9KRL1esJzsjXZUT2R2Vsq6Wmf2KoCK0DXjD3X9XyjGHE7TepAOPuPvt8XhtEalcZsYfjuhMnZwM7nxnLhu2FHHfqb3JztCixKmsXBUUd3895uGJwAlAM+C0RIQSkeQwonceI3rnUVBQwJAhQ362f+wXK1i2ZhO/6Nuy8sNJKkr4ulpmNpRglrC93X2zmeWWckw6cD9wCEG35Ylm9lo4gF9EUtBlQztQIzOdW16fxQVPTOKhM/tRI0uVlFRV4TYwd9/i7s+6+93uvqQi55rZ4WY218zmm9kfStl/gJlNMbMiMzuhxL5tZjYtvL1W0dwiEn/PTVzEAx9+yeYiLQIu5VIZ62pdCty+vTXG3ZeXcswAYL67L3D3LcAogkqNiKSw8/Zvxx2/6MnY+Ss4e+QE1m7aGnUk2U2V1kkv5orVEUBX4NRwPvxYi4BzgGdLeYqN7t4rvB2b0LAiUi73ndKbZy4YSHZGOus3F/HFsrVRR5Lk9hugXuy6WmZ2hpndT/zW1eoEDDaz8Wb2oZn1L+WYPOCbmMeLw20ikuJO6t+K+07pzZRFqzj9kfGsWr8l6kiyG8o7BiUefrxiBWBm269Y/dik7u5fhfuKKzGXiOym9DQjt24OEIxVGTVxETcf242T+rXSGBX5mXitq2Vm7xN0My7peoJyrSGwD9AfeMHM9nL33ZreJ1yc+CKAJk2aUFBQsDtPU+nWrVuXElmVM75SJSckNmsd4LJeWdw/7QeOued9fts/h/rZu3dNPlU+01TJWV6VWUEp7YrVwAqcnxNedSsiaL4fHcdsIrKHfjm0PV8sX8vv/z2dT7/8ntuO60Gt7Mr8ipFUEI91tdz94J08/6XAy2GFZEJ4wasx8F3MYYVAq5jHLcNtpb3WQwTjY8jPz/fSxmIlo7LGjSUb5YyvVMkJic86BBjQZwUXPjmJv31uPHPhQPLKmD5/Z1LlM02VnOWVSn89tHH3QjPbC/jAzKa7+w4ryelKV2IpZ/ylStby5jy/vZNLJqOnLWHcvKVc1juHVnUqb7rHqvZ5VlF3AjUJ1tU6h5/W1XrY3eMxbf1oYCgwxsw6AVnAihLHTAQ6mlk7gorJKWjSF5EqZ78OjXnq/AGc89hETnrgU56+YCDtGteKOpaUQ2VWUMp9xao07l4Y/rvAzAqA3sCXJY7Rla4EUs74S5WsFcl50FA46cvvuXLUVP40fjM3HdONUwdUTpevqvh5VkGJXldrJEGFZwawBTjb3d3MWhBMJ3ykuxeFg/XfIZhmeKS7z4zDa4tIkunbpiHPXbgPZ42cwIkPfMozFwwkv1mdqGPJLlTmSjY/XrEysyyCK1blmo3LzBqEBRhm1hjYj5ixKyKSXAa1b8SbVw5mYLuGXPfKdK4YNU2zqch2pa2rdTZxWlcrnGnyDHfv7u593P2DcPsSdz8y5rg33b2Tu7d399vi8doikpy659Xj+Yv2IT0NTn7oUz5fvDrqSLILlVZBcfciYPsVq9nAC+4+08xuMbNjAcysv5ktJlhr5UEz235Fqwswycw+A8YQjEFRBUUkiTWunc0T5w7gmsPyeePzJfyz4MtdnyRVnru/7u4rw4cnApOA2qiLlYgkUMemdXjx4n2pnZ3BaQ+PZ8LClbs+SSJTqWNQ3P1N4M0S226IuT+RoOtXyfM+AXokPKCIxFVamnHZ0A7ss1cjujQPmtRXrt9Cg5qZmuVLCNcgKW1aeRGRuGvdqCYvXjKI0x8Zz1kjx/PQmf04oFOTqGNJKSqzi5eIVFN92zSgZlYGG7ds48QHPuGGV9XdX0REKl/zejV44eJBtGtcmwuemMTbM76NOpKUQhUUEak02RlpnNivFYd3L20JCxERkcRrXDubURfuQ7e8ulz27BRembo46khSgiooIlJp0tKMSw5sz34dGgNw33+/YOTYhezmGnoiIiK7pV7NTJ46fyAD2jbkNy98xjPjv446ksRQBUVEIlFc7Ewv/IFbXp/FxU9N5ocNmuVLREQqT+3sDB47tz9D83O5/pUZPPzRgqgjSUgVFBGJRFqa8dCZffnjUV34YM5yjrzvY6YuWhV1LBERqUZyMtN54Iy+HNWjObe9OZt73punVv0koAqKiETGzLhg8F68eMkgAE584FMe+XiBCgcREak0WRlp3Hdqb07o25J7//sFt70xW+VQxFRBEZHI9W7dgDevGMxBnXO59Y3ZXPjkJFZv2BJ1LBERqSbS04w7ftGTswe14ZGxC7nulRlsK1YlJSqqoIhIUqhXM5MHz+zLjcd05cN533HkvR8zc8kPUccSEZFqIi3NuOnYbvxySHuem7CIq1+YpkpKRCp1oUYRkZ0xM87drx192zTg5v/MIrdOTtSRRESkGjEzfnd4Z2plZ3DnO3NZlJvO/gdsIzsjPepo1YpaUEQk6fRsWZ+XLhlEkzrZbCt27nxnDt+v2xx1LBERqSYuG9qBm47pypTl27jgiUls2FIUdaRqRRUUEUlKZgbA9MIfePijhYydvyLiRCIiUp2cs187zu+exf/mr+DskRNYs0nT4VcWVVBEJKn1alWfD357IMN75QEwc8kPFKtPsIiIVILBLTO579TeTF20mtMfHs+q9ZrApTKogiIiSa9lg5oAFK7eyC/+9QlnPzaBFeryJSIileDoni146Ky+zF22lpMf+pTlazZFHanKUwVFRFJGi3o53HhMNyYsXMmR937Mp19+H3UkERGpBg7q3JTHz+nP4lUbOenBT1m8akPUkao0VVBEJGWYGacOaM3oy/ajdk4Gpz8yjnvf/0LTQIqISMLt26ExT50/kO/Xb+GkBz5lwXfroo5UZamCIiIpp0vzuvzn8v0Z3iuPe96fx5mPjmf5WjW5i4hIYvVt04BRF+3D5qJiTnpwHHO+XRN1pCpJFRQRSUm1sjO4+6S9ueMXPZmyaBVH3juWWd9vizqWiIhUcd1a1OP5iweRngYnPziOz75ZHXWkKkcVFBFJWWbGSf1b8drl+1O/Zib3TdnE6g2aYUVERBKrQ25tXrx4X+rWyOD0R8YzfoHGRMaTKigikvI6Na3Da5fvx6/75lC/Zhbuzg8bNF+9iIgkTutGNXnx4n1pWjebsx+bwIfzvos6UpWhCoqIVAk1szLIb5gOwIuTF3PQXQUsXLE+4lQiIlKVNauXwwsXD2KvxrW54ImJvD1jadSRqgRVUESkyunTugFH9mhO64Y1o44iIiJVXKPa2Tx30T70yKvHZc9O5eUpi6OOlPJUQRGRKqdDbm3+NKI76WnGsjWbuPipSSz9YWPUsUREpIqqVyOTp84fyMB2DfnNC5/x9Livo46U0lRBEZEqbd6ytYz9YgVH3vsxY+YsjzqOiIhUUbWyMxh5Tn+Gdc7lj6Nn8OCHX0YdKWWpgiIiVdrgjk34z6/2p1m9Gpz7+ET+8uZstm4rjjqWiIhUQTmZ6TxwZl+O6tmcv7w1h7vfm4e7FhOuKFVQRKTK26tJbV755b6cPrA1D360gJMf/JTC1eryJSIi8ZeZnsZ9p/TmpH4tue+/X3DrG7NVSakgVVBEpFrIyUzntuN68I/TejNv2TqOvPdj3pu1LOpYIiJSBaWnGbcf35Nz9m3Lo2MXct0r09lWrEpKeamCIiLVytE9W/D6r/anVcMaXPjkJP785uyoI0mcmdmvzGyOmc00szvKOOYrM5tuZtPMbFJlZxSRqi8tzbjxmK5cNrQ9z034ht+8ME1djMspI+oAIiKVrW3jWvz70n358xuzqZWlr8GqxMyGAsOBvd19s5nl7uTwoe6+opKiiUg1ZGZcc1hnamVncMfbc9mwZRt/P7U3OZnpUUdLaiqZRaRays5I5+bh3X/sF/y/+StYu2krh3dvHnEy2UOXAre7+2YAd9fUbSISuV8O6UDt7AxueHUmFz45iQfP7EtNXSArk7p4iUi1ZmYAjBy7kLvfm6fm99TXCRhsZuPN7EMz61/GcQ68a2aTzeyiSswnItXUWYPacucJPfnf/BWc9egE1mzaGnWkpKWqm4gI8K8z+vL9+s1kpqexfnMR36/bQutGWok+GZnZ+0CzUnZdT1CuNQT2AfoDL5jZXv7zKXT2d/fCsAvYe2Y2x90/KuW1LgIuAmjSpAkFBQVxfCeJs27dupTIqpzxlSo5IXWyxjtnE+CSvbN58LNVHHP3+/y2Xw51smyPnzdVPs/yUgVFRATIykijeb0aAPzlrdm8OnUJt/+iJ0f1VJevZOPuB5e1z8wuBV4OKyQTzKwYaAx8V+I5CsN/l5vZK8AA4GcVFHd/CHgIID8/34cMGRKvt5FQBQUFpEJW5YyvVMkJqZM1ETmHAP17LeeSpydz34w0nrlgILl1c/boOVPl8ywvdfESESnhkgPb0z63Npc9O4X/N3oGm7ZuizqSlN9oYCiAmXUCsoAdBsKbWS0zq7P9PnAoMKNyY4pIdTa0cy6PndufwtUbOfHBT1m8akPUkZKKKigiIiW0bFCTFy4exIWD2/HUuK85/p+fsHDF+qhjSfmMBPYysxnAKOBsd3cza2Fmb4bHNAXGmtlnwATgDXd/O6K8IlJN7du+MU9fMJBV67dw4gOfsuC7dVFHShqqoIiIlCIrI43rj+rKo2f3Y8kPGzn6vo95dVph1LFkF9x9i7uf4e7d3b2Pu38Qbl/i7keG9xe4+97hrZu73xZtahGprvq0bsCoiwaxpaiYkx78lNlL10QdKSmogiIishPDujTlzSsG06V5Xa4cNY1rX/5cXb5ERCRuuraoy/MXDyIjLY1THhrHtG9WRx0pcpVaQTGzw81srpnNN7M/lLL/ADObYmZFZnZCiX1nm9kX4e3sykstItVdi/o1eO6ifbh0SLAa8D8Lvow6koiIVCEdcmvz4iWDqFcjk9MfHse4Bd9HHSlSlVZBMbN04H7gCKArcKqZdS1x2CLgHODZEuc2BG4EBhLMtHKjmTVIdGYRke0y09P4/eGdefaCgVxy4F4AmsNeRETiplXDmrx4ySCa16/B2SMnUDC3+q4zW5ktKAOA+WHf3y0EgxeHxx7g7l+5++dAyZXSDgPec/eV7r4KeA84vDJCi4jE2rdDY2pmZbBhSxHH3f8//vLW7KgjiYhIFdG0bg7PX7QPHXJrc+GTk3hr+tKoI0WiMtdByQO+iXm8mKBFZHfPzSt5kBbUSizljL9UyaqcP7et2Oladyv1NiyhoGBZhc5Nlc9TREQqX6Pa2Tx74T6c9/hELnt2CneesDe/6Nsy6liVqkot1KgFtRJLOeMvVbIqZ+mGHfTT/fvHzCe3TjYn9mu1y/NS5fMUEZFo1KuRyZPnDeCipyZx9YufsWFLEWcOaht1rEpTmV28CoHYkrtluC3R54qIJNS2YufTL7/nmpc+5zcvTGP95qKoI4mISIqrlZ3Bo2f35+Auufy/V2fywIfVZ4KWyqygTAQ6mlk7M8sCTgFeK+e57wCHmlmDcHD8oeE2EZHIpacZT5w3gCuHdeSVqYUc+4+xzPlWc9mLiMieyclM519n9OXons25/a053PXuXNw96lgJV2kVFHcvAi4nqFjMBl5w95lmdouZHQtgZv3NbDFwIvCgmc0Mz10J/ImgkjMRuCXcJiKSFNLTjF8f0olnzh/Imk1FDP/H/xg1YVG1KEhERCRxMtPTuPeU3pzcrxV//2A+f3p9dpUvWyp1DIq7vwm8WWLbDTH3JxJ03yrt3JHAyIQGFBHZQ/t2aMybVwzm189P4w8vT+fTBd9z23E9qJ1dpYb8iYhIJUpPM/5yfA9qZqcz8n8L2bCliNuO60F6mkUdLSG0kryISJw1qZPNE+cN4OpDOvGfz5Zw7N/HMn/52qhjiYhICktLM244uiu/OqgDoyZ+w1XPT2PrtpIrc1QNuqQnIpIA6WnGr4Z1pH+7htz6xizq1chi9NRC7nxnLoWrN5I37gOuOSyfEb1/NmO6iIhIqcyMqw/Np1Z2Bre/NYf/fLbkp51vvwFA1+Z1efPKwREljA+1oIiIJNA+ezXiP5fvz//mr+Dalz+ncPVGAApXb+Tal6czeqomJBQRkYq55MD29G/b4GfbM9ONPm1+vj3VqIIiIpJgZsad78xl49Ydm+I3bt3Gne/MjSiViIiksvtP60NGiTEo6WZcMaxDRIniRxUUEZFKsCRsOSnvdhERkZ3JrZvDKf1b/ThQPjPdOKFfK3Lr5EScbM+pgiIiUgla1K9Roe0iIiK7csWwjj+2olSV1hNQBUVEpFJcc1g+NTLTd9hWIzOdaw7LjyiRiIikuty6OZzYtyUGVab1BFRBERGpFCN65/GX43uQF7aY5NWvwV+O76FZvEREZI9cMawjHRukVZnWE9A0wyIilWZE7zxG9M6joKCAIUOGRB1HRESqgNy6OVw3sEaVaT0BtaCIiIiIiEgSUQVFRERERESShiooIiIiIiKSNFRBERERERGRpKEKioiIiIiIJA1z96gzJISZrQXmRp2jnBoDK6IOUQ7KGX+pklU54ytVcgLku3udqEMkA5UrCaGc8ZUqOSF1sipnfJWrTKnK0wzPdfd+UYcoDzOblApZlTP+UiWrcsZXquSEIGvUGZKIypU4U874SpWckDpZlTO+ylumqIuXiIiIiIgkDVVQREREREQkaVTlCspDUQeogFTJqpzxlypZlTO+UiUnpFbWREulzyJVsipnfKVKTkidrMoZX+XKWWUHyYuIiIiISOqpyi0oIiIiIiKSYlRBERERERGRpFHlKihmNtLMlpvZjKiz7IyZtTKzMWY2y8xmmtmVUWcqi5nlmNkEM/sszHpz1Jl2xszSzWyqmb0edZaymNlXZjbdzKYl8zSuZlbfzF4yszlmNtvMBkWdqTRmlh9+lttva8zsqqhzlcbMfh3+P5phZs+ZWU7UmUpjZleGGWcm62dZWVSuxJfKlMRQuRJfKlfiryLlSpUbg2JmBwDrgCfdvXvUecpiZs2B5u4+xczqAJOBEe4+K+JoP2NmBtRy93VmlgmMBa5093ERRyuVmf0G6AfUdfejo85TGjP7Cujn7km9qJKZPQF87O6PmFkWUNPdV0cca6fMLB0oBAa6+9dR54llZnkE/3+6uvtGM3sBeNPdH4822Y7MrDswChgAbAHeBi5x9/mRBouIypX4UpmSGCpXEkflyp6raLlS5VpQ3P0jYGXUOXbF3Ze6+5Tw/lpgNpAXbarSeWBd+DAzvCVlzdbMWgJHAY9EnSXVmVk94ADgUQB335LshUhoGPBlshUiMTKAGmaWAdQElkScpzRdgPHuvsHdi4APgeMjzhQZlSvxpTKl+lK5kjBVrlypchWUVGRmbYHewPiIo5QpbOKeBiwH3nP3ZM36N+B3QHHEOXbFgXfNbLKZXRR1mDK0A74DHgu7NzxiZrWiDlUOpwDPRR2iNO5eCPwVWAQsBX5w93ejTVWqGcBgM2tkZjWBI4FWEWeSCkj2ckVlSkKoXEkclSt7rkLliiooETOz2sC/gavcfU3Uecri7tvcvRfQEhgQNtUlFTM7Glju7pOjzlIO+7t7H+AI4LKwC0myyQD6AP9y997AeuAP0UbaubC7wLHAi1FnKY2ZNQCGExTSLYBaZnZGtKl+zt1nA/8HvEvQDD8N2BZlJim/VChXVKYkhMqVBFC5Eh8VLVdUQYlQ2Pf238Az7v5y1HnKI2yKHQMcHnGU0uwHHBv2wx0FHGRmT0cbqXThFQ/cfTnwCkGfzGSzGFgcc2XzJYKCJZkdAUxx92VRBynDwcBCd//O3bcCLwP7RpypVO7+qLv3dfcDgFXAvKgzya6lWrmiMiV+VK4kjMqVOKlIuaIKSkTCQYKPArPd/e6o8+yMmTUxs/rh/RrAIcCcSEOVwt2vdfeW7t6WoDn2A3dPuqsIZlYrHMBK2LR9KEHTZ1Jx92+Bb8wsP9w0DEiqwbalOJUkbYYPLQL2MbOa4XfAMIJxAknHzHLDf1sT9BN+NtpEsiupUq6oTIk/lSsJpXIlTipSrmRUVqjKYmbPAUOAxma2GLjR3R+NNlWp9gPOBKaH/XABrnP3N6OLVKbmwBPhLBZpwAvuntTTLSa5psArwfcIGcCz7v52tJHK9CvgmbCJewFwbsR5yhQWyocAF0edpSzuPt7MXgKmAEXAVOChaFOV6d9m1gjYClyWIgNZE0LlStypTIk/lSsJoHIl7spdrlS5aYZFRERERCR1qYuXiIiIiIgkDVVQREREREQkaaiCIiIiIiIiSUMVFBERERERSRqqoIiIiIiISNJQBUWkgsyspZm9amZfmNkCM/uHmWWX47x1ZWy/xcwODu9fZWY1d/E8h5nZzWbW0Mze2r13ISIiyULlisiOVEERqYBwEaSXgdHu3hHoCNQA7tjd53T3G9z9/fDhVcBOCxJgMPBR+O/Y3X1dERGJnsoVkZ/TOigiFWBmwwgWaTsgZltd4GugFXAC0M/dLw/3vQ781d0LwitdDxOs8PstcIq7f2dmjwOvAy2AvwJzgRXuPrTEa58MXAvsFb5eU2ANMMvdj03cuxYRkURRuSLyc2pBEamYbsDk2A3uvgb4Cuiwi3NrAZPcvRvwIXBjiee5D1gCDC1ZiIT7nwd6AzPcvQcwHeitQkREJKWpXBEpQRUUkcpTDDwf3n8a2H83nqMTsCC8X8vd18YjmIiIpCSVK1IlqYIiUjGzgL6xG8Km+GYETehF7Pj/Kmcnz1Wh/pVmNgl4BxhiZrOAfDObZmaDK/I8IiKSVFSuiJSgCopIxfwXqGlmZwGYWTpwF/APd99I0CTfy8zSzKwVMCDm3DSCvsQAp1H6QMS1QJ3SXtjd+wFvAMMJBk9e7+693P3jPX5XIiISFZUrIiWogiJSAR7MKnEccIKZfQF8DxS7+23hIf8DFhJcEbsPmBJz+npggJnNAA4CbinlJR4C3jazMWVE6ANMI5hp5cM9ezciIhI1lSsiP6dZvET2gJntCzwHHOfuU3Z1vIiIyM6oXBFRBUVERERERJKIuniJiIiIiEjSUAVFRERERESShiooIiIiIiKSNFRBERERERGRpKEKioiIiIiIJA1VUEREREREJGn8f8pM5/Sowfe5AAAAAElFTkSuQmCC" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "It can be seen that as the number of qubits increases, the maximum value of the gradient of all parameters obtained by multiple sampling is constantly close to 0, and the variance is also decreasing." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "To further see how the gradient changes as the number of quantum bits increases, we might as well visualize the influence of choosing different qubits on the optimization landscape:\n", - "\n", - "![BP-fig-qubit_landscape_compare](./figures/BP-fig-qubit_landscape_compare.png \"(a) Optimization landscape sampled for 2,4,and 6 qubits from left to right in different z-axis scale. (b) Same landscape in a fixed z-axis scale.\")\n", - "\n", - "$\\theta_1$ and $\\theta_2$ are the first two circuit parameters, and the remaining parameters are all fixed to $\\pi$. This way, it helps us visualize the shape of this high-dimensional manifold. Unsurprisingly, the landscape becomes more flatter as $n$ increases. **Notice the rapidly decreasing scale in the $z$-axis**. Compared with the 2-qubit case, the optimized landscape of 6 qubits is very flat.\n", - "\n", - "Note that only when the network structure and loss function meet certain conditions, i.e. unitary 2-design (see paper [1]), this effect will appear.\n" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "### Application II: Quantum encoded classical data\n", - "\n", - "Supervised learning is one of the important applications of quantum neural networks. However, the barren plateau phenomenon limits the performance of quantum variational algorithms in such problems. Therefore, how to design more efficient circuits and loss functions to avoid the barren plateau phenomenon is one of the important research directions of quantum neural networks at present.\n", - "\n", - "In fact, it has been shown that using Renyi divergence as a loss function in the training of generative training can effectively avoid the barren plateau phenomenon [[3]](https://arxiv.org/abs/2106.09567). \n", - "The gradient analysis tools allow us to quickly analyze the information related to the gradient in a supervised learning model, which can facilitate researchers to try to explore different quantum circuits and loss functions." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "Here, we present an example using the dataset provided by [Encoding Classical Data into Quantum States](./tutorial/machine_learning/DataEncoding_EN.ipynb)." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### Paddle Quantum Implement\n", - "\n", - "Firstly, import the packages needed for the problem." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 14, - "source": [ - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle import matmul, transpose, reshape\n", - "from paddle_quantum.utils import pauli_str_to_matrix\n", - "import paddle.fluid as fluid\n", - "import paddle.fluid.layers as layers\n", - "\n", - "from paddle_quantum.dataset import Iris\n", - "from paddle_quantum.gradtool import random_sample_supervised, plot_supervised_loss_grad" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### Define Quantum Circuits\n", - "\n", - "Next, construct the parameterized quantum circuit $U(\\theta)$." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 15, - "source": [ - "def U_theta(theta, n, depth):\n", - " \"\"\"\n", - " :param theta: dimension: [n, depth + 3]\n", - " :param n: the number of qubits\n", - " :param depth: circuit depth\n", - " :return: U_theta\n", - " \"\"\"\n", - " # Initialize the quantum circuit\n", - " cir = UAnsatz(n)\n", - "\n", - " # rotation gates \n", - " for i in range(n):\n", - " cir.rz(theta[i][0], i)\n", - " cir.ry(theta[i][1], i)\n", - " cir.rz(theta[i][2], i)\n", - "\n", - " # default depth = 1\n", - " # Build adjacent CNOT gates and RY rotation gates \n", - " for d in range(3, depth + 3):\n", - " for i in range(n - 1):\n", - " cir.cnot([i, i + 1])\n", - " cir.cnot([n - 1, 0])\n", - " for i in range(n):\n", - " cir.ry(theta[i][d], i)\n", - " return cir" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### Define Objective Function\n", - "\n", - "Here the objective function ``loss_fun`` is defined, and the second parameter is still the variable ``*args``." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 16, - "source": [ - "def loss_func(cir,*args):\n", - " # input the quantum states and training labels\n", - " state_in = args[0]\n", - " label = args[1]\n", - " # Convert Numpy array to tensor\n", - " label_pp = reshape(paddle.to_tensor(label),(-1,1))\n", - " \n", - " Utheta = cir.U\n", - " \n", - " # Since Utheta is learned, we use row vector operations here to speed up the training without affecting the results\n", - " state_out = matmul(state_in,Utheta)\n", - " \n", - " # Measure the expected value of the Pauli Z operator \n", - " Ob = paddle.to_tensor(pauli_str_to_matrix([[1.0, 'z0']], qubit_num))\n", - " E_Z = matmul(matmul(state_out, Ob), transpose(paddle.conj(state_out), perm=[0, 2, 1]))\n", - "\n", - " # Mapping into label \n", - " state_predict = paddle.real(E_Z)[:, 0] * 0.5 + 0.5\n", - " loss = paddle.mean((state_predict - label_pp) ** 2) # mean-squared error\n", - " \n", - " return loss\n", - " " - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "#### Define the dataset\n", - "\n", - "Here, we use [Iris dataset](./tutorial/machine_learning/DataEncoding_EN.ipynb) to do the experiment." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 17, - "source": [ - "time_start = time.time()\n", - "# Hyper parameter settings\n", - "test_rate = 0.2\n", - "qubit_num = 2 # Don't give too many qubits, otherwise it will be seriously overfitted\n", - "depth = 1\n", - "lr = 0.1\n", - "BATCH = 4\n", - "EPOCH = 4\n", - "SAMPLE = 300\n", - "\n", - "# dataset\n", - "iris = Iris(encoding='amplitude_encoding', num_qubits=qubit_num, test_rate=test_rate,classes=[0,1], return_state=True)\n", - "\n", - "# Get inputs and labels for the dataset\n", - "train_x, train_y = iris.train_x, iris.train_y # train_x, test_x here is paddle.tensor type, train_y，test_y here is ndarray type.\n", - "test_x, test_y = iris.test_x, iris.test_y\n", - "testing_data_num = len(test_y)\n", - "training_data_num = len(train_y)\n", - "\n", - "\n", - "# Creating trainable parameters for circuits\n", - "theta = layers.create_parameter(shape=[qubit_num,depth+3], default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype='float64',is_bias=False)\n", - "# Creating Circuits\n", - "circuit = U_theta(theta, qubit_num, depth)\n", - "\n", - "print(circuit)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "--Rz(3.338)----Ry(2.554)----Rz(1.318)----*----x----Ry(4.679)--\n", - " | | \n", - "--Rz(0.246)----Ry(3.961)----Rz(5.514)----x----*----Ry(3.248)--\n", - " \n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "Let's look at the variation of the loss function values and gradients during training with EPOCH=4 and BATCH=4." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 18, - "source": [ - "loss,grad = plot_supervised_loss_grad(circuit, loss_func, N=qubit_num, EPOCH = EPOCH, LR = lr,BATCH = BATCH, TRAIN_X=train_x, TRAIN_Y=train_y)" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAEGCAYAAAB/+QKOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAA5EklEQVR4nO2deXhU5dn/vzchEGQRCMiSKIuigCA7IlFsBZdWBXF5lWqLttVq1dbqz9atan21ttLX2latWqvWqqBVa6lQUagKBkHCpixSA6IERHbZlyT37497ns7JyZktM5OZTL6f68p15qxzZyY533Mvz/2IqoIQQgjx0yTTBhBCCMlOKBCEEEICoUAQQggJhAJBCCEkEAoEIYSQQJpm2oBU0aFDB+3evXumzSCEkAbFwoULt6hqx6B9OSMQ3bt3R1lZWabNIISQBoWIfBZpH0NMhBBCAqFAEEIICYQCQQghJJCcyUEQQkgqOHToECoqKrB///5Mm5JSCgoKUFxcjPz8/LjPoUAQQoiHiooKtG7dGt27d4eIZNqclKCq2Lp1KyoqKtCjR4+4z2OIiRBCPOzfvx+FhYU5Iw4AICIoLCxM2CuiQBBCiI9cEgdHXX4nCkSyLFsGzJmTaSsIISTlMAeRLHfeCaxaBSxfnmlLCCE5QqtWrbB79+5Mm0EPIml27AB27sy0FYQQknIoEMmycyeQBUpPCMk9VBU333wz+vXrh/79++PFF18EAHzxxRcYNWoUBg4ciH79+mHOnDmoqqrC5Zdf/t9jf/vb3yb9/gwxJcuuXSYQqkAOJrYIadTccAOwZElqrzlwIPDQQ3Ed+uqrr2LJkiVYunQptmzZgmHDhmHUqFF44YUXcOaZZ+L2229HVVUV9u7diyVLlmD9+vVYtmwZAGDHjh1Jm5pWD0JEzhKRVSJSLiK3BOy/WkQ+EpElIvKeiPT17Ls1dN4qETkznXYmxc6dQGUlcPBgpi0hhOQY7733HiZMmIC8vDx06tQJp556KhYsWIBhw4bh6aefxt13342PPvoIrVu3Rs+ePbFmzRpcf/31eOONN9CmTZuk3z9tHoSI5AF4BMDpACoALBCRqaq6wnPYC6r6WOj4sQAeBHBWSCguAXA8gK4AZorIsapalS5764zLP+zeDTRvnllbCCGpJc4n/fpm1KhRmD17NqZNm4bLL78cN954I77zne9g6dKlmDFjBh577DG89NJLeOqpp5J6n3R6EMMBlKvqGlU9CGAKgHHeA1TVm91tCUBDr8cBmKKqB1T1UwDloetlF1VVwN699pp5CEJIijnllFPw4osvoqqqCps3b8bs2bMxfPhwfPbZZ+jUqROuvPJKfP/738eiRYuwZcsWVFdX44ILLsC9996LRYsWJf3+6cxBFAFY51mvAHCi/yARuRbAjQCaATjNc+4837lFAedeBeAqADjqqKNSYnRC7NoVfk2BIISkmPHjx+P999/HgAEDICJ44IEH0LlzZ/zlL3/BpEmTkJ+fj1atWuHZZ5/F+vXrccUVV6C6uhoAcP/99yf9/hlPUqvqIwAeEZFvAbgDwMQEzn0CwBMAMHToUI1xeOqhQBBC0oAbAyEimDRpEiZNmlRj/8SJEzFxYu1bZSq8Bi/pDDGtB3CkZ704tC0SUwCcV8dzM4N3/AMFghCSY6RTIBYA6CUiPUSkGSzpPNV7gIj08qyeDeCT0OupAC4RkeYi0gNALwAfpNHWukGBIITkMGkLMalqpYhcB2AGgDwAT6nqchG5B0CZqk4FcJ2IjAFwCMB2hMJLoeNeArACQCWAa7OygskbYvK+JoQ0aFQ15xr2qSYehU9rDkJVpwOY7tt2p+f1j6Ocex+A+9JnXQqgB0FIzlFQUICtW7fmVMtvNx9EQUFBQudlPEndoGGSmpCco7i4GBUVFdi8eXOmTUkpbka5RKBAJAM9CEJyjvz8/IRmXctl2KwvGZxANGtGgSCE5Bz0IJJh1y5rr9G2LQWCEJJz0INIhp07gTZtgFatKBCEkJyDApEMu3ZRIAghOQtDTMmwcyfQujXQsiUFghCSc9CDSAZ6EISQHIYCkQzOg6BAEEJyEApEMjBJTQjJYZiDSIZdu8yDyM+nQBBCcg4KRDI4DyIvjwJBCMk5KBB15dAhYP9+EwgR4MAB25afn2nLCCEkJTAHUVdcoz6XpAaAPXsyZw8hhKQYCkRdcX2YXJIaYJiJEJJTMMRUV7weRFVoLiMKBCEkh6BA1BWvB3HokL2mQBBCcggKRF1xHkSbNpagBigQhJCcggJRV5wH4cZBABQIQkhOQYGoK14PomnoY6RAEEJyCFYx+dmxA5gwAdiyJfpxXg+CVUyEkByEAuGntBSYMgV4773ox1EgCCE5DgXCT0WFLbdujX7crl1AixYWXqJAEEJyEAqEn3XrbBlLIFwfJsBEoqAgnJcghJAcgALhJxEPwgkEwJbfhJCcgwLhJ16BcJMFOSgQhJAcgwLhx4WY4qliogdBCMlhKBBeVBMLMdGDIITkMBQILzt2AHv32utEktQABYIQknNQILy48FL79kxSE0IaPRQILy68NGAAsG2bhZwiwSQ1ISTHoUB48QpEZWV4tLSfAweAgwfpQRBCchoKhJd164AmTYB+/Ww9UpjJO1mQgwJBCMkxKBBeKiqArl2BI46w9UgC4Z0syNGqlSW43exyhBDSwKFAeKmoAIqLgcJCW0/UgwDCVVCEENLASatAiMhZIrJKRMpF5JaA/TeKyAoR+VBEZolIN8++KhFZEvqZmk47/8u6dfEJRCQPAmCYiRCSM6RNIEQkD8AjAL4BoC+ACSLS13fYYgBDVfUEAC8DeMCzb5+qDgz9jE2Xnf/FDZI78siwQEQaTe2dLMhBgSCE5Bjp9CCGAyhX1TWqehDAFADjvAeo6tuq6mIy8wAUp9Ge6Hz1FbBnj3kQ7doBIrE9iKAQEwWCEJIjpFMgigCs86xXhLZF4nsA/uVZLxCRMhGZJyLnBZ0gIleFjinbvHlzcta6QXLFxUBenokEQ0yEkEZMVsxJLSKXARgK4FTP5m6qul5EegL4t4h8pKqrveep6hMAngCAoUOHRhnVFgduDMSRR9qysLBuSWoKBCEkR0inB7EewJGe9eLQthqIyBgAtwMYq6oH3HZVXR9argHwDoBBabQ1LBDFoShXNIFwHoQTBe9rCgQhJEdIp0AsANBLRHqISDMAlwCoUY0kIoMAPA4Th02e7e1EpHnodQcAJQBWpNHW8CC5Ll1sPZYH0aqVhaIcFAhCSI6RNoFQ1UoA1wGYAWAlgJdUdbmI3CMirippEoBWAP7mK2ftA6BMRJYCeBvAr1Q1vQJRUWHi0DQUdYvlQXjDSwAFghCSc6Q1B6Gq0wFM92270/N6TITz5gLon07bauEGyTlieRDeBDVAgSCE5BwcSe1wg+QchYVW9rp/f+1jgzyI5s2B/HwKBCEkZ6BAADZILkgggGAvwj9ZkIMN+wghOQQFAggPkjvSU3TVoYMtgwTCP92ogwJBCMkhKBBA7RJXoO4ehBsjQQghDRwKBJC4QAQlqQF6EISQnIICAYTbbHhDTJEEQjU4SQ1QIAghOQUFAjAPQiQ8SA6ILBD799t0pPQgCCE5DgUCMIHo3NnKVB0FBcBhh9UWiKA+TA4KBCEkh6BAABZi8oaXHEGD5YI6uTooEISQHIICAdQeRe0IEoigyYIcFAhCSA5BgQAiC0SHDpE9iGghJk2u8zghhGQDFIivvjKvIFKIyT/taKwQkyqwb1/q7SSEkHqGAlFdDdxyC1BSUntftBBTJA8CYJiJEJITZMWMchmlXTvg/vuD9xUWAtu3A1VV4bkfYnkQgAnEEUek3lZCCKlH6EFEo7DQQkY7doS3xUpSA/QgCCE5AQUiGkGD5bZvt0F1LVvWPp4CQQjJISgQ0QgSiDlzgBNOMJHwQ4EghOQQFIho+AViyxZg7lxg7Njg4ykQhJAcggIRDb9ATJ9uVU8UCEJII4ACEQ3/pEH//Kc19Bs8OPh4CgQhJIegQESjTRugaVMLLR04ALzxBnDuuUCTCB9bXQTi4MHk7SSEkDRAgYiGCNC+vXkQ775rN/5zz418fIsWJh7xCsTixSYqH3+cGnsJISSFUCBi4UZTT51qAjB6dORjRRJr2DdrFnDoELBiRWpsJYSQFMKR1LFwArFgAXD66SYS0UhEIMrKbPnll8nZSAghaYAeRCwKC00cPv88cvWSl1atzCPYsCH2sU4gNm5MzkZCCEkDFIhYFBYCe/bY67PPjn38mDFAaal1hz3nHODVV62Xk5/t24HVq+01PQhCSBZCgYiFGwtx4ok2LWksHnkE+M9/rEPs4sXABRcAv/xl7eMWLgy/pkAQQrIQCkQs3FiIeMJLjl69gPvus7BUSQnwyiu1j3HhpUGD6kcgVq4Eune36VUJISQOKBCxcDPNjRuX+Ll5eRaWWrq0dp6hrAw4+migd+/6EYglS4DPPrNyXUIIiQMKRCwuushCRccfX7fzzzjDljNn1txeVgYMHQp06lQ/ArFtmy2XLEn/exFCcgIKRCzy84GBA+t+/qBBFqZ6883wti1b7GneCcSePeFEeLpwArF0aXrfhxCSM1Ag0k2TJjZ+4s03rdEfEE5QO4EA0u9FeD0I1fS+FyEkJ6BA1AdnnGEC8NFHtu4S1IMH179AbNkS3xgNQkijhwJRH5x+ui1dmKmsDDj2WGsGWJ8C4ZoMMg9BCImDuARCRFqKSJPQ62NFZKyI5Mdx3lkiskpEykXkloD9N4rIChH5UERmiUg3z76JIvJJ6GdiIr9U1lFUBPTrV1Mghg611/UpEEOG2GsKBCEkDuL1IGYDKBCRIgBvAvg2gGeinSAieQAeAfANAH0BTBCRvr7DFgMYqqonAHgZwAOhc9sDuAvAiQCGA7hLRNrFaWt2csYZNl3pp58CFRVhgTjiCFvWh0B0726ltRQIQkgcxCsQoqp7AZwP4FFVvQhArLrP4QDKVXWNqh4EMAVAjcEEqvp26LoAMA9AaNABzgTwlqpuU9XtAN4CcFactmYnZ5xhc0o8+KCtO4Fo1gxo165+BKJ9e6vIYiUTISQO4hYIETkJwKUApoW25cU4pwiAd9huRWhbJL4H4F91PDf7GTUKaN4cePJJaws+aFB4X7rHQqiGBWLAAKC8HNi1K33vRwjJCeIViBsA3Arg76q6XER6Ang7VUaIyGUAhgKYlOB5V4lImYiUbd68OVXmpIcWLUwk9u8H+vQJzz4HpF8gdu8GKivDHoRquKKKEEIiEJdAqOq7qjpWVX8dSlZvUdUfxThtPYAjPevFoW01EJExAG4HMFZVDyRyrqo+oapDVXVox44d4/lVMosbVe3CS45OndLb8tuVuDqBAJiHIITEJN4qphdEpI2ItASwDMAKEbk5xmkLAPQSkR4i0gzAJQCm+q47CMDjMHHY5Nk1A8AZItIulJw+I7StYXNWKI1y4ok1t6fbg9i+3Zbt2llvqfbtKRCEkJjEG2Lqq6o7AZwHyxP0gFUyRURVKwFcB7uxrwTwUig8dY+IuNaokwC0AvA3EVkiIlND524D8L8wkVkA4J7QtoZNv37AO+8A3/1uze2dO1tOYN++9Lyv14MQMS+CAkEIiUG8U47mh8Y9nAfgYVU9JCIx+zWo6nQA033b7vS8HhPl3KcAPBWnfQ2HU0+tvc07FqJ799S/p1cgABOIRx+1vERTzjpLCAkmXg/icQBrAbQEMDs0oG1nuoxqdKR7sJxfIAYMsGT5J5+k5/0IITlBvEnq36tqkap+U43PAHw9zbY1HupbIJioJoTEQbxJ6sNF5EFXUioi/wfzJkgqiCQQa9cC06fXOjwi8+aFE9Jetm0DCgqs1BawSYqaNaNAEEKiEm+I6SkAuwD8T+hnJ4Cn02VUoyNSu4277wbGjwcOHYp9jQULgJEjgYceqr3PDZJzNGtmEyBRIAghUYhXII5W1btCbTPWqOovAPRMp2GNioIC4PDDawvE/PnAwYPAmjXRz6+qAq65xgbArV1be79fIAC23CCExCRegdgnIie7FREpAZCmmsxGin8sxFdfAR9/bK9Xrox+7hNP2CRELVoA62uNJ4wsEF9+aY0DCSEkgHhrHK8G8KyIHB5a3w6gYbfgzjb8AuEmFQLCQhHEpk3AbbcBp51mA+GWL699zLZt1sXVy0kn2fL9923ebUII8RFvFdNSVR0A4AQAJ6jqIACnpdWyxoZfIObPt2XbttE9iJ/9zOazfuQRm3ciEQ+iRQtg7txkLSeE5CgJzSinqjtDI6oB4MY02NN48QvEBx/YrHNDhkQWiNJS4JlngJtussqkoiIbkb3TN0QlSCDy84FhwygQhJCIJDPlqKTMCmICsWOHzRmhah7E8OHW+fXjj22bn5tvBo48ErjjDlsvCnVE93oR+/bZj18gAKt6WrQofS0+CCENmmQEImarDZIAbizEpk2WON640Zr69eljXsGGDTWP373bROSKK4CWoSEpQQLhxkVEEojKypr5DkIICRFVIERkl4jsDPjZBaBrPdnYOHACsXGjhZcA8yB697bX/kR1WRlQXQ2MGBHeVhyakM8rEP5R1F5cojrdYaY9ezjmgpAGSFSBUNXWqtom4Ke1qrLLWyrxjqb+4AMbzDZggHkQQO08xLx5thw+PLwtyIOIJhAdOlieI90C8dhj5g3t3Rv7WEJI1pBMiImkEq9AzJ9vVUbNm1sr8DZtagvE/PlAr15AYWF4W4sWVuoar0AAFmaaOzc4x5EqPv/cBvxt2ZK+9yCEpBwKRLbgBGLDBgsfOc9AJJyodqiaB+GfeAioXeoaj0Bs2WLzVKcLJwwUCEIaFBSIbOGww2ye6nfesZi99+bfp09ND2LdOstVePMPjqKimqOj4xEIIL1hJjdfeLbPG04IqQEFIpvo3BmYPdtee3MLvXsDX3xh7TeAcP4hyIMoLq7tQTRtauITRJ8+1gcqnQJBD4KQBgkFIpvo1MnKTtu2tfyCwyWqXZhp/nxr8HfCCbWvUVRkeQzXAdYNkpMIw1aaNLFqpvrwICgQhDQoKBDZhMtDDB9e84bur2SaNw8YPNgqnfwUFVmOYuNGWw8aRe1n5Ejr4bRjR1LmB6JKgSCkgUKByCa8AuGlRw8Tg48/tmqgRYuC8w9A7VLXeAXCjd5ONXv22OhwgDkIQhoYFIhswgmEP7fQtKmFnFauBD780OaTDso/AGGBcInqeARi+HALNaUjzOQVBXoQhDQoKBDZxPHHWzI5yDtwpa7uKT+SB+EfTR2PQLRubfkMCgQhxAMFIpu44AKrVurQofa+3r2B1autyqlzZ2vSF0RhoQ2wS0QgAPNIyspSP2DOiULXrhQIQhoYFIhsQiR6OWpVFTB1qnkPkaqSROxmvH69VTLt2hWfQBx3nCWp3biJVOE8iD59mIMgpIFBgWgouEqmaPkHhxtN7Tq5tmsX+/rHHGPLVI+odl5Dnz7A1q3WYJAQ0iCgQDQUjj02/DpS/sHhBCLWKGov6RKIzZttcqKePc0DcoP9CCFZDwWiodCyJdCtm1UbDR0a/VjXbmPrVluPRyB69LDwVDoEomNH+3HrhJAGAQWiITF4sE1BGilP4SgutlDU6tW2Ho9AFBRY4tudEw1VYMoUS6jHYssWS7q7xDsT1YQ0GCgQDYknnwRefz32cW4sxEcf2TIegQCAo4+Oz4P461+BCROAP/0p9rF+D4ICQUiDgQLRkGjfHjjiiNjH1VUgjjkmtkB8+ilw3XX22tsUMBL0IAhpsFAgchGvQIhYt9Z4OOYYe+KPlEiurAS+/W27ZlFRuN9TNJwH4QSCOQhCGgwUiFyka2i68A0brDNsXl5857lKpkh5iF//GigtBR59FOjXL3YO4tAhG1vRsaMl2Vu0CPYgHnoIeOSR+GwkhNQbFIhcpFmzcCgq3vASEL3UdcEC4O67gUsuAb71LaBLl9gC4aqonPfQoUOwQPzxj8Af/hC/nYSQeqFppg0gaaKoCNi0KTGBOPpoWwZ5ED/4gYnCo49aiKlzZwsxVVdb6W0QLpzkEtRBAlFdDaxda+Gr/futmooQkhXQg8hVXB4iEYFo2dJu/H4PYuNGYPFi4Prrw6Oyu3Sxm7rzEoJwAuH1IPw5iA0brIV5dXXNebcJIRknrQIhImeJyCoRKReRWwL2jxKRRSJSKSIX+vZViciS0M/UdNqZk9RFIIDgSqb33rPlKaeEt3XpYstoYSbnLTgPomPH2h7EmjXh167qihCSFaRNIEQkD8AjAL4BoC+ACSLS13fY5wAuB/BCwCX2qerA0M/YdNmZs6RSIObMsQTz4MHhbfEIRDwhJq9ALFuWmK2EkLSSTg9iOIByVV2jqgcBTAEwznuAqq5V1Q8BsINbqnHzQtRFIDZsAPbuDW977z3r/+Sd4tQJRLRSVycGzoYOHayE1s2XDZhANGli7cwpEIRkFekUiCIA6zzrFaFt8VIgImUiMk9Ezgs6QESuCh1Ttpn19TVJxoMAwk/2O3cCS5bUDC8B8XsQ7dpZsz4geLDcmjXW4mPwYIaYCMkysjlJ3U1VhwL4FoCHRORo/wGq+oSqDlXVoR1dGIMY3bvbsnPnxM5zlUwuzPT++5ZA9gvEYYcBbdrEFgjv9xLUbmPNGuv02r8/sG4du70SkkWkUyDWA/BOe1Yc2hYXqro+tFwD4B0Ag1JpXM5z7LHAzJnA+ecndp5fIObMsYF2QS3GO3eOnaT2zo4XyYPo2dMG3gHA8uWJ2UsISRvpFIgFAHqJSA8RaQbgEgBxVSOJSDsRaR563QFACYAVabM0Vxk9umbeIB7atbNpS70CMXhwcAfZWIPl/B6Ev93G3r3Al1/WFAjmIQjJGtImEKpaCeA6ADMArATwkqouF5F7RGQsAIjIMBGpAHARgMdFxD0+9gFQJiJLAbwN4FeqSoGoL1wl04EDwPz5wMknBx8XSyBieRCffmrLnj2Bo44yEWIegpCsIa0jqVV1OoDpvm13el4vgIWe/OfNBdA/nbaRKBxzjFUulZWZSPjzDw4nEKq158hWNSHwehCFhbZ0AuES4T16WCVTv370IAjJIrI5SU0yxTHHWMJ41ixbj+ZB7N0L7N5de58rZ/UKRH6+NQ/0C0TPnrbs1888CNXItlVUAMcfz1HXhNQDFAhSm6OPtsqlv/7VxidEqhCLVurqRMAbYnLrLgexZo2Fldwx/fpZ644vv4xs2xtvACtWAO++G//vkyrefx8oKQH27Kn/9yYkA1AgSG28XV0jhZeAcAltkED4R1E7vO02XAWTC0/Fk6guLbXlJ59EPiZdPPkkMHcu8OGH9f/ehGQACgSpjRMIILpARPMg/I36HN52G59+Gg4vATYWAshOgaiuBqaH0mkMb5FGAgWC1KZDBxsEB9RdIPyN+rzX3rLF8gzOg3AccYQdH0kgNm8OC0N9C8TixeG2IhQI0kigQJDaiJgXUVwMdOsW+bh27YDmzRMLMbkcxMaNwL59NQUCCCeqg5g715YjR9qcFVVV8f0+qWDaNPtcunalQJBGAwWCBHPHHcCkSbXLV724iYMieRAFBdaSw0vHjlY660QgSCCWL7eQjp/SUhv4d8klNodERUViv1MyTJsGDB8OnHQSBYI0GigQJJjx4+1GHIsuXYI7urpR1H6BcTmJDz6wZY8eNff3729VQp99VvuapaXAkCHhXEV9hZk2bbIpV88+26q6Vq82gSIkx6FAkOSINJra32bD4RcI11TQ4SqZ/GGm/ftt4F5JSTiJXl8C8a9/Wc7ECURVVfC0rITkGBQIkhzRQkz+CiagpkAUFdWeg/r4423pF4iFC+2pvaTE8gAtWtSfQEybZkI4aJAJBMAwE2kUUCBIcnTpAmzbZnkFL5E8CLfNNenz06aNeRGTJ9dMQnsT1E2amBdRHwJx6BAwYwbwzW9auOy442w7BYI0AigQJDkizSwXy4MAggUCAH7+c0tUT54c3lZaaqJwxBG23qtX/QhEaalNmnT22bbeurV5PhQI0gigQJDkCBoLceAAsGtXsAdx+OFA01CPyEgCceGFwMCBwF13WVhJ1TyIkpLwMb162TiKysqU/BoRmTbNekiNGRPe1rs3BYI0CigQJDmCBCLSGAjAwjTOi4gkEE2aAPfdZwLw1FPmKWzeXFsgDh0CPv+8bnarWqJ56tSaExj5mTYNGDXKPAeHE4hoTQUJyQEoECQ5gkJMkRr1OWIJBAB84xvWRfaee2xmPKC2QACJh5mefRY49VTrKnvMMcC4ccC99wYfu3YtsHJlOLzk6N3bwk5B5b2E5BAUCJIcbqxDvB4EEJ9AiAC//KVd9/bbbdS2qyAC6lbqWl0N3HijeR2XXgo88YRNzfqf/wQfv3ixLf3tzlnJRBoJFAiSHE2bWuLYKxAzZliYKJIAdOhgZaqdOkW/9imnAGedBezYYSOYm3j+XLt0AVq2rC0QL78MnH56cBuOxYutnfi99wKPPgpceaUNunMz2/lx81V4mxcCFAjSaKBAkOTxDpb78ku7+V56qVX7BHHhhcC110Zv4+G47z5bnnpqze2uX5SbO9vxwAMWknr//drXevNNW3oTzj17mkAEtfZYs8ZCUe3a1dxeVGTiRIGIza5dwMMPB3++JOuhQJDk8QrEpElWxXTHHZGPv/hiOy4eBg8GliwBrr++9j5/qeuqVdYSAwD+8Y/ax7/1FjBgQE3PpUcPszdosN/q1TZ5kh8R8yJWrYrvd2jMPP+8fXfvvZdpS0gdoECQ5HECsWlT2Hs49tjUXX/AAAtJ+enVy57+Xanr889bGGrQIOC112pWGe3ZYzepM86oeQ0XBgsKM/nbkXthqWt8lJXZ0gk3aVBQIEjydOlioaVf/Sq295BKevUycVi71sTgueeA0aMtt1BebhVIjnfftbLY00+veQ0nAC7f4KiqsutGE4jPPrM5udNBVRWwYUN6rl2fOIFwvbdIbNautfxbkFdbz1AgSPJ07mwx5j/8IfXeQzS8pa5z55oXcNllwNixtt0bZnrrLev75K9IOuooCxn5BaKiwgQlKMQEhBPVkSqgkuW550ycNm1K/lpVVcD991tLlPpk377w5E/0IOJn6lTzdqdNy7QlFAiSAtxYiOrq+vMegJoC8dxzFoYaP96SyMOG1RSIN9+0pzJ/qKp5c5sYyR9icoIRzYMA0hdmWrLEvLF585K/1vvvA7fdZiG4+mTpUhOnkSPt8402IJGEmT/fllmQt6FAkORxAlGf3gNg5bWtWlnfphdfNHFwI57HjbN/tC++ANavB1asqJ1/cPTsWduDcO28I3kQxxxj+Y50CYRLvrubRTK48Rwffpj8tRLBhZeuvrrmOomOeyiYMyezdoACQVLB4MHANdeES1LrCxHzIl54Adi+3cJLjnHjbPnPf1p4Caidf3D06FFbINassTEexcXB5xQU2FwW6RIIV74bKXY/fTrw0kvxXcsJxNKlyduVCGVlJuLnnWffFcNMsdm82f72iottmeE8FAWCJE9BgVUvHXlk/b93r17A7t12I/IKwPHHm2fwj3+YQHTqFJ6Jzk/PnvaPuH9/eNvq1TYft2ssGES6KpmqqsKC9cEHwWMIbrrJnswPHYp9PScQy5bV7zzeZWXA0KHm1fXuTYGIB/dA8OMf27K0NHO2gAJBGjouDzFhQs2buYh5ETNn2sjuMWNqjsT24vIMa9eGt61ZEzm85HBjIVJ90123zm78JSXW88mfCK+oMGHavj12GOLAAROGoiJLGvsHFqaL3butimzoUFsfNswEgg0OozNvnv2dfv/7Np97hsNMFAjSsDnhBFt+5zu1940bZ+3Ct26NnH8AwvNie8NM0cZAOPr1M6/DH55KFncTv/RSW/rzELNm2VIE+Pvfo19r+XIrBXafT32FmZYsMc/HKxAbN1o+iERm/nzzdNu2tfYyGU5UUyBIw+aCC+wmOHhw7X0lJUD79vba217Dj3+w3I4dVhIay4OINH+2Y/nyurUjdwnqs8+28Iw/DzFzpjVCPPfc2gMC/bjw0qWXAnl59ScQCxfacsgQWw4bZsuGEmbatQsYMaJ+n+Crq+27PvFEWz/5ZPu+du6sPxt8UCBIwyYvD+jbN3hf06bAt79t8zl07Rr5Gp06Wfmr8wRilbg6+va1p3hX6+9n3Djg8sujXyOI8nKzp7jYbqxeD0LVBGL0aOD88y3c5G7GQSxebCLTp4+FxOpLIMrK7DN3n/uAAfZ9NJQBc2+/bZ/7lCn1956rVgFffWXCBJhAVFcH9xWrJygQJLd56CEbRR0NkZqVTG4Zy4No2dJEJEggtm61RPfs2YkPUCsvt/du0gQYPtxu6i6BvmKFhWrGjAHOOccEMlqYafFim52vSRO7SddXqatLUDsKCiwcmG4PQtU+rwceAE47zT6/f/878eu4OUhmz06tfdFwDwLOgxgxwr7fDOYhKBCEAOGurkB4DITLTUSjf//gENOiRbasqgL+9a/EbCkvD7cYP/FEyyG4UJG7cY0ZAxQWmnf02mvB16mqspvloEG2PmCAJcD9grVmjd1QU9VxdedOexr2CgRg3lBZWfo6uy5ebMn4gQOBn/3MBuZt3Wre1sSJiQ3Uc3meZcuCz1u0yDzE3btTYjoAE4g2bcKDMFu1su8ug3kICgQhQHiwnKotO3Swf9ZY9OtnOQNviSwQDvu0b29jMeKlutoEygnE8OG2dKGZmTNtX7dutj5+vHkVQS0/ysutSaFXIIDaXsR999kN9ckn47czGosX2+cYJBBffZW+Sqq//916gj31lCXDP/zQbvC33WZjZXr3tvlCYrFhg32mbixN0A36scesJcZzz6XO/vnz7TPyVtudcoptP3gwde+TABQIQgDzFnbtCoeGYoWXHP3725O6fzzEwoUmOuefbx5EvP/g69dbaaor3+3a1XIR8+db6es779RMuLubWJAX4bwYv0B48xAHDgCvvGKvf/Yzu8Emixsx7RLUjngS1W+/XfcnZlcBdMUV4dxHixYmgIsX2/dx6aWx27Q77+GWWyw05g8zVVcDr79urx9+ODWlu3v3mqC5/IPj5JPt4SNanimNY1soEIQANSuZ4ilxdbhKJn8eYuFCu0Gee66FXOKNZbsKJu8sdsOHmwfxwQcW0vAKxFFH2fsE5SEWLwaaNQsn8Tt1suonrwfxxhv2VP/b35q3cdNNNa+xc6fNDz56dPyNA8vKzK4jjqi5vW9fu2FHE4irrwauuiq+9/HirwDy06+fPfG3aAH88IfRb+qzZln4bvhwKzX157AWLrQWLqNHW6VaUI5r0SIT7XjDaQsX2o3eb7+bhz2aaF5ySfQy7iRIq0CIyFkiskpEykXkloD9o0RkkYhUisiFvn0TReST0M/EdNpJyH8FYdUqK02N14Po1QvIz6+Zh9i2zYRmyBC7mRcU2M0pHlz4xSsQJ55oXs2UKZZQP+20muecd54NsPK3ZVi82G6M+fm2LmJehNeDmDzZbobXXmtPzM8/H85zbNli7zVzpnXLHTYsviS3P0HtaNrUypEjCYQbFLhypeVKEuGTT6w8OZJAANZ1+Fe/sqR1pMaF3iqxJk0sx7NkiYmo45//tH3PPGMhxIcfrnmNzZttqtzx401knEcSDX+C2tGpk/U3i5aoLisLl3OnmLQJhIjkAXgEwDcA9AUwQUT89YifA7gcwAu+c9sDuAvAiQCGA7hLRHzzPhKSQlxC+t137UkuXg8iP99KSL0ehAvtDB5so2FPP90EIp5QRHl5uMOsw+UhnnzSbrz+KVDHj7elV4RUTSD840MGDDBbKyvNG5k6FbjoIvs9brvNhOmHPzRBOuUUe0J+7TV7gnWdWSMlxQG7SZeXBwsEYCKzaFFwixCXiAfC08PGS6QbrJ+rrrJjbrzRRqL7WbXKwnyjR9v6qFHmBcydGz5m6lR7si8uthHPr71WU9Cuv94+h1//2sRizBgTDP/86V7mzbPeXn6vC7AwU2lpsDeyZYt1APCH81JEOj2I4QDKVXWNqh4EMAXAOO8BqrpWVT8E4P/NzwTwlqpuU9XtAN4CcFYabSWNnZYt7Z/TNfaLVyAAe0qPJBCAzU/x2WeRB9R5KS+39/YmKocOtfX9+4MH/PXtaz+//KXdkAAbH7F1azj/4BgwwPIO//mP3ej27bM2JYB5On/8o93Ijj/ebpRvvGED9oYMsSf/vn1NkJ55Jth+V7HlQiN+TjrJfo+g8Rguzt62rbVHSYT588M9n6LRpIklmLdtA269tfZ+97TvPucRI0w8XRjp88/N9nPPtfVrrrEb9+OP2/orr1hn4bvuAn76UxOc3/zGBMDbTDLIfn/+wXHyyWZvUN8v95lFEuQkSadAFAHw+okVoW0pO1dErhKRMhEp2+z+MQipKz172o0ciD/EBFhi9PPPw2GIhQvtabCw0NbPOceW8YSZvCWujlatwnmEIIEQAZ591nIEEybULIsNEgjAQkWTJ9tTsHcSpTFjbHBfmzaWMD711PC+Ll3sRjliBHDnncHJ0aeeMm/MPzGTY+RIWwY1oVu40MpUx4+3ME8iydd588w7ycuLfezAgdYM7/HHaw9CmznT7HcPCIcdZtd1OSSXnHaTUnXvbmLxxBMmqD/8oT0Y/PSntr+gwPI6994bziP5KS83QY/k/TixjfSZAcGdBFJAg05Sq+oTqjpUVYd27Ngx0+aQho67KTRvHn3ktR+XqF6+3JYuQe3o3Nn++WOVu6oGCwRgN9bDDgvfYP0MGWJPxrNmWaho0SITDterytG7tz0Rv/22PaVffHHtJoZ//rOFTILCFi1aADffbPv9M56tXWvvf/nlkRsjFhdbAjvSzW7IEODMMy38E+/8Efv2meDFCi95+cUvrPvwxReHx79UVtrn4sJLjlGjzHvau9dEvlcv4Ljjwvuvu848t5NPNruffjqc93FMnGgejj9fAVgoqlkzC/UF0auXFRcEfWZlZbb/8MPj/90TIJ0CsR6At/9zcWhbus8lpG64PESPHpFvcEG4NuIffWSx59Wra99cx461p8do8wxv2GA3O1fi6uXeey0PUFAQ+fzLL7eQx6RJlq847jgLnXlp1sxyJk8/bXkAF17y0qSJiWQkxo41AX300Zrb//IXW06MUVNSUmI3O29OZtcuC3u5xL5I7TBTZaUl0r1zjQMmhpWViQlEq1Ym2Hv2AF//unmOixaZF+j30kaNsuu/9ZYJiPMeHKNH22e9di3w85/XFmXAxGHiRAs/eavB1q61cN2VV5r3FISIPRhEEog0hZcAAKqalh8ATQGsAdADQDMASwEcH+HYZwBc6FlvD+BTAO1CP58CaB/t/YYMGaKEJMWf/6wKqH7zm4mdV12t2qqV6nXXqc6aZdeYMaPmMR99ZNsnTFCdPVv10KHa13nnHTvmzTfr/jscOKB60knh9wri29+2/b16me114e677RqffGLrVVWq3bqpnn567HMfftjO/fTT8LZ337Vtr79u68OGqY4cWfO8xx+3Y847r+b2//s/2/7FF4n/HgsXqrZtq9qjh+o119h1Nm2qecxXX6k2aaJ6wgm2/513al9n2jTViRNVDx6M/F4rV9r5990X3nbllarNmqmuWxfdzgcesHM3bgxv+/JL2/ab38T8NaMBoEwj3ccj7UjFD4BvAvgPgNUAbg9tuwfA2NDrYbD8wh4AWwEs95z7XQDloZ8rYr0XBYIkzdtv27/Eddclfu6IEaqnnhr+R96ypeb+6mq7gTRtavvbt1e97DLViorwMU8+afvWrEnil1DV9etV+/RRfe654P2/+Y29z513JvceeXmqN91k6zNn2jUnT4597uLFdqzXvgcfrHmTv+MOu/727ba+e7dq5872+YmolpeHz/2f/1E96qi6/y4LFqgefri9/8CBwccMGWL727ULFvd4GTNGtbjYrrF2rf0+P/xh7PNKS+39X301vG369MiClQAZE4j6/KFAkKRZt87+JX7/+8TPvfJK1cJC1YsvtifpSOzYofq3v5lYtGhholJVZftuuUU1Pz+5G1A8LF2qeuSRNW+ydeHCC03o9u5V/da37El8377Y51VWmsd1zTXhbZdeqtq1a3h9zhz7Ll55xdbvucfW//Y3+4x+9KPwsd26qV50UXK/y7x5JhL/+7/B+3/yE3v/Sy9N7n3+8Q+7zssvq/7gB/a7fP557PP271dt3jwsyKr2mYiYh5MEFAhC4mXGDHtaTZTf/U7/6xmcf35857iQ1m9/a+sXXqh67LGJv3em+Pe/zf6HHlItKFC99tr4zx0zRnXAgPB6796qY8eG1w8eVG3dWvWqqyyU0qqV6vjxtu+yy2x9xw4LuaQgzKKqJm5OrP24G/uLLyb3HpWVJmgnnGDicPXV8Z9bUmKeqmPcONXjjkvOHo0uEA26iomQlHPGGbUTu/HgEtXbtsU/aOmKK6wE9tZbrcb9k0+CK5iyla99zaqibr7ZxjZccUX855aUWFJ/505LUK9aVfNzy8+35O+MGVZxtG8fcP/9tu8nP7FBfn/+c/wD5OKhoCByccI551g7kwsuSO498vKsFNaNSA8aixGJkhKr9Nq3z9bTnaBGAy9zJSRrcKWuQPwCIQL86U8mSN/5jpW4BlUwZSsidrM7dMgqdxKpxS8psQFm8+ZZKwvV2p/bmWdaddEf/2gjoF1p6eDBVln0+9/bCOe8vLSNA/gvTZpYS5N4xlnE4nvfsyqq73/fSn7jpaTEPuuyMquGW7+eAkFIg6BjR+ubAyR2s+rc2W6ACxZYyWVD8iAAE7aiIuCGG0ww4mXECLvplpbWnp7UceaZtjzsMBuZ7OWGG0w8Hn3UxOmww+r6G9Q/hYVWqvvQQ4md5x1kGOkzSzFN03p1QhoT/fvb+IFEB21edJGNR5g8ueEJxOGH2yjgRGnd2m7spaU2QrtrVxNLLz162Kjq004Li69j7NjwHB6pCC/VN95eW/HSoYN5UaWl1i5FpPZI+RRDgSAkVTz4YN0nmHdPwl//emptymZKSmyQWFFR5CfhV18N3p6XB/zoR+ZJNESBqCslJeE24n36WKgqjTDEREiq6N8/cpO6WLRta6OEo41gzjVGjrSwmhtBnShXXWUNCi+8MPaxuUJJiRVCzJyZ9vASQA+CEJIpvGJal5tdixaJVQHlAu4zO3gw7QlqgB4EISRTHHVUuP9QPTwN5wTHHmu5CKBePjMKBCEkM4hYzqVbN0tUk9i4xn1Nmljb8jTDEBMhJHP87nc1p/MksfnZz6yyqy4DOhOEAkEIyRzt26dtPuWcZeTIyPOCpBiGmAghhARCgSCEEBIIBYIQQkggFAhCCCGBUCAIIYQEQoEghBASCAWCEEJIIBQIQgghgYhNSdrwEZHNAD5L4JQOALakyZxkyFa7gOy1LVvtArLXtmy1C6BtdSEZu7qpauAkJjkjEIkiImWqmv52iAmSrXYB2WtbttoFZK9t2WoXQNvqQrrsYoiJEEJIIBQIQgghgTRmgXgi0wZEIFvtArLXtmy1C8he27LVLoC21YW02NVocxCEEEKi05g9CEIIIVGgQBBCCAmk0QmEiJwlIqtEpFxEbsmwLU+JyCYRWebZ1l5E3hKRT0LLdhmw60gReVtEVojIchH5cRbZViAiH4jI0pBtvwht7yEi80Pf64si0qy+bQvZkScii0Xk9Syza62IfCQiS0SkLLQtG77PtiLysoh8LCIrReSkLLHruNBn5X52isgNWWLbT0J/+8tEZHLofyItf2eNSiBEJA/AIwC+AaAvgAki0jeDJj0D4CzftlsAzFLVXgBmhdbrm0oAN6lqXwAjAFwb+pyywbYDAE5T1QEABgI4S0RGAPg1gN+q6jEAtgP4XgZsA4AfA1jpWc8WuwDg66o60FMvnw3f5+8AvKGqvQEMgH12GbdLVVeFPquBAIYA2Avg75m2TUSKAPwIwFBV7QcgD8AlSNffmao2mh8AJwGY4Vm/FcCtGbapO4BlnvVVALqEXncBsCoLPrd/ADg922wDcBiARQBOhI0ibRr0PdejPcWwm8ZpAF4HINlgV+i91wLo4NuW0e8TwOEAPkWoWCZb7Aqw8wwApdlgG4AiAOsAtIdNGf06gDPT9XfWqDwIhD9cR0VoWzbRSVW/CL3eCKBTJo0Rke4ABgGYjyyxLRTGWQJgE4C3AKwGsENVK0OHZOp7fQjATwFUh9YLs8QuAFAAb4rIQhG5KrQt099nDwCbATwdCss9KSIts8AuP5cAmBx6nVHbVHU9gN8A+BzAFwC+ArAQafo7a2wC0aBQexzIWB2yiLQC8AqAG1R1p3dfJm1T1So1178YwHAAvTNhhxcROQfAJlVdmGlbInCyqg6GhVevFZFR3p0Z+j6bAhgM4I+qOgjAHvhCNlnwP9AMwFgAf/Pvy4RtoZzHOJi4dgXQErXD1CmjsQnEegBHetaLQ9uyiS9FpAsAhJabMmGEiOTDxOF5VX01m2xzqOoOAG/DXOq2ItI0tCsT32sJgLEishbAFFiY6XdZYBeA/z55QlU3wWLpw5H577MCQIWqzg+tvwwTjEzb5eUbABap6peh9UzbNgbAp6q6WVUPAXgV9reXlr+zxiYQCwD0CmX8m8Fcx6kZtsnPVAATQ68nwuL/9YqICIA/A1ipqg9mmW0dRaRt6HULWG5kJUwoLsyUbap6q6oWq2p32N/Vv1X10kzbBQAi0lJEWrvXsJj6MmT4+1TVjQDWichxoU2jAazItF0+JiAcXgIyb9vnAEaIyGGh/1P3maXn7yyTyZ9M/AD4JoD/wOLWt2fYlsmwOOIh2NPU92Bx61kAPgEwE0D7DNh1Msx1/hDAktDPN7PEthMALA7ZtgzAnaHtPQF8AKAcFg5onsHv9WsAXs8Wu0I2LA39LHd/91nyfQ4EUBb6Pl8D0C4b7ArZ1hLAVgCHe7Zl3DYAvwDwcejv/68Amqfr74ytNgghhATS2EJMhBBC4oQCQQghJBAKBCGEkEAoEIQQQgKhQBBCCAmEAkFIACKyO7TsLiLfSvG1b/Otz03l9QlJFRQIQqLTHUBCAuEZ0RqJGgKhqiMTtImQeoECQUh0fgXglNCcAD8JNQqcJCILRORDEfkBAIjI10RkjohMhY1shYi8FmqOt9w1yBORXwFoEbre86FtzluR0LWXheZuuNhz7Xc88yY8HxpFS0haifWkQ0hj5xYA/09VzwGA0I3+K1UdJiLNAZSKyJuhYwcD6Keqn4bWv6uq20ItQRaIyCuqeouIXKfWbNDP+bCRxQMAdAidMzu0bxCA4wFsAFAK67/zXqp/WUK80IMgJDHOAPCdULvx+bDWC71C+z7wiAMA/EhElgKYB2sS2QvRORnAZLVutV8CeBfAMM+1K1S1Gtb6pHsKfhdCokIPgpDEEADXq+qMGhtFvgZrV+1dHwPgJFXdKyLvAChI4n0PeF5Xgf+7pB6gB0FIdHYBaO1ZnwHgmlA7dIjIsaEOqX4OB7A9JA69YVO3Og65833MAXBxKM/REcAoWAM2QjICn0IIic6HAKpCoaJnYHM8dAewKJQo3gzgvIDz3gBwtYishE1TOc+z7wkAH4rIIrWW4I6/w+a2WArrpvtTVd0YEhhC6h12cyWEEBIIQ0yEEEICoUAQQggJhAJBCCEkEAoEIYSQQCgQhBBCAqFAEEIICYQCQQghJJD/D+TQ75YhpiXQAAAAAElFTkSuQmCC" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "We can see that after ten steps of iteration, the value of the loss function only fluctuates in a small range, indicating that the training process is stable." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "Then we randomly sample the initial parameters of the model 300 times, and here we choose the ``max`` mode to see the mean and variance of the maximum gradient for all parameters." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 19, - "source": [ - "mean, variance = random_sample_supervised(circuit,loss_func, N=qubit_num, sample_num=SAMPLE, BATCH=BATCH, TRAIN_X=train_x, TRAIN_Y=train_y, mode='max')" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "Sampling: 100%|###################################################| 300/300 [00:21<00:00, 13.65it/s]\n" - ] - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Mean of max gradient\n", - "0.19336918419398885\n", - "Variance of max gradient\n", - "0.011469917351120164\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Summary\n", - "\n", - "The trainability problem is a core direction of current research in quantum neural networks, and the gradient analysis tool provided by Quantum Paddle supports users to diagnose the trainability of the model, facilitating the study of subsequent problems such as barren plateaus." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "_______\n", - "\n", - "## References\n", - "\n", - "[1] McClean, J. R., Boixo, S., Smelyanskiy, V. N., Babbush, R. & Neven, H. Barren plateaus in quantum neural network training landscapes. [Nat. Commun. 9, 4812 (2018).](https://www.nature.com/articles/s41467-018-07090-4)\n", - "\n", - "[2] Cerezo, M., Sone, A., Volkoff, T., Cincio, L. & Coles, P. J. Cost-Function-Dependent Barren Plateaus in Shallow Quantum Neural Networks. [arXiv:2001.00550 (2020).](https://arxiv.org/abs/2001.00550)\n", - "\n", - "[3] Kieferova, Maria, Ortiz Marrero Carlos, and Nathan Wiebe. \"Quantum Generative Training Using R\\'enyi Divergences.\" arXiv preprint [arXiv:2106.09567 (2021).](https://arxiv.org/abs/2106.09567)" - ], - "metadata": {} - } - ], - "metadata": { - "kernelspec": { - "name": "python3", - "display_name": "Python 3.7.11 64-bit" - }, - "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": true - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - }, - "interpreter": { - "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} \ No newline at end of file diff --git a/tutorial/qnn_research/Expressibility_CN.ipynb b/tutorial/qnn_research/Expressibility_CN.ipynb deleted file mode 100644 index d11105b..0000000 --- a/tutorial/qnn_research/Expressibility_CN.ipynb +++ /dev/null @@ -1,695 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# 量子神经网络的表达能力\n", - "\n", - "Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## 概览" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "在量子机器学习中，量子神经网络的**表达能力**是决定量子机器学习任务能否成功的关键因素。一般来说，量子神经网络拟设的表达能力越强，量子机器学习能够搜索到全局最优解的可能性就越大。本教程首先介绍量子神经网络表达能力的基本概念，随后将在量桨中展示如何通过布洛赫球感受不同拟设表达能力的差别。最后介绍一种定量分析量子神经网络表达能力的方法，并评估量桨提供的量子神经网络模板在不同深度下的表达能力。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## 基本概念" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "我们先来回顾一下量子机器学习算法的基本流程。在量子机器学习中，我们往往设计一个损失函数 $\\mathcal{L}$，并通过优化一个酉变换 $U$ 使得损失函数最小化：\n", - "\n", - "$$\n", - "\\min_U\\mathcal{L}(U)=\\min_U \\text{tr}[HU\\rho_{in}U^\\dagger],\\tag{1}\n", - "$$\n", - "\n", - "算法背后的数学原理保证当我们遍历完所有可能的酉变换后，损失函数能取到的最小值就对应于我们问题的解。而在实际操作中，我们采用量子神经网络将酉变换参数化：\n", - "\n", - "$$\n", - "U=U(\\vec{\\theta})=U_D(\\vec{\\theta}_D)\\dots U_1(\\vec{\\theta}_1),\\tag{2}\n", - "$$\n", - "\n", - "其中每个 $U_j(\\vec{\\theta}_j),j\\in[1,D]$ 代表一层量子神经网络，$\\vec{\\theta}_j$ 代表该层对应的参数。此时，通过调整量子神经网络中的参数 $\\vec{\\theta}$，我们就可以进行对酉变换 $U$ 的优化，进而最小化损失函数 $\\mathcal{L}$：\n", - "\n", - "$$\n", - "\\min_{\\vec{\\theta}}\\mathcal{L}(\\vec{\\theta})=\\min_{\\vec{\\theta}} \\text{tr}[HU(\\vec{\\theta})\\rho_{in}U(\\vec{\\theta})^\\dagger].\\tag{3}\n", - "$$\n", - "\n", - "然而，细心的读者此时可能已经发现了量子神经网络的一个不足：对于一个给定的神经网络拟设，**遍历所有的参数并不一定可以保证遍历所有的酉变换**。作为一个简单的例子，如果我们只允许使用一个 $R_Y$ 旋转门作为单比特量子神经网络 $U(\\theta)=R_Y(\\theta)$，显然（除去全局相位）$U(\\theta)$ 不能表示任何矩阵元含虚部的复酉矩阵。而当允许使用 $R_Y$ 和 $R_Z$ 旋转门时，如果我们搭建量子神经网络为 $U(\\vec{\\theta})=R_Z(\\theta_1)R_Y(\\theta_2)R_Z(\\theta_3)$，$U(\\vec{\\theta})$ （除去全局相位）将能够表示所有的单比特酉矩阵 [1]。\n", - "\n", - "如果我们将神经网络的表达能力定义为**在遍历电路参数 $\\vec{\\theta}$ 时电路能够表达的酉变换的多少**，那么，一个表达能力强的量子神经网络将更有可能包含那些使得损失函数 $\\mathcal{L}$ 取到全局最小值的酉变换；相反地，如果一个量子神经网络 $U_{weak}$ 的表达能力太弱以至于不包含任何能将损失函数最小化的酉变换，那么基于优化 $U_{weak}$ 的量子机器学习任务就很可能会失败。\n", - "\n", - "接下来我们基于量桨，通过观察单量子比特酉门遍历布洛赫球的能力直观地感受量子神经网络的表达能力。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## 直观感受表达能力：遍历布洛赫球" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "对于单量子比特的简单情况，我们可以直接观察量子神经网络如何将固定输入遍历布洛赫球表面。对于一个给定的神经网络拟设 $U(\\vec{\\theta})$，由于网络的输入往往是固定的（不妨设为 $|0\\rangle$），通过均匀地采样神经网络参数 $\\vec{\\theta}$，神经网络的输出态 $U(\\vec{\\theta})|0\\rangle$ 将散落在布洛赫球表面。显然，如果输出态在球面分布地越广越均匀，那么神经网络拟设 $U$ 的表达能力也就越强，包含损失函数全局最优的可能性也就越大。\n", - "\n", - "为在量桨实现这一功能，首先引入必要的包：" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 1, - "source": [ - "import numpy as np\n", - "from numpy.random import random\n", - "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import plot_state_in_bloch_sphere" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "首先，我们只允许使用一个 $R_Y$ 旋转门作为单比特量子神经网络 $U(\\theta)=R_Y(\\theta)$。通过在 $[0,2\\pi]$ 均匀采样参数 $\\theta$ 并将 $U(\\theta)$ 作用在固定输入 $|0\\rangle$ 上，我们便得到量子神经网络 $U(\\theta)$ 的输出分布。通过量桨内置的 plot_bloch_sphere_from_input 函数，我们可以直接观察 $U(\\theta)|0\\rangle$ 在布洛赫球面上的分布：" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 2, - "source": [ - "num_qubit = 1 # 设定量子比特数\n", - "num_sample = 2000 # 设定采样次数\n", - "outputs_y = list() # 储存采样电路输出\n", - "\n", - "for _ in range(num_sample):\n", - " # 初始化量子神经网络\n", - " cir = UAnsatz(num_qubit)\n", - " # 在 0 到 2 pi 间均匀采样参数 theta\n", - " theta = paddle.to_tensor(2 * np.pi * random(size=1), dtype='float64')\n", - " # 作用 Ry 旋转门\n", - " cir.ry(theta, 0)\n", - " # 输出态的密度矩阵\n", - " rho = cir.run_density_matrix()\n", - " outputs_y.append(rho.numpy())\n", - " \n", - "# 量桨内置的 plot_bloch_sphere_from_input 函数\n", - "# plot_state_in_bloch_sphere(outputs_y, save_gif=True, filename='figures/bloch_y.gif')" - ], - "outputs": [], - "metadata": { - "scrolled": false - } - }, - { - "cell_type": "markdown", - "source": [ - "![bloch_y.gif](./figures/expressibility-fig-bloch_y.gif)" - ], - "metadata": {}, - "attachments": { - "bloch_y.gif": { - "image/gif": "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" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "可见，量子神经网络 $U(\\theta)=R_Y(\\theta)$ 的输出只能分布于布洛赫球面上的一个圆环（尽管在圆环上的分布是均匀的）。类似地，我们考虑包含两个参数的神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ 和 三个参数的神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 的输出分布：" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 3, - "source": [ - "outputs_yz = list() # 储存采样电路输出\n", - "for _ in range(num_sample):\n", - " # 初始化量子神经网络\n", - " cir = UAnsatz(num_qubit)\n", - " # 在 0 到 2 pi 间均匀采样参数 theta\n", - " theta = paddle.to_tensor(2 * np.pi * random(size=2), dtype='float64')\n", - " # 作用 Ry 旋转门\n", - " cir.ry(theta[0], 0)\n", - " # 作用 Rz 旋转门\n", - " cir.rz(theta[1], 0)\n", - " # 输出态的密度矩阵\n", - " rho = cir.run_density_matrix()\n", - " outputs_yz.append(rho.numpy())\n", - "# plot_state_in_bloch_sphere(outputs_yz, save_gif=True, filename='figures/bloch_yz.gif')\n", - " \n", - "outputs_yzy = list() # 储存采样电路输出\n", - "for _ in range(num_sample):\n", - " # 初始化量子神经网络\n", - " cir = UAnsatz(num_qubit)\n", - " # 在 0 到 2 pi 间均匀采样参数 theta\n", - " theta = paddle.to_tensor(2 * np.pi * random(size=3), dtype='float64')\n", - " # 作用 Ry 旋转门\n", - " cir.ry(theta[0], 0)\n", - " # 作用 Rz 旋转门\n", - " cir.rz(theta[1], 0)\n", - " # 作用 Ry 旋转门\n", - " cir.ry(theta[2], 0)\n", - " # 输出态的密度矩阵\n", - " rho = cir.run_density_matrix()\n", - " outputs_yzy.append(rho.numpy())\n", - "# plot_state_in_bloch_sphere(outputs_yzy, save_gif=True, filename='figures/bloch_yzy.gif')" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "![bloch_yz.gif](./figures/expressibility-fig-bloch_yz.gif)" - ], - "metadata": {}, - "attachments": { - "bloch_yz.gif": { - "image/gif": "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" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "![bloch_yzy.gif](./figures/expressibility-fig-bloch_yzy.gif)" - ], - "metadata": {}, - "attachments": { - "bloch_yzy.gif": { - "image/gif": "R0lGODlhIAMgA4cAAP7+/u7u7uJEJe3X0+u3reNUOORnTueHdeiYiOmlmOV6ZezLxOzDu+VyW+NcQkhISO7g3uqtoQAAANra2j09PeiQfllYWLi4uMjIyJeXl2hoZ3h4d4eHh6iop9pFJxkZGScnJ7FGMZJDNHFEPOE+HtJmUdVTOdG3srR5b9R5Z0w9Ok1BPtFaQ6xnWbBZSK2ZldSimLWDeXVXUadtYpNsZI9ZTmo9Not+e947G5NkW7iMg4RMQdpxXHFKQsmqpNOBcIk/Mragm82PggAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAA8AAAAIf8LTkVUU0NBUEUyLjADAQAAACwAAAAAIAMgAwAI/wABCBxIsKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIsaPHjyBDihxJsqTJkyhTqlzJsqXLlzBjypxJs6bNmzhz6tzJs6fPn0CDCh1KtKjRo0iTKl3KtKnTp1CjSp1KtarVq1izat3KtavXr2DDih1LtqzZs2jTql3Ltq3bt3Djyp1Lt67du3jz6t3Lt6/fv4ADCx5MuLDhw4gTK17MuLHjx5AjS55MubLly5gza97MubPnz6BDix5NurTp06hTq17NurXr17Bjy55Nu7bt27hz697Nu7fv38CDCx9OvLjx48iTK1/OvLnz59CjS59Ovbr169iza9/Ovbv37+DDi/8fT768+fPo06tfz769+/fw48ufT7++/fv48+vfz7+///8ABijggAQWaOCBCCao4IIMNujggxBGKOGEFFZo4YUYZtjQBBp0oOGH1E0gAQUGbQCCBB88cIFBEoAA4ovQiUjiQAGc+IEFFEggQQYFPSDBBDAGuZyMBPn4wEAX6AjkQBlIwIGQUB5HpEAiShAAQRpIYAFBAYwY5ZfDTQkAB14SlKQEBeV4JZhs9iamBRJswOKPBJHJY5t45iZmjncSpOOKA4l4ZJ6E1ibmiX0O9IEEHhJ0YqGQynbojgYt2uhAGzAa6aat7UlpQX8W1OSTnJaK2ptxzrnkQD6uauqroon/SeaMSOrIoouw5hqamFWuKVCWWxLUQaq6FtuZmAAYWSudBMGJgbHQaoZsjSha4OOnBH3wQbTcXoasQCaiqKJBSWrQ7bmTfdtQloCi625j6jL06Lv0LhavQhhoWe++iN3L77+Q+QvwwIsFsEGiBCes8MIMN+zwwxBHLPHEFFds8cUYZ6zxxhx37PHHIIcs8sgkl2zyySinrPLKLLfs8sswxyzzzDTXbPPNOOes88489+zzz0AHLfTQRBdt9NFIJ6300kw37fTTUEct9dRUV2311VhnrfXW9FJgLtdFU4Ar2ENbsC3ZQmPAwdloA53BBSA82/bPFgRAAalz93zkA4Pm/83zlnz7zbPayW4gt+A4v53sBQgjTrMGVx4ZrOM2D7o35TcHe6QGrmIOMwZyJgtAB4173rLiogcwuekvQy6Q5azH3Pegocfu8uy2xzxB7X3nfvqlvfu+Mga+Bi/87cfLbHzyKy/PfMrOP39y9NKXTH31I1+Pfcjab/9x9953DH74G49Pfsbmn39x+upXzH77E78Pf8Tyz/9w/fY3jH/+C+/Pf8L++9/AAijAfxGwgPs6IALppcAFuquBDjwXBCPIrQlSEFoWvGCxMqjBXHGwg6/6IAhLJcIRbqqEJoQUClNIqBWyEE8ufCGbYijDL9GwhlC6IQ6DpMMdvqiHPvwQEP+DmKEhEvFCRjxihZKoxAkxsYkReiIUHyTFKTaoilZcEBazmKAtcvFAXvxigcIoxv8wIAEMSN0AykioASigAAYgAEESIIA6CqAAO2hAHQuQAIMM4AANOMACCIAABKRxAAvwFRsFxAA9OqCPB2GAHeuIAIEgYJKYtCMBAoAAA2Tyk3U8wCL5M4AGFOCOncRkA2jUSVNmMgADACUmC3BKWYKykqN8TwAgcBA62lKTC6glKAmggF8a85cHgYAic/kdCHhyj3Kk0TGnKQACCJOa2FzjQKxZxzhqk5nZcaMsowkAX2LTlgG45jmP6SsCfLIBaxpAAiKwTHAyBwK/NMBALrn/TlAWgJOZNMAIhFnMfh4gAAhNJyhXWdA6ypEBhVwjBAiwAHsa55m2TABCF9BPWQ4gABgVwEEfEAACEOCj5pykAzJJ0IQi1JYHyKQe7YhRB3zTorSBwAFoWYFluvOYiYxlRz+ZyJIe4AAMQChJXVpSjCpgAPycJC0VUFSXDpWlA5EnOXGqGgggQJ363CY1DxpVf1Lzn1BVAAI+qlSmIrShd1SnSt0a0qtWE6RSjSNXSxOAmMoSkvik5lN/Cc8FMICj+czkJgOwVJdKEpsIYKpQ7UpJuYaSAAmo6F4/U1eZIjSlxvzqL5O6S8vusbN7bCtCAYBQv1LTAAklwFETgNp1/9ZWlZvNzABOCoCf2lIBnz1rBH4ZWYSWFZMIGK4sk9rYhLp2mrANAFzhCcvbwjWTK52mKHNLGbx287mgVIACMivLAjDgmQ2A6jsDyda33nKyw2SsWx87SUHWVqO+taNGB2BaAfDXn/A1JncfU4FTOkCu/WXpTLH7UWUiNL92TChrnctSZYL2lfJ1K1wLwFZuTjKOAVgwTRH7SfP29ZPRve0rB6yYBIiYsr/8J1PVaUg0MpXE+g2uLIvbXJcSoAEGWOuDbZndD5v2oAj9rx0LUFUc27IALEZMAIpsTPAOVaMuHYBTi2yANSY0pQ2YqZW7udgMu1XCAF3nmAUAzx/DMf8BOxWAAxDg4I2+cc4IALI6NRplw6wZlAOQZ4KPCVw0B2CQWsZkdGNrAAP8mZIJHQAEBhCCblaVqY8uL2oLQADl2lHEHD4zLNXJR6YKRNIGMWmf66JkQkfarkh2bAIoSlQKy/IAK20AaRMgTA9Msr38HLRU43zUq1KXrrO8ElM9bFOBpBSXq3aLh7W77KsmdcLOXPInCw3hTIpS2QDw9CeRnOmFWtWuZ3ZyHRPZySB3e7eZhGS0yyJaA6RR3bY86ZmtLGwBFDeh1y0xazNdXNYGGLuw7GihD03Z9iYAASb9JAFULFIq73HeZbnuj7FZAF7CEgFqxfcs5YrlhAb2lw7/cK8tq9pqUMK229R8NYxB/cnjvhOUA0mAApCKca4c3LT9jeyFjdnZWCf5mMUVdyb/LV1j4neoglQ5jJ9McZFaFgABNm/PszL0otvSACKPsWeZimKV1rmucEbApQNA9D3aFZ6JnrpdF6D0boJyu1uvCszrHvAPvxi6S3frcWFL2yAL/pRPFTXbP+mBQv6dspY1QL+NPUl6nvisB9hq3pWygAOM96WYBK7NMypsuTo51IK348IVz/oJexeTIki43L/++tnTFJYmlWy5k715pYAW3nZs9sHFHtA9RqDlm1zAMxOveFS7VbaZF7XrJazuA5C07rZX/fAnv+NGl1zUMCds/++RsvhJwh3Oyx/9OYEbaJODvALtzbKyWc/UkBrdrdOHJa4bTcsQAD/7mcQA9FVfsvR4mRR/rBd+v1RP4wcUQ5dk3GcAQzdJqycQZ+Z6E1dH6UV/CWVzZZZ/EjZ9GOVrwQSAmKRRqNV5AfVR6nd7HJhQ/cRLDUgUo9da2MQA2DdJ/waC8zVLdTZ/bmVxbBZRL1hSmURVQ9VlfadfyjR60TUAEUBRDFBnCrhuigeCVShwFph2NzWDMcFJCgB/FqhuKYZdxlaECPV336d4CcZ0q+V6HxVTJGBHOCAArNVPxyaEGphQcpVyZxZ/lqVWgVZQYId/sFRUaTVNEXBq16R5Xv+YEj/mAAdwXAfAVuBVVKjlaG+kZm4laaImV6uneJlWZrDEVg3lSSSQiqloh2kGXSU3gFLFVsN3f62IZN0WXeq2dnHnb8q2e5EFAJ31iCzRgnaUeaZES5WYUDl4V5jFfZfmWrQ4Zd72gsNHgRtVZIOGZNwnAJc2dMU1gXflUsdFXZcoe6E3YycYAOCYSQuAbx0XaMJoEieHTaR4eSx1dMNUVt8HXqGojuxYhH8UVyVWdYoGhedEWggFi3WkYyjmVrWmjpKXjK0oVT52j9toTFoXjyKRhbKkAKTYSJ/0UdXoX7A0T/E3j3aEgPYoAGtYhLt3S972SRUgS8hWXwh1ZJ3/+EktmVCP54fG9UnlZ37EaExdqJEcwZEwtVr+mEkOlok8WJISl24IkAAqSX8TNpJtF3r3CEp9JFkYhWTD54Yyl46iNmbf94BCGFkXWV9GCRJB2U9VhZJsFmmkVpVNB0prp3iDlJd6SZCYNGYBV0kBZ3l/qG8BcEafRJgaNm6ippA+OWGBN4FLeExh1ZYesY6h5VLihnrKpnMHJmc7OZmLxnq7aAA/yIFI2U3SiFwMIEwHdXBuyIMDoIcLqXjZFm+iZnMI2JrF2IEuhwBjlmBIlUaWORFedQD71V7E5ErbdmtpVgCFhJzg95eSJUvNxoF1tUqRBpz0dF6hxFaD1gA2/7aUv/ZghmlzMkZ/tCkACKl4j1eVFxaNnYaAa5ZIM4lJYSdVjlicCbGSS8ZrbvdJSaWCAQheYulScvWR49aerIdvbJVS6uSHWUifk7RYrOV6Y8aBCulvpPiUIVZiZxZw6cmBphUBC4AAVLZJOuUAjmZLRcmfBqFQQ7VwATZYGGZq5qhKYzlJfDmdAZijoGR5fxSGu1VLJmZqAyAC9chUFwZHcLSkDMmjaKh+S2plPilZD1dmpiViDaCYCHprMNqfE9lRWbZ/T/ePf+icaahoaAikdcSCVaaXPaparEdcA1AB4+Vg+Nam1diS3Xag+RVdL7mkdyhLlRmmA8EA2bWWN/96ZjBnl7WHSSaHUV3Wph9qjWNac5bqUj12aPOUUMo3TahXV0bnoaAqoPv2YWlKnS1nd+d4ZjCFqASRn5zIemBliBAIaC61l5sqdbHGkZDKgT0GV2U2AAzAkdEFAQ0VjRx4XaPJVAxwVFBKnpOUZAWWT6J2W14GoPbGnwbYTxwWAeLlpRsVi+7nAHMWaRnaq6IGZxKZUCq2gezaXLq5q8fUXoh0mqbqmx8WrPRXgzBIXD46S8gpThVqmRvqT4/GYSH1hPGXpS4FAdd0pXUFqEc1p25VgnbEckA1r1+KXOj4S/5KjUeojJnVpt3mk8CqeNlJZEYZqdM4UQgZfgsQn7X/VKm5GXgIpax2dKAh1VM4GoTJtqZE57EBS52OFWPsqpSZKgBGqHptWldlBnPo5a8vuZAaOZnlaWiMSXEjWn8BJVk9anMMmm6o+pYu2quN1XdLarCaeoE3Bpxl27SwiYY6VUcOQIo/p38FkK6dSFGpuUe4hGrjh7ZceWadtUlVt5MwC3eERK4fa5P0B3OLRU0je2ZLtX2ieLgc+Fz9SIboaZudZpgulX/HdXzX9Kxai5E3+6LRJpe3ZLbm95O/xKwXFnBzK6OYSn+MeZdKq7YIhX3TWq6KhZq4iWn4ua6pN7uTK3kgZmWEebXH9E+9h2BomrF3xnTrCWnZKlWgJGoB/8e4LrWE+PhLw0t/S/Wo9AdeXwu+YetWtFUAVBUAdfesQzZ2aAiKO5t9EsiAfQZaHvmqbepV6FpIB8h64jpesrSIOTlX6+tR1VVzkqcAufuCjaVOx5ZkKulaOEt/nXWltopJUFpbl8uH00its8dhW0e/tVRcIAmd7pq7EJUAHpeqmgSQOyZqBnsAp+lWsBthMIu3S8uppxp8ytm6kkVRaNhZGUyaM8VpojZOHOh6Hki7AAhl0QaErGd/NelQzTdrf6jD49TDmxp2kZWwVsiu8pQAzVV4TKeQKolIRai/dvtRT0nCpAmxCBVSC7eMMIZ3LFa6guxSVkZnRWVlJRy8tf8UjVqbt0NsuLyIwiLMrs+1X1QWa3+HS0mGUeJrwkj7yLH1TgloruooXvVogimJU7BUEJb6S/dJli+odPa7i6BUwaSZZxY3mlWYyC51YQQqpboLtZ5sR5DrUq98w6Dcy6pExkf7afQ3gBK4usj1aNA2SpfKRzTSpv10oJ/4o9VGe7HcaJm3UGw1YbQJtNLHsjH5vp2FzhcGwloMAVRWgcmckCYVfxZYkUxZulh4sm76ZKHFTBWbzu65TuebZW8rjsakxTY8TipJTCzFzS8Iiod7Ye21rqbaSsVcz0U4dLzMm7aXSxvaq7T6vqRJAEmlk8tbXhrqdG71XEf6yIFJviv/SYpNuqn7ytGipm7tO8PtWJ0ACHGL5NG9ipkAKlLMDHBLFnCrmsP/6tJJ+8lDjGMewGHVSFpa1cCT1Ml8Cpwf2IEtDMrXtYZqaGuozGdfpL5MFQEXy3oguW07+4LHfEchNa3gaL+G1rSYRKGNOsTeKQD+Z4PH69aSC8pl9ayUyGio1Kb85MgZKAC1tVh+GXz9pABTdHnM+cmzqYOs54TMzIMSR0hc7Y5FmIW0qLyHSbqbKmmNNXzDO333XM/q9m+wu0YQxqzGW7TBjJHqtU6r1ER1ZVlYFnB2OXz9SH9hiYa03MG4GqqzJFssukn5122FBtKRfIWs11wv1r46zXr8/5ZQG7pJclXObbq91RrEKKZRilqM2aRE1M1vtNyzOWvSOtxuWBaVfIpIl3twQRasE/ZiIjnYC6BHBYDO2Y1mGMWZyZzTZn3eDBeAw8fVUXxMfjiobjrZIuW/KdSqdxScoGTg6tq7OnxNotfXN1a1vRpwTQy3nxWRbGVzfuhkeM1UnVqzB93dbsV3LlVXKTd8BiCJvDxNWFbStWll0qxoPrTbeIuZkzx/R/2QZalYB1fMB8fLHH5Hj7yuf3e+AzACu3Xj1Iix5Y2fWSZMo2pLtoy8swSyoWxH8AdelvfB61TNL6R+agld32yd4itXBzDXkB3lbF6EtTXj9MeFFxZdIv8uWVu+tKUk3498t5DNl49b5obKgWmFaxVairH9fMe3nTt30TKF4WTWMhqAN2SBWtQV3wl9oih6TMzK5yIqakJI6FqdSRs94hVavIbLzbTJyzse6DjOgXD2noStUg0gZHzqV+9KvBXqx7E6MWKSJLTCEGoiFtHqkX83mj/s6P7ZsS+tWDa34ocJ1zic0E8JhWUW3AtQZCWHyI6qpi8IAXA2a/cY7LgKvyEZwixllz/W33RJyl/G2ZI8Ta67MNFeJg1hJ2EB07oOrx2pjP20ky3Hft7MVHooR2h4tt69ZAzg2odWtiH1iytdsgSdkERp7+WuqoqHxscN03Zsc5XEVBP/pdoHV27yBjHIMgEabhCCAhYKeU20CHMHIHmPhN6/xLheZQBdCqrPBMW1LsxoCMCtl6kwt4kgtmyTOKcKKNEhi05Bi/Ijz43F/r3Qil38976YBanOHUp6rV/QjvATMS9d8eQl5qfGpADmDWhfVeD7Dakeb6lHzfXNrF/GBOZuZVqX6+wZfu9g71gK4GhVaeOgR/YKTU261lJP33E36aJvTyvSDhGZcilZse06W8TrpHHXlABUpvmWmn/jDfgCz7tLh5nczYEaG3xifr8sBfVLy+CPvGDmNYH2O5QnWPoNzr1ZaGD7STAHP+0MkS+rgxXbKLTnZNXAiezu2tuxv7QQ/yb4u5R7D57p9Jeg9LtS8pvvvUoAXr4AJYzGE2WioHzuKJ3MVtZUDQ/egvWAFo+/TF5HN68wADFBAgUABS8MLJhQ4cKEHyQwhBhR4kSKFS1eBNBAwEaOHT1uZBCAQcgAAwpwPPnRo4EBAVy+hOnSwEcDMW3evLlAgYMGBHDCTNAxgQKaP18G7VjAZgSVEIw+fRATwFOVGxE8xZr1AMoFWW1OdakygssFHh3ABLu1qgAFBw74RKDS5kyPCmDGXdsR416+ff3+BRxY8GDChQ0fRlxQIEGDCPdqkHAh8eTDavN+xCuggM8ABBD4JJo3QVaNK73iLPjTM4KWYBlc3qgUK/9SASxvfmxgFOzPqGRbGiVQ9cBp4jEzxy7uksGBBsc5Xg0QWuhNAg0MOPhI0mVwj7JdDkBAtyNnl5YvI6CcXv169u3dv4cPcXHCg4wxHtQQXz9D2B9TdvztJZPyIg+tmGjjaLTkshJPAPKky8u7AHbLKcCXFnDLvAIsTC4q2mx7iUIEO3LqJQROMqDABWESqzjnPuJMpeF+GpCjGVn06MbXZIyJqf5q2y9IIYckskgjI5qvMfssYLLJJhcS6IEj3YNgLe66a3CjG4FqC0LNTvtvIw6/Oo0AzswTc6Qsq7ILNayOKwCBA8Za8aUHfESJOgPCTBAmL1VcsUrMiBvgsrP/XOJTgC1vAs+AnpYqClHMurIp0bUSmDJTTTfltFMkHQOgvoQkILXUUhfiQIIMPKUs0Q2VY2CABA4YDTuPcjNKOgfGxOlKG+sEarwfCayz0ByBhekBW6cLVjiYyupuwQRQ5CxRQI16sSMFAnxxAQpPmwrNjVwacaNrSyqtAEs5MoBVd9+FN17EkgwV1IsokGBCeQkbsSapYCqto0UZJUA7rfz7Njlfh4VNweSypTFWrx7gEUf/HCZXpd8SxgnNBKaNlrhsIRhgzAahq/NFpYyF0cDybATvrWXH27dmm2+2mV5RMQrAXpz70omjBniFaWEBWmJgJwUMLm43cQVANoCA/1FieC2mvXq6Y3aJTjZRjI128CY8SSS0PxBPg7Yjf3s9gDVkAWD5uQCeFsCpBBpoQEEvk6qKgJ//BjxwIXX2maIMJOBAcIwY+M/trBBkaeywf+LYJqMHTi7RNbvrD3OsjMbVuJCNeuBFC3f06OoABNW2OMmrYvQAAxQ4F01Ko87K1zanFrhBA9Jm2AHFhye+eMIIt8+iBySYwHiJWOfoXJtGtBT3qV9Fdu+36Jp5o71VCr24LG+3eDyo5kbpaj6xtzwprnvtj3yRPEL5wD0PeD9E3F8iIIHb6ZZR1aLnPMNMQAMdIGACO4W8vUgABAosyAAaUACe4MYr60od7hJwHf/84Q51HLEQ8EACQJSUyGWqicABTqIA+X1HJfW7SW8GYKYJte+FjJITnZLTHw6tKX8rAk8DDqA64iygXGvZ3I8OAEEoFU4iDmRiFItEr750QAIbgCAJv2SUGYJNJUTMiQIKYAAd7o86KSnA1QjwHzplqy5F/I8BTHiblpHOK+DZCf3MyD++mQYmcevTU2bYQhqFCYZo6x5sriNAjnhLilSkyPKaJ0VK6geSe7GABDCgQDd2JHw20eLodDM/ge3xJwsg5EtGYpOWECCJxPHPgdrWEudICCe9uaNcTFkSOY1mYfID5EYwZhMIiOdsRuHd0RaEwbWwJpFK1BcTLymRwyX/rpLXdM80L/KBDygwAP0BYyc3IjnpzQUzn9nlHo/4w4wNqiRhColldoUVXOZOJancY8wQAIGE+TBXfnTJVAYQmm198yPDfJwAD/VBRi4RgtqESM+Sh02KTgaiFVUIQ6tyTJhgMI0BwJABDoBPVuaFo25Kp1E0aktsqcRfWZLNICdGHI0qM6Vo0yON7vnH7gRTAIfESgX6o4DwGABl36uaAh7qRIngK5oYherxmBrVCFaFdwWYY0l8SqtyZgV6KmnTHiuXnCwhVDUuLYlKuhpD1UywAdpZ302LMwDZ0e4pNS2QuMLzEV6FxwEdFN1lzvXMHCURhAq8KENStSqqNhYw/wHYAGMdyxBLJRJlIKuKWRdk2I1kVa7JUUsBFLRKrNxQhObqEJfeMiLOaBSon0WWTy20pt8dy5wo4RDYxFgAwN4EqRw5yxHV9tTiJbaJUppscpUrGJ+C1SWvS4oZmwtC2MaEnX9sp2a6Csi1aUx/WZEhM2VzxOqa0kufXJNd6DrGMr7kdYvyaQUcwFuu1bQj0PntRhqQQOMuBAQPWW6ABYwRocJmRhg8KbCC+L3ykislnjurR35YVIyNCMJ2RN9lugKxBgOLAAdQQAIGypGwureOT9mbhKaSTAmfMAAImllNBhCrpOVlAATsr0I2IAEEDtjHP1ZIZzgrprBgRmI35f+dWWWqToAy6CMVqJMrNaNZehZZw535yKE6vCDzOIBkR7YJhC48AEqJK07USmteLtwZzmzQACK2jAIgIFwBMADHjpmAk5xkzYRUE8h/HvACmMkRHapEQWPFXWjNapkEf24mcXpJosBYqY+UeMsB6A1svMMnHQ7As0BUS29XpNE1i+QAFQDjAsSTAKOVdchQS46XZJytGzsvSQcxVakmKklA9zq5AWCmrCIwR3F9OqVEq6XC3uhTsy6AAFldE5Qv7RIIjKAl+a2zgNKlIALYqtFYoasDYHpdrYkyUDThHCOTU1NKnZe/U40IFH09b6p6MTbnmtqk5zxLuVqrOInqilr/YyJoudG1AXsbE1jAU4G1ctlGImwAhoQ4ppKpsjvG5mJeUIbocnskanRmpEfI5xkR32Qqm/PJVKRTk3dPlCJWxCK9ZU5Rgl/Gc/3bbpjKCZbqiNRCMWvv6m54GmZn+L4lt7KNqrKZE9XGYJAzJZq2pcI3FyeZVP4Ji9lVNAQg/XOVjlooQ66o78zsXFWRbwHeOsPWFIRkxYU3QzK5yZnXXYrTNTRMFK0c5jhOJh/BCpp+4yv2JT16xPnqOP+ed5Db6Cp/IsuTpevdBQHAucW5TOga1PAAZIncPxHn2LXkkr3hZNCTe9m9h5fjgnDT7q9notjNJzX6wek3Pi1nMHEF//a7mJs0gFflrLIje81k2SUFbrEHBX7Hj/0mkdKGZV7oJK4fImhouMO7fu0tGqGfGCbIX8tZSpZIvwmO9fiBffqd1/kXIhGk/cGVT4Pee8BDN6vy/Px3dH6gRNFK9Mp8Gksrlp1KqF8pl/yLjrUInbwDDr7KCp2YnauZCkNpCbpimJhiwNuKECRSHNaDDMlQvxAMnM5ggGSyC8KCGtmLNAcEPblYJ1YiAJKaDX4TkHXJjf97LtjZH95Zm6c4rdEwj/kDt3W5kaH7iTV5raLxiPmTtARAp5cAP5sLEICDH9HrwLhTiP8SwS38mSj0CJ+wr5pQwRwspYy7lffzvafgOP8UayaQapzGax1JAT7sM6brEhd/kZUEwDhwy5a1IT+q4D2jSBRQciebCD3vMcTswInsu4x2MT8sLAgMkAAL4MJKlBcI0DqrEBBx8Ynt2zr+mQkHwLqXEDzS+8IOs7ELebbt2JPLYJ9WM6UFGIFJC7NY2qO9WZuF6UGcQEIfXL6XqJiSMjAN7IgjHLsIuEKXs8Rl/Bn7mrIxYRy5MbyqkMGAaiufuws0Q0WXqsYkixmE4h3Oyx3/qaeseBEBRBajKaNuG72vS75T+sXua7IDgQ0Oaa5hUrhXU4kKWD1IZMZ/ZJXLqK9VvJD/SBQdWsNpK5pHS8LFm72DmbI3OYm3+qP/0vgd4vAVD9Cvanwnkdsl8yi12UifrBhEnvqIMZOTbAk6N0rCzBg0A/A5uKk1wIEsyQLIm5QXT2zIE+qfBagRRLybvDGlD/M7D3sjeIxDxFMwFgQ3NcuKAaALAyCJhCwiBEAAjvSKgimTJaQ0j/QKJ/wYPbwJuiGPb4QA6KoKlFkAW9kMnHTLt/TEXZyrCoDJsfCdOkkA7EiRATC7qOk/fNKJMRrFdHqRG0G0xhNCYkLA5KDKlAqppaGOozQjsPEOwtOcp+GMYHKkt+TMZUy8M9yfchnMm4jCNdlDQQKg0by0ZNKyp/DCeVTI2Fy3R1NN63qfLDkbJdKlAHiR/erM/9+sxEwUgNrECtpKDkYczlGrRzNqTDaEzSpcC5aatuaUTWD5EK+DCQhQCwdYx7FzmBQDzvAMQZfQuk8SkF46zZJwyE/EyP6oTQKogKsENthoSJJDmsVct48QwoRhJgFMz+oE0AWBLnSMsGHZkxTRO4QRzwW1OwFpvghQALu6CYZKpRETAAfon0LcStjAyqkZQ2LanG8zo+MISW2zmgTVjMT8jrrarhhMJ+qMTSIkOv/QuJugNQbF0Xnzim/hEy2jED6RMuBakfUBzTcJuQJJi+isLvCQz+NsCRFICQyFiSxJTBF6rWLamgCtE51wAAnNpbUgtygUMa0DKjobjhxFU/8fWxB2m56iKKqdbMCOcDaGPA0UPA86spKoSY3PioqKU8I0XE8iswkevLSgJM7IZBaIpEbiyMvaIA8sPUVh3Kg0pVTlWhGwuZqs2R+zrJPTyxZA+cz70tIqs9GmuInPHCYGyJa7EUzYustO/Yj/nM+1kNW76o6iNBHpq9RdZZUH4DPKwMvdpL/o+qzARFDnXImZQNAolM5ZrQoVHVVMI5cIbTNhzc4MhEpouinRXJHTQr2nwKASzQoG6EVVoosxUokCSIw8+1Vedde+uABfBdYF4UsjNElRlauFuT6dsiD9sYzC+1MdjFbegICZGY7EgzB/Ik+Gwc8aMgrjpNd4NAr/uhHX0+iWCWGoddnMwcgzDZikdwVZv+gAeT2MGuK4b2HNxNQd2LKU0aArR8mrgyIY7eAYL8JKc1SXgtqlBxCXkDgvpJTGNBuWQyUOiF2mOWSUBSiRn3TUhv2Xl0ikGUkmlDseJvnYkMXaKiJZwkApa7QuiWWlj7nZAewb2+pIIQWWRDkkE1ovSHuK8aGQGdtDjnuA/vtMrnlZLyUl8AHbEdXQ4mAoKrOMGQk3owoPyDSlRGkTsNIYwTAgC7jarJVcvhhZm/wLsvUIor2p6UqUAGnbfUKWYHyxlIDJ5+QjyczWdlwQijlJb1URCDjNz4yAlliToZxdqE0KcYwdkQIj/y8pMUCC05JQ2qzYGwVJlApAE0f8i8eN3Ml13r2o3MBI248Y25sCCzvNqV1aE4eBQ8HdTT4J3hjaGwLwKe1QtY24yJ+QuguJ1LmCxv8IK+eo2OOkPPZ7R5yQjlITIe/gRKNjOb9g3ucVYMCIXovgTUeBVpFMSuq43Qbz1rRMqYWREPgzOaMrRixDWuJ4AO5a2I7QsmB6H+SDLwRQgApAwNQtgDJyp3LR3VGKCUwFRpnNOrM9pdLorb2BDrY74DfjGQ2A3AEGYsDIgAewXIZwVgEwz+LALOiziWhExAazUOBS2P0JmjhhRyRuDaHNi99FAIZDwzKktdUtCapDmdTVjP8AEZdSc9pTBdLsuuA1md+bmBXW8NMvBhBqy0BJTYrwjYlEQS+1qYgA8GG6C+JC9oshLuKE8MIWXpC/hS1y1ZKSyV7lGy6K6w/yGJuaOA4v2w5rPY1ybGJWiwmjbbByqQkn9rgjfmKcUFUEiABR1h+mvbdADZ8ptiHRxYqTO8lmEQqJEGQLIGRDFua+GOIeW4j++yzyqs4BoEu9reCi9T4/uYywCqbhWA5a6eNJ1mAYNcFLe5rmkg1xobIUIx/DCgkzPiaGurAH3ogFSEl2UkeAoYmI2gBgHuZ7FuIHMOaCQGapoMo15LDphC1crqF6pQm9DWhGWZY4tpMFMZrtOgD/cdNc6yKAvfmrzHIhYi3VdBWQLXaNCCCkwl0rfcw2rIirl1gTdQ2yDXiAYMbnl+aLYtZlzFjjCr5iQDUj0po2tFINq9yJR6nFDM4J8gUWUPaK49hJpk3i0/itRtVQCxW1mEBBzmDnLconfWzWZ/mil/iehICslobpsAYMDngAzhJRAb2Um1qjQNqyy/sjBBAipuEYno7FrisRo2Y+7Oy4w1uQ1xy9bj5ajJ5GjTYlVD5RlfrF15wKlgZBsXbsvmBEuUSWdeFj+m3fBlsTFWHa+kkYsFFNYfu9w8PrxN3lRj7JBjYaWvyJ37odkKvpRRy0rrpbCVq6FniAxn7s3MYI/+RUbV5q0k0kKknu26ghMwvWr0tjKLlMpvcBG440Dzl5i40GkNHeo36eK3vlzURNjgcOHwxZF0Y+Xyx+2LxIT/mFgEErgI3V7fWmCPc00l/pZGGpCqZxZwTo7SZGo5SeNkgmO5vIYz3mCHN0v2ymH+o2o/4N7Ics6OZDFv6Gb1MklrJxn9ip0a4dXc24ikPUDPbmcIp4ta7SKFYrly61qmFli1MCMdDN6LxY6urEbkLUbq/tqArvIhkx8P0p2DJckGQrLw45RNBy5KoWRYd92tX+CI2EkQ5X8oVQ5VjajYQhvjp7Ju8IcTmecOMe7upck2psOu70CkPJbiu5cTO6G/9nfpgsVciXxEaveKZZiW77zXKsyTKxWPIlD1KPqADp8IAgwArhpF7aA6g7BPDaCFTN+I+vSYD7HurqxQkRYuiscMXtOwspARYYpeLXBhYZkZ0sgU/0lR7s3Za1eHSYcMbMrfMO76TcGCQDuu2WGpauCKYHsUVeJhtxyQ0GKJCflKO5MqZapRGqS+CmQWk1M6yCGvOBHdU1oRPYuBZPtAqXYuSb4AAR6A+VPnXdNig2sQlWvwCcCNUT9ZX6Kcw2dcDTuhY+aXFelMyctkpFH1cbw6CGRnbYsvRbRg4MjpCb0MfSpeGcADEq4wAKeAECiAAEwN7yu/bH3j4S7lKDYfX/DqA6h6kaLSN4Djnv+11xtA2AsQGqmiI3b8X01FNd3Flrmc3E3zj2eQ/QCEiJfXV2myqfvBDF+iX32OCQgM+Af6XPhM9tOiurmDgBD0DyE395jGel0Ii4vf5WNjO25t7QDNqfhzYvC3JGlFf5oVSA5vD1O8qq/sBTmzuipQ6msML5MB9ans9tsCr5C+ZqGIFDpkSWDVI7d9fiAJ9RuEeWZEr3BUkm2Vh7oZH3q8cd21tTRW88dBS7GaqKvpKLDKCADFhBhsFmtBfrKLQL1415AfCAFCh1uq5O3mHi0H5w3CHlROtXMtyIeXKJlKcRJ2T0JQ1EH4RulOA8w/bg3zAi/86AVO/5DLXQ2b5RDrpoC5VQAcjP/Av14HSdScrHZ8yCDsyPYY8Q+qF3Ka8MUMuo7LYf+cF35NiK5o1/wsBfERIdY4kG0IRuwcUHPRSxfe3SftTqDBqMCQjYq6VDEz7xABO4CcV155JT1XkGCAACBxIsaPAgwoQKFzJs6PAhxIgSJ1KsaPEixowaIwbo6DFAAQEiR34McGAkSgEeUqZMwECBgQMDStIEQPMmzpw6O87ceXNAA5EGGPgsWnJAyJEFeho1SgBlgqYPbOakipMBSwQpFTTtuuCAgwYEdmpl6XMAS5QHcBpI2Tbl2o5lUTINQECBAwULeCZN61doSqI0E/+khVDyKcsBGxczbuz4MeTIkidTfkhzwADEI8d+RPp3JUsHXUcHsEoTwkkBDjiTzok2Zd3WPxWIVBBb9k8CrI0+wG3yL0rBvg+nRNA5QoSeWFM28Dk3bXOay1H2Hbm3Y9oEBN6mHEsb+N8SQFbqxbkg7W4ImulWbu/+Pfz48udL/sjAgUgHCQ4Y6G/AeEkINMAdSifIsAMLIsk03EcEHIDAbTcRKMBuDD6nIIOjmRbAAkEJYFtR3wkQVVe94SYicBVk+FF1IvX0HIkoCrDAhjSl5ldcAaYF40dpyUhdAOB95kJRr3Vn14Qp0bckk006+SSUGXUEgJGbeZifYTqatYD/CSMZsGIABAKY03pCgRkmS1+eOVqVAiy104Qk8ubbhX6NmWGbIo1VpgCCJWBAAQv6xCddNxFm1gAREJClR/il1GJxQv51nU+QBlDno1FquimnnXpaX0c3AndnaXk2V50HKWRYJ6U3YXrmj9GBWaNOoopEaknTKVWib56hdKV1stGaJ4UBAFsbbkmOxGhnLOW4wFsLlglpmmk5oOxIcu7EwLERQCDpp+GKOy654gbAFLYpiUbTc0vx6YEMEwwHqYo5HZrSaH8KYECFdrHUb1MOHiAcaY7+qtO9hc7Zq4dD+YrhmgYvi6maslXgV04RoORAT+cBGUAESTVAbKQogTiA/8Ee5MAAAglE6OpWexGaabk123wzzpGlVkBUP1qL010NQBhAwiOdYIEF8srmYwIu/+TsWQTsZWu/ouZIGoFXd5UkV2SmxWuGjA4goAIAM6jriEWPpDVppp6L09gH7PajnANkaStLLh9QgAHaBhCDCC60SnRIDkRgHtT+gpdAzo07/jjkCR3rkqS4emQa2iJ1dMEDGig92rFw3bRexTndmGQBPyGAwOBd1UlwUxofqVOLbOtk4pq5X8afAkRRK8DLXSXMd35m0wRp10dJnBUC/XbwwAafe2Sr33J9jd2opUW+Pffdh5tn6ng/yiycxX3EuedGDQDW8v/+lEDzPokPm//ukNpelKiWl+SxmWAzGAECDqc7n6SlAARjwAHkRpqvKOB15glKoOx3E5s4qGV/qRjnovc0s9joeorLzpS8J8IRklA+soPN/EYSvJvcZySWQ5/0NqiU/KRpOJJaIW4kaDqh9GsBq8Nhg1xCGtzh5mFvkk0FgVgSSGlLVMkbTZJK5xH+iQRSrWOhAgrQvgNkMIYNSkvr+CSrc+0tbx0hAFFKqMY1slEjmRPAb/5SvQgkEHaXQokUSwLDnPyIKKFLXRGFlEffWOVHApTQ7Aa4EyLKZnnrYpPEEMCfA1yxJEUD5BnNGAAGEKAnCcAPv26CsY/YJHRiyhdLPJA+nbwxQsf/al0U18O4NtKylrZMCEsUAAFMuclvEDilRzKnP4/skSZpUVGdntgaIVWSQW0aZCbdokifMHKBYCSNz0aSHLKMxAGt+tFQ+pLARPKkgKJ0FgF+SBpMDawkNWoRNC/lgAKAaENR/Nct86nPNlIxJn6x203wRim8PVInxfTIjs7FkmYaxVYcQ0ADmUKr4QyANgVQ0UQvxsFp5qSaRdmPywhlvJxISgDD7AgDWhe69rEEkwhtKflAwpJ6IfEv9wtmLmMzUUtWyy37/ClQu3dGl9QpUME7JgO086MCIGCegsJJFz3yo+tAq3gZOp0SOcouD2qVJh7VycNGlJaseuRbJb1p/07qlC6FeQRTygyARlHCUJ9cADTo6Qz5xpaY1hDIAEsNKmADezNjssSOJSkgcFqEw+dpMKxaw8yZMjPXrnYEAglQACUVKjrKehWKodnsaFj6z9FAoHY3LM1HxHcbYLYGA53DwPy6loCkgMgjakMrwhrQgKhgCgGC/S1wO3UUEOokmyUVAG47wtgA7LIBZePsmnZqlwRWKKxROeG+jKLRoYDpq3DzSwNCwtSaltSwO1lfbQagNpaM0SOEumIFJ4sTDFjAcwNIV3Owq5qPLNUos91Xv0imgOASuMDx6ZCbSHVX5i7gNlQEr0h029KmLPcykkxATKHLIGA9MXR7GVv8iv8yoZGScpFe8YtLc1hSstIOLtSJ0INFkmHf0Ddp5/qdSKICKdYQFH8toQm2DmDgIRP5MWh7oq0AeaO3VtRN4pMT3lLskw5QYANfVAqLNbwTtbHGL9wNWA2lu7Cm/CVDaoMUNP/0H5/Y5L4uPNeFdXKs5Halxhhoa2KJllCUahKsXO2IcSFQ5EET2iJWLGQ3Z2Kr9h52oe7NSmuozAHs4VHLK+JaZYFD1ldlaCpstu3PnImisRjRlRub8WXMW9y16UTMJbFzSYy7IGppK64CiI5030scvzCg0L7+NUOefBQ0lnOvOLlQ6ablmwxQYAZjlR8PLX2T9lUsXXS2nrMO4DL/+Mm3s6gkZ2vEl6N0mo1PJ8XTAiCAmmi3Fml37qD72uwX8vlQgUUh1Gr/Cex981sgQUrLIVm44GOPRJmQyjJNUPDsjywAL2JBE0pITFlb3+rRfinoeUv6Vmq2xs29HE7oVBiiCfumwSJ2S4TlC+tgaqcjMc5uptOEWYLtcuZFgSfBfdrvnfv65QJAtWZTMtnbECvgHSe5xdcWGmkfpTopxhajEVbSc3u7493Wic9z3Jkr9lc2IRMKQ2cm8pxMwN2d4c6blPWRkL/5xiihOtpC+RODGUDQPL97kYl17qricQGqnmjRGXSjlRgdxyhh+lH2ZtSSYEviR5FkCt00Gu82/2WX/aleZ6TG078IkO8FqBCh4qkTPgUv8sjFSdkt8O6PTEg0Re2M4WfyIyA2+e05SSoB8K77Ird+9JDSYtubkiSjy+aT+0IBBSZdbCEhvikUr7hseEkS/8kmrFEPgIg4lvTCBH0zjN8zTvzt3ixCOud/kfIENKB6Gco1T6x7i17o2Nt/mw+sysLh7vNP4O28GG7rJa5RvJzjFYVVMFsGdJ+mNd9Z5MkAIs5fXF9HDcfzVc2jsIhfkIhaAdnSGYVxbdzyedlHpN8DXMDt3RV26cWj9ERCgR9O/E4nvYz+xaBgXchNmV4FdoVfXF1XcAAFZIBobYwCIgxtvYUB6CBOGP+XquEE5d0ce8EPUywYylBHA2QWoP0Z9iHdToidSemEfv1YAIggCfqZsakX68SR7UGcXKFhsKiX03zE/6mGVZVEBABKA/SaDN5hLdHf4cHMcWkODqaF6A0HB9iAXY2IjDSgliGbuoEJAoREf7AbhyjRElYKcKyF3s1Ei1TP8+WR2nggTRjXiKwQGaaTyXyhBowgT6RGbaXWVrQge7lcK25SKz7HndigSLTKheQeHu6iGukaYfWhlO2EaHHUDYgAC1CSTTTiviShAl5T+J3JCXmTiX0aTjzfkVwQFn6gSBBfACxPVrEdHimRDyEAA4DhlJRW/5VEXOWIZZWhGiKLy2X/Ud/Um9TIY1RkDmtIXywioJvwoj+OkPi0irz14RaOHqCE0sx0FQ8eYIMcJCJSlt51FendznCg4wXBVR+OzhnuTm1cndqE3ACa40fUyf3UxXo0B5fxYYTFWg1p476gzvap0D/O5Pb4DE6Ax2qI05TgRNE0jY9wFg92QEf0ZFVYmlndIEclyUlNok9YngG0z7rYouQBTSe5xt7ox05AQKsQCFOZ005MwAagogZKU8aZT/4IXP11RJIU1HqsBd5UDL7RpFw6To+pZBVJDbGhVFXuREkdUVGeyQZQwAtYoQKGHDNmyE9GICMmDnNpIfRZUynixI3kSFMZFS81E1g+gFDy/wQDMAU4OQfJjePL1GVHPB/bEEAbxthupMlctibO5AnmhYqXIFxM/gVtZggNpAXBSBeIGeFoiJRWKSVFgkmexAZ4QOBOAEDoGJaM2M7MmNcGiIAJ0NPUzOYHZQu0bdROdJ1LTlbC0FQ0VZFiuCZ5lsvwtBNOQEBnDscbLRyeAF2uOCNospoiuacideEKMWVXAAXYwdvbVdoyMaZHEEuEUMtNbIAKlMBWkKUT3VtL+sSPKBPffdlZREAbPl4DaU95bqi4oNdGDlCLQArGXc5oMAAR3kUBFMDDsV8VOUWf5c6FeOKaPAeJ6eeZAAufXNsmRcBesGB4BsdPtIjRBWYHtP9nYKAUdTXF8jieapEoTyiRdFHFnwSK3XGolXpK6Nib7qANHYGbk6oPeOBKnXjACGzmdj6o7syFjuKJbhSFjTKIVSxAy3HaeRmMczna/tinJdEhwQQlti0OK8HEUw1odTgAfBLLZLUZAvhVA9qEjIznlUZqk6zPFJ4fEO0UrdTbAcCElwBKeVyVkJhkTmVmGObEH0VWTN0mZb0pNXaF+DChyVSH/kxIINKEn+KZkBjPhVAKAmXpli2cdKENeG5LLkmqsdLHG0qTq5VYWlEHaK3ID2KnVL1iR4ikXUIMgxCAyKiqljElAjUQfJIGn3xJro3VZaHnTg4odxhA8GQGayz/5GV8FhB+F4Oe3050IfBwk542K0scq7++hx6GqoZ4DXjUxbLqxFppnUdEUUlYK+zRT7YiZRBOo060C7ciEpD+Kp4WBQNEQBLORQEgH0Pa5VKICLsCDbVkRp7pxFF6yU6kENX9KUr8K81ShmMK3YpkXcSdyc3WBd7YjsPyxHc0gG+yxYu+RF7oxsWeyRK6zZpsl2Glk5y83IrwX0p4AA4xUN1ongOOFSgmV9EwFMk85k7EmJDVLNo+BqGQn3bOi6QYoZhFHqkUJ9mdYqnWJ2OuVwOEa1ct4XpBVxSOhGBMCHhCFmm8YcyORjZ9iXH5JdZt6tCMHnBcncWmreUyRsDC/5yMJO6gSMqIdgUFVVfTZMaJ3sSETlbQqg/XtlhaPmAQLiGddtWPVJaI5Mi9nOwf4kjuiBZRnJkDVMDSfoS6Zd3AtMV4ZaECCE2VXi7zYsSFCAeKyGhX4Ktu4gZ2+c3BPmlXiODqjZxQrFCd9IQWBu9wLGGM1SqYtKz38USrKFtTGGlBnslaMoU3rsmEUptuqItTPMjyNq//QsR/ucmn8iPnJl6KkmN2oGlXZE7ULorupF737tC88tHO/qj7NN8k2sphEicA0kT7aIt0xUACQmP1llUZreJNRABmNSD4YFlH0EudRtz/zrBDXMidvF7bVIcBgCO+tEaE7hrZngkE8//lBeeEnBLfCCMeU07pAFOWFZGUgOYEs3EAtUjjmbxRbPoEgWyc1DLFz5LbFI1S+OGNhtKwGRdE5uarbLbtM37E8+2HpBRFTDHsgBZx7qxcvL5oV8wM+uaOwAgGq2pZ0SAnE+3EFMMiVBStT/hqa9RJhRAIZ9BxsxBmj7BEBJwxJhNEe9aL2qDvhrRPdBieJzaYtmKrGdJnaSrwHZvdL1Zwa3wFoIzE3mpZ1gRAIAtyUuBW+OaEpD3eg5DvTUAKcupE+yDZXsVKMKtyo7VEJjfz2JJIizykWuYSP6ajloQZh2zsFVYgGyqyT+DxGnfTimQGMCfnSP6LjWav7vDtKZv/TS/jhjrTBCOTBvJU8o/xCcAwcPkIXTNnctYBEn+6iTTLrJ4wF3QoQGwmK2uUskBfsyyfoCKBM1ZNrG9s0S2ziYYlCsAMAAqIQAuUc1HMIYBNZLi96J7RohG/hQMcZpk0QD9nsuEJL7fKSPLMLuvayf5cEWzq8RR5s0fU2OcMwHpStG8gz0WzkkoHH9PpgF05LkddiE+ub8fpcEm0D2uwIfn+V4pW3Euf8dju14rISOl4nEgwI3joKAP0BQBlo10kxecxCH2tElELXt4cddeWn6V1wAoU4q1B5PXkZa8oHq6USR83ckrUS1efsRbKHUXpqdQWhZCws8tdx6synDbj/8ZBzXX16a9d3wQPK1KvRq5HMBa+Xuyy+qJWlRreQmxi0/DNQuDBAidYVVKuFp8C4430dkVmazabnASV2nKRXOW5gYdP86t4bg70yMt6gTTQyCdH1Q5pLOsbcUZrz7DOSmsgGRsLOcpblwQPj4iKZSxVSPKK7DYrNjRvD6cYumxOxF7umEpUuWQwDtAG+oTxYaW4UjKDvJxgVPcMJyzMEWAwQe4vkSWL9kl8JrF5qNNReMhqfCI15455d0t6K2at2LFDM0eapoVcTytUjDNga2QautNWfah/7WuGvJFh+PcMF3hiZe1e3pFS8N2+BM/zvdUbDmuDgIWJD+hdl7UiHf9U5sx3ekPACMyVDhltaDC3jPcwHxYAN45Gw/WFU3cGRIk2y+p3CbIxnuRgCLF483614MINdzRHnnBFajw4TpwqT0BUBfgdUXAL30S5i2O4T1zvTzCAZO9EVC13hV+z9rnis45OBbAOGA/Q+XaVshB5fhcWPXM5buAetkgUmDNvGivzOzYQdKRElL8ln7lydibmb240d6zpTjAWDGj5TzD5fO6K+Ul18wHABYQAznJUCgFMPHtorXcFpEQ5myRsxVQ68wZwZNPEy9nifKvmCyOlmAHHMI9Gi4yJu/qGXvN1bnvE19W4hvV6ThDIFB6Ar1OWa3kOExe3UWTPcMxPMC7/QIibho8WxaL2zcKCh+MKe9rOT2UDMVS0FIqDzBkK4Ln/RQFn4fWISAH4NFNbp4N+TNso3qAScVoaCmahSGGvCVCzi1Ox+lcbz2lPSknUOe4uEU8LY6WJ+Yy4k73TLLFERZ4MEoFurqorLU7ZuZK3FDBjygBQHKMXSUfTAFklSRa7htM1BbeXbRRrFTjPuwsT0k1e3Ia1FIbtT4i2DLPUyWjUCeVUYk2k/L/iG0FX0rHIlqf2qIaPhqpbdpqEO4kTvFkAXIZQmZVB9tGHOnbrq6u/LFtHNCsPxkyNzgG8OW5gSqD7BnnPhGMSzI0cPIdALg4lyd4CR/VwPc2+V5a8/4TQBA8EXIkn8gnPCI8XcmwCQNDqKMVAC/pIVID6BjG1J9+XinzEGwUoN8WNDP6FQ3rxzVMdfkTSe3d9ewSwmPr04HW6J45UTuWAEhtDB0u3vyK+w02DSb6x/k7Ir/1RDLVrELvCOkV4MXYWuvWeaDdFGUxc7NiaHLJxj93WRLj6HDmY7WNrmAbVBMDuQ7iBDyXN4/3BcDD9ALiX6ll9pxtABBAoEIEAgwcTCKxwkGGBBQMDDEDg4KABCAAwZtS4kWNHjx9BhhQ5kmRJkydRplS5kmVLly81MmA4swAEiDdx5hQ44KZMmjqBBs25YKaABQaKIhC6tCcBngIT/GQ6Ff9iBgocgB5gSODmgAQRhEadyZVqgAddCTAAipTh07I6ic40YcEChqkEkt5ky/DATptLBxQV4PYtXLYNHkYQvPgg2ZuMF2g12BfiXgEGuoptKxBv0QIwQYcWPZp0adOnUb8MgOAAxZkJCwuEoMBgAdgBNG+OzZT2TMkzFeymWtCgAbcAhAO1ijWnV8cDfwt4jrMB34EDCDwUepZzdYMOCENEUECAgvDJcx888bZ3cZzkgTNga/x6Tp9jkzNlvP/8/aLeDwoOogQMMOA2iFxjSCkIGCMgtQchjFDCCSmskCSBBBMwNssEgK2zmfITisPLRlRqKeSSW+C8EHVabiridNP/iYADDnDsN/CCegAAxTxjkar0DIqNAAUUOBC6oqIToACJDjLxOsG0E4oBBQowYDop91vMAQSiFCguzwQLD8WcBOsLSIQsTFPNNdls000UEzyogt0+PKiAgYrSsLAxgWrvoBqLWtHHQWOzKoOl4FOwLBhry9G/mcCascbkBhB0p/8IvbQhP4vzTa+ZMFuqTgGcFDXL/SgbKM4mBbsSqFVJxa3BN2mt1dZbcfUoAAIIAPKpBSJQ68UwBfLPIpwIQMDVwh41StbahM1UWuEMDarMsloF6gFOFQSwPCHhM6DLgSbQQISGLH2LzwF6O2CARPmDaIC9cEQ00KkC0/KAEbeC/+jL4hjId6Zxg/I1osU+y1XhhRlu2LTcvE1o3orSHYhHEAdUFqcBElwyxIule/ayiqctWSgOKDg0pxGNxGkB7RjMS6cH+J2sqGWB+tcgwsp94IIAIivyL5MHqhm/gRjgNYFohRKYIbCmShKhXfdr4CYIEjgAAbc4DHU4O4V1uqKLHC7b7LPR7qjZXhP4q+upkJyKQwd85BUqUInOuzCUVYZo1DuBIgC+ArjKdmZuaxtRT95k7vlnvYE6syjtFkg0VcAMfxHebw9mzOugJi6OZJwg6DVaRmtLW/XVWcd1xMvFNohg+xj6vL6uBGOaxc1DHpRPyPdO+SbBRc85UNQBn/9ZZ9FHtN3emRpwfNCkCcOO5OgIxFugzUsVsajdFqhg0oFQV5QpAh24vCzNClALcQZaj1/++SE802qkMxd16avbK7XZkCvFopjNpHvAI9rvcsK3rlSMW335DX20tavBbU0hMqPKiFzgs+klykTtacDQdOKVBPDkXXZ6yqiCNBWdQW0pC0jL82gyOss4z1QzYZJgEEA/He6QhyoJwGLmNJDlDSY/HHLSAJ82OJxRRTAsNOATg4KyDpQFVqEaAANmdxPuAG1cJbRTYVD4AkLFLgGcoqFAEMgZjZFPMCDcWAUM0ACnIEABB8hiV/YCQZ0Ipl5hsaDckhI7OfWQkIU0ZEb/yic7NpZpdDr5H0SS5K2d5UdqULTkUjZAgSkyzlMSGV+OmnaAAhTAXbFhVMvyUz7eETEnaZRRj3CCIi9OJieSItjbWvnDoqAyJ5K8zFt4FxzEBemQxTRm/KSWQqrtR3c/ItYiBUCjuOUHQO275DWDkslNBgWFC8iNA9yoxalQLzYbWEEMIhDOECUzf8LhXlC4NS7LlEqQlpLa0FwpkOa9pUSdy90xARrQsqEwmkXLEt2EJJjm6LMoZ3yLN5eITSiaTiAbeMA2dZIbp0xzZoBJ0P2mos2uIKBAvFxUUWDFyvyELlbWQlICEvCQhRBwfwRdoreaGbk/MgWFJ1zMAAQa/1Sh3mpzyQvAKm3oHGB6qk95kuhTMzVL+kzAohgdyJjsthqFRlAoq1qcTkTaFXh99S1INMiQ8EbO2JQuApXKKU6y1ACkXmaIFYNoCLO2RoMeBKFoHFZtnjPL4gyVsIVdUwAAJMeh+bKh/fIrUABQuYpgaSZvhepll8oQDVH1okxJJCiD8j+3sEtJDVDWDTSpE6lFtIUJgo0HGWC5wuSmgDoZ5qkM0gBusTYrNOkSSQ1QW6q8cGOJAqdhkZtcCbG0pf/LUiM5s7+l5MakUIQuZpH1TIFw9nGBayhogQKyg2hHkCaw1LWKpQAD2PGhurPeUQlYluXxVrC4nclMa7ebM/8ZFXKmU+5/AWwa3nlocHP9k8lKRwB1WvI3l8sndiEiXkXeRHprOVpHgzLEIwkGpHCdZnp4y9OtRu27TCGtff+j0F55s46WVdViQlyYAYiyAA0wQJUcFGAd79glBL1TAFXEmRubVjAOhXCIzHiTiZDyupbUsE4qnJPxXMbFZlkKh1I1V0GtFkNSCVEiF9xLWNZwMQZIKatoAkQCBZdMZZ5WfZvEYznPuST4XYx5hoLeI5NOMoh5iyAdw6EmQ5GxeM5JlAGDgAYcIFpbBMpsDjwQD0AmhGPlDJRYhEL+CqV8ZM3JmQ0iuYNI2L7gvAljQ+0jidSRnQah86thzZFEau//Pfci3XiYDFUO3bGWGbo0Uwn14MIksyZAQTRcXiMQR4NuAUOzSgsYAzqSNoCFBOV1Wd55k3zG7tqyYQzhnBsg4nXKvt0L96ZjE+6iwC/W7Z6znfczHeSIbVlx8hg2JdzhpfxPQFIzqlcq4MTLcstJaewZDCw1Ip4smynVCgC/lCJsDzdkUCwVbobZQjgm7tItWQoVr2aM4r4OhKDKFErQKHgTA4/F3S3XsdF2OiCt6TS+2EzmW5ooEH+THF0smnGVqisU3uk7J78pQTgFmRCGB2DBLvLbvmoTdJo3ZilTthJgqgyVA7RtgW+RGmFmTcsBoVgAvS6xUEbVpSEyBqgu/3c7cjUd03aWxZfoDoDEWbTz8Op1mXzl+X3xBL1YPhQ4u1GcUKLjgRDYRV6CSQABQoBjgUQAPpdzOlAGPSMKTmm93eZUjDEPr6zrBALNhoBlrjRl7Q5k5Y7F3YUxf3aR4fbttS9sIiU3eEB+D5vLE+6/9HgUgwRxw9/5C0FBmCyuT8WXo8cJkJYoSBnUBUFJEcCkDYIA8WLm8oOCQJyk7q8xX5WfXm7hUxq8KwSM8NEBYIBrHJDTAXinSgXY0tBDSP8rzdgBBgLaT3WO7CLA9ggwqEStKATO61YP80qGURxqczwNWYjkQM6Ea1xPKPgo5crCTy7OSxwPA+iC8R4F3v9qoyhsgDmk5eucydZ2A9BwQ7dcBUbiqPDKIoBAJzz26dFWRGzkCgBLjl+4ogCF8JjM6jI8Z9CwBnGmq/L8ZdCagzVwhqCc0AO9TAWXIt6YBQG4BHOuBQSpbwEUoP/Sotzkpds2ruZO5EzyY4gSIE7UJ+wOYgoHgkByreg4agPtC3AQZ9wYogHaUAAagN2GcBB5iFEK4LZ+aUAKRLjCTX1wAnWC4zcaQA5voowU4EoqMDk4hYUcj5MWI2+GyUS8kPGo8FRgA9Kyj0VwiCqKMALPkC/WDSJwa1kIwDWIDyc4ZXbKZ9DWznAYC77SbCsIcRjnR5c067n26ju0UC0SYP3/POcKkYTWhOP7rEP8eC85pswBnmMVAWOuQC82UA0ivHACWI8mSgD7DiIZU7GIbqYs6uTe0MM3eCdVBIkFI0zwcKJZiC5JHODawucAWKjV2jEAA4UEPYMYEZJ1SHCUsHD2yG4Lm8a+nA8oSHA6JKkD8wNWQgwCSGruUnABx9H9ru8gRmADUK9YRkw4HsXIQog1ElA4IoAiCkAp9MwYnzEneIdgPssa86tgGAI8Ss4IzeduJocanyshkfJs+AURnwLVTmV06nGXhuIAFEADdWIecUIybINoRoUl28yG9IagdAIDHkADJmAARKAERIAGyFH9KHAB0w0pZnLPCPICk6RK/yimOTqR/HYSmhgizGKHKhfDgaLuJuoKKnQLqcgmKRlzYZzyzgbiMb+NKiRplTCx54ACKxcKdA5g0cxQRiovzMILDfMm23TiAh7gAT5gA9rSu66RLscIXoiuPRwCaLLDpWCvFAOkElPyEYssfwSFQ74qpQygMY1TYdTNqeaQ7KaGAdavaTpGwjYtdoyMy5glN8sqOQjgxq4OeFjqFnMCNS3gA8wShsQONqNKlPyvOYgLbooCApJGyTDzSfBRJxKpfBwxhPaCrPyt7Y7zP2sFEUMtyD4FxQoALE6Sm7QPGGNkOd8z9HqyMHgHPU9EOK5INFGzPH2mLFtzKBKF6OYQBv8pFKp8bGqQpjMRQJ1yAx7Nrnbq67pcSFAE604AtEZrZTsPkaAsa83mqlQUTsQCBUfZKxMxT5S2BO2kiyddDwIkwwAmsjkqwDNHFCcytDW5o0q5KaZIL05cUdumNFMEtHcCh0bAAuVEUyAkSS1OzNAq7jdsw0bhtFYQSxqLtDhESUkOJOmYgtQ4JWBkTzgkq3iEqEwGp7JqaQKB4lFeki6xFCIcDTVZMzas84l+7kjpEg4nq7cy1UuBYsr8TFq8Qq84JAHitFQPi+nyiBJ5E0l6JfpwywGazx0VwLRAiHe0sRxRzHmiw9RwAlamtFHF6SYgtUOTRjQ104AEyyuZImD/vC8Pn1BxtMau9oW9SqZOMEPTTDVbKSRZ9iVR9ChE9ouvLIVTJBMQP7MulcSnFsNDmLMn7lBTsBO7yLI8MQwnOuABWDO2miQz31XV2hOSpFI42uNbhaNEaW0AHqIXL/AmxIssELbikOSztHViUQPOGOLP9kWOXm8/qrNJDvA8l/XD9gNpqMQPs4S/9E5JqW7PQJBeuUonOmAF0NEgFnVSB8VNxyWYhIND7O4tDFZBImA77cS+BMUzTqyl/mxVg3EmKLZpS2PlQDSEgA1dARB04JUxRm4pbu7/KG1jF6N7tlbl7PGyQnIplk48/vQ64EVZhWz4ggJ5bgJWutQ147Uw/waz9ewLlQhqVTDSr06McFAEU+PMaQkXJoLyYltyjXxpXCLgxqoyd76GY8sibI1mRYzGeVAoP0elb6eHLdhUHEOQU3PibIsPcZujNdYTSA8iahl01NC2brWWG/ODoKwmafB2P2rrcE3XPAuq7/ZDAQo3eF3iYyfp+frQJvdVasdWSlAUhRb1lWiQat2jOeAlWfiuMsDSPkr2G1PE/AJgFN+CdAmiKDwgU2DlrWSXoXZzN5LpefGK/aoPH3UXt7KIaHXOtHSC1EIFqS7RKYT3f1ciOZUkzwgofXFxaiPiTktpY/yS0dRrgYXCT1j012ojXZTvRW4MgjHLl2ADfAtDfP/96SBQ4Cpw7XPLKn2X7E6x0xIdI/N6s+qGUqsghShxSylGJQLT47NGpZnYKSFmLeIAOIhTAuY6JCcWMp4QL3khAl5YVPWCSCK4JD3MEH002G9sjHMhQj5yi0yhCO++ki88ODZAGGg4SCBYYGCEYy8DANQGWCjwC4vVUUxVd2XVN7fwhzG61QCqTS4xckocQAEeYnP64oVnDTPqkSeEOJFNIgBaTbiSSWzyczPlE9ggsfHodDf8JPx0M0IplHdCgPqSY4y9JFpQiHWXglueAkhSNYmr8Ucc4BCbjFv0LQF0S+BqJpIZFim6E3Q+1CHPymtnIv4SSS0UuZgvRF+jV2n/VzciSOoSp2LNjMSX6GYiGImGG9SUJof58HhKy8cHWESUs/KFcwJrEIBpOMb1pBk+u62eVIhKdnlXopUBUPQ8cnApUJFUQM6zkk1UIkA7cC+7mBOIjXmgP8J341AnVuVcsXdTA4BbCmQ/PIZIhQNW1MeTBA6ifS5KqTVTqsMDJk2TzZan4INIBMMDhIduAXF4ohUifOlzHkxH57igTo/tbkJqcLk5FDqE01GlrVJlixeYTyWHCHqoO8KgJ2xjmvRJHZQhbiNzT2VOqDNEdPbvKhhXPzE/HoV7haJceiAFejqUyQxVAsDhgPqmKViJWwguPy1QBNJ2YgeouBLT1FG4/1bFeTBCgG2IqPVaI7g2e5tmQ2QvOhbtVBAKdZRazPa5y453fO8MO7RaIHzVR46tLPJpjFuPVwNAgcbuNZuKoZmirk3M8U7FjYSPysJSrmWYIbIoj0YTxbYux/aaqOsYZBPYAJw5tR3xweqZM2iEKwRyenelAdJHVTfZqKQwjv9kYe8uIgcyOSZ7UEA4KosDlTQ7tXd3pKJ1SBTAfStNXEN7l56yOYj7FRvFqtHaZU4Ot+qomgQxtgkaAgBEfXRmverTr2ZqK5faRB0pqIlGi8uDMCR6VyqANUbpcf1ahTySKp6bUMY4Sy4uAlrABg4FhbL2jsdrdh+vLBSOjdm2Uv/heLgCFnlpG1+Qu/DK5+7c25jlhVkLNEvGhVMOZIZil6+8hW3fbPx0op8y65oV3KK6i2jGWCB3MFE8QAUygEOWZXMqXG90JiF0l7XExsapYkLRtLn/inM8aFd5YsBSXMWFogjX1af5C5rvgio9hEiWyIs1cYYxUDndkTR7XIOAZ4xn2oBfrHY4QAVKALD2O5utS9E2Wmi7VlOVu3sHcr7fAnWsSDsAwKIDj4C63Msfzb6eI8C/dDjI41avLC8S7ExJtsa4l7M6AFgee2PSBZyVb9XqqJxdhlg2QAXECKUP4rDz5sy69Fhj43eGyDEWwDvM+osvHC6eYkRgO9KFeNP/T3Z41Ho31Jwue4q68qaq5rSqVdI1xKVe39yzYbqiUmucxfmpJKdnt4ejGCBJd4PKQ0RPcQK/JnFUHMDYFfmujAeiCQZTLh1yKK84FmBtpGwRhUPaGdl75Wt5rezP7lCQ3AjgJ/m8fVa9vlpUBvw8EoklSVBN6UUOs7pC7TlzQE7RAyDfvwXehRin6pSmlsU/+kgomv3ehV0guGU4f7IwwkqxC50ppAY8lW22ejNJ8lPUn48i3jkofgc7JPi6LKNlmiXojFLscKkFO3OjpaQ6YNm2pEJ3wwbFRR6AKykomPQ7eKsZn2PlWT45dtu615EppAioizg2qmh0MTi4whaa/0yEoiCCu+Qla7i7s918xnk8N9THlcpofAQpp7UTAce5enXa17JekQVD3EV37HVC7DPFplvcs3Wiuh8jFsFx7wdClC2Dd87oV7wVJ+z+HZtMIMn77PP7w/0mc05sgR92d+BSvO5EcMsOAvxz8YNXxEecaLQSpCH/u1W78oH78k/aPi8ZxA0VJ8YYSDYnogT50DTgAWY2pbFlZN0T8Hwa9AbAJthZp7VRidYwzON2l36b3N5U94M32oBHkjQ5aIB/SpFZ45Q51Yy/b952dSnxlLBdJ6RZMgDCAYEABAsaDEBAgMKFAg4ahMFwIQSHFAkOiBhRQUWKBjAONHgAo4GNB/8RLNQYkqHGAABSYmRYIAHJmRdfyjz48kCClzwXIgAANKjQoUSLGj2KNKnSpUybOn0KNarUqVSrWr0KNEDPmVy7IijwskDXnQsLDOiKNq3atQEGnK3YceFIihwoZFi74C3bgwMSJNDr8AHXBiIJTuRKNiJgg4kZLp7ZU8DjjQkZziWAYCDhiGK5Vog40uUBg2AjLxy9N0BpxQ5XL0wAwTRPrLRr276NO7fu3bypxn45ksDf1DMVRJ5ssCZMBMiJO3+OuEGDmwcz2IWOnaTgmY0VIlDLAGNniwYXYPSw1qXcA80rEog7ekBcAQXUK1yJOULFlwvIH3Qg20LtkRReRKj/HdSdZG3Nl0Blx/UGYYQSTkhhhRYm5dprKmVXkHmRHbaRSTwNyGFBBDTggAL9lbiXdXexCGMA2800nwBzqVWjADe59B1BxjFUwwMXqOWSASSi9WNkC0BQIwMHeRiRfhWJGKCUew2gAFgxVfQbQ9QNsKJWprF0YZlmnolmmmcm6KBPJSa44UxUYtRAjCFG9JGdM1nHgZ4wzvhkXAr0JR11akHw45YBJKnQgV8JIFAAE2hgAQZpDUDAkRRBgIACBzjZVoCLcsbXS3lStJlCOTJ0KlsAICaeQQQoYMABGYKmZq667sprr0u16d1LySFwQKtpwamQAyQWyJOfpUbkgLMV//EpLYuAFqScQgWA6Jxe2UpE0gQWVOrsALfeaqqpBzFKH1cEHFBBf+jayC2M9ilU0JymDeBrv/7+C3CEqcolLEFtKrsXRg5klha7DFVLEJyaZkctxCVeS9C9PXIIrEKgkoTBuJbaOXCADOmrkKEBMFnWxBY5fB92r1KUYGffQopuAQHvzHPPPjN166qddXnSXm2atRbMNlocwUsuO1exxRdTdGudXWEZ80bMOoZWyOTCaPKIt4ZZXoPONY3R02thdBPKAkCwQIYJ/Ex33Xb/W7IAWUYZccFrAZCYkWopLQDZ5RYmbQcU9Cn1nxxhdCBJNzcHoGVcDQCi1yNzGDbkAf90ZzVxM1OEdkSGsxi3mwS5TdAC8/10d+yyz24hlDCtRp3bam9Nn6Y3q9pAsQMcYIACH8fY3eksKs544447lODxGzl8o0PmLoSw1nEJTpDmV0bQ6qqyFbBxAqVFrtboJNkuUQINGLAxiwwQwO3NxSebwAK0789//7gRMC/vdChWbMlb/EjSMdOoTH60Ys8AEGCABhjrOYrbgPP0hDEfnQwtI0Kg2dbHGcD8wAMeSMGsCuCABa6rLGHinWwqora95OgAA3NAvfT0GZhEhAH+66EPf+iU37HqAA4wQI4+8kAFMIcrQUOLED9UoggYkT3JcQ36iNOBB1gQLeq7IFoy2Dr/BCyRg06DjsM2Nh8PZGQj9hlPANg3psYxoCP1SRUCSqe6q/2oAWd5oE5u6JAT1Up3QCykIQ3pwshs7yPsm6BBxOdIh4gvMpFUi1vYpReHSY8tWdyiFzF4ECk6gIpJ85tzbrUSZC1kkwRRl2HC5sZqJZI+DHBYtK4mN5hM7F70OaQvf7k/MYVtVsXrz6q4Axy0JDAyVkrNHHmyEmEy5Ipp6eQEoAMBArDykzICienYgpEDpmZVqCGcAK33kviFTZzOmqRC8hbLO5mmenLiCQ+Bic98+oyXJnNbJQNQuYigxW3H6VYcpXmavVxAi9eEDpUKoDwvzgiOBSjmpV6XnQSt/8icHnBBQw9yq1Ppa14uw5qNtgmZyJwRLe7kmld4Mjd9ynSm/SJo51hVT2hR5gBLtGk6DRIBnu7yoJpcy0I38NHnJEgB/4TYjHzaVL6wSD3UWeZCsqiBpAZAX7f0prYWwMuJQSBDESWJaYgHE0AG0mRHeiLsaArXuKJpljdVCHIetSoVsuw1cJwmA4jHVGwFVEfJQc5gMRLN6xUtLQvNaonmFc1PPvWgXGEAYQygQuL0ZThezQlBGptUKvGRIpj6GJ3UgrLIooWfKfucERGgVgSZLJ4VIZwC5Irb3FboXi1VSA7zuEKeUDMA9xrAb/HExrQtSFunckveWjasCDZzJv+gBVtPpuu8GT2xte4yULXe5SnlfvYBju3QxLaWPSQRcCbqg8Bhy0IQBkQApQdZZvD4xhUABPAAuu2vf3HzzLo25D02wm7rFCac5vx0Vg1AAAM+uJF0Ek0hAwGgtkQCvxgapLow6utCQidRg5iGtq0Rb7VWdcCjalUtCWBYekSygCxhNi3vQsBvjSQfuZCopQYAiwEiCSYR94QA/y2ykadiVdlEdasviW0rw5mwcFKPrgJgJ1s4/J4CqCg7rF0aN2eExw5KziYWe4lqCWJNOyWgx4MqiAvtM9yZ5IUgJaMnRWRzRW/ZkSWQPbKf/7yUkKq0VmWFninh4hEZegSakPP/i4YNggHyflRfS6ZRZKxssRl12a40eYmB7bSqCiCnkzBiV5jmRCsTs+V3ZOsiQnlyGAikpAD6ydF3UCZBQOt610L5XZedDEPEVhY0zgSNEFFpNDp+x2tJvRmJX8yTZ2e6IKrUVldWBewSWdXKFXQOWIvHABdW74EIWBKZN4IpRybyn5suHEFy9N6GjGohROa1vXX96ir3BMQs1qVBXB1fOlZgdQWoz3mfG6A4u4ddIbDAisPM6ec42+DcJMiMJpzoy7nm03qy6fsadZBuswVYz40w2+RJ4X+HStWMcYCW482QiSTZpQtAgEzujXNA5w2gYXm0HzN7bX+jO1PUFnBZ/2NM6JVNcjIJbM+7DlDoADCgcgWodLW2Q2CVZNl4aeGUpx7tqoJkc+Z2FnlaAvgwmpXxIK/q2GPsc2Y6R4RYzJnh6kzmkJzr/chjxekAAqpl2LTFVgtLC8DXkqDhQiBVVhPws4E1q57oFXGIBi4MwW4nwSyzqRGoHKYvOHMBTJB5LOGKORfrkJ9WfpoUEU1FXBi6HGftcwnP+95v/18CVGCM8Y0A2b41kgXMt/QkU9jq7/M7tHtsP5yhZEXCXFaU0bfi2lFNtJEZJ+q/UTaYjpp7GA3dtWIEpcje1JI2ctyF8IXoYpcNvwmC+/j7d1Zcz3tfA5reUhsfnRjpa7tVGP96ArURYNVg7XEr1EQA7Kd9gbFd9HUrJCJIvBdIChBYcjYZsgF0BOF9B8FPA/BXSqRWCVRWBpQarNNd6RQBi/Eq8seCuFUjcad8kKInHcNOCWRZpLJpE5RAauRKz3GA9bVBC3gQD7BdQHZuyRV+waUqKKcA9SIbR7KBGcMTS7ZeFOFCvlMBRfQdcKRwJbFGG9GCYThTGnMQVMYQrBRkz8EodmYRTvN3Z2gRjtZGJscQPLgcarNmM1YQDtNMN8NxXxYA7jRmGfd6whZKJ+cQ+kJPpmF1G7h5yoRcLaaDpeEAUYctrjESc4I0l0JEelhfu8cvYiiKwNQssmIy07UAVGf/dRRBf39YMtGEGUCXJPkHhHaYNwNHEYf3bpbThrxYEOnnZUJocW2BLpk1MztHEiZoEHnDhi9xPHmTAKDYItdREOIzMcMTPI+ShOXhMvciEx+YgclhHPWhVntFYaOIjobEE7XyFtsFh9gyftlBYCl0EIuHek6kTeGiAT1QAoT2XmyIfUH4RuN4APXiMNIWI0kkgUMIXhRIKxXVVIqVciQBjPL2SGsHj4jYi5aXGi4ihcTGFm4DkGtRfgYjRu3xLV3FgRhBJunokv2Ddh/Rbsg3AM/1fjv1KYYmkNiigNkxKUJyEKsSdzPBjANFeXpiPvRhH44UAr6oFrrHWQRiiAYh/5L12IMWAUEVmB11kQGrMpLo1hOYx3NfGIgMISULkI8F4Y135hEv6Zb7U22dkZQBUnDXF3QJJWSs4Sc/OSTih1Nr4ZVORIh24lO05UKfhx2MsokgxR9KaG3OQkzMwQFNGRE36RAMsCIAYFXT91LIRVz9lyrZU5J56SVvaZqy01IxJmDJRCBotUNuBhxiWRF8SRLqgZgVkSC32TpJQmtUqS1/uDaM6BAHYIePCUMVoBNnM0XIkUDYlSqL2WHvoksd809UUolStxXY8YIF8RKHdUs/WBAzMzanSZ51k28aspqDOZw9cSAehpCIZwAO4AIr0JdydpLEUSNf6ZvbyC43of+LXWGGojecxdkuzyd0yOOMFCF8qxhI7yNqfDFJGgEnVhY91gdlKpca7qOV5xmP0qeTDNEA5SmiPsOhBVCRAvZ5VBZZMAecKwNBDcBxiimbaJGHurlyrLeRafccHhZzfomX/AeiHXdoBBFUUOcc9gEYLWUREcAuMChcnBGO2hkgH1EjefYSI4qlPDNkPiUA7dZmtRkZhuJhXSiResOKUymMd8eSfcNyqQFzqgKRB0GgyAEnM1iFSreTagFH0cSj+MKdbRqmxBKVeZdfNAYajWkwB5CTDgFxopelj+ovYdEffdoQjJKA2WcQmNlZOQEYv4OY99IqG0CZApimBFGRJoL/kd7mGmuGQnNnEA/wFRSHm6nKInKzkt8Ukn6TZKHTVyWQAMcTQCoJhtChPllXkPahn0CVE5DKrLwiPofBWmIBAAuQAM0UAfkTSKVRdUSqZPvpUhsBngGwARSQAqVYIib1pUZzWn8apBySAH9UEA9YEGDkEHAkrCwie1WWeheaPsrYp96iSH+lfAvoEk0IoG6xrM2qsGmSQFWVaq6qp/23izpEqhpEbxjKmN41rh2gSjNqGBnyaCVDNlsDnTDyO9QxI/85bxfrLgyKLRHlWWyxpxcJE6O0GO5EoHapfXAzGV1knSG1sEF7JqrHGO06OJ5DcHqTQK1CrYKHsZuqEDNA/wEdQBABZKNG6V3EEatbVo+SKC2/YyX0SjMA0gCc2RgtuhZ547Kf+a0rkypxVqZ1FaXY0RcRkG1jMU9Cq7cXsioDsQC/12Kc+Tgg+SRHeCWuEQIv8mTrWCJ5c6+lylIYASJiezlaI7Ecwj7JikAOOhkeCIHEUlddmB1zkj82d7cU8aYCUAF7y7oUAiwCoa2norLTg7QlVrtXggAmEAIoYLtmViLUw16Qq6ARYSiUyyWJokIOI7p4MY6IySkOUHgsUmPtCEs9aadDFmWS17rbGyEWprSX6xwuFFH2tbZcOSXYyzEaKbyWhADBYzjGO7gLgV3/GIeD6ifuxRCPi59eYv+xogIxvaU2aBdT3EvAu1F6yosdjVFJWSceLmO+YHq7XIap64sd8AuEpOKYIDcnV9sVKREp+aK+RypeosETHhAC9VkRs9sVfXdpbFFt+lPAMbwbgSmPUWVT+usQHnk12lRz5WYnNVcBggsdc1ZxGSR82+Q29QJHmKKe+/uXZUm4hUqHO9mOtoIRJ6ABQKknMxlnushPISrDYYwbDjOUFAkW6fqUkTF9OkzBflKwp5t59TgftEh7a1pfsbuyHxa8J5i/1biu0BGzMJQSBgAqP7k58ti+p5gapUVg5CPGj2wb4vsyqlJWOQI/IIIZC5mxwEGBxVIdi9PGa6E2yAqIBsH/Ls2YtQoaJjT8HMqYIHN7l0+8FuLyNRIXg32cFkRse5DMy7Rxth+rl4fYc1DMXSDyrvnTWyAXAFEYyhuBKL+pFoh6QYIxM7+zSW2iuR+Jo0plSjVimXvBO9m8EbR8yIoWNtwTRpocOI/Ry+18FQYjUhGszZCDMrNmxQvxt6cnADEAys2cFkeEFn0FyzECKH3lSBHgYMR3OW16JRHMpArAcZt1JDMTYMubwpAmMot8U4Bhm8oKE2znziE9FfWVP/BEEeZ0y/DFZD3hASzgz2msUyucoCHWfpADx4RaHtsjxF2BzTNhWRXVNvxbcZrzt25GKw9qhZGRIZEDcXlyK4Yi/9JRHRUGQ7FOiRApHTYfY1Nl/NKJOKS0i8s0rZbdia8eK3Zei0AG0jGsBAFmfdEEAQM8WHX6ojwYhz1u0YkDMTpCSdW3K9V/3RQrg4HlIRsKgHDoe6N/3NUBqaNdEZpmzaSe3BUYw0sZ+BYLsNPOootBE8EmpSiHM08VwVtNRb8WOnczA9ipvRTVZqZQ6zQBGsxs+9X+jBwYZ9EdkpYcsp1ckUHvZZkusRoc3DjJd5Rj+RpcUh4yNtBj/YTnG8WiHU4AIER6odrVfRRuwwBitEmrkkI9Rkr6vBC4iGYr0ALoYomlOmsAaNVexCa8Hb/36Mc8gbZ7jECKWmm/g2KmiP/BQHU+CJHKkdvcChpSnSZ0LzFwQTXA1q3gQAFxJPYq9xJ3Sv0on51mTbfYOZJZCJ3ZxAEBx7wRfD0TGdTehdsTOMwhjMLVW5uvq6RqysitlvFe3SgbAMlPous675RJ/bcaZrHgCu6pIPSa+8q4B6FipFGZpLW+LvSedkLRB2oQvu3e781Uhj1GrO0sEJdZR7RxUrc9hlOnRj7YuYxYdVgDK7ZtmlUjDKwtPW7d4jOSfXFcnybABVHkJJ4sf9UoxsWRHIIpMaQ73JQhbAiMUUqvs1Is6oE0SbbkzlGUPop8nWKk2DIZtm0Qdm24T6vfrXUio4QALGDCJ7CMYQk93v3/uX9hzWye2pauIA7Bm7+ajJFRJxz2fJkRtwZyfhxijg1w0wHQqCShwuFLq8QY1tUnZ4YYQDch0SzCyqY82z5ttOyavwzdsuu5EB6QAw01SdQxM6Ym5m2J6n/9RI+BMrF1eiVAXiegKVz6o9BRMt88xcrsRTZIWrZCPndrvCaYOki7wWxBPJ4IwhAblM3uLthK7We4qnyOESYgabz1GLAXzZL77YCdM2xJvNBd1QtRA+U6eySRzHu+asHu7HJRcb/DIfduSjTo3yLhJCoLLPTEwtoyGeeyyP0+QWneFpB+3sfiNI3F0C6Om54iHAYS8YC9tBSfpyzxO4NVAvbh7q/S//HqBx1FzxYarn32IdzELpVHXnQs6U7TJ9B8Qe+kJElo2u3rbiKm6yxfHgAXMAImgOMY60/SyBdWJEX0keBDH9UBBilJt8kX20V9JQQiEAI8kIIg79FsBR2e6rSLTW1astxRXhy4qqYC9abuLtvr3RVNvRd5k/Mlkt2ZUdxpVhGU2ir3AsN47+MHX7QfvSkvIQMftW6mB6IBlB2H/fgcsoKQa8FrZrMX/NFdZmnFnRbqId4hoiUbQ7RvfeIg6uQFQWrO3RPckk6ov+B5sxjrjIQK4QEl8CyS35qLihlLHTFs1vkZzBBR9+uMvxHGO7sZoh9PhJAwc/sdIkan47NZm//80vLKNLRExqVEgAEQHShsCFDQYEEGBxQgENDQoYAEBx86RADA4kWMGTVu5NjR40eQIUWOJFnS5EmUKVWuZNnSZcmJDSMeLDhgAE2cAXg4bHCTZoOJBnIOzTnAgUMFBQ9MZGAQANGiDAzEPADV6lWsWbM+1RpggQIHCpoafNCV6ACgAgrMDCA1pgAEVhnEdGBWK9eCEN7eTPvQp13AAaZOrGqQwEQCNAUSHDrgLdsACmIueFnZ8mXMmTVv5tzZ88gAb6sSOIDgr1UMFiycYHD6IISjDl0DZkDAp+OggQsWiNlA92/gZhMcSADh4OGHbMsGrzk7wACGDoVeTfAwKfP/q8gRP+ftsAJzBgiKX+1u/WD5hgVyCuQwFH3DBQdxI/1c3/59/Pn17/c8OOjDuKBKzQIMaEqgAQMCDKC6h6bTKiEDDnCOwYmMC0yyiRTEbkPmBkBvrADeE4AsDqGCzgADFEgMKwJWLJGoBd6K7zkEUnTxN/8EuDGnpTI0aK6YQKQpAwraOyi6hwpYEYIFbDqgAAMS4G9KKqu08kosX4rxraBUxGnAAn96yIEERBRASKsobAjNBd/6bUu/XjzoKyh3tAovHCdSz6u3VlxOTpo8fKgwQH+LzaG65OwxzrP0tDAA7R5i8yAijQyNywiRcipLTjv19FNQPzOTS0InUC1M/5oi5ZKirPSaKFH5egOOgNgMmFHOASqY6LtCcZrvocTgBLagP4+zE7hFHbq1V7sETc855h6zaoG0FHDNzasqVXVVAZIK9VtwwxV3XIy47dNUAg9KQIEDEsPQ3IYiyGpbAWZTs94OodXqQC9x0nUvZufscze6Iiq2TYeODewtXp367VHmIkBA3kLf0tCueyGzKgMV4PWLXJBDFnlkz1z1uKEQHkC1oBwVOnnEeQH2yjaEDmjAtICxgs08dVfVmFmZ6YWrWCAfWvY30bDCs6h3DbiRAAQUzhmqQxOe1YA67fLAg5MJIPlrsMMWG6RfPS4BJyR5OnnSxmJSbwD/COWQtP92A0u7oRtznOjnXu+We4BkHSr2XYfk/o3wNXNCoIACJCxoaZqqbiipBcpz4CaIiYJcTlUdxG5zqLbk2twBxjb9dNRBLhteis97OTm77k7svYuzi2CBHg0QMlnPtRJRbm71/dzAowqoXViHRjhIcgF6163s62jSW3hIuSTgve7WOgj0nK9v6IDMpzZoAQIWGG7rVQ1IfX3228dy1LecDxFTFBGoHHbACGggrPjo1UroMxVkW2wZDs6gIqLoRcBn4svK6gSgPIMgTgCG+w3gHBClnNxrglYJnNq4xTerDIBtwDEO93SzuMYJD248CQAEDjC6VwXAfTOkYQ0748AkFcD/AbVTyqoMVB4DUA8rd1tT+ULILd9EJiZCcRbeoNJBF0lwgkdjINX0RLTJiE+CexoKAfQmHXNx0SDQIY6v/MPDKmIlRwXQl96uUzRg2VCOc6SjSgBIQV+NiiaIk59ZANg8fRFxIgXpi0PU80UQcqdBB9liGrOCAMkR4GDeU4vUFOU2onQwOfA6TaTY6DoAOXKMNjsAFZ+iwapADo6yec5e6vhKWMZyIwNrYCEbksSayCg48FNLJrm1J1Ti8JNFgWSCjCjAmKBRlAbRm+MOVpAFNKmYypxbMoeyymTC6zVLNAy2HLnKY4moAJtTYBYvNZEXyFKd65xj4MSovwT95Sl4/9HbsrCpo+CscFUK02AoC1I1NuKweWky5FgI18dlIpMwxGoMehDKId758pfmil4AyjkRnwhSiCUaQPlEhBN6wYomyGuIcRw4gwdcgJ0rZenpOPAA/xgPa24LJG8UcDQHbhQr5LsnHhOSvtc8aYI+gd9pOuqTbSFVAQpIZM5O1IAddXBPzyzIvx7Sul7RDas40eTLHACxft4EcKIxYMCkaLWDaFKZzcxlTLz2UpW2VK5zFRdcLdLRP6plq1kJHC6x40AKbhEBg7VkN7k0I31u8IvUrGITN2gQqTI0JyJyQAWoqJsFjNAqef3idsaISUF6dpQXLKxWuopWgwgSKhDoi//cvogRu9JVtrO1UmwxwsvCAWZRCghfcGhpEA3ulUWdNYjkhDqRitJkcc3TLKSmor0LmbN6u5IsTpiXW+DcryGMHUpnlcVLMQYgcATo51sehTw82kWbI6XKVUToE66UzWsYCcAGUkpb/Ob3My/twEbuedg7QbMpdNohCh2XlfDYbyh3C28AmJfeACzXWjzy0XT/U2Gc6E1q95KbCWliMUaOyUJUjTC3SrvamAj3KpBsXJnS0xTA8caWiVPXUZw2P+RKi2Ux0WlOoBZah/AtWcMEDHQWUrqN1Pe++mVyk1nC347k1Z9QoeQvnUPGmRAuvYsKIk4QOBTJTYg3ZALuW2b/nIDnKgibCBVRjyUSk4YJUAENgAyJBbMq3hbQzQgbE3Oa5OO3NFc0Oj7nlM3i3YYYwAFQJQoB5sxdpYFEyRhwcqUtDZIMPKC/HhFoTJrKp5PVzpNEVFhHL6vEvWWQLv/jEpIKYNXvFUS1OSGpAFRsFQk2t7oZnHHzPtQVTQJNT1dhnosJw5vOQpqr3HqonEgy6UtHO9qZ3jRIcIvaoZx21duEV3KzgrwG7zgmXTFTcQjQlDaXeNxF+W1XygZhmtgZsm4b9r5WTb7eBgYCtZlxaS+aHgunh3SAYfaedTNPk0Bb2gvHL7VJIuXtWgXR3DzIv4EKmAUMZsI56WyPaz1M/wdGhIgQ/uLzKoCiE++6bUlq9xEzdChlcxBTp0YbombkRbVoGy4Lg3NrlMahlNSXQAwneksznYGTlBfD2X6ZxpRu6BfNWiud3ZMDoUYXfTk25RuS9xgx1K6Wy6U8sJYJcIAMswedWpAHsJGHiSLOm7qXAfm2C0sCoIGhF13vrzy6SiB1dsbWOn6+gheRAWXNrvx3RTPOKXVKc2WDay7eBOexXYQqTuAMnDn93F5gACg11mIXOC65e973fnr3deABSG/JWb2z2bcUoDZLpdiJxCJebm1cKwZPbJxZ7emaoOfcYX/QYGz1HLtQ63uu6fpQOGx5cz0s+n+Nibc9b6Zwi/9b9HWXYWVKPwHUh/90qme9S3qN0ey0V2ChXC4mgZ2eTxeF5p3PSaBlPShQMyUwAoV3oOpNovyZCjJjsQMzkTDKPDxrEez4N8MLjrCiNW8KDMyYALwDP/G7wFDhAI4gv8t4urI7i+GIwDtDv39auqvQm/iTCwWIkI26m+nYlsSQnOzDCm1rtggCPgDkPmZKEurxwBR8jdMIrfKQvQ5BgDIqEXpxDouDj4PTDAq0AAvMCAyIKwyswvsIAE3TCNXTwMy4LvxRHG7ZtwpAgHtii8SKufwzpAbqkY27lxNDkp4gpOrzCvSYP4kzF13DMZ5ROcBYwv5bQqgLIQwpgNZZFDL/iYAOSqisoDicuKfIexzOeMIovAgL4EIrvMRIVJmM2ELOiDDeMBNo+aMCOL8gCxQ7VLXKcxicgAD0+CT326nT+CIHGY4fJApSTDSseLCDaL6raCRZk7FbMZlBIQC6AzPRMjWDIDRFTJUDaJd7oTnJsb6t+Ax0mUQA4AANwERtxAzV6z6LuIAHsMT6QJ5EmjjXY6XgoJdihBoJqoAkDIwO6j+7kLJTJCIh4cUfoaLIGkFl2cGJOEWcAEQo+RkQW8Y9sg7cuRkV8g+/asQEYBv8MBUNmERw9MZtvMiUwEaMAEdxvA/oaIBSOqD0wS151Io5bAwvbB56AUh2I0EOOTu1/4i/QqqIXcwKCiFCwwqlbXEQxypJf+EWwxGRrXOurOEcHPw2mmkM/7icztMPiYzCCdBEjJzKkrCA8uNIKskKCbpFkCQtDoEjA6C7WwzLV8Q442NJu7i2wuAeAhhDKuLFpEqrRcK9dauJGumX2NG8griXGQTDq5KTGbPBrtCb3pkSifRGC6g2qlxMjohKSgMArKySb3sdiMiqqDHAD+IzJwKOAShG4PBAdAQMXlwsZmSq1BLBfDIXjUGSLnO7Vvo/DpHFDXGgjbOS1NCA7tuADWBM3syIioTMByAILPEiZFMxSjKAW3ynpJTAZsm9H1nBkDTIJzqZWsQJXvwyl8M/JP/MTJz4MwRjAEBES60gIjSEvdiDRNu0ANwEgG7sTd7MAAsATuHEkg7yPfnIqwP7t/IMnQQYD6J4C3YZSuk8TY9pyK4YTTgbogbxTK8YLFMiigjop/08Dl56xNVqRQslvFbrlNsMAAx4AGt0T23UAA740Pm8iBDFD8H7C+K8sVEJL5IS0KEgnA2bCAMd0N3ztI4LDLhMxatYACM8sWTxyWQ8SYwzF5HikLEaqsaIvK5qACuZAIsEABONSsUUUSvEwpeazwDoAPt6gPXkD7IrRbosnH2iiQ4STKsgIn0xNiLF0ZxggPKoin7Kw5zAR1eT0ZxYGhjsisGLLm4RT/lQl8f/g5Fj8orBUJKhgABo0aQDsJILsIAHqMTHpNLgJFEsvUQMoIDgnIAL2ABJ1YAMSFH9OCuw8Co76bUBQMSyIjfEIwoLcc1ldM0W8Ylae0R8FCA9zYoZu1Gi+CLZE489+6LKOjLAQBIJQY+9SqwgWh00gYB34aEOogwsCYAL4ABJtcopfIBJzVQM3IAP4FQwzYBKzRKYPJmhGNOjNEn1GyM7hdM8mUvRvAtmkU2tGFP0qEW3QK7fYDAf1b5EI6KG1JuL2ZaKABVrxVZuBYEPKFdv1TsQ2ACH9ZRCOxkJ6jL/46Sl8U6Oc6vxOSN4pQlZxYomasADda8IsA0jrM5AQQCQ/6SiMbVPzAweNQIwkMIaA7i1iuUSyKi1GROjWnscgF2TcenSbn1YpK0PF4w+gc2Jc4w4g7CqOASpGDKI99DZkJ2Vy/yNrpMik/3RVJOP99izjEsPEeEudcWngDTB8fEYDRGki+2Zf7WYpK1b2aKV5pGY6HvHmrANKVMQF+yi7tA9DUrSrhhZBkJc+agW4ZE3bRPUL8qcAcAQ3TMLm9jZx4KKpHGPf/0seBESQdoWrFLHN9sbjOyAibRbhus0WwPEuAi9yZm4ACoI+2uMZavLw81axfVcQ9IXeYMXBuXdv5QT40Ckszgu6oJAj+1Y5zwON4mU2nmP5EpE2poACaCAi/+4gOtViQyQgI5UXUs7uwT4OH6cnOWiMxsVXjK1ybLM2pzpIGWyM9YVAAdIuZDjkHWJDeNZ3jw605YULQOJH7Xgofc4PkiJgCsDIubFG/yyXuz9xu0NuggG32j7o5swEyn6i8llldIdFpFtlLBdpt2lv+Cw1zsVSXhRNpl5juWE1XPLC21ju9y43bcw3OVpV5pwRBNhHmnMyczN4f6cUrpyYIyQ0pWgAAkQYgrWL8zVlDL9XGgyQXeyCzndPvfNmS/qYXk714YQosaDXQHw1ft7MdktAJKKXi7hrdB5jM15DzGuuHUFLhTxtKWpNCIeCSQmVYvgAAkovyVusvIyHoT/EGCZ+SLX6AumpI0WvuKcWUKp6TouhgwGgM5boZfEsCVpBM1Bg82h7Ra+2jZGFVvp2KgOMlxES1JLu2PInOCNyGOPsN4H+ONKE0J/bBBNSgoI6Kef6ah3hdeRHWF41M6haD6d27m99Kycajwvo8zvQU1S00oZOcvjSICt0yQ88UCRteMJ1t4H5ghX9ggQkABZdjLBszXapQpHVLpPA2ZGVsWpAVIFg4rmA0SXdL+dDDhsK1LKVBFZyTBhXrEl6tyu0KCBZTYZQk8nU2Vu9ohv7ogNkIArHWfaOivfEEZWuViatVwjRIAKcMd2/uiaJA9uUZCVRLU+U+bIocywLF8B/zg1uhlKVsyxhToLBYASAk7fg5g44oiPaFNoVtaIhuYIDJCA+JRoJgstL7QJ2WVbqHiKe3rj5JuRCOiON23qKlqAlD1Z90oLQgQcG3HeLOq1S8ZpnNAgNWGcsNjaFsqdXm6gRMW5GXbauB4jyfEcTVafS/Ppbr5G1ejrDyDqvlYNIf5ro26ylIy912HBobjm4jG2BNVBw8ievgLpg+gLM7aKXD4AEdCpy7UK9xMk9QDjN0YSB4iPAUgAMlTEzt5KpotjPXQIIcmRINqWR03lbWZlJJYA3d5t3tbtEEViJS7sufovZm5eCEAAdgHdl2kAutOfAog75Q1Uyn7iXoKR7v/gml1FxSAjKpk5KqxgAEFN3D5dRS5pyPsNsYiTory+7b0GagnQY4sIgJ8W7tnS5OJODsdSEMr0VdmRa3OpHTJqVYMkvk6mVxVUNE3Z0el+pECMYgDNWADmsOta725e6I4I6o3o3u+l79l6WnOR3bCoPOJeldlYnXC7tuRapfAulPPWUABmjr4qb6wVH6+Ozgrqz7+QGBfBoRtxLOlgNMztLArP3vnGCAzXiAd4bw5nsvm975FOw66hWukqCA8fKFAypATIUA6pXRcfXup7nR4WH1XJblobQp9g7ZymqFqLxyGH4PbOiCPPCAkAgSVvsmJ28mQrwdehIr49Zo+pKOL/JvMNCdy3E+jfGHEuaevPtLEV+agNqWuDKCSNafJ+crQG6Wn2Zmgl74gOkIDdrPOjxm8nZ4oZGwvBEwo+Goptq+VB4V98dskXGVkkqdy1/ecO2WRSEZ/xqjVBb1vpQsYuXxUZHiQAwJ12kTa91nT4tgAJmFhQny1IYQCLKOcPT1TGcSO59ay+wNhah23p4SYtowmLZmokPDGOfY1UmQoPYFlezQ3HnumAMfF7ktHNseSsuDbd+ZC9U2WX+IAPePZoG/e1WeugGMiDhE3vDh22K0AC9aeEOIBJQbSq9qMvbNm6US74s05AgQD/4PYN1r/sKNTA6Cftegi7OG5Fi5DE//ipmMi3pbkXLyQARMzy0+N3ltDebATfDch58SPFW8zy9o30Vf8rDHWv/wYUkmITNfGcwLmYXJULjbPVFw4U9LiOGsEgg4CACM0RdlcojFIVlvVxteASmRXamuhPNFOLFeQSLkI9m18JDZAAKrzAtycJZnf2ouNHMyafm5i4B6y55FXSHmH4RoMXCQnSDemg5FqdwnCgyQsOcHOvGmG0nWEhiyJxnmsQtDAkGb3zAaZB2PFAaQ+/ugff0heJTv/0C4QaF0GzBCFFTYIWgNJy7IA4EQuwExx6dRukV2/pkAYOCWJZUqP2CQ04NmIrs7g2TxZ3SNohg1hCRNcR8Tt9u/+l/pCY80tkdVvhWUZcxQpgHMJvC+ik/ZrACuW39WDmV7lctz7HwgqqkQd3VeSK4XnBGqh6igDfN9QU6W4Td/RIFIAwIGAgwQYEDyIMAGAhw4YOH0KMKHEixYoWL2KMGGBDhoweP4IMKXIkSYgTJFCYKOEDxQcSJpSMKXMmTYYBEiAUIDCngAE4Dy4IIHQo0aJFESAManQp0wBIBx5oKpQAz6oEpTIdMKDogJxKh1JF2GBoAYQGij7A2hTA06pR1RIti1CBAqsCCMD9STCBUb1AExw48FVqW7sIjuY0INesXQEJakKOLHky5cqWK59MKXElxQwSOFwOLTrkzsYECwT/VoBgK1yjXc3CJeBg4OGhB+ZiHYDgwOrSVlsLHbDTAV6wcgsUL+pbAIOhCw4WYA1AaNql06WGtTqYwAEFyY1WyBmhcM61RHkazQ79IF+sEGbbLQBBuWmCyw8aIDB6P//+/v/vl5lKLE0UAEoAIrjffaa9BVxfPLHWlHoCjBUABBACN8BiPJ3VlE8JbPUaUEUtMJhRt+nUXFHjfTdUdQ4KVZdVtcUIXVYbDrTgQAXExpOKRMF3Wk4ReogjQkQKpWN99iXYpJNPQpmggJsROBEFEigUpZYx+bVkT1IlYIABCMz34JBYGRnUczm1qBZgIC73o1GFJUCeAArAmKeLMDLQ/4CRBK1GVASJMQUBAvcFeZADcDHAk4kBDBCkQTm1B6ZdHRbVZVV/HrSlp5+CGqpFU0bEGUUcSNCRqKtWpKRVyYXpwAFb+Rada4RKJSJ7kPqo51AIlGWAnEVNqFNOPPoK44twDWoXnkVNitABCZSJmLTF0ogmQsgutQABW/GULVPR8hQBU64KcGhjrLLbrrv+kQqABfPSK4EE9M67wUMnPfCuvwuFOWaxPLWHbrpD+YQXecMuVa5Q5AqwaLJDhdlApdAeiytTC01M1LJqmcYasKi5KqdPie7oFH5DXSchQm0udd+jRsnIU4NLRUCXwTxV8K/PPwMdUrz2El100VU2JP8BCEG7q9BN7G26M7IoDkQAAQ0YMCtcNV8VXGm2OtjyUL5hCmR9F3ccgNVMfSxVo1Y1wBrKjYFlVYcLVHAAzLl2VwGSTb1N0LNYFasAiK1p6GWOTDPeuOMAxPuQqRN1IIG+j68q1AFlyao4T4va+XduibbIQAJ7w2gn2gFwTVB4BN0sdp7qmYsWcGsiFAGRmjaGl66Upu0gA7wlYJADCKytFtdltxZ4ffphHr30rEbu0OQSWSABBtODirvnMwZgpLitEVDB4cGfm1OFRPH+bQLnB+/8QMO2rTbM6GGsuLl2Cp627FJxLSp+QR1Y6FI7ofyPKQOzymO458AHOql6SUP/WkQ+QEEIOolT3xuIxGxGFGAJoADImxn64HKf9Q3lQmdKlrf+1ro72e6Dp/mOndr0whxR7SBbeR1CKsCwvoiJTBCo0w/dlJPQoe9/ulHcATDoxCeKRoIMuR5ELiABDUDRSQvcoAHaM7BK5dA+ooNUUSCQPKYw4FEJVBlCVsdG2LFwMTcLwH2Yt6xiRchR6flNlxqAAARoinnjWo998nQfI81xjXkK49my6MhHzkSKC6HiQzQggQtAEkA83OBBaPS7lAXHbn2Ry1v8crHp6MUBJCxjogRJAAWICVATw1G2GDk46hDlPhUIJfBoVhWhRGA2BUgUjgg4lcbMUS1z4wkK/0vIv8bwKJPSnCZGJAkASjoEBBKgZn945yUEzKaLttHjMa0ipy7lJydywmNrDiXOooSxiFhpmaa4FQDvDcREyzLSsz55F+ccIGsLsBPznpmjrZkGLi1j5NySOTFDadBuA+AmRSvaEGtWBAP3sqhoAsBJD3r0c3V7VXASxxjcjO2IHcMnhTrGP6IMgADHaVN1pnMfGrWOW80iCAGW06KIOkZ5CXXQ75CzwuBBAKgEmyhHm0pNjFJkAxLogFMvI7+PCsBb4BOKBhfAgGXuSGMhlZZL8ZesnZ5GKG3RWxHveFQIfO0rx3JKsFoEANMIco92kRhRZaSArewUOTBS5BtNY/866FU1sZCE6kS0qdjLKLU+f7TLUK6aI5ae9CA3u2lZy9MxHPGFPM30WKZOw7DDBiACBnDADZWiG9UQCWJzVYtsD2JM4a1yKgkg4QAO0ADBDAWsPHkscR/J2OL+x6RYjaVVGjTEzdmWkQi5KpHQOpAx3k59aYuULMc6oqXUL43WGadd8ILP5FhWURHCbsBWg6ICRIAACRgWYX21gMWMtkvFES5CHIDc/2LwuADmz02mhdWQyTCzvZLpjhjWFsHqSWxhzC0C4eKtMvnTjQGon1rS28kAzI0oDNiJAv5EABAKwKFLGcB97VOtjmnFKDi62cDUuiQFDDjH0tuIqnS8pRv/HpggcuIQh8S1AOzG9LYOulrWsAtjnuztY0/JT1MMKjh/7m0AQD4InrScox/i6Ja+YrBOIlTjoVRlvxlro4/b7OY3U0S59VmQdInEky1rWCiACVQJ+9yanDZlWcsZn42RiVnUYdYrODLRwJyslgnJp9BHmk56i8PI+2QJzpredJvpuCQH1DZ8YilKuQwqOjnT188wPoAD3ikUBsByMQVY5YssC7NEj8hI2PUwl3MiZt45Giv3eYzaZhuA9M6Hf6gxLaeb7WwA+9NLijELkSx7Fp8QzGm53JYzHYCaYM8TUhvqUJf0hpUXKZspOSwA19pTbqzM2dhext+R9XTnlO4K/80qTbQBAGBGBjw74AJX7JZNgyNBPnOXGb4Vm4K3HHBjhZHfOhaGUfTXPem5KkV85Zi2MlD4FTarAIQmQ4PDKeTJRZUwmtsuhQKBmonLum+RrmMGbvObNxWEzBVABYzE3y8RZYtJOqpzeBLpiVk3xWlDpDe3giPWvCjavy0AavKEI3sapbanKVEvn4k8ohvxSGUM0fsiBGvW/ki6DcA529teUTKK2nOPsspW5Ndyo7hFQt054FJeiHWi1JcsvtZ6F3PylmV5U1FLJqdRAPDC/CCPYlzGt+IDIFtCSyWHeysMjf5XrH67PfSil+Yml8SVCGgdoK1GnTfVvTLXc7tjNP+322w/ZrA8s6yc03UZQgjtEwQMRrYV4meefBKBFwddnVJ5+Oib73wnerc+CvhKwTE/8pzMR2zYUqBKx4s4YjZGth362BZPw2f3mBX2Bw237nk6dLL6mfiEofqsnm//+0cv+ksqAAOsDHTh5QRfEYV0GQDfkdf6BU/xeEdEGVUb4RJ9NJJ7lB7uTUVgJEfgaY5mjZQOxY8CsFbS6cTG4N8IkuDjlB9BRMDsWYV3KNm22VbfNddScIfhqBpX2YW55NBYDEAEjEDDLAmS7cQw6UQLTsxAIYCckAcRYgeDNF4JOuET/swJBlkIURg85cjeJN7/kQ8gIV9u/BEDzNt6UNn/q1kg62xd7n1TVnhFDZIP2GXF5rhaXCBYUUBhHdohq+jfFBobjBFAUCgJBcLUhsiTtawg4J2IZ1FeY2CenYgZG6YP/DUewoxa8jUG89zhJWKip/ifVUSW+xGLQBRgJOZPmaGYA7aGbDGKXTTABTIFlF0HAODaywxS7LFfa2Bg3E0eVtxQgxjMYGTiLwJjkzCZ3kCAv8nZgYkLeYiL7LROh9wHdokNlqmFCraJ7PhTtsAiXjXFpTkibXWfVIhSevkJu31FMJrjOT6J4hCHai3Id9SZh+jR76zGoXhHrmRb7vmSVTgA2lWYtglFuOBjwd3dUlyVAXajUVAXyLzKJh4M/zo65EMS2JKchbcoBXkIoDeBDUJCWXAgQAMoABhuSCLJYVKEnWkYpNNI16zB1LbQ4PxFjAYeJOGknGuV3f/MHiAtSQNB5E7ypGREVgHUCtkQiXA1Ii+RZD5+11J0SVEuRSfio22QAAkMBA5I5XXBFBzyRX1BzLQQSYnACIsFT71lHBzJV3FEm2OokMH15FqyJZdM4RzRjfoNxGj94zcKhVimllwk42ppDUzJSEQ1x3hkZY1IZVR+mD/qhrm5TWK0zAIECSAe20whjIyMoYPEogNshdZthRQORFt65md6hAp6CWYKHt1to+C8WMsA5FiW2fJBB5LJV7lsyAJMh0H92v/rMcVLGaUnNgVLKQXKFNEaaV0hDUxxAEAYbgpoKudySsTOGFwiNpyHgKH3vZCKQBrvwaRUGMnVlaZdflIT5aZZERRh3FvS5VUCZSEHbmR3VoVOMud7LqenBZmlNcbfJFkXMlz/vF++IWVa0SGxPE9w3BCR6KYh8gokhlp4ipR0teGSgOE9HmhzweeEvmdMIeNdKiIhBlVusJqr+ZOK+Z2FQRdJEYUImJYVIuJSFEZGLkiZyA6nrJ2d/B1TFBxCzMd6RqhtXRiF8ihzimbvBJezfEv7zQ+MlN6Hndg62eWK1ahVesy/9SORhqBULEB3tMd1FCjepVmO0gax8AaSLFP/q8Ff6QmgfJ5Gj6Lpe3YihhSbRN7HR54OXFDjaw5F6+BeUtVHMqUFdsWJAvEGb6VfUfwJjaBVM/nGxbzQzHVXBuZIhCwEqqVppConQ3IIo06hSsKj4mDKJ0XAdFRLlSrAcB4mTIXAjpxkAKCIsDxil8Jg7yUQEgXHpBQA2jDSAbEUkdTdThxGTDlqQxQYmUhqsH4mBMjqmgbFjyrOjEqePq4n/0QAKVHqQLiRA3jAC+aJncyM+JEIa1ANpqLqGurbsSgFmaEGV24gl0mHsKormjon7BjeQHFSlq3piLTr2chgAKrF/yBSzGgM1RhAiPRhgqFUXf6Sc5BZ1QgFWMnH/7oyLI9y5rY44MMCz/80aVXgSb3eYJUFqvedh+EpZfcth7Juigveo02Vx1nWXMOq7HuWnnd4Dl5w4qW0IifxiMTGB36y5kFwhYz05VU6DL8ShMTwT5tEmz15mCdBWUSt3coyrXIaH1MtxM/ZyEchCbhwkjNOYZmuZLW6zkrSadFVapUFEXsuascu6YjhqD+Jaoo1bdtOKK+p00eBzYNxUqUkANU1wAJULI6mB9e2FFEcabbQ2XwQgO7ARVWcJM3Navn8aZfYE8pqh9tKLnPu7V3UZ0dWxb9ibI7kIkxtBVxtkIpRRwTsllHUkSQCj3pEBaUNKcWU2MYeYPjVzKy1jP9s1SgCTG7uKqdzWpkDvE8FSK3nzOMR5t7dNqraIOuogldTnBDqttEn7ZYciZs55YrVeM70DWcCgJXf6G73eiYuQpMefo9C9FTE8MV17udAFByRyA6HSSN09oSdeFvvAdm/9oj4OsZV/av38m9bhlx9UB3+2oWFataweY3gvBLibswDZp2vFYX8HEbyhgvOuka0/iAAlC/b9u8Ge6YEC/CO6MgxWmyc3pO6QIfh/FGw1U9a8ifCdGh7WHDvtYYHL0kT2QQH4/D3HukHI64/GUAsatwzQRwDe60pwlRpdBkA38cg/or4Ul0B5nAUM2d6Bhn/lUZ7LECtaMWd1a2DcNj/3DwKykRFk+Jk5y6h+NKmFKvxch6sAB8Ahj2KT1TAASEKJ1nf8t5rdlYWesgWUAJKGN2x2cbgEiniGhvycvYWIcmtPzJyb85rebkcXHDYsRmPGwEbI+lgcxQL2rAIgDaGiljZahzyKCtnlXLlI4MdRaqFofBGDCdEBlcmHhOL4WobWO5xebCU71hqIb0aflQLCPJn4uEuKRMzc0LAiG5Q64Lu8cqp9NmMZWnYi4xHYbyFcCzqcryFeiTAs6pvH4erfnIpe6RrHmpwMZvzcroydBQPbCCUaSTAC4GTAhvFnp4c+G6oNUMFseAFpHlsmyZE7B5EMTqE86jqORv0crYY//6ayP9QcZG2q8SEybelhXDB1x4OwHQyxXaK3dNE5y7viETIVxof9Egj8gDUlglLZF3NrLSUHqZwB7Ki9EA8ABC/1Indls1YnNnlHXQiFkn7dKS2Do4d5/B8T5tgFg4WxHoFFCeFQPn57udYa5QSbAuzDwNNx3S8V0//9Fb3aE8NU6c2RENzWzSuJwTgpT9zkgegLMxCrBEfoo02MjkvjkNkGlfbNcPK9QCbLi0aBRDXhweYYaWadK/xRDHOIsI2XvkVwF0zttsywCN3IaqhrQg1cZB5gMWkmZ0A86ne5TYvcPnZcGOL9sq261gk0ImdL2zA7fcs05/oSFauUcvItv9NDPBo27bKaq8iK55NMG9iePDVofIccizLQMTA/PBtI7fKmg5tMlkF/JFWP4Qg4wcPH1huYURvZY2KJPd2j3LmUjdWrR1xc/d4I7d0ve53cxJ5q/d22/M/0bA6JvT+rfd83zb4Lq1NGK/4Qk/x+JFpDDN9AzhjO4WYuGdD2GwIccpiP0Qbj1uAO/h659A7d9LsbkWpeoVEeBUYHuduQPeDe/htf0iWGCFTxRTALUS/AACs+dGHs3iLjwSKu3iMy7hHwPiM2/iNQ0SN4/iO37iO8/iPu7iPA/mQP7iQE/mRz7eRI/mSc7eSM/mT27aTQ/mU37WUU/mV+7SVY/mWn7P/lnP5l4+yl4P5mEuxmJP5mW+wmaP5muuumrP5m7etm8P5nDesnNP5nQerneP5nveonvP5n7+nnwP6oH+moBP6ofekoSP6ojukojP6owOjo0P6pN+hpFP6pTuhpWP6pt+fpnP6p4+ep4P6qLOdqJP6qQucqaP6qnOaqrP6q7uZq8P6rA+YrNP6rROXreP6rjuVrvP6r1OUrwP7sGeSsBP7sUORsSP7sj+QsjP7s0ePs0P7tDOOtFP7tfuMtWP7treLtnP7t4eKt4P7uGuJuJP7uTeJuaP7uvuHurP7u4uGu8P7vFOGvNP7vdcEVeH7vvN7v/v7vwN8wAv8wBN8wRv8/8EjfMIr/MIzfMM7/MNDfMRL/MRTfMVb/MVjfMZr/MZzfMd7/MeDfMiL/MiTfMmb/MmjfMqr/MqzfMu7/MvDfMzL/MzTfM3b/M3jfM7r/M7zfM/7/M8DfdAL/dATfdEb/dEjfdIr/dIzfdM7/dNDfdRL/dRTfdVb/dVjfdZr/dZzfdd7/deDfdiL/dgLKwZoACaRPaTHywVswAN8gL3U9ULwS9qr/YFMkdHE/UI4Ft0zerxoAAdcgIFgCURIlb7z/aFLEdxDhEZZwOEjeuIPPkS8veMjvt1LTuRX0iVR/qBDft4vhBVh0eb/eedLhAWJ/uhbvvVg/kNkz/acPp6Tfv9EFP7rw37qJ83qZ9M20f6dx/6+SIC97z53975DoEqPBf+bD39DXInnHz+ZxwsHUED020v0U0Doc4ztNz+ax0v2GM30N4RngEb2Iz/2V4RLwIT4s7mATdHSoH/6kz/lWE77u79myP+jq3/9wzmP4f/+83//+///AwQAgQMJFjR4EGFChQsZNnT4EGJEiRMpVrR4EWNGjRs5dvT4EWRIkSNJljR5EmVKlStZtnT5EmZMmTNp1rR5E2dOnTt59vT5E2hQoUOJFjV6FGlSpUuZNnX6FGpUqVOpVrV6FWtWrVu5dvX6FWxYsWPJljV7Fm1atWvZtnX7Fm5cuXPp1rV7F28oXr17+fb1+xdwYMGDCRc2fBhxYsWLGTd2/BhyZMmTKVe2fBlz5poBAQAh+QQAPAAAACH/C05FVFNDQVBFMi4wAwEAAAAsNAAxALkC3QKH/v7+7u7u8Uop8VU279fT77es8WdM8Idz8JiH8KaX78vE78O78Xtk8XNaSEhI7+DdAAAA8V5B8JB98K6h2traPj09SRYMWFhYubm5Z2dnmJiYx8fHh4eHeHh4qKiociMUqjQc1UMmGRkZKygnSTg0jSoXyT0hPhMKSSokYx0QTCMauzkgsZeS0baxnTAasGZXjzkoz3dmZ1ZSkHp1dUM5z2VQPiIcr1ZEcTgt1aSazqmibUxFpEY0lGBWjWtl11Q70JaKjVpPTEA+jkM001lBnYF8yYV4sImCemNeei8g2cO/vYV6AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACP8AAQgcSLCgwYMIEypcyLChw4cQI0qcSLGixYsYM2rcSJBCBg8cQ4ocSbKkyZMoU6pcybKly5cwY0akAKGCwQ4jIIhwgMEghBEygwodSrSo0aNIkypdqpSmzYEBcoq4UAECBA0FHUCgwLSr169gw4odS7asUKcEtToYiMEq14EaIHAwS7eu3bt48+rdmxGtQJoQAhDMAOECwQA1+SpezLix48eQQ/oFwCExwbYQClYVHLmz58+gQ4tOOvkChA4+txKsjHW069ewY8uebXBy1dYErfYcSHMt7d/AgwsfDnZyTtwDRUAASTAn8efQo0ufvtH4VYPKmQ/ssJy69+/gwz//t329oO6CceeKX8++vXvGpU+nfjtQK/33+PPr3390cuWnbFnlE1D8FWjggQiONBlgnAlEmGEEeSBfghRWaOGFtVkmkFoBqkaQaRtgKOKIJOI3GQBR6XSBVuURJIIIJcYo44zQnSgQTjrxZFBbGdDo449AimZjQ4TtFuSRSCaJ15AMOafkk1BG2RWTCm1QmJRYZqklTFRu6eWXYLLUZZhklmnmRQF0gNyZbLbp5ptwxinnnHTWaeedeOap55589unnn4AGKuighBZq6KGIJqrooow26uijkEYq6aSUVmrppZhmqummnHbq6aeghirqqKSWauqpqKaq6qqsturqq7DG/yrrrLTWauutuOaq66689urrr8AGK+ywxBZr7LHIJqvsssw26+yz0EYr7bTUVmvttdhmq+223Hbr7bfghqtlBT2Ka257FRB47rrfBXABjOzGOx0GGojQoLz4CtfBBiNol++/tK3lQLkAFxybwL4ZrLCQqDlwwb0LRwyZBiA5QLHEGEOWgWAOBEBwxiDz5ZvAIZe8F4RrbWzyynVtoN5aHvjL8sxgcbDbWh7TrDNYEAIw8s5AM5WwbxncF/TRQuW8oUAxI+20UB7glvDTVMe0b31VZw3T1FNr7TVK93X99dgoiU322SOZjfbaGqnN9tsVuQ333BDJTffdC9mN994G6f/N998+Ay54Qn4Pfnfhhs+NeOJvL8742o4/fnbkko9NeeVeX4551ppvTnXnnjsNeuhHj0460KafrnPqqs/Meusrvw57ybLPDnLttmOMe+4R7867wr7/XnDwwv9LfPH4Ho98vMovv27zzpsLffThTk/9t9Zf32322m/LfffZfg/+teKPX2355k+LfvrRrs/+s+6/32z88i9Lf/3J3o//sfrvX2z//hsWAAMYrAES8FcGPKCuHvCAwBFkAQtQoLYCgAADGCABClGAAQQgAAOQYCAF4CAHEQAABTBgAA2IoASRFQAJRCACAxChDAXQAISEUIYWqOAMOXiAGSaAAAVQAAX/Y9gABCRgAQVIQAFQtMJWEaABAzAAAhoUgBjucIcbFMABBIOAK1rgimAMYxi32MRSJcCCVhThABoIgB6K8YpSBOMX30hHMRqgjKNqgBgZIJA01pGOc/yjIGWoQjxOKgALIIAN6SgYPw5SjmF05CNFiEGBLEACCFCkIRW1AD1y0ABsXMABDlAAN4oxABScpBgDOUMDLECVO6ykJ3l4AAsyAAEK2KSfSomAAkhyAABggAwlOcMGoDIAWYQlJR9AgmGOcgGoJIAOYTkALtLxgmzUpZ0CEAE6SuCRQjxmAhjQTWU+IAAOkOYBEnDMdqLSlBz8pSMHAE1kCrKSD8ylNs8U/wACwDOMyazjEt1ZRWVGkQEkIChBTWmAAnRxhlGcACoVoMR2EjOMBYAmABIwTHzuc0sBEKYgAxpPMFaToDdUJgctwM4h0lCjLWzlLHcoAYUG4J9/FOkMD/DRJz1ApANIIknrqFMRGvGKWyRoUek4gHLO8IsEIGk94ShGAiiUABdVpSbHeYBC9pRET1QpHdk5Uw42oAAEHaoYL/rFbxazn1dcqg+PCcFjEuCEWb0nAIY6AI9+lUIEEOsfA6AAMDLAnTiNKwISu1IaXhGVVyyAWjnIzgRYMajtnIBgD/BQpBYArX9NkFyZesHC/hGtCigrBwvwgARIYAKmFaMxCwrJzv+q8Z2tRCUCiAnEHVoVlart4CANkFejhvZAk0wqKlP6RrSicqjEVaNkP6kA22oRrZMVAEsDu9Nj6tQAVp0AMclK035aNrLZ3eEAiivCJR5XPBRswAE0KRDmEtWEAhhATe0LxnM+95r9/G0pGxDQOBbTAAhFJUdFaAB3AlEBBEiAdWVoAAVIUr5hDK5wr4jhOt7xveDBqgwr+YBBDoCUuT1vGFtqTTr+1sJjnGlSFdCxaC7WuQ7WMESH6lSqznCKASiAXAsgYqaCGDyqbeCE8xvPxaaXwjs+qzsX3FxUFjfIz0yldhngX4JGGAFLBqgggwpHiQYgAVCM5wQEclc61vD/yNQJwBXZuWQCPOC3jK3jSd3JXzBKtM8zdGdnv9hgdwIA0HTscSSnGNsr+rGm7pyAASJgAM46UqNwlo6cY4lIpB4zz38MZzt1PEO0UhmMhdYtDjlYz2OWGJak/jF7ZfhbVBb1sFGNJ44hlmnaPAABtxyqVX3JYQJwV6WtPiYx54nKV4oRxySdI4sVrEwYC3bO4tyhRAFg7HaiCJUCOfM6OSNKv/b6Mc4GYybz2lCT/nHPx9zrFXcrQ2i3MoYNPaZmn7pad45Wz4R9MiyBDADVGlOd027nAvy48HqfOzLzrKWUBT5ZBfAS1GbmMxYD0FrO1hoAP22yoQWD0y/CWzD//67ji0GtygEwQIjQPXUEfvtt2p7y4Y7ps6gb/Ugco0infYViCm2qZR4SvZ139nbNb7pDC8xcMO0M8x8hHWtldpKmOzxsO3kORgngnDFBvqKoTz1IEhKUors+Oiof8Fmbhjve8a45Eoe9QxRcFdF/rLTAqaneJbsz3XsEeRLp+3WmFEACDCjiAxaQReVuepjtdKuJa632ysO9lKSE+8hrTgCnHhaeBqjxMQug6Gv/+AApp2ZiK11r9i52mPosPFKsDdBsjxjMaJU8lNd6YlFv3vLeleFsic5EmxtdyMQdgAo0SVjTvzGC9nT+hsFYT7JLss6yR8qscUzvE1N43xQ2vv8Ykw18hYKfku0Eos+X+9joa3cAeJa+SV19gBi+fNbKbDCKJHvQHRJbveGWfUOBdzIEZFKnRVLVT6XnaJkHbuUHdQFgcJ+mRslGdhzUWyL0RUkFXfXnfAkXdfLnW+70aiOlawIoExZoUpn0RtXkRq6kcA7lYRBYft8GXaoGeXT1WPBkcgKhWltkevkmTgxwAKK2d2P0RjTHfsrkXifoEsemZ4xUef7kTQ8oaDsEZJLUUgrQgRC1g/m1fzskRAs4SI7XT37EYryUeuqVSFmVajmoTBHQhDBRdSOldjU3hrdVhe3UYxHgX3CUACmoRqs2RShiW5WEUxb0bpTHdDO0iH//dFatJk22NEPkZ2UqJYcksYUNIAGYVnMsJ0iVSHSAB0Z6iHS7pV9dhodvpFMWMAC+RwATwFrBB1GKSFDz1k6JJUllyGcMwHoK5nEThX8AiIkhYYGTll8JtwAnFEk7hW+R6GSflHZhl2FuV4q2l1wZmF9QV3y4qF6OdkWL+HgF2GxHWGrv5IwOmH5nKE44pYYNcE4VdEHEaBHiCEaklGw6hksHUEThOI3+506q6Hs2dV4R8IHe1k4qNlzZKADsVHNLx19qdX4iVIlDBU1PmFtFBWkJqFQiGFO5tYVG2EHzKBFYNlK/lV2LuHSWCEfp940vV3nWBWRE12VnppALmVQq//lr5ERhFvhy4Hh2M6R1YaZcl4RLShh+tshpgYhjqlhqI/kQBAhGEXCDVxSK7YR3w3eR/WZ5WikAx2RCUfRDLohjgsRlaTRHMqmOFMYALaVoMBeUNgWWFzSL3UV0uidCCnWLFzV8o+hhhPeUBdGVf2SRF9WPCPlGyjVUNHl0fQZNo+hIznWAAkBk/kVlc0R53yZXtTaFHVRPDyBji3l0iSWNIAhRCjVUQhRGU/mVwihdgGkQkilGZpZYw0d0gilDrDli5deXAmBVT5ZqCdBNA0BvIrSLbvRFzvV2kMVpmkdQfrSaBKWSzZdbR6eVu9hpMqR1F6V1uAVLTDiPIUdDdP9ojxcFXraZUYwYRpuJAPIlkJXnSA1GgqdkU+zJAKRpXgnFje10i2o3YWmpdudXmzbFX9y5dJ3UVCwWiMmmUh82j+KXdULWAJUlAWWVVffZnflFUTFUeidnjYSVRvC3nGvloagkeqcplRdqgw84eJY3WheqUEumXII5ABMwTqn3lIEoQ+5ZiCKUehdqXfBGUh/YbdFZea41bbH2n9KpdiZKpOS4YjYlgelnmHo4WVQ6g2snSb8VXGk3hsA0klXXnFuHgWDknseEbWsHVAkXVshIomnKgvMlppZXY2waATi2hVHkaYZmgSwmXmZ1pcD3b4QIfF0pUV3phtG0YiP5iZb/x3UMRnQSOUIj2I+QOXLEl1a1qFBL2k41dmkzGIiOl5nCN3qm6aaOqkUP2JXsxJtoJVkREKc6dljEyJsydJ0nukNPZ1OjaXn8FaKEqnGCZKuV1zEWKKCI1o+Yt2tDZZBVmFgZp6mYukPzBY7/FKlXiIlFN30CkKtSCKK91J/tB5NgJKAKpWLKFZs4qIcdo1odelHcqnZ6yhnWeJfQWY0ONl7/lELeOFbYKk1GKUrENZeaRwBmOgHf2qjSCnw5Sq7dmJ0oYq2RZI0OkFj1+qSOVnkocn3At6lmOEyASnSq1WDoqmcCWKTR5EfcaWsMlgChWX6nhqgHiXRVBaO8tZJ1//Sf5ddMaBqtzKl2Fvix4jpX/RRE5YdTe8Zys0ZFEBZaQER4WIpY/neSVemh0iQBLwqjGEVQUmdmDQdgXmZ5OluX0ZlrCWt5s4RZJlt+Q/V5DAa0PalsshWVJwUAnQVKH+V+svq07nRRwzl/RkpcL0l0CmCmwPqTe5u1xxRQEbCFlIZgH9hZNcWxYYubcmqzRmV58NSHbvpfQQmkwOdI4XSb+WVVX9aqjgSI0TVMH0VSwmpRqnS1/xSK/4e2REdMBkChcQpXfnuUl6u3GGp06dhOQpB1RtqRR9eXreuy/idJVxtNIvWCZ7pDDcCPNkW2dPSdeNSVH/uJkXV0XAezXP9HhKKIReZYj2rke3IFsy1pvATlALblq2onefRkeXepjZvrfgLAZfyJUqjXgLpqmhpEXYKGf+bWRDrXrZMUjjWXggtljzMpYUpUZGo0vSRFu3T5qOP7jzblAKVkQZlUnenXdl7mSdAbXPe7XKPkXMyrUGX1rv4mQjMnwX/Kuaf1dhIERBHUlf2ESVT6a6k7Q6WXvAzsTtnFrO50qiUVTwV7hZaaqGFoUw8QSPP7v22KIkl3r434oCl7wtcYT+XKkudZT/U7uiMbT9yWReAVMRmgHo5hSq5YVrU0jgNKTDUlSsLpv9VLvABZe5U3xrVaUQ4mtQzWsu1EUupra6zUoTT/TFlkC71UWZyqysVY+0n9aKXAN1nLKEhEtkPZVC2T0RYAwhCb4RjW12a0pMEOZlh8dllGXJNqtIjppcjO+UYw+38VdmYezJXJ5ML7yUoC8KwWq0age0yqNXPdK8kEtXiE+6CsFqjuRoaI+JfS8skawhCs0RiOikEEy5nUaYUQ5XvchsoKtYVsiVKrKIVe+4avXIpJ9KKB5csdiq7ciYj4a7/I3KykCHyA1podNFk85cnVTAG8lhC9wRgaJpMaZsG/i5fuVL8MS79vtMyuRkf/KVc4y8UD4MuTGWkAF8z9JsPNe89eprGQKpxTFKOPhHpjBNChLBFOwhc56ly0OsiH/9nNExVcrbYAgAyuqGaVVzlNqDbLcCnSFKTRWyx+Kooip+Z4CQCMesixVAt0F93F+dtPM9VgIdlBWEkt1NzSC8EdMoMXYwidsVmGlfrI4Gi9rqh2WjnVIxiBjuZQucyzxTl6PyTJGg2zXftS2uZggHilUI3M+nlV7/nEhCUBDSjDFA1qBcwsXQ0RVtIzdxFh/1dMv/VrdZRjugZusdkASyXLNW1WMHlR41Z5/CVEzJW8D6jRD51E1VerkuykV6XARL2+QtucoruvkdTYyvLYEKEcecHYKBLAfxSa3UYAuLuEUihhzevHHARplcd49aa7unm/k7uVy33XJ2zL7qliDf8AtJIsn+1l1RzEALUWlY/UoM7i2w9RJHeRox10sqiGqxksVsBMV+A90WKk2iGVncc0YRXroQ6AsrUd3RBFeWR3yFXYtM4MeYqdABDWT8S5Vn/E28fC3g7BI3bBm1Z0AP41YVKEVmWFYxE2Af6V1WHknnWb3zPNQfdNUBYYTol1wijwVgV+dBbtuuVrjZ/Zo7pMgemJRQjgp4iZd9DC3heQ5Equ5AVR0GbBzOOduFhUcxKAbzgGT5ssWEdtfeWHxPFdeWpl3sZ4whot0VUY2Ic71CIqx9ZYVke9pA7VUujNVIodSfPVLOxtFXq+5wVxzWYhcA07qkdngegtT+UdjpL/9OI25c+ErJaORnvYTaIKoNEXOgEENmkCe8JD5XiJTrWGW365XXbjKULSbCwY3hCjXBZeHuXYOd1HZ4RkVwBllUjJVIb7i8DxBLSmnFXz5Ul2esIEoNFWmVj8LYpgRncz5Hue66GNic+ml2a6PeXLcuoLgRheHRZNSVmlOUJsd6Gzxk7SdEu/RW9D50hpmYVV6FAhnbF1tJpX3MR6qAI2rXApbo1FddKu3k5AJ2po7mWO5nLgPep0xIWj6twDTSzUrhDpYRahzkHgHGE/dGoGWXWKDm7f1quh7cXBe7wbNJyWZ4G2u7lbWNrH5ACzZJ4KlWduPduurKNDS5psFosY/1t5pGbmC82C4zdhb2lSnWjqGgLKdeMhZIHeR63OE0lQLe7wCvvpHpmhlRfh/ljelWe0/NXKH++xJU9Y6GmXYbTy6edJ61W2N450sWp5SZ/sE46UhgyxM+R1F/7z1cwQP0EXXYl6Jo3jesxn5aRWRmna6uVlW390kndYkmTmAB7kRZ+qeW+ix6uen4uY0FrgQGS0/RlDKEu6EobGohayoyfwxfn21+4QEoIadAHHvnurSHlV58RY/G3uageS4vttd6lWVq+VWogAVru5Q4xORXvr8A7f2u6m/a5Q9QvaQW5W4dTUdy3bx1/VcPu6Ph/6DQEiQ/9DP1fXD4hT/J32rP8OrdabvPaVcRXu99iPzH5Xomrnw2cl6wYwvV1FqMVl/GPPdW5Nq/TEcFe1Q6226khYLGOyEAAhQgQAggUNHkSYUOFChgwJDBAQsUGAAAQUPKCYUaNGBQwGGEigIOJIAQQ2ntTIgKRElCgVFDC5kcCBjwkCQCQ5gKLIlT0jxmyZ8UGCkEGNHt3Z00BGB0YfkjyAtGUEnwMaRDwAVOpWrhQRkFzakoDPkTjLtiyAc0ABjWN7miVb9kFDunXt3sWbV+9evn39/gVMlwKECoENH1YYYAFcAVG5Llh5YDFUrldXhu3KcaXllWzdxo2oc2OBBhEYKMi44MCBCZkpAjg6IQH/54gLCGBsGvRAzwUbYR+F7NOma+IZfwdVsJptUJWgey7PSACm4t4nDawcQABBc+cHEH8HH178ePLlDw4ubF59w91ku15fqYB2461fV0ooTnE+2eXc40KnKIHOAmgvorAWSABA4iaLKAIDBmAAAZwayK0lxujLrACfGMgvMwW0yk+CC52LCLoHOGsAo9FKGzAADUkcYD0ZZ6SxRhvtCqADDW6ccT+SQAzqAZ8k8EnFo54qC8iuqsJOIx9Hckyot14kCQH4BBgAteIYi4rKiCxo6aULo+TqM5JOsqhDlOwTgAEjjZpgNS0zepLEkujcbCP/BGgAAaAEhJFHQQcltFBD/w9NyMu3Tuqopo18KpCkOTV6kyICmmMAqOOW7ClSARRUNKfRNnyrSeIAXSmAK78cLrpVW8xsTwQ4gm+A1tT06rKjHlh1VoqCIxGkyKLz6c9F27LTO0SXZbZZZ5+9a8SRWg0AAGCxSum5YttqzgAFcdXI05KSM+CASTMKdaRRe9qTP+LYJEnIlSwwF4EETHqVJA6La28AXyl6gLFvibuwupbELQABCcSFSjmKCrhuAGrThW5EgynylDSlyiUAWo8/Bjnk9a7t1Lqe5kQyIpte3TejVwcGN2UB/t2VYW81UmoCO6nlKlSdGLNgVZsbuLVDIFEdCbPMbrNUOKOkjauBA/9g1giAoeAdCSiyLg4QIm/T/VFksccmu2y6sD750Z5oDiCBAyTQkoArW35YqfwqRSkBBiTLTNp/Fe1t1QEKLu7V1pAWwAI7zwU3I3FF6yoBnDINwCeqK7cTyp7jotvHtqbTKN/LzCa9dNM9RntYnHsaroDVuN4J9HB94uo3AiwzgPGYRRfAyOT6BAqBCAbICnGlu5KuOVsdL0txEhtvCe3jkTKewbOMajcuA/AWi/ONSBZgOLk1zwhqdU9HP331azSTLPwyahffKrlCG3KpAJD5Tug10vk5rk6kjGvGJxEgESBBAXBeTlS3P2StpGhbMV+DlKQZ5yAAAZc7CeKwZBv/lKQlNEV7VZTqNBIErM+EJ0ThYVKnK0vBxSZog133VsI2pKCNTMXZFLH8t5X50E1vfDMKy4yCgrVx5obFWQADDMCAb3kwIjRsiWoiZKcJysQjERDX9KRCpJ4cSSvgEwC67LSAFJbRjGdkiGIOwIDslUgjP9TSmDY3Errx0G4MdJmppNK+n1QELlBMSk+qSALsYIQAHMSVonj2MNm9JnqZGwkGUTIfSXbwjlwR3Z8iqCw0dtKTJ3wjaI6oETn+jyi6Q4q4JoLHncClknXjDYEEiRafxJAiDlAAfCjHwAupiY8keqUjAyAhAdyscJ3JoXE0soACgDGM32ujALAomU9W/9OaZqtWRZzzvoPtkJUnAV8wLVUAVCqzIgg4gJ+Qty2fAPKXVazQN3kCq3eBZnB6/OaRmhMBmKkGeNaD1EkYBqlrFtSg0MqVc8rpR7B800oRUGdGkMbNrXDHAFUEVw8p0s6gzGeUTKlIAhCw0OLMkyTiPEnqFHBAk35qfwTZSgEkcK+KhIk2EXxmAzNHxoP21Kc8ysgK53ckmvhrKysNpuDeZECaBiVhTZVlQ7eSTKlwZl+/tCVFuPNRpiCtjpmhai87BL46aocBEsBozyIGSJmsCjoFmICWBgqarzqTLJz8aV71Op7VVeUAD+JTdZiZVqRwZgBZlejajJJDXp1Um/9py2dFEDnMSwblkIQl5EoWGaT2NACV4GNrReMTM3Q+0EULZE5PHpCyBmgQRgWEZGP2OlvaGkanvHmV5MhHHE/ZryXtOl6aurmSB7TUjZE1GQvBihIiKhcpr9LdL3GVgAdlBVxeigBQLpRW4TAGpwZa42b1A8mo1Na8573LSeLi2hkWx2nYO1ZFLGNU9bJOXqPVCDENgNj87GeV4GquqKTSP31ZErLI/R+7msY6p0AqtvQUC+/ch14KV5ggClgYOXVJFZ9I+Hqu4agw14Xf3G7kviSxiaeOR8n8MM5tCINeZgsslcehBIwmoSqC80a7AJw4kkfhMEm4uDO1iBclHmb/nYUFkwEPKNmT0ZQWkiNSnCD/+Cgc9VlySVKdAqVomZXdiHywNDz6Fsgx+dstV16iOwcwhqQZGfKHN8IYLerYnIlV7XhTdRRFMYC9K9mlAvgrkweHsbbouQsERuDkM8aZLICt0lzl3BVF1Vlt7XUtiBT1X8kCKXVCsRLRnCm1Yb2KeED835UuuhEHXMpAg86IcQGpALNk11JEIezSmuNZpBgXMzKrJMSwNKs/GyjXTi10Aw5NmLs4AAIUYHQKR4gdiEgsAMZlcHEmgJMDcO8k8TstPtG1Vo7QBCQbcW0LFQjJdMH6JPM5XjxdgzROd/CCQR1qcUyiW+8Sdk8KilNE/11j19AgRTowwzaJbDJbRNtFAxDgQLRPmPC43LDYXA1KDo+tbhKWr71HRS0fHSNpEvnoWznWIX5v6UsLojSc78IpxoPqNXc75YB5BI2SVASvgUmZLCXUa8PrEgBmS3x9xa4KmoiCNUtHVjsNYCJHzPLVIB443MamyHftOcvMgBFA8rZzVElSbxpnrumsLNBaugaaSi0APvli3AALzdOfCr0uFYBAtYyePrCBxii6xVBmrGSA0KIcKYPNTIijg04AaV2a7bwPcd6pEbA7HU/O3SMkL/rm2p3kOGi7HUmGB+gwdwecDRicBITNJxIxIOhFtwsHILCjvafP8cU0+DGTdv/tCdT88BvPyHt/FcMsCiddDxC2tflFesrbuV+zsmGGIKkWlBKsUySalFDpOGJsZWTboDHA69Njl8E4oPbpu9YSX/2yb2rQLKvuEOAvClOpgNtF1JcJXDjkOgumMyYh3B8zO4nKwyNZyZ/s6AqCAw3O6xCfqLKfuzzniICNyJeYkDvT6BTxy4sRgIDzQ58AQQDiMxAM0g7/y4xpO7vYwCcEoRqZGQ7jOpcHCDXTQpMrqbfL6pDiUhIC3B8+0olQoTqjeMCewCIFi6x8kTLHUMAtSzkUo4hXgbSs0UC86AAIaDIPJB2kMDyOuCnYQblpEwAGPLKeaAACuMAJGoq9MRj/cZG5wyOntriSNiQOHkQJb+Mzn1CAT0Oe9wMuIkSuvgMNX0G6fMMczXqszni7jplCCriARnTERow4g3i4SMRCHvEAvcsLEWuxpOOKQay+4Hs0zDsKJMQjAGQgOtSI1YuQENyKG9PDDDmg/bgQsruf2HiQ0/i+6YuJQZwWJ8mzdOGwCKA7TDyohsMACEDGZETG8SMIZ4O2SuQRCnAASkyvxuEdMQyAaQM+gCEmSKo5NmQgMLozNUFFWHqL1thCxuAQ4wpCTFIKb4KejOFFA5kTH0uaPIsOuLiVX1oJ1QgNoDMou6sLRYNGQvEAB8AAvICeuPC9AJgANnIb5ssMn/u4/5MYCv8rLvDBRqnItFOUCg8LrVZKmpiIFASMP9bxEiPLDz4iPDvJkpNIl79yrAwyQcWwEudgDGULSNirCw+AgA4oSEIJgAy4AGJcCE3MD7LwLdcQQNfQPu1BCTTjE/wLRx7bn3IsxLjItQJIAK6ZAAPgGHBZFcwogAKww5Ncm8xREnFBDZkSuIqgCT4BimjCvp1kRrq4AAjYgKAslA2Yxoa4sy0MCmdSSTU7S6MAQ/c4iSGEEkHLJ1O8SqmIoE9kJdgYvFkRzOkqlu8Kil4JEoFpm0KDCrvEC4Hgy0PRAAfYy4TgpSlxqMHhtYzbjwfMHph0jm1cmjhkJax0NHgMu//f3BW7ySXTc6q3WSiGkTvRxKtqEkiGOMYMOM1DGcoMMEoGwraG5ApZgROURL0GgImS0RPnwE7PO4qXwM2tcIDZiLqOioul7DzgfCk8Cw2geAmyoEUQayfGhDzeIE27yAAISMjoPBS/3BHzrErfbBwwCounehP/oEWk0SJtbJzMxCMCSKDAszF7YbGVPEz4LKk1esuEmkk1SbjVCBaT2LRi5MmG4EABZZYZsAAQ6D7oESs8WiGZHImLcZ2psSyFgRntu89euyK2otAOOYALFQBYMyu0yg+3o0cP/c20G090UxiyuJcIQhnUi4AE6KnmVIgNgIALcNFlGYAQSAELCIH/8IGeB/CUwsyPeXRPo4myDnWJPOmKIkWKAUBSioqsljLJDKq2kITSMpkAypQ6e9oJuhwl/DkABykAa/LSMQUZAlsBCyiBOHXKnPDOfOJHy7HOfOGZIt2Pt3FTNdGb9bwJJHUMPOUtxUop1BrU3yQXBqgO8/nTa/O7bIq1yGDOFZXUkMGaErAADEgkrnMNCp3HUhUg6bCXKnJMo7AnLXkTDONR3WMJAkFSQ20LrRARPtGSfLnBdDnPcYzVmMIOhqEKo8oh/QwsChSkT8oR2vvVkBmmC/mBC8gACkAJCs0XQcUVWsOOk2HVxhnOJwoKnFTF2ZCqzNCg1rDQGRurtwuc/9Ea1dlxFz6DDznUsYPrm50yCoBdr76qknkl2b2Yq9ZggREIgo30OIlErvbwFgKLiHZEMMYQL5IjET79SDK8JQkAS2VtMM3i2VAxGO3jL5JJQQTjuVbMHEyNjt78EVBciQgo2aq1C6GyCcsQ1hggjv1gq9lorZYY2FQkNyjVoAl8o3QqWNHEEtcA15WLx3fsIsrqxZblxKqDMOAMFc7DWYPlyLgoGh9RRKsl3ISQlqhAmhCwABnQV0rDjgmiDS0aWwRLoo+QJKjNR6hYmL61SvrJNqx0x4DVI6bSik59ySvrCZ39zYrN07gYvS3tio4QPpkdCQko3Ns9iLiYlXx5gf8K0ADLWhOciABU0iCg3VFtLQ5FCUn3wzldecoNIY4qwwzQFa3NUIoEOMsL8TMIclUoHcIgFdlss9asacKcGFzctdqsXAmT0N4A4ADV3Ih+ecErUb6W2I+kDQD/0FgaNVYLMcRDLJkESFeRwj7ikEGwpBnqlQrwQZCqqCKmy7iT6M1xbZx28Vfewd/BvAyBG6gYQV+rlUqXEru6ZUTq1LNpwbZyut+/zVtO9QkaDDOz+JdOzSlfJIvT8Mj9QRrxUSWjKBD4C10Ciqmi2B8/rSIzpAja5ROgdQoc/TH80U+6++B5zRd/MRKZCYvfwIARgIGq8JF21CB3Qj3iyReaZaD/X6okZqoUqIkie5Hfb1LgrSCACZgArUg3p3hD4hAcC0Snt7SeOppcdMGJ3Imit0MNwPOsi9jXOz1hdQnhT5likhWdRXI14sGI49gNYTUBs8NbA4miktvWI5zb5H20tmjUcxOKyIrjNy2S9zTXYbmW072JioQeJJahqK0IV5vRHLQcSZsLHtGAK4zkMmIvJv4Mxf0A0XXZNUHgoMCp4UBkCi5PV1IThoEOmTFj6FllfQOzAFwUxkBb5s2nZALHRsZQbmYdUbqRHHEAeR3mFJIWJTkklKBdEDgBFwgNa/YlEglnUazl7TAXXMFc+Imla7OgN5uJj/DXANjm5WNCPnOY/67ozcPCQ7ABTlLE1VG2sbL13/XVXRvBgEZczXc2oxE5otCLCG5avZ7Q5KmE1eXCNuIZHOua5RbW1XIVIzvdKMWKFIzDYqlo6OKgLgh5M6FJwE5JFyVukAWxl7IEEjFrE7XVKiNMF1TqM2SjDJOrkdTkAKMk6RSqTS0zWEAUAGTuMHC5EBpS6oVmJGnOj1e5mHYKFaqBsQ5SogMgAdQzJpwWUSvbipJUyoGqvnbhtBK9uhz9lW0ZQ5WDyeuA3dAkvfMlDwrIAAcQ5q9GIz5apCzzOXuW0T0T21eeNAAmCRjesY6Dz7jcr/g9mf1ox1JCN5K4ULZGsHzZ34dhANRbL/8fYeK+hthoeiEn/A1QTaZfClWjgNpAJY+QzoCRxmxPGiC1y6Biia0PsIBNVpfriphRSh2npaARZWRWkpnd7eaMGMKTnpf1/ZVGAs72nbe3sNwRnlmp4L840sqsc91bg6rEFjepdcLF0lWoHc3vcN9p9Orn7iSkSBeKfDyzPud8YhgG7OH9WS1TVUPfnplCRlBFyVa5y+ZvEpfexpj4Iu0kfa75gZpabU8V7F+CJq6KaA6atjES+eXAoGzLRvCDkky2LSYDigh75gG35golzuAVbhxdrl9ckRnpZm3w5L7E6YwHvO1ahgvMwFNxQVtB/qAaau37plufAN/DJl80oeb/JYcv0HhUwDjIfM3xg5qJmZ2g5MycBjCYEkyADoDf/CjSBwym6LNGm5a8PQFiMS8mmPGxC12Lzv3NhIaoTaTl1EAsruyNtHYmMnmSQcvJvzPBta1blCA5BfCLAu/qNj+ogDHfqFQMSLnJ0IjvoPDLDtjYfRInPkKNQM7phW0crLGfLPo72T6pjuTr4oCXMHeJ9wsoJw2gVIzL0Ehjs8iOQzrMNmpHJOuLDSDKACX1g7KhNwE8hhGfPKaeBriBEbjEozC8HTXt6AhtpwpG5M0vRb9p64OVdsnyKPorvO5jkwAf767MM245eS8L38RB5AB3pMygC0JpAVBdDE8zOAQN/6rVizV/xmwvqDR5kjKEbNBId7GoMhrI82tTCfryYVz/11oR8aMQ54XsXg3aX7B7FdoO9v0ha9xDLtUoF9R4+Y72VNusIPzBNcB8X3emeGuSOwkbAFOvoMwQFx1wAFhvqaYLFZi3LMaY0pawR6k/igsBkCq71aMAu4RfeFyx9d90rQII+bDvmQYIS54nIRIPXyHT+VKGl+UsiA1oRGwf+oJyvOdVU4NHiQvBDw+ogBtAUOZxrkBGmw9PwKmzUXFLaOIBPgIUrpiHUuPi967AGtf5WfwmkXQaKVJiF6uuaIcJp4NIzQ6Y+LwvKPfTHjtxDdi27jRt+GyZ2gp2+8bhSv+W/euR1OYjYTzKB875OPlbvuElTF3v82f5xGXDBwuYwnOhV/2Cgto8vJDqdyum9KYBMAELSGa/Pe1klwml59lBFR6iRp6CBxc6hFDg71ML4rLQGH7fCBCFE03oALxdCpMp0YrsCekLcO7oBwgAAgcSLGjwIMKEChcybCgwgYCIEg0ECIBAIsaMAhgEWIAgQUUCBRZULGnyZAACAzBy7JiAQUQQJ0AIUIDSpAGMAwigPBBxwAQFNm+eVKCxANGKElY2GJr0adIGGZ1CrWoVZQEEJHjeJKDxwNWwJRVIHSBBLNqwPiWCDZm2KkSNGQ+slGs3YsuSBB5YhSm3bYC4Ekv/WEASwCHixIoXM27s+DHkyJIlB6grEWTFtQIGFMiZEXNJv5t5KkCAgOpJAgcMGAD5wHPGDyQoQEVgYMABrjjlcq5aACOCp7AjOiWAgAEC3Wh/Z2zw9rlJAp4tCECK8qJG6E+NYqSoHS0Bqswxgg6r/KnXuxFtq7droECDAQMMHECdFIFl4CEjmvhgoYQABkw2IIEFGngggglKppJEwUWXAHsaDcBXSZr9ZCFgUIl24WkbONDBc+PJZd9NBRRwHgAmiRiRcx1lZB1a2GX03XOiUTfATTJiRONNG0ZkXYo8pjQBjCl5NoCDPgaYVJAq1sXAeTcJZpcC+bUnkVQalXdS/wK3MWDTlD+VBIIFFqyAEQEKqrkmm226+aZAHRVpEncaRYDaldVV9YBcRWpQAQZp6fiVkBZKVFEEGeEoqFxCooURdXqetOKSjpZkpQAZ8qijdYmSF0CW3YW1YgTo2UQpWwEMl6d8dkUZgI8eyUUABxXQEIKWcOq6K6+9+gpVqA2KlwCqGrWInlwToJTBBbSFFWZG3tE46GYB1IkRSeARaqlV6UUU6ZYVBStAttxi6qCQE2gkkoTGbWvVqpKmFqqhEb1XEbWWNQDhk8UKEO619q7YnwMepNSnrwkrvDDDjSlwYlJ/BclgnvZW5S1GJHrIgViYSpTXdxiv5+JRb01pAP+F3FZlWaQkWsRUudxS6/Jz8UpALV757RSWXGehFO9RKQas5wIQb3jAAnfVdxLOBHhKZgpG6KbkAg1bfTXWCqua6k3nXqqe1089gOmxN/0ZqFULeEzuTU2KdfLXMz6ngAQHhIuS2wscwMDdy0lEHcjcup3UcOimRnNFg1eEKQPq2nXAWlB2rCVKSbe3KKglV6RAvGtjmTK0AgSwAQwnlBDCAZ5C6bRGFGX9OuyxDxgYfnOpeBumXFlu15c6v2oStdI+xayzVU0A4aeWGidBkWH2rXJJOu6sXWcCWGB4WoqHeMBpXcGGfVXjChDcXZgzmlGUocM2gFM9V7R7xSzppVH/DRcUHB6pFU1gJQOy+/8/ABVSpbuUJHQRAQ2qFqAArhDAL5IDlp2usrHlzAl6KorPvSxIlKFpCjoO0KClrPS8m8BvNFuzS8rAM5wKWqRRCyDWScIGtPjpRjAusIAMNrCbzzysUQH8IRBl5zkBcAVT3FOOyCJCJ2KlECr1El5VzpaUBQQFhFbUDs6E9MErlig+DWChiiS0nLoYYCg4q5bJMNLBComRKPUaSvzsErMW7MAGPYhSHIkYxD3ycWElzA7JXtSjjKBLNL2xCqVGeBMKEC81sCkbFyNZm0bxaIuSrIjznpLFtBAAiR5DgIn8NhWiKMl8J3mNfiqSx3VVBAP2/zMYUYaokT7SspZw8pcAfDY0tt1kLUiKHiutoqM1WgUDDuBYSVYVuCt2aV+RNM4RA/kxLV4ybhIx5aTaOIEG0Od3UFFNtFLZl3edxHFqhMoEIEcVJW2mOfCxnQYcIIMcNJFp8UOALfOpTwTx6XEmsRI2E+eWf1IObzcpDQJihpYHJCAIKAjUH4koyeFAEnolJMmG2EdNLhJgATxJ4FOsFBwLmYU1iiRKeOql0a4g4ABIiVdFk6kTbyLrK74EjWZi0AEHzMAy4DMJO3O1z6ESFTInbJBHozOu+WCmMwP4ElHk8lNHFQBySFFbRELwgQvkYESRpJayQAhQTBogArm5yv8EynrWm1gShJphAKqmujnLgGWXE7FWAhLAFfgYQAKvSqKYUHIyJREzRbaJgF+hoyRQdhIlBGCBAy6AAYo1SDhXKipmM4uYFWWwIiaSzl0aIIGMKLQi8QIjjywUn4zcgAQAkhv0BhevZaZESBE1S1oMVdoAtNWChmpV66BSNK6ccSIYSedMBXuXOSWxXjQVEmV1sqV4dsBZodutaS+n2e1ytyDNLUkBZHkXKHpWI3L9Di4lQoAhmEkiPuPibE/iy/NeJaIWM09wUdJblfWzYvQF3iozskwD/sueigqvvbCrMtUAFyNI2UAGHKAB+cqFvMBUD0e6q2HN4owjgI1jlAD/q2DtBHWUMbBACkLwX0uBFaiEpJF6YKQ9k4SOrVa0KzfzaxW7xhElPFboJhsbEgbI5wD1tFS9bhBZtHHJLpZVj4A2LOWh1uuAVQYxVngDvRKjqSIPYEEFJnxJikaHktohMDGlJJcFLCCF+zUodD781DZeZYbx62WFs9wcx+bHwujZW3LChxHCJKF4N3GyJlkDynjhc8qOrmWxDMDlK1nYvqiFDoF35DYOOECHkrSNM8OoEcRdpXrmxa+iJrISBpDgiuwcALTSXKLyXYm2gRkOA468qtLW66TgJS1URmuCFFjABRs5TFIoJevBjVZRj352H4FmgOJ+ZUorXQAD6GMT/4/5Oi3DaXBE1kiBC2TA0NV836wEisVRvy1PFiA1jxh9VBOKZVUR2NeKcJPcbx45ejDrGjmhYqVSPYUFZTKBREaMSXcySd1VhjbEgTjv9SQxKwkNTAPgujlAcyVMI/EqXFizVqg8YCm4CY++noKBMJ/7JJ7CkqUKlxa9MaDEFrA1tywkLQRE4ORiUUAClsI1z3pGcgXI9qJZ9FzoxEvWoh5lSlbTGgrUigMtqMshq6IAH604AKgqQMTD/r/o7mwBR7p0LBXVQozEFCUZXbr2CpAAeAeA056W5ALKQpeJLH053KP7fe5igYBCrzQupdGrz/NXRfX9fNgqtVcpNmwVGP+MwU9tfHbRdxWJib3zWSPpyFMC+Gyyu3aZQmTA20ajcWdgOwdoQKC/U8IvwtAqMwahvwaflC49dfRXLO57n1KvrqclWMQPQBulAjWEnyg/BO+WXLr98oncJjeev37CDNX2t6CqOGqh8xVXLuYmX9P3N4mXwluOkrVdz43AlpKiMa8dz/n5JDBNitA7K5aqSsD8Hg9ADvjHa4VbsyXPxURfsMmHnUVEmmCfA74Jqjjd5OjEcxTgNVWT3ZVZtHyHVDkKQqWfCsmFCmyQjplEsEwPCGFYhfxbSFSZn43LcXTTFcFHBDDAAriSBdDEXNxfnQUTUSxgczygEKrJxIkKj6z/CNpN0bvInfw9B+sVULpBBwLyiAXiHLKlxcOER0sVwBYBHYyEzmf9mu3oRQGYX1XYmXXs2uLcxTLZl0SY4XPEUwZ01Zp1TlgEzAil1ywNIR8aiPgIEnpBTratBKyp2/dJRAR8lL7gTgOA4Ft4AMuFjvy9EIw41xEWFAh9kCGRRKa1hUqxkb004VMUi4NQinNQm7zgS3vUn5BQQAdUADKhinOEDmjMWJyohqQp3JXdRR/24mQgX3tIIHrYmTCWyOthxodJBHOtRVNox061QAmS3PrwBGhdRqFEI/Q4gAVWSzKOzCeu3QVSlafAnl6B4oz84TnRWK2JYjFdgGTFUAdi/8p8aByXNECoicUuVpgv7uNjdGO4aUc+StRNPADmoaIp+Y52jBsNvN84YcTzpVPs8Yj4sKIWYYqyZBqOUIqDYEoS7h43Gc7v5AusBOMpsQo7JgV1mdvCjcgCGk6wUKSPtc7aVA0/1uRiyJIjRlV7hAsBZEnWCd+VlEus0YgHjAAPmNXoiRhR3F5YUEsxaocDdKC17M0fVsSGoEwA9Jc4ocVLHuCLpVdp6eH48AgjSZhwGREqdtypCRYhbomOeAe7sJ1NzmVihEl+YI9xIEffXUkFWUkSZhpxhAb4OWOn/VyfaNDY7FsmciTpOSR4McA9VobmoIU5VRZUwE1mKA1KQf9IVriHZ+WkSbjSO1qFERWhEU7kpMBgUWzhSZjdZjQaXcYmQ4gGWPAfalzUGYINSlTmfWVlUq2fbprjXbXih5gEUwKj5mkQOG3ESaKFA4SJhVlJWAUeBV6F2ygJTKYEAjBPa1qVcRjAF5Ua2UwJ8XFadflY3VSQkmDGS6AjSKBmSEzfjqCFbNanQpygN41V5ZQLLlVQlSkF383LT0ymNB0Qt0AiLFXFoBCe+lFTAjzJX/mkr8mIAZxkKTWo132FsUAFhJklnsEcnaid/eUZtKCLnYFm4tinig7EHxFTRIkH1oVV3r0mQ0XTdYjRoDxfdPAEtg2AWUWJjmzfd+zU3YX/1IthqMpY0l58k/n95nPw5gHdRiPe2GogTWayBdBM50l4wJIlGyZuTpaMnFAUaGANh7TwWE24nral6AOsqIru4gOhm0aUy9Cg6MFEi+k52JnJz0kcpwQV5ygOZlZ0G5ISxZsVqkm4oTJq0IrIqARIAEl4TEXVynkC5QZe5jV1pu2kSJdM29NNYUk0CRK+TLi5qWyi408oB/jVixV6aZ48zwSAUlJo5chYEILuXhRS1gDY6VUIWag6yqH2aYMqakToqLmI6IjqWIcmqK9ai1NcaKCSlpWQmj8mBUANSgOY6lwCYS6powFmzqVyn3wS6FhYRoWqGbJa0E6pZIYi66rA/5qsCgmCCUADNOdTBCt63Yy9rmF79J1teOqOHWZj6geXZsDduWaAsBnWIcVQGmlzLGczVgWXsRCxqpe28iMq9ibRDUB4mgSrvoVHGGTasV2OmFn2/CmI/MyRdiNWole6Aiv0DAehEoUeLp2ZBiy5qiJG/MArcoCh+SPbTB8K6uTLHqLAtmbFgN3F+qJ40esdzqnWQYy45Mm56llyfmqxRtKtRgdsgIXQtEerwsuXbhSS+eDcVKkpXiFRlChpAlJXEFkIkEDBfKgKPsDexWnEYKNYRBcaAZxOrNnS+qJ/jd68/qT3pAoqFg3NQKlAJuuiSlIjRYeT8isBcWDq0Qi+Pv9H2MirYkaF3lqtgaKkAxgs4bDKzFbZzJIQIM6ag/1W4Priq/FGTrKZVchnnspF2CYR4TXQT0zncR4d7H2Hh6TsUwDmvo7r8V1F5r6F+1xHW4JHS3XbH/qc2hbFatggUbgiLEps/HRQ9eCGcIJoyEhAAyyNmprvNL5uLwJWUxyH2dKIWEKdwI1hUqCIpabqd/xJgq5tosgjjUDLvtoYt4iPf36GsDoKgQ0tWojm/kZrxSgHZ2UlqPqpXghJk3ih+sKuwIpP8mJq66jHf6Wtb9goUbQoj0QuBB1XamVqNqpMCZGX7lqRnWEvWsghu2rS3y4XQb3ILnXkFc4XjYhqTiD/SQYPIWC1BuUOHXjVXn3NEGeoh7HS7XzOqsxSZ3XSyARVhdBFgA93CxMnqW+UY1jMKG71afeJ1eV0pCt66FsQwATEantYxwCZF60GZlioZvWmhNQaJ80KWBE/YAIj7FZWI71BBZoGh6lF0CQVLYVd7UlsoxI5ihQhKrfgK1bhBVVFoSHySMVGxIiJJpN9B5dhztqAhKFk51gMppEoscOiyR9jH0ZSinKsCkVkBZG95kmUmKZA6X8lEX1JZeVc7negMCVjbivXKo9YiZDSSCef3k2YJ21QsFXkY7a4IVeIRtVehSQ67j9+U/S98vUFpNyx8PxIyF/sMEtMbkkESwT0/1vU+eiGLDNybmUud66jZHExf0ewQguDYqG5BvD8UtpJdOj4WUqL2k3KFEuRiIQookoKRZRVIAw4ix2qSkRYjUQw01BJIG/xfiR69BmEYJfbnFbxihxAP0AoncTZSHM+C3DJum26xKsVhUmO0S+XjqYFDRPrOvJ3WMkua3JSuO5Ehx2aqhdUxBGMzAzije1T/FEHY5qengQxt3RYBCuq0IdJU3VTM0ANksTQ2ASl3jC3EACEkEhcWcocV4pxZNwmVZXdDORw0ORQQxxgOjMOV8w6fasUqvJdP94MsttAH5NWiwW+AqECD3ayYR0QRFhBIymmpK7+3Ib+LfFQACZY6P8czX7EYcx1xKHKg+KyMBGi0OVZa5oGQEumRrizytLvyT4FAJB1lwjzJCP27qEAavGuCtJ22hxBZBVpSpw29wH1VQwKwGSLP4KFU7dNjYIEZ0PbPP8EvGmPWrbLFf0h5o1r2EIHJJNs9k61bmMVdWRzRleubicF1cGiuXHOTyRheHDLGe8t+CnAy+WVXYwEV3xjUeSHXDf3lEXUvk5A/yJHFwfAWkx2VfxRFN+vNUJPeoUeShgTMpU3akcKzlXrW7C0BW3AK3UFYA9kqATfd9RxP/cxYCcmS9S3x/L1u/L3szllg67KgBP46naLzqi2dlT0ND0Fp4XyYI9HpAiAO8//sISfxAug2A+AEbXg3Kp08Iz9nyglJ7SMKwNirV2XM2mxuKNh597ShVnYOFRQCkVunXw4yEt6OZ2EKXCvdq1Bxbg1i8oowPXGuHJ9i1FvkMccNmK7oulE9UmIT4KTqehQVXzQcFpYibRUGWGpeSGn8pxi+ZQ9kXn02brBdEyyHQdBBYY7yvD5d1VAuKWsCGSHKJ33bQkrCgKYOaK6kgOwAF/XS9ttczGLyEoFRnCZ3i/lSPX9DqZstqNr2NBoqRMxdVPy9TprBLS2tMjsRET58I4LybiiumPFtvWEblJQjYTLoQ7Buqjz+cAeCrJHbwrxrZZC+3CRX4P0+pQNCtrx/9Vo82kbC7MqfTClF7N60ys1gpxVsJ5Y9+rR4mNGDN5JAbNvyPl3rHGEBwDjEkVlnpd8PmVs2d6FIfPP0dWkSLbSovuGyXJQk+SBf3F5Dae1aqiAQTyi+ggqhybLxVm/a7NGtFpEr+VlLiwXgfKhjXxXJIDdeFOKEDLOuTXB1++/QjZvnjw6I3OTYPyGEQD5uo/iFDUv1S9siHdKcGZVONe4wGGDPkCoSH1YZGDNzLvYZgQKXMUbHXiHQ09KumooSnFHljtKtHs3P0eTRFd2F70nU2Z8cwXScxe12Roqgvj5hWtaoJI1OhX1DvlYlKHwCsEOwGEJhTqmjD2N0zMpwf97QjK2F8u0udf5W8zQzzcyRgD+rAq8MFEShTbg3mOWP04VzthmdLCmlWeMdqRT/xH+j2Q64sNFTJxAD7Tx65lv8bV8WDwAApSvD8cL0VvFTfN42gyx4cjbWzAuJh/wBB7Y5gn7U0Apjthl6mdWWlpLAVAIg+mtiFTtsl8jT+e+dpRQCZCAb3NRCQ3A8gKk5aNFrZQbyO5ZEsc9WpSYPPsGQAwQMJAgwQcBECZUmPBAQQEDFkaM2NChgAQBBDosAIBjR48fQYYUOZJkSZMnUaZUuZJlS5crJVQsyECBAYIICGSUSWAhgYoMEPqseGDAgAM8JSaNKPOiUqdPoUaVOnX/YsUaFzJQ1aq0gE0BDQg4QFgAQQGtBBIcaBpRQUWkWxVuyOCgx8ABCLQC8FrQbIAGFdcmBZCUgcyBgbfmNEwQsdK/dhdQLezwLkKZCF5m1ryZc2fPn0FzXLBYwAKdAx8bxqswgUyGlAsOeOt08NKKq+Hm1h21dtTUBA0EwFBBw27BT986UKDTwOykBBDsfeh8bMYBfXV7cHBhA0WCB7ReHlvxOtwJhiMYl64aYQIGB7BHXJAgflShDicwMPCb4ITQ/wEMUMABA+SPoAJaI22ohRJ06CCEECDIQPByW6804zDMEK6YHKIwAA4c2EBDqQgoIDIHTvvqqeVkCi4pBRQw/46DCjqgIID7CqLOKaYSKiDFC7V6IALKJHjQqQcQaAC+hAhQYDQFBTBLOg8zLABKygIgUMstueySSwQEiqABBpqK8MqbFCKAw4JcTDMA7wgaoDetrCyogRHxzPO5imJMiAKsekQgASPxTM0AEnZyykKCdDROLgc8UKhOjaiCc6DZzLTzrCEJiqBPqBQjSAICDFwsuEwJikxDVKEcIEYvYY1V1llPanC6hGy1i7S3Fo0yKUsFSE+3rh7CTSmO9EwWrpoGMkDVhTwgTrr6MLTUApk+jQhHt/DULgMRF2qLT62km2AhYCEqkVqJgG20KthIS8A6vH6k0ikCCFVosG0VxP+N1n8BDlhLcdlUKEX3ZCoPoUWdVerJgoxVVuKJcyPAXYRosMCEOPF8oKJrsVSKX44xfCCGD06AYd2FHWqTqgIkwCkiVgUwwLsBnk1KvKQSaKCBi86E+M3YZLJXW6JQazRXBdcS2OmnoX6pVOyYHWi1Ag6AT900d3YKTpcpDlvsDAUIwYIPDhyRXwvWiziiXhvbCgMVLACBoGzT5DTYi+Hid7I4FXisYYW6Xki6XskrNoCH43VqaWFnDlqAT6Ou3PLLP/qx2U+dnGrSmaJaIOuVxy7ddFAJAuEEu+PW7eMFwHyodYUYb5Z0qTRwYIeNQeeKPmU/RxreuxUyMGdcE1f/MN3XoCxAgQMaGFUhgimN6PNml1ZRX8y57x7gUhmF63qrTy/f/DxP+8ACHQKAOQG+oWJVhYTyder5CAy4PSoKOqiAg6FDdr72TYAnV6IS9QQAFIkgjiAMSFHEgJUwhzwrggKQgEQQ6CvR6c1mZqFIBDbiPRGOUEu169BWRCeT+gkQKmmR2cTmlCfRLUkq16uBA9CWtt2siQFiOR8GLnABDCSEZhBhoUL0thjIIUQBDjTA7Bj4xACwSFeVGY/k7JKQvzkkbhZyDqpSFEISjpGMnalgs7RCs4EsIIZHFNlpZudGr2mqhjapTANUZ7eHZEgBPPFhntq4kNxlwEZcc4jb/4yDFrW85QEL4Nt5iNYyXBlgAAw4XkSyxxhJWUqBfsHiQPqkRgFQZ2SBGVlBIlBGVa6SJQFQEFAWUAD48UuKUCHL+7IUkUAmy0KUzJ/E+jii8cVRKR4biPo2pj+JzIlYA0CBLo9jHP45oDg8o+OIqPiQyHinOY7LSAPGZy4A6lApiIvYj97yowJscVw3UqdESqkQURYkS6y05z1DckrG7OVOC5mTGpe5kN+I03z6PIye5LW5DAELbCQqiAnORsyn2MoCRuvbxYAoRFAhAAGXnMqcepPEYkkSOUixFYVo2cJFxSee7XEIUOZpxKA8xopJ8WIux7kYfO6Up65cDAJEav9RIrrmKTSDn7IyGEANXW8AK9QKO4OVmxSBoAKRkmpBruUci02FVHZpzIxqdMSkykSZaUoALl3KLX1J5HpgG1l8JjAkK47VVxEhVCBrF7HxdYinfb2npZ74PhPWbCBGM2E/nfIjRI4NSh5FyAOOqhALSbSFCxLfCTvggEJSZVvXImjVKjmop4QRIY+qphsHy6OARiV79cNaAxAwgQMgQAEF4JRF+SPTObbMsVK53y/fRho2+pW4ZVzTGpFHmoayE2/akskFz3dGUMJzMgOgLELqlSELgVB8dsTNBhzQgbM45Fp9GZmruFIRA2hHo3ja5VTOVNYjVQSxQxWPU2+0F5z/RWWvFHsA+L5SXAGPcLBIoSs5J2kUdxEAqgguH4CXKFkuSsVCiw2SBN45omhZVSq/sYBMjxsbpYS4BCcIqxwZdMgQ61Y3tpJNT0iDtwRQ8ihjEdRU1NhJPYVKpwP2MeYa7CEG1gy2jSLLCxOiOTTqBi1ordhZP7df6yWqsg6JLH/VOxZZZigDF9gscnRigWchzrEJMkEK6sZiZRGgIQr2nE0MMIECNIA560yabhQgAbXUb54CoBJ/mhsVSKpVTyIlz48RXTmGaTFolyxXcou2G1RdFzkImG2j1OihGa4rUwpblUxM850MgVe8NRTUH3NaPW2BwAIp4J2F1XYaNUdl/4vX4fGt9NTnjMBHvWXZiuZ6u5u9cjHRxXaaGvsJ4BadS60V1N9721eRYGtFARylTvaM+DV4FkC+VMH2ITWkgaoiB3pHQXVqRxkRCszIBwURap6ARekruptm0M3TgSOZMJ40E9Z7vbK3oaQAYw/8XxipiFnwTWXsAgZChhG4biakITi5LWHRBvfYjGkn8mBTBl5OyvVIkGLVlvYCkOqRkylmofpGBV29FPaW3/VJNl1PxxHhz7uNk3DMEJznsXrAlBAy6BYp3KcXH1lzYM4zGuNN5RkSOnLluSCGmu5zsDVMjZnslRCg4H8RSZEF2KLaQYKrRP/W7k+0gi6ornwqof8urEQmYAAD6EfmD2lnUlLTSTbHCdYd7lfPAQ8r6NC2R4s5ysYR4nZVX09MElohcxUCrL5T2LLFiw1P0JUXDCWgoxbXt25S5IMKDDEhJhRzcB3Sgv51HSGpaQB+EXpwOg1lfN1WyAMOll5TYZGYBHCkhF+Kob+hM/DF5xJOEyLSBvw+AKzqy1jd6kI7XzMhGazvtl6MIUOzPQAztplJK38+JQtg8h/feJcLaXq3fW4FKDC55e3E5rnbHi5bxHmPCMjoOPHkuPdXytJmbeEWYwFEp8FkwoEGgJJkx3EMY9qiArLcCWKMbwIJpMnegsfYbs4igCYSYlFwbmQsRs4ariL/FmIBvMIAAg0uJG8qpEM2aisFw4YAeqWhpAKgAgC8uu7rasZ6DKAELIAGwMWQSKP8hO0AJMABfUTU2qMBDAABjGTwYBAqIigp0I38gE/jroQJKwlvKogIp8I9DmC4KHAMQwNVtDB/ECQKF6LinGKw9At2iKonYC8xKOPfwMQoqqZmzE5tLKTmvhDxEELcMCBXQCYwpum05ONK9jBZ+EXensPSREvkCkYiBuvSFsLQDsDQmifqKg7a3iV/vA8xyHAUP+PACMo+EqYojqKNDMouxscP4YIAV+QxGGARW88huE/zLkvVfu3i/KTLdCDMliyjSE9krsQRlaWIjINx0Gsh/0grKVIkACNNthDAALOs+n6KKhDHRQaDFL1xM6xxj5APQgTCugyGNCJM/yQn+4bFOk7xXiqG6G5EDTNkMODE/+xHJ4QKvGCAIEBmAHLnxKAiHA/KjabQPqCRpNLEK8xRW/aNF+1rwphHETnxGn/FdoZNkxDiGznSJcbv7W7kQdhpLTJJIyPib5RtIOwNz6TtKSjCzahisLiNgBjMLrxwN2CH8DAklvgGBupGACwgBNQHEaXCO+jOyuRoaWhwIZLQz5gyURDkWZoEnmgqAZ7HZrKlNiKIxarQIU5y2WzqpRSkTTqyLFViyKLEK8AJELvPOuhLZH7vI53SOIAFFjuQ4f8o0SsO4EFa8YGeI+lQbCoGIATQDAIsYAXskjZu5PeyyQpR7Bl1DzgkhSl0IheTDz/uRSbAIiJCzDC4r8EQaXzkUqbMsjRNoiuTx8rmhCf6kLVeCUMMZCkXxzCopXbaRLrYciK7KTCL0gdTAAJKoK4SSQLmjzdl0C7eUSIMDTv4pShOyPwcIh0n8+5KMGvOSlBcDCm2KiFKhTr6zDMTwjTFcyTQEkp0ZGnkK6Hszhe3QivRzpoO0OZkDyG4yTyZbRJ50ynkQgj6ESh9sBjzE0+2EyoKh1UOUiLUqHWqTR5XRM+aoilRMCEKJ61i4+lUbTwx1CMCoAU/yTLt7/YoogH/As1iaocd25OJWhI6LVJCw69JalJBbGOCAlQi2EtEkMQAVCAB/sTjNolMxMYTTWfk2gPOyEKF4HM+maRXLDN0KONBnmvKTkjJXCZDqRRdUOknmONisCYMDcchPgU63iNGINQ9BgCchM069EdzjEaxEFRB7CWp6O901s1/vgwh/ggDHID14CQCbHFGpZAE2zA3b09zIqxX+LRSbMeTLs5AqMVABOXq/IlKMZQpqvEAFMBCY2QCfA0ulkaBbq0pLOZ6bpISHXBxfqS5jAqeorGBJALU/HQDSo7DIgLVPsQBMMCE8HFsgBQ240SZ1iOOUmt6nov+1kNNUZT6kmwowGct/wZPDCW1LIuuIBADTpCRXcgDOn7kWX5kDqOic+InI7hLIgZKKUDLLLitUQBrRr0lCIlIIJyFVgPgT3AgBJTKT2UoAZJTKQCrtwBwOmV0I4E0Iy9OPWuqSw/JACXgOtnkWUvT0C7JAiUuNXkETs/UFe0DX6KjCbmNdgRllq6Mm/o0WfjHf/DOIUJOIl7gBIKTZOxVjm5tcpSiIuwNAEAwjc6EJ1hlsZamRLBo5xiWI68HsXKyVJky2DJILi2GrJiMOp1CE0e1bwCTKnZVbmK1Jo3CSMZnfthKAHyQd3K1ZdOEKGASQ2gmMRWP7dgpDKOWAZWnL4zUWnWIICnjZ8uymf/sDU6AYlcJlnRQBS3xolh3A1jwcZ7iFGyfYuwiUDJHEKsco2zOJt12DBK5NdZiY3IHUlCZ0irZKu90IjFhbAhLT2mf43eu8EroFlqfkjJIJ6HQSWQ4itugBDxqp3DvUiFv5ADkLjC20XAzZGRZL9UsgkL90XHk7gWIw7ceQ0SdIspClipo5mnhFj9fZl5ediWXdzF0K6mINnTPpAFOtyPlE1va1PCkAkpWA0ylJ3DfM3EHopMQJwB5VyqI0evek1+eSSpAhF1V9fJiFhfHpulyQz2hKl+R4zbi8GgEgibQQlB0Qspql2VfhlM+kgC+lyM38oGfcw1JY0krMmEslyr/MoiC5nOeZBPH3JV2lSUg6xSDQTIAhM4A4NUp/iQrRkxmIbbwCG1iDMRzdytO3E0F1YtBpyiJTFRT4yabmjE8uQqyPJOCK/gbIwcshZU03i2GuiIBySIjdlNPmnIATjG7WOYy9APrngoizYcC5oIoMSlFgwIBJMAsYvgphkONwzjfHLP7hDj2zLhbyeqsbNFAfkTN1DM6YctIAglG0iISc+4EcZcBxOiJSbH7fOYiXrZ9Y6gVQ3ZAJSaW6NchVrJnFPAh2Gl7j1XEBGh+faMgrHch4hgq8vcrFcS8KkI6lXh5occJL1cJtyKCoDfyJMjdCNCJcBPXYu718EQBzuo0/w4AkiNZOu6kq/7VYMkDhaViaoE4msOlj1bUNXPYnyQGrFb4KbBGJ5WilaFihlOXNDrJUlAYTkz040ZHNyKoWqeYMlJDLsk3iiVza3YDwJyVmYtvkHVI6FqHx1xlAegRbAkgie7P317mgMXGtCjGnKMiWk5LoKW4+yhp+cIlsjLoa29XFa/MQiG37ZDCPd2CZ+tuIFr1JwAnN6RrmQHa+CpIxzZWnGMrfr9wTJTJoakiRXhYap+iRsWGoqUis7rjSlZZnxmAW23QPmTtg9smmhYiU7a4v4AXi5xLeXzLRFjU8Ga6+PQpqHW6dDJOcR8aOJoXf2kknJXFqKWCAnCoVf/4hlVKeHHpqSf8uKpvYyoegCKAC5rW2JQFUAlTcibWl3CghJh+Tq1b8Z/DeuBKkoCHxdrKeityhZSZhPNuR/4sSTceRVbHBq6lIgHyaDGUd7SYNhGDjzV+mIkCea2hIsOmqHMnkjT2y511ZJjxAjrWhZ1kY/wYILIDLyNlG4Op2XBF5/vajnSZVFox6caSYl3Ph7SxTACQqZv3BC+dotZmI4MuIiPfWU/EozfSsJ4BA5njw/vIGJZr5kfiji+EMDaWlbgDL1q9Mk1u+inmZLm1W1uc57LhorHt4qhuKigaOFt894isOyoywmxyaCBouX061jKQtCcgES3krr0DoDP/g+MjORhDfoSymjKBjJAe2ZuUvDpXyhRQSxkXDcO+i2+v6qvTuu2MiAlkqVrAFYKdJpxJZIKg1kNYYPX9arAc6TkpGtyWCuK0hfP2piXVaJl59ZU8UJNiWAV+KdH2vNubmuXo+uKs2eQAZXzGCW18jqoKYS3Ledyh2Hi7MXOKZKIIHOBb0o49jWPJN0otwOQDVAAILtJBFHVvdMZ2JbGBUPODeeY9HOtmEjo3TCiog0mfZGPvfmKyyjzwLMRIKozlSON2aBuFbvm4j1l0FUWtGEcoLcAH+gaid0PP0wjCKQ4va6u3fNquUiRGPvKukSOJFqtENHsrnrotayZfr0Sd//ow03sOvweCoCLtTw3jrif0D/cvQMX3KWonMAaC1X5S0XHYSzUE1qfCO1TnBTQYz/8vj29EcPpCYB890Avi0YEdT57aUhrjsMlK5ZSd55g9ePG4r6GCpAdgqZ3xwrnqLbt1bZOFVUI8KBr5eHrgbOj1jrWiwMIdLnaVXz5As1gYSFAnOqECAqcHdy11zph7N2gT2oPl3VfEsppzgTqUZhJg33nuwDUnslowslg8gF1dW/aCrPn7W1sYLg6RdZPc4KQ3z/Nknchkr3QgvOYNNRBVvkfEmgtd3ZuvXtWXjvZqRL+zZXBvYWme4CzFQ569KCW82xSAg2wxe6BiPYAeQ/9CFpWxqYFJXdzhPVgSRdwihd+Y6NFnrEyDfXrcOLnhD+ATco/hgmbMVd2H+TvW5C7GnuCYHXJGnNod7EXqMB4NPez+G5B0A0QEUk801fBZWZgkdgcTAv1oxx1tabZYXr/x9ixEMFwgtX/RvULeM0XuOnaUh518dvITjaTVYlGoAnPde/8W0VKmretnVKLlyOoDAO9jLk6ydCFILSjeHPXIByrmxAAp7Wbqo5LjKMMQBIVb01Sr3dP5YjIcWSaE39hImjQoO53jfbbV2f2PqisigMMx6G0BIoDAgQQLGjyIMKFBDw4uYFAIMaLEiQodUIx4QIDGjQMCFEhQIKGGCh7/EGzc2CAAgIMSTmpUcJGBy5MGCiyImGAmgYIFXA54oDDnyY4PDHCEeVGgSZcJBj5IIGECxZ4upQ6k6pIAgK1cu3r9Cjas2LFky5o9izat2rVs26Z9MDPuyQMICSzYKXBC3KYQB8iNOwBvUogNXNIdjHgihwodKCR+DDmhxchXZx6WmAFFCJ8J/bpEQJHA35MRkCI0+tlgAc8GTCdcKsDATplDET/wrNFAZNo0CS6Iq9Kt8OHEixs/jjw5gIyjmR5kLqABUOi1IcJurhE05YIPeF/eDnlDBgcewJuHPDkygQcEUGsMfDGGhRInUyKM+x3ib+wCOna2XJdgEt0lEFwz/4V00UoEIGCAAdpBVthMfAmEm0YNKIdhhhpuyOGGFTb3nEu6fbjRTQqJxp+F5xFkl4DnEVAAghExdMEGK944WHqJIUDiABK4GJFoJZwAgkYyGsTbRkdChCJ/SxLk3kYTQiZgkydNqAACEjwZmQINDDBAA0BedyVIASiAm24drslmm262SQBuJG5kVUFxoSmXiQlhxR8DOFKmAAMDGDClQNANoKdBFCzGgWN/brcSYjoOJtRMPyG2mgAfWACEQgqImFSSoz2oGmeRMTcAAwnsRCJS19m3HXVGcjcnRxMcYEADIb3Ja6++/qpWARIgsECUHB30qWVz+lcQAQkckMADev+lKACXFDFXk3nJbuTnQGQyS9AGF5D3aLkUTZpUrQIUetECBbTgAAeeCjoAqRTxZh+J1gqUaWwEEMAcA0BCZKxGCVSqYgD7nYQAgw2wS1GEMxkUZ4qBAYtxxhrzKuuBBxmY4pMLyMlnc99NkECiBLu0b1ISlzgQiVNq4EAGNp4XqblJoRvaaPnVBdFID1EGo4tFD/SyABFI9G8Atw01sEcTuLbwTAok4NllHbsE60Uln/QkmaNduHHZZp9NnNjOIbS1SxEc4FrMbrftZ5YImNZvbBJ9rdt2cT34dwAUdFCBvDofLhHPFI0G8UAERDhA4wJRkMEFjiL2OEoJEFvq2hP/if0zARGgNBDCXAvkYttgD6a2RnU6Tq0AwaFNe+22f4Xd60hyZGlCVW+UpV+DDrovgB4dcEDYwPk904Oju3TEuOVJxB7i5io+UdvgHvShvQZhEG9iBSc8kKgCdDtR0noX9OFh0wKGkOn4sf7XwCOnmMDt+u9vNsh/tRwAGCmgY9sjyNcEoDKD5CwA8pNdkvqmsAKIrYCJ6Zhg3icAF1jAZiqJSHfeIznrRQZ76ZuJbIISl6gRhGZDo8i24iIBKJkwJjM04PICUKulncZkg7HSXA5yK+TxZwD8K6IRfYWdqTRPITf83F4k1J6/xHA7FZNSQRIQgk0NIW4rmwsXRTjC/8fg5WohUYAKkbYXiVDOckr8C7haYhivSeiKKRTI/ZaIkAccwC8M6BgDAHgQ00XOIEWJnUYWcMREKnJDrZvVvUgDlNd4biJfiwCJDKAuCILnWXArCAYucAEWnPEgB4wOGM1DwtdkLSn+u9JBFsQABAgGfIYLEogc96FRGoQ6JyTIC99zxQrpkHrP84kuF5ilA+iOIKobDSIXCc1oFoeAB4jaAiO4kwk0gFASmYBRsjUYYzVwTptLII5o1pgd/eVnp5TUYGTFzoQ0UABcLFmiOOCAFipEfRvR5JlQ05oBNkCW2YNaQYzlvQAwyEGsK5g/t6MuN0pzohRli8L+VQDBwP/InALBk0bi+Zhrhqg/tRqfLr0FJgZ8MSGUc4AGIjO+jbRzICKdSCoJCRgDLDOQcUEfQT60PQpcIAOXy2OtuPQAoCBsACu14ekKQpt64eh3GjnpRQxppIpqdatj4VGYBMMb2RQAkwwwUfcO95ExRlR+FNzhUBJaEBrpMzE+1MlMJWI3ld20IFRlWER+2Z+D9JWL4HtpQgBrMIW0cn17ksvHrErISDbWaitSX0SfydXMZtZYN5HVhz7Su3LljS7mO4mfzro3uYB0MencTimBiZiarog639kri5qjS1Fx6YAcxedcB4LBk5zxgGeMqbYA2tS6ym5FvxTTX8im2ehW9Gv/HcFOvZp4o7o2Uqpf4+gu61cQ8biURQiAViQJQJtq4mRUd4XI1+pkWxn+TyI8AuF9TIUQoRLVIH0dJkKCW9WEKNeUkImUD+HTrAIMMDU3CtQAIgCaAS9NuhSeqEn5M8FyTRC8AVAfSAsCxzQKhEY3G0jVmFrF92RUIaWUansVYj5YxRd1zQFkAGSVUNPt1JMVMCxBirmRu52ohgmRS1OT0rEpDiTEEfhSf6bkLsgmpWD1qrCVoTk+j45Gy4nFK67Kei38xAWCBeuap/63qMIVVW40oZtkm3WnF0dEfRCcsUJH01Y445cnX9IVRfBZ4gACuZ8qJBMAB62RpEhwpw4l/8g8eym6jXxYwN5VmFwmfOVM829r6G2ObqKYHYoBqWQhJAiAZfOhXt54JkqOiNpCID3fAeYvDx0IjuXsauMFwM6NrFZqKWse/fLkVntWzTY7CRH51bouxWRqQdTnU3Xli8E0PZF7QFPTAZIIAZru9u0WS8+I1itl0JHOVVgDk0iRiCKfdRoCjr0kwFo1bxoBgQVkEGhSxgXRJ2lqfQeJa0IK5mkcEYydqXsAgg6ojivCQI/Z5zHwcJYixtre146EW+peBLUIMR8RvQ1ytHUsphZ6Lr98EknE2jiAkLPWWPsDmmLl5si+PEkWbRCEky42cqN50kcqjWtQD+phANOIwP8IYucATDxdTw1pQgBN4zmaRwJ+MQDQbzsTlV3HXhHNUlzebBAznrzYHkFASPgZ8rSXbZ5YfUmHpY5YuAZosqQLoJSZYwILWAAEky4ImaRTWrcPRMsGAHvAAzinZe8aMdhaeUG0HIGTFoABf0yKsHEY8faqnGIHAxLbB1AAAsrTM2JSm2RTXCutqH31v2J720NCosuQyL8IudqqIILoqx/EACWwwAdMkJukmE43C2AQqH7qEp8e/s5yaVzSMdcwAUlw5S9LiQJWLBGHa4BMtD9cAhpQeTYzTHilVopcagVX00VA4wMh+Ulmx/r4wyl2EaWn0vHI/KwohDo7dtqYpTz/ODZAHz90EWIzIWElfQy3fAEQeARmEM+XFCEmAK1GEQCGG8qnEB3gADFAaIGUcFI2EVGCPmSCUBOxAMFDUnIhdzLDcYg1EwwgfzHoJr0mIqPRN/IjGAfUVDhYZPCTfaCEAYBFcwZRMD4lQAYBYAIAgoijOmY2EBDYRqvjMjw0EfqFfc1SIbpHEWIjI1jTHxK4EYYHEewxP0wEGLjxHX0FKjLIhmsyTi/Ib/7iLRyxJKHlVn7FNs0XNA7QWh7hGaDHX5VWhHhlhwvoguuCEFA4EeaDgaR0e2/XHGKYEB7wcEFkIhV3HoPIX3Ghhb6xb30hRVdYINiBWW1oihkShyzT/2mxkVEK1iwyMQA/YzoN4F2xlxCFpGsF0VIvBTCDoh0LoDIAMAF/aC3ys3KiIncvAoIA0ECKp4gScUnu9UOuJ3gX0QEWAHwaIQGl5XgRoYk8EWekxAAGoF5YNzH750avVH8KcIrtiCFqEyVd82YLlGKMdRVJA1fqU2q26ElAiDoVsmxUFTUiSElOBnM60y+tkRTOAhUNIjkKgAKDUmoEMIQGoTYUqGeu5H7LJVgNw0USEAK+V2OQkQAG8DYLMhPLRHC9cRBkchNPYXaNJk+4ZRD193HuiJPGQVUp4TAKhxEp+V0u8UW/k2cdJD+uwVpF1TFcYj4YWTqUt3KGpjMCif8jn2IBklYXqOFiEzEnZyQ2OsQgEGYs8ZQkXFdvRMJhiJEkiAJktdZAX1RXNUEaUvdK2AF2bOUSpZiTe+kWSYMUBfA8RweKcWQn+McTqCGYEEEdfCFePoZ8hOloceGEdDUT3Xcj5tN3iGEUVwk8BzFo5TcQkqmY2OU03hE/WfeYGrEp2XgSTmmCL/gAC9U4Hvdfs0YTuJGM1IiBagNLCPAAfAmcw5EAlqRSY7cRllkQiPYzgSNgC9l5ASBX/wGZAsFPApCZv6Z/sgVRhWgeGsGZoQaOZJcQ49MyylYXCiCJ9zedohKSH1AfkKE2BVFTI1eb/GEXoshTtOZ5oRWc/Un/HAcFlAohNglkPp14FZQnOUlpHahZGXKheIommd04GHOCI97pSn5HmgTxFAkAEwf0oJgnhYOBaEYIkAMAAmiJYBWUoZs4SebIO3bFNKMRNR/SFP5po8JBEGWoEFHilPXoJxT5SP0UXuMxPRIRJfnRTFrBPDD0KLTJL8hTkRAhE9+phEjInab2Q6V1RpnTHxLKTHSJOnsEYQGUER+AAi0AU7kooHMhLRxqEDp2pR6Bn/l3jshybQJxo3m6FqkZZHuDPN7Vi4SiAFrZfw2KhwzBQcLXR0/STAaKQkb2J4ClHVGSjEwzAN/ZOByXkVIyPkyzhFhYHROxAXz4GIgVpQG0/zl7ZFr8hSs/woBVwRO4qRqYCRHXJ1l6iqtnQRBi4yIfsXKhlzwdRCEsI6UzQQSE0yg38loCkJ6DsWCGuSLX0TdgaH+Q8QAk0EdNpWUgJTYmGad/sorleBWYxE0HQYlFKkfAFqTUpkqsuKld1izucZ00lav1ShYEkSRHkmKR90rlUx8LoFRE1nEnkXcWgK6RIVKBN6+LA60rsiDBOqzsmhi2FWXo6BPQRjFfti/aeRGwhI8J0QFsRGlV8nUQgUznB58Cy0kwcX2jZHuCYa8xGxaPlwDLZCz+hCoIME9CVKenmUG+FwKVuh3alCvCI7QHwbGQ2G9gxI/oMRiyJT+6wv+gg1chR5sYXKZ/LHIA2xSSOGBOvOFTSbOwDPQXE1F00YEUood4FzqaViSzb+sVARQjh6WASSNtAnsQFIADJzCA8DF5BkB5EIsjn2q2FTK222E+XvqA5/EhnYWH8iVcf+J+R/I1LnACLPBsyYevWJkUSWiPOyqUZHt8HSN2MymUcIu6y8ER5sRbHUV/YNqPF1ASDUJQW3O4QYcrfnZKv/ShNvUitAFOqPqIWAq74DFgSsKnJ4EDIqtcVYKeHXswLmhj8uMnK+lI7LV7lpG6bytIhqdckUSNKYkbrkkz+8WicaG4C9hO6AUmVhsRzwg08qkatQKaPYRnTiUXo9oBHsH/iSkraT6xcmo7qO9RJ83hlLG3vTIrMyO1EUq2rMsTI3jxsAmwAYTjmAZBrZz7KEmrvv2qM/Bbe7iCbO+atTeiLpSbjgEwEiyggIc1MBenJcMrEdTqX0AKuY5FECsRY7+ZwPXKpC1ptBCXIg9FFStgASpwsCzxF414VwswjsUpZ9BxuxcBwp2DvBiqgo9SMg3wgQbxF6SSASqwGdyyoLnxL5szAau4qoghqfrRHFzkgnrZwzZahEghUgNziAGao733AZsxmXz1F/V7OMGVvuYBT4+xAClTEY9RkicpxMdSEFsTfo/ixMTzqMdHEC2gAgP4x6XTHNGYGAjTyb5ELy1s/2LjM8e4WkoL+8BCGi47MB8u0awCUVq9K0JA1V7N20PuoWoFAYFrKRh9pTLmOVMS5JMe0QBNhjz7shiYO5ix45pm2zCOqp51V5dZl8p6+heFisU9JQEOSRA0sgSm/F/bhElbiWvCfFetO2WY7MuIQVXoo84a2m7lYhfZe8WIUTlrVpj0R7hEU0yFR3dXks03+lo32AAPI0lpKRAKWldF2cEIMc/thFgg2LwipSMcbH49i8sUo5WFzDR3amswihijajgFsE2+GbFDfKoB1NJ7o8gKo7O9yokFbaMHrbSfCzvrJBCNGcnEGtEUMwHW0tF3ZSyjLNHoexDPF5+G6kiv9P/PwvrM8CpijzESL2BQNChps7w7H4UjSTIlymXTNgpuHyU/EOOFDkpi8VN1IB1AEsDFMDHBN3IdPgfUdwVqcriQzPnOzqqmTkyOL30jFhiaDTsYLZACFjDG1mkoL8rXJUSAU/GnCMGrHSUzY22jWxMYdBaUclECNpCsU/kZBgUeXwPHIizYg0sv7vvTL7i4iHEdKaq+TV3N+fwYGZF3fes4NkGnS+tCK3qHjG0QiKYdiJY/mG2jJdkfFgITnO2iBJvYIJDaJRkmnVh/ECYjk6fQ7TydHVyPtszAJ6FXjxF6qhLUAsFWTq3TeHoR0NF7IJBnMten6dqiCy3eNQkgfaX/eshNx6sjP9im3gJgbylgAoD4Tnd9ZkN8thrBr+zm2ufdMYLcz63Z1+ftdCsNrx5hFD5S2jaXAiTAzwaUcIKthr1sR1tLUMppEPrIvzrB35ltKlFCxBuRRXzrLtQcdaGa4CniYTQkseo7ojjRR4lCIhRYxfK0qM8SLRKxFdqChkziilcx0+vaHwxRS5CRTDISU/60VFgr3J5IGjl+Ei9uo3FhFSXJUNxjxHu33hfRQCdVf5/cLsZk4QXzYfX4IB0z3uC6LBWp0e0yp1BFaHntawqRM9/nIHjhWyTJkoTu2wFkQhEuWKghrrJy3GQOnAEAQ1srrgahASTQx+8R1S1e/8IsVoPUAtHzO3NI++eHw4UW69v1WE0TkMYCceRd7YMvJlKyQo4zwdUKoV8hbksuoWQN1IV3ApAJolDkh+n+WX9LMjjh8xRRcVidiLcK4cQRUHnKbSmRLuF2Z+E3PGl8HZvgB1pWdOsT3r/qiz98dQCxZFWFRT+csRPgJhhv3ovoDIyqMeV42ux5+sDM8kkOQUnEaLKk3h+j/qpgU52yHe6du6gR8dgmdiDpnqM9Zy5UpzQrd7zELllLBVlQF2bn9yyau9Msqepd2n5S+O96Sm8mNAMkYL4xmpelQ1Z2jDrlteTbUV/gFFNI/fDboT5f+4IWv/JlWy5J03/AGhK2Cf+bdQX0BBHsTjQqUmyRNR92lGVB8Nfy/VnWApBFsQyeJutHjQ021K1SC/Al5boiaphoQZ8QrU63a0yEJmT0rpvFCmMm5wFYbZUkDACGcumgDfR4qCEmB6F90CjnZ2J4CwDXJjnCrT0XynXpXe+fB2RvFrACxrM51sLZfY+959FrAyP3cH8ie8T2nS1pdub4gjsvUicxiGIeb/6mKVluQPFyYtazBxY1Il979pmHZDyeJlRa3Gb5Nvo7fLzYB5ImQFL24UvS4NFI4I1rpT+4OjFj1MHE4flDniV8Ca3S+Pt+da+5D1C6J9+aAtsxcnd510yTVmxFwW9aeXL8N6oRJpD/2C5gXe6M9/cN/QgOEAEEDiRY0CBBBQIULlxY4OBDiBElTqRY0WLFBQYUGlgQwIHFAgwVJph4QKSAAQFOCiBJkcAAhgMIFITJkMHBlQYirixgkmHHgRpFNpCIoYKGhzVXKiR6kMFJnQ8TipyQE8BVrFm1buXa1etXsGHFjiVb1uxZtGnVrvXKw4IFE0vlMjTwoGCBmgMmCCQwd6nDAHYvRpQgckADoIMVL2bceDGBmQI/VvRJt+TJlCsRVFS68EDBBXQFE+x78ibEygpTBphgYMABBQUbnPw8kYODDQaFxlxoILLB2SKjPsSr2uFKCWyVL2fe3Plz6NHLBrg9I4Rf/94rT4NOLDBBdrkpMzL97bhnAwSjHa9nnOBAAvXs2X9MYCDCgfIFn4qMMDGkSAkC6EwhwCT6biWDHkgAgQLvWqkliIJDKTaJ/vupIgouyICgBx4sAIEDYDJgr4IOZKi2iBZIDIGcApDuRRhjlHFGGr+iIAMHPLgqtYUYqE8kC08qjwAEGDRIgQPeC8BElDorYKqFZJJvSioLyq+gB4pTrTsqAYiIgP0MoNAjCVG60jvaKNpPoQjsqsoyilhE8KIgGTqzIAUSaFCi1Da7yIOj+HowAB4hHCiCmMqrbwAGuCRITpEOqHFSSiu19NKsPHAgAwq0GjSABQ5ooKU1RRqTyf/hpJJASQUPQGAmHgXw0yAviWPAxyqtXODOih7YbwBDB4oVpVwnemDAyEhI8yFEo+T1rgbQI2iCmg6IDyImexxsN4aCXa/WAAhIIIFnI+oAtwCatbO0mAwiIMTXyuNxT4IKMwxTfPPVd1+yqHMAKa5inQkyg4YdiN2FZlVsQAG2q6jUVCnq6QB6CarM4W1FCtbelRwt9tFlUcAMondhQky+chNkOGUOV0LxITAVYiBlcOXLMIM6P6tTIZbDhQoijhnid2iii650gwwuwOCrdLtNoKYGFCggsTIFCFAgSKNsjNuNBohAYYh2BjuiUjEWdqjFQjOsoLkq/ligUtkUSOT/tSOqrIGeq1RAKd8U+xTmzqScUlxyJQK0iAYGMKClnQXoOVueiTPNaMort1w5TTvoVKyeXs06ppYqU9hgxt5cKmKnToqgAF5rhZxE0laKrL77yoXc8YFMl/3th2KNSlnDvBVoPDinrFmiBVhnLG4BrgVZpLHbYyj6gs7NjaABmzqISFdnuv3apzEj4HLyyzdfqwDO1SAthLVb1IA9d9Z+sWEbkoh5bSOqWoD5h+cpgFIJTnInIQjXGHI13hlEbQwhkQOGZbb6eUw+x6sSAdQlALcF5WfsWaD9JJKhDhBkAUoRoIOipIAOoa0gQWuStc73QhgWbQMXUNpa6ieXYHFN/4IWIRzDXnaQ23kmIgZEXfsUooAOGiciA0KREVUjvGIdL2so+oiWLjSQJHYrgQnsXMqY1z/GxAqMDwGUBwaiICMRSQJ7GpBOdFdCn50khnOkI6Y04IAQKodhflmNxTayw4UtizRFAowBGRKRz8kqdZZJpEJ+iBClzM+JUNziwRY0Jo8IRDN+/EslPVmhk2TwIvt7DSAJYr2C6K4uAmlcbAiwKuG1so6zpKV00vev5uzRLwogUgOSVBP7CGBE7Ekkl1CFNdfs7iHHYkh/HiKhvjWSQBEpwIIQUDiBXFAhzvskRCazybOtxJmfzBsrJ1BO1JxoSiycXkU2gMeDLauVE/+Bkp1qeU98qgUDNNzAcwzpFyviEGYW4RYCQaU7Rw6knguRSMkGIIHfFEACrzqY8gSyUHVC5AHcAkydKGm8xUwmVphsXN88aS9gSQx6AgFAlgrATYgooEiYXM9L5ELTiJRxSXNKYbsOdgADDJMg2jRAPo16VLDcMY/QadxcgoodhRTsiRWZQJISs7el9DEAXMPPYDbKQKAtxWycZIhgkGQABoiymwdxQMlWWhBuDUCtB6Hgw95KspUQhUkf/aQC/kk9iJzLCHMKwOcMQFGsClGhJBwfUh2LVAqcS0cw2l94siiX7lQNsBLRZVTPyDwGwFSqpgqbAT/6t7UyhgSBO4D/BBEQgXh104haJUit2DkS0xigtam1EjgvsgESfEA4LmJlMhlSgP3RdAIMemxz87nPDPRzRvhr5nse4MSljAmjDZtriZzqrriN8SFymdn2OoM6tp0EsERCgCmLlbwrqSCUEwmfUB1TV4LMEyLU/edIeEsQ5rn3ITw4AQgW4iiu7RFszmVw+ZbmldtwwEU16uxGXIOf/hZvp0sR70Nue+AErQSn45XLOInEgFeV7GsTMaBrGdJhvgC1Ad2FyAgXYtAAWECQvdPYFi97p4Aaxi+ijSIkbeKYA3zAAjVwFHYF2WAoV+6dD9bKjXJUqZ5CVS/YGQBJ58JXggSRIwfZLo0z/7yXJNKYlSo80kkoudDNRoSZWhyIjgH0pZFtMXsDlEuGMQgS18x4cCFanHzeGcLeQhVFUWb00DhwgQlnalObq5RKwmOad2nzPdb1jgTI1VkYG2RAH3XiiA9yWSEOiLb+0cgAAOs7iBgQnWiq29xOYuo100bNi0msMO+U4QpPkyLZgt1/JaKBCpgRe1CdVaOdjSmPrC8r/pJwvvaHAAUgaU77+41Nn6hL9MZ0N3Em1HAJKhdsd6xYsVq1QLK8EDAfhHSSKSjy5EIU/MqnmqKEql96lmdjfwlEMrgABVjaVNJG+tkLp5GmKA0ApDmAyvlqmra8lEhX7xFCCQ5AAZhH7v/86knAcOtNORFOgMvumjI7Tm+PFQO5VNGHAbudSGepl+9cBdsv8e64iAOOLYYQAZ7FHYAuP+MlhiddRhnogKQ5ZbSJlQejNnfPsArZTJAoZawkexL98ioQhhXLkLiWNWMGVOzJXMTGK0kJASyaWmmq5rtU9flaCRAcvLnrJBJANgZYit33kEvpg4/OO6XrL2mX73lyv7RcCvTarxH5jOr9JMNOky2eWySRYopIrxXJGAIIJaUESftFFLTH3Wx9i/1NQGUTRt/OjvkhFHQ7rr8UuPyQUiBJM3jcPUN44C+nAxe4ygxrCEMRJsk9jZfLrMMMcIkoYAINOmujaitvN7P/UinxxrlBtCmAR7oLAWhV+fZGXPrBfJ/ln6xMMOGHNZgwrN3Pxw4mzwqbgrQfnYk0KHYH8k4OoC6qCD4CPAsKuLLMebgXeohGKjq/CL+LaCSKkBAp8aiGqpskgiP28KH1+JDyMwj0i0Cocj6UEa15SwqoOAntqZPH44+MMTcXaaT+0YARWAHsKKoCzMGwuKMNUJ9aKggvcTK2Q4nMC5sNIhkeSYmwi77gKC8AorwqiZXyQy7FUYoIIAAkYowQvD6S0TnbmwjuKcKKgBwYcyID6iNVG4j/sYgvIqsrQgglu46NwAwdrEOuCAAN4SesoAAP4AAccQDiM59yQ4n32zDG/1sKEnwIrskgBNCl2/lAy8sVb9uIl+OyYquILeQhn5ixlZA8I3SWi8CvbCuAFpMI7RAflFO3SSKZBVCPnWmQnQm3BQgBCygBYIEcBrBDXbwKDBiBCsgADfBDBwDEDtCA3IghDgwAmUqSuUCg62KPmEGJS3RD9VrDwdgfCHSMkjmsxdA5hRi5gchEHhI9TXOMNupAcJurJJy6Q7wihqmYu1MsgQiaR+Ia21OAGagAv0OWXbTDDoCAEcAjDfC7WgqiD6GYIBKmlohHYQLHL5Ezv1iA72OMnUnEt0G1r7sIceQM4RAi+FKMxknE7VqIntmNLjNELhsIw1LEuwqXIrkTCf8wmS8UiBu5ACUIEwXoR500KteDqsSYxCPyse9KIjFcPLniHSxMm37zLIvYSPoSn11RAHXJxoe4nUS8oT/DCD0hjQURQGETCP07Neh7GwzAJYXbSbScJa+ci5dJJKpEmXtTnnfRLUzqvu0pAIewS14TPcAIw5pbyiJ0Sj5RpgEBuXiqtcXIsA8EDtUBKvzDkl0BOiGpJADgwbS8zFnCyLkAG91bPeEgnob5ucEASgzqoJP8RCEzDY10jNsiiZ2Zv3Q6LiQLjymJFdVTqVvbIqwIgAzYEMz8TRjCSrbLj2ERCtmTRHWRCa4STYuAuXP8EglgAIgKjIo7stJSHIcQR7v/LLPC6sRw2Y+uwq/32TUFSYAxwUiTcUixBJL1UL+3/JaseKfEA076tJy11I7f0Myg/Jh9U0ZlYs7BHMFKZE8G1BjBlAiO67m1AUoN7EDrRMkk0aH1YBLD/BJDKkqJQLqusMz67FCo66xqqppUwY7bnJLGUU9jw7i6u0aocJR3Q4kD/ZLkTAxtIolEqlCXgEJWAowsCjfTK4BzohJx+him6c2z9FAkhbalqA0DcogH8D3V0EYEaIC0iqn/7LgDkAAU3SIjghzY9I8QEQkuaRwS0LdrspJxEwgiqhJpKkSVJCwAzTUCagz8Cgv5TFI8xZdscVOXEc6FGCcgBMPOAKyq/3mZUnnP1LKizfgcDM0dFQSNlSjTBErKgdifEh0Ivfywr0RJhorTgbgdH2WMsuDQPC3VGlmAMpESJ/JG/1qeyTyIB5AQh4GcxeSit/sRNw0jOAU7/ohRKnnFKkE4YYqdSKGTrQRDQhND7qwSs+BN3zRVaI2RqmkT/TSNB10M39qeyCwg1SRST108rTEh1VAAX6WS1EDUF1wK7yq5iphEkwKcF2PRjOoStLjTaL3X57C0pWS7BFiTVWqMbK0IAwq1b4XLljwYEKGocqWSBZgpMBy/KnUJARS/A5jGiNAmGGMelfOJ0WNWtbgNBQQADsBXkjULIfTJJ4zXxkguuiIMHf8NRb0sWFqTGUyUWdLoDHQlOdqYSXt7VZxYP7u0yCWZubxkKbbAwwzQinc60pJt2q3Y159xIpHE2ccIHJutJHFpr+25koXVzfzLTbtaChw1CP06CIYZW/b4KiHSUOUoy8m6igNkWqedWyiNEvUKn/lqjLkUNNAzidi62v+Kxs+TDCldo7cJWLKZC56FmV392oTrJnbqiOcA2T10gJCd27lNyBPZ18UFXIuI2YLlmu3o2oEIkn8dzQXxGMSNzSWdzXYimQtC2w2cHOjAw6a7Co+4XMxtWuEcgLXDjiv03AwVXvbQL9KNIw2ju4UAI+bpXGH9UoqISZQAm2wziH6ludT/2iO5bdsr8xLccNoOSNrdBYBqhdoGTREGOIy5Yi8aA13iZY/bqY3jvZ1LJdbXPRiqvYgMQ9dq8pj80JKj3B4EmDmpYwC02lK70QwYoVwAkLh+pAAIqIC1uAAIkK7d9VOo7bAJ8LSIcrmD2dZjmjCIcN/hfV/UtM7jlabMwzjxMwC+HWEgfACsnIjfHSNwwSicqhM/scCYKicnykUYsd2rOD47hGAJVgsPgIDbHV/NhVqeqY/DsgugBIolBMvlzaL1+tQk6VwTpojj+ZTj7a9QpUamLJZGKhcm6kKWcyKHSMMluTDvAaZyyROHMCAEmBG3BYALeFsdNGK2AMjxxQpW/+03bmkTjltWTeUNN+XYRqSzLi4WhBoAwSDdRB7cBDa3D7FYLpSIB4iNLILe21km1FvXoSizVP2cL10TVxOSF7HgqwBZYCziCP4KCBABsHAACNDdkm3iff0+q1tWJ3aInoycRy4WLck7wvUbPkoQUVOvSfTdwejPQQQ/rnm15gMisSqIRoqA7VJRAh2tKMmaAlhgQNSAzQGhDBjZPp5lr6jlpIIAdQ5kUrzBYV4K9XMIbVqNk82Jam3UYgZDEFSM8n2U+DMUzSi73knPSYyAQg2giumv+aMuLrmsm1A1DKae/8FLGgkAD8CRDFiasryAJSZAP25nW2Yadg7k3Wyk8v9yYmFaGVD5Zpeu2/qN0xObzi1a2H3mn3B6PV6FnhY5CK5RPyAB29L9Mh47CYvdJBas5FZNNI3BFArQgAvAowwYgUAk6ZTmCncGiwqAgO3FXJcJjJnOliYa4K7q6aXUuTEOxe/8IyrxvO5KxIXFYApxojeNiaY6CGHtM5b7sI5tMw+2Xzp7F1+KDYxKULO9tX3pwQoQgREowJLuiq7+Cg6AgPlUaQAwrZ/GjNMprib5W5bSjX31xrYejAFBYNL2qdh0tZBKV2cJ06g5aqNW5Y5QV3Du5UcFsCutynlt5sc1CBZixi2xktkRjqLhaMneahpqbgqGAOcW6a2AYAfQ7Kz/yEDiuh3FwYwcSpQlmovOUL9knBIvTWu9tUaDiBu0XVjQqrH/5JbNgDXiyut99SWWw592HZdnqZMS3VO32xPiGTO8vQnrHovJBgAISHAFX3AFP2mtAOQCvwotedcl8aG8/dSXhdR7g4wFeZIHwb0ovCnHWFbBFgnFWFhghQiiom8Qk1C968gT2Q3fwCjiPMLRhBfznmfXloj9oRcjioyZiHAD3+qtqGyvSOKRjvAg9w4XXhDVKZUI4JL98dEy46XFFgnI8AknpJK4O+3RBm474TOG4OJMGoysibNe69hkXJTHxObeKKz485PkGRMApheMwlAG9USDCGoyro177Whd/0aLAy9yB/cKCnZlIcfduEKQgFIY5glVN/bt357vKtFMPRdzS66ZHxsM0iWcnpnnLbmsnOULQiINesK1rKlpg7jRbmxcItLqIwYADCBys9AAeHaOQX/wQu8KEdj1RAcAXtYJA6Lz7HNv2aQmjYgAfx6luYi+tzu1xMnVK8+f1awkMhxrAGUvMudWGLyLQKMX/OES24R1rJj1WEeLAKD1tcj1rDByrph18f11rPCzhlEw3l7eh0WxM/FALt0evwit7dmNUVfjjbj0cPSk79Ol0/xnwsZ3xnRkOR1zDf8Jct/DsBaLr774smB3rHD3rcgACJg4eSci0WPLu0iSWuULk//ENRIOszjHkxsU6mLVtwQY05ciM4s63sEYwqxieG1Gb6xp3OfUD5tY7nMPi68O9MvO7HVX9473da0YAQiQd62AHJJwO4B6m7iBXpCo+e6cdKiiqcZ5G0UljdQrc8+MlLb5OVJklG234jmlCaBPc5oKPTereFl3+qtIehuBgOpmDo4fiw2AbqrXCm4ZDt+bMQYYFXF5j/HRRqCHmfErNBHimyut22CxymIxogLhKp2nk7VJyGWPZq8P+mMPxc372Qs/I/fYGIXHe3P/Cr7/CqlvjsAXi3/k48IH9mgxlBtKHMyCfKUW1GvVuT1pZPBTNxFqXPlgp6i4rM+PiA7/VDn/Ll2GUe2LcNfrUp2qhR6hSGvcpgg/ayzCm+zY94rZ94rcB3y9F4va332vwPCcWGZz9FnW9aC+/sbtgfs/lfn7rRKAYCBgIMEBAQIUIKiQxMGGDh9CjNhQwYCCBCZefJhAoQADEh8qKKDgI8mGFRUy2MhRQMaSECkSPMAxQgCZKwt8LBBBwAAECVdyDABgKNGiRo8iTap0KdOmTo9SgFCBKAapSytAoMB0A4QLT5tGnfp1LNmyZs+iTau26UGYQN8qxOnS4YIEchFwZDD3pMIDB1XC5VlSgQGCBlo6JFB4oF+JDw5UbDBybkO8HBu0BeqAMucAfAd6LJngZGOJBAoU/1jcETHnBUABK2TdWcGCAAI5wiaI4GPunYEZrA0uXG1YqlaJcrigXLmIrsuVCzXaXHjx4davY8+u/WgA1YEDG5gw94HqASNHD5RQEsDBz4wzcxxQfnLEAicjIKhNksAC2Q69C0DfXAS4p193HB2wWWclFSABUP5BBGFDNq0U2oITAOUaRxYu+JB7AtyG20cfghfddideVx0AVYk1FFYQwBijjDBqZRRWJqYVQAcaoNijjz/+COB3gSXgUogDGXSQhBFRSJCBDYhYAAIJCAhSfEvOhWFeCxKGpFwHPRCiXw6w11mZiUEJ15cNodZZbhxVuUAD8okXkQIrGQSbeQ9IMP/AAAcsuQADBjBgoFt9fWjgQwQMiWShQEKKloosXpUVUwEcF6mmm3IKKaONNpokRGU+AJRcZw74WWkH2TRAkazGFNGR73XoUJNI1qpAlQ0RoMADBym4XkkkKiQgYAOsSRKxA635E0HqRZSmbm0dwAACF3k3gGzsaUlQAegBpYBlhj00VENANWlAp+s6NWmmSGFVo1IaQMABu/fim29Z44L6HaAffSqiQxNM6dIDCDTAQLK82oogRL4pJGqtNeHJGaqUBTtxAG/G1zCcc32H2IcQtrpbRG+u6pB7y/qUQJ8DMfCrRF3iRgAC+emb81DutgivpUs58LPOQxN9L8f9vqX/qMcfK8mXeRNfHEDAsT0kJEsaB3AnRyZjTVLGCxYwqNVxNY3ufiONDWJiQNVpGkmzCgaRs4E1kABsgMockWJw4Vj0vTxXKm9SEIzgt+GHA1kqqA2EbcCyHUVkNWYNARgBf3lrPLeTD/Hrbdf8Tq7kZFFP/DVnnQM1QAMGwg2aaWn++VbKU3ubwE4RvErZrZA3VKaG/tIuQO4RPb4A4n9nSqlS8S7lAQQdHB+99NYdvRICu7/FmrR9/RdYyh1qzRFrwQfYtdQISPBlmNOaD2yt5G8N5mRwfX8QxEhWDJGQnXNNEnuaC08ijxvIzSqUk+8Yb3qbAtzyhIaUC0BgAwqc/yAFyUKA+yEtew5BHa1sMySTkW4uAJJYQ2YVmhBqDED9653F3Neh6tGKQtgbiH8A+CEO8eozHOtMk0IntyERYHfaQgCh5PKtGSKpgpFSkXBEIAIlQjGKSIFfBpGUgJYsawHXC1XXCOQwiEjrMJwhAOZI8ruC6G1XQvmI6daYmAIYCHsJQMAEZLY9npgKIgiIwAAH0raHHOwA1wKgAJRWkgUc4AALOxMhFVKbNzkOJX0UQAGk6CMmrqUqGbAkJ6NIgNZVkSBFUlwoV9ISFJLkQW7klUg4Y5+BNABCZ+IYa0K0Qq/xxgC6LEhtrGalIX0vbcjiyy1nFq72PQSDGzLJhv+QZoAGAKqTKMKkWjIAAQxIM5sUPGMpi+WZbgYFa9xklvk0R8L6AOUhdyxmRNoYgDsWhJAkJGSTLKeRwJgMNVhK5jKRyavvfIkAaYpAI2WnzR5R86AKXehRXgnOWMGwX/XrDPnUuCAhDU+AX4RPOF3SxoIKQJkCWOE4WWKzA/yxhPQTp9MsijUqCmBVC5hAATKyuL4x1DoJzSlPFdqrSXrvIBxE2kQv2s+uma0kFySIXgZ2TI8yKYM9YcAB6AMgvaBSiDV1iQJks4DFNAB9GUWlUS9TVV6pxgC/AuVlepodHfHIrXJlKBJBNTx+1fUyyNwbkva5F+tJ5GIL2OpDSvr/KwVI4AAZbUgb6zpARc4RYj484EoIShJwiZGjuKIMIxfzr48cSgApPZBCMOPF7zRgrqpdLWvJAlI8dWwiK2Hrlnjl15zYxZ9vui1JrroxhWTWIR+Fi6uQxoAJVAmFM7RobkQFt8Ue8qimQQBVdxU+qg1VIQhoLXe7692hHClteLSIQ+DZE/H6sS2LQZY/zdekhb1PNaZdyffc2Tox5lVgrhTSRJX5qg8VVSJCShZZHULI2vTxAd9dMIPdWoBqwfEtA4BbWDNCIprUNTSn3Vx7X5rb9g52MhyEiDsRwoC69apXWyWAXa77FhyK0IARAYrJ+LugpL7vNfndboN77OOF/5a0SMsSD7HmiCdd5g51Te0wk8ulsRE/pMSLUk1TS5o/Hs5WowJ7k0ud/M34+e9toVTXj8tsZk6WkgAOQpeLRwoRuJ2zPomEr8ZYnJ8mS2Sckw1AG+38JQD5ZZLBpcw46dzcpQVwQajjrUTyu5IEnDnSkp5gRN8iZLPBBsYUk65EjrRkqP0FJf5MjXyGx+IEAGhXppubR9pMSaQVSVzpcwlsoDuhglRJAXa77cWORGeKondDkx42sQ+Xmgzuxmp1OYkBcNKrRd1kP3AbrZf3A9iPFFgo3SIgezLtJwao8WvBIyiNM9jDuaDmAQpgQKn1Bkc8a/GK5tuw9xigsGLjO//fOQtAYD401J4g6DY9MbB2qx2Aoe65Q6iL80Gy3R5TtjmjXWXsPekbroey8yV5sRk0DYnniHRbkP4ZbEscfQB9ozzl7CIlUEQquw8+pAATCBRcNL0g7GmsTK5u0FMp1NSvcVA+DuscUF0HsIwISYddnBi918RXAUwu2AJQOdWrDqmiE/e16bkWZ5CYcUB+ZNuwnDeNRTqAx+j1a1YWaGkvguqO1BQyfhoSwzHralNOrFW2ZmHVVtI97sGzQlYfPOGzo3XU9gpp1I5a4HlSxoggoCKukggGPd4hqesmXKazmpQ4Xdj40BedEWvU8CbuEgBBmjM7P4hhs+utwsM+9mr/0QkstwiqZqMNaX7l4GdJcisQJsYmzUZmaL8j0gQ1/J8reRlHLC+Ur8Ls6TR0spCC/apxxdKMV54LB18ldmY9DlmyHz/50dLIuQPFAAtw2uOga7P8fMuhBPFr8BiO5wckQJCN/44B2ujv1xhMQzxGRYCbRKDLZ/jbwXmeQ9DS6TyVqzlW+UngBD4Fv1WRR0iJs7GMHqVfmkgGZRBSl0UIdfVerezfd1iAAVTJmsVGHnXYhxRJ/lWVq63fSjgfIc3G9p0gnhAABfrgDx4F1hHErnRetNHFSoGNKlFGaP1ahFQLAigAZJSSBfCE9sSF/G1Wh+0WGM0WAI7IRlHGrChN/7AZgF0A4RmeIQsaVwLUhbx92YYgRl3Vinsk3EcICQjSXUgMEBUKgHqwh+8gDIkMmkToUwtRCHvpT4W44MzwRR0yIFV9CapN2K7sYCGh4SX+4Bt2k0/UXA4FBqO1BV+oIMKclbUZ4bD022flFR9ySJnsXxMGQA12EGWcxq/tTiLFFoNQyelxz6g8BNx4B6Rh4jBO4Ds9VEwFRm0UXy6uErr5RGjtndSwjUOYS8zxX/LRG02ECB821ZlYGQFRI7TpV/u02UWEiD0pCSg+hBoORG0czDONFgDhRJsQYz1OYCXyX2DgxA5GI2UIyZKMjEu8FiK2hUD8yUU4Cx8ujOtF4/+b2N/EOFQEGMhpGIhDqWBnpJsmMga9fRqsxIQ9gqQPPhjmVYjLxZQFgh5P9OOAeCEhgllJsFzN9SALVeNiUKGmwdCS4FzOzQxroAo3aUvy5QQxAdjurAl7iMu1hORS+mApAUraYM9uqKNptGQUWktLCAqdJAb6wFelxdSZ/OFBJOSzAJKaGNxvLaAvthc8rdDFoN1l3ASAUSNT0uUP0hZcZAR/YA887dMCiODfUQ1aIkmXZVp9zIl48Z1KDQQfMkZYIoRC4Icb5hkbugcs4plcAowgfgZmYCZO1eVnjh9JDgRNHCHMkcS4DOJEbBUAcJPJxCTv2Mm1fQQiZQiUDID/Hx6EajDm9J2Jn7nE0+2SSn5cSeyP70lYEMmHyRilZ4Jmc8aeV5bW2nyHxCSlgRxaYkAfLB3WAUQA47CJEnJgx8RfnikicFUGQewmJaHKBDhOKfLK9bwKgMTSVPrT9wHkWyQcRzKnc/In4ZFW7HzHHwXbZKjh5HxIndCMXklEA0YVePjHHQ1Y2QhAegrIrVRkxBASb5HOAjifsCigl5QE/RRAAxjAWVEkETWAePTnilJgpU2ekkAMiZycDZGPX9Cb+GzMAUhASwSPCiZWRmldHUYe1JVUabDdbnJIj66Re4hUhzLISRAkx7mnUrXJAIKIbIyNe8jXr7Bol0ogTG1U//yRj0FgTyTdhOtNgNIJFYIAF2IE2z4lYO8QAGMG5Ro14OEJQN4EkS5R2+d9DDSWFZJUSyk62kqklpci6vi5XmV920UE3ie9BTs6CnisBH2QmsKEntTcaIacTMEAwKI1owOMZ8VxxK98X0dslIsFmAc5jJDkDYdeFpF8aBX1YKLaauEhUlhB50CsW8UMVf4BBVsRy0JmCEnmDVI6DbYoBHSVWPBMjqvZ3kk2BDx1WfWRj3g4FEH+YsgE3ZAk0K2CK+wVKokgAHnARZCFEmssKjAlonkihMjp0QBYgGWdTMS0hAvKBo2JGYKQD5VUaoPCBbgAV6MoWLgaLOGBUxD9xv/IYGGjkNRDTZarddlt8GGfWiXXnSccGuCjhWNpetM/3mJEfCMBlRJwHOzJVt3IhgwwXUZG7GpIndpkiKa+fqcNghZ6ZmHXyRhEfIgIZitOsGb8VJ9QNoSkFguoRKvJouzSphxpORNK4tMd4cS6rhSYhop+vKYAxOpizh+2Ee1BcKo4coRlxqJ1kqgBdKdc7E4dAgBiCRKCAMCtoF+xsMdFMO3dqtzLlk+wkcj6dJN44ON0ZqxuoNBYDoTcEJbetKTycUSdPFhKXBYCtoQNBZZDRGG7HYS0mEfnkBneeq7KsR2oXITKBmyhwkVXpZXektNfSN5KngQ3smZhfEbGLaL/QygTGWWLf3BMaXBMarKGQzFARuga0H4qQWDG5yKvymnkb4yonwTuSLWZEB6GAkxARUaYXU2MhtzkaQRso82ESxacMtUPiYjK0XAI8NqF2J3dHx4FGSXv+zatFIbKRVDt5sCGelQRw1kthzUjZSQACshF2rTi0hxGCK2bfMzjW0SIhDEu3j1mo3gE/Eqw7Jnk6CHNnzjbrtlPFdEZPjoiZyhI1qIRwIjEiJboPs1QM8LPqgyVflQwnExwDBPeph4juZBqv+wGqvDHMt7mSehq1wRLicjNiRVJ59QG6RxRsEYLnigNg8KaDEOx1dXF8yLNLdVvrPCKtCiW42Bu1rSU/8YEC1stTJPcUH08jmyw1fU8E07Mil8owAuPbRTLcdUNaQ3bMCDBUaFyzQjZa27mosNRnIQ2LtGS7tVIp4TtCkli0G48gBDO8SNT3awe40O2GW3iXaX5xYF17FxkjJCEzpk4WhktHFeKbDeh7TNl0LdC8irnm51N8oeZMYhCrSgVsra8Bdm2U3llGUTkl4WUyU4uqB3bFSsTc97a8QA4H6yei/XgYwQYrSF3SMYAkKZpXUcK5h2LnjCnThkWczenXBTOyUM9ZN+JD9JajSI1QARMKVTJlgNva0Gk01ZWJipqs/BIAKGosjfrM8o5Vl71qRsZrXpMkjFuiBGHWSCLZf/YQgSqGUC0KsQG4Qksmm6/COM+W7TV3ZGrVBJ6lSjW5t+OHgQ7qs5dNMoyQpKSwCcbDSnAufNsGmrNLqtACnNN5fNF23TKgYtfEAVQXctn4MRTZa523R4tzU2dPgQKNNOGPN6b4YZ+wA1pkgQVpyTM3HRVl5/pCklJJUu80W+jqPPFXUnMpScygmEuCZ2XSA5xbuKDKZJVu7Xs7W/AKvTJ9JHV8FHLsUlFjDWUuQQAANAMKUo1euSGIFmW7udbIzbVhW4VJYAJbS3LIg1O/M5YW81t8ZelkQQhVdJQEFIBJ/Zny15eBWQYyYbNUBWoKBayseqEchFlfEihSFhDz+T/QzxIUQBGs9UqaOs27MnJW8B2L2ZN9X6t6paoakPMWNduCLEHW27acfKysB1FV+32dJMfbSAnNwPAJyFwUXyEVIPTAUgLcr8kuuGducKFHxoFhUQwdbM3fzrEM1swcanOMloc137H19H1aCpKQQ1AUsRibrd3gPNnH92doYaKZYi3dpFV1Pjl19acgEM4uMKcEH6H1iR4xJQgZ/XOUDQej0X4h3epeB3vFTfKN114WKvlXCZF1nYuiLs4f5rTHEmAKmvzb534eDdcWWxYeLx4j/enQ+k0UlA43yDEjQPXcBAAgPv4kjfnYQOA6koYUZCJeaMWk1t5N2eYo202AJDJ/1D0inht+ZWL+SOzWCXxSUcTxbGVKInCrZQbRQAwX5uP+ZwjdmNHU1F0uVIkpQLQeZ+zd577eaC7OKALeqELOKEbeqJPN6IreqMnNqM7eqRXNaRLeqXvM6VbeqYTM6ZreqfPMad7eqjHMKiLeqknL6mbeqrfLaqreqsfLKu7eqzbKqzLeq2zKK3beq43J67req8zJa/7erDXI7ALe7GjIbEbe7JTILIre7OPH7M7e7QTHrRLe7WrHLVbe7bjG7Zre7dLGrd7e7j/GLiLe7kvGLmbe7q3Frqre7vLFbu7e7wzFLzLe71nE73be75LEb7re79TEL/7e8BHD8ALfMH7Df/BG3zC5wzCK3zDswvDO3zEawrES3zF+wjFW3zGawfGa3zHDwfHe3zIpwXIi3zJkwXJm3zKNwXKq3zLIwXLu3zMDwXMy7zL03zNq/zN47zJ6/zOi3zP+7zHe0DQE33RG/3RI33SK/3SM33TO/3TQ33US/3UU33VW/3VY33Wa/3Wc33Xe/3Xg33Yi/3Yk33Zm/3Zo33aq/3as33bu/3bw33cy/3c033d2/3d433e6/3e833f+/3fA37gC/7gE37hG/7hI37iK/7iM37jO/7jQ37kS/7kU37lW/7lY37ma/7mc37ne/7ng37oi/7ok37pmz7kb0AGYNPpOzoTYUAHOED/c0AATkUF0LP+KjPRjMw+UowABNx+ozNRBnAABmDK7h9FB0DA0P++oe8UjHgmV3jF8hd68xv/UUyH9As69TOnNa0+9ve59ieFJnm/n4N/UjjR+H//uxSF8ysFBEkQ+o95+SMF8is//F+5/B9F79t//Ks/UbA/UgAEBQgOABQ0eBBhQoULGTZ0+BBiRIkTKVa0eBFjRo0bOXb0+BFkSJEjSZY0eTKhwAoLIUAIsJADBA0oada0eRNnTp07efb0+RNo0IcqWbpcWMGoUKVLmTZ1+hRqVKlTdRI1yKFC1pZZK2Q4GADCSqpjyZY1exZtWrVorRa80BIuXLEFNUDgsBZvTV69e/n29cs2bEUHECj8NXwYcWLFixkjbCsRwojGkylXtnwZM8rHED1A6JAZdGjRo0lP3lwadWrVq1mfPd0admzZs2mLDNBhZm3dqgMCACH5BAA8AAAAIf8LTkVUU0NBUEUyLjADAQAAACwdADEA0ALcAof+/v7u7u7iRCXt19Prt63jVTjlZ07nh3TomIjppZjlemXsy8Tsw7vmc1vjXUJISEju4N7qraEAAADa2to9PT1GFQvpkH5YWFi5ublnZ2fIx8eYmJh4eHinp6eHh4fYQSSOKhewNBwZGRk7EgrMPSFyIhMrKCdGNzRjHRBHIRnGOh5IKyXhPh7VmIxtV1OyOiJzOS3YiHizem6TSDmeMRxsS0S0RzBIQD7FubeNWVDOdWOslI/NWkRmRD3RUTeRNiPEramVcWmyh36yoZ2nWEmiiITaZ06pUD+IZF2CZmBlYF7Rwb7BioDTopmgYFSlbWGITEE+IBoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzaty4cUKGDhxDihxJsqTJkyhTqlzJsqXLlzBjspwggYJBDiYkiHiAwaAEEzKDCh1KtKjRo0iTKl3KtCJNmwMD5BRxgYIECRsKPpAwoanXr2DDih1LtqzZr08Jbn0wEMPVrgM3SPBwtq7du3jz6t3Ld2VagTQlBCCYQcIFggFq9l3MuLHjx5Ajw/wLwINigm4lFLQ6WLLnz6BDix5tl/IFCRx8ciVoOSvp17Bjy55N2yJlq64JXu05kCbb2sCDCx9OfDHlnLkHipAAkmDO4tCjS59OffJlAMgNLm8+kAPz6uDDi/8fT/7gbayqecedW769+/fwX5tGrRruwK324+vfz78/WcqWQdXWVT4B5d+BCCaooHUCBtaZQIUdRlAH9C1o4YUYZjgRZQCsNeBqBJ2mgYYklmhihhxKpdMFW6FXkAginCjjjDTCx6FAOOnEk0FuZVDjj0AGWdyNDRWmnpBIJqmkZ0Qy9NySUEYpZV5NKqSBYVNmqeWWTVXJ5ZdghpmUl2KWaeaZKgXAQXJotunmm3DGKeecdNZp55145qnnnnz26eefgAYq6KCEFmrooYgmquiijDbq6KOQRirppJRWaumlmGaq6aacdurpp6CGKuqopJZq6qmopqrqqqy26uqrsMb/KuustNZq66245qrrrrz26uuvwAYr7LDEFmvsscgmq+yyzDbr7LPQRivttNRWa+212Gar7bbcduvtt+CGK+645MZKgY/lpmshBQaq665/HsX47rz7ddCBCA/Sq295GQRAAZv7BlwdWw9IKPDB0wVw2AO/IexwcRhk9QAHIz5scXAUd6gBXRd3PNtvBHssMmwgA2DwyCh7pkFqHQKwwZEpx9yYB7yxNQHLMue8mMEl6+zzXg3/1u/PRJeGbssA2Fv00mUpLdBvCjMtdVhDPx3V1Fg31TDSWXetVNT3eS22V1uPbbZRZZ+tdlBpr+22S22/LXdKcc9tN0l13633Rnnv/+23RX3/LXhEgQ9uOEOFH674QYkv7rjVj0e+UOOSH0555YNfjvnfmm++d+ee3w166HOPTvrbpp++duqqn81662O/DrvXss+ede22T4177kzvznvRvv/+c/DC60x88TIfj3zKyi8/cvPOewx99BdPT/3D1l+PcPbaC8x99/t+Dz694o//bvnmq4t++uWuz/647r8fbvzyf0t//d3ej/+2+u+fbf/+uxYAA1itARJwWgY8YLQSqMBnMbCBxBoAA/IFOQgKLAAJUIAFBkAAAzhAAQUQgAgtoJWCICCEBiDAQBjQgAIYAAGIsWCzAjCAAHRQhCkUyABCKMIe+rCHCRBIAP8WsDUF/LABC0jADwvAQR4egIIyHNYBfuhDGBqAilgUQAEAgAARVsAAEADAFLNIRR72kIkAGMABXJiABTwIilFE1QAGkJAxknEAZMSiHSugRTvm8Y9XpKICjKjFBiCAjnEsVQDsaIAFEIAAb/yjAJQoSSzysZKYzCQME8kpNbowAgCgZBaDCAAGSJIAZsykAC6pylbekZOawqMPG3DKUErShq5cZS5TmUsBbBKWlwqkKhuAwT8WIAABYAAIhSnJS/LShwZgQCALkABR9lIAT0SAARTAAGAiSo3bnKBAIJCAZ1bSAcmUpBuRyU4CrPGPl/TjGRHAznpC4Jo97GIVCeL/Tg0SIIzexFMHn2kAWl7ziQFwwB/pORh2GhSeWmSmCIlZT2QuAAEIQCUWHdDCHiqUigaQqAAQKU9sBtRO+sQnGRnAAHP+kKHsJGQzybjOevoRAQsoqQHaSIB1EkCbWjwkFulJgCz+8qRwumcvEWDNoVIxASJtwAtrKEtJFoCVIgyhAtwIgHo2VQA3xKIBKkrWoS6SjAYZgAUOoEKkhqmouYSkSH8oUgfsMItMXEAmsTpJsrJzrnMVIUzr2dUAzLUBD6UiHaFqgFQWAKBuTRIBFFqAo8K1lU+sKhnnSsMWPlMBSq0kXwdbUXOW9Ix+ZadesejSkba2AZGV7A8PMBDN/2LykDSUZEo9uoDWCuCsov0hHVOb2B5qlLVDVEA4K6pGTQYWiANIwAESAMfYauiZCFBoSPP4UZC2lIwFYMBXE9DdLNbQjy+8bA+xitDUmpKKSZSpD9n6Q+rWs7w9FKlQW+lZElpXQ6FtZQp3+9SXQqCnEdjoeyUpXwGMVaIVOIADUpjaehZXmAUoLxOfWU/1+lC6+a2hh1u5xf9iyLb8zWMjlwlJi4L3mgS4a1ZPUEPCVhi4AsAvNAew2h8SIAIKOMBpBQABGjKgxrnFJwq7aeIDDeC5mPTtb/06ZJUilAAJcGc8b+xVTBogwWX8IyQL22GV+rCtTd5PAKQ8y142tP+iDTazYG2qSxEqgMyF9SQ2RyxnHyqgws/MMpTxmub4NBTMmOToi5H7ZnYSuM/rJK8XfYhkdrJZlVImbY35XMMFqxKyhR4PO7v66GuyFNHGTS2KP5xLhu4Wqy12tJmFbIAD9PaP7T2uAr4qgHWmdMIO/mN1Qy2bJ9u5IDf8Mjt53csaf1eEQfRrVxcw1wkOAAEHKLVx3YnbAAS4ziKsKTKLm8v24niUNUS1FrGITAIzlNpZNACxh4PihrobmavO5VjryVIus3OOQ8yyX59dgAj8NAFFJquHWbnvesbZlS3uar7LneTZVlS9TGzovGtTV2RiMayLrqS4LbqASiOTzDb/rvC0R+7eH17SrhXlokrHCoGS47vPRM1irPGNbeqifNgb/4x5+bxEKh6guVl0QM8Tzk51K8Dk/ubytadL1q6msgIFaHF0Y/1wTULAj5XVcS6pS/Q/23CCUY+KdKPN1aA7JumDxiLaA0DuOfuVz8dUubRTi3Goe7oC6wQ7UK8JYpDKuQFFzmIDEJ31GxcWAEQfq9sZE/dMmh2ZDJBnxi2AwxYH1r5Rb7RFawzSNwvR2AJIwQJs2edK1t2VY+VzSVk+anbmscSTHws5E4DItLa+4fXMbgGOblgfrzmL5g59u/PL60p3VZh8lHHrAQnpAeC3AOTOO75LjmeiGzf3YrEm//ZrXdNS9jn5A6ciOgNL2tAT2JxI7qo1+dj1rE7//uWk4mSxaF+Zmtv7IkRb4PcVE+dLJ0dDCNBRMFZhEBABhfdDuIRFUBd1bHZMBDBI1DVFLOBFKhBsWZRQ96d4VYZ8iidWdId8BehgBTB8FoBTA5gU2pZPCqdJx1VFogeAU/ZoEaB89bRq18dMtSYALDCEFcACWYd8x4drzIZJ60RiJFhGBegAYpdHAviCRJGCAUhWlSdCFiVRg5WC7XVgCcBUE+h4tlduPsRHRMVLGTeFE5Vw13ZYYrZ88ZZJBxBn9HV/aGaFQXFpvUZWjIUAngZfQ8RuDsVdTOdXEIAAQTZ3/v82gpv1UF/UgwkgVQiQcEMlZLFGZiAFiTuITAOVQvvXSgjHSzxGYkEIXv3GhytRcw+CgzZ4Y/VXQ7wGU0bFVlKXSu2XcshUfyG3Snn3eBXVY2d2Y9J3hAxWe3T4iz00GANASEiETFtYRZhUhaxIEidof4pWjY7oVw+3b0RHemUUenFWUzzGdDanWk64XmAlRH61at14dwL3ek9lUQLnhz6kfe84ja50VNcYEtP4XAVAexX3QzVlTgxFbuiXWmY1AA81XSFmaZnES3xkAXs3R8WlfT+XWs+EfaUnU/iYj/7mSNLkZZn0jyOBhUBUkFSUWqdFfC5mdDGJWv7WVWYFZdr/F4M45ADDJ326BHo9OE1mlHHKeGMidQDk5gCQWEkLWWEHd2tZ9Gy1hJIcAYBmBHpxyH9+5VJEWXwv5WyB9HS86FfkxlKSBHp29EyJ+GojFXMoVk07J3oV9lUXZXSHx4MVdVr7VnnyRpUbUYARwGMMSUUWqYVklGt4FZc8SIwC8GdL2EO09W89VUwi5AAsJ1MVsIkn92iX529juHN+tIM+2WtYpIAGIGL0KADx6G81aJCHKEkhZZF+iRHPlYhkFWh+9Zgd5lIHEFK7KHVrtFOgqFs3xgAsd3pZ9gC8GGf6WGGeBkb/lgARwHTPaGc19EyQBHAxlUe/WWGMGYteCUSQ/9h7szkRqGd8N9ZUzelwZERWaoWIyreRhfhHZciDykll6jdm8ulxP9SZUddU6JSb3MmARwZnZGRfI/Z0gFSeE0GJICQADVCfwedRE1hYyiSTZOWLBoiXEzqHY+lXF8V79XSfZPWdPfSJd2eIPJhSEZpaENBaBMlISOaGgcdu6kZFXdWb0cSgBUFBzHVE/2YBE7aLxkmO+WhyOfpHAepvNSdeLTaIUcmDN8VOD5BsO7eEq0mZwsWhNCShNPRwv0lgS/p67aWXCHhCWMSYd8Y7GcAxZpF/G3qAvah/NJRKwAeIjbVVfGeJZWiiPrSkRql/S+lgaaelPYR2K1BflDhXiv+ZTksUc1y2nxU2e4P5Q4U5YtTEbzq3nUsUaH9DGW4hIAzBGWZBYGaHcvEWZ0BJZz6UpZEaADcKnqrmUqlJaaF3lMjEV1NWT4E1gRK1qnhZndg0gVhUmD+qlQHwaMn3krJWX1n0qdcRqg/RGmYhgWVlee+IRdy0d6zJe8wEqCUKZRraQ14qkUCKALrajUPWlGOUqUUZerb1WDamR+/anshUUt34TE8EpZOUb0ymNxwyAUBXEL5RFqummINqZwI6Sor4mf/pm8YoSe8ESMoXZ4wIbj00cn76hy7KraFXUu0XZ416bq3KnxbHqsXISw2nc35DJk6iGV+BZUwWAHLnnn7/2KiPaZvqBXPvyoOc90eBOWgECaJLBFd8tZ4RiEW2yaUVpmMU1YNAWmFz1YQYyk4QUF5/xmcJ2AAPN7BnA6rX0RDewR1K8aIeFUYSpY8EYIkLMK7++W95FJdYhKIcWliDFl5xJkHKtUFmWFElCaFIx1erCXkMy7T+JlJvS0PBCay3+UNLKrK5KVUrqAA6qUfQKiDS+hBXcjJJIVFjhWItNqjVxLUji0xLSLeRZ7hzulna1p1cSkhHS5Cx2pTxuZ9fVbrKR2DmGLXeiE/0JH8WsIdrA7ai2hDL8TVQxX8iNVYbO1+Q6p2nVWlL6LodlgDWBkJKqX4WUHITl7h4SWZg/6arSItMuPmh+DZGMBl18kW7yvedO6dGE8a4M3lGmJa0WuS1U0O8EWEkSJGEqpSsCzW0N+Zhybexd8pOY7RTQ+m4PmSsAIyEqmuYutpXC+tDS2uz+XjBfCdkrqp3eVl6NsRUUVdqaHppNHtEb6O/ENEjSPGzrfTAd8S0JWWYG5Vy/IhlItqhaRrBF4dtE9ydKTWQUefCMsjDr1tGEMBMHQzDPnRzDMZn+Ms0KmwyF1DFVlzFBCsBBhSSWdi8u3pxmlhhyFpP5uTAmIdZFbWIHpRFdPu8yid9WEdFbUxWRRp6BDVwaCepEfxoXNuSEdufy5hHSaS040SeXTPFV5HIiv9cENR6hQ+aRV3XcCOomMx0ZZqIbWY1jFBIVpVLRYNltkalwUxbXnEskjeWjunZWv5Zg7gbwaD7cVwmfjVWq9GIYluEeuElNlPsEKQ6FPxKv5vaYdtVtYEsQiCXR6upZz1ZwUyow0ckwIWqqWmITREpl1p6mnPpofMrQkusuvCmRTE2xsy1Tjm1awknRqzVfvI0horlNbvMEIlRvDLBxcYMaMQMggwMm9jWbTyokkXMTk5rxCk6zQhXx6mlbuN7wuD1wYAcnxyqnf57qO5ZyURrfBLmAHzbbigUWNaYv9EatgwhF24qE8zmQmJVaxJaUnFJz435Q90MiGRkAeTUiPX/5EifJdDu6XKE6m86xrhenHzLi9P/SVdbCcLIpMblJYiKFZ2t5QDu/NHyrBD4IRSnu2ryy1yp5J/niWmPipecWZ9b/UM7qEwojdNXx4X+Rq85LcgM7WdC/Z9ONNB0WqfQFJgRPVHFXJpPjbkgvRA/MRR5ZLLFaL6ORrptLWcvbWHjaM3hSUXE1FSJfbjT/MX2rKhy+Vxz/J2RzYN6TEMV1rr3SqdEZ79khGWIRUpS3NcPQSE4ExO/fL8BEGeGW1hftYILKKVGvdZ01QDU9W05dncN8EHQjMCTPcJUpME++Uilq15z/NZcymz2pa+w+oFxN3g4JDUuqxAiIhTeR1Fb/73ZqaVj45pHXvpzULrcsDycS+3MYNWzUMuOB/yuabnEEWABCBd6DNCone3clbqld41NLIlDCl3aj4baRJPdCQEjQ+F9qCvCXAYBFrCC6VtRmVRyZjRXZvezFMZlu4VQ8rlqQuZGsVppvp3QtZdS0cfY7olld3iJ/F23L85vvBRrJfXIhCixc+WPOoPgTVF2o3ykflV5scYAEVBysCxRrUxD1RR/qVV/+2XK7WStUadMDbAC5VpRsrzHIRSNcgqKGRXjyudO2VZpoxmCs1Q0PM4UA55VSZ5ajzZYhQWL8d3YXAilc46X39xaDEBgcclpeEmi8OrYqitR3QiVDnblYP9eYXG4TWa+RKDkM2oCME1xdojRd9FcUUEdokgWATxUUIKUWowJSaVGVoto2CNZtNK9tkpJe4ttn3jJa4Y7YnfKS96b6Hg53nJm4OATxCp0clN334ZLboyeaqrVaYSoaoyY0c1XoHQNmf5msTftmS7NoYA+1Ot9d0ImZKtKxM0Y5e1s6/28RpX1daqEAPZd5saUPl/lpcIqlv52o+Q2gdbU3PvpSIaHQw557JXtZ6oaejlV1tSeWvWufhWWfUg26ssm5eDOb7TkAEDpkw4Ai7aa11al69FzWq47msPFZfKFkE7Z5u1kTmyYyVJrdLYFrkL9c9Xegxg1ZsQ92DBtgk7/7LzqeO0LT9rtxe2ThF4TB5T82EP+FT3/nYWffc9O6VvsK3U956jzxVaXZsYxX7JtG4Ci/NYdwnfQlIjkhX2u+lxIZk0OYJt113g3r2PiCKR/2wCvzc3SGG+x2oxC31r2FV3Tyasg3Nk4eNWxnI8KKdhx+4iyquIxvvIBnvRFHaWqhW3NTbISDe5WPZ+AjOtZFQA6f0bN+6/I41uQFJqvCU0fe3uXDrewSb6V5O8YhehgTviwjpdVFuZXZNK8K/g87Nt7dlptBHFID0jCmzs4iGXHPmKLr1pZVn/uzqGP6exMXLhCnVO4SGYQrborf6F+3M9GFXo4aOJvzY/JX0nH/19ZulU844mrod1DtT5uVIikXi1yL1/9b71b+/a3jRTBgC6VRP3QHa/3paWkN4/upWmomCSsACFA4ECBDgIcIJhwYAAADR0+hBhR4kSKFS1exJhR40aOHT1+BBlS5EiSJT8iUEhQQYACClcGgMnAggUGMG3eZGgh5cACA3D+BPqTgUIDCQgSwGl054KgTZ3CXKAQwQCFPhMcmPpzAAGkQB/YpLpTAFIAT82etYlSrMAEZdG+bQohgYIGa3sGCLs2oYEAUcUigLmVgNgDJg0fRpxY8WLGjR0/9phX4QGYdRMCRsvgwIGhLg0UOOATblMFCbtyDYowZYLRZlUTBO2y5f/ArjBfj/35FaZaorVb/w7QeS1l4MV3pzygAAEEm0r1DiS+wEBKvjd5pyzAEPJ27t29fwcf/rHzhDaFD0Tg9untlJiNA0XQ0kDNm+pxnof+/id7gdOfMw+APIFEs0m3g1LSLyj7gCotpQEiSIDABGFasKnBEsouJgIAXKBBnhSYjaDqAvNQIN8CuC4lB8RjsUUXX4QxRsMkE2iqAwxoIMSBJAzqwrVOnNAm9eITwIEIgiqRJx4rfMvHgRRIcqcjA3BAKpweUE3HHYOEyz/TuBytLCKtXCBEzKpUSEsBiLOJPwqheq4nGeeks04772yMoQG85Ewv1p6yTCyDwEwtoT//cdozpZcm9HJAJ8X6EzmcKtCLKULNinLRS8/ir0a8FIrwuS1vSmnKNkUdAE9VV2W1VVUhiCAC0QZggLlGVzPrVgEKmE0BHjelUaCmOm0NwKCI9PU49NQUTVf3AiCA0rWaig+0X/XziyBLA0NAAQuuLQ41rVKiD0WFHAiWp9kKKDew9m4aAAE01zLAVXvvxTdfxsh79lEHzUpRAMAGMHbTm/wVYFucAhbgLQiyBNKpARKIENqE2PS34AOk3enZm24F1zgC1vUtWxONm5higkyFCeFtO/1MrL7AVbNck5/TN2edd+Z5IvxwO1AvNiXW8S6De/wXqJ9HzPXLmwp+ioHp/xw4FKYIZjNAYRQ5xrDqmwRcc9MFtA5A1+I6FahdhAkEWy9N4R1TxI8nmzehnu/GO+9Vo2yYYYFyNIDlpwZoMFmzFkjOa+O0ZPqnQE8+y99BCS8o4tYWuHYArmlzKsoMjwYrJcufQvhJnBh/WiwD+CM76MlsIkBXAVhTs2G9b8c99+/Kpk6sBkCHScDR4brNaGpbaqDdpxiGSUvluQTghJ1C5u/z1piUuNTRJq59oMbPMx4vvoUdQLWsgWp717QgDRBB3d+HP/6QBligIYbQXsvjp7DPHlS4CEhAux4XPi61rX17OdoD0qU42FnJYAtiFlx+JimcyMUCgpsgT9AiO/9hfUosPrlZkcoiPxKW0IQOYUCIppSu54AufSGD17wM4BN/DY1LwaIMsQz2lXcNS25v4d99bhQanDzKAqPpXkJaF5S6IQeGzdtJhkonMAjwzTIFaMsJtbhFvOkkITWBAAfXssQJ+U1/QGkiX6pnMCdVJ2DWg0sEPkPEoHyliUBrimYOMLziCOhG1oLWdIoymgw67SwsrAqgOtYy6iBFVzm6DBclOcl7yW4ld0TV0ULoqaiRq1Nk1I9cEFCuYJ3RNUosCwMQULEAfOVRgwJeUCCglyeS7jmNe8omdfU2oVAQJkSJyWpSQkliFrNOEdgJ1UQFTNDx7Xk/QdgepwcVy9D/kVDINJ2Q0BJCvjQKKboZmUAMF6YgNsltxpllC5tSITXp0CkEQFNReITNgViqU7VLlTH1uc/wjA9Ky0xILRPEnt+ZJV18edxAjkgjON4wAQgApVMYxp8BGAgvsTQLPWXmlHL6TYP/u4w714mXkCFOObOKYkogwE+WtvQx49MMQEcVSwbUpQCmBEo7oYjAKDEwMOJClECN49HLWBSjorQcIhfCUbMkoEoOCBhO8wgiAyAlhDbESTmzepNOHSChAnFpWMV6GIQdqZDYeSZGtekUjaYNJrtkiUvAkoCueKgA20rUrnzao82kFXbJUchXBWABowKvjVBT1k6w+h7yFFQ//14sCGInVLvgOGisl8XsR0rkAGNBVgBZcxYfg8QAv6LlOqwpE7mo9DrXCSBJn9OSaN9KkMXOFjt5PUphQSfXcUVRqHCZ2CiBotWgaEYBew3QARIAoGpZsykH9WAkMztd6lYkABGAkuIQt0c4qQSjPiqAbJ9LMdHUDjMBqwlRBXIksMFSogqJWJRwlJVH8UW3BmtrB5NCneUEaQEUk2xxyscr5xaRPQhoFAF/0jbWsBBHDrBWdSU83TehZcCDfMu1YieQIxZXIRE1ZyJt8jjMJBE9rR1IgG9yR6xGs4hoOgBz7ruptv0qvwL47VlKJF6zQKBoA4jXSW37nNo2UMRiVP/ShJXM0gdgwH5vIm75VlfatMxmaI9yLE6iVOTR1NjAELWJqJDCMKnu1LunUxRQCjbjS/2soQFI5w/LKOL3BCxJiAPom3HCzOgOZ8l/1mcGOPCbRwnuJylybM3QyOf3IIyXP0FykdzFW6fwx2ssNHRujENcnNzKp05S8OIcyJDiRLpIMnUv0pT0NVEB2tXE3MADNIBEhTwlJUxJ1xm3bGEECDcossNlETHEmxnaRE1l7vNne4uh+tRRrafaVabBggDl2mQB1RQNAeiSlbP40jimlqnADkltxSl1IK9G9xYZMoEHbOAtmxzdAn/pv14qsVBFAiBBsgwvwUY0nJ8VDeb/4JW0wZWmAB2GNJ2dwuZnn+Vm2blOqBNuKLhg78ZpWmawW2Nq1qTb4/HDCQcusE3RNQXeMIlSgDVamwX0mimCJYgpNyntoHZu1Ngy5FMY3vCnRMnOTf0qiJuNJNiITiwKIEByVngjpP8Gk+35eNRvV5+yYIACGDiLmkiDHbDUjY+k5apK4hSUdFEZLRQcgAUKAFUBd6vAC+d5cdQkO6IlM0hJ3yOx4CnOAzgAwzfBD7J/YmLTSN3wPQvKBC4w6CA+yqd8u2uFCWABboc43E1JqJ5bIykfEyTVQWLSzstoAAMIPngtMdJq94KgpiDZ7K3J76JUbBNd5TgA40tJAw6///t8bddysZ4AqYPSIQMoIK25RgsBzA5zWmpFVzxez4fNRXGMil4/jfo8UDw7u4CBbd8D/xG8Zo+oBs1nbgQRaFnk/VwCKMzcIuJ9/Ft1m0cHQAMP6EDFf3LypzgnvE4BN/iqoO5BLrIDKryoG+LQFY27FOszDrAps3SBABLbMG15rkppmdloAIFyHutoiXF6p+zCFZxYAAYYgEAptu56Dt2Tvxa0k5/ZqwzIAJS5NVuiPqDgjxKpHeVJnwGBC7tSmLngriEbiO/boaOJGzlTNXtTJQT4N4EAJKdIooJ6FM1rjsAqDtzzQWt7OqaZIlBxwTCMEflyig6ggFkLDLp6C//2YMARe5erWK7QCajgciRmwwn8ETe0YA8rPKCVUSsH3DjVscGAWjEEyqidWBRdoTnbYL3AEKqLy6ZJEwuF0cIv4r0JyIAOEEMYuaPsuwl284DWEi8P2UCzIDyBwCvLKMX6GIAQibyFGY630B4A1De1AgBAjCN6MUVDVEELNIsNuykIELgwY62m2D71wQv/+D9FsgsjCz+wOMX+kLAJkAAK0AgJMIFNBA8UwZEEqB0uswkPOAESIEThey4TRAvmg43RIAAnJLu1WMTUkYpywq6mezZcXEO9+Dp7c8aj+Ikne4tjyyWi8InYegpToyFR8Zi0cwAHuBGxKIBprEaNeAD/CZgAbeyOuGo+2EEAlnELGxiBEIi5MImcZXo9y0sITwwKNYG+hrsvTvOhtag/uKk2RFGpCgOOgKklsCkAMuwLdESz5lPHj3ouK5JIa8yIDZAAD8BI7sBDgINGntAaAfiACiiBDxAIcOwjMQOTEFKA8dsvz5uQBbCAIfwfA3BIHsHHzNAL3TMO9tDKt9gxtIDEgOKTsGtLM8NAnLxCcjlKjQiAiWxKyCA837gVOPIPEKgAcixA4zgrgQDLy/GP82kNYrO9exMnuNi+dllLPcwf/eANwIDJw0mARVyQp+SJyyBGu2iWZYKh2omACaNGpMwICpAA7RjMxiA8Aim7gxkI/xKogB/gEgJoAAdQAEuRMs5IEdP7DSB7LhAbxr5IHEKjN4NitM7MjOTQEokrlrjDwXAjiNUctgNgmS8cCJWct0aqrtncCA+QgA3IzX0hMsDroZY5AKzJgJFLEOFBn5bAoribwBM7C/LgTqLjRUQJQoLDTnZEExD0TkJ5zLUQDUyqv+sAIC2JKHVMHtwcK/bUCGp8gPhUjAyalyOyj51ArRBJQavDOni5z79zijgjygcFiltBtmB5G+fEvHOBpnWhKwvgG2NZ0LjTNrOkUS0DT/1CGM2DgANMO+VwqiKRFYoBoCmJUIHBLA/VCBOQABFNDMHqCnAZHxyyCcULxV50rf9Tkj7gIUsj9bBaW55GdA4HXZ+LuYnUyribGNKGa5S4bDjiLL6diJmRFM/wrMznQArzZIvL0tKM4AAJ0EQvNYzaGR7c4xuc8IAHCD5dAaXSucy1AhglRB+COxbWE5DvWaVWLMdkew6F2VObiAB33JSAsZz7dC2hu5QKLEIgmxcbuqM2bIplgoD32xVGFUzFu4BkVdYLYMqHUMpmldSS2AkjZCTfIVX7o4AOqE9YbYDSkx0+1NHi+BmpQpj9oyrWWBq9hJwAeJyrECcJ6UERKT21TBCTKdAeIQAYYrEa5Ucajc6+yNcFE0AFWUI/0Ui9MFakxAAJYNiGZVjabIiKvMj/aCUJFtI8LeTJoMgAFMBKQrWJShQAv2KAeMLV70zJp9ASG8IPykgoBgAA5Js+9MPMtfCpV0Wdt0ih/FhJSouJHDzS0bgN5rzTZQIMRV2RDhXMa8xGipXWNFuwp9sRT2sKIghJme1HxbrAVR0NzxmcEPk+TkWRD9yWWRRI+BCVJdrTCRIqGeWk/XCJBmiAfE0ipho6f+01HmlT0YrG00AyAkjYjegACeAApi2JTnke1FyTKjoxqclKYxmAqgSBgWgX1KSeYtSKBikwsJnJg4kAsoFZkzXUAPA28JPJpthThDnJjAUKYuW6nwVNUd2/W8LL1cjSpMWIC5AADSDckrgV/yBh3YaBM9HAjxEJixJYTGUjNTxkF6f41XdcR5xook+FthsEikB5Rd5JCJrL2Xfduzx0tvdIl3yE09W9zwIIQO91XeC4qq8hPTqKl6f7SlgFlRLUDiATq0a9CBEQgd0tib6gmCWqy/LotIF1jhCoWmOpoeBATrWDqoL5qvqzNFZUDToFrmlyiv86kVd6Lp9ggA0ZjVc9sLdQXdgJoKCU3fQ1C7egFQlhHpRLCMNp4fN73gDBmnxiKfytiIXNAP4dCdKZjmhMU22iIPKoyhKQkAGSkM47T9/8op19YfxKCYRrjQqkYOmAwpaEiZccDbX4T7jQkkPB088yllN00/cYTf/gwC020aEMQopgURxKtZh1bCkcpogMkAAn4+HIsIDiKxf7UFSFS09CDZYZ0FT2nVdYpN7TKqLPgCQ73ZS1OaSSlUN//OCfxa1n0ZJFeUqhReEm6jB/KSi0kSLa4ldF0ZUs4ic6ngguzePIoF5jy7O3C4BjJJAUWYD7c7emOVC8IK+wFAss9uJdNtCw6T/S6zVGQ4tXTRD6ETaFABBV9Z5AkWIU/sVGvBVLSaJtASBw+WMNumHbrQgNkIALaOWOqD2bDKyLIS3AYaBG8RoGUIBDhgmR0+Va7La1mGa+fA/wqaWE4rKh5EOvQOEF8bLA0JF8leSjOeM+tNqwFYAGQM7/tTjJ25OpwkhlcC5nk4hjR57klbHMR1msyas8s2BRpwCbxtxogrgKMAMeuSBPh7tJoFBUYBVoah7a8Z1lQJ4QruCR8mmAA0hoC2nE4ZsWuIhXDPlmiM3owi1dGUaPlLwj6W2ZEjZTWizC5KvBCWFmIBpEX3RbvYjHmnY4AGtSDz4aGyWVm0uQJ0Q4/AhrtEhZsxCLt/blIpQdlgoADoDPpTYJ9QpZeDnoaCxAvDsRaAY4AoCCFWiCpqhH6NvOCdneZdQPtZ1ZKPRYuLC+8UHptxTQQs1Kt5PqjmYLdQVe/cCtmQQgpDhG4wOOL74xBeBr3hOVfF5pIFsm5CqRLGui/9l4gRE4guFsYtNeU/1oovqTo9fhaeAQvXgF5u0p5V+uMx5FmOYGigUI2NUNEXThDec6Y8oRs9g2PLZdpKZom6gWauo7qw9AgRqYkAQgPRz5lgnx2WWum7idOAwJ7SzOurUoKFWKw1hS1PfolNKh7tG4leqgH8ugzLNYkE2aDPA2PFEpLdkJ49mxOUNUVEJGw1KDXeP4KvQ8VJW2DqLgZAXRYs8+WW/6Lg0sudYYsLkTi8jEuUQKFulFXIuG8I9LEV4h5eeaOzhzuwzlUVYlCnbL5d/oviDhD2ptbWe2iX2dENFDMgWgKLUCoRaHCyVuj/GGCwRbHVk9mHiuPNSNWf+dJTtwATe/zfGoe40ZipfiGx4OYs6t4A+EG0rMELngC8SEYPLhuuCBXWYsV5PNrWSzOKtN2mwuURMZH3EURZgS1xXj8Zx8/ZcPL9V3/WqEXXOp24qSNWydDgqYC5/XsNVVg4mSNnAsDBKNSnR9RmdDiuAoT754IhnRVetYaqsSx96L8QnxLu238JvqmCJtc2SfrGvkvWlNVxX723R7SWGnFhFcjfQoRJTAKN+3Wzy8oLawDhjLcIACPxizVnSc/nSaxmzgemYCuSNw36rIAZzm5iDOKnMBoGtol1n8MYjXQDh/yTSWFFi94FA66YBkxeNmX/aforIEgLk5x/L32ID/cTT1poBaCzeYrRCNspagV35xXYc7/agvmzbqv2iZz6iq3xAjpsBDsDi0HreP9YOmXtNV9KgTDLiAdgt4g78TFy6IzDGxiW4bPz2LDxiByP0bgGnfNNmmJek577HQDBuioDYOZf63+AV5gOGV7glo09qoLxypeBnpPQP0ppg7GdGADHiAUMT5VXHvQXKTn9BCEG/mV34ul0OaDzDejhWqgiZv78HVp8xv4DmBiTaoqkeL3Ub6CcEk9+geoI/Jj0KwBr7D3HuRCeCAB+CAiU17PFG9/mjdtPat0Rjq9zIdgh4IAxZJoUKY2atCsHw/xidJlDEAaeF4wm8N77Nc0BzU/5ti4pNNEOtligRzXMVikQDI1AzQ3cxnFb9u20B+4inOOZOrzo4GzhKAC5597oFoTAe356pvCY5B6XCl/db48AT7+7q9FvJIPf9SQxTzXjFyWe8IgFi7gIJHflYJwFQ7ZRC6bqdfHaHij2ADCAUCBg5E8mBCgIQKFy4kQFCAgwEMEwJQ+JDggYkTIVzsKACBxpAiR5IkGWFgBYIFSDJwMNDAgpIjK8qsaXOkwIsGAiQwYACBxJtCJw6QSIDAUIULFDhogFTjggIedwZg4JFgAwBat3Lt6vUr2K4dLlzoEPYs2rRq17Jt6/Yt3Lhy59IFYKCjS7wLAVh9qCDAgLsDM/8mtZnz4UqNCKQaQKqBQgeFNENCSIDgqcbJeR+CLHngKsGghUfLRIDy4cgFHUWTJj2AQMzWARxeTCC78ALBBhgwHBC7JG2CtidKnZrQNOgCdddiyPBgQ4Dl0qdTr279Ona2CTpGaNDRwsQF3h10Lo5R8m2GyP3ezJAh/cLtF1njJGggQfECvOHz53l6YGIhfXYRYf3VBIF3L9GX1GECUGVgSQOsllBgwpVkHkEQMBRcR4SdBNpf2QGggXMeRCciiimquCKLyzGQIFYBrEcQZiJxSBCECkGAoQC/1dTBAxqMREACPpZkwUM1RkiAaAsYmWNrUqU0UGchbWYflCXB+NL/bQQooEAEQhFwgALDkTbgQxnteFGCjYXnkZnHgSZAUHMyUBEDC1A3AQcPcDBBi4EKOiihKt5YwAEJbJkmSfKxuSB8A+S0W1ITPKdRXwM1cNNrSmb5KWAJJApVAVMWGNKiAvwFqkYSdvQkhbBBiaaDrQn20E6OXqWkqx0VcF9CN160qrADIeWofnQF4MEDGWhQKLTRSjstWzzOSVCYNl5VAKTwEYBAAhoWxsEFE3XIKrpCZSoAtxqdwCRwHe2XrkLr0qjRYQZ0S9kCEk02kbBVMtjRTrQa19C1hF15UYCVXRbAAvsJO0BcGzxwAQbUarwxx9D2eq1OJFk7GHxL/RrB/wBXemoTBhRgoNCHFwH3ML2y/asRjw8u9IBNM8ZZ88ehTdRgrTWhqYC4GhnM7k0QyJqQriTPeBVDI18U0wCpcklSqge4hQFZZnU8NtllYxc0yAM5QBJoOpNmr7WtXcCBnBOGlLJKsGZW81DFLsizTQMkkMC+6BK9aW8erTyRwW4vRDTTNSGptkRL74R2R1UxiXlHVQpOMJgjLTzQiWiReKnZqau+ely3pk2ySPbimtTNAbi+a2sWTyBsgBrd3jvf/BX7JODBN3RAAwgkTdJhqzIku6YkcfRqQpM7gFTM58kU9UqQJ0aA1aqap3VHtg2AgAIILL01vh5ZcBafD3gAKP/r9dt/v1ecz1m4alf9XJj+OCMbDTzndv9TCObmZbzCMEABBXAKYDyikeItcEbtkskAGNAt/TkPKooLwKLC5LoLXqh8U3PQAQxwgBO+hEfhC032BGAZyAlsIdATwFcmwCwOPAt/Pvxh/SCAPo98CQEJasCTJDWYAYzMcYWZ3rUOmJQMXEAHAJJiQvp3ESUtAF4LjNdDbGOwA1IweFokSAcXAoEIEM5ooNlXAs8IoOM4AFGFY4hHlPdCOBXrWuDyVQAg5zia3M5YWwmAxTKQMSAyspEd685PoiNH8ESIYVEbyB1vUkjqpadlOMhkADwimgpF74sjsZaGFgORbE2kjHz/Y6FGOHSq+nhEgUO7yNouSSeSeEmF9LGW+RI0OgnqkgFGPEBMhKiAA2jwKi/Sy0QqUiyvjaUsjrwmNqW1pQJo6HwNOAAoA7A0BNwOcekJWs6iAx9LmagkU+vg7dJoSqVcBZwlKSMBDPDAxfUHlomrTU38xjX7SCSGpBvJ1GJCk6kB7zVpq4pHfvMaBUJuIGz8zkg6EoIVoC6bHv0oiwJWGGs1gJQOWt5tzrfMBUQtnCS5GbMQQpL1nAp6Lk2XHB+yNpJQcGr8hI/szBmUE+40mhO5HUyWpECCjQRtbpscRJ7Uxy2GsnPVU4kGh2kfDJGQIRUZUAhQUAEQtACkZj2r/4i8V5hCrqqLeosUd3L0mMhEaCIG7dE8cQYaLCakeGgDnpga4EtaEiQmAypABNZnEwQR8aaXfKsuifI0jaTNNnn0z7DSdoAC2FEk+AlBCUZQAhJQCa2mPe1yhmnLmlzypwaCKpag5J6k5FQAKM0rROvJU4UMrzAGeytP9GlPpBKsKAvxjUg4CMqlEeZbNYqsUHR5Ed6kSiJ7BE0NNRKD0KIgBB3JCmrDK161VLUj8qzJlmY5lNoxD5BZApKQQnIzBkQgNwTCbavWp16GFG94N80iU9GjrdcJoKSMhd2G5gRYwKBvuMXdTAFi49SkeMkBCljA1KgyyYQQ+LsimcAGTv9QgRB8ADR6Gi+KU7yVGzqxqZstAFPU5lpOuTPAWbIUdEjCRJXcar/4rdtDgBsACibHAgc4ACsRKsGasNBBAGLY7bLbZAstRI4RgFwDFhWghN5mPUhDYAohmBCtgmy/YznBD0rsRxWzebyc8/HdwjfjkjhKAd9CQBI7MufbkEtkDMvgfxe4pey2EmEga/FC/Lm9ehaFzKhJ8JzSWEhh3RUzBBCsPSMFyrsybGk+OvMMeEDgBLS51Kjd5E3XF9vRSNdB9LEvu/bcSZeFBHp8/TFvEQAUmZRxABb40pwomVwPH0i35b3WghJ2XI9clCB4/iB+FdwZnyWkOX7yQYcHAgH/U3P7rGvC6k1ajSPSXMtth5U1f+amkbuaE9fpcSWQPbJg9cznJsV6yutuq+qB+Ahz5osAyjhsN9xOWWeCiwAENNCnDADBS9k2ZLcj7tEdAyicU5XZaAKISYXc7inshZLuGFLb87pbKEJcIbwDwOlx81IBPwm0HJ13Qh7tV3//sxak3lmYfD5wta0hnwAUqMNmvayi310feCWu9EYiVSZQVDa5r/UUYSH6UwSkq0Kshe7ZgOu2EBrAZh1wa3oSpAKLizSrfO2TnzWISZtpN73TtGuA3TckNPUtVfnDgPV1xmJlUci+EYNZnSy98D/EXEwYUKSJPDNtVa+J0YUmoyUb/2+2CGQTp1T2qaDBPSSuS4mATDxPltaIAZNtSCEJbcMG/Ep9B+BnoOOtEgHLBm0fcMIFLoXHtPGmtggwPPDrN3k930pfvI00kyzjc9rvxXcgkj3LjdcBCsQ3AEJcu1Ag9ynIuTZoKfGUwRyoqth/capCjvfjhTLl8wvlYyGoQAVyINN/XoU8SU5ViIKvf7LBFpeYT8gmzZE69UfjYVwAwlm6sFNrPN29QIlHICDEXERKcNaFUYh71YvLKcDy4ReZQWAEXoTqJUX4kN8phZVoqQBehYS1FAB5hB7h7R8MakyrVVSdgEaSGYhT/dHB5FVMZRycZMkDllDZTdfgPURQtP8EQOXVa9BHpIkKFi3NvInEx+nP2vCcAdygUAAAn5hAd8XIxzEURWzIAVgAA1jLncQgGkKL1bxeLQmcr2ChgVxc3pEGz2ngUOAHlQTAXI2GtbDfaCzNBiqErkwJlghUbQnAPB2YqixEtmVaQihWeoCG6YGgfI3E0P0dHgqAB74TfUReaaUhKApK22BOUECOH1JIUTSYHxKAo2EcafjUTUwNYVjeHf4flOCN9gDHXZRKR2hIgJHP1pEGe8UT4D1cgRRLIN4EcxWFKN2E32GdlwUUw8QHyBBAKF4jiwQgnRDN6yWABmHI2CGQ1sChyHWYB+rYBcpEMwYAfCVFBBTHOd7/RgIsUzAmACGOG4dcEGgEI3/UVlBAQCFpYynZzjrKxmFEGGCMzJyNxXPM3/Ct2kgUkpkI5EBgo0WKCARYwAiKExrhiuCM4SkGQPhsCFNUYCARmAF4nUzQRG/JBPRgRgtUwA+YZMnV3j0uIoWoT5xYjSkVi53xlgXMnRymoEha1TlFAGY02U9Z2/xQFidl1LmMma8kSelcpFUuB8VdxYNAQL+YlzvOCWZEDVLskWW8XpcUJDrKS0IIxAeUQAV8QDLWZE2cAGLcEQuRI049X6uAjJlYC8kRha7FpUJoVUgonJ9U35uUjxAK0CPiha5tloJcpWTOBdDxG6S5ojLOCSsB/5JApl9vlAQ01cTvABhBhMAIHAG6fFyWPMACkEk4ghCuhKRkyabzXQU59p+ecRxG0dlDdJ7nQZtCDJ0iVZJXztTATRnDTKZyvoW8YVpQTAYLFQ5yxZ0zBUtEGZRgCJtMoEkIzgYRBo55IORDDgQJVADd9EcCuISbRMopphxL6BoJNibluEYAIlompuPElEROdadCnJDAPCMCxQZNKJGDiAflEZYAWGMxvg6pLaeDpoVWxlk6oscC5AViLRtoNFdEcSSVZV/dhURrNoAF/JfpRQACJBkLhVx6TM1r6tit8GdfVdA0tgYuzk5JvOND2NJ6FMCc4WYUMoTrIA5D5lhCIP9hrCXEtzlbG8YSZmBYuDBE4BHIg05pWJCPz42MI2IoVQbLlJnTBQpOG82MmWCOSo4Gh/CKV17dbTDgQbXGwsCoe4KKteBlz3TO+cydjZyojciaYiVWmIbEPIIJQzallhIEb5yQ1khVGKUGgf0elT7qIVnN/9zQQPYnU+nKAYxOgcRQMNZo0HmnWpbMU8YbCdGimS7pqWbObhnPZdEoV9FKPMojwWBId1rbn9idh6UKZ+kEmErE+YQqoL5OVULqlE6Zp8hhGnmP7FwSa7TmYA2FluVWvcEH5MjT3qUPSk1ffKnmSEAPbTKELt1RnH6KtaynawxIouRmjowJMyVEzkT/5UIYprOQRCGthOWcEaLgylX8ZU6SWbIQK6QGYFEV6lWwxgkZAOSkK4DwEzkBS01gDlIsjGdqko3VhALyIS7JRrHck4zu4G1gWY64TkYQaGMUbEJc4st4hnEsK9Sc6FCyz0y5UIMCbMBORbdEqQKhTQQEZLAEoutMLOaESVYaH39Ua1L04EthytXcBs1xbMcqZnrwbEkwgJEJ5ngaC/1dRAsAqDRC24zIkyeyx020ZpkMK81O6SXxJ24a4WV+xEneF7derQzVhLzBWBd5I4Tk1LfqIWQAkPrgqauiEa/hIAFYLUBWbGvgpgfSCr8OJrxm3UN8AAhUwAkQaYSozyYJ/8yd/gaRIAVFFlZrnO2jFqXYehVREKRfsNdRBIXeykQh+aZizMm3Nuytgc/CtoapzpPphdO4DgVUiedAZew5DVxICMvY+eVEyMf7VcBoQYoQNcBP8kRl/ujQRumREkUKRe/dmK3oTuYJaWdJKGLjNkR+7Nnr2sR92uKBXEnVmV7hpkc7yqVI9G64qWrzgetuJgVX9kabnJ8gqWwSxmsNnGAeEgWGWK8mnpJOXIvP8QUlMg6AjGj3OqjUcooXjW1InlCLIikk1mkAV5l57FfchgSOyW9I0K9NAJNMXElXPSyBJvBaheaw2ejJLhwGnA/CLl/Ymmzx5pFW7svo0Ee9Wv/jBEsmyCbXpOwtafBIoClaTYwO4vwLj8DoTfSZCfMXf7iP0y1GZ4UblhbGCRWIaipRAViAhlxiB3iT9obEwylA4QwPrVyPdDKbDZlYEV8lpVHIbfGIEjcN5JauTeRUrAIgsS2EQf1oUrRMyl7xkGUx1ELJytlWUmTlxgmF3+UYJYPv7jnewy7ZmJQtcV5Eks3gHV8lrHIoDENNcUIJAwhGA0CX+ulUmeLqB0MfIhaGRhaYkagbI6MwBgFnjrzQ3oLdQLhxTi7TvgzqBBgoRIwqQ1Tmlh6PWT7OAw9FEBuavJXyVS5A1aLyQKpVFmVgII4w2TFwUlzrBi8E+8bShNr/xO3YkorKJQScAJ5VRR+/ZJaw6bTehhwpCVPK1CE6m0gEtH14SoPAHXeOhr38D2gknTZfo6LYWT6t49Ls1I3QqWGkDRVDCO2KBI+ks3WGDJIehZrWpEPcpH48EVpCyJzAbmGMTkIYJg8xRNhq8nFtlgptaBgW4UD8T3xSSPb63A2d4UODIupKXZFCrSj1hMMOxXWlsruZ1EZDsKrOSATkbkmQ891kalPfzX/ss1AYjEvDh6ql5HqxF9qQQBIQHRubs0wIFDUi7qVZmNUa1VvTSgQU9TUiZ45aquBKq07RMMUyjLrKZQa9ogRNjLaCCiVXHXLcZAEnxdGgi+ucaB97/9BASC78yYCf6WVN5My/9JHOiCWrmB736vX+PfXAMhgCzIu4dSj6lo/wMrIP3lchZcTFzkphT8TkQDZU09ZPq4ueQokPTO5YlZhdmtevpPO6tHAACkw7jwa3qtL1oDYaPnXhvLZg2wStFAlkjl/JkbNWF6FZI29CIC2ElOtK0Z0A+PZU03ZrgM0JgABpRXZEMiar0cwm/9nxObOYCMYBqOQYWTcMru2HaoR2b3cggwsxE4RNw/dQnM80w2Y18+0i98cLeYpL+DZrjDeEy8TpzPSL/IqsjUk9Q0m5skZLnvNsEyy7EPj+kW79sU2HwePO7faH34bsLAgv90eUEoUCoP80PwLqCgU3vcgrYuqYkQ8M8brh7I3GpLH3fMB48FmAAdTRJiGgxs3JxD7zKue4TXCr7bLL8llMkssGBDjayjyARDjN8vVL+2EIRucVyn7mQOtGXa9X7DKMz93IkDt5Lva3zFB54VlZq1JGuTWs1g1FBYM5AIWHkJUwemYZMCvEuGYi0cpEqsyyKXEtAgnGhRJFk5Pr44pcCmUaMyfV1OpSZ7AGjzg0oUectSzNHXkiZhw6dxulMI533Hr4Tm9PcXyZUFixgeDcBA3JjIbvD+LakO7lHC4oo6RLEGY1YPd0U2lj411PdKzL2sS60tma64zd4eL6tHPKqDu6TMSQzmj/tSLHYYXvzH3Xslc/so5pUJb8s3zp6lEhrq8LRarw1b+gGgLp2lMAXfp+assSsbdL3F39xZ251J3FxOpWjQwHsitf9ocv+lBMQI8DFeuZa6GJRLmTxOiwX/MYiEyfubkc6FoWcmknuzouO4foCxEBxSW127fYxsJHnD4jvIFQDbrzjT6/907Hc7rEqbVs9I2cI9GMr8Uyy3DSLcuDajSjSysX8035TwRllroqFgCYVNDtfLdtUpcLBdAHfc0se2GU9NGPBLPaxNUXQDiSImmgsY6I5pf7tX1f8frEBF+DrtzuFOSIfbeNzPb4hPLgvfpmIdrjHWaOBlavJknQyp+7/2Sl28QG5J7lZiKMCktyDc6Sp0uSFrMt959QKbWeEb6pra1rbRMo5RQJ9nvjE3IDFm+Rl8Ris0rvDgBSJhpnZSmNrjTu5x6h6j3ps4Rg/KXsp8YFg4oqyb2gY8ndGbLY+pvql5qt2d0XywQzC/vs14zi0amnzlhu3+iVA7/TDnbFvTU5aQqkLEqX26pDMuK5300CVL5nHDCUkHPHIZD9Lx5ABBBYQEBBgwMAJFS4kGFDhw8hRpQ4kWJFixcxZtS4kWNGgx8XCAQgUGCDjycLkFS5cuVIli8DMIjAAGbNlwgMNCBgk2dPnz+B2lRwUsAAnx4uTOh54GRIoA+CBkhA9P8ATwYEUUJgCcGAQQNGeWrg8ICDBpsEiAqI8HOowZ1Rey5IKwABXJYDTAow4PRn3oIJVhIw4OAA2JpoPzbouJhxY8ePIUeWfBHByQYvGcwtmNIuzwFdC37tPABrQQWdUadGnRawTwwUMNiUe9JAUKhB237kDHOA5rovFxDgC3OChwcZYvOcmvYtz8onDasmWRrl3aC9of9kqlvldoPDXxJwIKAAgsnn0adXv579RAjUBVRl+VxzgejSA4D22jm3wdb4BRoAApcATA2CtH776QIOaqLvI9ui6q8gB2xy8KTT7NrggQs6+Ak7onbjCT66Cgxgtrm62+w/56j6ibkAiar/zaf2aKzRxhtxhEjC0FQUaDnNyCvxw4/ucxHEAulTQKsSA0TggOZYIlCg8U6iiQECinxJQ7PmSwvCoBD7KMGXvGsxqA4ueGCDqCz8zsiT5CMpAazG/CmzuXbT7y+f9JzQpyEN+q1NAf7M0dBDEU20IyADjYnRgqAMgIADnrwuuBfhQhE/C2Us8Ue9luQpzIIaGIDK+HyaQM27iMLwp9tw+6hTmAYtiCbX0vRAqbuyJKlMg4I61aC15LwwqgPn+u1O7mwa4NfQ3vzorU+BFUpFRbHNVttEH50QRNZU8ksAVwMQ8CW8gOxVRKIorElKntK6FUBAx/1JsIIQeO+kOmvi/+CCLg2y78uoJlUg0nOT7UmDDMjikiUGQDNA3sCIugyoUYNUKS11VVoArGcFsICkQdU9kaiDaT2JwgUO6FMvm/pMYNuZaa55MnG7nZBeAfiiVoCdCMBKgfuEbTWAd33CWK2eIIggAXV3XlE6kuFSmtCfXkuOJAIUaAABjl+ClcmOT23gaZsmGCsDhxHO7qU+J/ZpztCi25nYBg3ymrYIQg0gAi9rwtmgOANM4GyABSjV6oLUXTZgmyGPXHKLdu6WAE5Vclmn6lxavCDC4fpUZFE/Al3jk0sclNyfBu2bpwkWXGkBw8FmSeyxO46bpeI21NqmZ00XCILtJB6tyJ0RMP+pANN9RqlIo2tKS7QU/TuaJY8Fkv5rm5ofcPLvwf9+gB0frSrJlVw2wOW7SV7AdbvQJU/qleidX6BfQzxXuIs1BfPIqDS0q/6gzHoqGcntcOcTDXEoKOlLIE9cRpsEUGonI/qfShxngPedbl8r+VtTbOI4g+gOg4IrSPhQmEKakYQBCWCACOdSFQIIJ1QusQBRBhUnqxUIZ/YTSJva9baAgWcl3pleTyxYO5bAh18+0cADOtAmJQoEgQ98CZpWBZcdrc6KKiGNrHLGKJQlAAEEVMmOPNYynbgseFuLlxcPUIDyeO4AKrTjHQ8FEzISAIafk9ZdqLM8BI3MTNIxWbX/yAS4AEBgjySZnRl/WJ2kpUVg19FPE4GSgRJ8oINe7FUVTYSlBGKAYbpCjdJ2grQuCuRyCUBWGDXjQw9RBwGHTIvFokcUL1qwYnj05S/XwzIFYFIgHwQjCOnHlAJEkHHlGhEXUdO8XvlMRqNygGESoIBKvQRTS0lLGz3DgA1GhQYjCEHpHAma5UUKgZ8xCDRRI5aGbUpMYxsAEZEIS82QkIUIcGWFtEkTZn5kdOfaEZRqRRRgLpShj3GQfRIwmMKwzAEGiEAEumawtMDTRJp5i8vwecq0jDMA8HkL9PRkulfW8ycu44wq59UrA5CgAiCoXrkoaRgEFg2cQOEdcpg0/wDaBVU/rRkAAhDAT4HckFGlKUDQaAOzP7Ikm9tcqWbutpLmxW2gJ2noV8GKEXrxEl8k2VkQWQKyA5QRp6grEXw4Wi51vsVqEGjTwbrZkx2h1Z6gccDBEFOCCnxgN7UK4u122JkJLLBDq3zrSS73kbh2VQBPiwACFOAABWyxSM+6T0qz96gmVi5SlN1MWFGb2ock1KMwomRh0gqkp6Ylq/gx2RFrMoDoSHNEprNQ/kjXSdx9ESQsEY8AQjCCIZDEhLaiolY3BhcsrsmxTPLZiGQpqQNYwKU+OkkCjLkZloCLkJDNT87iVqs6NY8oEVDte99LPtGGFk+uCy8lo2tA/P9cFpKyOdIzE0m3CMnKim2CJ1hiFwCQQeq5GFRkbjF7gB3kalfVZdKCVaYdWYEFRDuS2iCn0yJbaqaIc5mfnr6CAKdWBb4tBitr0yUVIPGraOWzcFR6qGC33mV/dilYf6UTwe3VJIAjbmYAdmqZBJhRLiFAwQhK0IIbJ5C9kozSSyCgWzd2a3U1hlJvBbIjE65ocRvsjwO0oqeUuJjNC9VnoyTFzFkJj3hNzS7TcGI23DG1AMQC1JztcqUps5JRtV2JqjbQPFe1M4LXZIkGYDACFJyzICQddOEO1xN6CY6jVVWq1cCsEozN+VlvoRfyVrLRtpVOaRZo86vxSC35Crf/JDGCF5D4GhXimqa6ziqAA4hpp9LcOajdApu/hOoX+RyQN1BNDEl45wJKf8TQFhZMARTgFAcFG4OlOYC+igtIlnITJW2iiV3Vt2SsfJt+UU0nqYwyokiNqNqqAxGs8Y3CXdeLqUCK230ryyIgpabUFXLA8qbYRXoBuUAY/gixsxYg29WkjxpgbFu/e+kAWGiGRFGqcUVZrrZYNGJ8eVZIMbaT/tQFAsKqDUkJ0AA5clvGJ6ntfXcjpX6X7t759rnk0Og5Ur1EXLNq5X0SCtyghFqIAUs4Tx5plzYB+oGzHjfaLuABmIBSUh/5AAgqcALqhthtWlUfbO0JIk5L59T0/7267Fp2AL4wAKlgaVNWj7rWBeinpxx8EHQFHJ4YKe0rPzd8zQb5rbLChGsKyKqeDqZbohDbJkwHPDpTE3PdKFWomQ7AjvL347HBuCDDyXJNjFNhknAdOyGoQE1JUIC4YSx4/alkiQBOHlurBnhuH5xqauyqPv7eKnl1JNjg9nnmHJ752RrkqG4fFc8WU6IDuMo7kcrwAE+VJaBPDXthsvP/TP2MBBYSDo1FktxgUgMUaOzqayKDJ5dABWUXCANkblHBw8kuMCV0qwoJNRwoAARH+2qixlSErAqiJ/rIALuP+Dau55pvAg3l5JrkAP6pgIJikH4lJGbIQXDpOqgjBP9XYq9Q46oezrg8zrW4T2mI6ekciUr6LCa6ojzC5SQKiiUyIANUAoHS5gQmLWGCAmRUA2lQcC+IAgaT6ZYE4pBIUOrejEi0rCZGBDXuS+4QkGcocAtvpKQIigEoCD+kZ0RkxJaaaCQIYMnOBScMILtcUCSqxjc08Lz47/6GrfwyLLY+B35CypEejCU64AG4BFZ4h0OqDFWG8A8BhFpCAmJCow+9CCaM7GfMKo6ADT9aLgo3YzMICGOq7ScUkCgWgAtJkUakogEMpkyeEC5M650CYOfE6y5OxdH4w/w6w3MOpsZI8IUe0Mp8Jf2YJPcgUVW0Diouzrvk0H/qcGxYxmv/6kZdCMQ7+KW5cnC4WvFRQmoBFMAAFODjPAOWCqAUxdEUCY/xXKgnhG7yiJAl+oTqhGnIGG+zKO/W2GX74Ew5AhDjiCQq/I+F8ssmOIACREBNVE8fkxAuyiT6NO4lJKROpEcJg2IkrrF8+vFcpqhy5oIAxnEj1UP5oMesSgO3wuMa+6xirucfkfEgLoYALK0mfKZUgOMgfUJYFLIBcQeueIKUjkMEfEclBqUAIPEstjFfqqsi202X/O4eH0joCiABsnD37ORUmhImCKQVC4MjsfI8CHAuogM+VvElQnEBi4aIrGZi6IXqVNArFGAeHSnuQg4mHFEv+KIi7UqO0M6L/9IiKEcjJMdJnsqCihLMuLZR7hhALxcSP8oSD8NNjwhiKjsDFpEpALpFjpapol4QxHIrFGUmKzkzMiKwm6xGibqlNpwlNEhoZ3YLJWNSeqxoCkukHeFwbNIQn4rjBHpABqDEGB+gIA/zgaoKZfqobmipQmhNv4iTKjLQ98LIALKvxBTxJSaojCSwM6mTMQbijYopL32iW7yReiAwJfeRlRqAMEwuGXvTkgyCFm9sgYSAk3SmwZ5o7M5zbDIRAgkEPgDNrlARknZmnO6pV+jFdPrI4WIkVJjJMNUPsqpzQTliAEQJhtBqxDSsSvLir6TPIKrRIAUgiCzkVprrZeYzKv9aqDs7g5HYSiWmSzktRmz8JUTH5ll0Z9fUMw5Phu7gMTcIZwGQSkc/As1O0uMgoOO6JU4WTGYChI+cgyAagAEYtEkvwlQG51nqBGdojiQgz6xQQ11+xdTqUcfmItdcVOOsaQAwgMK27CS04nYiLkxbwi4sT9TUMDX6SE/qQkIwpEzkjlI+0QuZ5Tq7xR8p6X6cThuXKbuc9FAlIiy5SBpFFAH21LoMANt6Jrowsko9oyXZlB6RCwWigAN4U5qQrFwMA3a0LlNT45u6CD7kbWNQKS6qRCUgs388UhQJFJwQ9VYbIh33kCQIBCLbdNBANSZGZJk+B1ONCytgUuOM0l7/BEAFSkDSzmmDbIkzTkAGmyP1inKVDiqBxgdERsSE8M8kNc1J4NFKH4WvLGgSF7MlcLVdAYD0KJFXTVXXoDJA6M4BCMPd+KdP51VeX2ICcuD1pq0oYEJCAGMAKiAy2+/9+tVD9HVs4AMD+TQxNmYAzwUosmmgIiU0u2VMCMRd21VX0fIw/MlXq4sR5/AGzQsoXIYt2XSBisA9A+Y4LVTBElayVmIHG/Y6LNFSobAOPaxPLuNZMjR+anZkCMIAIuVLD2ZQJHO+XgJk2zUUfZYOGaxfGWAwwQZVgYJrdxZF02TsDDYqDOBm05N+cmAEXuAu4TKzdOJr2WQ/ecL7DDIl/9wpNLSi7VYCPuRlS/1wx1YiVj8TSEJKanH1bnXP/gJk5GiCZUbEZMP0TdelOPtVJ01pJZ5jBqXPbIcOJAWApkBAIUUt4+AWHamjp56lUxYgL4bGkXpscU2jSKiJBWeWdpXSwSxjqWSrXCygAeSOVw33cK9vZfd2X2LpLPypJftxWVWjTRA0khQ3U/2SbUqEATg3XnW3ID5AsGKACpGydHkDAZUKhlwWKEDmXv4xgtpIQpzC6vhoZYM3ZAuUqmAJk6B0hIqwi+hUi7gvU9PmOHoSd07g7fokuQK4owD3J4LjeVM1ho6T13CnTRTQMIyMgCIK4WwXh6rwaOL3Vou0BP9hiYB25GsnpZY6Y3b4xlQLkWG76AGC9C3N9SSMIDD/lnj/RD9EMjYdi46gDqlIdDRgac5QEBGpajyU9v80A2QAo4M9eJ+881HQcogdEG7ZsHwT6OhYYoHks7q4zm9QJ4CK9yRw7GEvrcqm+P4YuCc+5SlFV3K91C0cBUgwTCOZmEH3DkjIRV0xb9VScCFPr0BcDjEtwISDgiumarp4E3eQpotnlYjjc3T7lzfAAjUPc/i+8ncC5ocfmDkXTM/s8WrxUpLC0qPquDoxcj9YSFw0qo8rTxQXcv3oiXRRQ1yq9ldeQAke4HIXkpFjglJ0p0Ur0QB+1yYiACuY04TOWNP/FGDmeqJPHDNWojcoYHHWmoWMwVMlF8CpRjk0Spk6CZSIi07b1k1uclfj+qRqYSL4UsPcurYgQuBZS4AJfoJ5UYOXc5ICqNc4KcbYNI0BLtKa6UfZ4Acz4WKIM/IuDqCiniaObPAlcs8w0tDUDvEjurkzn9JNBheOr7Andm7ZVokALCADJRT4xLUzaqzvSAICSOBZK4DSfo1t8xcu7Pl1crmBuMyb4E2vEvhc3CdAjLVYShouhm8FV0KELjkpQTRlHiUcKzorL/qpyK5HJ1Yl8YZfbYKez4U6aCJYUaNN5lGVAKwnNCQFaEBmo9nCZronsHU7HyWuBNUWc2kZTTen/8k5H/WZN0bTp2uOKrwR+jhGVyurqbPyQ9FqcUbsUSkJex7IZbqOKH66JuoTWlLDw2wiRYXOrVu4QBbWJxQQplczMmHCjfdvZo2SkgWwrRN6E4Ekh4+U7iQ2n1iNoAQ7Kw/RrDRjZ+QjDaNDXbmxUM8PdXByU9KN7XxRJco0l1XvuGR10NL6J3QWH534G2kra4U5JBrpjfGXTyaPdWQ5aU4UDRGkZTQR0BAXpc3qku5vuxBitrOSrMqrRVxqVOLE6oCRuLc7m1E5U1f3c+5jYeapJtZR45r7JzoAn3liweDpXhwgm5KlPowCtKLlO0VF5lp3lpwugylxm1WTp8rFWP+tT3j0A83YGyshgHxcBWQEZqIXT5/SuJXLbjbBVyDkaW18AobM+4EG/CcQzTOWTPMamn7PtXyEKqCWDoca2BYZW4/FCHfnQkmAAmcMYMQ500L4Qml2A7DtVp/QmXvqmyozdSQK8YAx+cJ3+YGA2Scyd37Csinz+mfDM4GCswnNa6j5Gag1Y2SPsimknCPjfErMS8XCSLc0nEQKpJjJY8tD9Bh9rGuI8jBzPCjW1FquTskF4EpyJpkbGdP39VWFJzoNYzK1Ua7jGEggaTabh473XBy/1KzaAqoTKla9JdBj3IpS9MawWqZXiYZZ5Xs1NHF3NWcQvQnB67GzdKSgG4f/Wqg5vCN4LjrgMKM0EHAUU70UPec+Pr1itmfQhRAujsp3NTk1bh3SSymRZ33iVgmMA0SZMFA7Y5hIksdg7BxIrPiBZsfzfvHt9FnB/cneI9FBwQNxv4kgjvZpxWjaS7HKsrGb4ictEPCakseqtqMB9HLfgt2xBuCiikQsKMAFgKDcn6K6nqhD9i2JdimSMWgweVQmz7M/6u12CyQ3RDI4SnPGrnkuFMPguRAjcws7zWrEMFB9ttGT2RG0iU7lw/RTfiPabCBvPN4nHh01MuACYgCKt8LTJeUcm9nkNU6KeOOB8Id+nOJDFzCj7xznSZF8ssuZYYK80NEkIyBSsy3V/7abTUWIBIJgQzokuJu+Jp4eNTrAnGhDNzjmfvWidrB4bMJ9qiU7nCAXqeMVcQHjkc63sRnFPMyeCx1k4M9FKkOqTX5arTh9Afqo4qtOe8GuAmbgTD+C2Eu371GDByqgBHD2uqUKro0LNG6c8RpAmBtfORe/YF1RNaJGOZHKAiYFU8KSgy+fCxegEeMUeVHmqJIqN2QPKGCdNpyN3cPUAFwP9pKaq/fe3OnHcFj/J6YC7EgAlF3V6CE5vzF2G4neLphJqexUOt7I6iIIUAdu+bdw3zbj3QEiQoCBBAsaDIBAgEIBChZEIHAwYsEFCxcWqIgxo8IDEjt6/AiSIIYMJv9KkKjIcSADjSFbunwJs+CDgwcqCowZccGBAwIbCHgxIoSClwQ0MpBoICPElgMuamzgksDOpQRXakQgcYDGATgLWsBYYKBGjEkrYh1YdOzCAQDaun0LN67cuXTr2r2LN6/evXz7+v0LuG8AtRUNtKSIMUHXhAsdEK5YoIABxV0rd9TA4QEHDVoTFyy78Kzl0aQlziyYICPX0YwVOhggNUaNDC87Y1x9UKMFlwoIt+y90HDBtBhvHiRekWpXxBUH2FbrIMFFB8p9Pg4QOLv27dy7e/8OXu/Xxwopf6yJ0QFM5wMHHHBKXqHwg+4jH8Bdum3ECR4eZMBQEAPwlTcQABD/ACeAaKUtuOBpBDmG0W6WMbdQSgN18IAGvGFkYW4ZKfjRdSAhR2BBCC7U0XNrjYYeSipqFBZSjx0QXo023ohjjjreNSBh83l0okIxhjSAdQkG0CNZGQ11EAQDFoBfaQMcNdAGD1zQgUQaGUDVAAswCCaDDoq1JGssFTTBAxu41GKHBr0oQJQeEQYVSEEK8GMAEIAmgHIHGSlfANIJUACIIfEZKKAauflZRvDRuGOkkk5KaaVyJTlWAQqYJ1FqGDF5KId0kigAlQa1FloACyggmXExDZDUBzScoKZHpC7kZ5i6FojTmAEoKgCnOLVYUUQcXFDbR7d+2RKizYUErHrH/yEgbER7BgeBpxXCdOdQA0Ao5G0FGYiAAZg6x5Wl6q7LbruBOfvYax71yOyI8eE52a9gyUgWiYy2VEAIFVQAAgmGGkTsvrsu3BUAAfhqlUUQ8IoTqXUehAEFAKKlQAMH26uaSxELaQACcnaa0b8wLUAAs1sRpRRBBFAbgHsKNVBve5gqxKy7Pv8MNNC3PlaAqfQBZ4DRHgGAqm/taZQzQcAaAO6KL2ngwgglqGBRiISdLDICCETNcGW+BkCAUwaADROiZBd0AQcBJLyaTgbc53VhK7PqwMcfVR0nmBTiChOqfnuUMEYFBs14447reG9G5q1aQN8fJeAYlwbd2qNoI/8TftyHGlUr0QSZZSCDRhNLNHjIXZ14eNktnd3e6pdnrvSpFzUE0gYnnARZABGQZYAFcibO9sLXQkYo6UQ+VLNGSxHQsfMFDZBAAsmjdYAFOe+s0OKPj09++X4NFrniAXwO6voJLJUwp5/zDG6HcIJ9YgNwWj8Qf1dufCuPwCk47elNocbVEW2BTnZdoR2bMKIc9xigAbkCiQ5GAAIIEiZnEHgZA69HGJV5BFURQFSMTiSvJtkOJAsYkGgIwyTzyXCGNIxL+iAYAGcd5VuNmd+QBPUylskpSBeLiFQOABEGAC5wErESlg7SowLwD15rUVGe+FWR9pEGNrlrYGVaJ63/9WHEZAToYkQO8AEUVOADFfJRgKT3QdQ8Rk4JMEDJVog2pQzoKKRSwAEUYDJVlcUAbzOIAhfCrMQJaTU1bKQjx6fIwowFIlfJIVigJjPVfQRBWuzI0EjXgQvUinVJuiJBmqIWBdypggZZYhFZZJFCvsSBITmkQlZDRUJtL48CCEFQFDIetdgOTrJcWNMy4ip9WQQ/zuJIBKi1ukgKiVTJG2BKUKmRvjHgkdzsps9yKYAFHFMAZBrjAF1XzoV0MiJT2uVAWne3qI3kAR6YQEiOebiZgRMlIEkcAhxGmqb90ItdsaUAJnZOIYXEKSSoQAniNMeCKMqUsmsdDjPJoYIk/+mVA5FmuDLakXEKwELucYAdt4Qdb6p0pZFagEHjBAASUeZOsIlPnkaWwo/Ux3IfcVYYA4AZzWhoQ+npp6OSJMJTgsWdC5XcaGgJkhfVKaEKYeX14AOCG0zgpXgyyPIEkFOJIMABBTAeg+5UrIIk7od3OtjQ3BjSsSQzemMxAEvvilcbKZJZdlOAqbCpEKzAaXjLjEgCEGDVN2GEowYZSwD89x+dWmCCVLnTT9GSAFPNzwLHNKNBFmAdBTA1JJW0DFRBQthFPugx/JvI+4BKgQ6ItIsO8SxB+AQlIh02sYNCJsIcNRF0GgRYj2FsVcaC2HHNrzl5ba5zs7MsxAWnXv8Jg8oAEHCABNgOoDhZ5ZwwQgIQpOCJUY3QQGypoBYSsKOFmRifYsfAJM0VJqeNKnY5RdU+heSIpspAD9iIEduCxJYSslVhkhddjPJzOE5xQDHr6IC1xswjuZwPA8C5zedqeMN4QV/wOqIoBVUXj6RZlHQF8AEQDAwEH2it1FyHW/z0yEIM+COnIrATAe8KAgzAzSEH2qtdeRSsodrWQIIwAq6ltTLR+kgHP6WsjOQJULmlz2jn9hj4YnksOwEfijgM5jDH5ZB+qmMBkHimF+sNTLoR4AtWDLyukvZDBClX3/ATwDjCpEWSOYA4g3Nl0+yKuIX9SGcJ8gGCGbkylr3/XJojslwmEqSOd2RQHZekvZfo5IYVErOnPc0ABdwtSmjFSL3uB6bEFXKeHADwmkFSWnYuIFse1PM9J7m+QHekvsNKJcBSVpUPlGCNFIXZGA1d64NQcTW6hoktY8TdW3PaAp+uNpg7EmlxqQSODOLhogkS1AwMFZ8tweQZF0JcW7vEaWLaVetaRuKOJEmLEZCBxkpzIsnkSyI+/C5wW6PlriiyYjf8p7UPruG4FheEwl1QAvxoNMhujCBOgow7g/ltE13SLOomEmESGxNe4yS1R9qzUyMSt9JQT1HrHIiiEjvJhCXVMs/uyj4xAgGE67y5Ct84nkhNlg86MUtZec+Z/5kaa4arJeAfjPbHwSTyrhCAAPFmT4qK2hEr2ZM0ibMqeqjzkXMlW0o9PnmvwbpPSO187Ss1CEBfNJSZsRJBOMMuyLsSylEmoAENcHG5gW1IL+tYSi0zuWOh3nElusZUBIgAbgZgwAPEuyAaeADRLYPU0hyTgty+nti2Z3WCIMhcqZISediOem/2XJcH0UkD8FYzAmCvvQuaZz1v+2rLOMtPQ5Zz2RAUVjuNLkxRX9CLVsXxrmSANpgHPGl6xACLRo1YH1M8WKlE3KKByWZqSb33HemRGm/qTQxo2lEc9qKUQAA9mgOJwzSQAaEa0uyVIdFl8xu+siUMyDolwMMd4P9XmyN7pvUSENBsahUfd9cRHUABQ3V2yWF87EcliJInpJIrL+IcasF/pHFpZPF9HyhDECA2xWQQpRZG4zQQiAJIbGM6/jFxBuEsxUYUZSF58xcfYRJtHgaBpSEgGTdLLCQ2ZSFFlXFzvocTaeIBFNdjTDEgLddt8FFlapZFNJEybxUslXFdfiQnEwWCXfg4CjRz7LV0EIGCbyUs/kNeHRGDDMRVU9htwHEf+2N6nhFkQCJXViZ85LGBAQJNEtEfE9AiaxMSIjhB87Urclcz47KGMChlFrUQBbYeA5JML2JwXmiJ7vJuOnUvx2QYGOc6Q9cS5IZAYZJfUbhFTwIngwf/Ese0hx8BVVz1Q0VSehJhhejWUzt4EBpgAiFQEZfVcci2EQSROKrkMRDgUs4yFLnkdxHhLCsELAVwidHILolDUQCVbVJGPLn0AU8gShuwdS5RNdKCPWPDAKr4Elw1fmCCT03zI43XbANXhxKxREsWAIDDPyJVEbaFPBERAYmGAq6mgHV2EUkjO00zVZxWVTVDRS5RH2dmUQKBPS8ljRNZKU0mQJEjNh+lFiGAAiNQA98YE+VSMuflKAHpEjqhSoC2K2sYiKvRgwrhhAmUEb44O/NCGDdBKq1YMxHgeF2XNxVRLcwBAklWIgThUhX0cmVjbgswSJs4EVJhEVIRTx5R/3EWMToeZVcUqZU7ckwW4n9DdC/XtJEloDW8aJIspBYkOCEHCC0ZUSc8hh90BhM9YoggAVWltiLjNFqDckCwJpcatxANlUHKARoFkDPzI4Oj8ZBUCEOOlxVlRCJWhY8VQWi4spWXiSNIAhYQgByMci+UYUskAAMpUAG8GCgMIk1h+IshQXIJaViPxhSgsYwRAVWOuBCKkWfWggCvZ46tNGGNUhHClgK4ESQ/hIJgUn4mk4oUEwB4GVhN9WHMiJDpgZnVaSOk4k9vpIeTFpgqVposQ4OT9zpqkZir+RtuGBHH+Spq6YofcWFLNxAzlhUuRHC5J3oaMQT39mQXBUQZAf8msKMoQFaL+rU+rNJ+x5URZlSEc2SdDfodvUcoBYGPTqE/b5diKwZgTIcT+Kia5gkSNYZEBqYwvyhy47QU6gWTozgQNFUxTlGDrZcRXzIBcWNR5gF3lqYUhSknXkZkvDSLYvSbNkg0X+OgRbodEEpO3DkW+oMfGHABK1Awx8YwVRmjPJhZHhp2dEiioQib/ldMSQcT4okWUVkQVuJqiCRHjeFOOYhF28IAr0UfGsEqMLkaSYIby8U2lSkkbbgARuqngEEqzjJQXzMQrGZPOiQ7sohDbFob4CKIWMpOoKGhuiJy8JSeVBNIjfWXC1OOEaGLGbRenscTYTJvmghsAzD/TBphHITmN0NzdJUJjX8qq31BZVNTEK2JES1wOg6oKiAlOw4zMVO3IBQIqSnCnrITdQlDNjHGiAFWGusHk8caAD2wRgzRdHSlpR2BUor1m4ThN8CyFAkVAbNKrntBaa9XSgoGXip2AS94PQdgUrNZrJ81dvPKgQeQqWbzEiUUYXSUEZAIAIMTk1FldA3nEQyIA7YGj38jZdKpPukEXKwTdGPqKA2QYeWKsXcBWM6HKBdKMEZgr1EldZ0XspaxsWd5EMW3STNJH++xb12xsVBGH7N2EEioZ+m6ily2QoPjKh4lnsjXl9gBJymVsUVbF16GGwvhsSz2c3oGG7qmqGAX/2oew2wJMKrcqm0lCxNvuhTOQoAL0miVIYIO0Dd4NJkDBQFG8i9/CHnyIWAoma8g0UwtMY89ekq76WdvAj5dwXJG67dzYZuEVBAOIDAOdRI8oYqMuh6gMbBeNWMWhxym2Jy+ap6KG5s9RLL0VTPS6kmbujnmYrHWMiCXBU4DhSj/ogEU8AKmJpOFNmAJ+kDD5xIPJ6c4kbbq9Le5Cxe3wgC2QwBC4AIloWS3pG6ny041cWarM5mu0bC/FYxaCxOKMo/yahAnIJujcSLF1jS5Ioop6K3B5Z8R0QIO5Wot9yLlKYzJd54mtjJJgrKnJHu6K7/6kU0QsQQwMAIoEAJnhv+LcbRceKQi0uKchEof0Psq98KWFcCfUlc9VzeiuDexJFlXBoGr4RQRvTGUSraBBjVa4hS3bcm+TjZWI+ksxtUS84vCiRNeJ7ACIeBqawM9HVfB0+dUSGqwL2G5xbpcMlcZCaDA9nmI5gbBlDlchTEVoZMR8YYegmmEaZq1ugIbLjUWakml+NK8rPNHCBBvKIzCveWdTFul7ASHbBl+mqRRZWKbhKGTv+pk7Pe++0MASRG0w/LD9AgTOTwcY2dL1XJEIAc4LcccwlYBLZAVLLswLTKP6Lt5nuvErOd2XDy/NgBnTyd+lKEia2xzlDsQS8QkYNh71Fu8zmp4UhpQdaz/UAxkyM16MyYLLiaMEBVBBPd2bv0bE33MmHDFsGSBim8yWSX8yJD8t/D3AGA8R0ECldlaGyJpHG8HGv/CiQewQ9mzGmZWvwZMsUAcEopExqdkylfIQCRiRhGgSu8LaQOoUyM4ADGQAjBQQWbGO4yWRQ9HtfHhykOsTtwHe6fkZeMCzEbbghwwAQBwL5EBI245IqKmxTozheMYrubssIxszwQakYxkrwsLE2BaGSfwKE6bxdtMGnEMVvjlFCqmAwtTwTekHIp7THW5oo+xXf1crgHQH+L2Fjw6pJp8y6znT9hsRPAaxk0CHAWwFAo0qQzEil2B0e7p0AQxE1Pn0SWL/8cD0ZqicSK+VASDxmmw4xJ8Us86iFIgSgAwLatOhAFywVV+9hi7V8YZFR8d6tXPSZUISstYSol8+9MsBB8gorLWXBl2CrEoBgPMZxkzYx4L2hg1I83OxnfJxKiPEWqUKdYOGkpYYhdqMSVZBigzN3D3sm7/GrtEHLIKhL4Si55zBpQywdcMZFFLsSgMyKu1sUevHDmP+kGWpSl/lhiRfZnztCZ44YjlGFFS4T1G5Z8Q6hLAYo4+FRNRPRrXlVwm67LvUxai5RE1x9Qe+nBI5H/kbLLcdidHYbMxYUI1Y9PB8tSwvWB6siW6PZFBVU98UcFHsTMO9k5L3blQdkiLGP8SAvsSnmitqc2DD3wQ/p2kA7HXCwIB8yi5suO1Cq1OBeEBFwCS5RUz3AdOnCu2j1cuFNTIjcHelug/mwEYUXTN6uNt/72ysYRbEIEoAYl+0b0edw3gROhbKPPAB14a0kSTDDM4EaTMGCPL+525grIzmGyy1iHUEuEw46R2H556AWAl/6EdJHJAAGBLwgE4qklp9+HfieQa3L0cZeEAvTnj2up8EdEjnILjLqG4j4HhzY1dH/wmwnpK/tHZT5zHQgzFQbo5LOHkqTfZHeAd3GcRqgQ4FpubLpF5B2G5oddt513mSXI4CwAuer2ajwHmDNMaSY4eQ5mwOZvebFrBCpD/6R1hUXkCUDX652vnpGpSI23oKPX6k+rUu/sthKVe5pp+w59V66c0AGuOvQRsr7ZELA21JgN2EXPsPqayn2feMAaxM24Xn0qx6ggnzEl4I4YtTNyiFjP3ImSe6x3B3MdtEzHRW8P5i+fUuNB9M0xVt8HpAsiCEyf+qPiIsjlIABACzZkCaVtR7Z/2zwGdI3p6L+uudEldZwatbhFgAdrlngjA0smiU/D6sh9KLbqGHBVg5FB8JxwBrQKAMwxSxcGilp+ZMQASxwUQurf4aphTu/WnJEm9LP9+bTOtAZIyoPGB4UALmyUYsSEx7gIU29ihbPmIhUHNSrQL2mVTNQoc//EMAyxcATjnLVK0rSfvwRCwkoCPdQEusMAwKlwb1Xzk0XLNvhA0n3BRXtYVOZ3q62yyLoY8fRiDpJbjPct2/BKA4ycn/vW6ghEKzBFgc5SVYblXYUsGb5RvA6uDmxgpM6IQoGJx1oq3ohyJY6OPB3pPgdMSmtton1eB3i6wrvP1+bDwCxGZyJxMsetPw+d/7c0DYAErCDL2mZo4EfQDosBzOlI+vxDgPuuBdScbz2e893T9iRLaQt/AhxtF4UugasEy0zFafD/ctbHSkjbyAdLN429ACdIO8PSXxiWeP0MZ4AF1wdtEyy5ctaBXVEYgIZ8IKCQMQHJFDf/pnROq2v8klUQiJGjRb23/uwIQCAQMFFCBIMEGARRaODgQgkKIESVOpBjAQEMBCw5gLFBxYgGMCyISwHgQgUIHHBUuGBBxAAEGEkkK+IACxYeMEBkSLDBAQcMDEwdsLHDgIYOSBwl4/Nnw4ciLDhIoROCg6AAAWbVu5drV61ewYcWOJVvW7Fm0adWuFdvhAYavGjI88BCA7d2wAjEuXZC0ZEuqPGN6HJByoAKJeg8+JEAAsEfICi82NBD5L0WQDZdyfFpR8cGITZMujVy6tGiDIRWWnGradd+DQZE2PFn6M8GgEXeWJF3SgWuIB2mMsAER9kHEGwfmjgiAYgO/A39XLKxUYgL/2pMHdsTb3ft38OHFj+864YIHrxM4POAwgbz349ZnRycoMsDMg48rLnD8EWNryDQy4AD7KhINociwi60iBQmqDL+GABQKo9oCGCA65oDT0KUDDEgtwtUo3LC0oQowAMDPKoOMAe0wUjGiBRBoUYCOAoiPIMQ0hPCDE+oK4LaBLEQAAf0gcs4/+ihaADoBBkygyADoGwiB96q08kosswzLgwfc2yoALjPQQEu2LsQooSilpBGiGQWQasQ0gaqIgCchFIA0iuy8s7QIQCqgQooSyEwBxvzCcyII0VRIz8MOhVNDvT60LoDMJn1UwxgPcHSi+ZLKUCLlmgTMTM1GHKoB/wta8uCCCYAUIFQBJISszYZqdKlWijr1ywAye/X1V2DD0uCBDrja4IEL4AoWLVIPUtHV/4JL6kWJjsQMowgQTbKiGT+91CUjm20ox4ogSGDIJyESd6ACvwWOVEm3gygCjjYVEgF73Y2MSb/aFYoAf/mVV98AMKBgBxdVK41RkyaCdSBZbVST12Urtvji7wLIIAO7surggguKxfisSgnKVqEIDBstIlqn3LDBgW+lb7Droi3NWjihpTbQhiWjjGBICYo3J4hgJqhImHcG2iP6Ijatuu38dfcCGHByECNvPTNpQSSRo0hlvxIYeWyyy+7KrTEBwGCuDTo2eyw7p8P5QP/QfBqo5TVfdhDKh0uimWWMpnN3gATSpahPrFfcS6EBtDMAyqW1HuhDBE6WqM0M1wU08mtrdeAAyIEjAF8+DyASuA1W4OHzAUoeSFESI8CTgAZAasBfzJWkr4C3e/cd2AnoAkCD9Tzw8vexFrioKCMZpzs/NfMekSUDpeSWN04J6CwyWDdXV+HqG4J9gQj+5jxAoe/2yHUBYAfS1vMnAjL086EeKF+Kgm87gOe9B27GdhltTxQZAAJMxz4CIE+BCxzPqjTAJQ6kjYFocQn7ENK/vmXNXdAyGYNKQi0GVMp/MllcnjJTAPz57Gfxg5NyUiM1iAhsORHpmwBYWBGBOY3/hc+jH0U4cAGJNaSHkNET7AIgsNoU0AEO2Bz7FDBBKEYRLRqgwFwyoKysTEADHdgABzJwASl+BSIc9EtCWtQT15wrhd+LkAIMoADzScSCbDyIDmOIEXIREIYOS1xFGNCh090wIgnwEOg8QoC+6UdPShPkfYY0RM6xJgAsOkwPDYYBAhjGAHs0TQ0RZTr7tO4gghMgxcJ4SlRmkQIiqKIXL/AAWF4gAx7YAAY04LZU4gxvfslRVa5imk6hMTLK284aI+KqXgYuMmBTH0VwRiKMhM5onFQXNYHzAMKwD4UTmVEcG/lNApYEATcqwPYmYp66DACSkXGVbWzWN97lUp5Q//QABThQy1vOkyx3jB5BjFmRMzWHMOuUGbYC4EnI9M0CQCOmm7xpIRet6IT/hMwJKve1Wu0RAsoxwENZSMgCKMCaxumPu5iZkefZESJcmoC+1qVBwIlPIX0zpT5tetN53ocA9Ornqx7FKILCiVGVEaDgBMq4aEZOnZARoABCt66ResRDBPnbjdgVmQK+kaLuops1G9ezn8rUiaahYgfc9TADmJMibUKTrmKFU7jGVYoQ2qWDLODR0jR1iAU8gIQSoIAD4NUiEYWAzQI0mU2Cc5CXoUjf8qihjUhqJNjLJtdu6FZGxtRZFjpAAf6ko+XVJneu2VjRTFekZ46xVi+xpv8AsyVK5MhVtrP13brUFFTqlCQyEOoJbF3mESDlhqe/NY1awUmANmV2sA0xqoYmdxDL2baHfRPsBnXrEbdOqWRpNa5pBFjdiHSAAjgAm0qlNa0etghNM4onbd37XovVMDoFGAydtioRutkxAn1rAA8rm5/70EaxYfWbRxwLJzNJClAPg2mI5ORSyTUEMtCyoJvuC5EDjRAyE1gBCISI1d1FJgIKUMDJpAtfFKeYTDKkTxIr5QDcqpZGOvStmjRsoaYoADDsi/GAKXUmarr1whABiaQMcCjF3NjBtRqyQja6nZNZa12PLVpPGwLeicQokCMSQAkqQAKCKDlOhroZRLL/ywAVp1nN4yHjCpfrIBbWVUQasq15fSyROue1jpfCztA2R9Dn+RNOM9rUZ4RJQitv9s5pCsEIQkBcA7cYMkNRwOkKixFcrlnTm0bLpW+7kpJEdUO25UmbsExH6C7aNZ5OtWka013gJGBoTkXwriqSWojoCX5mPkClu7vLCoMGONTT12RIUIESfAC88r3fIa98UKBwWtrTLssCThrQRYlzqUvLrj9vRGXTtAnWqrbRARogI0x/i3CGM80JKGsq+f5RU65pJ5wSjSvTKOZx7uoUCFLQ0qeNTiX3MYCJ8DRwBPiJStRmeMO9AuzHkPpu9nHO6OwM0A+SZgEKMNHFdbdn/3J78CAla3KVceOaG7w7Z/QxosglDKdg29i7+P4WA6Dzp2HtzzQI/BGIGLUArWTa4UNneKBDSqR2BRrAX6XqiG7T4KNOBAIJ/6WQGkCgkOeWMgk47besmpkbP+Ckg5OSSp3D6hnCqanRA3fnLLW0Hz6NNWgP0s+Jfve76zoAEBBNbawq4OepXeH6Als5B9zjAAwXwPpitgDaHoAH3Mhyl+JtRBem6Ecxu/EEFWf8LlmaksjOb3TnDt5N33BYnSjhtCGA0uGs8kUDScwECxVzIMCAIeqVYK6/KkWwmVUDzN41dBoAi3fNVAScmjCNsRuNluJ6qAeA652PHzoj87yGNv9EJLeJwOnf5kXv/6qACFh7P0EnyYng2i7vCrflBfkwxOxm31ofJdDaPEJs8u/t+gqu1y0w70vRjwUgpOuijpibv1u7FJZiHH+xn/liAMdArgJogAQKv/CYAAmggLu4AAmQIAskk5hTk5hgH1HTEcNogB5iMeUCGrp7FeaasFIhGAg4wPSDvJ77sKVxHcSbqYNouW9BKBySkl2LANLRFyraAe2QlTajkZNTiA+8wAy8iw6QAA54QjLptn5qDaPxQX6jucP5DymzgKvbQU6JnhSSQJGKukcpvuioCGwaq6UZisPgD3YDDrcSvtKAgN1oQopoQcrqlLRyqRK4CUFjEyv/wzor/A4M1MC7kAATSMQsYZj5shRBSTvOYTGVEhgQikGyUxOP87ohiaMCKkCJwKakYCEIebyK6Bu5gZONK4BrE6bUkjgBG7PD0BfsAAFHk45c252koC9IxItFDAsJEAGxeAAJOJ5gJA8/9BQB0o9xc5eSUMX7IDFHYR+gkaFrKznggBUqs6rMekNSjMM5c43nOT7R8Ys/GaIQdBlGYbyBODYPsyEVKqPowIplVIthBItiFIsNkAD0yMf3aDztYx88NCmMWKjpgb011A4Yexh0jBw9iRi6oUDfgzYvXJr30RABij6PuDZevLzouTYyDIyB+AAv84Hz8hRJfBWBTIt9//yKfgyLAIjClySPJcQQxXpGOMkubuSUBMAT0YCxRnoeRkoAZqIybKK7T4Ss66K0LXO7gdhBWqTHhVmeRItI6jgABzgRVBOAEDABDFAI9mmAwtmxXbnJs4hJr5jJsKAACRA6teyOeyMIHVI/J2yhVrO3dKtBgnkJ5bsUFmsuk9tLhci/BRChj4ooO+EkOXQ8MqTFFdyPkgnBT6wxcgkh3BiAC+AA6Uuq9bOQljmAuSwLtuwKtwQLD5CADSjN8OC9+SKiImSos/wWxYuVrOOc/lsrbIOI/FMICCzJ0nCdzXhBzhmdycObphyki/KN7WjK5zkU5oOIY5mAUKEv6hAgoP9zTbFgS5D5Tg6UAPDszPKQgAfgzoxpx8B5Ku0ogBJULJubwJ/MzT7Uwetxs8O8M6YrgGwBqjgEm8H4u/3bEIO0EC7rI4/IuZc4FFxTvApET7BgSwmYUAqtUAo1RtR8RAjtjpwsFVyToRrxJR2jTxKNn+Yb0QgLs1JUtW0LMPDRFxBVFwS4OgZwq8A8JtA80AeLjLi7mayo0Q3tTpuUSQwNiymswiC9i6osCfghpM9hFNrRvpU4gAOYvDVsjBLNUgMcuYn4zZBbF600laRIQxrCo285EHuBACxNKASNDIO5JY9IUrM4Ta5Iza/gQA+U07RgMSl5rXY8sBSJRpcIShn/azYtPVTG6ayqiwgvDbnbmM+CCrWIMD53GcAEMC6YsdIKMlPTCB4fST89JQs63Qo79QoRKNJQVQuCFBHYPIxQa1PIEA36mp+8RNTQBJrmMyS8dI1GDTkJbAA0i5zooBb+gpNd7UUpLRf2ObUFBNVUjdAhbUtU9QoMkIAMeNa7wEKDUpOuFCfdar0SW0U1AazAslXOqbFD+6kViEp3OVaCAVePI6NINdT4YbEGoz7XKKtqwVZoZUQiFYsMkAAs4le00NaXq8tXqaEDURqDLQmPNFd6K8dBKwhIq9R2cVcNWdg0qjBEgxjIiICLOJEOgSPgOKkVxFfgKC0nJNivGFWt/yhVrjABCWBZtVhSjw0AkHQ8v4CxRTKseuwpSIXYN4OzR4mU+tAXApio89ETPGQfwtQpdgobc4RV/MpRDRGvPKVZrXDZstAA8dTatJiRbcw253QRBQCQGUmuiGhGlhNa09hVFuPCnXsuS1xDjLjR6xtHyCgJuZ20bSkNq+qhGlvOiNAfsOUKriULDpAAkTncsvCtnmgqNMmk1XJY+TmhkzKqlhzW+MFYcLrNAeJLiq1bvbTafAMJB9iUQLtLiZhGoaIPikra7QCvv8K6S8mKVZFLgk3csZBZx00L+8qKxDupzRkd0miTTamxcrTZopBYt32UA6HGvB1dAdDUDaGVh/9ViPyqGU4FvYR83ei4L2IbMK0Ylqzd3Wj9XV/RPyZVnPrjI3V8jJx8nMoMKs9925Uoqcui0r+5X+Og26fVECz0ODCdCNed2w8KzL/NUv3oivM4XN5V3yrhU4LYrUpBwPVzWs8yJIhYVdzMVcTzX8LQjhyxmwJQyKUR4f1oAIMwCnWTND0zXSChqPITAOWTRMJN4YmoRMj8CrfApQlozVQNgHuSYPGLDlVsPoIgTPbRoCWU3jtjpvPDPGNFxXUVzj08RXcy3aGF4kJ1P4n4o7O1kFBCgEr7ozeqLndV4VudF+aKUGLZigxoXCOu4+9oSdPpX4VYO0eZYWUd0+S73fj/YRSeIwwDulRwgoCLSI0c5qfokBUoMdmKGDEA3BCN0NsbZLIafCpBPZ9lDQvw04pksWNS7g4BLZnHElAB8J4WabDs48MyG7AatixtOYj3zDy6pTVcth4ckw48qTMA0AgHsEiCqbd5TdYODrMBeIoGQVETduH4YQ2xwIAHkKBqLmVsXosZgSMKsRZms5e/UoB/GoAFYAALGCfqoM/NheXWxU8WSp+KxRRP/LFJ+TuYqEUCqs1JolK+QCw9yQ1rIaM8CrRK+xlxoRY2xjjNGIsAeOCs6JJsjmizUGQEYcXQ+MXjGhTh/JYOfSj/FCR4XuU45ZPYKAkLKCUii6aTghIA//iMIXEWChk5KCEjwbFZf+qbqRiKrrScGKnDkSZbISqLDQAi58AmiT7qsXgJfDxHIek1Jl09kR5k4zyki1qaBbjq6NEw0NXlG5qMD6EovJxO9pm+vrQTIkG/yTrEwkOa6FCUdTYJJxKXoDgQ6yXjWg5q03wLAAge3UVqv96KUqph0xmX+EFe6gAbf1Fha4ueAaGmAsbfR5mN1JjMETGajthI4FTMPKtaK2viywlfM+spxAEKezXdhuLPY24vs8iAKhyWv35tsFDPkWMsYaVahQBRBiC/h3im/bLdCQHa0niYuuYcFqmAzzoffWsJzUGqD2sTKJEzjlCmiHhkOeonnP+NaZmDiBnkRIy0S7VwiwnAADCCbfLWiq1ONPxJaJT9yhJyshbxnw4l2gRJiSOrFkHqVeJuF8V7kecJihtxGg+mDDC2xUZRq8ScFsEgcBdUkwxB6UGi7wcV1eOBvA3ogGstb9hW8HsjjdUD1g2hE5qh1d++x2RG5hLvKaHF70ZiQ+lQpw9iHBkp13BirujAF+dNJNlskZgYQDxpYqP0WYTqjglgm45ZFQ9AUgz361meRva67WczjQO/G8AQGPwpu5VU0cTgiIKj0oFzVKvg4Lw8gQS4ZXexbILGFMTaPt8ADI3lJpADXEIVV+2rscDKSCCRm+/4mJAZngeYpST36yz/FkJ1KhmRcPDhlKmV0O0EvL8rJ12Iaojo8tlFO6OIK4DJ7mSCkW0UBQ4IKBJm+htwHW5EYtc2PiTAwhMIAJskkhFx5kH5Zm6QE48AOJaQuQAKEOI/j+i3bsISCamWOG+/TGscjLUTam/DRhTFFHafgmzOAV3mKDIcUayeSlcEa4r69rEWyaPa3a80xjNYPZCgsBIwgSURwPVcx+acHTkEeIgaSysyC/bEk1RTab0XdA5DzxP9lYl8X0MzJvXTGDjJXrwR8V/2wZvsTeRzod32BuqbNcmXc/WTy5Ihn9Zzt+MjGlbRuDqs4Vz06cs99hOVapNNp21ys5PAhCeUyWWi/2mk2+iJCgvTO6Or0hD56nYKnShA24KAit95+EDYJoFhkhodTZEhQLmNEcJxZAWRrHMdmL9rLIcNyUIU8gvADiHm7nYA+4BqLiXRl+p4RAe19l6k0L5bni/7uwjwaQwxxqkrQGnBp8AZtJ6kFw+57LrlNveZD0FhximZG70R5mCtjmVnffFcNIyJpvIIP5QQe9asZnOOEzN7yE8L2cYagjREjk/6AVXwzdHiki+wDycxikwNVs7I9hv28JEOTFe3qudwzWgnXGuq5moqc+IoR0nbyL/9s7DpREsIdJOSdvk7GDopR2FqoGFjTHaXyJtx7sau2rEgMWs9s5y0AbA5Gv85SBihDTDVkwDuboFHCTBOrQRoAAPIXJ2/OwtXRtyXrV23MgZId3z2/vd1+iYpwwcrESbysdswLxVW8cV3CQMKJIA4IGAgwYICEARIqHAhw4YKGRgwOFCBw4oLIxpMIFHAAowECVgUaLAAggMgExaQSFEhAIYeDSJgAGAmzZo2b+LMqXMnz50TJFCgiQFoz50bJHgoqnQp06ZOn0KNKnUq1apPGcjUuHHr1gYLEHDdiHDhgpQEF1gkYPYABIciBzpoO8CgAYt2yWL0epeAgQIGTt4N3PCBxY0DFhIwuIBB2IGHBS8ckCAB2rlcGUBeuPFtwQEQFAwsALgh2LB1A4D/zmhR62arrqn+DDpzqGyoAYi+zq17N+/evn83Td14awKFDoZ3dkvQAWaLbe0yOKCgeELhHzM3tJwcO/fAhCuWJniAodmC1sUqHICgwQG0q81zljiWJcOWCtuKleggsl0IyBEuMJJDkiHw0kjAIVhTbAoGMBUFEjSYoIQTUlihhVbFh9xABBxggALlDTcfWRI91l1Fm5mYUIYNjHaXfSk6RNgADJSoUAIpkcRQYhoK4CFg4U1UkXYEgSgRdXcNkJoDxxk0wI4ENSfYk2EVkBBEE9WYEGumXdjbgks9OMFOHkiwQZdnopmmmr8FUCRyTDaGEER+RclQhuPB2JCbeJpo/yCRdebpIkMPNEDQSha9OGVjpykUoHwOWcCjY4K5WdBYCxzQAAJZ2pUAnI0J5uhwBKzp2pcA0LZTmD5J8ECpr8Iaq6w3DeBnWB9q2IBgfjIa2IshSQQodoVyFehDEeV4VwoGHYokj5gtQABaGQpQZUPUcnVkpxIZ0CGLedralWCRDnfArFKdmqpOq+5kggTnwhuvvAkCGdYCAwxZkK3CBpCABdSdJ0CzxkLwKZ8mKqoajC0pemiSAxkAbQUkZsdpvUTiqAC+HhkQrkNbildQAQdY4F5g1BobQASSmtzQi9gSZMAA8zqVLm45sasTBxJ0QLPPPwPdFMiXBZAvkehFBv9itMGmzFACCphkLMwipvjpQO4VyQABExtU58MDaRvAxQe5NNJGDvyakKgiM4vdxdZCJlkCWQa8VcSQjR1zhEH3ZHNtOOWckwYSXMC34YfzHYCGzUkatoFVAhl205MnpN5GLXZntADFDe0V19slZPWRmhdQo+aXM0SuhpxaZDTV24q3UN0wxX1ApTMSMDPiPPldkwcXAA+8CIQHD/zeNA2/u/LLz5rwRgrNvtFzlW+E2QAREDA9S2nnyT12v4IMd54bFYfysuYhJhHcGcqs42YGHRwAzFthbtfKhma29kARKDT/QK8PKCzM69vN1DWTB0kggQpcYALFZJMHHW+AEpz/4IT6BTMCaA0lW/kUqRbCGInUj3IidFrMWNcdYnWmLOoLwAM8ooAINKBblpPIc9w0MABobgCYMkADAHW6sJiwdQmIiUO8Jz9u9W84QVzI/CJIwZn0bl0ScKBObvO3J2Ixi7txnpEqVRcObaoh/qEY5aIjw6YZUW0zE0wa0wOiuW0FITLKXXzGphA/xa86bbMLF/dnIF2J0HsBg5vVjBQZfzXAL4CpVGi0qKAC3gxwU+TJUZLiyEtiUio/RA7/7BKwA0gnjBXDDshaNsJTaukAYaTWSr5TNPVJhE9DOwkBFKCpw3gEkHbRH9hyN0SOLZFyF1tJH6+2kLEhZACMPEgm/6OIs0nu5AHQzCQ1q1kUFEqqR3f5INsKUqcbDaQBnOKe0XoVqAiYxQL0QaVxkJgQV+ZNXwzBJp6AVIDzmNIhBqrLlhQgLYVw6AD8aprR3DO/ZhUzLOZqJiSv+MBp5kQCJrAmRSuKkwBgU0PmhNRw9pMQRYnPIvdrUspANjB2BsBPDijAyG5goxA1hEMWIEDuNhnOwAwATg6YkUQ6mdKCqBOVHYELYFRnGNllU6BO1KIzJUlFnHRAAhywKFWrOgDbLVNkgomnyAwQgUKGcCEjBV2e3JTPFHmqR/UbWkEq8BibCiCPRfNIIZ8npQSchH0JudhAM2c7A4wuS7z0ywFqxP/WrrSnok29SeBucgEJaKCqkq3qf2yEAJDI7TG8zGZQ7WI0jzaoIm2kniGNVS/qDFUADchoW/nEVbI1JFxhMRFrrbWnFP1KmQXRpUOKJDnZbiQCVD2VVUQggskit6Ks3YgB7FkQPHEmq+TbqkHCGpl/VmSM1UVU3J5nNAIgAAHnmRhiFNAXu7Vss43hbWaGqUH4pSxgHYypfkKrpWzKxKLEpcpQMpDc/1ITrsihTi01BYHXkrRoC9CejhrgAAWctSHCaZ9DApYy50UnlioySAVCGoCEDoBc0q1WgrlTUD0axKfj07BD7LiQEYusqvudSgYkgAEA4/iSh83mQOLHlxH/n0Q4cu1OfDxcuU/11W3kqxRa6lWB1/kPxoaqZXMP46RgZgcjdyOt3lJ224/ZNSHAvZyMI5njM6O5JmPOZrLuGEfAZHTI2EFdRcCbAAZD5lcJZa7RKoA5BEuqRcJpAJ7vAgFOPWxkk8vQQI3Gpz0bpAGSnXGaK41jo/KYuZHZSmc1V+jMaE5ylINABAD9Pg7DNj2Znoh1OoviLmcOe5RLm25jlxZ5JlFDJJlsADhgJksD+8w7XrXXNrISBiw3wpmhc3s7BkASbuWew2Et1x5jn7oCMXdqC68pc5idCMytIsIpgLJ9FZgENMCfOB1ii/y3v2DDO94WRbaUy1U2g6gT/9NktYsR4wNawRRMnjPilHpDM2YHXIxr2gIAzIYmZ4ZwsyAt2lIeL4ZSqSHHAPLeOMepueaj2c19TYr4HgP1luauVtSk4RZBCM3EVX+kz2CDdkEccJKxxqW7ZFSbkX413aJhtbALGW1DFiOkoGdJhy8djsY77vSnUxDSy+HKwFgjmiMy99P2jRsDUguxwIyZt9HjSqYe7J4FfKraeqqu0otWEutWmC4PiUDAeqVdSxUNREaWklmuTh6RPadWoSnOiBcK9cMjHnHDzgi2U/2QKFGr3GgtrUXWXCJTE2Q+aXvSxAD4tQJYwCMqhwwKXZ5TroTUTSBx07N3KZGWXWwsRf8a60YKAIHE4z73QBNwR9f5qwydNGWs3ShDEAwY3gvA2gmxz0wadFUDpAAkRpydijOn7dDdiuZwwXqkiaySiyBx8RuxgO7Lb/546Z3He8/7RiQfgAxih1dkub6b7YWX4ZSuPlt/kSuHvuENBkZAwR3JMU3xlZDiGFt3yJ9CDB/36dpSnV8ESuCFIJsCYAaPUURmgR+zBBMDlEfrNcTQjIXg9ZjTpNx5/Ft6uBuepNFXnECWtERLgIpdcAbxARRX2JxF3AuXbRd3BEyz0F5oLFftjcztTeARIuGZICDLcEZx4BCzgVMBUMdV9VRmvARoWU3rZRSF3VtYOOHygSHWdZ7//70S6vHRo1TEZuELdriJDUZIGhYg9MAcqSRhHdphhQzhbkHMAgQhtNBZvciWG7aYsz2H89jFPlUEuiVStLnMfQ0E12yZZnAFCNbdIcIXd4BMCnYKybjHlIhaLdVbtdDhHZJiKfYGBIzYZOBVIeHJUd0dcgSA1p1b+9FUdhzVLi0XgZiSAbAACwhABaiALwpAlLQEtjwcRq2QJ9lad4CTwASeZ33KkdSiaC3hcxEADAWLKWrjNuZGM2aariSMtUgdGnJHMfndRzFbGC7E0IAIRdhHSvhiBQhjj8RgrvVIAkQAljkcTrkfTlUOseSgcpRY6yQEeuAQiEgaNyrkQkoF/19kGkLomwBYCcwdY0VIV4l4W2Bk1QfMh3B8zkCoI+5gWQT0xV98Sv6pI0oVyUkkACdWY+bRoHhkyALQBAT8VQIwZE7qZFOE4v+IzUY0gPg1xhIxgAUo1dJN4kJkVPANCEYUQG01CkF8pFr9I0ym0Wkh3cWFILfUGtggjUCKB4ggwE6SZVk2xTh2BvJlU1hxhsaUxHAciqK4ofesYd140HFM5cwZSOtpjlbqnz2aB8ttFzkZxtMkllkiZmLqRFfyCAIIJY9FGFpe4kuCpGBIBmB0Dmnk5YaEmf85Tz+i0tucGuA5hPOMomKiZmrWhLupT0/2nrjBHCA5j+1Qpf5xxv9JZI1D3EDd1I3paNtnwgh4wZ1nyYdY3IlDqKFqKqdyMiZyuCaVBNHHFctPNobkDI2VEctfbF0sspDz2Ep6eMR41JeJqBBclAh4VZ9ImQcBDqOt1M8+LWd8quaV8Mhz/pyQNB5ytEXBEcna0c59rFy1nABlCkyR8InVmIRipEiR1AVj9iMETAaH1FWb1N6AlEddyGeGoqZ0DuPYacjDYR4jvtet1AiKWIR1PJmfIEB5CswNSoTbKYAodQd7kmB/QkYQdgZXgGKbfRhlaOiPKiYD4NWYSSHMBcl7GOnm3MeIoeRPKUwAtdUwjkQhRoDJAABbBVGBBGUA1l71AByJahT/BALpmJYleyZpy9GffWhgfmZc0UXABW7FownIrUVptOTFEpmmQ6DibjmLhgynyngh5p0mmRKqWarFmT6KBv7f/9Seh2oVnSbjR5kFF5Ymqr0VdylEG3JUD57o6gjGsLEpTBTqqCbmYYQoqAAJQuCofGCeIM5VpKZHlhAAk8wHiFRAryDASkEYsLyof6LPXUTkJa5h62SarYwlqSKrWbJmiCSMQyoR8g1nwria9ygKIK2NW8lhQUSYi/3dHhEAZdRZl5LNAKBQ6y2rpWSI7iTruurkuVZLISWAn+DKcLQFoFVkS1hHzt2FWSlEqRGAKxEge6naZL5cdQGJwBYk5QWA/+iI1HmZjVgAwEscK7tSLEN+BQLAWCF5kaNuyIepBGVMhgm1ZHsgRiLd00Cp6X0qBDyFWdqMlQ0ypoew2KbdoiHuhaVwER3KlLpWbM8u5GN+KC/lTb2+HkN4Rnp8ynwoyuglbIoNRkKgU2dmR0mo0kAdWMfg1VYEaGmNDdMG1GU9Bjv67Ngaaqh6Kn22T6hR6GRGrWodRro2bUGsE0NY2NPOzjFOias64L6FC3WsalvUUjihxUsMzMnxLNkibk6eqjtVzvS8ok+aKEgR6IrSDzRKXIxwUZPq6czqCGVQi4fNTonEEYwJV0283+EmbuouJBVejnRZl+qhRmnxymYwUv+0qtI15tMDYMuReA9bNYQHxozKoiPnSmakqe7xpmZ84OSwSaEJ1ejXAYD+gFZjTidOwYkBaI/uxuldcKtCwBKnHlNPOWamwlzTIe/5mmUAWAB76A6gMYfI/WpL0KfQjahpHJaDIZws/tFCPAAXtV5LvM3ytQRbFVJKEqhMumtGoO8Cp+Y4lgiOVuTeVuhm6d1zpI0armzs7hyUOm34IgfmSF1JSkqVMHAJJ6bZplrIzW36DEdQZVQhvQ7DeOk7OSJBMC11PioLd9OT8iEDhCiHYqgJCzFZavB6Da9EICzNNkaT+g/Mns1AWIArQagqYRnKVI54YWxGuCKHrhr5DfH/F5dlvyjUEYNvdoQq/Y6ICmMK+yZEHgpACsRiakihr1zMaeiP6Ikx+ngjonIlGPtxWc7qVugOgT6cgI3HgVFxDatPt3TNq0lEBdCnDf+lEsPkwpKI8rUtQrjxquXIH3tyYl6txNUEyNywu5WO/oDEqXoUi3JYhqwfWViNaKRjQ6yq+oVGfn1yLifmh+FyTSyAeZGsRRQI6hVE28pt8aJFWFRA3chiVD5sGXehkZIfvuhyNSPrQgQcV2wyUfUkHyqz7+6KpxYGJxuKNZszu+LwmXLxQczPgHKuXWzFeYBg8YoiAGgN6p5zPpPpOvMIP+/WABBGxPVKG9mNyFgXjhJA/7Aepj4zdLKOmT9HW30CNEAlQJJJ2IcS64EAADbFKD439EePKVfRFB+r3wuam8s0J1e4B/PRhPLSxALgFUjL9LpeYcdYgO5EMkkjx8SAHpbp6XqwyDIZHk6Ak83N9FH3bLyyyE6gcDa15FZ8ZHqSYSNiX5wi9VXr8uIyXdxGKej8ihHZxI71MlaT9RCvLaICVv2hGt4JsFPUjfmWdVwLsdgUwEotByjyEHIkJE1ozlRObFR8BcfI9WD/cbSMNQDEk1/gJK3M6yMqhmsUjZgS9mR7sgZHTFFAAEZ85F5Tdmd7dlUEwAKsALL89Web9mk7haug9mqzNlOodmvDdmzfxP9ry3ZtwzZt23ZunzZu63ZvUzZv+3ZwxzVwC3dxIzVxG3dyfzRyK3dznzNzO3d05zJ0S3d1gzF1W3d2lzB2a3d3Iy93e3d4Iy54i3d5Vyx5m3d6Iyt6q3d7kyl7u3d8Zyh8y3d9qyZ923d+IyZ+63d/6yR/+3eAcyOAC3iBkyKBG3iCIyGCK3iDnx+DO3iE4x6ES3iFPx2FW3iGyxuGa3iHWxqHe3iI5xiIi3iJIxeJm3iKWxSKq3iLUxOLu3iMaxGMy3iNTxCN23iOKw+O63iP8w2P+3iQ0wyQC3mRnwuRG3mSvwqSK3mTowmTO3mUVwiUS3mVIwiVW3mW8waWa3n/l7sGl3t5mEsFmIt5mTcFmZt5mvcEmqt5m+MEm7t5nM9Ez8h5ndv5neN5nuv5nvN5n/v5nwN6oAv6oBN6oRv6oSN6oiv6ojN6ozv6o0N6pEv6pFN6pVv6pWN6pmv6pnN6p3v6p4N6qIv6qJN6qZv6qaN6qqv6qrN6q7v6q8N6rMv6rNN6rdv6reN6ruv6rvN6r/v6rwN7sAv7sBN7sRv7sSN7siv7sjN7szv7s0N7tEv7tFN7tVv7tWN7tre4BmTAjWm7dhMXBnDAAwwPhNzET8D5t+czcTGQud+Eu6h7dhNXBngABtyGu9vEztB5vEc3pQFAAi3V4BQOv/e7mdEEmMDnRPIQvHP7O8LjRI15+8Ind8Pju030l8QrN8WLqXFh/MQb/Ew4PE48VmR1vHBrvM7wTMmb/Mf/e8XbBLyrfHCfPE6ge8zLPMuHvE2Qya/ZvG7PPGO5fM/LNnF5AAUYfQIZPQX4F01YkdD3NnE9VrtHUiU5vc+zfDRBVNXHtr/vhERpfW5zfU5E1VR9fW2Hfdl7vEOFeUAAACH5BAA8AAAAIf8LTkVUU0NBUEUyLjADAQAAACwKADEA9wLdAof+/v7u7u7iRCXt19Prt63jVTjlZ07nh3XomIjqpZjmemXsy8Tsw7rmcltISEjjXELu4N4AAADpraHa2to+PT1HFQzokH5YWFi4uLjHx8eYl5d4eHhoaGinp6eHh4euNBzZQiSOKhd1IxMZGRnLPCE8EglHNzQpJydjHRBKKyXhPh7GOR5JIxzPaFOvmZWOWE2OdG7MeWhRQT5qOC2weGxwWFORRznMqqTXpJmrOiNxQzqiW03TUjm0QivOh3ppTknYnJDFXEiXa2KZMByxgXepY1aOOCfLtbF4YVzYwb2EgH+jLxq8UT66b2CrjYaPYFc8IRwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIUeIEDh06ihxJsqTJkyhTqlzJsqXLlzBjypzpcEIECgY3nIgwwgEGgxFO0BxKtKjRo0iTKl3KtKlTkzZxDgywc8QFChEiaCjoIMKEp2DDih1LtqzZs2jTJoxKsKuDgRiyfh2oIYIHtXjz6t3Lt6/fv0XZCrQZIQBBDhEuEAxwE7Djx5AjS55MualgAB4aE4wboSBWw5VDix5NurTpypcvRNgA1CvBzFtPy55Nu7bt2ywvY41NMOvPgTbf4h5OvLjx47Uv7+Q9cESEkAR3Ip9Ovbr162OVazXoHPrADc+xi/8fT768eY66txf0XbDu3fPw48ufPz716tZzB3bNT7+///8AhnZZZlLBlRVQQgWo4IIMNmjWZYSBJhBiihHUwX0OZqjhhhy+dBkAbhnoGkGqZdDhiSimqOJEH1LF0wVdqUfQCCOsaOONOKr4oUA68eSTQXFxkOOQRBb5344NIfabkUw26SR1SDIk3ZNUVmmlbFEqlEFiV3bp5ZeOZQnmmGSW2ZeYZqap5ppPBbABc2zGKeecdNZp55145qnnnnz26eefgAYq6KCEFmrooYgmquiijDbq6KOQRirppJRWaumlmGaq6aacdurpp6CGKuqopJZq6qmopqrqqqy26uqrsMb/KuustNZq66245qrrrrz26uuvwAYr7LDEFmvsscgmq+yyzDbr7LPQRivttNRWa+212Gar7bbcduvtt+CGK+645JZr7rnopqvuuuyGRoGQ7cbrJAU1ymsvkRNsUO+9/NqoAQYn8NfvwBxeEAAF7xGssIZvOSDcwhAvmC+IFUZs8X8ahOTAvxd3TJ/BIH7k8cjwCdcwySjXB+9bHAic8svGZSzQWxjACfPNuIEMokAV4+yzbQ+b/PPQtIk8s0AeLEn00qLJfDQARjMtNWU67/z01FhD9rDVAJiY9dd/Rc012GT3hYF3Y5ettl9br+22Xm2/LTdacc9t91h13623U3nv/+13Un3/LThRgQ9ueEyFH644S4kv7vhJjT8uuUiRT255RpVfrjlFmW/u+UOdfy66QqGPbjpXp6c+Uemqm85666K/Drvnss+uee22W4577pLvzrvjvv+uePDCG0588YIfj7zfyi+vd/PO2w199HJPT73b1l+vdvbak819919/Dz7W4o8vdfnmL41++kOvz77P7r9/c/zyv0x//Sjfj//I+u/fcf/+sxgAAwixARJQYQY84MASqEB+MbCB9nogBOMlwQmyq4IWVBcGMwiuARxEBgQgAAeJFgAPJqABD2iACAFgAQG40AAPMIABXFgBFxbAgwtZQAJWOMJ+DWCGLgziC/8PIMQiCqCGNlxIA4TIAAAwYIYFMAACcNjDbTHgAA1AgIQGwoAEFMCIYAwjEm0IGgJ8sQAJAAARi5gAMCZgAAooABqr2CwCKKABaRTID4vYRD1+MYyANOIYXwiANgpxjUX8YyAFoAAABCCEW6RjsJYYRAMAAAKKFCIOH7DITtLQiED0pCgRKQApQkAgj+yjJGFVwoMQwIgJIGURJcAAUXZykLbMJSAZgAAhNmABq1zVAAhASTQOgAE4pKQQDZBJIzZTl0LEJTSnaUM3BvNUEAglGGUYRm1Ss4gH8OYRPfnMb3YyktcEFSep2ctcKjOMBVBAArQpTTAuQAFgRKMC1mn/ziDyMJ2gqqU5xQlIfE6znkLUYgACIE4DLHSh8NSlAQ7wT4BSCgFyPAAVX9lPAoQzkAYQ6EED+YCHBkCklaToQhfgzAEsQJyyNGJJExKAU1oUUdq8oUBQSs0ELLSd2zSoL0WJ0FKa9KfdNExMGbDQYTYgigQIgCEBeQB07lEABVDhTQnFUSE2cqEEzaVCA7AAfnr1mSENazQBOVaTDgABMdViGBvwUEca5qF2ZCYYHzoAC3ATlFsVVEwFMADDXBWQ7wRlYR+6gHIasapIBWRRIWtXk8a0AAGg6lE3G4DBNtWxQURAYAE12KoyALRCRCMEplrExZbwhC8E5AIeiknJ/wIyqpwNgFCDiFmzFjG3Ju1qJRc62ESiEocESAAwRyunkx7At0FkaS5ny9ogKmChyjTAAOBJgAUcgKIDgG4QEepQ4FaXkY8EZGEH4NrNJlYAWkRtEHW7TXQyF0zEXeR7FwlZz+4Wq2EkAFBvGcSPCgCywA2AbwnAgNUG+I8GmK179yrfTjbyvvgFTXoD+V/eBjK/idyuKPcLRiIiEcEJNikEDvBFBYTyu481YnsDQOIr9lMACVAlhlcEAb824AAIkIBBmgpJ+oK0nKidLU8PLF1yivKGJiimT1PM2AMoAAHe1GuB39tWEdtzAJmUp1oDKcIBQMCmO94QmJ253IcOmP+YN3YjiF34AAhkVpRjbi0L2JjbYUr4vN208zN/bAAFhBCeTQ2nChcKaGiKNs0ZCitm7Xre4nYUr1aecmeLKEU35hKXmL3rQxH5gCWTmaH8DSMwzRjEKTe5nxeGNIMCyVQADLjAFXahAnbdyVAnGJENsPM9/9iAwmbZtq096q11eV0JdNK3D1ivEZmK6jgXQMey9o+XwRhV4Xp1AGvUMhgLu+xS8lbCKT7mjDmLUUbOtq9glOaMYR1ZxIbSAHbedBHpulChYtmcVMx2f14tYxqHcayONLULm/rYk+4wtwSA4gMOgG4qm7Sy3qXnvo+67WnitoSWLukCumtScfq6ptL/BqUtDyBw8rwUq49ejGYVHMYZl/vAwxSwEKOdYkBLwOKVFXVl+TnIGx4VAgM96iI5620X8ruuJXRjnivZcvFUd9IMcPGVD95vMLqY4qMuMSkTYIEDaDrBgAS6I4NuUqAi0QBRRaWbv9nWDRcUtxkPYyzlqfSCN93rVb/OnWFZxHJDVuGtJrdMz7vu3BJciB/PLds360hKjvG6C03ubHMdxs02OsaI3Xm+B89Eg4Nz2vYNPHE+n0hxaprVAN5m071oRNFavOOQrywB1qmAxl9cICv+pD9PG8SnfhPB2YxziRkOSqQbkQDODuLPU6963Nzc06nd7AKOSeZMEhTFKQ6r/2u9XVKLE/2QMjXnAxCQfOXvFaLjlvMjIy/36tOmsAX5exgZEHFd+x7xAmABNBdIUwZuBrBonPV48FVyz5dgjsRag0Ri/VROB6h8D0VQuCcAFQdcCIFm9vcYtIdVeeRIT3ZXowdcIAWAWMV8BdZnCIBCUNV34CRVMqRFtFcAWoRPKkBDK7CDB2ZP4nVpA8B65PRQ5xVFRoR5CzV5S1hXAhGCWRVwH7gX51Ve+rZIkUdlarV1gBRhXcdHyUVtFkd6vDVmMKYCaFgBaKgCFOVMAcB5ueRa1ydK7EVQHWaFK7VPi8Z2dlVuFjCFfVFOrhZIBQB2Yzhn0wZoZNVei4RvY/84h7e1Vg+AW97kU+REhF6lbOYEe2xEUIVYWN7WZSalXoCoF2Q4XPU2bum2gRm4gLgHfvDHYQ5oUhJYUNGEh3AUWlK1SAWAW+BGgdbFWYelS8tWXmO2ZsmGSFqkgC7EcqWYF0mFV3cERnXnVqHUVvmEV8t0gg/VYQX3Vma3UhKQhVMXSBXAWRDgWia3AHCVhbGoSeqWYMdkafnUYQXwgIG0X3C2c0FYSs/oEByQMEkxWGf3UMuXW82kadnIVwhgAfTnVvI1cqkVSkb3hdRUAXEHdZX1TF8FXN4Gixyof6FXROVXbbYEids0jxS1Y5cRFwXCEJ+xFKaHipvlerl1XiX/KU5KKI8IcGXshWVZFH+EqI3fVAF1J3cWqYspxgBPZQAFqYW6NFjaxWjGl35sdGOWdF8tqRkNARtKYYAyFEXVSJS8BVyetVBLJmEC5o5250LUVnmFh4kf10KAlABkZ4lFVAE+xXbguEMFd4iASVbQZHZeZ1LnpQA85Zcg5UnOOFofMgHUZxDBMRQ6hFsAQHBjpXmbBXvFRnmM5oYPFX0uFFWNVUkz1kwnd4U22Elnx44I0H/B2IS3do6bmVoJsE5eGJhQl2Ll5o26CGij12HXZYCIuYu0hpIu9IeBhSZS0hkzoU1RJU7HpEhP51bcuFnOl1CbKYbNVJ2mJmGV5VrM/1h6N7lrbIlIBWACnAVKJTRjTKibKnZwpwZorgVdeGiES0ePnLacXOmSEAEeaOMSMZWBHQaSogZcxPdCvpd5qsigqCeM+mlU8OlIw8RUDlCbf0ll6biE7wlcvSma7Alu7xcAhpeA+WicohRrALWVL8kQW9IzLoF9ngSfTWVWbPmZRlRxI3qgA8hhJ9ihVHahR0Wfu8lZyphiTOiNdjZX7FVOCnVzGxh2YYR5cFhKI3hNLBoRzrES6UgQ2ZlQ5SgA12mYQLZuA9qEJqWAQ8pG8zRxrgWigBRDE+WegSmkbkWNHpRgiTWWKRZT5VWauoZMSWlDCglG01ekUiVePsUA4v+FWlmJpf3JlQAZAUpDEhAgZWv5TAwwntnXZ5mUhfLHWXu6mczklDm1WBGao783huBWAU55VMV1o4JpRLq5ZGcHffNWe0uYgXzabnBHcJjFjPFFgOmUpRARJCjBeQ5FAHRJgMD1XjKonWaplJTHiYdkGMjJaZKHqMyHRDt5fcAFpy4UpVQ2YDuJgrpqkA24WbKUY0DUe0a2c7jFeo+6SsYKABeQr/qqrwUxmSThUbUoR82YoIv0lLRlqCb1TLLKVwkmkqHWios0pilmUGPEnXGaW6a2oDyJAOTKWdBVcbKUmiyoSZs1aKmYTxkVmQ10r1nRsi5bEF45EmG6fQuVaxr/m4GahrMcaHFq5WuYaEQSa17j1YLvCEYCyFnNdK5AyqNj2H7XelTKVADkKq66dlQwVVO5NGlVdK8OEZMi8bOj6aCdtLBvqKo42nA0eopPG6+l5GIgFZgal5wPhVqhxpeK5IhpO4Zx5Xjj6JGIZVLi6lMiqXd0xLUMwRgtuhFhSlgLRbXUiACvCXFFtJOf15mAyV5lm0+LdV5R9VbltAASIEMWoLEkmpfRhZ+05pE5FphLi64HGZiBdKhXGF2Du01/pKIQZLgL4R4iAZuMyVj59LZMB0V1B7FYFbT3BHOwN1EydQCjp5Nt9wByNKekVJG55U0ntqaAJLJ5m7fCC5iD//txh5m503SPFqS7pDMiGwG2LlR3e1q7Bppgvtm+TDurtuhM1NZQCbZk53qgvlUBveh44VViDdAAstu9O3u9qQuYXzqi9tiW8JVLV6pA6JsQQbERHjW/RsRvbHekJ/VUjhVDBptbDbxxnJVnGhVLQBsAzUqt7Laj7JqXI/xQKlidCByYAMinQhtIEhZTD0ChPTlFKNpJ9UrBkhoRF8IaGbG4zZhuSNuIaBrFDDiluUXENauryGhDQVu6tApcWXxEFje23Dpyjde6FrcAJHbA5bpIErZkOlxCteh053vEEFEiGcG+C7AA+WbGfOVJapymTKXBHxd0nQRZNQdyWKVR2/9qv7G5WX1pAQ+wfnaaYETYvyUUSjZ8w7DaxeA7lH3oS/L4s9h2QMypEDSiEYtLuinmSZZMVrlmdpwEdwbYAHlGbeLVyn2aWo3HWjwXAJNMyaBlyd6Ey56JpEHntAIghoCpVln4Vg7pxWH6w3OcuC+hrLOYy4vUez05uiMbSJBrS9qkaY1Go8QkRY33igv1yxbXwi70lBmryR6JADOsob55n1TGqc+XQaWcEqmqgUCXYNoUV5zGa6zcSRagAGA3AOPIjfu1xWlbbumcwFIVuSXkfSdsTylGswjcoWacgcpMZf0YYBLSRaP8Pm5iMy+htu1rZUJ8w12EW2ZFywPVSW//DLzaelLkOmwPMM+bBdG+nGLC5YhvFUNj6bhBC1QK4NBv9WPgOYYd7UZo7H9eDE0Pe7cqa38ndcg3DAFY9qqGWcASYLyehJI13Y1FlFy8pcwER8xH9XcWusozSGX7Fb+3Zs9pymfwvFAljGOJJLFifcjd+Y+LMbcm/M9ebNHCaEvKFWYqLUQdy25fFFJNp44Pes/U+NPhCsMKzMnrWdk1ucJSnLeyNHHp+sS6xH20+oE3mEdHBailVMa6uWx/TL7e7GYHOH21e2DwKU5jddlnvHzq3HYNmmDLpsM6m9hGNNuUx8fxql0c6bepRbDs+XdS2HLVZaBrmbbJFXnQ1cq5/y0A6QZX7DfUNx3Kb3TFk6uuhffUbhTcNAyaKVZbvKWx3NZn1pTXfEVyJkm0F9eewyZFKwVPKcdH4cR+VTfcbnZGPC2M/FSR3e2Reaab4hR5eSzcusjbZp1si3yBYaSeAI3XVPaLn4jNZQlcz6TKN3xeH/1Id7uBz9RW/+VN1X1fyCxEZydLtneI3lR+y0a2P/XiPOmT6v20CRrATXdoGl7R0sqq5cQCnBV0a1QAyo3AUauxoUhlzD2xS964+zVyzBSU18qUUaTCzQhYkEaEBajZ8ojRPQpzKF5C/AR+2Q3BEnbZuJd1SYiiATykCL3iPCtITdu9EFBkfOvjZBVHcP+H39xKw5DbXl+cSOA0QzsNwVpkbHuVZqkqtuRpcaYmvt5k6CSaUYsFAFkstTKFiC5UWOzMSPqbeX6OwMvm5Ire05A367Z+iHGcSEd14mUVYDv212H7nYeYge0lTrklAfIMVrqs7J20WOGMXc4UU/ELz7jn4ZrMhE3HYoz05rd+w8BeROimgKy3l/eVrfzWTHb9a3HdzWELkQllRAKIz6ebeWUqpcuEe9yetwSbAO6d13m2bv036d3u7dDkWoCmwU7ngTe1uAE+3zfJTIps4bp9p7Bktc+W1TOaYI9HmkAUUnmb5WRFbf0u0WMoX+daXWU98BYHWs9UkmxbSeTEXAz/b4QWsJdGCu6O3N/oTbI2DcXAPu2a3mX5juV1qvK5ftcZqvI0CqcpdAChm9yben1hOsEA9V6/lOfBVapZ+HjpzlnVda4qSL+z23ljGEIOrfRHNfK66V1Ob1Iq6Gv6B+poD3HEe7DTlK0CUFHp1HRMNWBGV+Fw2lY+neAjflQSwEk4iJ1g9E54OL9SK3kgP/dpD88DhoewB+RFa+OSj9/TRFcSvFVc3M52lcHsV+TDPfj7bb2POIN2pABq7FhDj/ZXpFJBqsmPd7SMNVstbIUiCfSbr2wyNMJMLAA8J1wV1ph0pEM5mwBhbd9Y2MeFXWm6eYNl/ejtPvetS0pWOE8A/25SDnD2FndZCPpdkee46KWbuYhzs65N5YVRnyjv1vVx8A9OkgSd4S/Gc+fwg7qCA5+BH4e5ABFA4ECCBQ0eRJhQIAMBDR0iCGDAoYAHAw9UEFAggUKOAg9MdNix4ACQEzeKJEhyYgGUAFAGQFASgUSHBQYMUFCyJEuCNHX+bDgAwFCiRY0eRZpU6VKmTZ0+hRpV6lSqVa1exZpV61auXY9+BNkRLNCGBhkcaIBgAMGcICu+hFvQ50QGENoKgBhXr8K7NRPIJNAQY8O8ewMEBqlA79iVLwkUaPig5EnDAl0KhKBTMsgDMMlmXEAQ8eefBgJ4RZ1a9WrWrV2/hh3btf9OBQ0UEDjYFyhulKMfVoY7YPPKuXiBnzasEmSBBjsdDi6r8LLBBQcMQJ4YWm+CuQrWipTwWfFxgjFJN1zwVycBAgwwIyiAvaRuoAVk38efX/9+/v39Ow3gMwMUOIA35UqSAAECv3uJMdPIQ2g6gRY4TwAI9zKPs+aAgk4A7eDyzSHvOJLwQvl+6uzCiHQqriGbdDJouJ/o2+0/G2/EMUcdd4xtALQQgACACgXoLESHKCPxIJwKMABJFRNi6DwGDZryyRVLGkC9nzqsUqQTo7NSJC13e7JFAYx0qDjeBhpzSKAs4DFOOeeks84bQ2TgS7IOoLCkD/cK8U+UunypQoT/xiqszJIeNFOwNPWKEqQ1ByoxzANRtDLDIwPYkEUFDCgwAQkI6tTN+g4Qyk5VV2W1VVeZMrIATUkjoLgGjlsUrgzzgiABBCY16LJZLfgyxYJKNc7KNgUYVaAE9BRgMJsgXS/MjmZ1iIADLBD0wrluFYgs9/riDVlTa3w1XXXXZZe/zHRaoFEWH0uTUMd0stcgxoj07YF82ZRMowAGkA/cgvoMKwAIZmqSvO7k0gkjY/XSM6EBELAAWAj3bUjjgirdroEGkMT2SGzXCm9PGYdcoF2XX4Y5ZqtK9hAmA+TVzOO40Oz2II5pM4yABHoOIGWQFiB4ogeBI0CB2wwyt4AU//7tKEQnB9J06QuX1fo49v6t8tn19FTrZ4duXQBa0hiQuW233475Z54GMvq88YC7FEyF0PwJAoQWtk3nhND0sSTByTOSAAcIAlmhmR6AXAH3DkL4ocYN+3LygQYggOjB5Ut0IHoFGHEg3VjS6YAvvxUNAbOBQgBu2Wennc5lzzSI5p+oFmnWqw/CGSRCk3Zo4gk1N+hLxfS821rGOlvcsLm6LsiCnawcYMMCgO3UAN4FytvJEOcWyKcCQmsxeNINgkDoIQmoPX75588vgC9/D3BI5CtLQDIDDifIylx0PYIwADcc+1DafvMx4gnAAH5jnrUIsgAEIEA70dMLtkJHkP+fWeZJEOjS6X51rZK85WIN0FOzBsKABKwpRA9Qm/AQor6GGIB+N8RhDrsyAJpsb3AgaWGkJvI95+ELWZQZ3U/ykjcVFkRomrOepCSYEAzGJX0JqVtDDDZF8AHlgQrpYN4mkqLLjc4AEoihSRBSOQd68TQ6hGMc5agU8Hluc65DUnGMx0XGDQxLAoliAVQoRs44q4QogYCMtsjHgVSRARJ5AP4GcsWErMyOT2JjIRPCtSspESVodBOwBmCBASUgJ7KynxfnuEpWwjFCBsHA3+6yR0YejCYNYNBNcrc2j8DoJTNpQBMR14AHSI5SBsFgiGjJpskoBAJgMcD++PgZZxr/7l1A+R4hyVKQNiVKiH5qZTjFObtgUUlBM+CAxZD2MfAxbIMQqlVD9pghBfjNdAJai3AO2asR1pIgbRIcBvX0r+mpiHOTu9xIVPeA0L1OAP9agIwMkMmJABB8Dq3WQMz10ACia5wfBSm7RHIgEchALw104EAW0BxUBg0kWpsVTBeluokoAFotVJo/MUPAg0RPjJJ0lsiAGpexTGukLy2I2ch3KLcIEAEJsKdCGCDAnBHAAgn4jktuJwCsWmdAQGFbSMU6VlWhpDghqKJIojiRUX1zkS9p0Zp0orm84SaNhLlm8RL6JJ4hxKc6ESYjZ7XUhNBHlI8ESWANcp6JZQmr/1QaEvUmqcTz2JCsl8WsjgalEyI4YAIviWCLpJkknSxRJ0jK06b41pjb6RRNow2AA/oXn5LodCAZ5UjqmJoRi2qzeP8cY1KHRNiBqG2jywlSZpW7XP0gpyM/zQAFMoASASqmtHu5brgMRx3N6c4hFSkZEZ9LyjMiRLcHSQGZuFgiMS7Rc3papl5Is7RM5jGyHhSuTEjTmaEclLn/BbBq+qgQAa5lAg6IJQkl1d6qEQg38fxjLxvDkdWaBE1DHdSJmnfP2lKnQxlRgAXE+6T18HBTfeSY4Paa3/pYJFccVhoD6msxBOXPiw0wgIJqkqoA99jHUxHd0NgpGk0KxAEaEP+JIs3WpSyVayJUZdaxanJJgaxso2h6Zzn5UhJprnUiB0HAhwUQVdsKZLAoxV1BIPAl4hqmqPOBcU0KuN3DTMQCHMGJPL+zngUQ4LgZ+XGgBb0Ugfhmw31kgE0bVhAObMC5mxSZBMx2teeRRi2Ua+FLsvcbc9mUznrRVoFsHFwnvpibYi7zLmuYJVOTqpkX4twC1nw0rMEZuCcWnQRGLLq5eoYs8Bt0sIPtR5BkGSUeSGeh5tOtrf66Iyve3IcE+D+k7qVUNKKlmpT04bemGgIM+E4HF1uS+OKtLRMlyKyzwz72kHnIrzTLXCvckAQI294/NjNPDaOBtNL41RAzlUX/K0OfzoCSdLs25Eu5fJBn1lBwJlgJwvmILeLC958HuPQUN+1AgauIzan8TMvuPXLmxjkkBTyAqFGCAc92JIsdO8i50lweyDxAAjI2TCZzmZKFGrsnizpRuUXigOooAKqpfu6/y+Mn8J2o43jjiKTVIuvDbIvKCAkRAXxbQ5J3faxiExgEzKQ1xhw6IdGdrkL01OY/A8VJP3vA1Q0yugLAFqWSBbjSLmaABjydikiPS2rlmZBSFaZF5IG2uy9GoxNluT0KGWWI10LRidzK65cfp5fxQqOZGwnDAzlwgpWkxOsYcyHL8VF8foY830o8AOtMCMcUu/RiW6nfgK+ar0Sm/zMCVJBBt/P7XgJ5km9+Zn8ZqjtKaNaABVTnAU3CfPTlOGqyCJIth2xJbJE8elqJDjve42a16UYWnwMngqLz/eZO1Gbg3B73kNewSMw2+wvpBiJ3LXKdZahgcqO5AcmVvgCUn+L7CScxk88jCA7wgBkijaXSpYMQGyKZO7IwOwiprslyiEFSnQJAlTBxv8rgHNcDo09DCG0SwaQzHFNpnhYpv0LbnSUTwBiUnQBIgLZbN9rrMLjYgGQ7GCkJjoQgPwnCFt7gmBOEiw+0trNxt+OwOMfBFBDpnLboQIQoGe86LYIAGngrn+1SG8uSwS+EGXVblJgCt3SDFthSCA24gP+DIMD9QxxsspLpeBjtqr1aQsK4QJZuq4wm3Jxzo6DsQgnBQy4G9BM3eQsMnIhEqZTpMI/4aJgYqjcwlER2Oa5pQT4RCSozkbuCYLnPciLs0JOugT1AwS3D2CtTeprbkgl/ukNNwxcVSTEzlJSS0MMSDMKYux7Nc4sNOQB3M5IRQ6m0IL9JJMZXcaN2Uh55Yb+OQLuBGYnQaJMPyRDwS4jLGZOJgTYViStGcolW7I1SVD7IaIAyXDyQWCRsSTk37B2y0EMBSpH+4biFkAAq05Lk47nn+50Uw5li5MeyCsJmExe9mI4jOIEeaIjSmaADUICMo8HlYJrgE0gKEz9G8sb/o4qwl+C8J1u063NIPwOVXcMojjuofKM1CMG5kTiRt9Kt11GAfnTJOZGXuDPEhRRBegGBCgiBGkKJFLKUCkLDEgQUmhA6i2EPJ8o0v1KRPAy8ytqtnNqLywBInUi+vkDAgSNB6nORjdiTl+RKHdEmDnQTcMnGeHOImxQBmOsInbizJ9GUCtSXBdIpTcENfYoMQqlIlOiU/4sLK3QIQim+qvwbmZu8pzJCkTgvF2MRaurKxbSRRkkjd0y5nzQIeLyZkhABFACBFgQ5NeKIomPINVI6hEAWzbyQXywOybrLQdG6vYjKviyntoSQiCoehfwM0jyOwoEW40GzCgkrxvRN//2gvNqMoaGUMLIIgQoAgnVMGIVok3/hmEMEzRwcmNWEkCppkZ/pltTko61zEciroE1csQHQnOCsoZTbxJMyPoKQAAOAss/gsd+ET9hYCBp6soV5PnOxKL5siA8wAU/kiKK6JGzBO4Ggj2UsGngZGJ8gzhEkjOJaFHCMrfebzO6TUPyjNwnCKI6UOfuIzw59jYOYt5M7jRZxSwJ1kxiQrpEqSo44rnxZlg07oQNwDwJcCz2ySlIzl58JmxTgk4VIOcDEHgUJRfiR0Ncbku+BAKrbyc/gDV00lQbw0CjdoRVNCRt0yiqjxb05lwxAsNKEwxL8kj9ho434klshwOTQCf+/+ct9aZ6kGQxfUZolLDPkg0guCtELhbexWND2HLyQPA+Rk9JArQpy2ZyA4yCZuBzOM42ScQ8H6ICN+QnoLKAeqiFBaZGbkI8vup3z5LWFO4zV0dOCaAsx+60ibT4JnY7L8NNkKaz8g494HAgnTUTuPJPN2J7SEtRclQpssSf9xLWmm7BW3Ym1IMC8uIAFPA5Z9ZhveoAl/KlCSwDNOdO9oKhcIjdnHLdoIYsSSZA6fT+h4VSOyMg6tMUIQ5Y1Ic+Hak0JfEAWeSNdhdel0JOTUB+kIZo8I5J8shdOctAI28HjyCR7NIgWCawDTAgbNYyVkSnpTLfn2CaVkg+jKlL/PMtUFVnX9fmhhcsk6KTAAyWNRZKbeBVZpECTtaSPaLIOEcMiHCsMMyKUuZBYI11FgVDDv0GAwGFQF8mXw3TBVyxBnyjR55IPfyEIJz1YR5kRglidie0I5YE8uOBTTEyIavW1/Ws9hWEsNTMTYBvZkX05LerZihKJUmnWb4pZrGHPz6RDUhOITkRJtgVRhRwqshFVQJxa6qxGkRAajTGSAY2SwfiUkgwAGv3W2pAkNHHWtvChkQKL9gSg00y45TQbdBOIutEIpsvWygPUL5wADuiArsWKGKq1UsWvCSw2c7FNjbrKZkTMGwSOk2ExOWPa4vhJBmiACogkM4sPhNQ//5CQTC7qi2aFQJ/tKLGNCxqpxc3xCWrMm7uhKgZhoc5RyEurR53pQmGbgAigAKiIgBMAXavIq4u8GLUV1pU4P7hgoyZ5LNDr0rWFy2OqxkqZi6spPs00oMIUixqyOwXhE28UI3+qFeaYHCN5J4pKiZlotZdID90LppdggJsrte9iEGhRXYeQ1pTrpxU6St1pyUHL3u19CgeIgAn4XqrAStnVQoRYO561CMjgXZXakLkwHkd134ZYS8RJP5+50qmVj6H8NvylHJAwAZTYl9StjFk5IH37uURUqYct0otRudZ9lADgGBOVWoWZCwIIX5AAwB/7YKjQgAjwgBKmCs4z4v85c46LRMSggJKrPFZO8dRa0hYFCKxKCU0W00srKY4K+CUXOeO9yBuWKNDyTZT2NNAnpjPAMpJmIbitFLQvfooA0F4yBjIWZB8JWF8nPI8NetHYS+AA2EE2ClqUqI4GmELyWBb225cBRVOQqAC/A2LwwBcjaSwC0LU66kHYYdq9kY9mESMcy5Utzojq8+BJhgoKiIB3pWSo6D2sIpS6iS8QuliNGWTRVOKBeQEWaAEU2kimkSLyMFrzwlxYK4kKoD8JJZxOyojf40zqAIrkhYuxnFpFUywG2B8LTak7XY5iBuGn8IAI0IBljooBy+V21tAHVePiRGFVq6m3/YAKIIH/BfUSh0Tla54QwLKSL6mAWA4TU+MOhoLeOC6I0grXKVImMakQiLjYMeLnqMheBxBoqMjfidxCN9kjAKhff3NdKxaADygBEihpsvRdCLmfcnotKwmRFNjlg8iiS6KPCuympQ6AAhOTu5oWNBlHaCmALvYxSIaKE4iAmAaQyYQM2pLKgh4j5xCYpjxIhYgX/c1cASCBEqABeOo18qDLjLiaJHqyR7uQRGMSxeGjPqsMMeQqjqAkEL2O/wkTeYYspWtmOfWuNRmohdCNAwg2r36KDYiAzxXrpPjotJgcP12k2znZqqkxNesczLCXkgCBFHhU8vCl6jTHCSoNjkZKCVKg/xqKjKcrwpwlXanGsyusabREY6DoxdeL2A8Ro68JNEiegAuQ7umW7jEuijC27s82ihbBJd6MYHO0aCmjaeSzI8N64+Nok3M+3k+jD+ZjxYjsCGHOFpSw28ceIuE2qwj77bwrDfQDlgqD0q42ZgyIgAI38ALv56EQYRLW7qL4WtJpQI9RHmwZ5cRuyOXkPqn918qQTbhWkcO0cD7SzpcAyEOuYVZFiKmKjN8NEwNiQ78bU1UEIh12towFig4OMM12iu5tcKMY193IlwZ6oLyhMmy54c381cPQ4ou6GSSpWUC+Sly5Vp4ObhHHUPdcmCYnROPFs++xXYoAUhAFHe9Lcv/vNOU/qW/11GWFII3NZS4dZ4oOiIAN6PGiyEi1YYk+yxdwVSmaeACBQ6mYPcwkMjaX6ICWc+sqEVC3ZnEpbghpHWeKlKCovDsQpWmvyT/0lKK6Og4BEpzXGaqQfM/lgvOluIAIyIA6Jwq+iaafgDCMHRRCaRx8feF57aJvPjsK8M/wi4wPqWazkA8ERCmnARVoZCvbGvHNunFsqWeJaCkVEaCgrtpH4Rh4Ru0dNghZ5ShxFZAcN+anGIERUPWhiMDtyhKMcx21WJn4cuy4aJO5WXSOmAAKEL1Ove9p10n7nm+UqEEC+WYq1alkJ2Vo8ZcL1KlnNQwaQRMTpzDsiK//yXN1IlbM/yr1pCBwDhh33RHYgiBAOa2lDIk7k8sIlKDhJWZiYjt2hp7il9hihpcggXdgLc6SjMHSxCgz4g6Oyf0Ja0ekz9GiIvb4IN4mAKt4pOCACMAAVT9hdWSmSJ/a73yJFWsfQYl3kXjjy8jC3kXxgxbRb0xoZLeWFWP2C8lGc0G4GDoub72XlZjjFlptvTWl+vD2BGcKsB73kJSsaf1PuLUWTn+JDXC04n5fJc+Xqvd6pr8QfvpJmCcPRUo1lMKwEmk27sB5x8DbjmiRjTCxVXProfW02iL6b2eKDIiACxh3C+0ZW9NSXJcgQQxzD1hDj713V2R9kWh5a/GN/wFlfPJgmDCHtYIJeoQo0NHOUhB5qUnxs2L6EN2yFbVTOBYZdcwq+nFPipSeUJtn0eI3St54HJWl1kY/iEP/LLlkE5zlCEH8Y4CylClHpidpdwltfrh4zkIdahBlWWslborja8KgWkt3k+gHCAACBxIsaPAgwoQKFzJs6LDghAgUHlKsaPEixowaN3JUaEAAyJAiQyIIYPKkgpEgT7Js+XGkgZYDCoQs8BJkgQEtd/Ls6bNnBgoTAgwgQCAAAJM3BSj4eZLBUac/GSgwcECn1KwtE6gU0NOB1rBix5LticBAAwlEu2LVykBlyZMEaAooEHXnAZE5TebtWmBtVwF9Rf8W7cpgpwQDdAN3VdDxMeTICgNs0CD5MubMmjc3DAABAAHGhOUeHixS7c6kfOG6FC3AQtnYLSdQyLATgcq7snfzPolb5dfeThEUKKCgrXCyEB6IbBA699jfIBvwXHC45wKVTQGkDLzgedcH3UEeHcC2pWnXKjmzb+/+Pfz48hcGaIAzAQHmTAeYFxmXK07S+ceTaoCNdlJ2rv2VnFgEHBCDCR20pJ9ITTF4YYMqPRAchiwtJQByThWYnAUqAThSiFktgIAFuoUlYEgmwUgYeF0FsEACCUBwkn0iHSCTaOmNVMB8RRp5JJJJHkkhSGrteNIAZykQVY2MJSDVAD0e11L/lX51+FNSPQoAQgoesMQkSBZ+ydKIX37o4klgrdmlmmv+tFhICoiZpp0+zeiVgTCZJJpP4/24FWMlzcXYAko6+iikkUqKUJcLOvWhAJj21p9oMfWJFEsnhlTDBieVONKVn6rqWXd2+SRnqAcgkOJYQgK66k548jlenbjeqN1TaO4VgASBOdYmlAs8iahKh0FgFFEDCGnApNVaey22mdka153aDVbAAsLZKlKqvmLagAcXmDSTSJ76qiqtLMFKFJ5wiiWkpbgWOF5IUQ3AQLyrmjYslAQgcEC5Ji3Ab13LjsVpSDEJeNSf2TY0gcUZa2wtpuQ5tSdIsBV1XXLSMZyv/1gLhFsWpjF1IKe0DxjA7bvvIjsvyAI4PNZbI8FWs8IqUQe0TwQ0YIAFAfskrQEGJFyWqAIsrBKOXW1sEAYcOLDB1V17bSRjQxetktKbmpRfmmXzxABdrkbHWgAYUNACSAaQTDTeAczb1dO1tps3pnfjTUBVV+W9EwMHNDCrrVdp2PUEGjhwgQYYf3055u0x5m51Enxrb1bItiS62j1BDJLgWOJp6QAglPBBSCsfDrQJWJ0OUt88H3AAahgSV4DhPnVFM9Ewyu4rVQU4x1PUIVHX/AEZY7CBAxxgkDn22WvGcEiH8pRzprNrJWSvWUlbXPAB4EZCBbAzJf67uFWQqf9OukoNf08fBjw80X3Zz7lsBtCd9PGkSk9rXvc805XPVCsAGriAAzxgOe1RsIIdgYD9QNQT7iUwgMr6FKY2lJwegaACIagL/lYFoPmhsErlI0uUDDClCxVrJN7bCfdKF5ailA18ItkZDIeUAIQB0X7IEY1OejYSBkgqA9S7gIQsKMUpaiQAB2DSAwhoEgi4JjYQMJQEEnA8BglJbL0xDQpEAMAUfokuLBSAoj5SAOKVhV0dFA4Hc0evATFoPAaIV4KQKBuBjAt1LAmkXrCiROgEKiQDcFQAOgDBDWSAipa8pEVMAoCoueh2KLpRVRSQOp50rC5j7A0iPcabohhlJCH/kIFWRMdGqXARJG+sC+iwxBPunTI24zIjSyCAAAUcYJSyYdgaTYJAkYhwNxmsySEDU4ArLfI0HoJJkibggclpACmY/CY46TOoIe2ki1XqHXZc4zCD6VErNWqnLPFSE9Mc4GWztFNIbgmSXv5EOsTjn3C61K9k9cmTK0tAA2Yo0L+ZTkq5DEApB2qSasIEgyaSyYeuMp+sbe164fwoSAsCKoHiqAGL81yiAmCjnyw0JKkaAJNGmTgFtPNsDw1L8xiQAASsTG5D2eFLDMDPe/5Gn4K5lw1ZAlBxBeZHX7wjhlLpMSY1RUGmG0lcgLhMiULUNS0aCejYhiL3RA6ClQsp/1rTSgDFdAxNdakJSQJAUQEYc6KuOVTObpNIVbmVjkGxjfnIpqoCxVMqeTFqMmWCAAQItC05G2pZBPqjD9FROAadEQHmGrGe5CwB+tkSjwQ5TtH8RVoN0CJL6MSZ6VXPo2l9LUj/pJ4GLEAn/HmKYS4lmpJ4Uje3u+GaugJck0zAARKSyoyGe08oGVW5oXLNXU7n3N0IKbMr7RAyA2A/C+10RnpUz4aipICzNFWp6llX2WxFgMtEEoIShC18QapS0bjVkT2xH5Yialu+seRPayoQptpJOamEcLk+MQHVfiLVZrWFaQZAJ4PsGDEOlg4CYSzdAJbyR+0C67lQhZJsbf+onriwk4NYDWpdT0W2x2Rgm1D0ZnxjDM6WwjGi/KzSTZ9CABXXhWRdOZ5/z/aSAwBRNlUqQJFPwoFS/YR7iTWwA0R1Ux6TFgE7hWxPCCAB5NyWJxDw4UiSzJIaTkeOle2qj1YzEggTJUe0CrF6VBI9i8I1zvatTlM30gGtUVLGfv4ojefIGDEv4ABWwXKW8cOsPLWEokOr5pOhFjG1pYuljDTwTuQELcPaOalaITMcA7CoTPUyztOFUqdYdJcF2xZPkS5gp+Mcrr4Sc0Xqme6fiGQRbXITxn/+NRVXJEbXwFS4ROEnf6LE2B0GLAF0US7IimMBTOV4LLUNiz39lOb/sSTAAFnU4YXmlRVQT4cAOxUNm/GMVcGyxJMjASaCSFbId5/tx+tCgMzO3OSuGMBgsRbAlTyZVTjX7Scde6RDOGo9YDP8kvyat2fw7aMMxxVKLUOu8wImZvU94JnbzhsGHPBTngxgp+AObU1OvpMF9Ai1UJLAUcSdFTStDM6vVrNriFfLrjinl2LFXQBMzD9W/4Rpy/NJzpq5JwQKGyvkBsmP5s1MWiXl6QJY72QeGMEJNrzrFmyeg3JGvAF8UFcvfaa+AxC1ZpaF4KEui06jm4AWkeWvGOrSqZ2SSrazZDwFMAEM+2K3k2wVhVIReoVwGJgz387fdl5QRqeCVW17/3qiVtYJjPom0CH+m/FsQYgTq9cBr5Oeim491M/fl2WVLCjEKGuJ/UAXpdMaM6J3FgvFQfKAf+1VLMXFwIXwdcyLtgRGFYhwkLLi9qO2hM5hNotKDOB8qxLlJi+85idJriulrTVToFvgv1Wp+HaJVJIRrGTp0y9FY/tGhrkMMuJ9snM+Aon+2LcSgT42ErfenCcDTo7wxcZ27YxKVEC6xUZLIVojwRG7lRNY+YStVB9OiEad8JBTeFI7CVDdKKDejYTKhJ8AwFvQMBNStNjkRJH6pWAFzZ9LoUTiMc9KFVKk8ddO5EyKNA9+LJbKrYud7WAALFly4J1sPFMBoMbtVP9A2pVFGBlN3dTVyr2Eq5jGQ3WHUPVT9EFJ/TBKEBGfr8wdarCgnSXWnoDAB6TA1qCfCqYhBQlUVDwdT+3E7cTFguneT1DZrbQEDbaG8/SGZnHhWFQaHk2dbMAZNRUgt5RctSEgAahNl62LoklFYaHamu0EAtGWWABYAw6S3gUMmAXJztTSCohABZgQCPiaGp5i5giUp/iQ28jIpW2VU/jdKIHh2+0E4czQWEiABSRAW9BiYPwMWWRbbxBOA9SUVoDZX1BUBUSFFN7dYuTdqqQe8XQbk/RfB9of7m2cqThPkfVhXYyLp6iGC6BACbQPCDgSKqYj9gSGUogWmr3gunD/z+uJ2pDhyENhig8uDZ7I20gogInlY8iNHP44yMHNl0gcn9pl4ir5Yd5Axc6UkhOyRNzJBFEYGi7yTFBBFowklq7YBczZngREjgNEUA/wG8KpI0peja3sCJx5j1sBUxzaoqA4RTVB41hoykkMxqHYIcDJht3NktXVm0gAHodNXsmw3sNwIG9slQg2302Ai6jRhQIUWSSO4IHwRG4hDr/JFhmKogN0k0lYHUicZEqWpbWczxXuUWC4i5BoHjyeyaWtHjYuZFwSRTDl4QXyxO/dk5w9hQKIBwPICfsxFXBoRe715KftTkS2hNDNI2MOCblZI08IiecxJIh1ogCQQAiM/6IIuM/unYRYUotZjqakuBtdQcm4eI+ECQDfnQQE5Egv0WISGhHyWaYeXiXl1SJL/N+nOEgxSUWNSB+HBFhVakXzSKauVNtSJGHfbU7BjBEtxh6ojMVLCk9dPmZXfIAomhAJIKV5rQdphqejYIpxnBJoJBhqSps2pkbQ4SUcdsUBxsZ5KJhRatJk1idLAGGf7IlN7tRDaRo5XUhyGqeGcFo/0gRoySV8moSY/JFqmCZ+itoiElhf9kR6OOZJ4AkIbGYJoMAHnCNj6EYGiSeJIol7LtrVFecOBYbS9NaFRI1NxpAoYckC8YQHcICdgJ1wOICyOVvd5OPS3IQxskQEOv+Fx43lT4DPz2TXSdhZudRIEnaJE4rJZxqcAKzAZpKiXqCUH5ZRiX7pfJwoA9zNpt3dUvkETqLSYi2ABDDHHH2JQBmT5KwJplzfWKSAfzTibhhMJymlMnnnT9zaIR3AeGEFQs2MBGwZD6Kn+sTZk1DUTZkGc46MVGDAD5RjCIAojjQNAjxJV7hIR5IlmI7qZuRQaolEIsrGXKlNKqXqT9DTp6yqTwRkh2zXMOqTq5rOYhBMHcHNvpEWaHogfcYl4l2dUM5k0blZb5TVGQrIAcLIhrTJh+gaqVZrZkwfzUjVYvKGrlijeB1AuFybkV2nYWaWVHSrU/wkGdnmTeqTnYb/xYdIZk+kXoy6RjOl5VUxqhUZhpVJIqD2CWtRzk9FSXEkKE9QGbwZhrUuLHsh1G825/59ygLs6g6azHpyltCUxbdAloTxak/sZW1CU288gD7Jq7oJK28YBbhpoHHATWO9KrK6YmH211r66Vho3QYAXzC5mpHGLAYyLNBGxgBYAMIgSAZtK5dMKMkR6qzcSAPYRFQIhFZsZGxcXFgqxtFBn14A57KFxVdeiAYKBpASqT4xp1Ow4eyYhrtYXdmMRwPszG/Jk3MySOgJrNaSy9hk4o8FLd9uhKjkhNDZ5FM8o0yiaoRKRVb6jafBSC4taIdwgJlg2gDo09guoAbNTuIc/4BvIWWZkhzA3G34UKJrvKtW7FlrSUV1WqjjymzE9K3rXoRBRkzyyYSythtDxtnKnmhgfdLtYOiZXsiNfoqK9oQJvEQDVC7OQV2HhK3LvQhWLcaQNpTm9sT0zWdPyBKvnR+8FijochXrbsfrhq9DFN6noijNzEi+0FgLagUt5iqC9MjxHqtI8JN0rsmcgkneyJxPiCvGgYTZPszqXCx70qNxdIn7GqbthQtWQIDgpQ5HvZj5dMd4WW+jXZfKHGZOiK8GL8TyRUwCKKpcXVqR/ql6RG9OBiiDvCxPwAiGJget3pP+iq7ucSDyqu7h+hK+fgl/zJWh0FwAMCsl4d6RAv/dfQLHqLHeBifxQdjekAzItJyP/bAdhN7eMaZch+SwXv2oqmTACbTARcJPDJ9q9p3E8AoH/yWHPMJp4ejEtIrGB8wANwmk844Y4iDUj0GXEufxecKFnTFhE8/tCfvHDUsFmyItWVQJon3uqhgACbyO6oExhQ4yrtTpUdLbBR5MfBbfErUn1HXFhlZACYhADvAGE+9TMEUUMeWcHm8wA9vPX6BNntRpB4uE4CSG8iDA0xZH1s6StBQqG/1GCZ3QAX9JGDdphSaH5/AigT6gZZGrGONE2dyOp5AdsYiEdo5iCHSn4WHJALVFy7zbXy5PJy4AE2PdKr9uHzYTcrTMFA//JpdIMqaJz02UkAhYiDDVGtEUczvCsxCjavPxBxUexcNdSOoZIxiSLgIhBwGQISh7KIhW3AUOye5wkAQsjE2kR67tBydL0zmL727ZcJqRc6w5F23G8z2hiQjMgFoS8W4IE1oYRQI4oT4n5BiT8syGbbOImmJ+iXVkBQI5RUITlwfIQAWIwAqs5fh0Wq8MsfiFsDQxUEf3bR8+2e00WH0lru2qRCabdOh0iB0KwQXQTU0LGdReYAZtGE+EcYFMTP49TPkGwFWHLvwE9dJoyAPDwEP7iKq12zA1rVxhBVOHxHXoxBwqpKjoidOYYlQD7VxNE5sgjn48wHWoRmCXDyw7/zNX581qukwJaPP6Eh6qwGxgNOVMr0vnbgp/qW8KSVULy6xmVoAJBLG7KVeVDMYfxTXV+ChTNIYl2yKcLLbrLpiVIZqeuiBMLOK0PZgMs2Nm8/IBFMADZNUHlMBRQ/RoiUSguqO8HA5twllr1wz3ACNQIAELsMALJIGHjXWGVtnjuV0AqNgLGQVVAjffzptwkkUqfXfsYnZzsxEjO7IpywVW46FojFJp56inFd7/roq5ORlUIIf5WQ9I/9DalHAp05V6RBcQQSkc0nfQMrEZDYAAi7RGn21T1XB/q8pbBDPz4VZOT7hKFBmsGN0wR5ab0kzY4E+xqUcLKMFISpBPLP9TYqnvUfnmh/jjrAicoYFrRE8iUYiJBXj4wkqdBllsh6hiivPGivh1nywMD5g3T3Rk0T2Tc8lJNS34mizSzCCAIauK7ZEhOaLADgAnY9RVCRcfTTTA3bjo1F5hckl5tbazrTHUIVWu7mZ5UoeEeH/KBuDoO9PyJTfNTUyXnOCj+Jibza6Ku712UbvPHWKsdmikOvGEBJhUwpyMWOQROwI6qR4xWySudKC1pBE6oo+FAZPxpzwQHPa1ykFA2YAFBtY6rixSV2JqXiNpt/Q2S31Ev33LKO2Juxzm/cxxu1x1o7B6qx9FRgU7TYssAsqRCQuH1OZNzpAuhrzwqgD7oZv/jwC3G9GGe95wEad3JqHoX+Xh3mmDNn7y6RYaLotie7VudPfwuXQ+S40Le9Vi8RbXBq5UukL2eZq0O6h5LBs5UQpwZ5r4JposOqypd1gI0wNE95MgUGvGxgJQyJXUVwMAPKmK2lpeqDFjlZQVFKHSFIrXDGUCDch+ipykEpr7Rsziev01h52UMUtEOPBJxw1lyYcFeU0csGowCZItVMnLhsoEq6Cw/KgW5ac+pewIl75eCJ0IPVdXNd4Yl6rMuEUO84D3xE/DjwluHRyazgc1SJuvMFyYGM3Ek4qOiHRMk9a3umhciT1qMkwcM4YYC6Kz3HRwn9J+yQVErp0c+O6G/7ZU0PWaRAnv9ITCHVcQPn6HtEzHUPz1GtnKBP6o8mTTn01gN2XKMgYbGf1UEO6aNHqfUH5WvPU1kqD5wBy3MdOTADFghYW55RKHu0n0tUy7i8VEhgrWXjvqh6d3V7idCe66DJWMhtjdZ/btwPvNqsua4L6BevvhMXMs1gSiJcXpgEARPFHl4PdiyLq/hsRWx0bz1NfN3x9UvjdYRT9pWi5ACBAoYEEAgwcVDFS4cOCAgw8hGhxgQGABCREHFGC4kUFEjx9BhhT5cMCBBgcKjoSIgGEBlS8DDEgowACDDg4mwNTpQKdKihVTvkzwQECDjiMPLHSpkqUAEiEqVBCBof8nRI0KG0RMutBA1ZcNFBJVetRryJkDXQ5oCYBtW7dv4caVO5duXbt38ebVu5dvX79/AQfGa7DpRoIRr24scLUAWZEQEgskABGs4YVlMb9ksFDCgqBIN2aGCHnhggwUMoj2yFM1xAUJJh8kgCABhNYHN8YWSUNE1BAkBGYmsNHhw7MKb3skoECBhMphk0PMPZzhAMHXsWfXvp17d+/f3R5ccOC4wAcDEJxM+XPjgQCedSZg2PXhRgWRBegGSYCA7egixWpJP5DkW+iB5AobSIEAJqCAquhY+4+kyBzLTC2GEAipAw4cqOEDEBSirywJNvosgAQFElHCh55TKIGXCGj/oAADBsRoI9g2ggC8HXns0ccfgcwOAY0a+Iy6gQoc6KIjGUqgOJ22uqw+DN9TwIADnvyIyQw9yrK1Cy2r8CP8+GvgASwzK0+ApQJwoAMIV3yIvYpUGmABBAwwAAEvDVLMywk8cMABD1ILYE4BxNQJTOQgWlSyOCFKciE+IyLRxY8giHIhAjbjKshPQQ1V1FGvO/Szkh54QE0BHEJxIfcgYsBKlCJy9UA5q1OUoQEJuEoBSr1awDKBFhxpAfYSQPGoBBpo4MWXNE3xoQs8SC7CFR19FCQI1CyAT1cFuBUDDi948yAACCMy0Z7K4/IhAI6tqEZIDxXo2ZBCk4g/gwJU/8pPUgEOWOCBgWRS2oMyGtbbmCSYLGGF3A1A0vwabdK1Vz1C96NoaXrIYDZVw89AmOyMiaED51QxpE4vfWgDDm67VkJhGboIpHoFghWiaJ8SdINCId15oIgxAhbSbAUg+t0AWFZoMgsU4rgipRR4keCrsc5aa71aHAhhnLmCyODgcFMqIiZ1JumABwywWaducd30trGx6tLoiQVy9V6REkz7IA0uaE1mCYkDiWbFPOr0g94qCAEH1RYgwGiQHBpg8qBvZsjEiA53Gu+WOkeSga1JL930q3E2SGrD0v58zQM+T0ljg/ijdPayXM1KYpEF8DszWWek0uOrDNhc4o3qVf85JPQQMN6gm3LKbPD/Jvb9IdfX9EiDCkoQ4UOBLhdpgcSsDylemtb9kgDnlVuoWJFEDqBfwx5oetfT8c9f/x1XH9Yw3ejmP/bFKVuTAVfeVuSqhTEtVxXjSvJgwgDy7C0ip4leWaZHPY0UQGlis4zOMhAoB2ggBu5Tye2sspAOfiRbA/TKkEIUPoMwACwc1Izc/Jc3pClkAfvz4Q+ByJcd5vBkD+GdZUCGuYcwgDE2G5YMoWQZ+nQtaR6Z2J0sxhSFLNAjDXqQVzKoRJDwzlsbcgAHzKW6gZQvIig8iKW2CBNXwcqNXpnfwQhoAQWgyVDzCZFBqKgQBQSRkIU0ZFv/VmWZBoCNJGDLjRg/Ah+DhM5p/+mfQAoisvfFalbF6ZfyIskQNhrETRgcSR2PlpgCBOEFgiIU5UYCgWTNizD58kkRG7WuATAAWAc8TFkggCcDUHA/DIHAeA6gGwg40gCHdOYz8Ye9ljwLca4hgCNp4kJISqQ9/kkOBHI4mXqNslZ5WqFHwDUSaoGxNajEDAGIUAMHlKs1TDqPR+CIFpioSUUTGZrQBNIAbx7kiBTzCmkGAkrZ0GZ8aNnc7CKnpgNAk6IVvVpBzXYQjhHTINLU3QvNiRk3HiqJIXFnROxXOLxpUzRQY8hDhlQABejnZZTjZUTCuM2HTABwDvhZdBiy/0kjqtCkS9zVUFsWgGgpr6AsRWfNunTHgdCSJNWx6FWxCqohcsVLc4LVABLgJONIsSz9utWXIuPUnmy1dxpViNsgNbaPjvNvgbPcQSDwHL/ldJsZ2MA8NXDB5NCNUv5EYHwgdr2WcFNzAJ0PZu4oVEAOS6Hv6lVFRpdVzW4WPAHwn5OANR4LFCdBESPAAehaFVed8z1qDcBsOJqcriWGaGCVwECD1rWUBPCjLqgAcAogTowdhK+Y68AFzvjFFX3OaAtgAG5Vktc1PkRqk3ykxzYi0IOCS7JsFQBMPMNZ8Y53O9EqQAIOsCedjC02BEgALxsIkZP2MWzKYQxVdSoR9v/cE4pKRMADZPqk/hUEMjkoAXAE8DlvFldCIXSlYCFFyZK25lDuIYBUC3CAxZRIsVsUq1ceBlUHIrEn5DXxif+SstiKhIq/SkxNKmMABTQAAdAVCQQ519j8rgw2X0IAAvDrXMz48kVNIUEJPhAuDpNym2ZE447Ls2KYXHNGk6GkAPJJRDyarL5lWd1HDSKBA1wywTAZSoatg2I1r3kuTKxbT+qlyVqipb/HWwhHOUbOHc8tRNAdQIBYazjLTOYsJKhAkgvH5KABypVA23NTgquaieGoJYbBZusS7RXF7K2hOdQzQibFZlGPerXzdawAsyXZG/+xjTj2yjXDJeVXz1j/1iwUJWLu/MJqulQgIGhcUB/CYK9g4K/03PMpM5MbLf8KmwJ4H3Mx054AaCyla0Jg7SIY1FFvW804K875imcQFHq3IukE64dFwixngURNqlaJwT79kuM8wMYIw+3nIJLl7HlFgltMSbZEIII3Ezc6E4CBCUywAeXCtCK1PvZI6LZhQd6Ivk9kLHQwoybJ7Uuq8f4IuLgdcvLiLEPZAhYDmp2i9iQ1MxzriKlxPal6MsQCH0nSrw4CroHymlGYYUCPsbsQqIBgtDhtjV9N0DjggHmsLH94VQJo7YGcJFfStJdbK4kZR9HY02naiMjBvlnuKvXWlLtyiE4WXwIxZ15j//P4iJ3u5cVGZGJnTelZGTh3CQVT6BV4nNExc9wzdgBEUbPRS5+OmSPOL3hTp1Ugsx6TBBigAEaJCUhoSJPYomqYUY+8SDRWEo10POylx+pGMnTHyh5EqlMvj8jIOSemB6DdZUEaXDOud6RG/lD6MUygCSCBOk9JIR+gAITbVBUHDyp6+M73khMPdS3nZzb9qvlpkznbjl4FVhcmlpfgPZKUKzQBtI65YVxievVDE9aT0ndRID6syUwezXIGiasGlDwEJLMq9eLzcB8CnIRHjWhCPz7HegaAP/Ip0D7OfU6jCQ6ALIQtAJwsjXLOlmQj087lISRgj/ArOUqmTlKurf9cxTH+TCE6AkUa4GNSSOZCAqPI5vnC4kl8KUXW7wYNiYoaIwB45wNniCIKoF+sh4pYq16Eisz0hGQiwwdhYk64iPjeSouMqVYGzSsSgPvyytCSDFb4iqeQ65W0RNpaMKE8QpbSa07c7TakK2c8InKehNxSr+w8BgHcBnmyiMtyLSQgj848SA73cCBwMBB/CG+45HNm793GbF3spwDqjV8Y4qPAqgYHgt7MLL2GbyQm7wHUyyM4BkZ0r6MoS+vmzNdCgGIyiNgAC/k8ouNiZYv45Oy0ZUUq7CE6TQBqjnYEyVUcwv4oR8t05vZEotoGsOLiyCASKaEEMRnzxwjf43//PsKdYM77iuJy9AYU0WJqfi/6vgIt0iciDoWYWo9ORKNfUEAE3ONavNCnFm4kBiCQ+GSWPiIcnS1Ormz3rk4ikiUljkMCwoqKZA1pRCZi/G8k5HEggsIyMlD+lHEhS6desiKRMGcAGnFCWI2SnMSX8E4bzQfoSGYmzssj/OcQewI/QiAFks+vUvGdOEInYDGg4iR2rLEYIykB+NEyMvIjXk8XJW99llAl3k8OpQrMNCUyEIAhjVJrqrEHNTIm/ksTse6PhDFcljJoIMBosKkboYUhhIACRiC5WuPK6iwq71FCqs0/eM5rRCJbxOIAJvJrHIr2olBTkkUBik7eui4m//PQGENkX46yL6+GBzGOGWXDTBTAtTAHbogxsWBuKv8jgCLthJZnIJ6iAs5oBFRxaZpwIUQSX2wyaPDj2T7xqTKqJ2bDYYSpahwCby6R7IYFrlbnIFIqQ/xyNgfmRBYjQ7hlJQlwqu5kE4/NVd6HY2ZEpgyTMSVtEhfgrsynv1xgBkqgAnagOCgANUAwQAzgElGE8mwoTjiG6fCj1qpL6yIDVurlFt8DtRQAKwGzCoNOblgzjmgzPgXmIHDmWcisijZwm1qI7vKk93QiU4ilOI3zPWQoShSgEdPxpyACJ0opOX5OPUFCAojiIzGna2jFNQAtJiZH31YPNBaiI5DHSf8M5h8dKSOr7SiqSz5VdFTuZFWK4yzDBGFWU+t+4gGoSi11wlQGVCdoaEakbKkiAhUvILBAgjWGdEcxJ6UmbJKeiwHEon7GyD3LQtr+UO1Y6DU0cD31CRfdp2GmbUXB1EcuqTimb0HO5zEhSTkJJEsjFNiQNP4M7yOWrKcUTiUihAM24E3jBFwmx+QwMyY8kgk5E2PEMrueBJWgrT1jMTFdJEwd9Ts8TwBsg9wCqoCmMlE9VEr0NEpd8GIW4gPkaYQu8yOuxQMCB0kXE7EQDyTyLC1bQ+NoBwarwwIWg48C8LG0YupwC4aoKLMe9VevoyXnMQAEkIh+DFc1Mls6lLr/QnNTEYbiDg8EPoB7UMAJTOkhbsJZATVFBBUkTSgkXC1oQmxYA6BKc+gJ8RJdT6TLIKLdgPVdAwOjVESiPkYmMFAbJ6a/KIkBMyNVQQxaIWICbCAqRGAFpPJaHwIDjk85Jkgb5wdC22cSL6f2ymI8ZMwHB8AC8uReJFHLOmg8FMA37VEgOqI3yXQ+4DVl+eKAqmZznuMBJOBQGqBVkHUpx4PGhi9BllVP62WgxmWeXKAFJBYzpuc0HO09w6UtMYdDtQ4e4RQFy8J++PX8cuM+D1ZXmkRTEKDaJkplvfYujqiwVCm+ssXhtHWSLID/zpaFIuNFEtTRFkACILZIP2IC/xo07+L02MJTjBLEbFfRSlVCipYlh2DWcgao/XAmz4jjaxl3LnbIeZoNEr1qbT9uMQqTcusEAfaoA4qNSG8jPWZK0T7iSJFWHH+zWY9GAoTv/ri1SzYC91SCCLMERv0HTRlOYZLn6xp3d9+iWDV1A4WVbBCqITD3dnmoePMTIgSvTqNjXM9xPxpABGag31Y1OVI1W4jGXyWka2oEae5jTQItARnAfm4yznLoYp9VYRZA9USJd923LXjHxiKVbBRIXMNqRkVCajbzJQbASxNv+TxgVEXD5TIoSXqjVZ9OUvZ3bixxJO7ub4eFjc7CIn7CVunzEU8r5brv94COY4Dsj//e933xZinGjXANAmfOJAFhNyY07AH81s4OCwQRcsiisCq0NyIqUDzStltfAvYyqO+EViHwFwR/bG4xY05kTedQKocoxbzS7ajWNYc6IoAixk/RI5lCOIvxY4UAoCBj4xgFqaoGLhih+DZ+8rvKYmwE1CsYbVCOVmeBSpSmZ2yMzwcAzIKR9/JUgmMmx/kwAj0/Z0DQ5bpAokXeZ36tDWyYbgEqY2an7VyyOITtp1UMYN0O4g/dBpHbSi+l1CweMToC6NPqKLUgRUgtkBaHcYB3ZY434gaoM4+vh/tGAvUi81vNB/rSNy+ZsgFCl3bGbEBkNYeUFpIjmXc9y0D6JSv/0KOgsoRS0fiYARBccSk5ROaekI1qXTKNgayL6HQdT810VWNcs+KHzcZuvXnHYGs1J2aBxVBGFdWaV00mpaOMnTctR9DiTqiY3ddqYYg9CbRj0RKaFcI8QwKBHZSovA6he6JzrtMgUHJIBZhZqzec12aYRLcPp+ogSPfYTjCjewKXvbGMwY0srrhbQ6wAjGdcOwbUOtkjgnlYIFaf3XcEj6hqzPIatewpDbJOAFc1ZGmbVSOlVjMyQOAFkIsDzjkk9C0NY8ZwTAKP8fTh1GStADZxusxPM0MC6DBzXBEKe64Ns0vicshsZZp371kO52z6iAVhxhO8atSIH+6ysunV/wRiBRgnBI4WzkoDcxjMjTwAZsSoA3v5df+TkD8i8zZ5N6drRSBAzO7VGQ/7urRMUMt6d8cmmIlGrcnQIPyj/NS2qEhiiPdMTbWXBlDgOYeg8IYYQItijXcCMzRgAo94iwzjheFSnvWaXUusmCwjS+pzULcISxDZNX7soSq7cY/DWyIjT3Ts4tAOK1rlQguDAa9wTWwblneqpzgA0b7aWWU7SHECUgD6lzKmS+ZETF6jNkRCTRb4X4fFU1s6UnobjBMbad2DAWgjzY6bcSWol4NpY5sxb8tGStVUohe7ARMLu2FCSDXgkhX6hvfsuyvolSVkBNsb+/RjNlb4OGgJXf/Yyys0DM2o8INyFeNCIkbscFjAbGz6hQD2e3dLIk8isFEqeoWd+DGIA8PF+Hf1FMIT1Ju3gkLXVsIjwpxXpCBtMVPhj296+gL/iaq72sDdlCSYBS2IxIWsNkUsuune+8W/lm5c6znUdYY6A2/DIm/pBq6fkTEf2nOXB3mJfDUavGJ/AucMgnafXCTGRtYCMi3v1ytgT765QnJKPG8OpRuz/PNSLgG8XGUF+kNZklNYyDoLVTKYBWdce0CdTLnGV8FXIzmiuipCh022Sob4SSTaGRM9kH+rCa/wI1GsbqXDUDOluMc6tigbHV6j7iZnGytSrqB4HXPbGAwPIklsVyL/UOtChzw6/roq1ORFOpqWlYPtJmtkpFmXt0UI363V3XJNaGkEI6kjNOU6kXyqYJDRc/1dPS98TO3K3EyzdzqPf/bJrLpTzRzLKDfOQSK2/5RTwxiMJ6xFsmKO9Hw085ch1BNpyqfAsdkwOAfQTqtqOJtWZSqHFgCMXTzdgdV3mzxuIZZuDOilX+e6MWcx35bF0Dp+lv0/MCC8X+KO3OMui91iImPMZUVVGECuHVklAl3JY7AqzDVtqDfuRtZizthXNf5REwmUDIsmwmeH+lnLdlY0kpPlOzeiCeqTndujtVXfQ8JohQLhOd4wHAOCRK93KGVEY2KYB1zACzqh2F5D/41KYcYsCPewxsQNow3j+tAv6eH1fybIm7pmZ+k7u1LZkhQkjd/LILoZ6OXwyvQDwnXK60PCyFXiOLgEyTcJgkxN5dmljOuER8XiMZEmbUW+IoCl/UTGiVpCv/3+URWjq5GGpRIdZlFkSVmIJtkeSFlSIxaHMt28KoS66ONeGylfJEZIM37sSWJdRVZLJaqNh7d+6t37eB9dMhKd1WQDCLmEBbl0aF7/73MoK6L/bOq8OIKZs5Gnyg6e64E73l8iB6j1Qxo6M4ydV7B9U49fJDigWuxI5gEiQIAHAgoKKABBoMKFCxcYfEiAocSJAQYcKPAAAUWJADZ6tPCwoAKBB/9CFggQMqVKgwMUEgg5MkCCAgUNtFRoUQGClgB6+vwJNKjQoUSLGj2KNKnSpUybOn0KNapUpitTQhigkgECCxEDMAj5QKCCqg9HviSbYGOClDc3OkwpwaPACR4cmBCxIuWBhQhoKlggdyEDBgs7Clyg4EGDroEbO248IEGChBMdPL7McAMHzAHekhUAeCGEvgUstA1MMyTn1awFNkh5UqzBBy0/k22buuyBiANOB0BgcG+AqcSLGz+OPLny5cyH5r4doORDA9MDUA8ZF+vDAgwIhtxte+P1hxbkag9JmCIGDg4udAgAcmVa6yFDt76P37H0gowXWmZtWGMa/PfYWSH/9VVQAf1NlABBBqS3kYH85TcchRTtZ1ADCw1AAITj2bYdTmQZIBGGBzWQQHMqrshiiy6+uBxKICq031jfqSTcAtc10JKELNkGIUPPiRSYjbNJNIEGFziwQQYLDVmdjwJoaGGVVa4Vkm8BEGjlRBg4MMFj5z2U0AL2bWTighJZZMABZ3aJWQINKKCmZwapuZCUNRlQwF9pGgbBZ/MJNCZYw8GIaKKKLsrocSDGJhAECwwAHGwpaUQRllnq+dCbCr12YGPj0aYQBhu0p0GYDH1V1UkmFgRnrKx59xCm/sk6UQYUODmRYQQgEJGJ5TlW6EEeJWDAAwdoiatHENAqQEwL/0lQa2AEeGfAnGo2WMBiDIG6EokKsbrSAY2ei2666i76qkpatlvpQ8wKpCehBzTwKqR8QSkAZYEtIEF6HSy5AQYecVrTbyo1y3BgOErEZcMTOGDwRAPkRlulBdjamKbyUvRhAfMGxkACeHIWH0QTEUDAyBVyVnJ/F1dFKqFkFbBuzjrvzPNT9AXnLgIKuElvSiSCK0BcHn0oAMdFPxSkbEa7LFEGHpjAghE+IFjAoAwFWlVEdhYknJgJHOB1RQxQzdAANh7gb5VMC5D2lg1D/J5E0Aog7oYIoC0XtWytrBdmEiAwXgGeYgalvgwnfqYE91ZF5Wc9X4555pcTYEECvf8ZHdJ8THellecvUzQAuE7jJPROa7prEUarL9QBexzsAMJKsysMG2Px8h03ydsBNsB4ZZtnaJfkJljZ3RJx4MGq7ua53chgVzdRvgWu5Dhn/Eq78gEK1G3e2jSaNNHeDz2A8EGavw9//Iku5LEA6ieEbEgnm7e4Y4Lr/5y+zaUuDvCAk9rXL4pIgDoGaJmWFnCA3XjPUEPaHUNeRT78ECA1PGqe8zKzGZdkZSFGO1j1LgQbYpFlfwwhgAR80y4BzAtDAvRI8YIjEJWoCQIXKdfN5AfEIArxOA0RHwLGVpCUDe6DAdDTq+JiqvbkrYkIQNoImegVldQPVqhJCfisNID/4N0KJ/2LlZJEZBURLhF1f5tMhFIyrMD8LiUZbEhuwFesgkTtadUKzN4sgES6NbEBbWrLFqc0oiEqcpGMPArqQEQeLMpoOs8hQQhSwKSKEYpfKnnTAMpoISdOTy7qO94H/7MA7yjIeV9SlYmO979OBUByRFuNkewnRhRWZY8SGdLx9MQs7SkkQNSDpFbqw8darbCRzGwmIzfCyZV88W7LExlNPiCCClQgBDGYyNxWEhaFpNIgdcxPHutVpJSwEFeWKdY6Q8mEEpBAAQNImdPyOABombJACkDRZQ6ZMLmgUyFMo1KJUigXgE6thDlMyc9g48yISjR+b5wOWSzYLAgk/wBYA+iACUqAgg/kTgB1gqTi0KgyWc1RI0OKo0egBEp28u4hBsUVq0hQgg8cJCMTmSPdMMhEfu2zMAI55GluWJAG5LKJhbtKr5gKIgMcUo3knCREJ4rVrOrMIwxQQAEa2D62ycpqDihgBj40zSzOiC8MldVM7Ke0fOKQIcS02aUkabdbMo8iBGDgO5dmEBBs0yBfLNZJVNK9ZqUuQS3bnkMlsoDGArZTRtqd+nz4WHsZgJ4yaZVWPwvaRj3mm+xDgOmcVzsHcGCKRVUAnR5pmy+2K1J/cx3DIivWhoYOr5ZRYkAlMsdyyiUkghWBQYJk1JU0jId+CWNuGcI0TNXVMf8IeEABlhVdiyWuKj6tIUN8Ss7Qine8LRKTjbo2KQwhYDSb/etlkrQkA7bmlUzzTXc7gx6BHsC2cOJQW/SaQEm2Ey4UWdhT5QIlEaAgifRzF78axjThbmSxBdmJBE7bmuUZxC0tCyR/5hgaBDVQIbGkKXlPjOLjEICQFuxqIQlVoS0+ZyTTtWHwongBDdyHZQKJF6aqe10tFSste0ssQR8iYc4YqU9HhJZ7KVJjx/xHQqvriJ542Zh2haACIKCxXaN012YBNMkWA4yEhvoYo1qrcfQi5LKkZpALN8CKU2JAiu+MZ6fcMpwMqV/Uvqk/uQRog0nNgJIyiZ9YxtUxo3n/jkYCieVXPbcxAD4IwPY76S5xiWUj03BBYrqR64XkAxXgwXfzO1O+NazSE2JNsTBKVPZKFZ0LMO3IFgCumkEWkk3Ls69/bRQpOU3UhEVAG6M5V2sVBJvafAIOKORpLFMEWiITiKdJSrgwUyiPv8WrQiLWxRCxJoYC+EAJeOUSBbwYJxuVtpXI7d3H+LR7CRjagmaWIV8G4JZ11CgC3K1QgwDrUMAuuMEB8Co+J5PXhWuMDSoAUpEapNr3AXBaKeLTQY1yXNz1SJQp4uGCZLoxH6cIuE8nEQ27e7hk4QEFNBmh/YIaPxb5jJGzbOBNPuR4r7olibZIgAUEL16rzJRt/0h08KQDO+EtZHjYPEJWB4SABODEz9ziDbK21m/YK0Qdj8UEHW9/mzOUwnRruF1VB7BWIrd0aZcggOxux6mt0UmJfeLeksuSjaosOWhUCa70wKNYSlQCFCR3xIDn1HQh6zFBCkIAAr0flyOPeRWavZmSmvbVfnULOJ5+92RW35yJJ3feRRVygegxSJ0qTYn6FkQAdb8ZwYFWiEpsFfeRIFs4c3MaoG8v+OCnmM57CRC55eWvvn41bfBl0hHinlLWIHHmPaajvMmyzy0+t9JPblbp7/YqA7wQhJj/TqwAMLcHJL6qbIWaee7IkIeRJDx0DklCoAS+a4tfrjARvv/HC/8lbRFy4uYa7hcAOJYq1WcSVTFyLZQaRYcsBmBa41d+cidQ2Kc32gYZv8InDbBypyR2+zYb0nZGQuJFsgJg4rIAe1QsCjcRenU8AMYY+FYV+EUWgNF7DdZWCFI9/+eDWEVsZAMBHXF8d3I+gWUEBANzcDZxCyAnMGEhZnJkGkg/c0ZmCyF5aiJ/cWJ2zuMy3+c/pnV2QRcYHQAmCwFUsSIl5VRiIrcRlSaAUCgaiNMAPhUTm7cSPbJGs6QSAsRmPwiIzWRVgfZ7NdEfy5ZN2wQEaLKDc1VynKFQ3QcZ9ZdWOXgZNJg0DbMfuwOG72eAuKIr6FYoo5cfGPJV/MUQbSj/Qxi3EjJzEVIlFyZyGgmxNzWjKV8lEjehEgrQORUhH4EIjIxUfyLHam64EC4AcSE1UhaERGnTgI4xjFMSK1dBKQYAi9n2MZRHEQD2jNAYKp2hbgrAAJ04WRNHAOKjNF2SAC0ABS6AE2/TjY7BAAdQXxOBRC74JHnYGiu2bm0zN4zBAD6CEFCFWB5mLsGIkEEEd/JxbQIXAHRRVh4wUtG3esnWLIYRjfiIRW/FN6FRcx3pEVqEK4FEkAVhAtqIPCMCRqkhWEXgbcWyeBUBJdIWLg2jPmgYZvzXhyphAQnpk0B0SCylEiDwATogRQpRP1i3IZIRj6uhUBd3GY/YGJOS/4+yZDG3txpSyYd2NyQVIH22AWuXgSGCBQN4BV5sx3oboY+KpUMKgX9fxmsD8JNzCT86NEeWpE0i4I4SwZEKsFQhuBCARn1MtEVQqT6DyRl6IiUVIIm29xkuSCkDhxkqoQMhxERnGX9w5BF0RorbphLpODfCIXmzARF0aZqYI2M/w2zbRHVKWRF/CZjflSy50SeIeTcAdnM+ApUWMiQNgEQVcIWnRhYK9zsxyXLfUYIfhETexZNcRYWyEoBImRKEgUCMJQERcZrZyTNzMxIPVwIiIHEHEZaxyRlz1JjNwnQbwQDUsTENswC5YRMB0JWr6JQYeBjP6REAFhZmqCqCcf8dlzduyMQQALZyxdk2f5OOAcBDhigmiNMm5rcQt/RjvHaQ2mmh6/Ic2MQCDvACVIdkREWeFIJQIYpE48lEBGAyfCcAFdA088U9bZGeKmR9utKfamUQrrkaC6QszIKJACpOW7EgHlMzowMZQ0IT17gqxmZIDJciF+qk5wIcH4ACILUEmPIhD8o30lZyWnkfHIKYehJTXGohBhqiIfkQLLqbKbkds8eEe+UYlSYuE/ByU0iRd1ON3nJ2JyglODp/WCmjOzeMOPOkg4ooATAgrElTLeGg1YVqZSqCNeEbtYaKJUlYLkGBYheZH0ieY8OiPioXOpKLFVkWocZp1laTc6H/drq1c7GCLP7kVguDmbS3EoMpIeIiAfxCqLm6IhlwKqsFAJzEANdJqaomSbHTnjiJPUzoNCvRALFkoo4qdj7CosHJGkPSPx6jEeAlSAuReoNYYatBKfjiKVeKchQyGrCacy/VcWYjmUVlNLoKr0Q0MGb1E7bRJ+XCRJjYN3mUHlsUJKrYltAqsPd5pvQpEI8ophsiHQbQP572K304ERuwAZLGGWPjNT6VoPnBkSmEdgDqW32UZg7SFXRmZ/Fqsk9BVu4BeD7hdF7kVTuKntZng9ghEKHZdJDEWQNbrEwpER9SAUOFLEH2Qa/CI3THEB5wAS3woZwxN20xN8bJGtpa/xDhhDBK+SwroalHSE7/eLJdqxSp1SRGIbUti23QeYIK2kkC8ZaZGZc6WxFfF7MOKRrgkgIvmCXOk36pRnEUYYY30IWYkUegmXlVEh6EslEz6RGII4cWQxkxM4Cd4rWRKxQQmWMToBTQF417+Em82XB1l6wAtjrFuIXQSnTn6T/TuSZrA25SkqZV0nPWZkSwKRAYQAE1CrgiqYBLmx8AO3Ft46c29IpexTf9QWhTUoitKLnJG0UcgAFOUZ02UYQFMR9IJUgJKxrf9Fp9OiVtMYpiRL0kNZzDBJgB0oZNKR6dCzF+pxp2anesIafoxhnq0xZXe6OhBJapiLs4t7TVaf8bcpm8Jmuo8WW5USG6nzYQ9yufu8UamVu2A2A+DAGq0TIyv+JGEWy0YPSMllglkQklUGs3DPGxAsAw14JYsusRE7N2jiW3CiFr1GqP4hNb0qMSwaNRf+uLj3W8ttEA/wuvvKpa72EcAWcsOom1w9qZsPUZpluubbNFLtwY61kTtumt0WIlY2tB4IZEnrpjp3cfOSZ9XjViuDK2AlAyCeAp9WcBnXMTYwMhYDrFDKcAPDyoATCvYascb8x+JRNZg5tqG7Yaj+umsYIh0nKOkwqueygq6IsfjzsyJ2eK5quuVRFvZ0OPD/AXHsEBG+C2aNdqFBF3EVFkKuqG0DdxDiX/xxZKuTq2ImNbHmUnNuNhK6m5GkG4lrIyjxJUEU7mcYFheZjhRBYCb6BUerFXhyZ8H7T8jTqXlnypADZAjrhScmMsFzn8TRAyJOIyxkl8yqa5Hpn0IgksH79jtZeyQAZgGmIJIpD8GNx4H1cHiQGLH+0SRoHxzI9hvar6dDXLPRJBvwJwSbZLnmMrXPwLzxKyt7fEat/UpNscjPBVuYlSiD7ldoJxR7e0t/obLfqJRfm7GnTWuhVYqRp7tvQcm9FLJZwMQ6NWu3ezeQ8w0GGXuGR7VG0EWZIBAbQsmAwdiMvbvIsixNzDNxlLLy/kaR8NwZRhRVlrIbT8rNhohPHL/8f5sTfUV88ZFTKuR7C1rLYpEQO7MsIQuhHRSCyMCklNHaF6oRI7rNP+F8AFNMCN8rTnCEm6djqzdR8uxqYfpD5KzYorjBmvYtYTtrCDWdUjbGsfWzY0IxE4gsLNEp2JCyUmStCcd3bQAsUmsdYn9tZH4cMquy7ciceIRS8dSBjtQn0oKsXN4iMefIk862omYczeVxHCSp7FYh8AtUcyKBBeHCt5lGQQAC5avNUgIrtl50Z8JYaeu3OZLV4TcAEcYBR0TDAZwDNbtBNO97AQ0ZAtOmHw6aibd6wh6ja5WG+4LGBLxtfn1xnX8SAtRBBf1Y8bEhIClMm9/ZmOsWJ9kv+1nAyyvWLQYjV9zP1ZAcABF7DZQJHKK7sz3Ol02kNudTQkRh2Vbpsf/SwAxYdFKZBZsdkbNHcRPHW0FxArc+MY9fNXaNdVikEAj3jBfGWOAq5VdUHdQtHNBSM/0fsZ8jxI6mNkehLb5HnPXfIq6U0hLKrAFBLkTGSG5sGjxsaCz+FeI8ogyXIAlyXhw2qw/7IAMJ5VA9LTP9HWqSJEBWwbapa7D2F0iAxlFP5BUCLcVmLk/S2+SU7htAvQFQEqBZCgvzNNNWzILu5FgPMta1Xi8LzEw8TlWPUlGgAUPsy8jJTDn7Gc05KuDVHpbB6bo+s8cf7UsSkp6gx1Xm2CKeX/aU58s9yDop5DeIaupiaxTok+URlQQD4h3fTKTNn8mO1blX6NGF+Fh37tbSj6ZLgWqjb0wPmh21hkAujTJT3BGfthjRII6gzR2CTGUOHHGdPFa6SciZVXFZNChiAK683k3JsBACkLxBEFzmR7KQ+UG7/0HZUFmDpJ10icIH9pJFc+YfPNW5oSnyX9orjC28qN5o9KgFvM7lrdMZcFn74x7o1E4BeQAWA741k12Qg8EQHpGwHoVLHJNHwK2Nu4uLNMyS+7O8btvRbAi8+IStN+zPYpaKxR331sLDSv721zEX2ibpG+c/Xz5tD1GX3TEQ+/SB5AAezhxQCY8FPzp7o7/+9pG8k0dZVq7hjv+Yl+o1dn4iPnWdjO87gMg7Q33EcLaZUxvybPgRAXX20S8N6BrbXfbhhEP0QcMAInwCQa4AEeoBkFXlZ9X1YV30hSon5MkxH30kOiDRn3/TVw26Umf4HLnHVgXUz59ZHtHRhMQ29V55bMjhld3zAAwN8Ns+QSgkc2wrCJ2U9/c1cMfBAS+ONTGVvZsuJyH0R3rwEdgAEYkAGqIl4W7JeeRiJug2zuNTdDZ47yqG7nnNVJZUMb1ytAN/V3uzcrd07yzYCmirriS9ICW4w/3xqt1EQYRiFFiM27Jyu8qxe0r/5grsz1ASImarGn3ndyAWJtWra6ZP+RbyjngRkSGtKGFw0QAQQOXCDA4EEBBAYGaIDQoYAFAhk8TLjQ4sWBDjBu5NjRY0cIBigWGPDRpMkMFDJ8RPCggIKIAQggSAAB40SKCBtYHCDyocKTQRcSUKgg50EGAJQuZdrU6VOoUaVOpVrV6lWsWbVu5drV61ewYZcG8Pmw7FEBEiwC4DgAQYMDMReeNYjA4wCzAike8HjgIN+TDBAgkIux50EDNv1SBLqRYkmBBNAKWEgxKFuBGj0yOHCg8cABCRAwEHqyoMMDAwYYFWCgcGnDg0kHmOAAQ8eGCAmc/SxwMVq1ATBLdGgA9sIFkE2yzmlB7HPo0aVPp17d+vX/r6cnHy1wfGOBhwo8JngcgKLdj8q9d1xAQC6CozY3kkcIWOADtAkW0j+oH7Zmjn5rbSid1tuIuYMsCAA8hOQiYLbj+BNAPIEu0GAjnBBiECH5BhKQIgoNO6CAB9A7jgAGH4DwLvj2wu5FGGOUcUYaa6RKsu0Qw8+gB9Tj6MGP6BLAxPkoUvBDiAxUciO8cgpuo90EKMC/gY4yoDeZGijAACpLA/Cmh9BrEiEil9wRIS7DC6BFKVc0LcyBONgAIzYnu3IgHCl6AMslFwIgw4N8nKlL4fJ0KCkbE1V0UUYbZdS8HA0ibQD3TOKvADctMtQgHy8a06EABjhTSj77ZC+B/5qKpIhQT0fkcqEN/+oIRR5fM+nLi5Dsbs2Hdj1puI1yqw9BgwrYVIBOJSKgQw97XciDC7J8AKY6t0MAAgQUiNWhUk1lCE6BQkJoRe0QUsBRdNNVd112rxIyJ/tOOjbZgS7NFCNiDYqp2ni95QjBUj8NlD2HQqwWWY4A5dTLjvLdFUnKvD2Ws4ceELLMAAQsE+KB2OrABBAQkjDHWLc1KER/YX2ogQFsyhc0F9uVeWaaa45R4ZwMuNejizvG0NYfQfTtoZ1T5tUhejft9yJhD5JLwKK/dQhjj3C1SAI1ZcrL3zr1K9egkU+2SMjPwt5pIQg+KIGEgwqoc8pIi13ZaP/hBnr3ZIqCyzcBm/tWdAMO/Ba8ursdeuA4k1E21eQhIUWNboxMpjoykab86LyFQut2oMQZ9nNspAca1aDNTbLAoDtDS0C5OsXreSCst+bcodfgW6GED5xe4AAF/CNgdCvBhVzruAXw77zBk69qgggo8OqCCDJQfvqvHN8uAQLorRv0qTtyy7OhluXo62Ktl3X4yh5a2jvMYRNy/Y6svsgC8BRQ7zDaeVrMfty4ZVK2yDxEPfkyCE9Yo7OL7IgEuFvYd6zVK1YJBFgJi9rRIjUb5FFPg0xhnvO60oEIbGCDI8RK8cQmLwFyREIPgICh0DPBjFkmXxX0lpCepKR8aW//ATTp1Lw85518xQsCJaMXzg53EntZBGLGEQpCQFCBEEQMQw4xmWryNTmPxE5KCPDJ0ih1MNkhaQAk3GAHvxKBE5BRjVIh4GQU5zOLJBEjCWga3vw3x7wI7I3D25SvljSAWGFRQKyqU+kwIr+NwBB4TBTIwRREJ4ow6yMMANqxKtJEJ6JAByxSAAIo9bhQWaY0OEOTYfbCoHgBsj5rpJ4ZoxKBEUzFARGYACttuRQImLCB8tqZqOLGyItsSyEL2BAw0YcnBvHPW9iCS9HCZitKNaZlQUHkSYI4F9nFUZR9+hAWA/QQGHCgLaxJTQAYoKUHUMmSNLRIGw/CJ2LtSjUI/ziAJ1s4k2beUnmuhAosp6KBCHhAn7cs3FEMeRKIcactuTGWXrp3TE9BlCPAg9/QDFJRi1TTIwQ4QB0RNhCPGhNmBfMXARRgAAtoj2ciC4AG5CcwP1qElEDrCPAemrkoFQsy5OPRGAeaPH4+xZ9SCUDzfspKd8KNIgbwpEUgoNKLoMVkZ+PIU2G3TYlmtSOd28iH9niRaqqmqyPpzbEiGMCD9OhXWuVoUwWCAQdMQIkPOeuCigMbd4Itc2Xp3WcYV6yjDi6oThmqVCgQAeEEloSkFI1CCkcSgQyAoXWVyerMxy2iCQWMktRqZ0MFsbPmMoVVM4xPGkog1OxMQF8FDf89D+rZjqRkJeYkIFUvQsy2QRVMaFHP6B5JHLQQQLF9G2xTChsVD0RAA8MlIV3K4ja0UGh0NxwIoDq6VNIwgEGnDcqxYgrbrPJUSgljzEfkJ8yF5EukC+EM+MAr0dpgQItZUyECqCuU+cbqM5ZE7VEQwNyaBfUCAyZwBCJA4AGLsCnMcwCAR7iYaZmQeBrylPocYluBLICmH9kWZd9Lt3exrC0U2XBGLhI2YHr0iOPziYghOgAG6FZe9q3aEAwqUQbMJgEGmNaKwvZRhxrUwTMLqoGNfOQjx5KwaRzyBoXz16NYECEn7tUARlSilOGvcR+x6ocNhJn29Q8hK45frrD/GjaMwlTGBvpNAyQJQ5CcpWgEqIAI9uJZgZmIvwsBI2Cb3K7iMuW4UAGhgv+sQRPu5MdmfshajDaAEi/kNxg11aA4q6Qwkze3t7rIwchs101/86begXOzSlnqRhagAA1w08umKIIKhOxk90J1n4SknG3Z53vaYsyh2RXopQz6KdCTnq+pZ9OjlES0ZLrIfHl0nFqvh1iUNpCWL2mqHHL4UJzmCV31B55ybjWbWSZxR5wrH4GRjiMGCUGsx5tI9K0KNGXhy45H51xjrwvYShG2U0ag5Hwrz5LwwpO5HKibY2rYJOkGcspcbSpVHsSbAkExtzVVHyXd7bWl4Wm3fmw//4/qFUoGURsJNu6vZbMUOdkjS87KYpyAp2vfAOg3UzAQgcDFPHkMP0q8CJCADePPcnzcbunW2ZEEMOi3J8mbv9zSTJNwLAAL8IkyTQwly+Iw2X0CFsM3HPLJRG13BmiBSj5noJ8f9NYbcTbSYOxTnTtq5jVfCgcigIG4D27gWxeKWNFHPpXyVHvVEg8DFDCtoMv7w56eOhV/HhON9onnF6Ubsda7JihbKSjx7ZOhDABVhVU0r3DPu9yN+kqAQ+UEESi94CbvJEd7OQDXNPeFZTqYkpznjpF7SKSPmW79uFM8kV/Sjw/SAAkg4OQmEdbnMVLQyaw5Mxdaj7hsf5cDWP9sc0ltvcxPz5UMHLj7fgN7TpYvUSFdHjRncv5AEJRQKnLE2Rg+JpznC5jMH4D4SjJ+xUoS7aCgFJrauxzBIjjjAA9YD7CTsQXQFrcZuZzgm/FrlJmjig2IgA6YwL5Btkz7CADsE9rbjARwk/4Lux9BJdkbCGZqAP+Avv1bDwB4veuTKPjLEfXjCMA5jsnzva/5KrDrDg1clAqcitULQpuBPocglA+MLOkLCpzxvYnqlRyBwhS8qtwqQQF4QQMBI8Zpwi3UJYMziQWAEA2IFgkKjCgLksyaIwOQHCNMlCF8ww1CQgqDDckqlvMbD4S4L6GYqlHBme+im+Q4w/VIN+P/yCsTkKjdeIC4oKS2SxKJEq9IMSTt6o+3iqvL4LmJCzJmi8ILk8MaiUNQnB4CxKqN2CH3ArV3MhqiWJK9kQmaQKtVhCN/kQAGcQ3+Kw/BAKMUeC+G66w+2w5qSzegkC2huKLFuBPHEJ79qKf3GcUZCYANWC5ovKUaDA8SwRgAqJPDqbgqvK34w4ixi4tj8qH1+DEioYhEfC9i2UTvoUKC6AwBKQD48zCBOJ0Z5LygYA6WoYuywp5sy5zMW4BqLEiDZIprzAkM4ynG2QwLIIzLMBWqOxkvBDFmhA2eOoDhQJLIW0LvwEe3mSY7LAt39BR68o8+C8SLcJiM6oC+i7EJ/0OMeWubQLqIgpLAg8zJakRCk/mMhCyff0GIpftGzxIaAykvFTyLAuhF2WshBnGxoBidkmSJ8mCSETEZkbqABIQNqZOatkkABSDHbqMrVEksnTxLULwsKrozU7MWFfqJvmvFegGPB+BDj/BIyHmdtbq4McOjg6iAG4xI7+gjodizJQEjepHEuriIHCwNMIosiiANOGM44UJLyxxFNzKS/toOizkANxESFjyo38AUKdsyovyIsKnIi6CVCUkWBKmAawMvGwoKxKy2GKoYjig/ibuIMiyNdAMMMNock4GAyyzON6xBeuo9i/grpopAlckJ0nzLqTHFD/PIQvIWlXII2P+ktnhTn+6izqDAx6MomkjxkPpxAUwMCgkxDga4GwVoALfiy78wTvoMwoLitd20CPHasfhwv8m4NIHIPA0RgHQ6zbuQy6yKle30MsnBPCmhrFzzjmvMzhwpCbq4AbMLwMEgCgF1GtBIAAmgFJFIp/os0QlcAOxhTTQBS8+0SpICjrZ0zmU0oak0UBpECNhkp+E5GCsbNf3cENbyiJTLCY/Iq0BpOwWYAAq4Dd8sHibqGrM0USmdQLWkwvYCCiijEiOlP9EBQwA1GrwcCC5iQdiCgDOpAMAIU38BmF/sCAZgOe8gpQLxnlihH7N4l8xwSc0yoU+inSn90/ELucYYDgD/DEbIkMF3w4hH3I48lCgznVPPYtF1TEEUDY6jw04G6BAZ9D1mAh/c2g5f0cpj5FOP0khAPVWd47kVwcuQMxEjLaCxygl6Es9xsdFGgsv30sLOmimIozeQurHBFFAiaUyMQNDStJMAAJ4HQFVmzbcf+zShqEQ0+YwcgVbIlNUurcOOUFNCXA/gCdJjwpVoSsFtCUyhkMrIKhx7ZBJktYjelE/juVYNeYvI9EqEaFZ8/bMfA4+hOwlardXnhFG/pKIu+RodBa9v/bAvGc2D5QhuzTANUc1iRUpzwh5i1MHz6IxS6YD0DKU7ktZ4DYC2A85IyleTZS61xLio6zmLCMbF/4TA0HGqBKgnic2qg7FLiQKQ1OS6c7QAnI0Q6CyMgzHXjVi7bTXG24RUc3KTpmEkSzpZqFWsUtStIQUlbCqYN/1STkSdbpUokbxLibiXISolzxoOAGnQ4juAVKGbe0Ih6EwvZzmOr1lX2lhSewXKjpCABiDTgDUI54hawB0obHlIitW0nLgXk2rDV3FbnfIsNlEArY2MDbkvbDGAxVXYKvFOA/kaoKlZKTsoKIOQoTUJBACPK8GMp2tRoXCADkASLvXAUDkTUw1c2tUnyjwAAzgAC8APZZTX8Hg87DxJ2KqWwEy3hvUszQAA4KFbT5wyScvP0jBH70E2acLVhtk9A/+5ABjQXGiLwWWpXfDVJzoUOYFIP1oF10qrJ3jEpG0TNQ1pVIgCEMLcXKO828kZw6LlXo8IuctVUXskH5WEjQ34AeuNvUQKXwQeqIjLEWl6rpa5SKM5ixrdVt+1RJjVX6L8Ev5ov3PMCZvgqds6E1bhKm3LGfZ6LYjx3IV4AXc7PthIYBgeKBWdDMiSCOyhOPA0CVSzMrhAkvXlssLdzHo1mtLdov+4LRU+Vpl8xPsp4Ls1zdgDM7SY4MaLJFNpgA+oALbB2+0x4CiNYTAmo1IMx07L4fWQ0/PxzaDUVpucDO50TKs9iReMXP10I0tSj9EV4oYbn3YVihDzFr8oOYP/eF1alKAwPmQS+kmAhddnS7WX+OG+ZUvaVLr8LZYNE8aUqdo9xgizRU0UNJ3tWOBBbifqtMVi0VEZJFqLyIkkHqkFyh0dZQtEnuUNUuSDsMvRAYo6guSZ2I6f1SaSwpPOoKQb7gi39BdSOrnIGxmiTUhKKqYmxk1x/OGCsgu87MAloRUSqAAauAxa/ubpQWN4SZY7fNBQUa9CvmC0UOWkjdmz4E7d1Bd/4an1RSTMMBkaGmPI4KIt+QwwYpWHFWVQ4crRKo1ow19R1WFwXujBGV+EM4xDTcOFm4zcOAA6rmCEOxhDQlT0LY3RsdYyGzFvU8OjOJtNMREh6Q4eFkv8/xIJA1ALOjJjh31U6DXooCDWs+sYht7pvnFoD8WTk3Ird6LN/DiR8UxWDN4Il4VV7NyQAvjhyGu6nG7Z+mlPxJCPKhKIkFKYUlGKMma2H9Oeyr1c2NFdSIbdi4AWL/5inm7rdvFpymtnyGJZhBqJBtgcFM06PQZKEt6oBpgWljSa5PvljYi8h8NIOK3iOzIrk8GQjmqqHqUrUqK4sJQLUWbnLoY32OBYuYqMoCZOtw5tmRFngyIf8YBO6RtdCRjmyoIQgImqXokJJGFegoBg2Ys865MU7KTYpoGJIJYy6DqKk5oaUfaPfw1ZjGAWGIKxi17rlJArvwiBKAJC0a5udf8Z45V5TCRJDaJITNxVgGX5ibsxDh5lZCIRGJCmSplMQb8LgP0bFKMBnl/dzY4by+JJurSavfC4G4xYDO5CG2F5445QUhcwCBAogRUQgNm1bgZnFCzslcdMNwTBGEvargQ4bnMxGS8SXk8hp5pFxZN72LswLbX4EkjbVYcIDiSBgEUD5uLZllfF3pbbw1C52jRejwmogNwRgAWSkgb/cQfvUDJZGYGW6tkZidkQ8kZLZ1tlEqhCNWHSDAhgjqFEH/zZE4+dTgheajA8ZuDCVp4C0DVTgCeKIgHI4gIAcjVXFOwuFrrgwLuq7aM4nsmwqbMmyolsjeMNABTTDLqgYiD/4hbGIaBMUcy4gfMCXuoDeMTXWI1i+eUxQQE7EwAReIE1v/QaefC26XI/ej0KMdLgLNvdzh+hgBiNAGGIAmBZHeK5GrO1RAzGiJuYevDaXAh0NVwBaDcpcYBiw3RffxGRndku3w5jgjIKeb1rqcom94iD6Wg+6xWNCGuI0nTS2ZYA3rFHvk2dcQvL1Q+6EI8GJBGpshVil+aCmxt2RYgsVgiN+HV3fxEChOuHPneKXQ1VswDmAAyv6jwe4uQlKTUVE4odoiuNsKTmvgiPXNRVX2QmX7iyoL9NyR4gmVipQncxxdZgcYgg0IgMuIB3//jqeD0DiHEL+B08FJE2VFl8/+lENhHw2pvFrEISdg45vtAMGHfUlWHOAcD3+JTIxNbPk4IJk2Bx5XOu93HxJUd4r9yJ2sgADRAokI/65yjFw4uU5IBCjlLdgUUK0OA6MSpdemxlXFe3lU1CyNCMBT4bERdHbenfiP3UpF92cXTqPkUIH5m8A45BBnCBWmIL27iAXpd6weeKMaZ29VPTo0+ZkdAQrV17PhfKoKDYL2EACQCatf8Tq/2eLgnslJkJ+PUeAbGP62SapeLkBeMAwFcKC2n3wW/9rEjZ+vglAvUdBQBv2OhrUylAJfHqtkAV9ag1hqMSXTUQISmxdAN09oDmF15jUg8VY10IsJP4iJBlqP+QRtYFAMBpMNfffqtocxO6LhcuddtWEkQfkLXufb32FlbXiHOafW/Jc4yfagkh5PW4+UkC0f0luPQgq9/4vKrwAIBwoMEDhQ0ADiJMqHAhw4YOH0KMKHEixYoWL2LMqHEjx44eP4LcOOCAAgUCTqJMqXIly5UJAsAMACAmTZoDVBaoqXMnz5oEWqY00HNoAAQpEQydSVSn0aA0HfxMqWAp1QVAUb4kOiABAgZLCSRY0FNpzKgqB9g8YEABAZgNUrbdebPl1K8sFzRFWYBiBwcXRnQIKXgw4cKGDyNOrHgxY5NXH0MWSjXmgrcCFKCdrBkmAQMnDyRwubnsyrg7ye7/JHAAQeaYeRVAePpgpdjRNgM4vtraNsyRBhoUQCl5aWiWBtpaPXpg5W7SLZHGTKDggFeaDFjOVcmgIgYKETIwDi9+PPny5s+jn5gb8skEBgpYfjycN33e8QXM37z+ZIOaqHlCMBtWAQyAAAJiLdBcAA6wBJ1m0h1w32MHUFbdZsmxVBdRGLLUGXtZ1cThWTF5hhKFNAmIUgPZpZTARRikF6OMM9JYo43mXcceSjSVeJWDNCXQAFv1bfYfTwSUZJptPQq3oVoKVLecSlJ+xhODok0GAZM6njTAAimCSNWWKk0mYUopPvYjjys9UFsAFqxkIYHBnWQAWixtd6Oee/LZ/6eff1JkJlAKkDUAne0dKkABsdEUoFS9MaAgkZPyRqWJMBkZgFknSRDAhzs5YKakPFnK5Un7CRDmUCxiR1OmMJVq6klK2tSjAZHSlGiVnLWl2gFx5XXSA4ASW6yxxyKrWAIPFKArbTVBIB1rBB7QrAUKwqmSe5dSGhMDChhwgJvd8sSqAKPC5Ky5xoFqaIs9MUDAbs7KupJWaK2b0mjBCgfZAxsSsACV0LFEYXErFYAWlQZAkKzDD0McscQJHdwSpfROSW7FAtBKboglGjCuTiLOOibCoMKUwAEHjLrAoRo+JoFaJOkockwDWFbAts+NZi51jyVM1X4UokrApisZcP9QAAlO3LTTT0MdY450YRrTqz1hrJK8k0JwMrlXBwABo0ORzPHRzlI4QMAxOTCZrieiqiJNRyuKJ0+68pvS2JptKplvDZhM1boQsCqUoCkNELXiizPeuGBZn9sbAg8Y8BIEjh3nG5Q0xTookXRH7rEECHRKn7MwMeBZAV0xtzBabdtlL4EtMUyTBDXXpPbGAjyAs922bYVAx0WxmXu1lTunHbXNQge5AAs4jlAHHEwQvfXXW+8yUP25KxyaKzmYL9X0gY5uz4cGbdvRqs6uEl44LUhV3qFnyJSODkJw+EkBTI24xzdjCSYiUgACGiCoUenvJA270QQiQAGEYMCBG9H/QAQ8gL0LYhBqATDZSRDAQd14y1TmG0rX4Eeu7/2LNwJbi5xigipBEQB2RAFdTAr2H7o1ayV1AUACcxIAXeVnMkbbW6NUlpITkYhLQYzOY2TCQAkeJIIP1EgAoJjBK2IxWT+s11WyIoExZa2Fp+HJxsRIn7LZbDQLSEACdsMlBMiQKN+zgAtLsxNd7ewovUmTANE3Qp1sSk0BuJ1w2qgTJaKLkC3Zi54aOMWDTMCJGvGOJLNoyUvy6U1cbMlL8nacpe0udD7xjAFKx5NvheuPKRPeGDXVISJZilkNAF1LYjgZ3x1xjynpTwCk9IC2DKBHSKFbZmh5Kp+wsmd2BKC2/3YCGdCYkTIf5NieHFkR71TPIR6IgAYw6c1v2mh+XNyK1zC1JV7WZGOCpE//0qeTEo6IPqGsE3tyEketYGkkBXgAdLYUFy8RyIM9ahMztWVIcsVqPtk6004SmKqheIglwWlAnhppRSk+BJsPaaADwOnRj56HAWrZZAfL9rxaCYeIMGnVxVQynP8sdFf0+Z5KaFrT131FXnlLYcqYpYDd+VCAU1LQljRUtUmhKqi9ZMnIHKogpXSOP4CyZhStyBCNPuQEEQApV7vKmP7Jqi1RVdACtpY7BMRteKMpX08QQKd1buYxSLoK8u6ZzqAwFSZxU8nYxqQgLcltKAkIzicnk/83dAZgd4hdGmSQUqgQ0oVYVAUARh2CVYdsIAKB8SpnO/s4LhLUZDyVCUSvotbNhDKNgn0PZjSTQALY1KVtM1pzTOoU/rEnJvB8l1zM2pNSnTZ3y4QJBHTVwh6a5nIn0dlSnyPZi1p1IZdtSAYicAHPYje7VHQeUNB6F81cRan1WZdmILCA/ajWiZAl6UkqkMuYRBUuMBHnLkm7LvZpxlziHQoD6FQAU96sRAXo2GMQu6WVASVxU4XuIwHggQtAGMIjsG6EIVzJg0xYuxre8ES4S7vhjoUzpiXXfvC7k6gu8Uix5ZJ79QgTk/kXRPQdUBLjyZtQqpIyNkPSTw0kKcj/ZAasj3HRcx9Z2YN4JwJKXjKTlZzNhFCSw1KeskLiayoAu2onoSRgjg27XHA1oFNbOQCWm2sxzcyYPS3WC3xZ0kY3+Qoy4wIrEnnDViIJSpBW5ljK7rfAIkMwugqZLkOq2GAqI3rDEKiWh1tktBCfNan/y12imORO8enFxDVhb3tlx9iVAHivSNPJSCgX3KP2ZNREUiSIXzxi4rXkAYBz7LEme+SrRuDJDaGgBRPt6ynPky4J0oyQaTxpWMlnvROC6DR1tOblKhslplHsTyHwGpVOelPupI/+FqvXRSbItieBmK0FDeVcQ8QB6P41uzUsbs9RhV6/pApYuhwT7mYG/9M2rgmrudTG+zxbAKYstoXGVOel2ZtIBQJNtz64RE4n7WHlPvSg1+2QCJyg3RrXbrMj2xsJdKzY04mLyqZlnUdtBt8xcaixa5I1JhEAAkOMDp1Y0CNVne7eK/E2+Ua+k0XXKZqTou/BzXwmLhGA3AzOqMUZ0oEIGGTjUufsBsdpdNMAwJj4SVRywbeZPeMnK8Fkz/AwrYA1lhk1OAUoaZPXnrUZvYMNR/maUiJ0IsW2tpxGQMQmznRdL+QC35k64b0KduMwR7eyYlQoN9O95Y5vaSBHwAEsMKZyhZcnmbIrahbwHsoJZwCsUqraEg6A3XFZxC49dtgs0Cw63cp+CP+7n8Qm+5ERjKDwuudqtDgtgB+luZmwJhNR1C7QTtJLZEp5vKLUOk3mtpJtYOOgUM77mXz3yKhi6m7c98d6m4wq+BI9zsRs35EIcmD36v+oqHXUO85xqS40zC9PGtQTc5mR+a/MMk3wYoLMGMmMqdaBbcaKCQADzI+mKEAD4NdMqMaBsFMCtNC7rQSFPI35cQQHRACMrF8HYlLVsZdSaV2crFTibUh8HAAR2R8Z7VxPqMxejVbbfZsAuBeAkQXkDE+xddmMsUwFrkcMuhpKwNX9pYideAvL6UXUYKAHMqGvtR97/Iip1MUKpoYHqVodaYtadQ5VCIpOKEVetNiJoMb/Y6RRvx0TVQCA/j1KxRyH19FE3tydTmyJUIygmymhuTVhHk5Zf7GXg5ghUKQQFdoEDradGraHTsSUsMiPRCkKdChFAaiACtDgCkiiUCjFTIhaihWbKC2FPq1ggbCSpOVKBS6FUpRNHbpURT1NAGxAN+nhK/paIsrKVCycARhgnQRhSoxLgXRcflhbSbSakLGPkeibBa5UJKpABUjirFhN++wctuUibzkeTmCbKOqcSmhfae2cEsFiN3rjn7jSJlkKy9HRp6GEURliLZ1YC7qGDvHNY7RGjzybBV6i9RWAuODKqriZCllGa+2EGR4cqmja3LARS9wim31jQiqkjWib/+8l2M0cj6o8YcbIYTnRTdF9hXTsXzjS4BEpTUD9iuBwhViMCTQW32RYGloQQHWICBCS2gfRDGQkzELSZE2iR2J1hfhtUmENhaws0RZG43KpxkGdkllFlZxExbNZCBua5CBJBfOdmgzShwfx00johVdUxmc0ZVDmkklJoNFAj02K5ViSh7753kB6iqnQiT8m1ndt0auFyMvki3gBQICsGRL5zP15Xckl3KT8YcKtCwOMy/yoIlka5mEmBiqyV/RN5CIVk1t23B1hY0tUx3+YgM9hSgLyRN7sl8cYSbSsxjwN4SltJGkxFWKiZmoWRmIFG1B4WALAnWooQOmYJfeVYP9KBFUdYpli5scCMArsPKBYaOY6eppnlgt3YaQ+mqDVHA3fqeZzQudHdBzSaI9MMonfqIUByOJVDAtM9JuSgJ2c6ORwUAmFtA2TwOYVopoZphjrTacgDQADmOT3IFZCeAj5RWd+6udFbKJctaaP+ISs9N/M2MzC8SFLceQRuWGpKIADxMrYyRfWaI0XLgUqnd0t6chu5A+31ISQ7dB+gmiIagQBNNo5Dp9aHtVusQe6vMof/h6KqAQCFBdu4gtLyID9ZQtPlotjzJttbMw/sZGkmGUBtBAB1kTniGiSKqlFxAYSCgAvcdF+TSdK9GWCciiBCJNMeCLLoA5LmEDB8Nf/WzyAqmxlT8KPpTjIR/JRiJwm/K3EksJpnD5EOsKPYiKNnMyTs7TnUtjU6thEehVUSpjAmJzW0SSn9QlACvYGV9AK6MAhm7pEhFAHgeRjWnVoBcpppmrqQUCA6wGZnb6So6gIWk3qflSpd27PksgWWElGpqgLqdVUgs4H6IyJ9q2LpZlIvhSdpeTEpvqqnIIgULwP0uiIUDzoWYFGmXKGBZhcO1JmzwzUALRNsNSOXOxjTaBK3tQZwtBUEB0kXrFL1RwEkiDPr5prnJLoIuWZJyWgIGpFkOoWzL2hbfoHUTCABMKEA+Tlz11r2+lpXqEqXMSKILXkJlXmuSLsrxKA/6e2CFD4VbuuRDkSx3sda1vSa304wHBWJF/pxL8WJ/+Ai7g4I5XKBVqxxrcaR8Kq7Ll60D0WiI60Vl4SalW4BOi00ROqkkkOQAoEznGmRJmdKD3Fqk64RwGUUurUCZIYrQ2SxeG1xMpCLcL+53IlTlB6ydHsqZviZktUy5AtRbZAn+10pHq+kwddKE90HK0AJIFAAJ35bL0wUtTKrabWpqIErEGqzmiy7QyyRyaKrPnsx4/MRcAxI4UmqA1WjWpYQNzkxyZmhl9lilXKinPObeXG6dQy4/Pdn8Jcynh+EOfKlE0ArMUGnI5KJcl4xdXEGrZy0si23E5ME5M0gOXSbv+cDoAFgMYHIUWzlRku6VBtUkgPUeTcuCXpIg7YdF82ilRItsRicZDlgOnS1AZoJkBsRNWi4GRh1u72Jmk6dtJjSOw1toTogcxhqR6XNMedfdqaueTG3laBgEtQCEoL7VVm6CkbKo+lNQCtcW//AmusMBKdPhSQyBVxZYaZnAivFrDLrR5NmMSaDQ9ZnF799GessE/ZgMiU4qZ3GhCR+e8Ha2oAxEfvIATQ4cdK7I1ZppG2ChBacZfNVGfzMYV7mW5qtIRYvNx5NYuini5OiOxtyoqCgfAQ/yr/CDFDUAmRHmmyWasJUqCiAO0g5caA1YRd9YTJIEfmLQX1IQDm4gn/EYOx5crc8HDXOoFOdTQmLt5Q4kkJC9zdDbojbgFFcoquQ75pGOMx7bbdE+MHILFUiSZqb4jaSHWaGBnJmNBRuj7kyCiA0WqwrHhwHkvy3L4lewAYLT2ugL4bk9DwkYTF+VJpfyaqgrysHdNO0k1yKstt3Z4hEONEfDrtjjQbJ3vfIDbJ1YkwwtAKWaQxSaGyKgMz1LLyZSggyppKHVpKi3UsNvabV9QPqZjycnGFTx1xMFszwjoLxhCATuLm6HDagLGIex0cKv4LTSUnN7vmBl/zOsvt0XBPUQ2z3ekIvcwSE7VXEHkxOe0babkoJBMA4EQyOwt0wqaO0f5yXaoM/3VMcDTXExEtnAnsBB+zhqVEsTFvz0BjdBiDqiknpxUH62e4ZhdLgEm+UXxACe4edEardP+mJUPrSMd4NG4IYSW76zI/E6fK50rrNBiLk5OyVwvFNIFkhooi6IUt9C7VifD82U4zNRgzAHDY3Uw88qlwiXjFNGoQdWlARF7M5Ew09Ven8hql9Iztx7WYyrhctUI0W0oXmmCC9VtjNE7OYRoeDyoHkjEdcUdNhL7BdV/7dUIcH0Q82kHETdwehF7vdXbqClv/dWM79kMMltYoBGJfxO0qwLU8dmZr9kN0RgGc3UJQ9maL9mgfRmiT9mmjdkeYdmqzdmtPxGq7dmzLdv9CwPZs23Zr1/Zt6zZp5/Zu+3Zm9/ZvC7dfB/dwG/dXF/dxK/dKJ/dyO7dAN/dzS3cwR/d0W7ckV/d1azcRZ/d2e3f/dvd3i7flhvd4mzfUlvd5q/e5pvd6u7emtvd7y/eSxvd82zeI1vd96zd05vd++zdi9vd/C7hYBviAG7hCFviBKzgsJviCOzgTNviDS/juRfiEW7jUVfiFa/ivZfiGe/iUdfiHi7h2hfiImzhnlfiJq/hHpfiKuzgmtfiLy/gVxfiM2/j11PiN6zjj5PiO+/jT9PiPC3nEBPmQGzmyFPmRKzmgJPmSO/meNPmTSzmNRPmUWzl6VPmVa/l4ZPn/lnu5YnT5l4t5YYT5mJs5SJT5mav5RqT5mru5RWzWm8v5nNN5ndv5neN5nuv5nvN5n/v5nwN6oAv6oBN6oRv6oSN6oiv6ojN6ozv6o0N6pEv6pFN6pVv6pWN6pmv6pnN6p3v6p4N6qIv6qJN6qZv6qaN6qqv6qrN6q7v6q8N6rMv6rNN6rdv6reN6ruv6rvN6r/v6rwN7sAv7sBN7sRv7sSN7siv7sjN7szv7s0N7tEv7tFN7tVv7tWN7titOBnAAB2q7fdseBmyAA0xYBBg1R337fdtek5k7Q2hVuoO7VXGAB2BAFbX7QmRWnMP7ei8hACiZUQNAdV3Xvrt3v/97mENkGMHzOx4ePENooLcr/Hgb/L0vBPpF/HlPPMBjWO5dvMQzPMUH3uB1/HdnPGZp1siT/MdrPAC8O8p7d8kzBLq7/HbD/EJskyvO/HXXfMWtfM4ft+0RBAUkmdBTQPohhKH5vHbbnuCxu1XxWtLrPB4+hLoBHtQvd78/BMZZvXVjfUM8XdRt/XN3fdib99iTvXizIs7XeUAAACH5BAA8AAAAIf8LTkVUU0NBUEUyLjADAQAAACwBADEAEQPdAof+/v7u7u7iRCXt19Prt63jVDjlZ07nh3XomIjppZjmemXsy8Trw7vlc1tISEjjXELu4N4AAADqraHa2trokH49PT1YWFhGFQu4uLjHx8eXl5dnZ2d4eHinp6eHh4eOKhevNBzaQiQZGRnMPSFzIxMoKCdINjM7EglkHRBGKSPhPh5vWFNIIxvHOh6aMBt1NipsS0S5OyOmZFeql5RLQD6JV021dmqTeXShVUesiIGtSTZxLiEnCwXbbFXOl4uVOijMp6CJRDaLT0OXY1mGa2bEwL+/Uz54QTfYUzjYX0jKg3XFjIKhLxkAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIceOEDR06ihxJsqTJkyhTqlzJsqXLlzBjypzJckKECgY5lIggwgEGgxFK0BxKtKjRo0iTKl3KtKlTpzZxDgywU4SFChEiaCjoIMKEp2DDih1LtqzZs2jTnoxKsKuDgRiyfh2oIYIHtXjz6t3Lt6/fv3zZCrQZIQDBDREsEAxwE7Djx5AjS55MObJgAB4aE4wboSBWw5VDix5NurTp0xMvW4jAAahXgpm3op5Nu7bt27ibXsYqm2DWnwNtvs1NvLjx48iTK7y8s/dAERFCEtypvLr169iz+2Wu1SB06QM5RP/XTr68+fPoXe7uXvB3wbp308ufT7++/YKqWbueO7Ar//sABijggLZdlplUcGUFlFAENujggxBupxkAhIEmEGKKEdSBfhF26OGHICJ1GQBuJfgaQatlEOKKLLbookgjUsWTBV2xR5AIIryo44489mjQiALpxJNPBsW1gY9IJqlkhEA2hBhwS0Yp5ZTnNckQdVRmqeWWxlmpUAaJcSnmmGSO5mWZaKapJmVnrunmm3CmFQAHzsVp55145qnnnnz26eefgAYq6KCEFmrooYgmquiijDbq6KOQRirppJRWaumlmGaq6aacdurpp6CGKuqopJZq6qmopqrqqqy26uqrsMb/KuustNZq66245qrrrrz26uuvwAYr7LDEFmvsscgmq+yyzDbr7LPQRivttNRWa+212Gar7bbcduvtt+CGK+645JZr7rnopqvuuuy26+678MYrL7wVHDnvvWo6kCO+/I6ZAQf79itwlh5gUIKKAycc5VsVxKfwwz6+5cBwEFf8IgZ3OWCBhRZ3DCIHKjrQAXgelxzhcA4EkKHJLDuYocQtxzwgBrK9VbDMONvHwVxvTdBazkCnRzHKQRddnsr9Xfif0Uwn10Fvw9Hc9NTJbWAhxStTrTVuFJM4UNZbh43aR23BxbHYaI+mAcldp+02aRpw3PbbdJc2d914V3Z33nxD/7Z334D79XfghOc1eOGIn3V44oyLtXjjkDf1eOSUIzV55ZgPdXnmnMO0eeegr/R56KSbNHrpqHd0euqsY7R667BP9HrstDs0e+24J3R77ryX3fvvFu0OfO7CD1978cbHjnzyrS/PfOrOP1969NKHTn31nV+Pfebab195995HDn74jY9PfuLmn194+uoHzn77fb8Pf97yz193/fa/jX/+ae/Pv9j++9/WAihAqhGwgE07IAKNpsAFBq2BDswZBCMoswlSsGUWvKDJMqhBj3Gwgxb7IAghJsIRKqyEJhyYAxZwNoEEAAIpzJsEFKCABgjghgI4QAMucMMCGIACEAjAAf9wWAAGxNBkA4ChQRBgAAMkgCADsJABcEhFHPKwigWoogAY0MKCDCABCVDiEduFABwaADQDsCEVDQCABGRRAAoIQBm1SMUr0lGLBjDiQAbAgAEMQAFUDCMTD8CAPo6xW11MQBUfAIAB3BGQa3zjHQVgx0lWcQEAgMAULanFAgygkQT45CGjNQACHOCNFCiIJHHYADVy8pU3rCQsz7hKWPZwkwI44yidNUQtKqCXuLQlHYNJR1nOUpicNMABDkCAXSZLkciMJg4RUMsqGlOa2OwkAjgGAVE6s1YBIAABOFbNbL5SmQ8o5zXNyU4BFACGA9hkAZ74TVkRgIoIGEg7oxn/xwBAso77DCgODwABLTagnq8KpxYlAIAAPICdB0iAApQZT05G8aHWFKhGKUBHeiJUVb3EYwAUms0HBHGkIx1AOXG4gDlm1KBVdGlHxylTcxLzhmz8aKr+2VHDhFSYTkSpUEf60yqqtJidxKJD75iAALSUAq60pAIGgNEq/pKOBdBpqSBAgD7CcgE35WQ/UUrNGx4grGYNgDpXGsh7anGbNZ2kDyUwUggU1ZMMuOMBtBoqfxIRlgVgKxx/6kmULiCqWqzqAYhaTLRSkaB0hEBerbpMOkYRpQNg4gMMgIDLQvOtDWWIGPnapwWEciGMlaZjBRBFAkzUAA1oagAQe8cB/ywgiSOdbBVNAEu4xlSIiZXjHVkYAN3ekIsNDQBV6TjUFpY1lx4l7Z2OesMGEGCKBmCoC5Obzbji8LLAxeEDijrJUmKUp2YdgANg6dksznOk6HVnAD5bxTOqValC9S5K3ZhWgcTVk9K1k1snuVihOhKbX7wjbCUwYGk2mI4NCIADyFvFcTZ3v75U7iSLS0cuolQCnRwpfXM5UgUHGE4H5iQCYGiYAGCzwAuwpGAteYCqbtgBFZ3kNi+M0loS98HfpbCFU6pF2VZzATGu7YndROE7DnnGWiywiDXaQxe/UsJEzWINtQjeCw+gqAU2bg83jFIKszDFgUTzIul53cDmc//JW1qtFk9qS86K8wCdxSwCvItHLBKTi+ckkV8tuePmMkCHCHiwAcTJ57eiFK0UKLEWxynYBtg4l3Du0Xw32QBvAqDJTB3ppbE60mDKFqVYNepnpxoACRigAAogLqhv2NJ1/jazzBxpo6t4gBoycZh0beiIHwtfLQrXwZnWkZhvKMpjY/GOOx52lD/NZaGSlwAISOcBwOtHHj86kGo0wAIAaWsqMoC+eUSmhau5Wc4W28kpDSagX/zFZiZ7RY9sMYUhIG0PO7sA16UsHd+c0lWO1dsifiNFc4uAMI40uZMt9w2n2mdh9jO+VHxAeOk45HA2vK77LAAmR3tvBwF5mqX/Zi5JzTjUUnJR2neMtIGZGFSEk5XjD7fQzSlJRxr6sKm7nmVDk6zjZePT21QWQCpL7iCY49TK9UUpAd647S4bVt02z7qaqdjiC0PTmIUVKm35KXW2nnHWVh8piLG4Sijzmun2GSQmBUJ0ptJxr0O1K8qtDdSsJ9fbJ79hx1seSyIqYMd/d7owiYvZNIp05Y5u7k0XK1FCQgDjluwi3LUjZoJzsgE3petQEVvo+8o4rVn3dkP/OMlm5nyoirxi2JvrdrkOHsNRH3TPL1zNg6s9mvbevHmgTkXiKl4BD9b4UOuOw51bcvB/5/EXE5B2wTZbqI3s5QUU0NTklrUAEtg6/zJFj23RX12L89Zxc2lb+tQKc6/Cj8wGHCYSae+4oK0P53nTLu3LQrm50Yd983V0zjdw3iZJPMRCDYVeQWdR1DVx4wQAgTdqxjZUy/ZFEXVSitdz8fcUlxEXCMIQn0ESFFZgAIBWB3dSF3Zyl/VK7YdS3SSAyzZkYeVDFEBcXDVk9MVDEaZhWDR2tjRRu2d0QQhbQzZ1ODViXCR+mJdDHQgVEwKCDxEbJNFvRIZHtxdOy8R4TmVZKTdJypd3/1R68dWDs5VYrlQAMrVNQ6QCsdQCAiAQ0hZ47dRUtUdjBuZHKndT4jZcofWESjEiE6B5ByEcJLF19tWFC3VhUSVlJ/9nYUTIbBdGTIXGh1JnS24oeG3ohhegAlklgZZ1h333gOZkdUJ2hovkXa6XXIAoIhMyEViyEdg2TgwgSb5HR1yoa5N2hUb1cAHXYYamchs3UELVhI/UYDy0TQ2FR+K3T4lIh0GYW71WTuFHXnimctHXikbxga/IEOJBMhbRYA8QRQyQhTVlhkI1eSiFXr4HeTjkbw/Xf/y1iygVibZ0AejYYJ4EhAZ1h1I2gOyUWZ9XW8uGjiiljUXBjSHIEGACNhRBW9bVAD50ey71j0LVe3yHejHYY/iFfSc3a0Nmj7BkAq/3QglAAeMEjT1EfcolZ9/VdRsnihOHTQ1AXOiViwf/+XAGgWQImRIKGRHQgRGzhkOnZmAAWGZFlncLEESs506iJ2bweJH19UoqKJO7FYBDJWRflGjN9Yi9tG0lqVxdpZLSRIFWlwDpFGvNlQAIYH46CYo4FHw9ORI/CRFPYhHEx0mpR3hUVAAId2kWllmHl3aGJUkuKQCnppJvVE4pYHPx5Zc2R0yJuJcC1QAIsABrd0nSd0pq6FSSBGCsCGSeNpccUZcPYSQOkVmdNRXNCIxhiXBNCZY8BmSTuZcEkAAtBUtFuQBnFV9LGEXVRJI6aVhBBGQWeWGaZEaEiXBkCUv9ZHSESYqvlnsSgGfVlFOk2RGmaQHc2Z3diR8R8Dg///WPtReVUpcA5rmX7sd16ilUyflKOJlSavQAg1dTBZAyWYlDCvCePdRlWGlYBJCL/+llvdZZDDBRlWVLUnZp7biek1SLnJSdMBKFE5IVFnqhBUGFCeFHwzZkHPVKkNlyhrmcWRdWQzWgyxeNMJl3addQLmUA6pWfVBRhCdBEedaeOJp6FGh7ylVVToRdHbejUxmhElqaFLqQIlgYCAGhCtaStgSJm3RKVWSQxZWeQwVhCHegD6AA8CikRPSC7dlQfTRS+Ilq1XaUNoeiCCcBrVSUQoVNHlaOuUlF5neYIDoQ5TiaRRoRptkQjIGkAtGaVbZaCaBDskmW4DVgAOdt+P/3WxfGAB8alyPFfKHWni21Zyw5VGWqiBWWo6n3n1FVm5J2elZlYCGmi5w0lIL3gAqwpxTRpwwBHwgxlOl2R/Q5ifA5qVoUn6KGfl15R5ApkjcUhjwWfbQlcyi1qeJnpUOVbbCGSZ6amXsnVF4qALQVou5Ia1MmY/MYTUvnqhABqwvhHwdheq0nbbw6qpn3br24glMajA+qruuaenwmAZp1AJuKimuUriOFWPy6oihFW6IKjQ1AXpPJgqgqVtnURNEFrstxpBARFAdBlnFkdDb3SshKgdg6VL8IpsZofOeknm53AV3Gn1REossmqqknsCuIUb02pHR6pYv0bbpZrZb/hJ0OmxBtshAb0hrzhZJtlEw0yGt6dgBuabB9eVlo5Zbe9mU/16vAGm+vlIU8do/HGV8NmrDsiaPDBqYW6EvExrGaOYycFKfZ1LA5C56A6hAp0pzTahg5Bke4N6yXZbLDZl8wh6yzWVQGcHn5t1T4ZFpV5aaRCUsXsLEBEFZUa2aeGkzvdJD/SV7vJAGZ2lyCeaOCuquXSEdeal9pW4jdCBE4kpdyZV3SF0qYhUcuSwAU0FnS+pKke0OEi1lsdbeHKowLwKyAZ7jE2q+cy2Nz6KlyZAAPsGKpJ7meanQMVksbG1/pNEt6mrM7yxCqekM4GnSJ2H9a23zDmY7cSkWD/6e99SiR2YWmHFutF/CCgRedkSWAwvuamEVbWWtzy8qp2jpUNitXhLin07sQh3mcNteAgXmqWity3iasKZmeJydUD+a1Xha7sQSmY2elRaW375t1MEeiheuoGOhwF0Zz1VtFaOuwc1InEmGMknqiWeqCSAm+lttVj7pnpAhvhrVnjFdL5HmmlHlHPORlw+Rtc9SZF7yXlApHXDigoPp4gNdw4LWBu/e5HCGsAkC1CMePsitUaJlLVFxIQ4XCUZZn45lSVXVw4je73tZkPESYGPe+XxR+Q4xSkUpE7ckAMhywSoyrKfyRpNppUJwRqqq7QJxFBhBfTcyVgCdJFubEBP9Gj8WFuqbKyKk3w4XHY/qVph8cSG9Mtta7lzwlW12rwg7KWvJqrVIsX338EHk6FZNqw1uHuI3rwhxGRIRJqSxkp3VWohWYddRUAAfQUoh1AQDsgzPqqUAGyKkHZFQKvJprru6kgs01TMWZtHGsYqcsWlUVYQP6YFSMo9iWqXGlsuQVR7XnxSRmc8zHtDxGTFG0AJLEAggnU7OXpQowkfqqn5lMTP+KUqO2WBf4ms1oX7gmet41z1gFf9V8EMSUzJjVa7KZyc1aW5KHRw2IQ6+rV5GMAL+Uz60WZfUYSvnalb72SVnXwKOmsu6LcJkETMbMkaXKfrP5tyk6Z47FSAf/XRBFLE5q1NCpx2+4KbyThJNIq1erdEYuGXCd6UJD/JjN9dE5CRoiC7ZE69CeGl92mGEXVsQ35LVFlZKWpF01DQBgBVgazMBUNL/ehtUCcNVQ3UlJRHOyJWYwCkkFW6pNPdXCmKyPakNCvJcUFleEqaZSbb/ylbgczWM7asbhhKDg1YQ4W81WHHl1/cgEqJ7N6LUNVp13h7JRqoJNptG4nMt4/bXDnHowJ04YJW6BLbwMsEmslq0K6GXlJNJ7SW13dFDVPF8yKapY+V85SluInVsWBmRm3ZUJgG3q98Z3tNQRXUUrvaONJ9W49ts5KlPbrHZtl3auxVldFkWgJpef/8vMwqTQMlpFObpcZoR89Nubl8ar1Ym5bifdOwzaZPrMkH1h3IVzxfq++jjWCwBGkcxgT13WD118esdJNH3KIbyIGHzH7YltBrfQBVC8gj2dNQnbLmynY72XJqqp9P1sORRE/1lNwTzEW2fWUVXd3OyFvGhGLolnRtjH2dSOXGWetYTisBdRmtxM0llNGkxbpYzOqp2UHN7FN+ttw+bMwovUc7u1zTXNouzQ6JrFVplLNmbbadtbVXWrA+5O8Oh47mTjhfl5mtxTPNaoVOTkb5Xh7UlfYPrRkgzLl9xDK+2p3rWcZJ7JRZzgEHZtNZpLelSkXjypjgx7Qg6DlwXY1P/6Shr33k07cJY0juZ7weLkbUw9XweA5iMulnOueghHqb37pvX9xog1lGaXYEkFvnuqZlsm51mnsWp+1rMEuBaFcEcGZqXEq4j+xpVupo6a2jiKXlQ8amCuniEFRpxEhxKA1lg0l7e+RzVWvk5V3Lpc5Dl6qYoMdK8k3iP1YP3kUg5s374+3wjn5K/uqdFnWkhOVoK8zckX7sq17cM0Xq21ewkevcLnSpD+vqpa7qFM7eDdkcw5RXudUu7uqbtOszfEtLmeUukufVX17aknAW/U2gVPuqL6R030Sx6GcWapjUX16ZQNS5uerVVEAX/kZkKF1jB60hWP0iyfegcvdXX/7KnzuJ9ZV0vwrXUtf5tctN/KNaakaMAAmXFm3pcjXHKxC/Gv6bY4SlvP+14Ih3EmDb8tn6NYydQLv5cjprILQAERNWyuXPWUPaLR/UKuVGPC6GNDj0dzt3mBB3Dl7rZKP1SWGOBrJPZ431Axn8nVFL5XhveeemkGeZiy9WU4xUVefPQBtstyNtwIX1/fl/NbTozEbtUFn/UOvfckboCpy0lhD/grrMPKPqMPBfXbemX3Zstya2g2PMr9GaaWW0v8Xr/mzsB4psGYL7wpU6Py7ut0JHpNqWKAJ/DKNOwOfXKMV9GwtKC2pPhaNdHt2t8SRWyj1qBfVrA4+Z9NSfHq/0mbQ2y3oI9byYpYl2VK3DfE5LXip55DQLx7gC9+Kgj9Z1p7zq9TVjlO/HibOry5Kdzyys/vABFA4MADAgweHDBQ4UKGAhkcUJCgIUMEBxVAEGjioMUABQ8amBiSYYODBRgIVLBRJUgGBBKGVLmRgEiRAGhOTLnxwEACMQVE3FjApwSUPn0OAJBU6VKmTZ0+hRpV6lSqVa1exZpV61auXb1+BRtW7FiySgcYRWtwAIW0F0kenMlQqMqbdW8mOGp3ok8EehVWLPlyIt6NIAOk8NlTZV8CBw6ctMkwMsMFCeIKnOvz5E3FPhX49Tt5oUcBFBQaiPkgQYIBAwgsAKxSYv/stAYPlMWdW/du3r19/wYeXPjUBT4PnDXaIEBt1B8nFo95GXQACQg2h4RA+uADu7ARCBbIdzp0nSIzwz1sPGaB5rany/XZ4DpNBmg/vw+AET/48Gn7BuhsowHe2kgB7VSiAKnhFmSwQQcfhDBCCbvKC7mVMKotpv8Wqi+6hkQjoAEDvnOosA/ze0AzyRjSbsMA2kMPNNoOYsg1l8TTSCXHMhRAuukGOFCA+eo6byOJQBvQIAN8bCgBA0YUKcW04lqvQxMtNIqCCbfksksvvwQzzBk3DFAA5QSSkkcBCtgrppsOTCimnRqaUQAD+JuozB4HslLJ94IUYCG2DCrSoJn/HNCuANd4nPO9nBabrk/n9CLgtSKHXAjGB/RjiDC07gRQJdh8EgjQ8sJENVVVV2W1VacCSCBF1ThErQAX9TRIgUc3mkgC2WgizyJf3WwIRj/rMvYngRAw4AGhbMVPz/sE8tQoNgNwAEAFGtgQxgIKnRY0Yx84YIGbRBtoAAQUMODbDdFlCNeDzqRTw5BM3agBCNZSgMRqaSw1QwJcJbhggw9GeCz8YJ1LAcH+tTMkBhQooAEmKeIrL4aSNewmjgNIM+JzQyLQIHMHKjTNAk7OdiIEnD0uyCNBC/YgThf+McOJJDWIu3QXCtmojtNdL4DIBiiUroSXZrpppwkWSDR4/0XCM4AiL36vzh6LbjKmmWkK0lavcQ7g5QIcXsi4yqRr+SYsRZ4O15PJBg3fnidKVgCfGWiugZfUnHsgjamtLYGnD0c8ccWD29kxrOsawIAQSCjg8fFiUs7YI9dyFyMY6XXbp0ILeIzsqYMW4OuB2na7oAIo0C8pv3gWoOr3pm7obZ9UF0h3g/qquQDPeVS9ZkMXIGDX2gowfHHnn4c++qgm0i7cupIfsTUPVqB7NJVe8oh5gSA4z2cJdCXKL+Vra7R7gYbltSHW68Ldr6CtV2iABCS4ufv1VcLf+ESHkfUxhnjXAZJP8sYjBEjPgQ+EYNPyNDa7JCohHuDAityWJ/8RHUcgC0gIeOrkounYTUXuG4inDBC4qGELhXpJQGaGthDa8A5nRlkNAliYqZi8BFwBO8iOcGg8NdXGaBFEYhKV6CWSxWSGITHefTjgAdAQoGG2W9ZHwPOxifSvayoREVra90IGYNGFL6RJgBSwANzpaYcLi49dkGakgSSrUfpDAAIOgICSqQR1ayqiURiwREIW0pDAaeHGnGgXrQ1kAxqglB8nAoB/XUsgeXOJHhOwr7cYYEitUUiRzJWAProHjXaZ3ykVYrzH2RGFQcJUSNTVgHIpBGKBq1ml/icneRVRQYcEZjCFuZVEGu0vMTFNXRo5EAt0wC7JwlqhLgMxvdX/5iUEkBKoApBAO81nfZajiboQAM6JpPI9oATbIidSKOXUzy9zDOJfnIU27LCIjqFUCZtKuTvfBfI2wwRoQAXKlIUAAEgPMIAE4EkoM64ScwtxAAbqYpw2QQplgXSPpIQXzpXQ74vH8os5/WLFnsVyIKW0JEMK+EII8FEB0tFcvdZEQnWxZiFEfAiPErLLIr70iAMFalCVqBCb1CxmuWqo9wTEEAdkgGqASiZDdndMjOrTXuGkGLT2g0zQiLQ7PQxJnQL4QbBOh1kGsGGnfMLCA5FwgtHR3b/6Aj8lNWdEgWyeUPW6V+cVKyZvJKpIJPAkDxpzIBOogFN5ggDW9DJ1/zKNH9EwCpI4qhJjxNKLV+uyvjHmLyYmFQhJ7QRYmoTsiSOhqGTpIhICWMYnGBFt6gKkKOM94Dr7nBJfdbtbplV0I25FI2InkJ8FGqVqpFmZWj+SIaKkzG3MstjCANXVhSRgj0kFmTqfI6XKbTOc2IXsQdJ6UgUqBFcmjRxaXNSS/uTLVHFBXdJ4xVv61jdVBGjXkvIHKOCOByIkWkgGKjABnhqlvzaSZR5ncqBdzSlZKc3deTq7TY/oN17aRWW6zmM517gynKNsGATcWUxkPVQhDAgcXePJp8HxMCiySiuucGuYIB1Avr+zb451LKF/pc9qxjUsflS8www4IAQYnf/wJEUSKzvNBI+CCdJpFbI+TAXtYsYCbTnJqxIvFsUopF2IiqWMM9TRKzYPmFuyWFikGTLgJL6L5WSomRayfi+9QttxnvXMOFKVDS1d9gsEuLaQDlzgyEUELnhBw7PxtncjppmMnk6bHSWRk6kCjImPFTKoqdpFmtNxZ52OVEmFaIdJC8iMoniSGa2Bs59iTAjflHQy2sFlz7fGdVloZy7c7qkhCziAARSQZRXbprXg+cEF8KrU0pTxhbRJskJ8ElUgrlaD+dPkTVrmOxsax9IDEfRVX2jai/7qxFkmwDg9myH+VHgzBTZKXEDZWgbMmUa5xne+s0LKvO0ULRcrU1r/KVmbaRHgAyj4iN2k8z+/KRlJCdBhugBLZRr2mTNBMWPbCrVD373LLp1GYWvO+rXU7gfYGbIelgXSa2tpuCSF03fMZf6qP94tVEbpcqFkmSEyvYAEAhij8lL66jGT7c4CcOvb8Ke7/i4k3PkSSdvKNNZP1w2z3YvNhAvVaJEw4MYdNe8itaakAfzvZDU38MzVPvOxE0q/gLIhER9nQghvgIpOb09yeZKWLC+sSLwD0pM0HfZJ3eW1IWEdfmcaVkm+p2R998uMngixby/k1aJjtoDSIhG5AaDW/1576PP99SA2hz3CNqnczWPEhTyyIa1l0ucfi0Y9QVgveIR8ClsM/9GsaXFh9R483U6okFIqmiAYrXh07CO4fIY2kAYQffRxTXrRNVTnVLuxzxbSTL/cuPJ6WeaIu6c72ytEs8AyvmVrBPKBoK7pISku5tetEyIOu4X/crIJdSJi6fd/x/oXjyBbiIATwNcbpyIJPoGIqNszCu17IWqyLAT4lsLqCJWwnPNTvwxMDKmSk+lYH/lwib9TrmMJGgfkCQV4gDW6OTUxjKRwjV/yvxjUq4UqItApqA8KNvszL5uaiCRZk69RFwMxl6aSo2R5gPTTC3FzOHHBuBQSCgtDvAyUwrcKCr+yqNnxkA9KkwNDAAq4DFQrCTDDNGSiwVyxiaMDCRlUw/+g4qYi2gnxu7CDeD90cjnxQizFwr58+r7xyIxowxmI8cMonMKBgMPeQUKI0bsBLCvQqBbeQR5AWzLGsgtqegmeUTVjaYA11MRh2rIiyj0AYSwCQLFM84viE650MjcprBQktIv1KT9t2w9WrAtZG63u+6uQ8BQ0w5lKgUT8KEQ/W8RSopij2MRiPCTqQLnfghy0K7yJGhsBo4kfyh8QGkS6iYz1McEMY0SLkEUoWkSOoiAoAg8ngRIS2w8KoKXAgT26MZ6UYkaVGCRjlEck6h2WM5SaAq/4K4kTYYinU8YAwABz8qEOPL5cqcbu0ZP3E0QYajwUWqm68McYoYnIKJn/TemOA+AWwYAACvgWlSCKhTrCLjqr9+sj6Qgk/pvHlFQc/Dobc4mt2tjDy4O6AWQXCrykRQzIUpPDOrmMAzmT+im7WTtIlTKR0FBA0Kg692EnvSilkVJCXBQVNEGL7CpKhiC3kBgUKARGRlHJrkScMSmiV+w6NRmSf5kPnpGODrAALzsICoCRO9o9pxOloXSNk2kMBUhAbbSLiPydF/KwZZQJznCJAHDF0OmotkO6uBQ1lwlDfOJKr4TM3sIoeHwPtJiL7pq/7ViIIoEwDdgA3xmA8zkA6aCddIMZ/hCrg3wUbSKbVNIfHkybcKQb/fkstxGMdIPNnckMCihMVLTA/68DFExJFht8n5jgFDX5DAaggMeIzOYkGMcyCscAMLPCvHm7ruJcRN/xke1Zqx5UoCaMmt5cABTUQTQ6kGx8j/mpFmqrNoChmxgilHuSGO4aTMiRk6dsiMk0mbgczoZAnZmxx1yBEehzzgJNFXirq4r5RJqQvJeAABiRiGKrnYFQvYVYgQ/4xoXoI/lqAHOJshU0CK4LpzzSyOFbGNZBS9QilAUNLIVQMebJzdwxirGiqqDwll4MACLiuQosj8uST2kjyACQlBTkEQI10CPlkuXgETG8Pbd8qdZAscEyAIjoId0xwbgMABbA0HkRiQf9iAJbAEajnYWhjWTiNrphnf8PpQzLGJmJ/DELrAu7AbPpIkcEgMTI0FHRYY+elEP4q8ogc78Ta44D2Bfq+wkkRVQJwRWxOYgE/EUKtSgT6guzrK4rvKkLAAGyuwnk8dC22Eozka89dD44VVLKbE3iGzQNxM+GYDmxhJXU+DW7whNDjbakIqUGGC+IAY9BER8KQyhOI8ZEFVYGkZdtkoCZeFSRSJYBkL2+1JYpBY+NfBY74ToTsAFRhc7eySOv+zdHMbEDKTpzlJ8a5QjLY1LQYD9CzLwN7CIEXL/vUUSdWZYnUcjeW9EpS8U6s5Zh5dfh8AycAbZ+idbdQUxDKS3wpAki9EDLjFejwA8u4lEz6Ub/8ws8tLrFdGkPiWAAkpgV/KgTHNVXHBKJBdjChggSt5qYG0ufAT0lCBDFm0pVR9udfqVZ39CTbvyXucEViGMOmoAY9pyIU5yOOSOhthPV9jSl3nE298kRi7CrISmSAwlEkdiVBbU3X6Ma0EKdMROtipnSk1nMKfwf8Bi4T6nZs90NBsgmc/EOFuXLjvmfynGi5gBaFd0InwE2YbsYoXVKWG1Y+lsY3ZnYm2CBv6JD3cuQc+1BNgUNl62TcC0xANpB8FiAN4LYa8MZm0gaeoKAMlI8nEPb0C0LQSkQvZDQgVQgC1KfRSJAhiiyy8lQzLBU/FgAu1LchVE2zMEUABTR/wwkjYYjGz2JCzXyGAxTJetKi5PT1KQpANF13q+Iwx9dssSwDLRzDXaZTrvQE4kolKrJSSacyRppj3odSrvIXXZF3MIp318bXJ28klW1Jdl0n6OhPtQZrHh73vzNisCixcIwo5YygAD9MnGFnF0BCe2cCLVEkvYwgF5Ul/w62vUdiMJtQMtLjdiV4BeqPflT1j+lXcASYIxqIP0lYakYAJdkrIIFXsszVDrz2IbRFXlDX4bQgLXcpnWppZF9DcOT3tzJYIaggRvjD261DRrMyx+OlvpEUPdUsjNj0QG8TB+RSf3skRK24qZ4ySI6rSBxln1yktmlCQiwLj2SXIVAHf8vmgwP+EyP7B6LM9k+RWJsUZekGUCFIgCFSqEDSJA47h4wNMgQdtXeuViaqU3VomLRueJEToo85RFMoSgiIgpOI19DbjFJEVEOeAHjJBvaMak+muRTioxtMzEQ/WQ+vqkdDokioYCrtTbGK2PQiNvLaGE1URRFTuQlRgveSa3BwaKWwBN9lOIczL0BQIEtbdRNNlFIvToJbptqUbVtIkUNVjfL8lJNjV5e0UcmngiUeg+0iwu7eUc5seVEbuFWI0pSnRHipIzMCJcp/jbcOYsLMObZwxnOHAwsPUjWWYsD+BpgBSl29F9V6qPT0pqEMJviUud1hZtS/JRRjTeM+oz/1mKjcc7fEGaW5quR8wiXrCMSBKHkmMWPAggBTEUIuimTi1GXw7vBasTA3uyeIqHRwI3L2rPgAaaPLKwiFy5VAGoNJMsXinbeoNTPkMydA0AoG6oaeMEVxxSd22UtARjpTJ1auyBiOwGPo3vlDMbAOknouMHnhcGViwmaDaldoVHcaumLZCUch/3UpH2RsBRnoK7ZiDUO1xihJ/bYwSmT0ZxmyFmNXm6AEDgBH8AZdbkuYxmaBWrgOMZA3YngEVyqFwLN3Bnfj+5hqvnr9+QqqmzlMsynXKEmuaZZVu4WgsQd8YPDpTYv1OjYyPvHkODbiRSNZp3QHOULvFYlDMxR/9N7bMpwY8xd3dKl0C6UNxZCTFZU69fLJ+79beqQRLpqH2qKR9FOVEb2Ez8Go0G0ibFGIZ5RSAEbrumgvs2QG1M+I8gRQ7X2ZMt6lI0W7nP+VySGAE/OmzCWAB5MAAOZs7yi7iPVP5CQr1KWI4hjoaMjIdnBj//57lRKHp9qCNqubSICWdPRywxeqM9AnvatkaUtkXwtyCD9Yb5MncqKXGvqbyQN0P1BCw2P33KdxlNaoIb63pt08RPLkPYxlqlm6Ta1LM6cl3ZRQVVS05q+bKOrlJyOjv+xtIKVwxM/0oIFibGDXEI2t+TWC1OpVwV+VVKNTR1ZMYyt8ZHqa/fRbf/1Y+XAPCWX/lsBVyY0rwsiIp2SWz0e0RInL1DHOpJeMnK7NEJQflf4JSrPfOvs9tG+hADSesFzUhmnTlgkBkCbQyNAZK36fKFiU7Rw/vI5z5DpnscJ2IAOsHMAyOIlUTAcLK6TiYxfJBCEarlBJCLFxaD+fD3U0EpVMpZADikkZvKlcg3cnpoiYXHwfe1NbWFLW2IjXbsJiIAKsIoIKAE7d2yGkFAu53HCRM6DlJSYZggOWAH5XV8E7p4yt6wpFpDYSMTC9ogOzeD4hiF9jGl0mmJkT/ZltwoHiIAJcHIjjDjms6ZzKiJGJ5vxZI/etdAfuNvnwO33qFA0jWPo/Aj/iJlw2sPjaqeJZGFzfKl185qLFRr0tGAe0VN2Zq8KDYgADzjx+LsPh9d2b8wQTzJvvbAAGegcykgTgiebo2DWiF9IJD62Aag57BavoQwQHU8wLwRRtYiUtLAd7w4eiMjx0At5qwgAeqduh+c8z8j06cgQm1dX/PDlcJcoGaX2CASg9iD6cX35D3IJYMvInc76Agw5b2dI54BPi9D5D4fffTqOrPoP30FJmYt6q6iACPgpoPZnn+AOvryW9jWhYAcWVgt3PCTXf1Y/CbQNYwHaQsRAeLFystk6Pw8vSEeSDpS892iM8spPmyY8HZl3ka8KD4gADaDuXc8iN+8efFn5/8wFN7kHjTu0p2XuHngW0ubOrLT3WYyuxumyV7pIZr1IlrFSL4agHXnXt8CvCmV3AOqO97eYiwfo7S4qI+xe7EFExO6J7bbWm/KlRPwQd1M+M4DHmcc1/byBu2gpZA7JZd/2DLWz/qoogQgACAACBxIsaPAgwoQKFzJs6PAhxIgSJw5MIOCiAAMFMHLsKKAAhAAiR5IsafKkSQIJGKBs6fKlyAMeBcCsGSBDhQkkB3hMYPMnTAIzgZZ0QPQoUpgMFhAlQCBk0gAQPBIgOmDjTKxUoyLgiAAlg5kXB6QUK4ABxbRq17JdOyFChYgcInRoa/cu3rx68Q5AcKDqAAUXDf88MPs1KuKfAIhanFk1wAACTJFmMEqSgdbDiY8W5nggquXNokeXxXh48dEFBi4WkHBUq0fYGAskHpAgAdmTCxbIvujTJE+xCvYSL2584Nu4ACZYaO68uYeCGiJEP279OvbsCE8OWG3WAFEIfhHkRoqadMneF1VjNFDe5XmRGEKPZEDgPXqY3TEqQEw/P1cPFHAAfjUNUN4CWyE2wGREhTWTAULN1CCABGAlWwMUliQYhNp5+KFCyQmEQQQlmliicgM5EMEEILr4IowPBRCfSF2ZlRFQCXJkQAOPARjVAp11JBt4SHVgwY+JLXBfYv8lCZR3rBXYEgPeGcCUTB018OT/SxJMKFJvv/1kH1QvPciRAgYowEB5NMbUYYxxXiciRBGUICeeebpY0gASZHmjmDUJOeSUXMJ0I0eFwqTBBoY6ipKTR/VlgAFiullTY57ZFFyiDcT2qG5D1TgkUJjNRuBOTIrkaUdf2SiAAgcYgGpJMyWgJ6540elQBxFwkCuwweolUgLqQTjAAQU8oBlKnEJ4maqgmhTljT4e5QEH0kobKVBXcbRlVBxyRFtNf2J0gLkX9actSYMK8NlIfxagoUvOcsQUBFEWQF5vDaTLkbX/XoSAsAVHtGtDFkSQgcENO9zQSJmapQDFEthbJEo6mkUWb+eyS5KEiCpaEwcefGwo/7c//WstUeJi9IBN1A5m71knQ+YRuCNFxhJQr3YEHqtDeiTwbCQZmxEEDytdEMIMiSDC0lFHPdLRg5G0skuIMuURs+ipRC9JEmh1QNDqbraBBjYnmbJNvcGLVMim2VS22aZ+xLK2EmM0Y2JEC6AxogJ4eSPPNHuEltQPN60QiRsk/njBOiMKktFDu0R3RwHo/VGF37pEbQHirruZBR2oDSDbJonH429uI+YyxkEpCBnY9fqVQJmIbS7AyDb53FHcQmN0H6IEIFD1bJA3vHhCG0SAgfLR50nSVMVX3tHbJ1U/01cUiEra9hhRgNLm5LGJngMYnI7+T97yFwDWiBFAcf+gNfncdVPj9l4T4BfBbNOlRGI4ATRggB+BgFNGIrNWBY4jiJNerpiHkBJEAIIWdBEBvDO+ALiMeyTxHvBegiyuEetT6NkdSjD3gAA2KQO6OwB51pe6q3lEAsVC02gCM5jaAec2+3uJR2IXrhCKxm6zIUsH2wMcd2Fkd9W6IK4kaJAMRMACULzidYK3pf2YpX6DeoBPjFe/ZqWnI2MEipt+d5GSEMBimBNiS1iIkglUwIWSgg3etDVDqt3oAQ1wjWggIJsfjiZ4YxHNDRvAM9IsAAFpiqFIklizk6jEKQ0I3VIcMwAmvguLeJKiJ0OJHSNiZDJi/BefFtiRRY6EABT/QADYuCgA/MmxJoYkVwCMuED8kYaOOiHKAk+3RzBpjTRqHJ2jdpebWpqEAWk6AA8NFSSOAJJvLyGAwHimRgEQQJQwAqU3w6kXzPnGJOKaV0lUSSqSlI2XkGFlftylAFiGz387MlRlrOIYtc0QNX67SPZeAoEEICCPHNzno2iGS6IMbnhqs41BW6JO2hwoAAscjjg/FAAOaCCjHi3ONllDK51JAG8GJGIA1AjPhEpSlfNTwBlhwsySzKdbtuJn+6oGR7Bw5AEFItoGHZWuiAJxnfqR1ZpsJssh3VAAD2CiAT4q1akqD3l/0020DCkWMTExoNJCYAM/VtOf9AY/M0XM/3nogyxl8bIvZvEqSnDWzI2BKgGFiVBStEoBdBUKAP1zZ1Qg0LuQKoAAZzILBaiq2MU6rIEGyN0mPXazBjZoJsgkzQjfVah/sqYkZ03MkX6iN7huS3L3PIkTf6jVAoX0jJ9FCWoqWkhExXSBhCyX3ChpGItSlrG+/W2eyOlBYnJkg5LsCDKTGNMFwaYAUzouR5aLlL5A0iWM+kkGPwJYlyCQqD8JTfxM4q4CrJR8M5nSYZuYJAZ0pgDetUl6zwucm4qGbv7CDTvN4kwIeWSFonQhcAMcrJOGUKvxulFA+/e//KiRl05UrzE19RJsPcpn731JaFyHkuNhMkexSeC0PP9yW5t2JJo2ga56B0ABfy3AcNJtX7X4CKH4XoScA7giBjjgAAdkS8A+1tNaHZtS+YpkgaQNwAJYNVIR5u4lC9xpAI42YtmhdCQ02oDJfmSj3pgYwzKWMHrYIxYY4hfJ2GNAk6OiEpb867JIsSoC0isB22IKhoXSKkcUOJPPhHSbN45eADqwAQdYwAMM+zGi8eQz4RbNwK30SJd/8ioFpPkkmMsZn447me4mJomYbokF0pYfRr/LPyMBoQO9JpujPUbFPAKzpHajFUr1V2fR+ok678XE4B1ZZ3g8CY0B9qaZ+OumsYHcBBhFaA20KNHOllP/3nW0dbmraxK78EsSQLH/dEG5JA11KJXk+yr3Aud8Tg6iTUqHnmBjBNOytQl9qPW2pgbVQYcTWX1IaBVSaymS7a50S75tWcPdJ1ntiWYwT0LbIjfwffADXtQy4AELOGADpns2xvH0L/C00ZCFixJpQVwSBpCtui2BACcxUl5z4vDcODTke/7UAIAPG9YYVt9oQiq+UdWYkP/R9l8ihlw0+vtnCydu5oDZ8ItUpYPdtmtGfGSulXhqWWbeSrQLRXBL34hjiBqUcwNQNvc8DAMe2DEHoJfxteMpiQu1G7l3guaTsPB3vUP1VuGLrpWn0uG7PPBpmyVioDjAjpt58CH1tmAvv4TLr1l6bqN9EZpD/yYBPmK3Bw0Htt8VlCm2KTOfZhKSJLrTxSU5HoJFgud7HQCmIsH7GoUVaB0X+tBsv72cNjdPBVAgNwzKIbpdgjxsTzdavVlXPdfjEjFfiSi+FM1JD9ObC3MrtvQFCr8RGmyXmKsqiAeoU3JDY5OaxacuYaL05YqSsvqJPNkHF4EpWh5iR1HQy2427vOPp5QzPT+7o3zVLJSj/N3VVRmAPN9mrB5FDReSWd5JpM7W5Y+W3EjsMKBJbE5kBE5AaV5piMXieVvw8Rb2tITeKAD/TQyl5BqseAe5iUVUxUgGaADFWdyM6J8NTk+WXJJHAAcFqAnxCd3gtYTfoJO0wJwAff9JYrDQAOQT9CEAOW1NDa2KsJHEDGFOUlybvTwVQJ3ez3yOR4wP8tCL0+lWjJ2EwIyEGkVTdu0LijWQkMDGAk2TrYCIxKGd+twgHubKEc5OAQ6MPnVhvcAhAzjgx2QKeZHEGCbJn9jAMNmSfKULucCeAOTODEWWysmPj6yVAZSe6q1GAbyYZUGGkDQAtbhT0LhHXAEKSkgiuSgXfNQK5ImFqvTFX7QZnr2gdQRAjhGaoeWhL+rhjGjVfSAArQWhyqzSUbHVZrwWWDTIIN7HKU7ZT3SQDCDJaNRa0X3EZFxfAAyTGFEeg0lWzOhbLqkKNkFTvdway+lXxpBQGhJF4FD/DKJ8BskFXZTVGp4ZxwTYX6jh3y/+4/SIBCd1TBfpx+0QSwEUwCZKo2gY1mbky2y0mGQ8ieHI4GzdC0ksACGKhAU2Irv8zqe5RPBQDpesXrdpzmn1xnadhAr6lPuMmbloxLMMGaTlRbLN4MUBpE7iiupxD2e9WNwMiOVIiyH+4DoWjaFo1QJ4QKNAHwXM08hYYpV5pLYQmS1hRfM5inoUkAghAAX4yJ5JYLvRopislUJyzdL5FI09kFpIHMWlXQ3upFxCW+u5hjIFzsgkn1isJGkY4XQhVFLsD42RBQdki7So0gdSZX4sANksmeQZ5bs9yQIoQEJ6hbkdxQIZZS55/yJfviSstGFHwMxQUIQu0l4vziVq4gneRcieIUq9oVbDCWB+nMcCbRDqfaKBcGP7sMoDeJe7YAzagIrhoCIVqo3ALZLhIKc6nkywhSRQBM8HJsmkGIBrZN8q/Y5CfoVDBNqghZrtpSZ4xki0oR7kudkFLh2oHN/DeUVNICFRyAbfQcasvYe6OcpjmoRiZhcYIYYJSeG4iAREDgY4GkqudZltFFRKYIUC7E8j2aNo6NxWORFtJMRNVlwH+GN4ZiiM/ItznSA5toTkZQWo7JLhDChIIsXmOCcbbSQV4pyhWOVIUGW6vCZ2uacshZ0IjmVJnYwqusS37RQh+UyElBxDAv9oLK5eJxGEW/LYHWqok8rJGZajVc1STYAmjjwKzAmj/YgjUUQpaLjok/yOeTaiwGEEQyrlyG0kgWlmYpSh4LVKUoRoKT2nd/yTzLCmWRQAAOyiA3iA2j0poMqJJE7iSPBXEO0PhIJbMs0GS0hepAkQYrDiZhSeo7wKaQ0Tu7Fp8slmB9KVtAgXuTiTQlrLNiUFZ50kGwVOnIXEn1CaVo2AC6DABXhnoNZqcF1fEknANv2PHA3qCErLUrRLaEoLzfAlTCCgoYzMMEEXm6LkFNaLqmpLsDFF8GiGl3YpXtqEh7LGIrWYkV4ECHzABYzrB4zAhNoqusaIrwbVxeyhAcL/5jyeDkF+RJFeYcttBrLazDBNlPw0wAMkVZXGK0VySPP1Bs+UVU8aFWNka3suHX4MgA2QwLiiQLl6RLpeLIjoXDUhmWAUALvqZqhYz/oQ1MYSK0E9qk0wIU4FLGBKC4q9WGLIhkYCouHkjJElxQmiKklA3mF0gI5dAAmAQAioC/dgrNFiR54imXcsqMLx4ZtODFjY2fpMbVSMVUqgS7PCm01E25JpywCwyUhyie5pDlbMm1iYVkcwJATkYLrEZ0lw1kWMwAe8AC9igO7BydHm7V4MkHv0D6emS3SiRFdRSskC6KDQKGxRreKKRGhtiOcACLJcQKVcJWtkrf9hZb2y/+x/QiraBqHhFC7cEAY6/kSAMp1tCEALiCu5LgEixgb96S3s5gVCLdAZ/QlxUhmXnsSunQwzLi5JXNejmVF+BMcFmE1NMIDbnkxkohaCRsW/BC5Nfk8Eno4YDYDZWYAJUOwIdBYNDUkcxi742gXgMpxHmCdkLOdLTKZCgm5GEps1+S78ogSF+Wfg5RLKogSHFO9FJG/8wldPFWl8xdlKvO2YkUTCZZvUikTvshCfcoDpOGtG4IchkQdVhK8Fr4W4oGJI9VpJzgT09m9UuEnvokTJkO9pvcoD3C8sCoD+lhoIx2y/JcWiCcnt7s4G/logPmti7OOg9SmYKi1rqEvM6f8PBJvpBR/xROzMlyGjZ6HEGhqrmYTlC8MvLVZXcKpRCiosPF5ECyPuFCcuyMBoTZwHdVVJDCNdOaFWAnth0iVFDFJc7bWjWLxH8IiZVyAxHkNEGR2qTQSP+QIFE2XuF+dHHY9E6QhSw8EsSmRJC6vwIItEmfLOZkheeXARbh7vZNDI9KbsxFUcs8EEdGVPB1Um9uSxKSvE2irjQcliTTjeggwK/z7yo4RgN2JAkAnsHbHwFrILWfbMRuCVfnyP/MwEPC1vwM0G+fWEVLxEAz8wWSXttxqdGZ0yNReEZ27JEAazMiOLH7GpRsby1JIcBYDzj6wWFdqRnKYxUogHCxT/VhFqBOj8UAddWAcpsjanbVLEV2445D1Kc9yJBA/bYWpYHv9hjOFgZzUntEC0GYqZmF5KQP9wsCy3hMtI9JNE8nvQkQulM6GamrT4jc5GG6eexJZZCkn0bgdxsCbWD+bAEKN+nxLIIC8aXnioYG5x5NAcQGfMnEIndCwOzBqbhBXSGUw0ksmVykQSpdOCCgAolEk839F88HcRK765hDKdzp9wcP8gU2/Y1hoKRgiE67hewA380us0nDPmmoBUSk9X85SaRR6pUVVYIP7anH5Eye0SaPmqzVCdBE5MwOpZrkgoJp+IVlWToDDbDAREGub4COao5EhgwBFMbMXCymYQ/9gUwi1/tPUp+2pGNBB+cFtugGxJbM5vzNSdjigtF+JqALNfGwVjFqMfTmpUNJVFI95IU4/6PbIUBwCSXkQI4EAPc4AMDO2w7oRO9wiwPdNkYLaZrue4dB1n53EApBxgZNBZKnPn7o0JP7dJnAcT5bZJUPKj/AsUr4/Vqt5TjEbKyJHe6OxJXVhQCnJSjLBYVNO1rYbcjnUNGJ7k9Ye2zROckoTePEZsqsRPE8x0I3HlOQYr6SWzaBXP/NVLAIBwRBTJwZSEJxShyHLj/ghh93OqZZvQuLZBHoBr/cjq/JHzsnIrEUAReAANkOv2SjJJyLUKvocJ/Y57GNxP98SCX/8w8+mcjzARKw2mzhCjO8NErsGVz6hHm3CJDsEKfWsL8KLOX34oiBLpMkonQbEJbPyxCG2lfOiYhU6AIZaXxOgqohRUVaBp9CKTTROtWSRNkIMvzcwZKWNk9AroHiuRmt2IhijU0PluBj1A167P/OZHiM8E+0508Abxu/7EoIwAE5CACTApJbmtfQjk0m0ThQwAVHwtR5upGQP5nYMvAbpNJA+GPc4rjrb4XnJh+ebu1KaLI88mSZQwo5vqDuYz+nJJAGG2RSsw4MmtrF7ABwitC8Pwj3Nv3y1dg4i65sTKn6V67GYFm2RFA31G9znlTLwmOdHOgPJy8NGiYBt7UgT/J/usM7WQ80jMa7GLBANckolvRqI2+0m7hBGorrK3AF0jhWa326TbNGzEJ7aDbwDk6bMDlDF22uG07mobSgIEdUuUqsTorKHUJ3sjBgMgwKPDhGxAcbWSBtxim9k5QPZW9o1c9lvDijPNCthw9FeIUUkY9SIlPPg2fIID373mkljkuoH4kADhsFUTs5bbxNoOhuWmD2mEuGhEcts8PGK0eru9hM8KtMBIEvQly7+2OUxEcposuRm2nM7Hbr7zvF1HBTdP7ge5p/9pygG3BM0YgKRi5qTT3QPStEefTKneMzWRhrsYD6WcUUAX2g+rkXv1p8l3neokNdB7BDhO8NLa//nZX2w6+7jaC4A9J8bfQ0aVi0S07c57/Y6FJLYjAmJSaLRosM0I16gWP60Og7F+cEhvosQbLxvf78QXirg6rxsFjHNDpbBJjNtkyIxEt+G5Xj66Vo3x5Cl5Tg6oRFt/nL5TwfsiBxFpp8QjNedRDOoO5wRtq83Ij2PSxXyiH0WaXe+Z20TGC1CUnHd9aKa3nmdHhIQsifkSbxXzoyuS0gZAEBAwkKABAgQCJFzwgGDDggMSRpQ4kWJFixIPNCwwYIFDARABXBQZUYHHAgU8Qhw5MaNHAQtWUkTgsiKCBwUUqBSZocKEmCId/BQ6NMAAAwQRCO3YUEKABA4RSiSgwP/AAZ0xMXBw4IBDB6IRByA4EBUsg68EUA5M+nUiA5cJIi4gcFWkS48KAOTVu5dvX79/AQcWPJhwYcOHESdWvJhxY8ePBc+0a0Dl0YZmJz61K4Bt54hTDSCAWNIhBc8RJTdUIMFhAcxCLTt8fXEAAZhgPR6g2MDhgpAiMQQ9Lfx08aKzByQgazGsggMwIZiUmHrgbYsTOmzY6gGDce+4oZ5emrvi77qbCR6AvJ59e/fv4ceXP/+wQI+iJyJA2cBsAudkY0vpKwYSmO20tBpqwLgBEKwuAAIYamitn3hzSIGVWhKAsohYK4gi+xLEiji2RvyuuAwFWG4kEBtSaQCPDKD/KAMNLHDAAg0yMFGiBSg4oCmL9NPQwISoGyjGiH4zbyTSPIKLrQjR842+Kams0sorscxSrwYFmPCiAHUjEsqGiBoAygfoiknJAAIcKMziBqjQgNfa/EgoFgkqwDSLUBTgAYmSQ0DFhPoc6KcOLPCsRB3Z0qwh61Z0SSVHWwwgAw9q3EADnxiViFI0dwtvIibzPG0zCDrrME9SE9DS1VdhjVXWKxNA0EsgPULoIAYdevOnNo88Dc+X1PyJrreGKtRIi1wiS4L/aqLpJw026GzRTocakyAnL5Kr0AIiojQEEEjYqitsK3qx17ZglKldz7h08Kc1A0htwwUQSACCWfnt/9fffwHeC09fLYq3QjcRNGio8SpNN01cCfoR3eiaJArfOiUGzyEnwaSIYTeH8oADEtHtbDNId9S2IbIGGOEDFC64gAQdSr6oSEOnkxbQXD27mVjjFqAr4KGJLtro9+J9WKJ4m2SASdd+GjZFiowaqABuRaptUGzrVHqkeAlOqNl6ec5PI68t2sCDr66teaQ6Qa6IaQ1hmoBGB0z4IAaChnQ7AAp0TohSgipiAEGsiZL61tMYQEAsAxSQ8ujJKa/ccgDU7bVWIQNQUtnWhkVb44aXFtXvn9xqKOyfwK6ozz8DUPlCihg4QAHEhbqRqLZPr0hqAWbPzKVxg8h004RAs/+qd4kAGDbYhDInKHiPDZyqAdwtOpggBb8jNeLLwQ9ffFgpbs106OduSOXF+VxXeIeeX16kBQ4owICM5yXSo74DyHDDAOI1PQIIyjsW8IpQeCc/qbiEfYAbyLhIEDMS4IBTClxJm4akKj+JTiKkgt1IVBa/nm2mc+Mz4QlR6J70lWoiA6gfelwyvZFkKExyUYmyLNi7AO2JOXPBSMWKMqbnFMcB3flJAnMYgNTlCVUU8cHLJAiCEAwEe9iqDf+AtB+UgUUs+IuUQ9jHEo/wUCTPGstF0keAFK6RjW0szOccohMCHOAAZoHhfcoEvdjo5mbgalQDFLC1/NVsjnX8Cq//PJQQuIXxM0d5APYckKOYIDGJEBpIA65iN+1Y4ANShF/vmASqoUCAg8mSzkg+Zqe3qY5Zm1GjG2EZSzcC8I5NBBPcNlNKqZiFS6IBIlEaJMMkdsqFJ5lQKvl2kcEtbgI9mSQBErDFYYKliZeq0Y04tZA8GaCKneqTH39Cw+6dciQMiJABpGm28JjHnOgpoSzhGU/xIXIy+gPjZriZJyxWZHAeeRArv+K9qU1zJQSQAEdIc4AmxoQBuEzPRSRFkWZW0CIMuID0CEqRrGxlAx2g6I4IsNDvcOQ85xOJ9gSwurOQx1i6lB0EEGCA0MBQPfK06U0nFwD0bCQAyHyOAk7S/5uEMGCfvrujSgyqS4rEMKMX+Z2GfoLMu1R0bDJCogAuShAyJrEDWuGKERWoTQEUYGvR21ZMzDoQkXqmTQ0Q5IE80oAV7g+ndbWrv6RGRydJdXr0awB+2HpHqh1kYS45Ul6aOjqX4G8AaRIosiqCTEEGR5lYdUgONWkjD0gyiWntm0uKijyXpNNiDGRUoRw6mbuulrVaWiLp2GSXbsIVPbdCkSFXktaUJtZd6HlTOzkXkbmOVSTaAmdFEIWrrCJFqaexpo1wlNibcU+difSdIwsUUejFlJtEyaWO6Kmh4XqkteU1L33eFRG7fJBRdULQA85oz0/SayIqWytv4Ri3tP/qpE5jqVAdE5CAh32sqDQy6nJXhi4MeICjHuUtScgpRiMpbZnaom54qbuSfp4VvPUrQFLGq5HzjpjE68ETygx73++EbgGkOtLcVLojh3iRtz57FKFY6pT9/ZDDLRQLYEfigWpR5AEIJtNX6BuArpoLrA/mcUNipJ8CKC8hEGAA2kALJQMstFBv7VxE4Dhbm1lNzDbeTE1LnGY1H6Y5CFgoBB6rSnQ5iqxKxKM7c4sA5zTXgrpFSkTqZBABB4BUXuonaYfCgZF9GXossIuXV5JZC3DHyVnziAQCxNOeKqdbY4OmgQL4kw0PpLnJaRMji9IgTEpAAq8lyCvXHGtZ/0X/bnZBNVgSQEC2EBXM0kkfnys9kQVYpgASmCMFIIVSMPbUcXTp73c0RREHuHogNB7JjK4Z3TJCS5nc9ltDJdRP3RwMalSraq0tRNKRlG/ZdyLhRVCk6aKAdtb1lnW97HerOMd4gQVR8VAECq5RHzfYnWmsSJ5abTROlXZUcWvuDhiRoCTtJwvOlINjEiBhKhKgIkmyu1mpbPj6syLGFYkDNdLjiihbYULxs7yQNNQxdrA19rZ5mmlp3ZeHbQEMWGha+R0TDcbNZz4CdsGHYmaoWkSgixucCC9SRIkEZXBB3yhXIi6Umw0K5cmsWdIECjcaE1gkEFBZgtOEUqivROlK//sWoAI0gJvP/byo1dVmMlY1tQgucJ1p01WcZlqkoys5CVA2wWWskfsy9YhgFQ4BjnK1imBHOw6gtGdkR5HWlUy3yrmP4CkCgQTolYMxBaRJ/gw97SYdn/Du+4M4TXfZt3ZunncJwbkEF5/9eyRKClJOLDIsSGcGAdYefLQckuEPRQiTH7KLUiOZkARiG7qcLU6oJ+KSoMNpbC7OeYItsgAEvYn3/YPhWqQ2/KECtQGfk7fzLeTx2c+/rr822FWGTlxqs7dmAlV+txDk/Y6POXZsJLzmd9QvISYqABbluTTlo4oj/15tVMqmZOrkM2wnKgaH/yaCSyggSLoEYvBMt/9KKeH2DgNxi+NgC1ByjQHo7wXjycwIwNWGxGfkok0S0DjqhAML5pMGEJWILQchavViYqKE4+rOBVuoLY52BsrSRc+AzDPMysvo7AEeDv58K12OKiG85/9aCYasI0C8RMqAz6g8BAbRsI3gaAYRhMZGzWqMRAhPJMcuAgCWENF+EHqOjp/SSygwoAREYDuarDM+jgvPr4U8jH1o0DhgSgEoAG0YYC4Gprdg6GFMcKGYpAHKLyKW0CEegEBGzyOkKclyIw1N8YQ6sToKsAPRgwfdJq3wULRWMQ8nYhORRwECiSLoi0X+J9LuxgI2QATk5+xUA5ha4ysk4ACicEUCUED/+g2GokIyJO9B5oJLLoR+rFA5RAfT4EtqAjC1to9DXOIUyTF84EgCbkaY9M6VLAi46gytXMIWC64l3jF7nDCqbGMlHPB4EqICEgWUDlEo7tDlxkTMVC8gJYIYL4PQNmZHEsbK2s31Uu6yBmiOaGolfmPD3qkcOdJoPgchDq+F7gh4OovP+uTWkA4HLSL/DBIrvKorIJABDex0UpHUhkJqQgvCmHAklO4E4Q4p2gRcdOtDCiQhVMZrUkkl1QuGjK8tDq8jodJo0g/HjjFn7igcT6MQvyJIppEWPyPCJILlOoPymGwlgkJkekdVpkyfvuL1SqohDDLOVhAsboOeyGoB/zbMazpvzETxANoPxSpxIiDPTSbFLvAiKhEzYP7uK50xIZTt3ILNhaoiFvPQZywi0IZC0jZrKISDA9amd3hNISgT+VRuJUCPLzcDJT8jX+RSzsztlyjxyHoQz3QyTyACPRIzN/3Fe6wDJ5+s9URNGa9iAICqAB4gNI5uF03qK2yIoDSSNFNvJzAFumJykiIi2rzyQY6i5YqiJcqQIuoktNJq9CBHDgPgMbdnlXZSC/uwuiajiTZMUNBjX3SzPl8llfwIApRlNmrSamwxvPbq9vZQ80iOLdYRKyeGDuvrbCzi6jqqOjlTIgwoOysCArjEEpMPdQ7nNF5ug1CpIX0nX/+UpYo69JJUEH4SbiPtc0WrRFkaC8aesbZWQqAgAj29cEBAqzN6aZp4seykjMoiYsm+yjvMo0SkjkKtsuPaIvJUc0dy8ouST9dy6wAgp2/MRH3aUyJSyyaZJkbwiUXB1EoeawHQk7h4hEpHcuOyr2Jok3EgE+Qua5pET0p/QjOtj1EWJfrgJNdGMy4G9EStS4HmaBnjop7Ygl7KNFBbaK4Q4rHgYsM2IkwllT6kpkM/bCSV9AslRKfezTjcMiZclBaf60buNF1mcDgkqgJKdSgoBSvRYiAeoE8pIuz6bEwECZfMkz0vEuEc5/l6SkCViCpw8XYmtVjng0usAj1a0y7/YjE8zc8lbhQZQfQrzm4AF6zBIJQiMqQAZHXqJs+Z2CKVDJLa9nBYWpJRaJR59IjxuG8kt2yGDOvLwM0HmcdY7RU+YmsgZocY1xJTfRLhMjSIiLA4nOYBFOBJKyJeg01IOWAQf6JIEK8t/DIK24YnslUi1WcllK1JXacYLQiy0M1jPRVT1TQi0FOOBvZeVfY9lAhlNQI5lSUAo6nZulMBCJUTmTQzqEKmgJS3TpOgNNNhjXFaY1PeeCcDKKkiHmslsK8zaie+FIjdojM2ByJXoROGZutzuCUvJ2JlvRYy4uSSIGJeu/KfArYosBDmPAaoussrC+XoyPBPLeUXtc07/35WsQSAuhKIsoiin6IV0BQ0O1UGi8wuREykJ9UHIg6uCfHoIDVCF782chUjrdpEhtpki8wjS2UuU48PAgIEa7QScOdyJa7VAR4UW7RPBGUTiZJraL0OYNcTSfHkb4nEAK5HKixjq9TkDSdje65CaiClT5rCklJKco33MPJrav9Gi2DXQvRVJ44yOwf16PKvZCeCYbMOXdjVPQlH+laCWsqkQh4gAaljUEL3dAqPgwbzwzoDT9aONvx1vWgu/vIDJRTGfY83fwVjvCJW6LbQZ84VSTu2KicvOwRRfjbPY9IradHykMqEsAqOOjgW82aR7dBjS6uW7+i3PCJCZWBNf/9BWC8wGGcO6Y6ASrYEuDPeTiKoj1ST6GawqE9eI2kDwDNTOPgMwH7UT/h6rzjuViTMDC76MwTzVWSPbYvswgVDeIlNcFk6o+vi1zVvGHXwyOJMlx8JSgxHIgFyOHK89Sews+AgIGhELSIvwv/cxrCet6Bg5DWkSjUYQKwMV4slwi4KYInxeFkHSiScBnJuIxIhQAIUcjMCeIp5bFxewFyyN7EKqVu/uA4ldJG7NokyRBNN0yM2ETNrJnmV5mkxTTZ+M4q7RLdm4yPxOISX1SCXafxEGdHOF11emS2wYwVSIAVWQGgNeSJoWOJweZr65EhaYnwlYgkhrVAQtDM8Nwv/tRXKgqQBUEaPN2MjmIZg4OaDT9l47wguwuIAsEeUdzWXffGaNvM7YnmYdlniVnWaQAulJEayDLAxjePjBtW9aKdxY06+pIc4YYgyfkeY4vGa9TebKeX9mjh+BRCcWXg6H9A7cs1qk+icFVBVeQuZ+qh04hQIjQRStBICTtUzaFXCHpcAhSp5BaBxUHgihg7NANp4GTWuYtRfH+Bmjjk7kRDjvOO1DnpOHblmIDqiL7Zk1kRq4bAxXU0I5TFJudUAMXSDe42ASamFAsQgmjiQ7AKH/aRVVjp/V+iR7OJNvPnRwq/VtoubReqKiKKcIYACTqJnC7jyGhZduCR+WIR2/+WnpxPCYhMrxHzMZuV2izG5oiLkE5fZjAOgeouCNK5GpIokAQY5bzkVnrs2q0EYGs2MeyTQm1cnNrjaNuUrqVeMKkRjTA7aTt2mUvF2gnnaM/g2XZanRDEqh+IFe/ZLJP9aS5kwXv5HUhI1KR4rjCQ7hBVSQd6YWACAfqpiAAxnW8JiuBZnWWOkn76jJ8NkH3/aRCTQOp4zo+w6IlYbNZSX8NxVdLTmJn3oLR8qIuZU2QjGN+sXJyDidzZCanI4mhUXZJXkt0HYedr2sUGWejzljlDGtT8ithnN4NBjXHYAW3NoKCMCiklYF+u6OFqXKs8beq6sU1YIalFzj51qU/8vQmW4pSbjZyDh1daGOPn4C7ITAr9DeHM05CpGL41cDiEL9ahStzhuZgTIRYJoJqP6BGuGxRUtaLslAnznTUDC1k0CmQL0xTje8H1f+mfCrwIpop8WCoaEKa5jwswuJMTCJrwYicVDeHHRB4b6t7LyxFtulr/t+PtK80kGwmVi5gI6aYqIWEcGM6WOWhpxR1scGsIVBSNXAi2JuYhztDiIdzkr4tkwVlGrK1YZczMwgzTuJwBLaefM9iqfEJD2ScyX2La/WSlsZ81BGqyhuziA4APm/ANGQHMR3RO9Q5/H6s/xFNo8QLcWYLiJy0S4GCekCaZkykmaVmnBsnBQhnf/tTlX0FEIf+c2oNmxUYfTVtzTQRhvNQRYZMJ2m9KUDIssUgPS2aJ0YcAFWt0lhLlT6oTWAcXJiJwibqRN/qSJ1R29vZMuMOw87flqoX0lniUX8TMBDgpQnfiQDmBM/qo24leQzCOZrebKqL3aFWKxHJxbwst6Ac6laYcyyXQgemAGVsAEhlTH2HFXdOTGVzyJOHreH7mAZsDS7YwpTURbrqLLyNXSQPmCQgSlEKeqv4JSTrggepfhROKxyOrhj9eiWyTzKHwCs9LQB/6QQgCKZMaTuEWoCyK59dVEfliBKEXlGRBPMaAiQf27PINAEELckB6jXtVPpGl9CyRC6lEk//qpKeiRsXj+Jr0ZIZQeeXL4Cq2eb4xecv+blfY+gU/DmO9ZH2kkBei8Bc5tWPQkvASAh8qZaqXYgkLnO9rdIvT0J43EfQw0NgogJIVL6Mkcpdfl9NXTcEXCYL4iUbsanxVO9puiQw0g8CNXMHOWbEzH8KVQxRM/AHLgBWJmBTwqtTJsm5dDAk0kQLY9smynkEWC0Y1j8781JptTAlCCfT0D9v0klDl84WI34zC+eQkC2BpbUiJR8r2YzY1kS3E/91efJJsa/IxjXgVbJJYsBUgABModLgCigYCBBAs+CIAwoUKECAoSRLAwosSJARggSDCAIsUEBQtkDICggAADBP8kAphIwOHABhpbLnTgMmbECRUmyLwpcYDKnRATDhBJkKVLnSol4ASpMkFMAkAbfDyqYKfDBFEFKGBK8EBIhwRSSv0qoACAsWTLmj2LNq3atWzbun0LN67cuXTr2r2LNy9dCCYVJmig4ICBBwcy/iwo9KjGAU8XTuiwwYEDDxiIOgzgVaoCBAYMKJWYmavi0YtVKgggsGDJmAek9iStECZsjRlkxzw5esHO1AMNRITA2bNMy6qPQgA68OBsjQQSlDwZeqeBAQsGEDCQdGd0sAUN6P0OPrz48eTLmz9/dwF2qx8JHDiwOmHrggsCDAj+mSKDBEZhZ9BggQMWaJCBQtv/CVDffDshN9JED0i3XIQcqbSdby4x8FVjs9kWYUQYcNihRDtR9158Ey2gwAMktbReQaMNQEEBD7wWok/IPZDRgQ9yx92BBR3A4EAHoEdkkUYeiWSSSqZFXFgQVDXQaQjp5lADuMXUogAM4ISBBwFuoIFNoO1UXwALIHARUAVASVB/Cx2mUo1HnYmAggU1FKdLdhJUwJakXYkQiHIG0IGgEcKoQALAVXkThncuxqCJgy63I0G+OeoQnjx+xYCPA1Gwp5ZLjkpqqaaeuiSbUapU2AKhCnBTqAEA6iEHknHQgUxBKhfRAvVVSpCUEWnK56SsgeXZTsfmWaOhcnZggZwT/w7kkaYH4JTlQBq+mYBW2xrrEq1mjhgAsCMFuSlX/B2QokoMwBklqvLOS2+99qaFLrrc3RbATvkl9Fhkk2Gg0AAHPNCApAY6VCZF5lo1UZMC/BsTY8t5OtC7pi3FasVdxeSsnB5s0Gtq1w6nklDflpYUSusdwBdC4oJ704FbwttnupsaAAG8ApwMnAEJ30t00UYfbV62YekMcUwQ8ITQfwFa4EGBEWE6EI1vIrDZygoRK+TKoZ0sk3rJKTyRuKqG9cCaZUpgkNcL8RaW3AjZifaVIcvJAQcKUWmpTNMWxNfMLE81Znc033QmRm/uFDNmCJT0NNPJGaBAkKfdJ7SkSP9/DnroorM1uOV138RgCCAQ8WWYLT0swAMUK4aVSlobKIHdjzPc0gLORaS0hVvDd1QCgxVmeEKlCyD33nKCmRDdA6Ed0fLMk6b0t0pTvxiafs5Gt5sIqUp2RNJvWtKBBQB1++juvw8/0a9uWgD3EkmgOgkXXLBDB2JqxBeJPWo0EFBacUIUKmFJhDf1axjYfra419lOI847CgMaFhEL5KpfHRuKSnilGMANZHYI2Un5WkKVLCVmNA/UkIJuVzB0EaYBB4Cb4gJgPYcIqzkDiJ8PfwhEJBkwXYER30wg4wATkAAEIVBA5CJWlQfYMEOjmV+waqQ0EC7kVQWooc+uF0H/iphQIyZw3HI09QAMKkSDHMyUTPZkv6EggIbfoxXUhgI7AcBQVx18k0wkoJWuqJEBL0uICL/iK+QMKYiMbKQj76Ivy+FIIRPQQGSoZjX78NEgYInjRHgkvAiFaoU+yaFqqqIA3WkkeTJRGgkxI4ALCGk2y5PR7RyAgez1rkwJeFADvqeRBZhsNBRQiSqtWADYSEWVs6GOQs5nO9s9cprUrOZZImm5A2TASw4A0/8Us7whTk8xAnTICWeDtXFuUWdhrJlDCvBEnwxEliOEDTYViJASgMCNFKld/eb0ztFkyYhiBEtMuoWAxhgQnz6hQGCYGZEBtCg/VuyNSsRizYxq/xSI5eSJSvK3vw34b5VvHJFgLkoabGpLTsS6nSm1084/AsUAapTPPAPXl5ZwB5gBCMEJRkAfihwSQTg5H0OXchGIgoWUEY1UQtSXOIJ4UiJBEl9Fd7LRrGpVdC+dykBGAAL9XWCJIYBVjR6YzCk5hKfu7M6ODOAnBlAAATXFiab6JBFx+iumjJNbVegZFnuChUa6GcFP20SRUK1IJlKJ6doIUleFKO2ZKN1dR8D5wYXo9Z1b7axn7/VAqYxgCDDY3weYeMMQSYxGEECoKg1HgB2dzGLjUwlNjwK2tC5EpSqJLF8VgyfAMvUmL6URUUBwgrJqiSJD9EhMGisnww11JP9stewBKzLBhTy2TokqaZwG8C6EJIC3Wfusec9bqo4KAAQf2N8FbpABg2VurYMa3FHDaEqIBgBdCoOmVIb72xfdNGOzCe1KFVIVEFwgBFrU7ldCSZHz6XZKqUmlnAxmy5sI0KqpVQhvHxBPidSSN1JKVw/Ri+IUF8lOIL0ACj4A1AkzRCRwNdYAEkDXACdEnOfUyB0Vkk5zAqXHOn6RAWT5T3S6ZoEDAQELvHYcsOhOYuJrUpKLnBB0aYgBJZoIeSngQYeY6zTkFYCKz4xm8iQgBmIla3f0i+VJYRPCLUEXQTGjr57AWSasnJQD9hzVgrzSPgRgAIAoUkywVDeilaL/GBenSrPSEVkjBr5sSzBGkPvwaJFp7rSn40KoSwohBspFXJxPbUU6UzqgFGHMeGM36BBR5QCLHlQFUcaslozMy/vScF3zSNTfAuo6YUHAfiCNEAgAm1ou2SyBN/vpaEv7LJVs3QTGMj9VK0QCk4tIn8N1aoR0FNl3I0galectmiXPZ3uU061loqp2R4QDHqDqYA/6oMVq9iv31XGL8EpcwBCbUTrdVHsaAE2MTnvhaN5mgHA1q7J4yiknQo5zO/Tt4omkALGW2d/ON+nFEKBhPiN3iNYGaJz8eeQdeuFRoLfOBck7IWCbnSm1HbE6mVxPrFbMGAv+Th1GRDoML/p5/zFgKwdwAANr0WtaaYuQIOH81GCbeavR5NujZEvG7fxxTj4GmxQYxOpDIQ0bY6i4EEdMWRF5bNMO2uEIwbRgdXUV5g5k9VAVoEUsOcmVeGL0wGs01AKq2lt4BKV/HijlNBNguMU9d756fSHE2jlIAIvTIuPyTQcTDk4OVFcuuwvXBQFzhwT4Gok+ZGHd6a3x3DYRpRVgAQTY1n0eFnHB6z6IlbxkmOay7J10ikynxzG5IRBe1l+U7DSbruVno7RFLw+iuIklTwRTmAA7IJMXI9dEpjixm4TWJd1SVJ01MwBz5Sdf3clWZCPvcR8RYPf0h5/Du5mru7j9K05hu5kyt/935BYaU6cQCjIdCRFkcadh3jMb3sdXh9RvSsN88oR5UlFrxkIT3DcbUucSYBcr/icRC8AgWddVrCZACWA8XyE7jQEAJ2hvHaEU9SeDn9Mlt8J031GCARVvaiV0FdNHFAE2oaRSO0csUuIeCUVc5lRkKCIjsbYT/SZGFbgTDRZCAlEAVkcT3zQcKPgU0ZF1sFEhGmEuXDc3TGMY2qFeWbEQwkdoq7F4MwiH9UIotoJJ5NFG6aIceMJx9qF6LeMS4wd0BfE906WGODFUnCFoNfMgV/h4LFJZdiWFDpgbDkGAAZABNUFSfvEjPlEnCKB2IZIt3DNdtbZ/0FUuKrEom/L/L0EYAHYyOSMSh7FIKgEjIL+HHgn4Ff/CF7UjFZWIFLmWE3vlF68SchJxVQfWiDWCd4ohdjzCeKhBIRFTaJb4buPiEHe2HAxQa3tyW1cDfwiWTQiIOJVGiZQXFDeWHZwli+tYJFKDf7lnJLDEIyt0ErhoEBxTjoEoVcY4ejhRih0xgcnYbI94Eys3R4lCkKMxRlAXAIk3AB/iXQo4G1N0ZQuxHd8iiTTHI68WJZyHOX6CacXSKx+RLzXHjic5Httkg/CYKj0iEf8IQVjyQfYTKtVVQJtYPEwDYAJ5FAuiGIICNs+XELsxUxmxJ8kELTEhYTUSZNqTXeY4QBHBW6ZH/wC500pV8jA7WUIj8k4QgJJfWRcBgHSFlwH0ol5ExlsXtyym9kkBxTkK8D2zdoEasStg8YU82RIC5IsvARoN8AAKcJc5VW5gAU8wZUl/uDEn94NDmZjVs3GDJhVXmGMEFEVcI4wUoS9rw2lgyZlqQYsDcm1Eo1cHuG+UCBQWhhOONxEJCH56pFpVQVMYE5C984zLgXo3gRvVCBs3CRbW8xke4DeHA1mURmNzeYr5WJpRqZDkknEt0TO9+VQXYTyE8UCPpXCduXsTsAEcABfV9o5IY4/mFhGtKQAEwIC0Q3yBZm7GBC6EJBUdJxOaQnFFpjSfSEGCqYzsIhWvEh/01v876/EA9iM9caSZ3jZ90GdbcvKPEMCbptER6oOdu5cBFrABobkW97d0LHk0ZWaebVMYfbgSBQGFKJGRCpEu8LkcKOcTpMGKOgYAh0RCEtAZ2fdUCmAAKVCb2PKeYKNFMEcntmc3QUaAQRZZeNN9olEjvEUA/iUATlEiKGJCERp4E0oyaiGWSWd475OGfPJgrqQYHAiEmXKZ4JJ+B+RyPdmPOnYfNFRXe/IRmiJLgdkhkcQX8rktGsQms/mLl4FC15UTEuBJBKAADeCJiYWTeWmcCBF8TDoQhvQVUlp0H+I3aEF4A1KWP1Q5pgNKioE1aukyI1ESuhRGgISE0KicYcb/ljwZZJtTELK0lxHyWMBUHRRhAvskiDkJjP2UqMmmEXbiqQtBJ3cJolZHjpuyYxYIqdMmqSzpnSJloYykNMfII2nVWumWl3WCot54qjGVgGiKpLJ2PM84foNDTzkaE02JE0lwArY6S6m5mDJhEaVqILK1LUFWjJu0eo7Yi9whJZmKGF6ZrJ9WKB5QFhhKMNb0RQXAQJrapGDDU9p4YZ03Vc3pj2z4gWJmrq3IOyyqLOSKjBFUOw/AVqxUAIbVAkGBWea2Z3mqfMkREa8SIdtBhn9zUQq7pISZEQDgrwSRAAHraRrgABowFmM5MFu1Xw/GsD6JELyIjXh5lexZVJkV/yFDpZW9szHE4aoXliM2SqOGBGhRYVhA5ZrkpHOjsTwNsz3JVpUwm5pccwD1AQChZZ8NKRUlgVY2Kq8BEK0+i2ZA6wFIZKnmtaVJO3oSs6tOOywgSHq3ekaKexS++qYEIUuH+5/UsrG2ORAtkFzwxFe48TBksxNg9lIjCqzXGADkaVaz8oKZ9UU5Wz1YxbcoxgElUAHdZIvoFZ4mBJvFKhqjhLgClqplsxNNK36Oi5uYgbeNsaQ3ajfNqV6vWrlOJqeDgi4KUH22Q4iZpqN8qi/zCTxUNACw6Vuoe2Kx+1klIAK1Kxnry77tKxka6kh3yB1SRB0DwBe56xAZsZS/y/+pyKGnW3m5sDFUpLscutkSV5WxCQGROrY2+ZFoBWEwHxSu7hqNIrgg34K6H6u6Xxda5uvB8pMudDtLvJuvvsu/o9Eps8GNIfLAp7M4BqwRm7UtCOCh+tVaCJAD0XIiDDC3pHFIMpYlJbG/MuEeiTJdbsIA57NHr0Jn4lJRm/nBUYwqvCs05vRSDYAdM1Jh0XjCRaYgTrEAPByzyRtGMBxhyLLBCJElvxqC1lEQQUAyb9Ii/1u57HE1CEABBFCnjclzlqJlCpGVraYquqNXUCzFh1wq2Zs1wifB65Mw9hF0PEuxXTwoEFAdw0rJsaGMimaR76qJUgEDwZll/MRXZZr/NRIjp6tKyvLYgyVDLYMRNhEFJF+BV4isFxywAbasf7noI3YisuYUKsYmlJmcpFMxyadmxmEaLFy7LXrXT9yxAfW2tAkZRkGSAGYTFsimdwyQOfqGXd8IeSo4cBRgwdyhy3phARFwqec8F1sRUBlcnnViFGtTvcQ8HB4oJ+Q5s4hbQVvRAMLKhQdMzcdqUAPCEJDDV7UkbnAGOxSxXQVTFWXGpfPLznjRARHAnRU9F3oJFuWzIJ5szzEXFruKzagpEYCYyc7jfiGyHaYnImgcAGx0IL+F0rjVi7GXoB5GuD2i0XcRASXQ03Ihra0svxZFXz4xH12byQeal105EQpN/8x7E4YIJJGj/BXxsXlBQsekAdXG43kugU0q8rbgqITKs9O9GdRpEQEiwBYOEAHPmtZrIdHKuTZJrJw+w7ktEa8J/FRdBtZPaairXDCA3cV708IEISeC2l0akUMB+hLxVSn3KmeIkyW+mC7fQ6RkfdbSFNdnsdZsoQERQLCdvRaDC7XixiAnc4Rq9EAzRzfZCm+I4RI/R5cpMxEtZM97U9MLccxH8cB4pXZZaCa1t4TIIbp+WNs8AkKh4WiE2Xo6c52kDQCfvRYBEAEVIN1Wmi5AIbIRxRmPrK9VfdD5y9ItkzwPA5/RymuCXTFlch811E57IzGSTab4PBHCHW6d8v8RwYOYBlcwdPMaQ6UVOeYe5NygE6NS2U0W1L0WFRAB8Kvgx3gts9oSEhAYtaY0WokuW12GyEmifNqnRz10HdRLoKoRUJIlk7QRBgB7o+E8xAJimVwbAmkd/O0Sh71M8vSU9nVp6caoAJvdDK4WHhABQqvgaMGoO6QVkZUlRLY89qO0EWLjjG0pzMSyOC0aNYfl+xlRseriLuEq8C2QvqIRCxxuVjQ7M2Md+4HFUjuYuXZjk9lWrhHXFmDndx4BEXDndp7RZTEBEeAAR84kXO4qDHI7OL5obDKiBjTMGsneJwJne60R6XQQAhRiityog33TPxnSCEGRCrAZIVYoNjb/y0q9pAGosZveEjNTOsAUSa91wwoDALxoTnGd57eO67jO1p4N1IKOFo2VQzyFLpPmHsSj17T9ant4FMDCxjrmnj+TI3Xbyb2WEKX45SHtI2yclIPC7B9ROqGlIgEZvhlWEcy8WznegVUNog9x5EKeFhfd575OFtNFEl9xQrStGIACIXuaNcYBJF3UvFjmKU+Uu6HUVdduz+KkartWI8tzMicKUG82LBtnQFWbbCAdHcnU7ru+Fum8zvI+Fga0bPi0NtxjHcxEjDurwZ2Ome+5EMv2PWlIwBGRzHGmUt/SNzVyPgeBv+p0E9BUPkdJiapkPRQhAUUp6O6OFiLA8SA//xaaSjFNgnNQwhJrSms5oS8H0uhe3BuL5iNaY8ojESNNCkwv1ewuUfNYplcrE82KWY7TpSpUqI8XheMTw7WiiEFyaxJjwRjyrvRmgQERkMtOTxamk1aAMu6MeD/mwuLbysqClp4JL+Jvwl+gcQA05B4qsopTGOqkkfb38VA5MSmess8xvUFHmohHe1kGuGcMO5cMoCarEWT7TPjT3fRosQERcIO1P9fQHkISvS3TFfYui+05rZ5U+EVXxIP3WMCwkU4moikcftLSTkGnr8KyPc0HZB3TCxI0xqhU1Gr9GIoUUft/XxYlEAG1TxYhmRWANtckxPjWSC3c34hs+9RN8f8tpRgfe0K5E1HzQQIQBQIMPCDAoMEDAxUuZNjQYQACBw8aIAAhwQEEAx46wPDQ40MCBw4QUChB5AEFFDR+/KhAooACL2XKNMASgcwGCgvCJDnggIEGJAcCIFrU6FGkSZUuZdrU6VOoUaVOpco0QwQLVbVu5drV61eqFGaOLbCSZUmXY2ciYAggwICYBssGSGuw5lm8efXanHl2AASPahEuTGCggIIFez06UKxwwcyeM836ZQD44QOZBOBKFNrQQYbGLAdgPtgzdIDHLwskEKx6ssO6BwU6TH3wgFuwuXXv5t2bKYcIHXwPJ17ceNGIrW3n3az8ZWKQCIQml5jg9HX/7AMHyKTQVnHrhNk/Mg7NADLE834bLHe41oDMhxMqTNA7AAHG10TpyoyrQOOABCSw7CPWZBpggPcEQ0ACvHaS6K6GEpRogeMqtPBC3UqIAEMOO/QQKQkFm+2sEGcKiiYG8IrNLvFaVKxAFrMr8aUUXXSIvND6Qm0m6FgqsbuG1kqvIfnoO8u8CdsT0UEBOnsIRokUGoCBGQWA0K/MHlrrQy679PJLMMP0yjmYvGtoO7X8G2iBFQXo0aP1XnqgMf1sDM2+kVpEcqbwHPLJAAVqDA3HxqAUgK2BShzxoz2jbEgsGmey7qEMCPUoLtkqWwgCMiV6jSFOX1KgoZtemjQv/+oODUwmBMR09VVYY5V1ODKBVMittmpT7dSBSpVoVL5eQtROYot9aIH1CkAAgQYUcJKhRgXgdS9LFSPAMIoWYtIgYAmUzKE4DSIJ04M+xTUADBzwKSZloVWrzwDIdW5YkCSaqyEo4dWLgIpAktegAWYVeGCCCx5427FKMuyATwPgMYBzBwpXNrxIk6thYzPWmEQDB8Ur4rPaNEjQga4V4AHrUj3IowUCVEhlfYdaaIYLQvh1IZVfCs9Q5+D968z7GPQIQATeLMwABAZsLGe7DHb6aaijNi5e5UjaluSBDI2ZIJrwgoCCAgpguEWQNzb7VtEk/SgkBaatNrtoJYJXa/+q5d7LZJTxauCDC55TKFS10Ov0oEkJiKsBjBULsQCl83KrSgEakHpyyiu33CmEIesaX3bpdfcloek8++ezSxfcVI+YvDeAt7HzlbuFJBvtoG6NDfUDFKpb6HUDLVZL0ZJVE08CVhtbgGmELld+eeadhrS1KrHL1/RC+0uc+uwMHwtjXQcbqPXreD5I0O7FHYgBzcxGUwASSCCcIQkgj3smCbS3cqUZpy3boXPbnLM+30mmeQMkYAG9VL6Z/EsA2QFQAq53mv0NpHHeetBDpvRA7ERQMesr3kOe5yjWNYYBCXiWdiDnsyGZDlMo+IBBJjiQAB7gg2SR0mT4tCnHKcT/f3hZQGIUyBkDBlGIQyRO5l4yMYPkBGLYuw6C7IK1h/yrhA4yAAaZqC0TlfBWmVMI+PwkodUlKosRgg8TU3WBD2jRhLQLQObqUoA3MeRfiEpAXLbmkZx5riH2Aw/EiPhHQAayKnykH+9goscr4oWDAMNZAwrQgBoBTiKe29aVEvmW+jUEiWViSc665UUySuR/a/oWbV6iRrMRgDQ94MhHLJKRrHVtAASoUQR5phFDKdFMmhRl2sgUMEEGU5jDPMoPDcIWBhwggLW75FkM2SdDCU1tf3vYdTSYFyY5CWG6/AgSzQLKhSxyZC+bCRT/dhFYNnMhrXSIr+AIQ7/pJZsD//lXHFlSF6Q1S4tGFCAx/flPIorsffTsGLGu2ZhNjlJzOnIM/Zp5SynJxJwOKYzYJgNOhcyvM+IUwPUYkCxEFuug8gENQ3gGGJ88sTENtAxHp0XBmTAzAJDrC0BtetPmze8gSnRp9hTgrIy16S7IK2c4NykArB3UTgFU1cswFbrrYFSCpZSYqBj1Ekt+RKnXKRJDmPrSFkmyNHoxZpMYwk+d4VSta6Vca0JyVGYVIFuKkwg3bRS36TjHkhy1kjpvCK2JNsYEVuTazRhSlzsqZEaodNGUzpKB+cROJomF1gEakM57ljEvrWFm+WiJAAndhq2jJS3BZji4SQ7tPunkGf9UbfQ6eDlnlIXFKmEzlr+M3aRvVcwLYi24AAzOxFbFcqJcxkYpQn0VL4ay55l8F1glpUlmBFhWdaCkrNJmV7uwQmunGtY9AxQGJ2Q7UwIcyBCVbZKZM5rtJVXGOGMVqG88YWyqQrqXsYC1RQpEZbpWclIsYVWrL0OAfj9iSN0FoFEUIQnTFLBdCEeYS0TVWQI06pCyVlA0tLSRTxrAsPJhbZN2vaQE4sJbY8VlvglmiGezY0QDXwd5i1rIAgzgggsUgEHubC6+qBrUsUBIJsCCHIUkfGQkF4evMkkMR0uIwLHcl7bvLBYfneSWnDEWez55wAOSZqyDrFgiUERYVhX/AwGmctJOCDaIPdfHt74quMcU/XHGBlC/dbUreGX8YauS/GdA5+aowoPnS9pJpgIw1pAaY0BgmUTZsxzty6JTiO9o7KIw/3Uhm7x0aDJn27wQbyz2ZNIH3HeA+FlJiyATZ3vNNs8AiE8jkPNzoG19a6rQ1HznOyVDZqeWBpSIxAr5V4wf8kJ+7WUBy5ozXhb3Qr08s1ilEvNEHjXkFjEtJg/Q8l4UeGlCss99oMML76BLLIjGbTbi6yiu3f1up5hsyFizjwKOuxBdSze6qd0XadQUa85Qj2dSZgkAolcsl1RbLmeSqIvKamy9LECKu1MLGofsWodc6wGIwd4cxZhg/45KDt4jJ7lRHFZQ5qA24A35F8bxqBoI5KxHWx2wR3Z4nSqBuj4mODi04pLou4rITgxg1sbfROEQWHy82Jlltxvz10oClaklpzrJOWpmj8xPAUAp67AN1WmPVOlfDIO2nW5+msw1GzsOQPDQ1H4aCdynzrdtTdJBMM3QuPPcdEUdUREQLQJUXfDuPjmTF3JNsTKy8IE7tEEeAGqVozhjeWQ6Q4vlgPJBWmNM0/lpMiyAEJzg7kc8DUQ9goAHWPTwGSe0QAEGAQTYG5iDp32gjwpxLBqWwoo/LIvx8nn+dH4vE3N1Y3iH+9MwhndOz9jmzpZvg4zgBC0QcGg8/pDFYf+wjnZZyaANkoDahx/Xi5/I3inuvZkqB4qGfLtOVN5UjSUg2Mg/S6rnmjHyqIzgDaH5kewl/NDYvYOQvhHwPY+YIE1Dr8nKCwSggM5gt+8TPwkMNCNiPilhCOf4FKbSPO0QEX1TJxBcjKp6CQAUDwDBCGa7k2WxLQh8iRY4gQI8GWeSC3pRLodAGLCrMUx5vEKbCQiYQCBEsvTjj+xQDpmqG8M6C+/LiR6aEQ68kwSQjkTqPxEkv2NSpw96Qvc7iGFRKgZYgEeTCRA4gRDYv23pk/eCNhz0CFyRl7tIKVYJQjk8MgRrv2NpjQZ4oTZBvt8xC56xQ2vRsBBUDPJYC7T/wZ4s25cs2aBMaiMxvAC146gBgZEHAC4KUADMOp2DGC6HmB+z2CQGmENR3K75IaEFkAAJADU2czyWITS8MBEyM8DGWsBBpJaPS5JLGjG9UC8TlAkXMIFOKqqFYACNUJnJYJIHgDZcYZoeEa5RfMbS+jz6W0UBcLmMSpB/W6LV2zTD8xPzKkGWEJ9atMUdsZtmmhGscwh0TIts/A6ZqIEN8BOwUaAec76SaYAHCIoAMzRSikNo/Ee10ikayQsoEwAFaIAGoD+C1Jlmartx3CWGwBEuu79LQhiGSQsDmLPuCiOWAC77YCoJ8AAO8DVjgq+GEDUSJAxBtDlhiaV+AkiY/wQo+/A+noCWAjMLt1AdfiG+srsTZaLIu7HAl5OTh8wLqcIeABAniUtJP1GO/QsAaowzDvCA81MLk1RJlBMnzXseROEr8ItJsASoFkS/iXkWAtg6WMoZTlQnPlJIdew1/ivKiJTLNUmQjDSkI6zLJGKqdFSIsTyAAbEADag0p8yoJiNChXBIv8BKEgxLx/Sn7jIfQ7qeNSwdNgkbRBInobxBx1O0mGiA5qJCOwGlidxMYuG0vJiRYZMjYHMIC+iAW1SLOYGRAkgmuIQIBcq7mXhM3hSmsZwIQ2RJV2SZn+C40OgeEiuz0ikRQDwbL4oWLSwW5cQLlBwrlhAMrGulqP9UNQNJAMwwAEFhtzfkMGhJnxqjid5MT0CywsGhrJxBQwN4gHtTGdMMgE16ljbJQYgosJ6MS5yxRxD0ohkBR+yIG/p7tBazLMwSjMT6jCG0i8makZBSC6uRDehoDgHQlxUxMvXs0CDaTgr1kf/rlYFEwpV5OlpMzKVrCAgIkfqkLXtpTo0Bn8STloY0R71gAAooGviJp1VMnK5KgJ8iCZpko4ZAIKDjndmQF+lACeuoKP/wUCkNIuibieLDl/iEpVQTsAsbmk8Jzoi6zd7jR0+joRDEEZCpUbekKBmS0bdIQW3EDufLnNX4iK4yqcJkuEWkn3wzgCn90yECvgIgDQP/2FESkie1mJIUwpkTO8YVzainCicCgA6Hagy0mhbqetHk+4gBtSDzHBrfWVNiYZrjaroSibFKaQiBLBfsI7QaLdJjAlRZJSAB7Ktfs9B99EETNYh6sZcB4ShzWgCscSdSlQDzIyfBsJWlvBjT8aJFykwJyUsY5T0XOcu2oU6yMAt1Y4l0UUCrRCUMzVBi4w/nKIBZPVfmcb3lEBn9dMmZGCoxxTeZ4BUwhSnZsErCKtJTcUOIHE3RAK1AaVUcDRIAfTFRmoyyWTJomjuG6ABC4ahZ2rtblUGoVA1BRVeMvZxlHQvNoNA7UyMI7BE2AZQ5S8B6vZTJEjpna40a8cTS/znKO0S5qmRK5liAF4obzVtFFdWsj+gAC+DGgQ3GlqxY7lNX28hYpKWcJVMOFyW6BGiptWiYkDgAc7q+gWiT9hMuEwvRs9jIPYsnGyEAfAzY78meapLXsdBCB4kZLqq/hHnQJGQJDYjHLYQ/FZGJUYIAYuxHEfnBpP1bqAE+1CIJKqHZMeWWnUCMnAsnhvy9eW2ox81Vjn0Ly2sRQxEKmDUlmQU4wXC6FWGmzOk28UkIkTGA/lwIDhjJv+m8/Mw6mgJMwI1dp6lVlYsNZcGY31xEhZiYdmXMhZOsElUPCJUJoVmRpzwLXEm82UDTmnvLuB3B35FcakWeB8q5Gj3ehf/YAKrEjuo0iLVEGwgI13aTXfItGHl7PzIxsColU4jpXrsNlpOJI97py4+gqlLRs7B9mMz9IiNlCFiNtEW9vevsi576CDj8N8HMDnmxIjjMyPJ9YIMR3PdLxzRzq4UQqr2IuR57HgU43YfgHZki0F71m/31VNxtjRGJWF/bHoId2mMzkYEQxmMjl3t5zevA2YeIGAje4aeJTPSlWM5ELXhJKGIBruzYPgH4Xo1BzBIODV2blHDhQRItWLjdNZQVFY2YX/hlD9bpiBz+iDW8Jh4e44JZ2sEZu6GRYPTjXH6TSw/eRuxQmRpp4tCQv/BKlfDYllHKuZYREGQ9iCv1Xd3/8ZUOZgki7qKS8s+HaFutImNHnhUzdg7/oOHrgUOUUD+GyD66bCYwNIB7owE3/Zg4zbjzCoAaFYpNMgwWs592PD0WfgsPxmCFuNO7SdEcfmRcjhU1ri3t2Il769eMuuQE1MvIEeFNlpJk04uIQZD5wl47m6ZafROc3KwOUkTUWQha1gtNVuRc7mZXAdEgI5YTXBZ9UtXGDQ3RTKQPqs+YWLFTAYCz9GRj9hMbkii3sDFRGuasQchJOR5BabQYhp2sI7XnHYhUNb6FeSBvXugwgVXGI7BTiedMlJFuLBYI2AnwvCLTs+YVGxHeCWUDTpA6dUQNYxLwrBISoymUqY7F/3qSTKmsPHmIbrURXMENhr5pLylclZOS5+KdeT5ZRc4a/BDRMeMfjWEqZyZaMevA6gNmsoJLB8lDTRSXo+JEcI5e1jPcvPBZUQ7qtsBpsO4SH8ZRo40cTItcRSIXVMoZ+qXpcjznvJAvimFjT7ERnqmJWy2LkOO8TP7hOEMv8XoJJZbbn01nNgxrxPaQSBbEGq3c69gk29okNXTsjIHANTWIFaMjhv1iMO4LRVGgmnidd4qYCu4UXtlYbAunAwibX84oBIDHWTaSiBMJ60hs2+6Qz1MWJ1nsBUJevyAXZ8Y7hjCk3s0Ot2jBN9bB+eoTcWrrvSBu3hbXt4jCibrqcP8e13cJJ3JxtboggRUwaJiFkjm5bfKuEAHcGr3qMGah2r0oYD1tYzsBmR/KyOswgVQcbrBtEXH6u06xQwjYZVfcPUe95ik+CBS4gYHggMHEi/csbwcvDnxWC0TKpW2xQzyZ6BZhqjmDEufeixEqoZhKnK1qHbGV5yozx04JZBYFrX9RgK39wLF8E6bipn8xAdgMgAo4iwiXiQfv8eFowYZB4vCIH/kkrGgB6aHsXwtaFk11iBaVjckoNpmpIb2g4wJVgAe4PxCGHNO0D+kw4pIpMsj9wCo2SOD9lVbCgBUYW3MSDB9/891gTyg/RAkKRwNAmigSHiJv7fJ4D/wVDyr/XJFFMaTGsR/6PgsrR2dDERRfSYgBOKro5KEotEsRU1l3tU665sIuToALGD2zEuS6gnNRB4tVle69CBFX07r8NmwQ5CiocpDa/Jy6ZolEn3JXarRWi9PXAGo7wRh+sqQQgZcKto4KiAHpsxk1m1ZPGXVm74qo9BwGUAC56gwJCLY28Zxa7XC9kLSNsYgE6KFX1o5k9t9qrsKNefTWuJ7J9FQkVyQD3SOReBZjYgAggEFTG5+ZpZ3Za3Z+p4qPssr/TC11pbHGvjgX4clRzrZfGQtpZU2rgoj3MADXqnWjVizleKCyNJO6kOLKDlpQOdwhIwACvADqQyrGPaV+T/mt/1hFfdxVaVGOaeEd79P2JNd0caaJt+WYtDIUeiGUwihy0TjUJ8EIASxup51se5m8b2+gxJG3fyvImhCAMQSBvrk0BsCUWlN5rZeK3MV5FMYXzHiAVFSQ7Dg78iLunmMJ99UIXS3baU2cN6I3NW7yr125syCAb7/7gpb131WwKpEBGEACqb8AEkijrwYAYfWjrV98qdjlKp1BM72O1iWWzMFhBgy4Lg0hBXvUhTitvmZaT24y0AovxVhFiLv6nfpCbUymkdhvTkVrAMDZMWyhD2CByLoVxs99rXjyTonM2TieHov23OTechcPNnlXknY8UPvYMS9qt1dMDETrxb6SRf/S9hbsNrKoUECmbIUYZvtJNIMIARLodBdIgRQ4AA7VffWnijMu0oyQENOFY0+yIJTA8M93PA/eqoKcDicNAPtjZ4AQIFBggQAEEjBwECAAgoEOF0JcSMDhQAQQJ1LMaGAAgwELFWSUEHHkyAcZHS5YCIDkQgknK76kyBJigYwWSS5IiVHgiAsXSPAAIYAAgKJGjyJNqnQp06ZOn0KNKnUq1apWr2LNqnUr165ev4LtCjJmxgEJYh4IYIBig5lqKXokuVNgSrcBEhgwgACC3b4sG5wsQIBlQ4cJ/OKkSMCkwAseF2RUQHLAy8EQ1p4cQAABAgaFBWx8qSCuXbIC6gb/WEnyc2DTAh7YZS3QI4O1BW5KzAjixAkeAgqEDS58OPHixo8jT658eXHKrgcyCDDW4cYAkMu6RVCgwOiZGhGDDzAAgYIDqCOqDnAyLUvnFA9sPzAgvd3xBxAMwNzYwMIDDguQBtFZGcEWQE3rRTTgQAe+FKB4Y8nHYEYF9SXbc4rNpNp0Ahw2lwCSQXRSCB9EcIIADDCXooorstiiiy/C2CIDFwrUgIcn5pZRdOEtBEECCPiHHUn0geeeQIe5dVJngN12kWkA8mgdRRcIEBcBCujlYGpBwhUABYHhtpCEBKEVkZG/WTjQYHbNSJZ+Ax0A2G9I9rUAAgnExRhKTor4/8GJMQIaqKCDElqooV3d6KaCH3YmXmZRthkTakRG+eZsbm0okEvU5UgWe6mNV955EXlI5Y5+bepQgWMKdGqIGckZmEQEcFnRZwUY8IACo/5l2mJdDqDlTAMcYICNAUCwHgE7hprmoc9CG62001IbFkOsNmhQrfxlCiKP2C4YpVvJZkTnZBIiYOlQYj4J0QASmuvulFWGN+aa2Y7EagK1qrrodxAsGyW4RyILnwDyQUoRfm4G6KEE1UIcscQTU0wovy9ZdKYAFEgHJ0uUkuqruMMiaFcC5UVXcqKqQqTuYxAOsCGV/BUpZwF0qkszA6dauNACmR5sWlsjv/UeAWsSHf+RurG+BOBRxBqwa8VTU1211Vdrpa7CDJ200AALCKuSW6mqiivSSUekJ4aIKekukAiQLZABImnM4ZkA6kmlACKFF+xIN2rGIN9cFrBAerU2APTaI/tLL+M1GbBm3RcigLXll2OeOdYXK7aA1kkT0IABnKNt18qO93Vx2JwPddK+NjGot7eqpXeyee1lWrjGzAZMEgMHHDCY1h6TBEGQD5xtZroO8S0uv+WlSSOKmlNfvfXXxzi5azQ7T1a8UQ5AgbFIr8T6wYh5GLlbtI65nUYnGRC7QJ+O9K5DYTr6EtMCeQse0A0Az1VKWxxEWPOABPBlZNqj0UkUgL0HQjCCEvz/SqQYeKe60AdkPiMQQb6Xofa8R14xsVHYOhXCkaimbsNbz0D0ljyIXOw85jtJgcJznT2tj0AjuWFFkta4mHDmQgaQVgc2MIEJIjGJSiwOBAY2IQYZQIA9Cl0BDriQNNWPALxayO8OIMX9nWYhP8wI/fIVk7Olh4cMhEljBMIxlsAvIk6MjF1ARoADCcYuP+taRC5GoZGdjn9RW9NnVngA4UwgAhUwCgYUmRUNRMADS5wkJSuJlc3M8TcTOhvQJINFiEynOn10SBnbBoC4xeSN9fNUktbIlhYOxDt8ZBeNXpgav+SkPmqTySgzkrQFrqt+K5wNIh1ZlEYuEisBMKYl/5vpzGci5UuunN+SXpITOvaHIjU0SEbO1jZk0UiWosnONAcyHb1xKC97eZUvC0ijP5aOJQMrIyqH1j3TJNCdbjJcMZNZlAmkJisViEBAoWnQgyrRQOV0jUU2BCVw6ggiYLRnAMCIGlRijCWK05RdhkkWBewEnf+Ji6xuWTSGxnMmp+Ne2iiyxZns7CMo7eVLNlKcRPoTKgM9IlM8EAENIDSoQoWgQhcKRP0UgAKkUSPBFpIzM53QXQZ70qjs9x23AJMieEHTQhgjUodQYCUNlAvwtCM3CRUgnymNSJooYMuC1eilcmFQ9AbyAJFcKXhM7eD0bspMZDZlp01JpAOGav/Yw2puhuXcZVoQ8IACcO5UF8Mf1I6lUtGZtaQjkcABKKCA7eBPLm5K1wMQNhmQXABXE1qI6/riN2LFp4TxTJRfCEAB/EwGSHTKKqdOCpqaJgenjGSmUgTblBJEALHKXW7VeEsjxQ2TpWCMmgeLNDwpRgQCFIgtTFkJHoUAjUIXU+ta4zmm0I7kTeaaC5QUqxgA1FWrwf0rcZNiXKZwIAIdYC5/+1utAEy1nAUQ3TS36Sa0/fCtXR3pTAaWR7ekRyE3ws2bglfe8uaHeOTsEmspErkLccdwvkWLcoR7zPoi5b5LyUAELODfF8P4Wc5toFFPZRr0hudRM2lcGSGyV4f/KDgiCqmoqhJIrJNgd0iMM0kUWXIlBcRrAQSQLS3vZ0LTxG8goryiawrQV+SYGACANYoHLGBmM4ugxWc2c0GNkuYYwznOgGLAgQwwxjXu8iSD2SpZ4MkSvEBWS7LBVXXBuE2SJEB8mkWhRBBgggQmALPuGhh518qv5NXqAZX2S8nuHNHNJG+FB3FrisI85qIMNAKqXjWrVc3Towy0zXKeNa2VMwAIAGDGIwwkXTxKELtkildpYikor1qhR4EMM1QiCqWk+ZLq2kWayAMhReBZwfmJC4x8c+5huKTK+H6ZOaZGMawj8OqlLDOntV43u43ja9NkMyZ2vlCPIXJtAVCU/602GYnxyoW+9TRKbACG5bpoV+VvuiWXEiWgGHU88GqL69rbdO9g9he8BDixReNWd4rN7RRISrLdIh95WCCQZxo1j31GfahJF95OkjxVnx7OcUxApBoBqKAxLcj5YOgjMpXicTBM9XMAMEoa0t2aR7WZH3nNiq2C6HogCdA4fTle7nMrxQEeJznXu64VT5OleQG4NwNNW7yi8hLmOmw4W5CWdNN575aUUQHdL5Bzgaj9JYeOyL3H4/AeaSQ9N4IilaPEucHwmkDhLnXVA7t1pkSgBF6fPOWp8hzF4Sa+TRswZ7SE8SfhL+Zo1/LXuNS/9gBJ9GgXaXSKwkX9lRBoB//AKKPZGxfVeLTw4fnh62l0yBdt3PFYR0oHIsCByiM/+UtxdkwOiOSFMP9JYDyfzF1DP9HTiNgAS56haZcq1iPaIaOhcp75g83JeHadqzm5QHAsLs/tO399DnSMgs8UFSfFAhHIgPL773/36s/YgV5NPEBdIc0akUYnsdNzIM2iNI+FpMVKrMSAoNMfxUyNHAQCyJV4FFsIzcUD6J5bDE++fYxf1I2uBM9zyBrwkVtWiIAI+F8MKt9dZJIveVSAkcXQRB2d3JtkZd+VhZF4jMntOQk6rUkTcdjHfN6HQMC91YVZIECQgcfw1NsHzQQAesqghBlXNNIGyOAXJh/YQZz/Uc2c/BlG9JiLA6ZXOBFZVF0gvokYRKjGAqTA6KAGBLqFv/DHokghhMWGNaXUuwERoWzhVmxABGAAGCoi5d0R5agHGWrY/hTEynzP0bTcRShAecBbAJSfGOWF2VmHBJzNkEUEGBEdTXTTrFzYlTTAXliVYRQJkIhdRGyUa0xdoRTiIuriLjaFrxWABJwMJF6K16jNjrzELBbJgXVMCDnUfLThb9QFKXZgb6EHRG1NCSZNrQBI+GxHK0bhvy2IliSeTTxLLvLiOaIjAGChMBoAr2yG2P3QpslhDgGilMDFjaQFv1CINKbGjUBba/mFBrlLAqwJU9FPrUghrBDGkwAZ/7QEAAcAVTpKZDou3XOMCfuRUZT4CzLKRSYiI/ycRyP+RnSQjp4FAD9Cn/jZxcVgY3ggZPThHds5RAklirAc2Uk0QK7hyUTyZE86JAAswBxxSQpeiLiEyu30BdMQG9CQRhqhBufUzWGgpM9wRpINEHQwml/ElEzCySzlmfv9UAlxjk+SZVlCC2dlFlnA5IecBF8IJIL526RZmVZm5PNNJXqkEEhAlloxQAJwZEsahOBwYmScX8lQ23+ki15MBhmZZWM65qAIojYN3lotgJx8ynQlSPxwh1WSRDNyTW85wNFQ2ZnsnbtoEWIwFdllYhKqS7w4VlK94YKwjEoUxVwM0f9j4mZussg4Kskumctb6lEZ5tkfBRuPhE6WyFwD0AY6VWG8GQZs2dlCxMqWXSFhfgdelFZTeoifvQmAmNXokCNS3EVn6GZ5mqdyME0N0sVYQBZjNCdigBECTF9BLE8ZIsZbgg3giZT7sYqlrCY1zoS6gEtfiCR1Nk6YTNd5KuiCMgcrEgC5PMdhQIBmsMUOneYlkgQD5UpMXFjDiZSfpcdwPscGrqOTwU34PEAB/g0NlWLgMeiLwuhxrGVrrQSrMMBm1Ce++YV6/haH3mQDbGB9pJ4AfNWGuVKQ/dj59cjw8MdKTA6FTGC5xOiUUmlYzCiH1Q24nB5JXGm1fdTooU7/eFzbh3YUKV2IKMqVSHKI4jhILYKGR0wfaMyjUlZpndqpVjCfYFxjh9EIlfkaDoYEj4nLmIgUtFnHAaDMMoqfvMnjeD5GRvAKGUbgUbDiw9zppWKqVPxOK6aGdg0SbSrqc1glA1DAfdxHbA4EqjbNavUFfdwbOhnqdHrEKwqARZgPCVamleXqa0SNq0SdjmRqsArrcAwARgpJZ5KS18DLI7pSacLdlFwoppQhBMgnSLkNvgAhh1yZ2PEoYw7rt4IrVxjEbWEU8QyAKEJaKooR8NRFObnfTEBoC5ng89XPNFKEqzTNwcUkV2Yfs4XrvwJsVXBZTWkmLC6N15CHacWp/5cOBAlW40I6hAnUyfSdzWekxUaRBtnhHdlV7BotXsCCbMgyRbnWFfzN3LUJXYRqB3fQpOgoFUlIwFpEzl06J6RWH74lCv1o7CSapAhdSE6KbNAKrVK4EvCQ0eeIh2J1p7BoY1z4zUjQbJLSjFhBqsVlKIKsZXykpcJsLYcM7deCrRh6GK2SBdK4aUYeaq6oy2hgxi8KmbTiZD7t1WFIgOiYVgqJWmQ25Epoh16A7d9+7RqlhcneGJ+A2F102eIMGaVoTfLUjRTqrfXtBeBSLuWGV0xQqBAhy49EJoBMkyjRbJrs0cHAKcSxiTA6BK5V7uqCrW8xwF49QEesUbmaxv99JC4NJURpsAVaiQdSjcoCFEsm5gXqxhLrGu/XesZhFAW13gcEOG9RaJ4weqf1kYXE4g5FaOI1HsTZmMU6lhPQHm/4hq/30ohfYhZfrExeKNUCpcBhEoRHsIrDwhfx9tkKiu/9/q3Yfm6A7FW+nc4FsMTFHMbaTsbCCuOdRCH+KvDqginxspS+qJS6sEC9sopkNA6m0W+NLIi/LnAHUy7ZysfPkoWV/N1I3Jv1Ppz7nBDTlJH+lp3reXAMG6/BRFFRnO1QxKu6/hCxjcSiIMCQeZQq0YoXkUS3vsQBeKqNyPASL/CIKUxRmE9cjNEGmgWenKQAzpTuksUDRE30OBD/E4NxDJ9rjv6aUWjNF5/SswXkQihE9O4rXpqxmxzFz9ihlM1HGOOxDOdHfMjaAkQanDxNZRiFFV4x7d6rU9wbZJFnHjNyI0sFByaF1kxFYQFADd5xUxQoPznyJnOywEqpVFByUJrGA0iFR3TyKaNyVGTYnFAFJdcmQmxXtV1yKtNyLWPFhFqFKyvFXRyA8tryLwOzcehyMBNzMSfHMBtzMiszWCDzMjvzM+cyNEvzNE8yNVvzNWcdNmszNjfzNntzMnfzN4szMIfzOJtzKpfzOavzJqfzOrszHrfzO8uzDMfzPNuzAtfzPevz8ebzPvsz5fbzPwv00Ab0QBs0yBb0/0ErNLgm9EI7dKY29ENLdJ1G9ERbNIxW9EVr9Hlm9EZ7NG529EeLdFmG9Eib9ESW9EmrNC+m9Eq7NBi29EvLdP/F9EzbNOXV9E3rNMnl9E779Lr19E8LdZwF9VAbtX8V9VErtXIl9VI7tVA19VNLNTRF9VRbdSVV9VVrdRJl9VZ7NQR19VeLdfWE9Vib9eWU9VmrddWk9Vq79cS09VvLNbXE9Vzb9bPU9V3r9aDk9V77NYz09V8L9ooE9mAbtnIU9mErdnHs12I79mNDdmRL9mRTdmVb9mVjdmZr9mZzdmd79meDdmiL9miTdmmb9mmjdmqr9mqzdmu79mvDdmzL9v9s03Zt2/Zt43Zu6/Zu83Zv+/ZvA3dwC/dwE3dxG/dxI3dyK/dyM3dzO/dzQ3d0S/d0U3d1W/d1Y3d2a/d2c3d3e/d3g3d4i/d4k3d5m/d5o3d6q/d6s3d7u/d7w3d8y/d803d92/d1Z8AGJOJ9u/QWYgAHOECaEVRSEBZ/9zdxtdqAJwVyGfhKb+EGeAAGLJOCI0V+NXaDj7Q5AoCq2S+LuRiGZ3gLcvhSvBmIi7SGj7hSHOJ+m/hGoziFI0UXtrhHv7j9FsULzriLiziMI4X+8V+OW3SN45d+AXmQ77iNAwCDF/lEC7lSFPiSS3STJ4VPRSSUO7SUdxySW7k/b6FEB1TAl6val1eAFw5yC275P2+h/iU4cYHcmV+5mTOF1g2fm6M5nC9F5NH5Qms4UxTf8eX5Qe/5n9O4nQv6RT9klXN2QAAAIfkEADwAAAAh/wtORVRTQ0FQRTIuMAMBAAAALAAAMQAgA9wCh/7+/u7u7uJEJe3X0+u3reNVOOVnT+eHdOiYiOqlmOZ6ZezLxOzDu0hISOVyW+NcQu7g3uqtoQAAANra2j49PeiQflhYWEYVC7i4uMfHx2hnZ3h4eKenp5eXl4iHh7A0HI4qFtlCJHUjEygnJ8s9IRcXF0k4NGQdEDoTC+E+Hss6HkUsJ0shGMy5tdNlUKs6JJRrY0xAPqxjVKhGM9aIeXIzJs6rpGxYVJM2I451cLCDe8t2ZtfCvrGaltuZjdNcRNxUOregnHFMRKl6cahXRWxCOoRjXJ5WSNqnnaKMh5GBfpRFNWstIS4OBwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAj/AAEIHEiwoMGDCBMqXMiwocOHECNKnEixosWLGDNq3MiR4wQNHDqKHEmypMmTKFOqXMmypcuXMGPKnEnz4AQJFAxuGCGhRAMMBiWMqEm0qNGjSJMqXcq0qdOnUG/mHBiAZwkLFCRI6FCwgYQJUMOKHUu2rNmzaNOqXSmVoNcGAzFoBTuwgwQPa/Pq3cu3r9+/gAMDaCvwpoQABDVIsEAwAE7BkCNLnky5smXIhAF4eExQroSCWRFfHk26tOnTqFNLzGxBwoagXwlu5qq6tu3buHPrdpo5K22CWoEOvAl3t/HjyJMrX74wM8/fA0tICEmQJ/Pr2LNr3x7Y+VaD0qkP/9wwnbv58+jTq4/Z+3vB4AXt4l1Pv779+/gRsnYNm+5Ar/7lJ+CABBa4W2abTRWXVkENZeCDEEYoIWacDaaVaAIpxhhBHPA34YcghihiU5kB8NaCsRHUWgYjtujiizCeVGJVPVnglXsElVBCjDz26OOPzVU4nlU/GSSXBkAmqeSSI5bokGLCMSnllFTa52RD1lWp5ZZcXnflQhks1uWYZJap2pdmpqnmmqehyeabcMbpVwAbQCfnnXjmqeeefPbp55+ABirooIQWauihiCaq6KKMNuroo5BGKumklFZq6aWYZqrpppx26umnoIYq6qiklmrqqaimquqqrLbq6quwxv8q66y01mrrrbjmquuuvPbq66/ABivssMQWa+yxyCar7LLMNuvss9BGK+201FZr7bXYZqvtttx26+234IYr7rjklmvuueimq+667Lbr7rvwxivvvPTWWxEFSNqrr5wN7Ljvv2tm4IG/ABdM5gYZjMCiwQxvCRcFrzUssZQBMNZAcRNnDCQHXDWgQYAah/yiBoj9ZKfIKIdYHFwYp+zyhB8JBNeGL9cMYQfCwdWBeDb3LCDNcFXs89D5Ybwy0UjTJ/B/AnmwcNJQc4cw0wBkEHHUWGPXstFZd72c0FQD8LHXZBvHsVtxRVn22rWRjDbbcOPGs4lx171by3bnnRreevf/TRrffgdOGeCCFy4Y4YYn3hfiije+FuOOR24W5JJXHhbllmfOFOaad34U556HThPoopf+Eummp64S6qq3XhLrrsfOEeyy134R7bbnLhHuuvfeEO++B48Q8MIXH7bxyE9EfPLBL898784/n3v00tdOffWxX49969pvn3r33pcOfvihj09+5+afn3n66lfOfvuRvw9/4/LPn3j99heOf/6B789/3/77X94CKMC6EbCAcDsgAtemwAWSrYEO7BoEI4i1CVIQaha8INIyqMGhcbCDPfsgCGsmwhG6rIQmRBkKUxiyFbIwXQNgwAAQMoAEJABDBmnAAQxggAcI4IcFAOIB/xhQkAQcgAAv7JkCfigAAwRgABVwAAIGYAAmCsABQyzIAC5gxS5asQAzXMAXIZDEhi3gAEcsyAG66EMvelEBBHEAF93oxQcAwIsFEMgAZpgQCOCwjOZKQBCtaICBMICOiLTiAWYYAAHMMZFMXKMXETBIA/BRIAEIAAPaaMknApJcCKBjAgYwSEhC8gEJcKQpmVhKRBaAAQ5YJQIIgIAbftJaDEjAAgjiylX68oeP/KUwf8mAABCAAH+8ZbIg0MYmIuaQw4wmE4MpzWpCMgHKLJYxRzmQKhIyAGK05jDnWABv/vIBrRSnFw+QzGzuigBWhGM41UlHA5zRAApYIh0fGf8Bc5qymKmkJyLZ6c5eNbKLCJCkQL04gEw6NADpBCYr4elLh1ZgoYjc5UAIgMZLFnRVENihASIQymgWoJaZpCMCSsrEKT4UMU/0p0Rb6kt2wnQABNBnPa2ZR4H48wAf9RQtbUlDNlbzhpnUqRUzuYAKHPGJayzAIo2ZTwIMQKGqjOQqFZBJWiIzABFA5AMCoNRhEhGrP0RiUDE1AEpakYgASIABpDpDmYqzoU+cpDEJ4Me8fjGWTHRAJgcw0x/a1YvIJCUrFxCAZnaRsWCNKBAPm9aDdrGQa7VUQL0IgLJCc6FINWY8NyuABLA0kUhdIzVNiYAAyLQAT5TsEx3rxWL/htWNDaVjZitFWDoClpAYLe1LCTDKzw7TAAhwgAIK8EjKIrS3XWQARS/r2nq6FDEESGdrIerG3VIKrab8LT3x+tLq0pMFChjiaRHJAOMykQCHlaEbt1teY1ZxpBCIAEn12k7vBmoBC2DAARSATQBA95eK9aVzbVre6arzAsX0ayK5alkrJvibDrZwfR0KgACQFrEv9a+gMvzDB0AgmlxtK21BDM7lGqACLk4AASDL4cYqGJIXYDB4gfgA+q5XADvU64EVmckO13eedGRwAPra37YqoAIeFTGZSMxE59IRjA+VrGHra2SFdtKhJ16lAT7sxRw7lMqCLe+PcZvJHad5/8MB2HE8M8kAb9qzyARx7yulXCYtD7MACWDyYNkL5/XC9qGrZCeS3XiBr5aViRHg8o8dUEr6cveytRT0Q60sgAgAYNECIK9DJQtXPm+JytIU9UNJbIAILwABFYhwSlmcVC+esQB0daiV0Ytr38JZvCV27JtR/UNZP/SiiHQiWfVqZE3W09Qt0sB8EOJhBCjAAA5Aop9/+Uo4z/aLDUX2Dyk85B9ut8MDcOxXN6zQKcZSqqud6EvP+IBsP/rKrV0zE+t7WzcyOKKCbTaxoY2ezMhFQQwJDULIDORh6tsBNG7wOkms3DWv+8wVuK63n/jtaSZ7uF2Ucz2faEM3XnzWKv/V9ToD4FZAX3mjQTwpwZljcCEtZDYHKTcky+lGCDiXsR1ewLud6sZ7XxnOHW72Q5WeSZnG+4cVeOm2VxlpCROSwGdGrUP7zUQBd/HeCBDIh+E48+SUaAL9tYkEACfynou2i7B1rxXTvOiIFgDYcGfiA1S98Ro/tNxPByMmwUlPrnbYz8pmOBMFjdUp+vKruC07ctyEpc8YpO1dDC1tkboAo2cS7+vUNxMXMOMNG/meU1360uUe76mefuqJdqjizU14Op5ck1WU6uwz//YuViDoZJQ8bmqOcIaQZ25xVfDff2tp83YR5VZ0LBghsG2+q57rAiAAAyIQcYcC3oqhrfH/Qi8eAS0rG9gOGGV9V7xKqyZZpwEXfm2ID5Ew0Wwg1F/loR9KyVw7tOjQx0QVQAAOgFx9dVVH13eJ9GUPhVZzdACQ5WSB5mECpWQPhXdj1WZAVHXlVWemZADg1Xm/lG3ylxr0BxElgAKS5HoDAFjlNGBepGwOBWwROF8a+Fje9mi3J3GJ9GbNhlVcRFQOVgCvpk4FsIO1hlBwdkxMhmqtBEYUF01AVYKmcYIPoQExeHcnV24XR3H/R2v+1HwvhX0/1He9h0gcBYIRRlpc9GYxSGy/1H1Z9kYT+FCktV3m52EVUHWYF4dUWBpW6BA7oHWrZkXNt2MOhVb711UHUAFy/yh1bvSIMPWFv3RDa5QCwKQCAiAQVHZhQDRMyCRXBaAANYiGB/AAIIhYctdSHNZh4jZ30RR2fzgaVmgBtniLt1gQPwBJ9XVM9bVmD6VTWGaGL6VzApBL6gdnfSgAmPhDIcWMmHgBKZBHFGhrsAdJA1BWjBVm0gRxI1deoLZIsTiLtFghBzcQWpGO6rgAMpZJIQBJSHhkK/d32ndPCmBsfWeMioQAPHSIDgeEAtBaBoZHcPh4MZiE0TRWEVV1BnaKPcZyGGZnRvdY5HgZgTgQCaBc/fRW75hIYuhtpzWMIAd+xNhhnEZdifhgaSYQaCVX9HRYg8V+psRVGbZuQ1YAEP9wRk+1XrsHfhVZGRdpY9YkhwtgfXQ2YOEHic9HjLVXZdcke+JUASZQXgngQwaQXdw2TPwXTbSUXjsEgZs2j5nEjRP1eD85GVaIgOKUgVs3SA/wiEwHjianeg7VfwqAV04GgZz2ZqAmTAnQAEVGl2T4Q+I1Zsi0inREYQ4lkzv1VsVIR97HcH3pRk50lpFxgvrIbaJGYg11VfiEj/JIay8lU6IWQ5inmKInAESoAKg4X4CpjP5GcggAmuwXkqrmiX/2mLjVdgtgV3aHZ5YJGCcIeu1HXLdnV7P5dX0XURtGZjZFRb7kaZkkeiJ5aVZEAK+5YT+2iCHWVSsnYASmaVv/V0vSZFsKkH5uxJhAdIaq+WMymHbBmRZoMkxGlIwbVnQrVp08yERJ6VCPdmjXeEWFyEazdH3UlZ1QhYqJxV9+91JKpZ/LyZXiFaCOaUxtdJdcWF7xyReEAU4HUE496UXEaFdyppgbZo+gaUxrBlshim0cOIM4uGHl90M2lZ2Lxk4OZqIbJ1fIZZTeNpjXtE6VxJggqGqCxgCl1J+tuKFqcRMmUAF2Z3tiuXFkiJjHuGRM6X2M2Vp9yJ38h06kmI8P9ZoAYFedaVqSmKVZKkjjNpHmhncymJkfeWTF1GG+CFVYpFEAwI9ApFZM+hQT0ATD5Gmk5UTwRXuFdp3WWU8p/9qgTZdImRSiApCmajqmY2mDlZqp3TlYDyVdduVEcJp1iDSncHaHXUQAg1lgf0oiJDBMeJlQyJRhDhBD1odT61aQP0Spf5dIh5aZXedtcWmG2Wl7mqqpXgVnOjdWZEZfQEqj8biff7aqTuGrbrRhjGmBzTmT5bVHHZhIellRxTqdQXSVmTSsdOSjS8aP2Rau6cZK1sdwFOZPOJmSkPSeY6mu6+am2CitTEGtIrqtkBR1CrhzDzWjTVSV7amPD7CKEXCKXfSiTJl0ccZ7r6mPpOqJOpqlr/WLbiRr/NhjfmRkJykAJuqJgCaU0gSf/EoTFPpD5NVspmSGBSmDcKgAhv+WfhPLX/ClhY7KlHIHW685mUAGm6dqhlcVRIukc6AJamzpbZ9arfR6WfqaSH66skjBas61g/qKrt7ngl4UWpxWhDQaqUZnr6ZHjGyKW+aKqfUVUdjqd/lXlqLpn9H1ahpXXmS4Y+SFSMTpS6zpAKVmtS8hXZdkX6qZenL2iO2KSJlKWkpmSkjFrbiJkuH6RAigngOQnfqWsZRIZBv3Y3rbnGB6RoZItDT6s4gmTOiknl8ruC5xYfGHrLTVtA12AG7lucTVqIFZZDWEAIw1VJN7qi0IRFNnS+EqtFUWAAiqby5JrjAFXs/6qJimnH1HZrprt5AlU+G3jJG0qKvkui3/kU4MuGGLq5pcO1jmlGKlZADiuXH+tLUUKljGqallunMNhaDOh0ih5YlvloMHyVJvW18kmqWSdLJ/R6F8FU0uKQC/B74lgZgBvGrtmKWkh1fpxLmyp1xfBV4TSUu/ZFXNBKH52IOhhb9WulTex49jRowktr9ZCnBmqHQv+3fLqGzqhFkO3BHDq1JuBbhHNsGV2okb9r4V1lLQGXLL5ktHrHeVmpkvhb9FTEe62ndK1b8aumECtmKkurvIakPkdbspl8R19KH/lMMcwb2/eoGKqqYMZ30/RmVRt2JOxLpv1bF4ZoZxC3f4CMWrNMV9x1FPValGJ8JMiVXh52fbpXNp/3bC5hayZjwRh6qa0fSe4NW+3taXG+a2doVMeIdGv9Rqc8mUDOe8T1xenEa7lYusdzqSXjSr4UpmNLbE0RW14/Z36jlIhvfID4GrMdu5/FmpMjWnEaUAGaZsJAaHEzoAZMlE5+tQTBuPUFyQNBasG0fNL6VQRPhSoRqxQzyPRlZD1FuXMdef3IvDuswQI8uLvoyoatpuk3jNXhRpkXwATEZaCYCYwCaDaIXB7NbK3gbF1aiaRWltLhWs9Xm2xPhjo3mQqTzMT2RV3vehK9x37UVnH3zODXFcUxpR0ettXOuJ9oSutjpotqaDddm9/MdDSpq/QGTNUJwA6aVL7wxnSP+WzZtqhm4Ufj+2xUz5aHxay9vqo1j5Q9iUnvOF0Qyhf+UUijGaSdiHyqJcoPS4bixlTuNbjMFIXbH5d+XlWGYbxc7EZcoLU15XumaYTlDNlGxrYE/YzH1HhjJloh7YRHLIhVpMmSCK1AghcnvHxRBpRRGXtndJjOCJABBgXMN4WkbkSvw2SDaFfci01YnKew+1zEC9Ya8pZ+d7b36cyXOrlqlXuXInxE3JzC/1ip+4TpDkAHptECw9tn5dbmaLV+gGq9r5Rf7My1YEsdjnRAcJXrorvXPHyp6L2exp1r9GrJr6YV6aygI8SZGIkKyY1avUt++F0R4oc0YGvBUMZ4P/WZoR8FWFSka7ako7/EsCO2rQzVCeGMEq10VWTGXPCpgTucVWaskJXWVu3XfWDNah670C2oC+lJo0es7FPNNm2Ma0nLcvReAuS8eUfalvFN1thW0d/dc++VJQC2eA2bfBrW88TYxF2bOZ2t/zJVMMNsDlHbMnqaoODNbBTb54BJW9fNIxO7VdpGnzNeOa6tX19WHRC5ibu6Pz5VYPcOFI59yDBdEb9mh7lL4DWqFRjoY3mEhRJrigF+Icu8b+KgDzhkeZF7yEBs/Pt14Qq6YqvNKaxJqk2N9jncdApOZg9kZlJedK3ne/xb715Yn7y+QC/su9OHGZVtmrncP6dtUs/zxXYYrh9VpeaMUAJXWy1k3UAxDecOZP4n1fSC4ad87hgyVJg83C0Ye6nV6p+Vyq1zZERuvF3gZsc4qrnua6YevmI3xlRUuVil7X9YrkkG7npR6uAK2mvcvUDPXrTKlzMyyqW0brf/y1TEXbuNpTVtuiTax9No5HaknK/O196mzs3p6lwV6spP3t3raKO2jZ7i3ibuRyhtVQlh15VjuyLBwBainQOXtZ+71x21bqzA6sdx7uMUyXDJ3K/a6bXfSuG16sy3hoIdqZK3uN+O2dV0YActzps8fP5J7xDgXwxgpuGr9xZWXF147C4QrhndZVrHll+qTdf3qSX73iwtTZTP9J8ev+8TZfXhyvqZ7pwx+fXzJdXvBnySTW3Go66Sgt8XWEUMG3oQ6uqw5+WTIPzM6u8UwnwzKk5EaW85kqXlpeuTm651fvtLceriTGfu9JZYp3hBuamYT859ympgXv33Bf6jqF8ZWq9WxcW/yGUpVbbl1fXwX8VXG/5WNLmTAPRG4auBWJviW2vs0sqQ/r0QxwpGjU0Vp88/VVVnYP7sUaYM+NxAe8WOG6nZUb8ZlaQ8nYyS8F5PVqmS8FAXi1fTG+u1r2AOyHwedtU1hl92TWzEdbAFCm5Mjed3aLrng/b83UfA4dll8Uroh4890988Xe4HMFgcj7Q2dJl+zqTQX/EGkMwFh9GcAyNYBTb7rZJ9bO/FqmL+pTCvjI7XfHP+eULYrlb3W/Suu9K2tk9vL8HfflG8AAMQDBgQQBDAZIIEChAAIHDTJYqDDBgIgVFRYAkFHjRo4dPX4EGVLkSJIlTZ5EmVLlSpYtXb6EGVPmTJovDzJI0NDhTp49DQ4Y0POARZ07IVp0YNGAT4cDEkRg2tSiQgRRrUqdGtQhgIMEiPpscJVnwooPAiSdWsDo1KJRvS50cLBAxbY7nSJYoFUs07kRq+58e1FvAAIMeEKYmsDA1IUFCNSEHFnyZMqVLV/GnFkzZIMQFl9csFe0w88KD/gkW7H0wqWjrVZgvHSw/+uDqxdC9WlbgAKwe7kaHEqUsQIEEx1mvUqx4t8BaB0zTb3wL23CU3kqNfi7Z/TGA/oy3k0wwGby5c2fR59e/XrL2QMoqKg2eQUDCgyLjqDgQF2HNi5YRMCi06jLjbHvpqNugcQcYiCpAhB4ALuewnKNOwEKCC4iDCMqyKAAIxrQqg8rcgiC2XZScCoERxsxIggcCiyiEwMY4ID64EMugQMQGCBGotgDMkghhySySCNJci8AtqxKUTratOupBhBAhOC7C4MSSIEKZhQNR/BMg9InAnYMzaEIK9LLRyup6s01xCrS8cuFykRorgf3yjCi0fIkkTofL9yJT4VOVE7OF/8d8pIxCI5ktFFHH4U00pLcK5RDq3TjksABLvhAId5oDE6BoJpUiD/RjpJTgEOZQovNm5YjLVUuKXRtgQOri09AAg36s7W9Eq2ITtfWRLBVDXs688tPzZRTAUmfhTZaaaelrKep7vOp0oU63JWnCSiIICgCEChKRwTWFKDbFh8QVABse2pRoXcXUKAAA9p6syIbFXIgU1ppY4CAVRNFdzcCIagAXVOZildGTUsLESHG+NP2oogeGIwr3eKjtmOPPwYZZHjjM+AALisWgNtud+JAgwGSdazghRZmkgCgEjAOVYeZSnahiFN7QNgFxfp3ZYQMMAABCIx1lbaeFXqAZp//qpzK19HGLWgBm3faWD/cDmpYAB4RINensCsKOW2112abPdQKflc7TI3uSYMZUqWLRr0WiGDhl33e6Wmre0J32T/1AlaATHcqmu7xAtD5wlVZtKgCscKkkWmMRYNwzXcPerosvcL+fGQ5F2g7ddVXZ92lgzA3iFSofYp8xZ0y0hQFEvCe87MCIiitgNmo9qup74S3KnFudZvOO0v3atxxXs/sl0DdBqetx5xEc54xoeQMUXZArbJQxQFaRz999VuncXsxkbsd1AcckLonBg7Yr/1we1rgg/94P9eX5LMApukJMGVLTnyOoyuH6GhLo6EV7Og2gMnRpoDYk1625PS1/4N0DzwO4VPpeCKztCRgfSdEYQqh9R4NCeBeXSnY4vbCAAXMb0wXe95OBACCKYHHAPYiQPnogjIXPekgBDTNYEJnO+pEL4NWkeBOLKSyJxboS1T8iZyk+EMFlAkCwTGAsJTEu5mp0IxnRON6AnC2lOHKIvJhikAOwMGdRICMAhDjGgXAKcZErF1w+uNCqngQO6KJbk4cZLdWg8GDJAABIoxKFGmUKhuxSy+RU81V1tSWO24rjZ8EZSgjYxAthq5UUYnO5q5zx4g1MgQoCEF8VsTGOZnSSYkMwCIdh0hcuoYAfSkA/ZgSI0ZSJ3G52tmfIgLJRr7RIbQEDwJEOU1qVv+zJBEgl5yUGcaoVGxZr7pjXHoSAf8FiydEZE0ASNjKJ4qPibThZS9nGJ8KHiRfgKNbsyzyKSI6II882VigOqkQaxbUoNVEp0XE18aohC0vDOokOx8igBP0cFA9iRH+FqKAF6HLMTI0mqDg2K14JnJM+YtKAd9ZPscp6kXtOgifigkYU85mAH27YwQOulOempGEZWGhIRsKnqjJJadNIVtDHvDK3RlsahEwTuz0optv7io/KOUJTI1W0irmaaZTqSrYplJP6jDvILCxyDPxySQSPsA+PFGmD8fTU7rWNXWYBE9o/jazq8SVr26USCDpFCMMFaCc4iSQheonltWENQD/gprpVX4TT0n6CUA8YyBcnSmW+2EVMAoEJ4h4ggADWNIqvOOPEGNjV9a29mOBzBshdwRSUn7JVzUqmbDWBEciGgAGGjBaoiTqmobxh6qHXBkEOvfA5FnELKixSKZss9jHRgSxNPXUbIyFPIdsN1OqBe3rNval87nWvOd9FDQjEtnTapFJ5vRQNC2Agfi5hgFkQ53RQhdWdF13V1yNSs8KQFYaMWAAiRtpViNCx520aLifhRP/ksUtz1AJwqKFXdiU+bmBMgC9HwaxkO6Jt27BNsFT01ECJsfGAnzriefCEG1HuE+eJO6drgGw2S5rl/GaxipOiUA9tXO4q0D2diNm/4hBEqfg8Go2PsoUY48Z4+EQV9nK5EHiHS/HlB7fWCx+TRcGLCA928gYhBbBIibNHBUKCcQAwuQJ7K7HE1sKhm66sVx9D4LgsUhoKnQUaVTWVJDNwqiTVL5yohUdGdj28XI1Is5sxlWciDh2WLExyAY6QLdCitY1HnShmPryAGbimEZWevBOLnjhN5rMcYW7ioXYCVOUUfFPwx2Tlf7iI/6oF07kWnSwhd0SvMpJlVbxESQhgLN/RtJ+Uz5IAyYQ3EKPpkYFuFNUHiq9sCSu1M2McAMZc93KMnbHVlnTiRr2XHSVLlHH7mAMj2ijA+QRZaIqdneGvW9+h+QscvKdA//miGwuVhtyB3CA0qQnPlI7JAOIrNEDDMDgMzdZnrsco772YizsxdXSuyJyckI1o4r9hTuMJIACHIBFg4zXy2rNCpLH2m+a7zsBP0WTifYCTTq1iLtboc5ue9KBDfBP4++D1cUzGJappBowClAAxdW5pCempgDfHo2sCdkXp49lR371L1OOKYDTSPkiNUe7otHKuxN3M1Vl8ibd8PrP+QJUoUzxqtKNFkSddNsiWOfe07q+qwU0+8dbq7HBCRxHnPvYKgyQMuTwhui0V/68GUftaDptILGm1dr13HBnDHwQCqwy6WLCn9T1vpcBBG8AYQH1xwk/ELysvktwqSCCZRj/ReK93WxvhqZ8CohmyxfftQxoPGuo65DNU12Pnk+SjhWCtAJ0cZKez5ABgiJmHZ57kOWWnubaTFoHqN721AF/T4A1uLg23Gm8YzkE6szAyRvf/nRNaKXXXKI3/tAB78KksJO+JWkYgQAtTeuurzi/QUIZE1jA86sslJmNsVMc12i+EuISX4OaUcGb+/PAnWo0HjEa7tAr8isKYDG87mMMdisLqmuADIg3GnvADFooB5zBbkk/znI+XgGPwas4OckUnKuPlfuJ5EOdD0RCapq/dHGcBUA4EYy9n1CMGGM9IFwoFTGICfgXAzw6pli8GzS9iIgBpliAp3C2GyStpPnC/x+Dn+wIJPYSqFRhJpz7HA2kvCTEQzQavoV4rkESlFZBEHqxoakBQjCLiKJoGUODvrHgugdMPz5RACcyluXzJQcAItpYjQdYw+hDlEyKQ7CqFbzJlLXDQq5hu/LKw1RUITCbjnLLQcxjjF07vZ2gQNlouiYbABOQgQ4pH3FRgKQJinipqlcEFYFLQQIZkdOIHlK8qAziDpabqz6bRdrwEgeopyt0F9pokTfrwp4ANeXLoz1Mi7lSxXJcn7MZMIJzIUqsLfdCFy4ZrzLhk9PIkGPzCqYSHryqru5oQ9rgNQaMNmtBsyeyDtFYtW7pkUwJG2i8igWoAJTKkK6DAAosAP9hMUQ4MceMVB+n0JEfegCFQ6Vp/IkZaTTFQZliKsPCeMLB+JBsoxECEKOFOKxc0hfxGT7zg5HPQRffIJDoKUXHwStKPEigy6D7IY6c2MTRgIAFSEqDAK/JKUmf0cipXB0eXKarKEgYuojP+UaLMBFH2xUh+0QBEIEpAQqIeb5UqZ8IOJ77WCh2hCdkUcBsoT3aekvRsJCXeyKu+KLpo5iLK4zQoaL7gZkICJ2+4CiqVMyQMQihcwvnEx+bSsOqMQhb6qWG4RStGAAGOJSwYZq2+0GHCcpeih4f6UOjO8Qfm7pjGQ1dWj052iScIIC1QxCBiCpOpI6m4wmmySbwUIv/xQTOaSGMYzK8HrmWmMqsDlrKoSm2/Yujp9DMqSABFKCdfdorhUjBYvuLnSRNn2DL7BI0i2ugvmAauEQIBzAAhhykC6Qk4CieVxtIh1goiQEPEwrO+2wUAkBPvCCh0gEA9ryIWPHEh/iMjdEL9nScFimIuBoC4PqeZEIAnEzLo/MR9USuOGrIHQQ31kAA/XBOhBwIC+WJLBso46wIwBMLC6mgdimTvEAXA8DPGC0SClzE0DrOPZNBAMBGx6sNkbSsE1WmgtAADvBOpHE14orFm6gXOIMiklqZ0ZyxE13A5qsA6rrIL4G85FSXcOu86BJQEpHRMGWPfJuKPNqY2WI1/3nB0YqwxKZxwpIpDb3cC904jTXpQ2mroiv80Auljs1EmXpCGTnNIHSqnyUEQo86gHpxIRS1C+fCChns0kMU00lFj6i8pQWqUXHbFofoL55oPpjMoNCJCx+hk4fzw/hgVOmZrD4tDd4EjPESUVWlzyTVoIFKp6g0z17cUA2pIJQ5AEoFVvJgRjmxnYKJCgggAIExxW5sx8YQOX7JI8O8kA7dsSwRQYfwAA9ooAeovmNkCq7Qz/owzyfKMU7Vl8WYuDSNT70DL7EhiFXhCnQijnExEA5MFTiUojYUIqJ8UXIM1n+ljHaFL5jzNNcQlM9RJhl6GmHhjsShLQuAwX1ciP9UBcMGKy1XK1erZM3XMSo5odhu2dGBbTnK7NL9QCACTZXskZAs0lCadDSAhVmaUKYCuLmpyDO7c1YLWteuKNOQrIhv+rMz4SaxcDHxmalxGddeWg3hydgJFSRvxBvZqyIa3djY6VkokSH5+xLqIMGx/CuCrZqYFduXKB+lWaibxSgHIELJylcfRTLQXNONXSioAArXELOwIavrrMiKJSQBaVqWgtp7Pb8A8j2k4tbq29NA4qeBkNDYWckR7Ucl06axpdyU0M6g+lkY2R9i7ImhbNuv9YlAY9nYoo4NgIGsXNac5VsEa9rVvFSc/RIf7CptSqSuFIDNSaU9DYAK877/0fXNygXekhgvs9gYcUK+jfpW0ZgzMXEAt/JWd/rSAO0WE2gquAhc0gVDkWpdW1krb9Q1L51BJCqYVbmv23SNMLk2DEk93+VRnVWNutAagU2Z4KVfkJAZtTimv+hd6mgYQRWLFvEvUPvYncgAE4glO4PcuQTDP0GA1n0IxMsWBliAuiSMURvgQRLGg5hEeQobTenH1rsjjKjfEd6I8aLHzQLcbuk9yRnUgViYCHjXbLERBVisDqiBxhAjAiityL3BRFkKBxYLLwmruuXbDvo7JwTfROrgH8Ves5sKEoZiAJjZoBiaJV6Z9D1SGGneeqONFCOQ2nmc0OUj6XXP4WiK/9GbwZRbWyBurkpDv9XTQLHppV7xYKW4j4QaLxiN4vp12Yuot7zQTcAiY1yKF0YllZ9T3iS2llc64CS7PpvtILQsYjaOo6bT3Yuj2oJFiBgeUVBtTSlFvz1kgO9EM5iU1z2mX9tIVGXp2E31RpwJCtns05XVpAGtwp1tVAEoJ1cJm9l4GrS9QUpGup/kWL61VEfm3jlpitLQvjMEm7n4P3uSYNc4JhLSCthCRVSO2TguWBCWiAG8EByuEB6OH7wysytUz74oy1OaVQPi2Ux9QGG+3pYt4vyLiDJ5mpFiGnxlGNZYs0zmw1ZWEW0WWyeeGLswPDCDW+hS5GG6UbGQmf9MAYAPCYELIIHbQorP3RkwlOee6DGpvUEAvbuFuuOeTSzxjIpjdpeQJTuChtkrJVmDpF3uoWW3g2efuEK9/BAVYAGWFKp37pOK7ehzyuMiRjETmygFxKsQIUZ0aVynZKXGewyX/tdh/ZIIcclEviIkvWfR4BP/VSb/zQuiMwqVu9adWBPZ7U6ibEKVMup+Bo+vgR8iSlpijorEkbLGE2GqDtazGT7/ZTLwKDXYoaGS2b8AollrGyvaqDvukWR5QlapATDOZV9EfmtFJJm2iJebTWZbHg10idW8hMVO4g2+/teKSbhjitVa/SBHJEZmBGyHoIBpGw2tuWTOSc0Jkaf/64S30aDsXUnrt7kQbkkoZLzp6NONuDBotjBtmI2OHwKPpoyzAFiA8QJmk0oAb401O1ntnuC+5E3ju+OJofaJQasigThro+ns60oArIZGityVDNlbc8uksCEO8OGVBLjD5o5ROUo5wabu0PhtCICAzQNpo/EgA5DuXvKATWMSHMniXiogiSJvTzU4o9lGbKuABReT7AZbOY5Suy7mw0vVYa0KhXnk4SAm/hZTTE0MPtTubnKkC740N57kiGXt2bm4Th3vXrLqDPKr0+RJn/iNxUZrM3Yc5UIaLwM15AFFp4UTAWFxGXVxWcHpGNe7hG3Si9PClMZljKqA9B6NxKHw/16ykIV2X1qVHij9cLK77RLpGewh4gNLomZNJ15ZDDstnynHTxph3OUGcQb5ju6WVWn86YpNxPKGVG/smXFVM93GJSSL7UuxrXZ66OhlIiLWxnVtjtet8qZpCgjnQjDlc+AkLDKqKpR5jm6iDyalQdT94l+McOoYUp8InVRLHA7nFWCCpAof0e9Qa7GALWsEIxoHHZTmFTKBq75oZtcQ1WPPodC8KK7IsuqxUaksdcUc7R0GEbOS9mi3C1QbJNvYtc84AOnmDmMPgNk2natkiqFJkBT0dYyCYOlJKMUAZcIT2XniVdfQjQeAij8BzdUoiooJRhKyz2zXSJHWkAJM3f+CXDYPl9x8zyAv+YvIEXIvdNTfDgBT7dz3zHFPX7rLTpDivUB+9sIU0/V/89Ge+A10bBcCw5rBEBQEEMezU/iMbOc74o/TiZFPgeRBWsroZedI0vJuyVbUqz10+ztcmvcbTDkallh31rsTgTV/NxBYv4rQMeic1/kzF8VcBg8GHm0BuO5ECmRkI2ccw3EC8REB5DaSz6CGQXMgp56p0tK9wPdUOfuo+PdUeQCvL8dfevFUoSI8pnvMnVi9Qxc5rZi6J9rSWxkdBvVBenocdJyS07vIgSMLAakZwSvCdao4mo0LLMmpFnw8PMmGuEgs6jEkTitQC/YuNlJBuZmlZ2j/0O2WRJd7SO99unnu1dMNbskTnAyOxO4KXSWA/RmmUROWPBE4OUn41L+/L8K25G6KRCWXdzwnK5E4HhmAYW0NN3P1QSKY1cAZGxcTWcdysaj132cc+M/8pLK9tNefNbSNBe1Bft9o6h4InAOIAwcKPEAA4CDChAoXMmzo8CHEiBInUqxo8SLGjBo3cuzo8SNDCAUEkCxpskCAlCoDJDBZEuVKlRAQGDgwIOUAAy5LEojp8yfQoD4J7FRAAAGCAQt2JhDq9KnQBhOgUq1qVWWDq1q3Xh0wsACClQC4ko050mXYqwx2Fhiws2RaqAp2xlU5921JB2dJPgDp9y/gwIIH/xMubPiwwgN4Sxr4ubhnTAh3BRxIufck5LJaFe9cydnkA81cM2QV7XOsaaypty64WXbA5QIQVpdFsNO1Vds7P7/UepmkA594HRgwgIA3yQOIlzNv7vw59Ogdf+MlgJso3soxdZo8gP0kbtpQkZP0/FZ81Q4byqJGH7O0e6EEzj5YQBXByAJNA5BvHP/qZAJEcNV8i513FXfdRWbgYgVI9yCEGk2gAQcRWnhhcwkyKIB+AXxHV0xL7Xbgf0Kt5ZJ2KbXkUnABjJVAfvuVaAEGJZoGn40rfUhSeEAh1xR1AtiXI1QLJJBAjz+15+GGLvln1Y5CxuRWk51heOVyE0hAAf9FEoyAJZhhfrRilQIkAMFiQ6oUpQC6uURkULy1ZRZaEdzkJkl1mbZkABNQsNoA1omHI5wa5ukUlW8GKeNVfML50wN4RfpWZrmZNGBMbDaZgJid/qUllxM1IMEEnpp6KkQOlMkhS3j5JKJLsKH1KFAEKGDcbFPedRl5AuT6HwYWmDaZA7+KRqh7CyDlGnUKOMWmspTS6t5bBjDApp5WBVrpSrCuyiOq4V4EKkUdSOCBuOmeyt+3NwVY0k+GOrvAXilOu9IASHEb04kM7oveBh1o9u6Tx9oYYFiGClCBkmu+dROJ96qUgAEFKKCmVW81lahJ7nk1qUtB0qUuyQ+RO1H/AFuWvPKVIhuYUpQFq5RTXitdm2SJXh3AaAQmyWzehhj/JxVZHJeE81bIwiwQA2WRWRIDPcf61G/+ycqTxEBDrRWePKaEXLZBESBQBMb61K9LDwTaZAUsu33QyRNRIIGLb9vt3NNVpmjovyktIGjWKoIXgNGUAfXuW6EROYHSVKGN9Y0/qVqSvQgWxS7kTqE955oInBm43zv9DNXkJFWKH4eMOlU6cLgNwECuCidwLZJ5U3r3ynFL5IEEHeD++2G9vsTA0zJzZkDf0yZwQFI+Fe5s1+X9FL2GBQhdonpcFS4A0loha3vyTrlsUvgrQbC86qCrtMABCrAOL2sJYKqZ/+0cDkAzScW9xZvCTgJPsu4ioqUG/K+AgYleSRSAmwggoGlQmYkCDnC9oVTMAQ7U3mXmJ7jOIBAohWsa+tzDAIGkLwA04grBVoMshTlrK4hzlfo0g8COqe99cAHZtxpknLoZ0FQBjMgIJNDDIXqkcCXUlkuOmJKuVcpRQkFceBAIgZgFZQHcKUD5RIOnB5gtABSYigvz0sWnEEAvDqgUsnAIHK54y0AaDMr9Yug8BrUQdP0TwB1z6IABsE42ROzUDyGyASH+sZAXaaMARKOwMRKOLWTRWLdE1yqXlC+ONkJk5QIQrKIB7ip5kxGyyBM2x+XRJEoMAAO4Y4AJisaJUP+ZIUk4B7oZlpIxG1obigwJppNNwAK+/KUv0ZUQc+mymBKx4RufMoAI2KmRTKnVW1iJqLfo6V0EeFybqOJKZXZvJR30ScAyJZAsPrIzKUGW0WBSlhfu5IIhuo0cl7g/BSCAkdMSCTUZVIBrNSlIxsTQyTAggYESdKChQsio/qlQhuwvAMpCgDTlWRIkQfInbOqmUNQopZigzoIBQFwd0YO/AiQzJr0CSgMyYBeThHQ19XOg0gZwF5uIBpEN/QniRikxKsZzZmALwPggMz4DLTRCgXyIl4qqVABQ5zgKwlcF6EkeBmi0eztR3FZ21FKgKGx02twmUCkpn520yEUrYdz/BsmHnv7BFE4fQqBXNVrWGNrQnT31m+dcczUQuYiPsVxelXi4VOcctSEckMAGBrvQ6IFPJVJbjFFQNFaT2DUlYLWZTsBCFfJkMjW286pKDKUmPnFAAwFQ2Fy7FVGhBEk1jyIAZBDHsHjtJp7bw6j6HAW2JFlSogYagGKfU1iGWEACGQiuIT0EGdYlwIYt2l7IWBKpB5wSJ+1r3rQKt1qynNQp+LEYRimksAdwq0AcImdM5IqaxsXksl6hJ25DNzWLktUB2JXYAAC7E/SSsbLmo4kBqqvM42CquUYJSv1CBgHkMme4CylBCRj8Rzz1hAF5BUBX02qgy/A3JQxQwAMU/+Bf95gXi/+JnjpTQwEa4GWf8jXJdmNiOzWxtyo7atpnRkmASRXAAA44IiyLI2DxwJJ7oiGTiZ13GdBeBQI43CpO2CZhxDg4IQLVwJR7GKWbwAiPLNRwmeILsyQ+agExfg1fV0Mal82Gs1pB2EpqTJWrGqqzfosNzvIb5Edh0ySpzSo8TbpfzZRRWj95WgGoY4AsG6bKCNGABDDA6AKykJ2MiXIOdSocc04rAg74cWrGdgB+Us49HsiB8JqS4ZlR5aE9kjMZA8vV2gIlwclh3pmhpBPqWtpMikyzSprltMVUjgAJsM8CKiCQ4UyaMI4+SBCb/b+hSkolwjOQnc9m6P9HsY7JVAlQZYwt5qRloFeVAWlKInAWBdjTKbB+VpX+1edE1rpKmoaqj5P32FgaSEaXDUqzIHA887L0J/lFklOwvb69PElkDpC2YJ6dAQlYAOK/s2GTQpqASBlAo28p6UooVpNtbyVfDpAgVKJ0b6c01kYTGEEIIInNpu0bj1x5t1CgO2ifJBiOZdqu0exMbZPg5t+zRou8dh5yk+hUU8kJtmSdjkeLf0plVP+nTZuUvL06Uii1LEsbBYw4rG7ly08xulBmcIKuT5Ik+6FOh11bmyRGTEdvgfJKm5RtldjwelnPDlWUsibmuSZKtnsADv+MTcTT1Gb+YtJO8GmgBVz//SPPrjzu8Gegiu1kgmPJV3EesJc9CsXWmdPKItsbE8SlWCtyLQsE4iuAE4BgcDqqFDWTZhoCVBDHLgF5AB4WlHnfVCi5n1KLYxmpDikzQQjA4X6QbOGH0QTUPrn2RlWiz7aTb0OcwjxHAhAw8BsSTRtqC3nwnvdYbreWNi85yX9Sc8NxF9jampy1nGKAEKCABBN9SkVdBaGcTwMRWsWskomcRESxXsc9U8LZX0r0zx7hlsCNhAJ5HNGpBAMMyTcJBcZdmt0ZyBTlkOmQnwlaHPalTgRK0mmMmWTp3/lpz8c9RfWMm8Ep2FZIXklEFFF8wAXEUrt9TeRZxXqFYP48/woDjdhKCFsbkV1Q9N1P2NTKpQQGLkbYFM7e+RYMrcT8dUyREdUJhuGklZIsmZ2P1N2hbYi3AcVYUEd80URB2KAHzZQcqkT0qF+6FQAIiIABiJmGxJ3cmd9T9ZTCaAcD1AtUBJ3YBBrLZRo0geA0vYw3EQfgDR2HUJYxaZIHUIgYdmJD2FBN7IwRUpZQdBcMloRGAaLDMN1dAQjbCcUCpFTD/ATxAB9UwEf9tOKMCWHBKdMB5NuznAUCykUObV0CIAC3DFyI3FFZcZ3ozEaVNMZRfN8fTQAHbIAFNIAFeECNeKI3KgSbuNhKrNrw0dpTiFxTvFXpdRItKkCPqWJP9f8HVfjJtMBHB17Fd12MePDGfghiBopHb43Ht6xhiPzGvuASK6ZEr9HbaVXJBfVQBnSABjRAA2hABxzXN2YkQ1QAXoQHdfzZ9dleVhGAPcFZK6IHIg1ZSmzSo8BHlLQeVbzPtYyTaRwcbvQZPKbGWLxkg7giCwqak2ifgVyM+70g7mhiNm5jN2okUzoEvQCbDc3WsxBHPf0HeajkSVrF02QhOAkMnDRAGT3AAagRIGLTZajfTBBeV7yFEtIK/8BSh8ESTrGdv5CgADgLy0TkRFbkRTalX0pE8ckUIxJIW4rFv22PE2ZlTR5JHQYA0RDJCrBILKniF/raq4iVVRhKYgb/zgh5R6BQB/NVhctMz+WkhA0xnmCSGQS5DHCFC1Jq4wZwQKn8JW06RBkZQAUoTFpAl1RWxb7lJL9soWLKEWkQyQD8oM8EQBAKRWWOjsIYCcI130s0po2Qxz41JrH9hA6ShJq0UUg1y0P9zWI0DSBdI0VapErVpno+xEK6xrURpAZ2Xk0mznDeVfYQoVYkAHKaxHLmnBrOUb9RhbEBJy0mAIGyU12gXUM+4xzmj115RY+pjkZVz2I0BYZo4l7G5myuJ4c6BDYliDiG1WNUBeJwJVUoDIHWp3ickI3dSuOd436WRH8yJ4Nky9/tIH6BKHXqHEOqhdLRRmVm54NYIzZq/yM3ClaHJmlD9MoCbCCdZCdVTChOVJ8qct0Uqiit/Ml9YCaixOj7aQb7KACS4NlPDJWJosf7bKZlTVZHwuJcFEAFwFbhTQrpxQfrVCGIOIdenmdfKqmfSkSvyAzqKNy31RbXnelQeA6WniRLRqJLKNBTRCaMiRRnvKiM0dF/uNL2FKYHSSJQZF2KUCeBLEtRmo5lORsGeEBSHumftipFzBtuFCWn2qF8Ig6nKmgrZaWo/kQ4NSJ9uputGIcc4ioZ7ZpGYeVq2BQ83lFYgN6B8Z0VksUC3Io+TgnsBEWQuh2EatZH7ClfYqSrhmtF9M+Q2I7F4NCVIhIWaZ5J9CYbrv8Grjop6KhbciznUZSPLJZehd6FA1wPzk3L48Akkfjj0eDLAZzc9YhaT7DroXCdVG4YV2gVwvnV092gvV1GX2DEa1qAhoqrx2IEwUrPR3WdqOVa1TjTW7irjRAPp7pJfWQqmx4hHOFQcYQNWvlnlbyaYu5Y62QNcoTUjlRKgLTI37TGtY6sSwwJg3DFY9QZUJTJVU4EkfJpen6s1WYEagHX2EXsw1zbrNZkgqgNgg3hvcBdUNzRZt4nturNe9TnrqYGR1ZsSsTtm7igKQXF8V2bwD4F8Qmn1gylejHEazZAx16t4WpEHiEkXHBFFy4ABuKheBgKaB3rmsJJyGaTxeL/RdiwqNhQW+v9a08R61bcDKuNY3Uo5E9u2qxQIV4ga3yuCit9IPkUIkIQ6aou5eHmbkZI3bmJpIcZqDKdR/+47swgAHwFXjQ9rTmyx1UE4Dsthld90VN0W+o65qLSylOShMpyH2ae5hPKJ+pCYFV8iz31bSLRLUl8QA5kaJ/qrvtuBBmCGWRAgI7ajOf8yruEhbmyEZcuY3KwSd9QB/GaBnnY0+YBRaPCIvAaXtteL5w44EpYGq26xPa+mNwuKGiUhdP9xt6ZHn6owB5egAiLQBAg6fuecEaMD0wgDuueBLRmjm6EpkFyhUZFYcgIXxq6xIyulVqtreYGhQd4AD72/2KcpQYDgFDHWao2TQuf7C9QPhNqxAaAldDHGMAbuRnYuaOTaB5I/i1JhIAOwMANiPAFgMAHxJz2orAaa4TpscrlGpu0kEd4dNHxfO1l/mj4+syj0ij7gY6FDRlcuZtKaQtS+Bfo1kqQyFLWnI9aPgX6wo/jhQy3bOsvJmdVaNdTtEaxyu3f4JZtkMAHiAAZx6YLQO8an3JFtHFybE+izeBbKDJrjOUZ2TAeB99ufAZXTpEd9xSXCdlT3GxqHPIdA17lkoXocl0WOfETf2m9kZmNnUWS+bAA7JHoOoVexoAIm7H/pUUVPhwqfzNEhJklSkmLafDqxgQOLyGtvW1KVP/gXeaaYpaWCmlGCtoRp7GWM58NTZ6iJWvLduWNmlrFBKRqNn4r5JFEHckuAYAzQzMEjyZtF/4qBuakG/LcOXsT+KaGobCz+lAIV/CJMG8HxBZvI+dM/EUhyFwpP0OieJjtVUTkBjTACrCACMgAD1DQO46iCzc0TyOELTfJTRDcYhQeXrQN/O1ESfEeHiWPhtybsngHVMwf5C6q9BpMWWBfirTRLrPGSX/q0WoRWXnM8TkFQfNpC5TyP2qhALjTDClHT/e07BIxj4boQd/tUWNmNRNABdwXUOBJF3ux10CF6IZpVcZHcVq1UIDV38nSb+wtbVT0vWyPUBAgesVeSlD/E/CelXnCpmzqNP2hLCouc8e8NU9jsB4jdG/lEWnqMFlo1BTpBfKIkPgC9mSiB6JxNFAEMWKTxYe0j/VZ8NaUSN4gqniwyYh9iLelpn4ITwi8wPqe55HGCdvVz00uxoKRdkNLRlB2Mi6D9nw9MV1rxeMcST6vBnkEtIcZCHDOhAMcWOH89Y0MMlmENC0mD07miFJTF2ems/ksr0+oUQLcBSiL8giDgA1UhQ2hxDL1Cm4Ij4NgNzgz7GcjbamlZt0aXGbDTIZf8i+K2E/TEG2w3lPAEnojCq/k4n/QY1nQt1a8xQ6XiCbXjWYAwDJxy8nm8IUPhUmEwAfggAaYgAk0/4A2u3Aipiz2qQk7USOEr3HITjI1MQ8HBx7Diep904btTLVDjWVXCySKuHiJyPN8w0neqDRAFh59bPXhvISabA7SSBFQ0EAok7EIgEALYFpGq94EowWDMAzoacySfzMWr2KDMMaMqhF80iJbogdZVkUgb8XdVa97ePTNvZZOWLH2/CLKEcikUNdgbgVypBgjn9JLrgRMNwCQi8AH+B8kf3gPO0WvmKnT/eIZ/fkaB0lsAzdbdBmH2GJ6d7pVNLbH/FSRe3mL37JLoLlYUMVjek+uEsnj8Pql1qhmbLnX7bgOqCqfBgEQVGieg7ivnna/vbIWJxCto7DLyEipnh59tf8Tz0XQagVtfMjxZqFhoYoVxVgMPJccASzAYTP79VJH4OFpzbARtmhFBhwBgZuAhs7M9r3w4r7SfqlwrwjcfpX7+47PzAh8UOIsa8/MZVTXAERVBeC2Y8w2gBJxV5zlVgT4qG0GKirBevg7liorVGj8BV9yHv0Ln2CARPIpBtxk+zRFZYZHl+l3phCHpUaTKmsMdbi1xedukbF1mTj2+t08FMXQ8f3bbRfNWAaYjmSWTlmppZwE51YFi08LzWvOz22Fy6ip7VJkbMo3R4FGXJPEjCLHriFQUyy9kzT90+uuiBZfXTMIQeaY6iakPR87IYsi7BFAMwn6Gv0EeeTaWyD/gZZaxdlPC3XYK7G1OpQsRp0GgLcqZZGIDqaW/qpkRvb2U/Qs9N/nbgBUgMjYiyXyF9KMNS1WQAUge1U8Dnz/x9PEhUb5F+5zPNMl8C1iqah1zZBl3cbAFlkgEAFkQFkT7kW6/KoYwIxmayw9b5MUy5O9/glrSnVvCJZ7GDuGFrufYamVbrK+KZkn66BdbtgI/gOKVa8qu4pqiAKA2CzHJEAIECjQAYQABxEmVLhQIQGBIT6AEHGhgQUPGCYw1KjxwECPDgciCEAAAYGNDBF4VCmwwMACCxqulCmQwUEEBhwQALCTZ0+fP4EGFTqUaFGjR5EmVbqUaVOnT6FGlQp0/6TMCAkhJOg4U8CBkwAODngwUMFCBirLaoyw0qQClglOxpU7FyFYuie3ejRwUCbchQ7Y3k3psQDCBhnpNri7mPHJwR8bVkAw4KRbgV7nkjS5EYMHFhcunADxQWTjjSA9piVAgLLpAAO4CkzAIMFmhWO5thRQwPbBqb+BBxc+nHhx48eDv5bZGyHsmaXj6h6IOeECtw+gMwSs0oEBlX5dEzigALxr8wm3Ez5o2WNrhQu4M85rwP0ExYnPN2bgfi5uj9Qh8G4g5hQaAKa5FpCOvoMy4GCDBiragIMWBOwqP4YqFOjACwPISyaDNopNJAObS6Ak5FBMUcUVWWzRxaUOyv9QII0eW4m/hOyqaiXzZBTAP5fM83AvDs2rUaC0BpBOAAKbU6AA7EwbgIENEepgA/yIjOuxBedS8kiEPBToRtd0gwiEGiDUoAMMGFqAtSwPmjIABB4oQIEx8yOguwOUJHC11mSqoKaFUBPAgBcRTVTRRRlttKew+gwgRzBnKm+jBGTC87UKHDgATyMFSK890woVKDs46XLOowPDdGBQVOOygE257oNVISMLmytMAcDrK78JdJgINBFAIEFTWw/ClCUqkU32gMliCqlDG19DIIHWVHWJAUe57dbbb8EVSiH2eMPqph+XpavUGQNYIIJXz9KLuSQJU1Yl13bNdaFJo4z/4Nq4FhCw3HYrjWuABP4lkgLETqp13yy9XHKubA1NSKZTC0RAAQEfICCDDjSA0AIjPghBJWabPWjdY1MOi60AIavAI5Hs/S7cm3HOWefi+GNvIGwjHnAxdBGAWaAFg06rySMpW4k6xnxmydaaMV5oAP5AHQgvjyw1DwMLaG1ZuZWqZmgAPgs4FV0BXl0IPgFI+EDYC27oIIPmZBL7NrIVSqAlA5jMkl6VhhQP2nVJ4krSnRlv3PHHe5L5MgjWFqCCg3Z9i7GApwsgagPeXg5gBc1bS6WniQxd6MWylk2jmjVM6OwHDOg6rg06iMvhZkXPk3CNPmYCtAtE+ICEoxeK/7psZCm+LKEwA+ewx920W0mBdQeEXPvtuW80zOkFSCtiBVAGWOAEDGqeV65Q14iA2fKTkWV8VxryLvWlZmht6gYniLEG7raR3SELV0QigICe1hkLpMkDJZsJQ7aSNr0lJGvQaZ6+UIW9UGGofgEAn066F0IRjpA4AYjN6Q4Ssfb5RiPNg4nqBhKBoFlognMqQAE8RaRJiUogD2hM5gTCpPFRSiXRY4h9GraYBIwFcPJxSfnO06AHRYgDDIPhvVpYw4RETUwIgV0XUQWA1jFpV5jJ3OJImEY1rhEp8TohGNdmRJRYLwAQyJQG5ahFDkkuNaSanu14KADoyGSFJ+GABv8EeBfoMWYABGjbeToTsgaoaVYamWEhJaVHzK3EhwjB3vxc80UBRIBfLlOJe9wYRDaukpWt3An+AqMjj3RyMYHMVaviJKO0gdI1pRSbCxtjl94pJJDuIWRjNMABjQywhSvBoNgm4KAFNkBCDJML9uynyY1csTfrymaWUtm5bQoIdAU6gAE85Up1rnOE4FPJoLj4TY1Malf2y4vSwoK2/2gTWZzzkREhsIBjFZAhw9xV2wZQAQNc7yQLYwgzGWK6U6bsY5K0SCX9WICFlmSC4iEPXSQqSE9GrAC8bEzEHMAhdq6UpZDT4MkOEkhapiqcEkNIQDWFOH4yb3733Mh88KT/PvD0j4amHMjlgMdMiBJKJgWwnWui6YFp4i6AO72Qhx7ASwj4yz3Nc8BTL1RTAUDxJAw4wAEcyZqWrpWtN3MnkJLlNMEMJEPLYwgXUzqXBDiAoVbNDy5buJ+TyKRtEEAAX5kTSLJ6wAMLWWpd+PIcX86loiK7iDVtNVnXXC2TZpGrug5QAZjsKq+2wl4eFZI5BbSVta1VlAnfaBsIKKmkdPkeVxnTI3lykCx+NY8dqeUaI+1WIxdrWFUP8thoZeouCkyT3XzrGn8OLLV5m0tdbZky656EPy+tgGvBG94UvZFtCMkQl74iS488ki58FKdjYhndxVzRpsJ1iV0VYlyr/5moBRRQiHLNOcyFSFFk1eSnZhvTPPaeUS6gwmvKjATWkehGAQbhokfEm2ENBweIo5oWTA02Q3zO02rBPcnaRnwXBP+SsPmpWW3l0iOUhZQIiDTM5lqMkEg+F6PNWjGqQFVaT9JRLiqML7IOaCgjlmovgfQIGjccZSknJQAzHMiBZELchFTOf1HajgPImpAhyhdqvztP81LcJhQWaCVFUGZyG4OuEEgTQgaGE4lgJafGZPcvE2XIpAhJAOlI+DTj6ZRJ5RJHUbJkyo12NFEWzbXIWu9NDBHrQAjNwquuJNNkVojRfITo123XYOfMyRxVAoTDwHlzLwDBCUDTgIs0a/8AFQKr4cJMQbqKusodRIkBcHisSXFxM7TZ2AFyLbuIoVYuMnGAlVP6aGlPGwBWXh2Xv8TUmRTmx0QiKnG7zZhwb86RHMoakTKXgfsAOABRnaYGYLADaLXMS0wS1anEg1YvqkRftDGiWDtNFxjar1TMVtyFyOtMKFOb4eKFbWz05eR9sjnL2EJbDtWCgKtshLPVOdAA6GQA/Hpab1fUMmNCijzGBgCila3IZTX5xZlKClSvyhBmIgaXCr1ELTIp37jfAxgcWmxH1+QKs7eW8P80nOkZfiNMGkleEKHndO6ZLWGmjpAEuWRMgj4aTLy+G6STXNe7kfACtoPJcb0zS+j/2oysauXcSULXYBpDtq0YvOXPgsokgQrTM7X+IbGJlb0LaV19ga6Qt2676Y13bYfHWmully8vSEUIqDDmpW9ycyXJJvsWVVK2gdNliQUA850t0zEdj2AEBa7ifIsIK1EuZMz76/V3BJwQGXkl8frJ8UlemvVrAruJCWGAtSLNb8cvv63ulLzSNQUBPOlWIWKlUjw/+3m5qE8jxI7uAHY8SQ2U4Dxrg5X6vslFvwwRVPR96vOLKramhirMMykn6b/DEOC+8bvM9z9LCWBtXkLp4o8uqC8hsKdtrI2u5Otsbgjj4gJ7yueYtCmaNmCBLMDODmIEcidKco9DAE52VIKW/3bFL/KC537PbASrhl6qvKzmrTzv4Z4M1WLDh/7vBtfpfaCnBdHCNL7IUtQn63pkzBKMAGJw+2hL+BjikxhChWrI5S6qYVatMehr7O6iR4SsXdKuq7zkTsKi3GzCzCZoiXxk4zTCOgxAt86qNxbv5IZsJdjrpfbqq3CwDllp647GAR7g7tRHYxxgMtyEMhJAAfTtLkSltHIkTPCN0+DQNNIDvYqEb4pMDG+l85rF3eqM7uYCgNitCU0MTrDwfqKmAJQwDHtIAeatZYxEJN6n8ALAvYiMvooO+IKGvbjiUBbODnVRhGTQeS5vJbLQLm6O41ZQZdZwIxCgJZyKIdwLLv9qJuDWTi8u5AABhjCOpa5QBQphzjQUw0pIJfQIiNNaqAJQcep2xa5SbltSZv/sjwZn4ip4kF1OY9s8q6laYxfxcYRSTh6zBvDm5MjCokLULkoSIAKybjU2y+fiBxjvwkTyCNc4RO7UBLnO4z5kxTQY4NmKD1l+hLgKBcbWJgsVwkv8US72qnaM7oTaB5b859L66CQ+qB5PZ+rysSa5J3MoQxZdUMw4CSdsY/e07yCq0MVWwgzli8CoCLOIpFb8KyjnJA2fih2Rx4OIzNJS8Lr04mCeZUxccgYr8RY9p36sMS4qrjl4EovqwibV0nGyZrS4wihTKDa8QqycUn2OcCP/RCXNNCn8KElv4g5snDIu9lEABBEgEfAq4yL5Ron23ghPFuCsAqlolsOsyrHZJPExMKPgtG4A1rIzd4b7Pkwhqys2BpG5ErNOyEePvmezDlIB+kqTLBADN0AGfsAB4LJlHAZ3JijxPCp6RKk1fGYgSW0uJM7DEKIrqYe7kjBr3q8YiWi9zqYH2+Wc7u4fj8QzsfNmvCSvBrNiNO01FvCB4iJq7pJD2KMgGuMxKmynXE4DZg08X9Iv/4sio8tniOuCjE8ykg12oDFG3qhrQO4ArkVGMs0Bgw2Iyuc8hS9DrIw/7GK4sjNCuUV9TEJ91rM6EKAkII8CN6Km7Kf3Nss5/+dKGicIE6lJE5/HMBUCt/Jjd5DI20Dp+FJxRcURgmIvPIjPCgNAMUXqJCDAMnCoNhYDf0QyNKcSATP0hJgkUyS0SRVFg46P1BqpON9IL8sOLQNz0tarWbQRIyxzzZZw4kzyrJhlgBzkQp6PuvpMWtaURBmCDF3FqhYvBgcgPXguM2QizeySGU+IvSjUSQHVRS5N5LbrwpRuRh/GOrE0MIUqSyZAIlGULjiU4iRNOSuV1RTiIn+r3twxdhTP1wLzJkSuVJRmxf5uYjKnfIYSRwKASgWguIoyUGV1RbjC5DaJAD+Ru6oyS3sxiKLIQSzr9c5jVwIHVGYueUwMohzKvv8oESFs7ytn5sAwEgEUajdGjuhudB5l4liNalVslCto6fkcwMlycVbNFTh6VWrCpCakElcL0PgqzRRZgtf86lQZgy/XBFWIykrzDlbBEVMV4mvM48I8UTr3hut4NaYgo/repZlq1GGdKagG4HM66zDZR2XI6wDOdWOFI11FCoZSSicTzjGl42kosz/JbOeSLTaTsmVALg1vMyG+yA31i+U2YuVMA1R2S/30rwIekF53alemDv4gESGW7SREyXb8KQ13DWLf0WOdiWOl9jcOMJAIoF1nYmNqFlvJojyDcgGEFHhAhoF6jMyubmE3okde5bEAyAPzz234LWHvwlf8003/r/RIaWQ4uzWIjDAspu+EeLSHpnZwoYJiqCNQqNJ6FuAmTi1dEYBfFq1IPy0Zg81ggBZVTFRC6FP70jSPwknIHutFG6NQMMmfIFBuyVIS1edTyGJ+1oVby0hlcKNokXNDQ4JwcbcpEmqhHOkA/tC4CJa3thRas08jfgTGXlBztKhLlVJuOw5BhO5UlOuQzIMAIuByUXcj4ghjVdRvDTBbda+DSgV5hdJJpufwCCN31bcpdvSECjM+rNIjirQ75fFNi/csp2NPTGrcaOAFRIAFVmDuNpefsBdVACyZspfMmAxvcjVIeihwLgwWTcVpf4aHXqJCHGB9NVgpWLKovISs/zLSWjfCykpxPRRuIRSzgBkEWD+jeI7nWmsoglD2QkqJ3ZZVbED0PAyLEF0xP2ToSLIuaqzUVpAzPkeTRPPiaThzg5n4KHjULyb2aHo4Ua2mckrShEfwW8G1hE8CXzOAvqxqUgh0vzhKbNhN3TTpefWqJR4gZs1GSWA4wTjivRZjh6uTdRKukGaCi5u4j40icIFWVJ+qOyVsXaomcKe43egsA4X1DUEsh4mkpp6pUNyQQzoRZ/Um7O4vLmDxWrlIhRsjoLjYUjENsgxm8RB2IWbCiPy4lYOig12HMToSbp0p04SEgukxYMd2kt5TW/3Mr7Kmq+4XVjoxACxggFGlpv/mBzRT9195tZjuAtvmL1Tcw8nCzJWx2SdsN47ltZRTtFmB7xg7lLxsgAOkqs44AJktCZz5CXtkVm8N+C4moClbhovwKwG/NFoTlm5T0l13A1tO+DUO4AEat1yz2Y8PyE78yVsXIxSpLm7lopTOhncJRVTMBNYoYhulayyJOEOPsHjPLWWKOQCol952NX5BDCYlcafGjZDCFmn9mU3Va6wkJZxK46APWiazraEZ8m53Gvb0OSF8QG6GRzQc6FgYIJH7pozxTkzjIpW+6XVxkzEQOGV6ZCBvbyC49WUZal2umOzcKauAL8vQdyCyUCvKQ20XAKdzmgEi4EDQ7klQ0Qr/QQUIG7ExemQAPmaKGsCFhzlOpIObR+J6UeWLkK4VhddXRbqsEKg1phDJLPGpCQNliIp2TFOHmqUriSsCSsJL5lLpTlcEtw2E2LqPxeKJJIWSR3khZtltcENNTwM3RAK4zAQ0TGAiHfm+cJnZGEA6hhivT9qB/8mMtymLAwCN/4xIasSNFyIrBLT7RlZureNJLjtOZsk/kARX71FlkjQ2tqW0m3htFqBdf9vwoJK7YjCkSOAINmB4iEUFeOV1EECpdVZSnflC1qaSP2+pAskvPEAIfJJ5IkBHB4u89DvPAAMlR/cqrYcB4tVI3yhcw/NowJuJ1Sdt4Fm5z3sjZuDV/4YHBHrABT5xAFZ7Ifr1UjLcNM5xI3wJlC05ROQKNi7gA46ETqAkKBPOaxHEdxF1pt/VYKrbnQt2ZnJD5wiwwjc4Hj2ixE2jtRX5AiHkvbkGhqAj7BwA0eq7wT4wITl6+4CUuSdoqZzQLUgABUzGuH1sYGMDFZfZo5Xol+MSVOkialDnN1H6aDoYiAwgv5Fcg2EZroBsIMxECCzLS9P1Kia6oMe3YnUVfH05pfOjTpkmmh1dj5aq/R7uAy5gaz0NlvS7RrCaALSWEmFp7DwEY/KlQxFISwnwatiizzUYlRU7uU1jAmZgbkRDBqB7UT/1beeit2WaxOIcTLUJewQbTv8eS1T8wiOIRc5JbqK9RKlrCqyIysRgCasRImosBXv8QtRpp2jy1l2511RgXYMDQJqH+wwf/CT2WmRqwHjkt4V+pDd+2HLSFdvhlZG21apaBzP8ZoKJu6wy1D3YIwQu4HjsNigjANhS09Jso55G2H3Dl9OLexYV1sz4btcJEAFNotw3GPIGZbwLpEL0ElKrqq6Bz1r4A3aebaVT5sF2KtJAzmDlYroVHEuGVDpI4ALOPJYDM8kkqPoGrVUDernaUdlE0ySrO2hwaCY05WC4yE6S3uM3+N/BNTSfBigt0PWat27x9i4m3MXloqbkKIq7QuwZeDmq+9F/fJmihHEjYAn/RIABs5RURfsjQKWQypq9DAuOU+XC+MNVyQbBYMhNLpvq17esSypM0iJeLpoi3LNskXbDtw8BtvLPCdxttnDUgt1s+E2NL0SDBhPMnbWB3f5CYoAIFID0rUrUv+psGVpRd81LcmrbGt59yNS2ZiILixiFVgytQYSTcATxc/eE9kJ9eIADbsC9QQC+N2TFcrjgjJ/Jtw+izQZhbqSUgAi2gwl/e4hCq/9hdUdhup4uIFlXCIOfo/41LGOTjS9Dc67mBSaPFk2sIYt+txxeha9UqIT4cVdkAUKAgAEEBIT4AOLEhQsNPPQgITCigAAUK1q8iDGjxgAFJAoooMCjyAEb/0tiPCAygcmVAR6IlEiApcwBHQUWIOnAYwGWEF6qxAgAYwOZKzFYIIo0qUYGL0VGqIhApIGMQS2GjFjzY0yTA0QyoFgVY9OtJ5u+fFByQVYEFwcgUICApEUAdOvavYs3r969fPv6/Qs4sODBhAsbPow4seLFeruaJfHBSIOFJ0B8CCFgAUUDHg9oDKsUY0GRBFyaJRu6YtaIClJb5Gx2atoDB1CXJICA7ADTAhkwSGAbI2yJclcOdX1xQwfkzEuiNBvRomOYKxOkJFDcZFSPDkw21Tgduk0DPzH29Fheo2bG7Nu7fw8/vvz59N8PF4BQxMILIl7wuC+AbAEMMJxnzf+tNJpHX+HGG3XNNSiQgUQNkJMACsRkHXQlVSCRgErhlgCBEn0F3mrpmXTcgQE0kIGKLgbwnE4OVkRAVidqBKEAErJ0lUQ7lfTSjxhlKJ5HHlZEJFYbxXhAfU4+CWWUUk5JJWE24KDQBZVdJtEBIgpkQHYDMiDmixed55F0IgnJ3HYjIhVeRAf0uOZGTHnEFnIxRreRWwocoBlRKTLHwAITDGqmUguQlCBrASRwQFxLxTRAmRitJlBrRO0JpkmcCvBURo1iJV6oFn06UUacGlBlq66+CmussE7AgQcWNGCBBxzQAB1aAfxGYqJJuSnQiQt4FBNorlUoUJ6bNqUAA7T/ieSsRQkYgOlHzL30lLLMIRqamw8koYGww0YUJrMfWZrRAFcVcKNVKcE5r0nqViuWkUVqam2dARDAWQFxveSArAYfjHDCCuOVQQcaNNCABh1kgFe26JrLXAScGRBcABBAKumLBBxQwQEdFWDAAxwvulGOEcnVKL+vmcWmUnE2myi4SSUp0A0cYMwSzztd+4CXREEYL0XH+vhhlzItkICpGzVawNLQddfWvDyrC9PCXn8NdtiKBYCBrbhuwMEEfY0qUYhAv40xqugGehGAMwYQQQJ092uWzKFl2/GABxjAcVI6MxDB3htl6wMFE8C9OGmhsV3zRQvApgC7K+WtOXIM/yiggEoAuOxRoKVluhrHFr/UpNiuvw7717RuALHELQomt2nwskSAAgYgAAHkwnqL0c0vlcnzmyxxjSxzPB9ZUZw7GtfWcGF6J9IBGegs/Ev4bgQasXwW/xagwgdA/JLokmT3mgBzR2dTFrcee/32308f2WY3gLbahxEMoKRVZE83Od+L0mcRtnkvI/ETiK+WB514ITAjCaiJAoKXEeYpriSIAlABHhAtjWRLJR7wgAEt4pPQJC9VWWvbCVmyqpYUaYZmQRUB8IfDHOpQMLODWK4wgL7FGM9lFEHAAwpQgeLcyWkvhJwCReK3ikgrKwWUyQojIsCkdC4AC5TJoKz2kv/gLFEiGGRRE8XHQqVkLyN22+ILXyItGsoRPcfboR3vmMOGPYx/HKAYfK7IrftUEVVvW0BOBHbC1Unkexf5TeBK0j6BuFFFXWTJoJ5ok0uJhG4ToEATYYSVDRJljFEcUAq1iDEwYtF4c5RRRAigyo/gcZa09BqtzPbDINIHjTQTSQUoQkiMjVEAWBPeMI/HHAReC0CMNFcDRamRQbEyIntTYHY4UC64uQtMmiHIIxt5AAeELIF6A88pV/IbBNRkeklZgO9CWBE0velymWqgHJGIgEjJhWsJqKU//0klPdZuYlTC5Ax9xTaZLSCcDvAdeZBjt2BB7mORGlyDigm0AVT/wAAXMiBNmOjFi9iTmgl8ieI08DOgQQBTk4RK6ZKSIzfu5iXQk8mo0hNDjPCylRIF5Uf6CdCgCrU9+ruVBfoXK0UWSUB0quKjmlLTIZEsO5Vs4jCj+skDVSp6CODoNzMCrkjWzHhgfRzG0FhKc+okKaNiJxvN0lOZZEuk66tIWKbZFOZVDixD7Sst/YeYHkaMoAmT2wyrtUyjUUSe1CrJRyNiqqqGZpsBguZG7PbVrCoKNg/ILIowwrzelMWFcwnA9oAW2t2thJeetYg7USa1jcRykYriVltgeZs1HZF0InFAdvwK3DtyIGK6BExRIYZUsHGolS/bHHSwGgDmyeVT/y3VyEpfShTWadZFN7OsJYWzJnapUwAPiK1FShg3s5gXI8vF09sMmsUBEQA1s30gUiCQt/lKdKThJUlw/4u/AHigAR0IjGBzGbtjgom/EarOczfC2GJRZKZYbBMUkZKttF5kgtst4oVdA65PuTUpFgBioh4bJHSG8W149VQoVWPSduHWZpFsCv0AjGOwZcACJfaLQPnoRxxm63qhlchK8NpMU9aLIpAyH3MauNeNtFciD5DLAuKaVYCBxLvR9ZdFMPjdFhKnOZ0UFoMHspK5wm2k30Sj0VZ4I2ZdDykGzWuO76yw4W4AsHeZnVE9AMRZys0AERAPS6bcW3bliMsawf/NNz8F3bf2dgG8SfL5xPdoqcTzOZ0Ns+VgwzGTPcDSRTmKmWaYOceuhtEqihFc1nsRi+0kwgKwTfzsuxLDimcAeO71qwJAuwLf5ce2Cype30dTmyoyym21GW+c2sglEwXRTYG18G6Ga8tJbjPN+6yqO4Qc5bwIrx7ZoiNPCIHqcrEpbPGgmJW3ktk2SzxA9bW9oWQUC/jxuEdNW3AZsDpnAch34pwJhaRtEQbk5AHx1QiAHriAvRFLwyUBpI8QwGphrbBzSfolRdg2agccAMsrcjF6kNMAs6pIqSBtpO8U2+GSrM4BDxfTbK19kZ2qhMEFu7fP59MB/mGAA7QbbJD/cxxJmT3HbiqJAOh0cxHtnhiONbKJbhCA8dTI28ZE4TBSCj0SriTAbQOkN1hNkmHknNZFdY5ItgMgvoxn9YoxNU+MWcLLCmQdOgX4ud/bs70RUAC5/vZ5kd3avgZdqCYOCFSOPG4mBaNR7iuJH4Mbnihaj1g7RSoT9yqSI4qzpAMbEFnAugrV4mk65iXZaWNHiy4CkDzaNRTP31+3AQ28bgSCh5gPLaCBDZSwAxzAQAYy8Lj/PrFM5O7bU8stLFo3cPPhskmIHvzCjdusSDf6vIe7jZwSYwzZpOUb9M3kp3EiBwKClDrsn/3Vtsfm9q6zgASOXj+KTCADGBh6Bzyw/wG5xwH/JWLtwlwR0R10gnmpgWi+s3rmAnDy00Qr1FoXUWfdtxL3IXpE4UkJRHNOxhx7UkraJzIKolVF8kgD8BthtxEHGBEIQH9iwwESsAExeD9tlBEuKEkBsACoFyCzZ2EN1kAbuBIc9jkfhj7nE1qUJx0JgAAMUHcX4X1I8nQuYhQuBW/I0YNPqFbgZiaYEmXn0isZ+HqiooMTYYNhIwEjkIaxs27ZMwALAGZFNkOUgilMCCdS5BVIoXAfQWptkS3qpiLtcyDDBHkWMYVAI27YJiwjA4LiA4ShoWB4CF46ARuAMmNNGCIZlm4ZAXYHyABtCDYNIAF8Jopf03wGsv91pLJiaCU8nwgqfMgdSFGAeUOJG8YjSMgcr1U4Z4ccbpF1SsEisNhcoqFPScF+i1QVBOAARSOIvANHOtURhIMyWcQ8TFVX32cTIqE7J9J8cHWKXtMBEuAB4Rg2CvZhgCQwKCYRrQFlBjRfShFRRKFXEoFRqbRJkBMU3sdhE6cUh0KCM1Nhz4JdcPMSGDFSm8c2W5FT8nc3PvWCV9F4pBOK5pgwASABFGCRX7OKY6Zk7vWRIgGRF8N6LViGlVckhwgUKlJ1WpER0iJOLeV1JZcaaLSAFoFN3Ah7xcgSNFUBFega4oMvq6g5dGIgCvQVDVRj2pJzHdFpbQFlG6kwFCD/AcUllQfDcplSEQ0kF4D0KwhXkih0kiYhf+cTcRrBM7foi6KCAGR3EajydithAUNgglE3lkBiFvfYiPexI64nAElDjN00FgFgN1Mhe/ZEeRR4lQjjARIgbIt5MB1ZjOyYJxAwUlhDLNRXktRFi0XiGi2pmVzxgM3BPfdhG+gYhiZBAS3wcpbifitBhwLwh83BKfxicfGSPFMhN5pRgNxGMDMhFbwGmVPCYzXYZxLQAMOJMCMJLfGEACJHIuyoILY4AE6olidEYRKWFEsZl87lhSqETAeiM5xZEdSmlaGxY/aybSyximM1ds9oXeGJV2CGJE3xJUYyYSzInC1njFi3/ybKOSUSIAElkBdrCKAHs5SOohEjFTrtGJZEEQHHqEbQAZQWkS2RuBEB+S05KG3mmRmugV52gp99ghGGZBbmpyOhoSwKRhZXFC+rMwCoUhz0VFlqcqLtwnIHGiszaJw6+irfKFocyh2VcpcPmiirUwA451iSNSGjuaH5ApIUcUwFgKEo0iJ2conq81MUhISxpKQsYTwS5RaRUj6iRGvaEkvBAQH0WZ/2KWl56aOvYn/4F6dTAqSyqRELhEapaaQqmnNeAZ9ieXKpwSlVGlIYkSO2QUCBahGHwhwBlBEQQjeQdiAPV4R5umJ4Q1sEUE5HFkxnUiQLUKetUgIEOqqtcv+nzWQ3vHmQfYpa5YccDcQcWqYA1ykUZugjB3AizPg7jHoR2OQaU9ouS7c379gc9wltSfESfjNfBGGPMsFMBkgzonqqU4IBEqB71Uol6Hh3JeoRmkKMAYIxM/lJDIB1BOE76oeMpumqhyNrvsoSKJUaGrpaukiWJANN5wZRe2h3HqGSFmiH32mXZiGc2golGiABGGCwdkpDbJE+vJgeTuqqGINovgoibBqW4IJXkXYgjjM5rdqkBWkS9zGbWjeLXCqSuGoWjKRrMLiwTzICEvCyU7KUXjVZ4SkqpzexcLJR5BFLermzoRFiu/Y2azeh/AmmnNVaaGQAivM+iOQarzX/ahvBSy9ZJHFZY/U2s/KRARJgAVsbJRDAWwIRONVZG1a7nmBBEcRIhElBrirCjkSUERSVABgbtFJYiQQLHi4SokkxRhzbJ+pGkTTyre/lZYRbJMxGsGA7HxsgAQPIuFDCcmVCNWJiPNAUiCUZo9wEQzOUEapkq5oFLrFZOZZpdSqib6nBqYbqPLmxOgKSLaG7pFGanzO0eewWufIRs7kLJUWCWNmSbQASVcZTspAjqSsxQ0ALhlwhe30KLvCVt2R7IGU2sdyaJiE5kObiZn86Q2ISFoDDu+GbQywnIYalOPc5Z6qnk8OzM/aaEcArskrTraDldvCaMxlBLA4wjcEB/3ImIS2hYxIYkE1IYaIWwi4QwDKukZUCsVjn1Bzu5IcUwTy4pmtg8ls2iiziq8H2E5t/Wbvs9rkJEIntI7u0CbJaChMAYwAwV1Jpeyoe0Z2fxD3V6ZYLesI65SOdI6/kGicFgLGuZrcIQlNIyDxBXFvgRqkouqycRxob7MSv45cCgEHhCqtsZVtwZ31JeD6fwqcDshpESGsYBBq0VqFvozPkekWytUYcpHK5NpY5lRRUXJ05HD2rUcYb0UCyJxWxxXK5dZBPDMhgY70sZFDMl09fZTytwSl/+LbsWaTm0VUOUIFCSYXmYzzl0azICJ/Ek4gy95rce70bYbRp1lsDK/8RrDYyAExWPDgnuCmh68cy2rVCMnNwcHVZ3BLIuew1SlUcKzskHeIWNktX1HLDkJO/b1NBW+rFLhSNjVKytVwAd3yrJru+GmGeK0F60PphQXFzbnwx8VO8B+Jq2WIgtfyQ91mXQmqPuszOCXOm5/kvMCzJFpig3wO/+YidWCfNVEEUXIloU3EznoUp37RQALwRndyFD0l7zyqXJmYSyYMaYUqWjbVcqiU8nLJoMNYZxWM3Y4UAPylD6NHOI20w1ltFY5o0FueRFVGP+nm3lDQvMeJb+5msGBGu0BOjYMguCO1wKVsS8ZNxHYiSL4iQMOzNTLNYbsscQ0RbH/fJWPj/ShPmFp5J0lUNK/upJD3ZsKDMGpgCuC+NFF2EwMVhTzX9wj79we5LETyNowpNQUeUalpcElfIEuYajPTrQG5krAeSADS3gAo0X7RBN1eUgiYTIGO3wFVj1YvtKkpFAB+TG0shRyqTRBN2h2Nk1kjRyKy3qhqxUxS3p3WjIWvpGiBjvyYhbgeyAM3LEuEamp8h2iT5bfhsygz9cQdwRF4inbbL2L29reKxJ1XmrcwlF7VsAF+hLl8N1qPkwtFzowmNMyxtaKSdVemjLGb0QoJ02slDpuKVbBihYAKiFlB0gArg2+cNJYOs1jlCHldzJmtbpJu93Iibha5lMROtoEwm/x5RxdYd5qhnlNunTZjQsV4uYykKJCEL3LDozeD5w3fFzIPdFqNHBOFdhtbzHYS2PdwaDh600VMdTHL93WHZ3OEGMM/8zNlEG9sOKq3Y5ZA0BAENLuPxsVMFIKOuNTi08cpQbWQZxKQYHhqh5Rzn9xnOLJDLalki3mHit+EdUsI00pbNcWbfg0bWFj/FFMX3RK0zzuXtkaAbjT7EGDg/i5Yppo8lmSN8qjHOKJqDisVg7m0Y7rEr7tK/eB89NV9GbIHA/aYWYnLNAjM21iBKteVdbuiLodL8erhvSeRQitQGJN9fKLFBOZqDrucVoeQyAQGFIix0LahPnRqy6tTZC/93DzBqwfO9FKoRTtdRJZGMdMwR3EgSfT3PvFWwh47riNFKnqFAlsWrLPzLhQvkj7rG4nzCEKBOSNRSmV6ved0WZBJuy/Hpi+4aK5amFNEgDxDj0UM6yo3CLH6fDNfTTVHouW7ug5HlTtPrBwIhAj7fyUNy8s20pKlxa1V28Cy0V+qb373UKfQp3ZE8ecIAnFE02IFsB3DpWn3CKvjQ6nXuD08YFewg1J4aEGDYcT3sT9bUcNvcwigsIwRMJxsa/y2/TXGTaJePejXg+NlsifLcn0EQdBNJrALxNf8XL96mWAGCGR+WW+juFUFppH4mph3nL/ISv2Q8jAqsWwnq83r/sp/SGtcY643OOzSnfuP1QUs85M7+L0Nm81/PF3eacAow0Dw/WRvV6ssdh2mxGkDI1uQK8iyKHPIaz9wRce/Euhm6Ts5tgslzfWD50z5CIhWc2dqYSYYfIWCv+HlBQw+gLBT/0o5YgaoUznfrbgd9IMqSI2lNUsjhsUp5U08ze2wKAC0ZzdJ9McbzpXoYJARjE8Du6FHtMavhw4tv+3WR7rs6vx0G2d9EJwDvEg5Acjho9nwPftM8t0Y0tUQxW6jvds1xWhOsZiURgdr5NBvkdA5QHnZjxAu1wqwqR6vP+dE9IFeRObeP/gDAcnmSfiv05M3RKAZgt2wDIFjmwDw//9Udv9Zd9VDx1CDKDRAJBAwkKGBAgAAQChQUQADhQ4gRJUL04AEBQwEKMDZECGDiAIwOJRIgAEGix4kPPQ5YSFDkRAIMCRzYWHNghJQTN74MAMDnT6BBhQ4lWtToUaRJlS5l2tTpU6hRpU6lWtWq1QAtax4IwMDmwAI5xU5cYGCgg4NjJ0LAeGAAAgUI0jr4OtCATowI1Krc29dvX40100occKGgg4cXGSboGxNjWpAMw0ZkgCDBYLUNWmgVUMCxzI4TFRe8C1EgQcZqESw0IPKtggqYJXIe+LluQb+jwXa82tv3b+DBhQ8nXtx47wB1Wdbl2TgBA4iRC8ree/ordP+zt01GzD7973fw4QPQrFkh5wHDBUV2J1h6L20FD617f0jXZd8JFAYcKFDAbVaMHiIggQUiCowhiBYIaawDB4JrIAWoS3CnBm/jSC2PyBOgNQLSOu5DEEMUcUQSSzTRJ/by2igBBQz476/lwJJrPIzM+063msLCsSayGOIqogEkxBCimQ5gwCfx9mJrowdSS6mA9Aj6MUUBEOtrAa0MGMw2ggbbUUiJONBgJIZwwpKg+BLDqAAHYqORoTRTks4mML1aMAEqbWouIpQeGoAkrRQ4cVBCCzX0UESB27GgRff064GNEKDSPb/srIsBhQqiLSM5D3jAgeas0zJJ9n5Mciz/BTHCSSwAoPQRofkGcjInBgpEaMCXEjhAw/Yg2lSvvjTgQKIFDjBAAVvbUtOmsjB6YCQEcIp1IxufDPChVG8DMyfaEEj0W3DDFXfcEOd8bKMkLcWIyjj/yhO0/fpza74Ctp0oAsnE2xG6U8VakiFbxUIPNITYszKn0R4IGKEYN1p4I1P3amCCsfC9NrmvXMSo3YYLWJQhSiHyiEvG+jRXAF4FAPYvLjsj92WYY5Z5ZqGmrS2AWGcNQFIHVj1JQJuodDSiBRQowACfySvA5pyKVUDnviAt8zuPNo2434lSDlnOKKuMKAEHFPA5pWm5aysu2YT+K4MGxlrUpJZDwmjh/xQ3xehgkohV4AEFHCVAK70YMLq1xhzge4FFe6J5ccYbdxxECFIWwE0CDDiaJwikhjC6vBMK4GSCHODVs7G4vBpWhlbGOiJqw7N6dYHbs/ehBiQ1AOpHMXIS9LGJZOjZ7zrwQKyWJ4uboQEYaIl0oFUkaFOH5tuz8oFO76ok8KhPfc3Hu/f+e/CdkvwsIStYcGeIKyRILxxxf0jzLmEyi3C+YAdwsfDU793+6BiYHaK2YQ1iflpRTgggtQiFxwIYEAv8BOAkuz0PWwtDiANr85YDMIZXXFHXQBbWwa2J53gPoE0CwndCFKbQe+rr1UQ2FZ/jVUly9bpfQbZDmAKOpf9P9vPIjm4II5Dxj38B7NemZrUpeyUAART0S37EMgD7qMx3enqiYIiFgCUiRH0RUxvWIigABnTHWyokYxnNGC6bEYRfEXlhAN7lwQBoDy0ByJZ65JRDlllGNgNiolgOVIA1gmcAGvGPEIc4ErM0qS/T+qHpiHcY8WDAAmKpzIyAVIFjkcRwyBoL6EIoEQtSqnX9Al38gnRGVKZSlSX6Iu4k55AvSrFH55sIlf7nJ/iJxDbtEotuhuYXKJLPkCI0y9KIiLqCVMttzwvkrRLpPobVSDwb6EBK2PNL8Fjwf1uko9EiJR6TBU1xqyRnOc35mzfRMjqcKU1dDjabi30Ef3//UV+H8tITsUwLMztUy8luOcyHWIwgK2DdRm7XTwI0EzxME8/EJCI5+3VQdZR8TAwNsroIcuWcG+VoR58iOSG9xQAHxVldJpM1gqWkWZ3BZkpyhK6xUGmif9nROwGqFtpcYDB1VBafDJk48bBNInjEWrE+1dKI/A0sDrEgalb3RgGM06NTpWpVJTfT89TlATsckPJI00cCIg+IFipIAvECJ1LB9Kb9xMgFdqectd6KSdSJwPx+2YENQORfBXmAQuOaklpFc12WjF2VSKJQixqkqotl7Ebb2BfzfWVlFt2W5KwnlljSqZb3FE+ewPpXwRbkAjxpqlP/2tSQtS8nC/RV/02QujoCRGB2oIMmRPJUALrVpbG75S0qJ5WA15bSLmG1SW0nxTKy9jSpj0nSoj4bmrWm6AJE+8r+hjmAPA0GdGKhAEQE+ru4quuytmVu6b4CkdJWr7frZW/4vqu7nKDkuwcoEk8+tj6xRBFNlfrKp2xy0ohEoCUGeO5e1gTaTnLGBBKBAIt2guC4dUiuc8uJJE1jxY+QxwB+ZWvqUDXPsYzPtAFgoV3ae2IUN07EDlJLgy+T1a88t2Ui4edESnyzIKnvkwhZwD/F8t7XglZXcjlmdIi6VuH2NW7bouaF4xkRB/KyOgfuJAJEV+CHRLYmK+Mpyp6TYjCHGWb7CVpaFv9AACxLJI2bWyZ+65eTd9FvwgXB3QDSjM+9FMtFPkZwAIoMkY3w+VQ3NoizMpMB4oZOZPKJ1AAS8GK1jG+YXS6ItBRwgJpKVcyb5nSh1pwR7MqOaAd4mrVIU4AHZMcBz3U0pP3CTZQqGkjdqW2SatxnsfyZ0WXFdTrbwiUsT+CY9KKOo6HK4ooZepgfq1ep9LuhTkdb2iVKbIreSWzCZKcAq0rRnf/S5c8yYFeOKmGvzU27fB7mhwgeQCg/BxfCjkVMCSI1Atbt69sglTZBDg/iSC27+xbkSNMmeMGHg7HkouwgJ7OpnwbzXk4Z8jPMWyiVz91rXT8kZQ0H7bMjrkD/Bqrl0zXp6xNp/dcIQKoANsqsgwz+cphf5dg1ebRaC4ugYRIgWqfSMm4ujvGcgE7QWGsZh/tCAYqNJb11KXCQhPyqlj8w5lOnulMQnnCUBTrSFrdfu2UdnmkB+OegzXhXHmxu3dRaLRmY5Fiwfhia+GfosAv0igtSdbzn/SgQmPnGlP1htDIMAZieewUDD6uFLG0se0V2n29N9qA77OKO3lW8w1ORmL59IwW491pREmHhokbvoyc9UN6+q5Qq/Vo85TdltI6+gowXIV6t3tiBnpMK7Ri07FE7kLCYlgYg+mdx1Pw3+fcne9nNIYO0yQFK//zR272ACYCUA/yXUJ/q/3UjLeL6XyAugGSVl3gSBu2fWn+qx5cdIVEc1cVBmpvYB8CJ8VVq8VsIuyg6oPPEp7JwwwJ9AKy6AFi6fDEQgngAMAk9dSKMR5MNSps9JnmAF7E9DcGtn1M/hkEzxzsrRmmMBZm3Tqq/zviKTbm2Szu/9WMIjsO3geAX9UE1vQhAGaQ6j8uRiEgZsWOj5PqltJui+KMjprO9HblA2/OLAdoLHUMIYWkMBHCIGkSLaXmJUvkOoRMNi4uUGczCqRu5giiQM6O0X0osG0qJokOmHzQ8cRq7Ixy+m8LAInyIPDkABzAAyyMv8EIIh7oRmGqQONmR1oswefIRp8NCLSzEgv+7OuaAqtqinv6wCWCpMSr5ke5rmI3YPz+JgJd4PPGoCSljFdhxQzVbiAewLoBKLBqywldBCKGaCE38PlupL4RYjTX0xM95vYfKEVsyRF2ctoB7nmNrDiEZH6T5HFODpLhhIl1hoRATuOO7sd4TIlCECBzBqlKMpU6sRbF6CMwDJpuRkDeSvYl4thUcQBJklF08x2jjQkITAOBBCKWZlbgpjXeUCPXRi2O8oyDCs4j4EiDhD4/RG1TTGUpcF3OLxtDyOfDQRLE4tqCzDwKTCAsQPjlZxxAiNJ5IHnvJP0usCzq8tIFDR5DctNJ6mttwkhRJjZZRpAB4tonqsrTovn3/zMZiHLHPYSeI6KB26cV27DOD5D+GMDpDkr4kmT/oQohM6S/q6CAK06L9eiLyywmTCkmp7LQbI0BZUsrJ2Dweszmm1JQHsIzU64rBcQjBoUN7mUXJMcmldKO6AMdh6kmlBL8+o7SmjKQxQcXNa8KUkL7JqJBx7AsAsDsDmErCDLO4TK7U6Ea6NEM7SjTJmIk9W64OzB0Qq6G6ND4SY46CDDAC4ZY7PJUFAK7GsJtTTJIllIgaJIib05Mq7JdvLEzYRLFePK85w424NJ6NeCeLokbLHIh/ei+xsyBTwczE2kk2PKTavMYO8raUiCIL3AsGgA4CmMM6DA8TcIHOWJkV/8tBH2w+1/qLx9O5HSmA2CxP9iqphHtOhNiY9YSv9oynwxyuN+OdvxAV2fDDh1AfzJC+2Ro8FJyIADoZaqS8BLDEvsBBzysdEriAEGCz+OTNgim+wiOTxzBPC+WtqKs912uP7eCSdnlBHayJTwKd19qhHrOmM6zJyUwQLFqUwbi1+TAAA5WYWDwwhRQg9zw3swABEVCjGr2bvUAAEjqAnvsKjrs1CCCJzhuZQLtQJ10s6cM5NdPLmxxL6vKwCaE5OHuy1YmAE5wIFjkAVoNJIFGuhnJHrsSaHSKzvwuPNfUUkvIXgriAD7ALyBg8LC1KhLkNGV0kOqOj7DAr2hjMJ/8tVI9iPJOawOaCJAbTFfjRPZ4ixSLEkZYCqiQJoJS8qfiMqtWhxL98TxVAgQbtjMHQT+SCK+jUHck4CNuoF0N9VY4q0ttYmvmR1CtCAOh4C1xdtJFQALFZxrMokBvln2ElEsMRU9VI0+8gon27qaUTSLKpPoV6pTeDiAP5gChZGczcC+n7VGslq1EZvJKBVXI1J+3RPAjVOF4Tomez1Tc8VdLoFyJivs5w11NRQE6No5Ywq668D0BTFlgEEq0QARCQT0RsPG7NmE4ajL4Di3J92I5KTQuZ0Rnjny7jzncNjxT5TwCKCAiYUH1UqXzzyYFoxy4LGavRLykbjRC4ABX/2BA4XMtUBRkDABXiGbACiVI6g1ieLScxpKL8AlLYAYBujCuSAFn42xCg7IuetJ/McoguGp/9bIsFZIhQDQEn4anTudHRGYAbbRk7Szjn61myTSWd3YilPS70864j4x/am5yUKFZS6py/aFrYSaz3jL/jEdjYY5ebxAge7cejecZedYB0jVkPe9u6GKOybdwyWketbLMUXZ3vNKSTIVz+qcDWIyLFeACO/QsGcICjoVTY8zC74Tgr6xtyVEGIGB8TCLmf275dqwsIcFzbVSExjBWkGkiklUzW/SkyjSt98osAqpD96V2VahFkLaXk2bzZkVXVYaEBQLrvwJMC4CTX/+QsbJQM9bhd70WhmcOg6vyIwODXvXC08a2P4O0XSZNb2PkV4gXCAvwc+6A4+0kAnC1dO4pLXYHBoOMMsdsRLbEwv0iZz0UIWcWMFBnMJCWA733g8FnJ20jXIlnaZJWS1TRY/pkW4+yUYO2XWRyLtina3szEOBLN8OASzpPVfL2NcYwXuYOnufGAajrfNgWPLhPI7rgLCO5hFOLC8ZpC8VBKXZItIwtLp50atXAg5pQIKiHctvk+xjRYrwMLQXvilimNYgGZBdTTiSTI4Jsy8QMPyyKLDvFhND4hCLCyr5AQj8tV/3y1dfku1bGNw02SBdCcO56Wa/RATanbvGUzSf+L0Hh134NFGbbswsx8HmQJ4TgaN/N6DGETY5kED7XlkzTO5B92RIlYFEyLV5zx1aHxOOhJKuyJq+SR4/kljLh1sg3xMUzlq7QYz4MkiAUwZAuyx+x4yB1BwG2VYDSRxdYYgApAm+87CBCsonwUD/XpRE1+5vD5NCM5CEQ9ixphj07sZYLM2OGboViDW7U40fgCUD9JgAq4SM6Ky+a4UX2KldDMkRn6yilmDos7zUemr6+p5OzBCIWCZn8Gn8xqkpqQ2MY8YtIoj3GmwnqbO6fDFu3Nz1Q0JDfcJcf0zVbeS/U4mVjCXxFNZLLim9Sj3gaxKadJX1bES1kSmX9e6cf/sT//sBDrCSalvS9v9WNbbrGb3OWA0Y2GsxlLNOSIAEUXo6CUcUs56Rwu9DAWsaADcunmYBuIw9yL/ogGxGSWvurFqWayGoDvY8+c2I7Qs2ADW2bCCAzPlV/6eLdzxiG0fct+GQ2jpmSyegmrOdvKrVEQKFiydjys7uuZydAFiTJVoaPfe7yVemgRskUok4l6lOu0Rk5SShKdczV8/eOHsJqBTLg4ORA6JWs9UwAOA2pW9GvShpmk/qbIsYses0leecRZqkzxOOZ7WZcSTNht7tSAsVv+uaZlQY0cwQxZXT5/zCBNcaeDJAFRFQAQqNPJgm08icwhqZ/Snu6XaVjY//YT/pBniMMm9dm/JDXiTgpeYTTTnJDt7APd5XEI3T4VCFiABUhtmZxOCSyQuOGlzJlcP4njpt4yhHgvbBUA5C7NTfnW5/kfYn4AeaZuBR8X6yaIGUXcdZWTXCKbFYUxf+3kNSlDVg7RC2+MZ6roBVjvvagx6YOmViFvWPnSqMmRDsWIE8ABASiCHqjoC2mZPvYTdlpwHQeX065L1dtrmNAjkZWJG60rNjE6AQ2AnnMSlNAQ1ZFpxfMLok1FyVEAExgpk14dyIXQfemXleBEzKANF5iYSd7K8xlkJImOwROaHW/zQ+lxDRWQljCVqxIP9BU3oe1SRv2cqqa+DTlXhP8FgIaO7kC26DyJktK8W9G9HQt5CfI4a0IeCGUC4Rx9CHWpF6HagGFBiE0xicX8nGKeEbqEEDcvdULR1QxVCS4pDXNJdL8ozuMzFuhu3dtISH4CQxYUgK6J677o6jT06Ju5lV1p4rHwOCFRopfAqzIn2QdKQYCViVgaW1OfdhOxSovmdH7mMfsw35CNvLq48YqLPe2yEKQlUbQWLct+9V8iqzn39F5GZc7A3AXagJB7r9SwItp4WmrfdxJhYbWq5jvui9kkdrHgb/SkXR0a1rqZXXbU9XQXuUoryk2VoO1QXClVKTk0FgjZp5T4bke7tCbOjzKHqQGa+Lbgd5QPkd7/NKh/ve4kGR+psV+ioyIx1D33ZT18Ghl7cngMvhUUplBFlo/b0pSAUcB0i9yjl5UkkSR6V2cWpG+yOsGUn/oPWXlakpwHp6RAnZa7aOjH65PntrdH6uhD/t1ObZHxPY2uWTjNQUB6VK436goEqABJqR423Yqv/grZU8oM2pKdqzCK2QAPaABcp8QYPOT2oXrFBxHItQ/DKejw6CBUQ2JakcXnsUSt7ozaZHnxODN+0Q1SVIyuiXQNRkNQvq+X4CkE//XZ/q8MZhS+Y8aJyAAKYKAG0AAMQFuUCNPPtyDGqJzLWXzhP472nk1ZsYztkJT+wN6ThgiP0xW7AEb+iFNn/0fsfJZdwcugOg+PKBJogBEQXRoIRD/3mybwH4ygd3rBSJkeBTDcBqsLXoVwg+JSiLAAD6D9Bvhl9QUZhxh+/xcRgAggYCDBggUPBEjIwOBABgkfQozIUADCiAMSLjCo4CGCiQMfRAxJwADDBSEDDCgwseLJlgo8HgwQoWCEAA8EXCCYIACBiQQiZjR4MYBKjxAnkjQIMuSBggUWwjTQMmFTmD6nBthgoQOFDwwRnIRaUGoAAGbPok2rdi3btm7fwo0rdy7dunbv4s2rdy/fvn7/Ag4s2G9VqwMfenw6FcDDogUrQKxaIIEDhgkUJE2MoObUzAQnhwQw4IDjz0OxJv8cYHigA7EEGQxwkBM0yomnHxIoWuAnVZgQSw8kbZB3QgIEXAevAJP4SdWrC+7EioFCAxQMBzBIYPKhcoYOBoMPL348+fLmz6NPr349XM9WCSSwynJqR6EP3T+3WmB7xPgewbYEXHAqOcBfSEEZpsBLGiXUwG0BLEjQfEAZiJKAAhhAXH0FLRDbQLslBEBPVvG0EmoBMHBTfg6hNgEFJbxwkIoYDrWhQQmwl6OOO/LYo48/AhkkWxdOFCFMD0TXUmU6PYRcfoYVcBJ+BbXknGEsnvQkQ1EGYEICvBEwY3DFGVCAAlhWWZhBBQy15EBJQnAbgr4JxNCEUw0wYkE2Ynj/4kMNlICAAwqEaZADqXn0gJCLMtqoo49CGml4Vho2pYlTMYAAAqcBwKeWA03JXEJuTsQfY4itRlZZEamJYW7PQZjTQHyymRCfokaEwAMFGICfqpluipWRRSY0EYB+BrBAUg84lEBRd7YUJwE7HGCSkwLUOFEBknLbrbffghvueQG0+ul1J0ZwE5L+rfmcAgPMSRBnELE7EZoQDWvUVIUpAEFCYnrUlKwe7UTph52tViFqlhI0VLkP+jnAgxBXSWpwUzrEWHcFKSCuxx+DHLLI4AaQQAUWmytAki3xWe4BEAiq4Ja32SZlghMTSSXLBEGGKpQ4ySdTqSfp+R6ytTHU/+sDBwwFgbPQHR11SBIHAEHOE/l7KsADjNy111+DHfZ4DOe3cpZQSmRZrgy2lIABABe0VEQox3RSuRTdrdRAAxtb8kRm97YaxS4NDRFyTEt94qkQKfth3h4ZMJRZ5ILKtdiXY5655psvIFzK/mL6HHHxDjTvQ09T5KfTFQiIa7KaZho3xQZ/2jjf53qq8uIPPS7h7qgRm3ZBhyL7+2IWpWwQA5sz37zzz4ucu2HEQ7Q76RPJTbsA9z40OFaXYqoAr4Dj9uRTnSsQbE8DF0BqBGbBjS3Rq0ndN0RFN5x4S8bbmrxT0AMwgAIcYI8gYC6K7S4/ELEYlyLCv4eA7mwGOf/WSWxUq5NcT18niYCsHHCRBSAgAafR1r6sQkE/4ede9cqfA/U3FbodkIAynCENa8gX/E3vRNeaCEQGkJkLRmxJBuBeADylsO4xZCMtiR8PVzW5P1ENYRPECgEOoIDLjKWFqEGOEhmHNRcerXcEIZsAFmDDM6IxjWoMABnHBMHLII53zzkhir7kp1NZzSBHRBm0itjE5lzNjScBQANQA4CZGCSCJyKAgsjnpwW85AF0RNpwwKjFHiIgXwX5yQBOxkQBnIcDGpiAGktpylP2SIzb62FpkqTJc1kycBxryQKAA63coYYACCCSqlYVkUL6siUbo4j3Yqk/7TkyWh3y0wr/SVivC+FoLROQAAXOggFq6qUDEvAAKrvpzW9OSnT3KUnVmmm/WJIQg180nKd6iSfwYUQBD8iQLk3QQsaY5VUMcZ0xH4gaARWTVQRxgCIPJDoc2qkt06ymWa7JULwEAJvgnChFK1oX6RmkJtr7TCAF8ICCImsACDhAAswpt/4UrkQeUZjxtEfBa+VkO5M7VQYHwilj9vCIU8EhP5mypgPwU4wPuKJHFjQZtywULRMoi14oIAGmWjSqUp2qPq3CulStZjcBjQgiV/MygTIEdLQrgJm2+hAmVmRKsspaiGRpLPgQ0YUemhXR7BgZWO6vWAGzm/9AWTW4JHUuTiVlWzwg/4EOTDWxiqUodhCqpY6O0awGfJI748ciTWKFfzukkUFSkAKcqCAFBWDr5NoIKpyycYrd+yF/BDRJsHoEV+bMjwHmElgAONQtg0WqBBqw2N8CF5WO7StMGtjWkMx2ORBh4kWIVIA4PlJ8PunsZy/wWQGAZXevDF5xDgDUvIrkjwFgoM/q9rtTbVeQvzGIARzQ0eXJ5ba5bctu3TICCQQ3v/q1YXKJOxHTta1IMJnPMLNItpMCxa5ItIxaP/OQUw13nUbq4olyNxTtsQg/yUTRaijcvQUZQJWzoot8JcqW+rZlAxLgwH5b7GIAYtS/qsUK6aIkvWOJhkh5Mgz5jMQbAP9MdjjXY99JngmqmuEQwDv94/U4gz/j8tUwB3CAARwZYQGoJEN1KfFD14JitmRAAhZ4MZnLnDl9klXGf/PTsH4y23ulpG/ppR5H8DosLnXSAJjZm4SaFMKLQMA4EbzWqJJ2NFsexU7f1acHgaelj4bkagjIC5fR4gELYBrTJRBzpjEN1bNs2syiHrXXJCYaqyQgxiRC1i5dhaiaBROhAGKAAtzLEAQTRW0JgYBnzBgSksiKTYxxny8X5x4A+QpZ+HMnRskyAJCG1zukMZOdUiOo3h1AL5U+i1Ml4O1vg9vbhEWLUz9N6nOjm2SW+pK59pO4J/qRvQHaJ0qRkqSJ9Az/NwjoaREvIMls2SckEIhQAQDkqdeGxNBr+8/Rcsefctn4ObXVtonne2IJjJstEe1yujvucUh11SBWfOxP/NnwSobFUBK8FNyUTC8FHOBewCwvQRAuJpDE2TR+QujsIH40hKYGQlsyLUL2su2LZ3wt2uTmx5vudCHVyU5a+ipqUaIrgjzgphipTMHnDROTPHkqEBBTvgMwc72KfGdTHE1wzKpSPbbkblEDzmaKYtot+eXoXsb4WxrA96cDPvA6Mmd6nVL1hTtYf72LTgSK0ui4k7MsZ08tyn+t8GNuaclsO95qh5c88RX8L3pXy5fXIoERCD71qkePD00j4lWeJE6X/8ws2sdCqIgwoDJIag6qewjtRKe9QRHBH67HKe+jsZ2YfHK58Qmi09nfnUSCGX1aSp8WDkhgA6vfPvfDgyLL9fe5wZpahDb8PZhQD38TquKeYX008E2eJ0mBLnJ1rbicf2gACbhJhk5UlQKtClwtkn9FU2BQH7n9HVtYgARkQPc54AMGRpClU0u4h/l5nUdEwAI0np1xDP6pTPE8RL4QR/xFC0h5hjsN30103cEdDWNEwNsgDv4ZwO+5VbvB1/SZmF+UQAlAYA/6oF4wTB+9XUHEFVbEWM58iTwxRATADMwdkclR0mmhCAGQIFAkhQFUCGU4wIat0AEkWxjpEXB4GP9sfUrohcdt9cU1acAPsmEbxoUHFoT3WIrW+V/KMAydGRKekIYkoUhRXIAQRqFNBZOfaMvlnQjpTIn3XFnAkAca8oUGSAAGuOEkUmJaFBHMLci7GA9jJNeEbKLAMcDrpUrUQOGr8Vl0DMCCNJrLVNDbIEBBbdQSntxz6BRjFN4YPUCBlIcjVmIv+uJ4PBjlIQUY5ZF/IRwY1ctsWIhQfOFyxQ3ypMpNtEaFKdCB8AcB2NpepQcv/mI3euNfrErOCGEEKAjzLSP6wZDOxRJjQBKvkIqsxNtBoIyHsaAzagm/JUsSWYw7MYBuEAcO7QR7ZAVifWNBGqRfpCOaGNvw0JL/VUhFOg7EGLrQcOUESPgKT0VEsi2Oqt1aHercsKgK7dygmkzcQZrkSXoLRhlHCEVQM5FPcvWLMMLEMR4XVnxSTtREvkiFjdBRMxaHufCbcZCjAYxfuQBIuXTMWYQiUKFkUzrlo2yW8iSEgKDgEL7GafTXwYARY2iPHwIIDlWAd0VASVFMMxlABdxGzvBSWDgGS9TSMI5X0jzlXNLlo0CWANTeGFXPqvxXRtJPLCHTAjBAIZ2KmpSGRJ6KpRDHAMxIzFmRCMGEh9EOgERFWSBlXWJmZvoIHMYWQkFL8lVe1UCJYNIgCsHS5IGQptDbVMwW7nlhlvFGcimShYXcFJ2a//JoZm7q5np0FLsxBPcMVy/V1If02VREwAGMH1BMEAGYRBWiDB4iXuVxJpgU1cNBjm+cRVUV4G5yZ3eCB2fqUVfSVSCuiRc9ySR5oOuI1KC4iQHEgEVc3eWNRgHwodBdRaFlXiy+SUJk5T6pBQPcoHcK6ID+BUYRT4z1ymoM1Xbc5WGUTJkMFX6giFiSIU6w0kymRmlIRYGxUCym4mqAjpZ8B4GSaIkKRsmQlNtg2aRlp3vd4vQswCLGYRuRSi8xxAVoSHE5zBK61ILZizgJTWJg3fuYaJEaqXn053NohxfOUcoACO1cQJKg1WkIyEYUzW404QHU5hiZ1vtM5V5Zzv+RiumYDoYoGsaOmtAn6QfN4QRxwM27RISAsIRxXAR4OoWMyk+G2guZ8mmf+gVH5seUEadONGaupQx3GMQFQISnOB7AbVJN2mdU9OMchUh2ikm2+Wmmampd6Kf/FJwIsSMBXAQDRN8syRGoFJJIkRTDNJBnSGTUyZgZrQUDVMCmbOqt4upbtApEPkmP+c/EiKrZFY0kDQrcJMll3J5CJEWDlk2uOuuzzsXTYCEAMGtR1d+WOABClYkAwOlUNEASMQY8vU6ZVOunEAC0omu6wgWeBk0PTQT1wA3EPFtImEATwQ1YNI6aKZC68mu/osV8FtfyvNnuTImqqF8KskaMilD/AKxAzTSTxOjrk5yrv1IsxX7oZ0xsuH4FvO0QneWeR5nNZh1AvZZnQhhJTZhp8lRZAiBnmFbsy/IrzFSArKLFpFaOWuSNJw4ifnrE7QgAc4DQwhpqxGIZWWkZzCJt0rKFoLFF3jgSvA3tRNwOruDTv8jYDwWo0mrt1q6rtswF2dxOMK5Ff21hSXmOvDEGgHLt2rKtW7iHsMlFhN1OXAjIc2UtALjN0lRABWRs2/rt36IFucCmXTwO35SkWwztfgDu4jLueeifqC4Jr/ANza7rlzTu5WJuefwVAKxAllFu5oJu6O6Ib4lu6ZpujpDu6aru6o5H6rLu68JuX7hu7NJu/+3Oxezabu7qblrg7u76ru327u8K7+sG7/Aar+kW7/Eqb+Ym7/I67+I27/NKL9tG7/Rar9JW7/Vqb8Vm7/Z6r7p27/eKr7OG7/iar6aW7/mqL5mm7/q6b5G27/vK74DG7/za727W7/3qL2bm7/76r1P27/8K8EEG8AAbcDcW8AErMCUm8AI78A828ANLsANG8ARbsOpV8AVr8NNl8AZ7cMd18AeL8KiF8Aib8IuV8AmrcH6l8Aq7sGK18AvLsEXF8Azb8DfV8A3rsCnl8A778Bn18A8LsQwF8RAbMQAV8RErMfMk8RI78eU08RNLsddE8RRbMchU8RVrMbhk8RZ7sf+kdPEXi3GjhPEYmzGQlPEZq/HornEbAxCLuXEcy/Ec03Ed2/Ed43Ee6/Ee83Ef+/EfA3IgC/IgE3IhG/IhI3IiK/IiM3IjO/IjQ3IkS/IkU3IlW/IlY3Ima/Imc3Ine/Ing3Ioi/Iok3Ipm/Ipo3Iqq/Iqs3Iru/Irw3Isy/Is03It2/It43Iu6/Iu83Iv+/IvA3MwC/MwE3MxG/MxI3MyK/MyM3MzO/MzQ3M0S/M0U3M1W/M1Y3M2a7MeZ4AGSOI2ezAaYsAGAIq3mRsATFMag7PuomG4PdVa3Nc6bzAaaoAHYEBEvbNaqBgcy/MEcyMAmPNahNmY9bM/5yBaBPSWWoRaQUvwPye0WkDiNzP0Ajt0PquFGk60A1f0OYMaD2a0Am90WyxgA360AYc0W+xzSZv0QZ/FQ6tFPKv0AJ+0WqRzTMs0S5uFS1vaYdm0AM909Vl0T+svGnoABRi1txk1BazhWWycUP8vGi6gO+fg0jm1//6zW/hd0lW1/F51W5zeVu9vV68F9mkfWN+vWJs1SON0IQcEACH5BAA8AAAAIf8LTkVUU0NBUEUyLjADAQAAACwAADIAIAPcAof+/v7u7u7xSinxVTbv19PxZ0zwt6zwh3LwmIfwppfvy8Tvw7rxe2Txc1pJSUnv4N3xXkHwrqHwkH0BAADa2tpLFw1XV1c9PT24uLiIh4doZ2fIx8eYmJh4eHinp6dyIxOuNB3XQyaNKxhHNzQXFxfHPCEoKChNKyS5OSBIIhucMBo5FQ5sNyxjHRCwSDSwmpWPOyvRmI1xVlHOuLOtZVfKqaKSRDXSeWhOQT6ue3HUopjOaVXPVDyKa2VvQzptS0SzWki0bmFnLCGGV06PfXmkiIKpoJ5yYF3ajX/CwL8+JB+CTkS8gnYAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAI/wABCBxIsKDBgwgTKlzIsKHDhxAjSpxIsaLFixgzatzIESGFCRcMdjAxgYQDDAYnmOjIsqXLlzBjypxJs6bNmzhz6tzJs6fPgx9DDgxAkoSFCxMmcCjoYAKFn1CjSp1KtarVq1izat26NSjBpg4GYkj6dCCHCRm4ql3Ltq3bt3Djyp1b06vAjxMCENQwwQLBACDpCh5MuLDhw4gTKwZgF0CGwATHTiiIVO/iy5gza97MubPixhYmdEjplODjpZ5Tq17NurXr1xIbI0VNMCnKgR/Dwt7Nu7fv38C1NiZJeyCJCR4KkgzOvLnz59CjMxyu1ODx5AQ7IJfOvbv37+ATy/+uXtB2wbNpw6tfz769e52gRZMuO7Ap/ff48+vfz99g48dCiZVUSiv1Z+CBCCboXGN4WSYQX34R5IF8ClZo4YUYXtYYAGAJWBpBoW2Q4YgklmiicJAJRFRJFjRFHkEkkHDijDTWaKNMGwo0UkknGTSWBjcGKeSQRC6UY0N83Vbkkkw2WeKRDC3n5JRUVskflApt0JeVXHbpZXdYfinmmGRCF2aZaKap5moBdFDcmnDGKeecdNZp55145qnnnnz26eefgAYq6KCEFmrooYgmquiijDbq6KOQRirppJRWaumlmGaq6aacdurpp6CGKuqopJZq6qmopqrqqqy26uqrsMb/KuustNZq66245qrrrrz26uuvwAYr7LDEFmvsscgmq+yyzDbr7LPQRivttNRWa+212Gar7bbcduvtt+CGK+645JZr7rnopqvuuuy26+67pF4AJLz05umAjPXmSycGGeCr779rdkCBCSICbHCZYV0w2sEMexkAkA7o1vDEVHKQnAMa3EfxxkRGeFJ6HIcspG5hSSzyyTPyK1BYFjiI8ssjCrwyAB68CfPNCkocVgAR4uwzgg/XN/PPRPdnsdAAcKBk0Uy71zLSFMzb9NTrmawz1ViDpzLSAHRQcNZgQ+f1VwNtAHLYaAdnModpt/3c10O7Lfdza89tt2913633a3nv/+23an3/LfhmgQ9u+GKFH664YYkv7jhdjT8u+VuRT265WpVfrjlWmW/u+VSdfy66T6GPbnpOpZ+uOk2pr+76S62/LjtHsc9u+0W13667RLnv7ntDvf8uPELBD28818cnX1HxygvPfPO+Pw+97tJPb3v11suOffaub8+96t5/b3r44otOfvmen4++5uqvb3n77ksOf/yOz0+/4vbfb3j++gvOf/9++x8A9SbAAdqtgAaUGwIT2LYFMhBtDnwg2CIoQaxRsIJTuyAGmabBDRKtgx70GQhDeLMRkvBlJjzhyVKoQngZoAACGEACCECAggQgAQ04gQIUYoAE+PAAQJxhC/+LFoAFIKABDDAAQRIggCY6MYYJEMgDBtDECggAAQeZ4hO3OIAFFMSICXjAEDd2gC0K4AADoaIZm3gAAkDAiVYUQA0LAsM1PhGLAAhAHZtYAJeN8V8MsKMXCWBHO8aRASoywAIUUMgt1jCQXPwjvAIgASoyoIYPKOQBAtCARpoxjhAIAAI8uUYGjHKNSkwABAZwSYMQwAA7lOS0DBCBORpkj018pSYJSconxrEBEeilMJuIAEg6MZYAUKUTIWAAW8pyWQRQowAaYJBgbvGShaTlMKvYxAXgcpuaXCMBFCBNLhIgAD105jN/5aByCiCJ58zjN2PISTsawJjCtOIm3Qn/zjWW0YwD4GchJaCidcbqlepU0T8LYAADFLIB6FwjBB5AgHkKQALDLAADBpACAwRAj/0sZBdPGdIn1rEAyDToqRTgwz1SsyBvfOI/7ciATtqRof5cI0md2IAHfNQBH91pSZ94Tl4OVZwqPZVNzYhIgUQToJ606BPx2USHmhEBCIgpAxTw0Z8GwKhHJWpQw2rGlyZ1VEJ15EcFSkqpOrEASx0ALNnaxa7aFahMHCZbnTiArgJgpmRl41lDhc69CmABERXpUYv4Q1L21a5eTetRE2CZj1YysE4kKEFeWIAoDrZRCziAKUNrWLHmtZAKcGsjHxsAqkrVowaI6QGAysjA/8rQrglQYwEkW1IH4bKvn02UAUrbyChatZAIeCo4EfBRsHqSAd+swAGOO1Qa6uWjueXiUsPqxb9eNbiHom5ID7CAFzYSoui8rB1j2kQGdFW84IxjWAfA1Y8CgLcJ4C04zxmANQ4AvIWialjZa8ZNdhWw7U0AYh/gw/p+tLYlla8n3Ulh/jpXpgL1YQJEu0eslrW5/gXwnBozlpCgc4cMVm1JFXzaY9oVwk0cAH/tq6KuppW4cOwlfcu5XWJ+FL5ORLCPITvOrpLzrUUV8jtFLCcST2AEM8VxSfsYAMBSFrLe5KOD82jfrlrTpBXNpxOLOYDdHkC39d3wDAncRIgCAP/IbfYnZK+LZQV3lc1OrKEfmUymDVFAv0NNgID7qlw++tWu1rXrZW/70XlK4Mdn9qR8x9pECNRyzh/t8Rm7KuUYYxqyBaW0GUNJZxrzWUw56nQBWCBdCSxSyWc0Yx8xusUrf7qrVL0yPw2cxwVImo8MQDBr5wxfB/uar6T06a0xrekxf/rUX3KyMEmtHQ50tcVPFKgE8OzeZQcAxnwN6FUhq4CNQqABq2xjuStg2AQowKdctrFMEeBRSvJVwFxEgIPnHO8fu3UADSizrU1dEAKcGQKahfaNnBwCUjJA2WNpGaftmF0uFtjbN9TrjJ9t1xEIcwDkVUAnQf7KiscQ0I3/fLS3h7tNA9u14Gb0rMJppIAVjEBAMPDkxgOwgrx0tdBP7CFUt1jvLhN7wlrm97JTcNQ+qti/9sT0AyId0p2/vNkynzmJ6klMgZQYAXv9OSRB8ILrgtuJolwjLl3ubcOCnLxGx3gAmH5UlNtRAWG+Jqb/XdqBx92O/9V6ib65yRLfsADz7HYA3JlmnQbgy3xFJxCLvuxe45jtt463x4/a6aSDlIszxO1qRUnFZkfg8Qjw+7HXKHgSnb2JN3iyW2XQMmy/86OQR/taa/1sAiBAApSv8Q093EglKv3Q6DxBOSFAgPJi1oxe/CisBVD06U/T6Jo+cowRy/UQA+ABCNCo/xJbj6BmN/EDNjBjCUDwgaRMZtBdZerPO3zrFlP509a//ssrqxcCQDKOZYYAPtV8+EZWMwZ0W6Rs1sd9P1dO5pVtaYdcAAB0ckV+7UEAPuQytvdEIeACsoZ8QnZ/1CVj5MaAmHZhmGdXbZV6BwhZ7CVfUZR3MfR8bGR0BGB+V7Z6XER5uHUAyXVhZ7RXBmZR3WWB4GFlKkJKDbdF92dkMYdoCBBEJih3N/ZpQKhJkFSBGZdjhkZ4drdaQTZnCOhEtkZrbaYA+7Zsr0dTzRQBQGRHZmWE0iFKeCYABZB/IZBzW8Rcc9Ziimdk0lQAyiZ3ZjhVAcWHynZUHgVY8oVTXP/0eSEliO+2d6j1YhIwXYfWb58mZQbwAHWYbckUbAklh74xhtv0ASPwW3omhjbwATWAae70h6W2f3AWblCUf43URzslX6knTk+HXIh2gA/1aaF1AKcnd1sYVa3VVuWER6QIHOYnTLF3ARQ4iJClEpgGZNbobb9ITLhYSMHmSzGmS/l2VBZWR3L1VZpkds1kb7bYAGmoiQWoRgfgUzr2Xc/4GyFlA+U1Y2nFh5A1IRoAWeEnUFa3bJf1dF/VTAU4TPrEX+5EdSVFX4tHdBVJUzKoWmnoghQHWUM1fvnYGtk1ALnXSyBwAXOmaX00dZakAKGBAXb1b8iIaaRkbGF1Ai//l5G2ZXt9VIszKEzotYn+NWdDBQEhyRpgt0WfuEVAdAA6ABIp+YHftAIkIHrAOJN0yEoqtnEsJ1GlVQGYpgCKBE57pWmP9YBhdXzdh2Rz9o12dJSqIVWlJVceFRRHV2u2J4vmNwAASZABtVV2FY0fKIYLUE5UJnSGFE+gxlu7NW+nB2sqiWjzVX8UhmhnNgASgEvFpGNw6Rm1mADqtVpPiZJzhk8Q1WyQpZJW53sMwGbc55PmdGsGBwGdBVlSBZbIJ33+NIA+tHNKZnt+55Z2lILYxVQHaJgG4INcBZs+lk6dmRnTd3pSBgQ58GnJiYkBUIcDV5JXFgEFwEobaGju/9hLfudteZRHa4iTP8aCxblFQZmbIGZG5FiDRNZp7tSXdsVPJphWA/eLhYhGz7kY00dDZDmFsFhKpWaaokZKC5qLaolx5WaYQAWJ1Ld7T2SgmEZVipdOt3ZE3ahWRLZG/Sl/D7ZiAaoYa9htIbWNpYmgkJWcSRSfwlSipKRyD4qMPYRYQCVkRQVJBWCgmnhgYchxJxhSzIWB7vZR/tQAu/UAifdVgjlhJ6oYQrZJeSScZIhp8aaDTsSDH7UAAcdQX1iD96Rif5ijWHlrQCWilYdx43SQcvehY9Zim2R9fGlGnbhXDflEUzoY2fWjXyqFOxel4+Zt2CaLPzZl/pdt0P+FSg8WiNsYpEZmdWtaqKAGWd5Jm6a0imkqhp0nANzZfbu2XW3kVpuESwJGZX0qF1TlpWE5phXqpgcgfkK5TQ1gjIn1RJRlcHc0cVMldxVXABsHVPPkpZqoZBhKpPUnAWHkTUIYgg+WAMkJUJI3XaYIRV4GRFzFZkW3qm9he2UWoyuXbYskVD3pqvBphY6FQwBHean6c73ZXBsIp9f2iF0FVOJFgmoIeJ36UQ+wAPSaaWwKf3YlZMMWgS56gpDETKDmrWpxrUMaABQVlqKVXNemRgwQAdJUnt6Ggfp2hWL1ae8qhm5FrwaQlBbpVWtph94WjRuJcTMlrOoqTsnoRLL/yKWbFpiF1IRW2GVoqBcsNX4MdnoO+xMEIEYAgGN4Z1MMq6ViSFF4OpN0qlroZXAaxYC2x4dgKnB7dbA/t5QACVRA+LIyukbJ2qFM+GkbyFqM16J8Nai7hIypFWO/patFqxMLwF4IJ0wo60Rni2lpxbO3hrN9a0ZcxaU5yEU+xZzOxmzFda/fJmefpl9ei3H8xIMKMKtsmkeLaoeIFaQRwKQWm5pRRbYNOEwpdbczgbPDFJkzSbAwK2usKZE5O08+FZGNJkzdxmAHEHogS0+Qm0nUOrmFxLHLBoQDF54s26+3Rlz6il1UdFvK60+qaxNyyoRrhJVp9Z7LBrs8CoQN/5W9wttLfaR9MQSwIrVvEypQ+9dVrMtQPxZwDPC3Shq1ZctFC9BgzDtn88RPAClUUbhNRlm9NDFUmmtGWHlh6NqHF1e/tQa+8/q7j/hNfcVPdgZZE2pHy4ZgDoZtC2xZSmmV7tmLEbu/NRtjg9lfV9VPAErAMCFQbAVdMVqF7Xt8eRtjxyh3WvREDuZ4touzfWVRdQiPZottKZhHGZy9y5YABQABbaSC9uq0VcaW8obAF2a8aYpPhRtjHsW6jFtWLgwTknVPb6VGDbBx7vTBt/azadq5KBWT0FdETHiH3yStbNqVfsu6lBUBb8SXapq78tmpQGa6PwdLc4azujhqJv9sV0ZksVL1o2uUuVUXxhmBTiApT7z3Vc6XbYOYd4yGlSebw5/2AA01k1zqXpw7q99kU7clWRbmo/VmkMg4oZLVr4OceRhHVYhlsIv8aYW4h98USnS1V1lHyRPRYiBZRFEYegVrqc1FyD93cMm1R3WFTjDkx6eVjnIXoRDwey2pjmnLX2+mxIjmVxtInJg2oePLU3IXpO5EaibMxOB5AA2gadzbr0EKsjvGV2goUqzbdcZMEULGVZKanySapuY7lOI1T4R8Tw0wumzGUmu0jbjLjcPLYPT2aROaqzFErwWdqBfay1UsSCKdaO/Fr8N3ZWsoAKHke9T7QmVWhAGtEM3/hs622cAzeYO9hMfr6MvZ5tLXtIHbWJjsjHFqJ8dvO2cb/VXLXMPZyMw/JwGbGnf7e2FqBAEMAHwmHFt8NIVChqgOjNP89NBEN9M8BIfKesICAM31ybe9dM80aojilMIvmqQYJ1mP5k73PAJ2nabiBZiXKtJqLUeABdbbHMhwzMNKx1b+yJlmjRBSZaPehoRYuadb9M9bJNl2NaZ9tVMU2c63RoRANmPk9EttfHfCJ9jtSXRP2KlVOmdgx0pk6134e9OkNIqPXUgBS2TxmtNL+WFPt3O+951A+aXQNbqLbFGDPWNUJF82TWxsBdeCfWF3SNczOU+q2qlta3RfiG5b//XYA3GFrPXRi9xp3YZyPAix4Qiiqi2k7gnOEAjSEoaMJblF7b1/HAy7lY3TOGrX/wSP2QhOlzzTK03VWy2tJw2HmumE2dSWInVOuCTKN3raIIpgtpZXErbbFlpI901sTPrEtvfctyZk9NtchWWzyOhOqhV4j43ZzGthEnCreCyz4alyyalvkMVPnXWQ/FRmT7yeyN3hD3ZSO2RjVAS/7stNnuamniTinUreH0Vgz4uMY4jF7u143qYAbFZabmbWcCa4UhxUZuygrMvW8yTdFylTvZzabazhcAyDcve7gtima+zmYhhpl+Ta9rvBo3e8JQUBqevC8J2yMwmrckShV/8kd0Km2c1M6EL+6AdgRZ+McZoWRPtbcWcs0lBu0HvYsQyKkE2H20ULwpmt3duEWHiMn4OL2CdIYE7+6L3sAHZ+ul26yNgGz7DukWbE6C+qjMtGqJ40wAQMWcoEcCUuhvuVe8eu1mqMQ+Ka67C+1FgZAcw6682759D+UQKG4GvsSWqcfx610oc17LO4yOtMSps0vBj3pJue7YEt2NLu7kTpzPvb7l/FVlhMwVyMcZjdRKcHptlUvQ/A1p26pwF3cmiZbUhu4Iiuf/L+8Bhswvbedq29yBNvtcVqhewlrBOLjNPLxDqnujOFeRMvddQcAa3ZAPV2Tnan6ptd8RB/37v/He8Qn0dCVbnyHrj1t0p53qmk7J2ydttf5bAI9upYmb8eJakS7EQs2lU7bGgl79RuyvAmTGuTHvFR/2lsTOeQFWUED+nqbtvjuGwna7wJjWPoWMydCYQmK7rWvsTC9MG+R5su/6LfWZvM+09+LIbMS1V1T/OdGqxfT2SlHPMEad0greYnKE2f/cz3PlknytG1jmmANeWXHveCLV42/dF+3+jaPPWDvuRK3cv5unNZb/j3G6tdH/aJHXnfho5Y6n2dmfqHfsj8XdWyRsEYF28dAJO1GrI5Tc7f9O0xlgD1/bKAj5XzpOqsGeSoX0QbtfBfqkZXf+XLVKTQ9/Tky6CR//9N2f3yCCzSLUZfXOpRgoadt0YBgA+EtRSFAohxtwxfuB6VMkWzo1/ety9eagzt4qXqCvC3AGFAwECCCAIcRBhAAUGGBhIwhBhxIIIFDQowYCAxAIEAADx+BBlS5EiSJU2eRJlS5UqWLV2+hBlT5kyaNW3exJkzZkIABAoQLMARQMKNEDQSRZpU6YIDDRBw3IiAgQSOPwkeUIqwg4ekBCQiYDhAQdaDCyRyBBsx60KIAwZAbKDUAdmsQxFaZWgw4VuIUAM8oBtYMFG+DP0ODpARaNbCBAkckAgR70SEjQcW4Mugo07OnT1/Bh1a9GjSpU3bXGpgrFKjEbEiHowAwv+ABqsPpm1Id4QBA4ATThbgVnJg4HEDPFSL8HGBAhGQQzRQOKhcpXYFC+ybEDtErAusNjgMW7zXiAbEHzSAMQFZ3AOxth84m2ADiQ8APIjMsMBp/v39/wcwQAEHJI0ohxaga7uwwjsPKcUIQvCg1hh6TSkDRABhoPWUawy+gRgkigDpoMKPO4QUaMyygdBLwLys5mqQKNwGiBAhBQkSqy0QY0xogRrJg45HwRJ4awC9gCRoPYcUuHGgCPNjaAECp6SySiuvxDJLlQIwwKgBDijMOKXoi2hHuqxDyqzhDlKxQqTIW4EgFxFK4ICnmhTANrIONDDMhMiE0k26YBTyoAf/DKgxoRIlgwwigwxAYE4hF+BrgA2BGyBGBRIVj9KCiGILotUahXIALU9FNVVVV2V1peMC7UrF4MjalCMFGLhoAQISSABEDwVAiNSCGhigAAMeGwACBBoVQYSBxHwzokzfRKCABiIIzDlOobwMNkILpUvYiSacDy+xeBqvPIUakzRNThWacMMGeQMRuAJ+41YAA1rlt19//wVYtABkZSgp4AjSrCu8AI1Ir4SeK/ggERkiV1qC4pw1K/ja3aixhMXjFloCyAQvqW/BJWuyew+2bNoYPbw3KgYOMDM6HGn+yzKOD5LgLWPHK2yA8A4oQNnIEAg4aaWXZrrpnvL17UQo/wsADM2KoWwXSfcSQrYABAiOCARnhSYrAswamNM6cQV4N7AHJapwYhzDA+BklLMy4IADXMRT3RjXdjkwrSGEuNuDrANu5wQjRffgiBJwOnLJJ6f8v4PWbitNbgXtOzJoD4IYgh1DzVeACuITss3z5JZoTg8lQMruuwcT9ld5z4MZsV8FKABzpJqMGdzdIdqscuOPRz55V6stIAE1ocSWqEXz64jO0hej9oDbo71eABA+GEhxwVSE/bwHEGiAAXI/DuDg4BGSfXbBdu114Ij0hM1svwV729GI3r/cUSwkgacEBmxzg5SUlLdABjYwcp7qnkW+dBgJ5IsBq+kc3ITkuP/8VCAEAtgebNbWNvEkACPt6p8APheA+MlvMEMpHPtgk0JLwWZ4rBtI9MrCQaU8gFziY1P3ruJAIhbRiKhimBAHQjaEfC04UFrN1fKTKAKYKSkoCguUUNACAehwdY0R1MMwc8EYNYljLXRhUtBEJ76EcTDPm8/qInMvCArAYRvJjxvbF5GoJQVz+RLaEQU5SEKe5o9CdOP0IpIwn1zPRq0pAAm7IpUCJoCDpguBJAVzvouIT1yaZA+FTJZGlPXxPIBrUB2XaJsFcOyPALSRRELItQPmx1SFxGUudUmTwSlxiUpJYcQOwiQpXmWY0rqjeP5YggpYEWWkM1yDCICAAo7/kpTXHEwFMxcjQE2HLpekkYO+QpeREQQC2szXfna5Tna2MyQBSGJkjMStwHGNg/UMADr/55tgCkCP8+MVcE6wgULl7QAkLNxATAmbKr4Imw+lCxy3Fpg17lGU4eJWu+LJtsEoYDUbbZ07RTrSQl4ySIcUAOwIsFAura18tNRPAhiHkGIKwJmCW9gGLCAkhrkxocBCSkXfRKYaxg5lQoUoRuf2xbMkiFsQkJG0mFq6W5LUqldVXi8lIiZSNcZYVikA/m6jH6UgS1ljyg8QEcMkqGgAA+KxS0I5NjgZIqZiXjwIGpNKFqQK7kFeYynoLIIAUxIMlBn8EEwZItbADO8s/1iFbGSdVk4o4ap5IVJNAJhykQjo6IoS2JuQOhsZtYrHAAUIQQVKa7BFJgViTDRtRKBKFBj1da+D4Q1xgoTWpaInP1BRANEOoCeTKjREiqnN6orLHQVK1rnPZdUDamnTwGQwmfMioTzl95wPgOC6uoWLUhQA2lnGRoDwu22hnjMA8QHPQq6x3lZ9mxvN5muF4iUTzpLiRF+qELr/BTCWUBpNNT5takJaL8c8dK7BJKABDSiv/QhyusMhRp8awmZC8alXbLbyplwqk1J+pRRUHvN/UGlZAEv1YWjONqr9LUiAZTxj/9iMW94MJaxeaKAQE6Wr382KypIiUQytVrGoQ/+IbWNkmetyOI1YHMhLsxJPKT9Mqn688kGSWCFoOsmi0mJAhMUJkRAKUTgRaS6N1bxmznRZWka+MJp5FM/vEiCzsEloCLu8ggg95lmMVQ6YvhTYJBeqjm50MjmVg76D9tAyYpYwQzTTUK41LETLcqmPl3hHiYYvnxKBpQHhmxA3Ty0y9mFzqlU9k35CpK7vzQ+QB6OiV3PzfxWtGAwyICFRpfc6EdhRoruiGPZCGcNI0XAPq9UmqxQVPYXRjHU6BwGWgijFHXMUYk4bHNVV2sxHW3W4xb2S6RpXMMBxDgIAjZh4TrDCrrVT3iDwM6LEM9TGZtsFXmUiXwtJ2Eip2MH/GBRnoIYIbDozUALE+r/B/k5vO7uRDhVgr5siVqytRuS4Nb5xkbCsqfNrlLEayTsjJ6VvDH4TwaqcUCBP004c4UAGStxvNQbm39opXQgTGurdGW1NdBkt8ZLytlffKldIgU+miBScENbUjkl5AAeXi6Picdzq4TZjlhEDGBzmiUdLb+3QoRQeeyHGAWsLNc0HQyglE4Xgj0uKZfA6lIMl13dBJcpPGRR0OYmH1tlWDtyoacUFWNJi3SPA1RW/6hmZp38b8qgNw/7uxhZNAsEEEbe21yRZE8UDR4A73tU+qMFQGnSlA9HInU2UgyUs2YHpMj7hGZH7kuV6fZQIXimf/xC4lVtOiwc+jR+TPi868Wc2Zm/16ELD80yGYDjGI5S2xzKzI0HSo48RhyceHxcNTlydJ8C6A+Ch7oc+MOLamfv8XjpJpRA241Qlt6oefPpHVkGwBVWPlUrWrDDop/LsI6c7DDeTPaXAAA2YJorAvuwjJ8vAoOsLLmspuSC7PoQ4tN3TGJ9RHA/pvDfBFImwjW2jr8FIoVHpHsipvxTEqgCgPRIbNS6xigPooy7TPdBpI3xpi1jDuaOhJhf5qYQhtISwAAo4D0gBorYDF73yEDdZEopqEAdjAIg7ljSSrrAIQqLoNLEADhcTF/1CCrMpFkkZnO7zPaRRwTNspyoyPP8+Yq01kSgAgpgqiy/sYcH/YQqJkKFtMxJGaw+q+SkFcCIjoQudYqigET+I0qt4crECW8C7QRZ3QwyBw7ZVkpj/ETGI0CFFyph1KZ00Q8NPHCQb+62yaIoHO5jXOJh2eQDnMBMVQRC+S5KDOBg55B4K0cQGuLB/OggLIKjB2EIhQcIXWamsWJvaK5RgbEQ6mRlO6aU5iQAEuJ2fmkFdyTI8WY3/kxZUA8VtLKJS4z/HGojV0CCGGqdf8Y2EuqmNAjEccTMrooCdmh+JAKVrSoDTEQAGYKkum8BkBBc76w2J6RBv2y2W+ikLdLoH7DGQ2igF4MaGbCCQihKFoKc5IZ//85Cnmfu0vvumyJCYZVGS1qmOg3AralE3C5QlmnsIe+QdpYCYDuTH7WKI9VibwxC47VMhPRkc4+g6/bPEolCixHPIoDyeAyKjjJSldjnFU7IlMguRFrmOOboiEKQLCjiZ9qgQiaBFA5kplHkLleQoqDMAYCvCn/iSBrmV4NBFUmqSTns6k+QOz5rD4IAKcHyfG0EQfLueAxDKvaScS7qdQ2KQukMMl6sWecILlySLP1IcTBGMrXDLmDyIcSyroPkwchoIr4S0Ivy5jtrMMwGXFMKcZILIT+mRpqimABiwdgkuXISKqZMtvoRNpvGO58s77UKKeErLWMKRCFBHJrnC/8YCSVgzDMEgFLTTsv1pQzoUksscwbs5mHlMiBSqQc9sEPeJp22xL8EAx7QcsPxogNgET4DBRo0cueDkMYiIEAUwk1ssSEeMiKw8CNAUjAzggPi8sjekFaksFMhQyQJcTktDjG7bq7UZLldDitLJzeizpZSBMX0JzwflF6qSRWkZgKLcL8i0MQhoG1j8EMtIUIU4AAY4TaTjPwoML8HQt327KM2KQaeSM3BpAHtEudk5SRZ1j8ASUAyUn8HhiK6ZJYzzsus4OLxpUAeF0CNFFXAkiE05L7IggAj4x07zv7OoI2M8T0rUnMVy0qQUjJgLIi2VIzZEmRFwSvnRlpmUyP8SfTEwBRck9I7LgM5JdI/2QMweEcEVJQoA6E5uQdI+zZLRXCy9MxDMoLcxy4taNCcbUTjE6EnC6MyE+KNDTIgUJQDkklRi5DeUubnq0o/JcJF4UhyGqVMXMr3SkwAJlBheqUykgCb/NMoijSQ/ldUB2dNMYcvahEykoDUsa07YwJPwYEtfkYjkQwwP2DX5CcRRJU750cS9gUa/kEyHK8mXpE7Kq5PM7D8GcIvyUQAyYQC/8EYBcDo0m9Vy9Q+t2i3gEBQVSQrcZMmziVOT+zjd7DVdBdAr+kejosI02lSyaE9HBTxqRY8GgIDhYtWxYAqnGB1DRBkcgq3dERqDKsz/qTHXijWkzVEOvBAUtuSYJllVadI6QwlZhBgnDyQIOfSADsC+yFvW2RmxYToACEgf/aPWjTHIYWUl06yYReSRtbmj8QpRHOEYDoUIizVa0hDFFxymKcy/F8XV4NjHBrFZEs1Ve90tgCXNhHAAIuw35JvHfiXSNbkRctmex5i36UwqjpXTnhywS93IE2XVCamrijizoj3au+WM4yAWKJG1Nbo2sIza6ipT7SAWBpAkMCxUZNumK6U6ojjAfpNS0pOfxOE16Bi8pr2KSh2Ib02qKpQnbjmffAlc1lNaHDSmrrg1vFVdm/BczRvcsjpVprytO5VLbCIV6NuI9GjSXezF/9tKIfjMKxd6gEYh1l6aznZbEIhS0rErHZTh0LZhy8BKoWNZ3eqNCSA1T4M7mgEFtWuKOEhdUKQgxPS6GitloWs6jGZUitJRVpOrH3SZUBhrnnxJJtvyEfo5jNq5UP202jez3v9dCRgDEYyL1xhhy3Akpb8dz/LixfRyV7IA2+YT0wNNJx5RED0CVCgpvGH9CQjAVhu8V4W4XENNjrgbOwBGYZMImZ4JYZLVMdtNK8EhmssKDLaMELCRNapML48VveDdK3yLMOytNcFp4fnKS4vAmV5y2x6JYSKODBliir3BOL1M4SoOCZBisGh14fwY4rsBzAasQLKw4ciUlgW4wv+RjJGlE8TASLAzieDVYTTxw6HpfZmRVbGMcsGqDcnb9M4haeI7VqGDs+JB9ggNo4q7ML/o5FuIOuDcTKF5/Fv5CgwdltpMTRAje2NSIgAfYTQEEZYP5VWhG7KHu0OIAF5LqtAlJoqaSjvGrdd1zAttjQxPJGTr1cTapddfipVRhKj+WWO6wEpOHcHnHAzHtEia1VSBvd0BpCZV/sJGzRaGMF+UgcgPlRVoSSHjcDMqrmUA3p1ksrGSUYhE6YmJxdOH4k2vWeKSpYvVNFgOOWfJRROPyAq1lZ9MRtZH5cqrNbzETThnNuBR3CwvxMJF6iOWuSxZ2Zdu/t9X6grfsMn/trSn0xVYTXvlGJmmThIP+kwXp70bfB7eyxjdOrza2ekfF4GPD4YosAOKsSgc1dQbXoFGpk2I4emdyABKhsZbh/gj8300fP3Y81gAbUUbHsEhUL6mFIWNX3QhfAaOAg68RG5YacEMOx49H6HgsKhp/SC01m0Yx5EAnb7bncRErmHa8lTOHQ5Y80GfKLwmZPRShpqQGf3ogoLm90NOlBnP+8EmZBROMO0yXUQWUGPLqhLrih1X9vkrvCQItVOR38Q+v1ZqX93Kpt7P3c0mfbZrxKvoHazXBROMjSIYhjxsc3Uznm60YMnBYe2/3FodRCmr7O1s2DBWga2b31lU7bRq/8FYZlLqHlcNEUH7p27d3KBOiiy7O7rYa+4obXO1RqgTIsbqKlV+ENFBVI1MI7+ua5DbVuM2uyObZgXNWmm6M7W8ni6uMIdFXStUr6vFE9xNznTK6ebuUyXevXBtGAMgWMMdv8U9P/9GZK2WGO8ePaFK2cDwap69572w5Kx4m/BuRMJcZN5uQYs+VCeVKfEZ6t7Bn40KHlQuajHqnoWm7z4NpkiSHiFKHBVBW6KQbU7suzcV15EGFwVwHn+jgLDcEQ68JkLBE/AisNlWXJyetd29mlfzDQVp5RwLkqktC98biBLv0wcI6XkFZN7xPVlBzF6apWmamR7la4hao6gzJ/8CfwHw2dz4fpYej0vHYPJYFPKlCFFPzVPG4N/4PWcZf2ByfJzBcZlbzigpf1Cwo5li5I05IRXw2CgpUhEjc0UKb/C96p8lJ4sB8KCTRQrBJCVCib23DWMxT6Nd2Zm+wpw+AoCESpQDbtz1g45fPT0lQkFBh034wJVS6T5deXVpxhP4oPStVlOysLd+6yWoBjFmWvXDkSs2D/DxVvN7jHM6wYzhKtUGKV1AdhjapR7cyRw80Z7+ViJalvWGxJwMrhdp/lKqAztxRg+aptp7dKbwQ83Ju63T1nbTKQGCWCiGQW9/s+hf1piIaHF+PHFih+c0t8CYFuH3heUb+xugQDH/eVruiAh3vvxm+nU7oAgtIw5ShTgMUQRe9SQnQFkbGo+RO8etgUgtXXa4jFd2RVnVyYBw7FN1r+MRtkoIfQo11zxCJy3vhZcMJTLsiW/IUuEW9vm+QlvNQ45t2Y0R4HgblZ6fagnxSzT36hyI7gKhBcRnB4OwOq9ox9p32Og0OawskQ519CnSJRL6oERXHCEYh+mlStbsp2yLQ8lXRwQjJkfq4xKA1IL6TX/2NHIs4BaPOMMngvn7Mkr7iVh7h6QqItd4CFFKAJc8ZL6bElS0fiQAY8Y+fA78EJmaRyToyQ+LNeJABmEewpodP9+qUiHtxgfF5ZKVRQzW80iomP+d/90uFHbeK8/n98/P58hgaVyel2qfPew23eCA7MyOSRX5kqeab9hPQSX1cNKtevHwan1JnbXeY5Ap4ofi6M4HfvkBgODSm7zgcR6xjB1ZAGgkyBZO2BFtMJ/BFlkh81KRfjTEb7aRTu29DAIHCAIFBAgYYCAAwoQKFzJEqGAAQQEHGlKsWJFBxIgKFBooMIDBAosiRV4YafJkQwcoV7Js6bLigwgJCARokJFggZcBEtwc8BLjzZwJEWQcQFNngIE9ERo4APFmRAMAplKtavUq1qxat3Lt6vUr2LBix5Ita/Ys2rRq13K1CTWiBIQHMk5saCDBQaQBCBzVi3CBgb5+G/8SeEqwAYKZAYhmzDtYIYcMj12qnGz58kmgGYW6NBwxgkvNEQeE3Au1gd65N+sOhfA2AdvYsmfTrm37Nu7curESMGDggWecEjYmVIAAQemKADCfvEuc5fKRvgUrJICgQAOlBHkuZV7SZPTJACozL28+gAGoCZSLfIvAIvWE6d8WIMD9pk4CrnvGDxBc4m4BCjgggQUaeOBaqhWkIEE+JRTeQgswUABIIgG2EYSTGWAYA5g9FFGHFTH4FkH9+eVBB+dZRJ6KLT7GYIgv/QdaQwk8xZpCom12X0Y6aRfRATQhANEA7wUwIkEHILgkk006+SSUXjFGV0QQPFcRjwI4tpD/QBGhhhkBUBnJkAJ4tRTcmAz995aJfjlAAXMEPLCii0gN+VGbli0gwQHJvZSlgwxl+eVCBrh103ybvRQmVBuNGJeOET0QJaWVWnoppmf9l8ADBlxpUXCBLrQfkJhlWVBDhw7wqUWJjlYRiUGxhxQGKVo2JEEMzJlSnSbd5eePAlDo50tlbsnclPVR9B+rASjwlgES3NSsSQtAy+hNXUKbKbfdevutk+61qhhTbyVnQGKuRoSZtFAxNKKoIk2Z0a4MBStAuw1S+9ibk80rLEUs9srQAoZ9qW5G6+mk6r6DdbovtglT9NZGBuw3AI0tPcAmwgIsgCRBC4A7Msklm6zW/73HymdYXdY2ute92V6GcE4JFFBAkNA2B1W8HMmqwAEMIJDnYBhoMNl/xCIk8MAKBTcRyOu+BK9eGbakc0Mjfjnieh0VpPBI+TZ4QAQUP8vmyWmrvTbb6nLGpXoI/QeBU7FKfRmpBBla1GsPihQs2HYphWOvFmwwWMQRKWxfXkw3jd5rh2J9NVQqD0y1iCAilPjXq52Ea09Bfbwm26WbfrqlNgoAwVMgHUcAhP8WVLHddqeJkNUtEQCUQR1DpXRFBLhV5OMWDv7ABhY8pjODBjje9Km16+0S5wIEXrx2q46kQF/R/0dT7mr2ZNhHsRoUAOrpq7++bjr2KXZcCUVdQP8CDawJlXa3gymX9G+fREDDGhI+PcnKcIOh2qlwULwISe8tK4HQfyzXtAWYaSUKiBmJJEgmaKHLNw2UCvtCKMIRjqV6k4teA6cFwMvxTHUC0JVCBrhABQTGJJLTGwWeNy7qMCwAeSPICS4TAdcQ7yQYPIyOrreSLPlvgdS7XwZPcjZEJeSGsZoUCbOoxS0CAIVQiZF/UhgrMOqlKQfQYEJcRpfN1Qs8TdPWC61zMwS0ESFvmYgGMIASVxFOARFwzH+COJkskdEiUSPIcA6AM+AtsXV1/N9x0AgdlsiuQW/pGajchZBKkogBXPwkKNPnO/xVx4pi1N/CMlLId23mkU7//FvoqiS+m7wnh/+LW0XuNQLLfG8lhSERoR4jpz8pqnhWNEjMGEkRdSmMkyQaQCijKc20iZEhvxTj6oi2xMpJhwEMUOIrLSS928nuKB3wgElkB4FW9eR5BHDKAOI3kuqh0iJeVJoMy8O5eqoISaiJ1CpFooAJVUhu2BTANBOq0G6NkooL8aIAEGOACDQAMZe5V0AXks9w1qh/DJFc4HSoEJCJZEOHIYDjrokTk5iQnxRx4U0UttHzyA6TfmPOFKMSADVqBHF2ixnsFirUoT7piGtkiNiKok2NIQACELjOaZxoH3IRsHYQIJbXBnC9DHBgJKdqImF25TgkgfOjJAog/0M2BpWMjeQBEhjAAIJkGZKiBFcFkKRXMzImHrF1XCoLj91g6iWiErawBCpbA8HqrOxBQALUmelI8vafAdDvcTxy6UuMGhFlQU6vC/mOSIKD14U47j+EowgcPcsSzBlRqRqKamYcipTpMMQ3//uRXOEWK7q9xbC+/a1t7rWmJhKgYLK9jDNhW6ecTk8vCrBJXIUHJFNG1KAyS0hk5jm80ZK2Ifc6LaygAl4ZPuBH3N2JeC0TLLQ6BCrrRAlkWWLSnmwkAQc4gHFqV1Pg8re/ablXdtI7UhIp1i+aPW4/lVssWRV3V3uDCgAnhxDQiuQBS+UVQ2SH2Rxx0yXo4tRKIv8FTb0Ipm4NUKag2PTKSG1WsrVjrgAQ4N8Z0/grxo0p567E4rtdhrokAm95rPheimw0Un3t7E0WUL282CcCL7AVwQiK4pE8z4rveYB9h0YR5ha4PEjq8kgUBOSTRO+VDT2oRHiUkxoLiAITuACbT9cxoSzgYlsyYYPKA1EBu0h2Yz6Jaa35ljkFy0FiGwGcChXTk1hNh/e6MUGO7BCMUHaRInlnki68TPHWsCUj+nOFv7hiNNfOwk1tEGzinBs3w1nVbPuPPDfHqoZuOJVeOuKULaNSgrDXIj+USEPc5xDPHASxEQHBEWb5qpfo8C2/diX/JIZazxgFKVHrk6arp+n/2mYEAtvGjI9JLQDuBSfVrq4Nq8+ttiWbBMalOo8ZD7Lrd/fqgjjJ9UhkRy3VFHFzCDjA0Gh4rxMk+i8SXkmzGyhp9EKYIhrWy8fqhj/2duy8hPn3wgfmRcqiuWPQVDdt0g3ykmH6d+nEX6eb9mEEeNNyEmJAxv3Cl8lIDrNtSu1NaHC04piL2blsYFnXtPB7ve3D0K6IsXlGZIVEb6nhuRMDem2eDP1oANkJ+EEPib6Rx0bkXP8WCm26EOEywOJNq/q3FxgtBEjdu7YzYEJCpRMdfigip74uQ0i0cCt+qbyNWUlyy5oQtcpqJeudmSQVsK87OXYhdecZVHOV9Jt8/73rb668t/Cc68nT8k9EqvVqRc1RF7l7NARIns/+7vPgKbLsSE5SRdZkIoTlBUkoScCvj4olFYskAt78o+gHM1+M2eUppLl0qry0l+f0RkgkkgDm1+L16F+qkloOc+3SniVQU06To1fRKDkL980doAH4RYpIG7IA+1V2Jy1XyMMvUpRdvSXmVZSe4BHSdJFIbk2PgTGxwJiJ8BsqaZP3bB31ncX0JSCl0JVvHN2R1E7+LUvDCROJpN33sUT1cI9C2BJmpN9I/AgYMcgEPo1p4BI7SQ/RwNiQvZT0iF3o3QQZIQnh3MUNcR9h/BgDKuDl7WClHNN8xVhFnBno8VyHbf8OBsad0mWgitxgQ+TRB9rJEe6FbZWUA4VRkmFfT+TL8Y2EjkhSuCHSYxDdAyBAA5QdgCXEvNGLS0QNAvpgWIgcBVgAHcIhkxzTFC7EIQnAt7EbzOCE2SXEqQSiGzFhQmgGkHmgZYCgRWCUS+yfugRT5ixFbwBP+NgVXmkWmK3El93Er7EGFHmMoEDEXaGWKSmAHYqFyGHABLRiKiKI7BBdqwTNv4BXnthbUSAEcGShS0wJ8RliixRXnpzTZTCiv1FIXjhiS/BUnjHF4OxM59UWIS5EpxzEnnGWr0wIHW0QmhHHmVEH1yjEc+HEWzTAK4LFAp7jgRCe3cBgdShSA6j/jAuBl4gRh+xkFEslITCWhzFmlUsZ467FhexMYEXcEEGKBIM0EY8cpMONRhB20kkwSLUVSihGlEMK4k/pVk+8xxpCmDp2RTp+ZIGcGcDoBRPpIQoGgIiJxz6GE1flle4xhDFGigLs4mZZW4MkRgK0XW15kxIxoyi2BO2p4EgApdUpkQIApd2hx7GUnk6hTwBwHpAkVSeJ5FaEpFUKyIFtSe4M0HJImIR9WUuOZUtQGAXiXXeZhLiU4Ryh1r+NVm+oEnMgCT7+3E1IwENWoEVQpebkHYkoU7iJSkMdWEFkZVZgpWHmRgBIjySixMydoAyqYd8YYUbYn4clBllq1Hlk/1fw1B9F4AAEJoS4wORKXZqYvMQAyeKZiN5dIIw7RlsULYQp1SW/SRgUESZCJaZVIKZu1kZyFRMNGeBTNABNvAUYRdBCJB0O+hL5AA/Q4Iw+bk9oqkhfmKVGqh5HDEAFRBTR0OQ8ickDLN4SzhWfrYSVLUQSVYvdFNLjFQRiEI2FVU/gjFIYNkhvVgVv3mds/GZMaQc+qss6BRpGFhM1ykR0UsQN9Yy6TKMh0ZtfxNd8MQABoIhFJCi3CcB2ogp8eAYOJhd48aWHvMwy8gdSEQlDLqbdqMw73YxnHCSzkN/9VKTi6OdU5CeNpgWKipEJUkTKzBnTOZJ52AxlMdnByf8deWZEYyoEWxZAEVphtwVAv0xbRiiNUmSoANgfAUgAdnDXHgKbohXezBgfg85XAezLdI6K3bQgSvZE+22aXO6FjI7TjQKAjc6pWexZA0GbuOSlEFbHmerEiByEuyGABAhNXIro8uglQ/xaKfpI5RhN70kAVSlERFhprD0GST5SsDDo9vDklh1oitmNidjNn/mj/IgbQTxVUN1ondopWXRpA1HLpiCEKbGGMJoH5zhIKGoVxUyGu0mQMzHoW8RFlMaXEmKo4mwSKXIqQmgWq5RcozKHoQwpE0aAR4TiqNoNT8ZprMjUnLaqq4oFf0pPRcjOrlDXTGjHcrbE/l2jkVr/oMm53TPpxKxC6kswhpXSRDjqxVsJC+81xJ8KEGkSRJOeB1+SEo/aDkvgpvnI2JwGQAdwQLjOBjs+E6lahGZ0IcPxTLAULDRe1xAVBIv9S14YK8aCqb2I6r1W4Ph5GrKeT66qV2Qu0H9Mp8nqTgopk1Iu5TYFRdlhk8MqVABsgAdkwAZMrPqc2RFxH+OkbAqVh4IlhFQWF0F5qg1tVptAFFKIhmOgXn6MgGNM7WTAUZIu18EVjxfhDHRaCHWlneTUBUlSHihRAAZwQAdYgAM4gAVkgAccLdKqj3EMzb8YBDDphYj9q2W4ykReZ06eIbMKlAHkGgat65ZVkEK0bEuw/0jHgGqEeMoruRu+qYgzle1faGNf7JrHMsUBSMC5HBQqihAFFK0G5K0DaEAGYAAF/O0IwdF7fFr0bOJIoMkVxsm/JcACQNvgxqQT+d6PFEDAsoQiUsZCBAfpZmZkdYcammGf1EnglWtRPEcZMsD2WsZBrSrbDG3R4q3eRqwe6e4nlRuSNEV5Lsp2JcVq4IpWYcaUBJS1Wl2khK6L2AcCPK5IQOHqpZFrWa9LtOeWtGfqooRx7NhhOAul2SrCqgieZsTrlgzd2q362m7fvqH7gpI6WSxaAux1tClhnK66pqe/oCzuOM38KrBfRC9LMA2WSUBiKFnrEXAGWgfAnS6Lcf9uQzjTR7he4ghFmU1ScaRcRTxnCpnvpRBtBsyu3moAB+DuCBPWmkCRmFZY3gBvE/PFeA7Gi8beDNOwXhCj9FoTBnnszUrV/ZQVYCThzqbqgN0EaETProRHHQ8ey52RGqorS8WpkkDJ0Hpw3lpAxB7OFgNX9cRVCrnUQDKa1CIuUshngyKYcymFhJKlMcqkvF7gTalxvnWrNZFKXVLEHuJIoHGOmj5eXKCudfHs7olRXBhIB1tx7fKt3z4yjUVyR55tQijjSmzuY1Rsc0mplyTAAMscMw7A80qRWxzANCvES2YuN6IyDZusj8XHjoaYyibEJ25SSsJvo7gmfKCZT+D/BvpW8SKzb+4CM8jJ3jDP7Cj3pXy8TiYh6ZEuG3xoKZOSTxLi4mlaBpchhXWaBNOc2Yk6URzjXKlASMewKzB9ir4ZHPaeypokBibDH6kFrVp08N0usi+LMD1zXSXNSQoVmOw4ht89pfoZBjY+huTUdGjB8C2N0WUYmU5EhskyDZ6VSK/QFhMfM4FZzv6xBLU5s+X8yF7x3rjGmDpXxMEuCIGZRezCc97arhandCrCFmEC2d0p36me8EM9M2aoy2uWi6JG5MUu3Wp6jk4stEiMVaxsWBxfKMGqiDLDHkUYJfWoRgOQivYUCsBdSUUjBOeVTxb+kEudmSLhj1egb0mv/28WozRYv6LiHkUUJx+SHstkPs69HGTHeKpRATCgHfRLUCjCsTKQ9HCdcI4PuyCiJqxq2RpABy9d1/J27FqIwBH3MWxUXAVJf/BJbzaNAjHYjNJTFIDSPAAN+mU0Ps4dsVQZo4QEP7BFZDT6FRxDw8cCiaV5VFJbIaJqC1oeVgSk+Q/vhufHQIAK78XxRiQpHlgBULEVM3IWz7NyTyxUysclyVt/eBF1PJqKLECz3Avo7StLAOUBTCpSZAhI+YW9nkQoD8xKmgfN/I+CHHZL/OoxGy9q8bCDDkawhAAIiMAHVICLVwAWO/J/P3JDvOuWtaNi30T1+kWyUMepaBr+Pv/0Q+U2h/PzYERpeAPjParIpn5sgyRhLw1GdIzIKqPEBtAAi794C4gACJSAKs14SjsE+LyeliBk7UiiqUKWdAkLWgEKKzVIbftSAkj4eSwAvgWnRVw4le3jvKV3GwIiSpT2yr7p2CLuUh037WoAEaBACNTOx4H5I7tQmTqEIp2fSEgwj+VHcBDNrHJJFb6RIs03h3/xlpHKpS4E5u6ER5xYQmQ4Q+x1uynF+awEYFjGAF2354mhRSxAYgSsUuYF/qYJ3Vax+vI37jqerAMTpI8weljo/7jFgS1TYiyVn7UHa3MUcLcIUMrqolGE1571U7r6G2lT4G7E40W4nwdPDDf/a0pSz0hIjiS1ZvVEQH4JQAmsOAsk+klfmqyDDqIsu+4600Hec1RFgFrbL5CEphWBWacjdKWrdvyqSKSAF0dbxPhxjlCIuyEyiMQFxTVXB1BAwJawNRFPYkaYCBxhR0SEAAqoQIu/+AdweQiknYweMsBPbEPhIJI8t2gYBEHzJRpFyo67+cxwMhr39qxkVtSij3lXhCLun8Z/HwDEba740tgdly9aLVO3ezETxL2LgBCkAMyrgJcTcwpKD/TdfLga1XqkcD2R4VEYwIQ41g95xFkN4XpnWJVofT/vdk7fpcSncWMXsB5tLBtG/ffVJxvGUBHfiFsTaBrxPUuMJkJs/4AHwzyXl4DiPVispPdUe4zau2oo+vvqPJIVBZRTkgg/zctyPgxzKGXoIklpSAgExGNVafBZJqtFeKAyfwnijx5xa9O/lCldvbqvHgXQ1P5BaIeKi4AMFDv71gDW5J4sWQSE2Aw22Xzo0yimU76AGz2Zk2OsSNpyTFXJIwXs8zpywEfe1MXkRatfDJ8G8a5JsHFnL80CKbhcm8RVZ3fuOzpABBA4kGBBAAURJjQwQICAAgkaCigBYoiMChdbiHCRJCGBiB8JCGzwkaSAkAkTHii5kmQDAC9hxpQ5k2ZNmzdx5tS5k2dPnz+BBhU6lGhRoy89smQ5IMBBgiojIkAZIP8pSQNKHU7VupVrV5QMPw6A2vDA1gQMDhgYCJakVK9dFyzoqkDu2wsDCSA4kICgg7d/zYKFoABwQQJsBQwwAGGlW61VsTZ0XJjrAgEhUKj4cPHiBxEgZhgoQFbrWNICrypNmKDAQ4KQVzIumeBobdu3cefWvZt3b6KpI0dk6pSgAgQITk6V0DaAaNWUoUdHTdJ0Q7VvLbNMjjAvWsLSwWfgoNUveMDAGw7YXpgAg4YMTiowAHXAZK3B35svSAFDBg0OUuhMBBRCmI07Awx4ACEEwJKgIPdWagCh0UgqwIAIIjNAAcSG883DD0EMUcQRScQJAfwiKgu8BBgagK+BFir/qQD9aJzrgAIOUGAkkhj4SwGlXkQou4iu48oABIqk8a6pyqMsggYKQEBBryj8yL4aBVpvq+raSuC76DbwwD8HyNQgAw82CAAxloIUCKKI2sQLpRNLqisABd9cicuwqGLtoxlLDFTQQQktlNAdUZwSyz4TGDKiHheNdKoqI5rxrzXhRInSxLgioMoBvjSPgwyYhA7C9LT8qiQVJSXogQMGECtVgTYFCTD+OOjAAjIt6IADDCjQNLjt0GvITq8WgFWABghrr6HWlML0I7RYOsDQa7HNVtttc9oztlnBWy7aVskliE4rAXPUVu5WSjIhRNOD7gEEWnNsyYSa/KtYAVjd/6rWKyWlVL2pFmCRR5QUSCCCMMfk1Vdg39oXsThPTdE82fCrVdqSuO3Y449B9hC29wyMdN+SwIURgTjL9eqwsFJGiYDqAA7gx5LcNWylY9+i1FIPOkAp37e4ZKqrfWPWL0+LH6tSQoI2yPUEzj7oAU3zzlUsrwZynFDGFVFsaOmwBQjZ7LPRTjunABpbaVHnglO0I4wH4LnlTqE6IOmpZi6AAbWIKwhTuRG62SqURBvANXNLdiBYhIb2qui3srZb0orjrSyGF3Ld1YFeOQiiwI9qJADBrri0tqvAnwq7R3g3rlDt2WmvveNz/2y3RtyxgnQqeDm9e1ECJMDRcn1JYv8ZIUxTLbbfWi3FQAN8Kdu336OPl5RLSwtiWIMRwGdhiSLSFLxk4fFCGTzelYLgJAMYiL1O2+mv334Ra8XKwoISZyB7nTOmFQCMTAA5Qx90NvQR5f1lAQyAQAMMuCDqqIokyanV0wLgOMiZCmaFOwADkCMd1lWvJDHAQOfI5AAzvYAHJXFQQRozFeIkqwEhNM8CKFSA/xFkhOlTykMk4K78rUSH9zPiEZFolAeQLSoD4Z27eniyShmgUZ1aSQQOqJ9a7Q0lPeSKweojs5UEaWwCCJL0TGenyL3lSVEiXHPCEqosCmQDNBDBZiqQAtBBjCAb4xnGiMQV3A3MIJQhABf/u4IhlhjQcD8kTBIhGUlJ4sRbw6JKSYxmmNNNZymIVJP6BuLFOfJtjKO802N0NxB4YVAgIxid+zLYqq+JEkveS6GZinCDtGhFivziX4Ws2JLovBFLBEiAXj5yPRixRIeHFMgCCDBJaU4TkvLDCl9Otp6x1E0ga1KcBDwZgLEp05RvIeAC70bLWiEEfn8rCAJKUAHhxNJkKwlnV3ClK4f96nGAKeOjEBIBsDCAmAX5ZyErQyH4JGQBBrhnR44TKh2RRV0N2c65ChBNam6Uo7MbYnCwaU/G8QmOwpHjVtIokLGQs5w9A2V0EteAHf7lZYH0CkNaUAIirdE8J6vZW2y5/08+9hRIMnvLQQHTyOANJIGnGZ6MJjiQsQ2go1W16sf+iZ+TfK2PJcvLAWzoFXEJAALVUR4OE/PTcqpLrV15IpYSAFZPNiQE8pQMT6NzEAImhosn1GeZzlQ+cuWPe9IZWWG9gjkzdhVdCI1O/hDVL6Va56qVtayhPqoUx6AHVDAsSVvNEplMLnNaLZXZjdwpnSWSZLTlBMsHQGCdyBkzAQ91Ikt8N5B8em6P/Tygp8JygIIWpjon5QqmWCUxhNCSK94awANOmj8EXJa61Q1RJVkLJRwlSQEfDOtAAGkd6VhTAHKslXHLydzzrAS9B3xTXTk1NNyBlpfhlcgLGqbCwP+iT71UmSl0DAAlvVGmVi8MAPtMUqPJfuQ7xFlwAa0bYQnjRrElweBUZzpVr7wkIfgJ1WqTZ1qBtBGcNcqmiA/ckA+4ICT52lcE8ckEzXCmAh/YL4pxjBe9wFiqJfmScmuU1YactKKJmfCRkSyUB1cpo3caYqrkZrBl2XYtkUEs285XTtMQkjtQ0WFX1nTlli5AAUvKl2JzqxUKiOk/vNLAgEZH1hy3tIcV62xpFFiQTaFzKz0UcmsHwt4kD5rQOUGwSeTzpQrnhyBSliyVG83aOCJEsQ2FtHQqmmbwkmSmxWpvOcVDT1pxtXtsvuWNB1IdHs+5KaU7ZgTZB+jCJaD/ttzZURhL91FYt6XQvfZ1TBB85b0KZ8BjY+XuKnVIvXwXL4DEmKax5EUEs9O+x5aZBEB46VbdJV9cuoFfefsw306FQQ5ZNatN/KeESOvcD4hArbnzaegA71ldm0oCGOOiX++71wS024NZW1MGt4rMf4kAWDcF7ZZNu3UrkTW6uzKqfM0ABXfkTG8hzh0ILZQyltYPiJlGEJa0FT0sfSrOAMNvlRN6ix3OWCnnvGBtJ3VVrxlXxgGDAROYwHMqtAEIdFoAeQukv5Jaz8hS1UAcraepvgRbSbyGclKGeHXRWXDO5sNsoq+c6xPGFMDIq5RzYzoBY+ckSYYeqS1vR8j0/xVe0XfrMA2Q4HEP4BDOA0Afx9SKVQTAE6cZ28S3jJDhBNmXmEeq7ruJFC+UKpKzptx1yV9WT+xi4jwRElet07RKsOTKgocrw54yoIaEy6rC5xxU/V6tIHQXCPvcXpiiowRzbnG4OMFCb+6V8eHYIbXh2dJkPLNWeLxLM5dOsiaNTp75Gy2yMouMH26+BpB83grwEI8Q4Jm8pSODwH8PGHfAemDcKLnA9AIAPYgT8JKYFHJETlL4xx5OZtAUvZss/BpPOsWZWim300Wu5srIWpqvAKXpnwBt2KIFixAC+QyJvbriAU6F+/hm5rRiabjMlFQP4yiDTIKF3qwNxU6GMP+WwpJKiqTAw8vMDswArznA4stQ509WbVa0o2gM8AYjCeBw7QTDJgSxjOrSJZW6ggDsL6lyCPygg4Y2j1xUz0xYj0YcYAOmp4xW8ICKLCQOzcoCT2zwjgB2BAKuY7KSRlrSLuqoY3twMA2RyL5Ky2Yub4FiqDBADv5aZmTKEOfEjwPJxS8sIE0qBvVELLx8B7tY4liAK63wbiAeYDsUq61Oj4QwaYzUcBLt5wdZ4js+SlqOp1ZmynS06WBaZqxCbs5UEGpMTahMyS82wAJQ4wB2CcdGSOAKQFEATjjgZ+kSAgG4BgnnrNr8ZSmgI7PmiRKJ0XYE7rOyRFoGQBQzhaH/QHEqHgBR0uxclGn23kL30I1CSkAzUmj1BMu0AKA8+hDnIgABeIaK7AZTEMVFwOUBKCX2cozeBmxSmAnAUIQAizEf0+YQs4yK1EIBIkAtEAzaBkhZdvB3nlFO0IdLfDCL8gkHqOYzeGDDRqk8KACvxiz43GqCjKNKWIpL7hDHpAgMUSKrVnCT/ARF9HElzeYYK+jzKo87EKOtCMgCO07qDqgJA0v+FoQhZKoiB0IDMADd1oQC3aRF9o4kDGwLJSPlyMU5DtKglOKkXmUllvICcycrVYMlubJjKilI1AknCYLeUuZkkFBHBgACrO+oGqtVxG/1yk+c3AYlgIcX9aNJ/y7ygKBrK07mLeSmyFxOKXNsnGzmpOit3hJAUTYFApawcEQLK6iqKyUzW2InA7UCMVgK5sTopbZCXQCxOVYm9O4kAiLAJgNgA8XNK+YQAH8JmLIoXzrACDTPNAtipe6N8fwJNwdCsaqwMBZAAg5gpjAFLBQjACEzJAbwLwjRIZQiAibzOTGrd9jIFWFMM+kyIVcDSdLPx1DCHT+iNwtDJ59wuY5G8XJxLg8oXxRgBb4zS5SF46IDc1iqonqPL9GzOITpMW5kcZSzDTcTK14RPyREsXqPdQiADaMFQvQNOhlUUN5PAGhEASrMHK8PoKai6aSlZrikRvIwNSPFmLST3P/uU3jypQFEQARI55OEg8pqUljCYgCYpTA2pRqpAlb4U2YQoyEVoiQYsCNQZEaE0aK2xyuaLmxUpEGRVFAWrSH0I/qS7TEcaivICw6zDKhO8XN85RvdRALWslVGxigXpUlWiz2JJDntsU6mwlvskh/B1LFSTSy3QrF09DD1pBbhr6K6VEUvrymStE9JZAGQKT8pgzg0RlDPNDKgLA6n4i2dUEsLhy3ubI6WJvv20IdOFE4UCwKsTjd31DWTKkr1A7lcylM7IuyYorsUB6xKQlMDQBR1FD8xyaH0Iq7cxk9tVURUCu3MQwHXhYMiA53s61g6lJ9klCRYdZS+CjzvkrH/7MokhnT+PuJVUwzqRExUvQL27u9Iyg4rUsIqIoABQAg4V7DI1CKlMu1W0fVDpKoAYmV/wINXI6ITiUkBs42XPqIEXCC/GlU/FiwkI8Uaa8TFGgIEPsCX9iVPZYbJkgapTItLkNDuOoiNpAXxWANGA8w8OwJUAw1lTsV97Gz50jVkcQOM/u9ZzCNIBSD0pAw+z04IEeIhOcMHziQuu4iBXBbF8A0RW2VonKMCYuBNLRQ8FiACyvBLTSlwHgCQ2hQvYEVWqmdNMqxKs0QaE68hoCTgduTLRHZrbSMLm9KwJkY+sRJjeRCUUJNY769GVkI0s4gw3TQ6eEp6igMBJMAu/4PsIzyvnG4RLcA1SQA2OtSFUokOG4luIGbU8EYjdgQGZLm2cYMiOOqTh/gGAbwjVxviKuGnhkICU9ylJCZCBITg1J7wb2mEd+DxbpiHfxpAcc7Ni/BKg+bsqxC2VcZGWaWDXiCgeOA0IdSvIGTuncgGHx13eHvCTpeqz9hDgkxKUfmjB/BIQFzAUSUlWV6xK3JWLVnt6ghCkQSvMPBqFROxpTCJXGTXcCMDtMroSkbQfMImMon3fXUCXgW3mEqiYj73B1IIdGrAuy7EbqEDd+Z3jgASCQkoSQanA7ViHMN3jtY3r0oSb40pOOjLZxLid40zbGgDfjX4JoI0UssFd/+28QOmRkBQQLD6z5QqCh7p5UZrBFHy9hdR0A13tyswEnwXOItO7OSmhU57dStWGGAQ5HD1LFqmcoONWCaMV87IBVd+gMY8AwTiLHMUIIf8lUYmh0rI1jyqI3LxAlKPRXu9dys0QHoZaCSiUiskVHFmtztKTFJWVVL+iUA/okdhKvhGEWgb46P49IiNmBmVQi5mj7bWQzxrAKrqBDYsU3iuWJCkVjpulpdWhneJD4HVDCONBDtRQl3atEhtdyu411gkBcHKqOxWJpwQRG5GplFmJQvlZ7r42IjDroD6EzNUQAZ4y0yGquHS45+SpeYY2Je54oJKxzqtDjFs15IDQCj/oXXgYJiZmzlzIqW7uIY2meprKiaAFYItHIMhUenyHOKVjThsYsZ7RoBqVAAFZiBiBGxzia93H4NeIIhGFheLubPVwANTqlhmKLcxzaVeFAWZ8xI6FHUqiNlHZ/iGAwBz6mI+Uos9pI7eNNUAJABJCKeXegecNdgSEdUU9TWw+C5tHzjP0AylMLN0Y2UeN3J8j6oBGkB5eAebI0VgpgSZA6ADPAB5AzPPtqKgLY/+9OOE0QcBIABG/Rcl/Php/DhWogovUhJFFgCj4RdeQwAERMCWhSouMQX11CvAIMB/Wla8tALNECCfteiRXdRklVcAPpNc0lcg/EIB1oN17gUw/xQraeqaBV/SPKSsAahZUgLMYh9EpeGV0QwvbFwZqt+XJD73eTMCBHaAixoRSxaDOQyqbwUCQE1pwej4NoHQd/s6sbhqBF4we0KNPQBps3FUpy+5LdMFVIuFi3G2s9nHd2LEBHuM0zCmALj0ARCbeE/TA1jAiT8jiiNCWgVCqRIZpgLODNVaow8aPB6gCNetniuUVEt3qFGarr9mAZqVZJZFjuYaMA6OnzOvcrFjdd0VMA40RfgxIjabdMvFm0JpZOrCa326m1Cu/3p7awMA3BzGA1yAuEGFDJGFQvgaS2rFXdgHfjBbstniwNOasJ8ZrWtknvuEQlcbXRigu6k7AP9GBaHHCz+uEt2K7FhquzgDwElXol7vZKD3eL8blD86mvxm4qPPiabcGBkJgu9c0j/145Mp3KDAYmlHGUuA3Jc+ea0TWvEggMOxM7xBPGJQZHZHqchCdAEg9TuWM5WuiIdgvCt/OwPCjZ904vBwxKzniJjtq0fygl0bOTo0kW+KtVJCST+KZmToq50OoDQDoAGcPCwCB2iivDAelA7/tUY2ZsCNVSS8GULzbpJD6cspUfz2VSjsG/NEjEsIx4/p+BiP9afZxCm1glKofEtkJNaIlC3S4s/pvCBgd9C9wqLTo5MPqJcIPNbASX4cCmoNQtKbL6gsQAPI/DZAMxKjgl3/09uUHE8ms9hZnNaeKSOuJACuC9HI0ZRG9iVQSeKm2mIErgkh5NY84PtuPqp6naMAULsgAJW8yY0hkh2lKBdFYiV+qIMA7PQsOvzFfb3XThOFsJQD0gRE2FBbTbfO0fgAGqCNbyiS9bk1Sh3aucI7K8Wdx33HgbkCJUfdjty4j3wAHOABTmdpFO7VYb1TDnO0xsYtys1FGL17iaazg4lsNmUAllRsGqPNo2Tfk4zSA8tBWSJL7tN0jKtYivq3jgP8lvOF9WPNZeaYiHPs5mPPzfcj/gvBhiYvMDwhbLjkXQat0kM+SA/BqtJKyuhL8gLeDDqG8TqZsGJ1Je3y3LxS/3T+bDyAFWsjzNust7IFslqesk9F+KpM7f+i4q/VxwmamagzS46D1vHY5RvfmWmqFLkCACSGphFCgbn+qMDq0a8Jk+xLRUSxZnJYSE6KdyQEKhu90Q1g7j1GCh1gPISiv/3dAvYLZLTjsm+vOj69gSFustaSW287PXCErGV4RTNPKZa2rBXI8ruHFTM/Aj9Fgh2u5l5shEZfql5Qjv7vei499fWE9bWFAjrAATqAAnxCxtsMLmdn0YC+EIWQ978oRO/mWbWCh30IzQuXYAxcS1Yzi8vFCwFCgIABCAI4CIAwocKFCzVgYAgxosSJFCtaRGggAYEADQR6/AjSo4GQAv8YhEzAMSQDiCNBQmDY0uOABwsVRNhYM+SBkAMMDBA4IAHJoSAPADiKNKnSpUybOn0KNarUqVSrWr2KNWvWABwcaNgQNcAGDxksOHBgoQMHDBS0un3LVAHRhD+JnkSYQAJPhgQUMFxQV0ABnBcLLzQJckBFuSQbJERAVLFhhjQj7iS6crJmvn4RHtxM4fPm0aQvxhRw2W5IBYEFNmDs8WWAAiELQEzt0fZC2iBRIiTAW0DBhZBjEyjuMQJCBZ2Dqwa5AK706dSrTwdrPTtUDBYseGhKAQOHDma9ZvCwIYD29VaFkjyQUO9zjwsADzVwWObwAK0FOC5tkXsfwbcYYh//KQAAQritBqBEqi0AEWENViQaRgngV5FDE24IIAHzqRYBa8YFoEBHqOEk30f7KWRgbAyRNAADC3jY218HHOBbALj9p9BpHxrFXpBCDnlVB0Rqt4EGDmSg3lFjZaAkWhqs1daRVj4l4EcDbCTih4LxlxgEMi5k4ke2+SiQhBwu1J+aFCVQwAAHdIaRXXSuGYBqDCFQF4F4MiQaARDI5OZCof2JqEXIeRkShAFEgACGCx0ngQEEtLYlRFkK5GdCzj0nmXoR0ajiX58S1UB0V67KapAmtOpWABl4xcF45aXFQXqw7rpUniEN159qDRCApgBuwtZbBCQViicBl72WkALM/150KlCJzmaXhIui1qABlkok2qe6TdSBB9eey9CCJDEAZwEItCiAbBOdVsACJg4r0aBaSoqQsoxWtOlAElULHa8GH3zVBFUiDNUGJJBgwgUanIcdwxYDQBICx/HE0wPS1sngQsUKRqpM6Erkk0AQOKrZA+oKwC+eIwus0LKknbaiQp+V7NGdEV1w8rkK0BRwA6l1ilCZEEz7m04XuRxSzNvaJVmCEU0tgETA5UYSghd//fUEGYDdFFccZEDeWVKqhd7CZFtZ5nz95cwzzQstMJRj8OYYdEJ4g2TAAexWNtkCDBQwJ7oGVMs3siKN5rhgB8T82d+AV5QBB33jefSl0P8tR3hNEbA8UcBZX+SvmWR6mTNLtVGkgAF+9TfA27YbPMEFt08llnhQlocWBruvV3dkXXIrakILFhAzQsEK4BufA/FtkdUNwpsY05tbdFlQk5JEumEvu6Zz0yFpjxDQ20+4IANbD9S8RAhAIOe0WBf2co9ejkvRp/EHEDgJsMxHBhieAa10gQk06YAMPJjnnjO5ACzgW1frD9ICELBQ4cl6htEXZtbXoYjE7Uujwd5HcvSZU10wImcDYWkeYDMCoE8hzskURCyXm8JMTYPjCwmPtHaAAQxAXzEqVNz85CyjbaSBTNROBibAgSZKsVXPG8oAwreQvJwKi5+a4eZGSBL/F/7pfQPxIkSw5hEeHaRohqmQGA0TOZhpBk0rTNrlLlK3FfXQIwnwWUQ8GLUsNoqDCJmiIeFCgQk44JCMFBIYczO1Qh3Ph2ek3wHMuCYFHAACDYjZzDxCmgT8hHlv7NGFOlRFEhokJSDhX0U80IFSJs8ixfNjRdSlwT2NEosUOQ3ScKgymdjyjHqiodP8xoABMK+RzKTKBF7VzGhOJ44CgdOvGEJN1RFAAgVgwP82B8ycmS6No1kQhgxwE1mWJmVD2c9BwOhKiVjNARRQZ2HgFU/u7YUvByhAJ9fZx9t8BAIPIMCMDPPIj/ArWJkBIEgQIM2IKsUDEzCSRC+KFXbO/+eCqRxQayDwzZOdCiex24i3dASSYVKkblcMTEMLo4AFhA6E41RZ+QJGvYpgQAP2nIhBN/KA4AxmM8AUzl8emqjAsQtgDWCAchSSUD4qRF0ICOLzHoDRiFpgAhXLqlejskeQSEBkjLomRAjZLJJoJDidglP9RmO6/owVj8Fp3eZSeYDQfSZu+aRQPXuartxwyQC8xJ/qGDLSUtawARpDabYwggDpxYZgAingV5n5sMtq1ilhpeRjynq+mqh0Q8UTJVI59MkTzrA/OS0cJpdjl5mKJgENaEBrLbIBC2wGrX9a3mT49FaFLOBG8SvtG9EogBIJS6P+EeIBkFvZzTJyAv8akK51j+Krsja0WCYcylMBWJeenOtUqTMZgDjYH0AWhSLltdZokDPUwhSPU4BakwXSA9iEkCSkuwGJGY0r39FOhrIFoGxkEtJdj1zXkBMQ3oI3m03VEEYl2JIJwZ4audfCsTUJMJ2G56WlmkJvIvfbzLb6OjCe2NWNAMptfs1HYYC9rjCJlacEBUfE205GvUUBrRwdOxQgPZiJExjyZuf7nM7gFCHzqx81K6OuOpIWAUbzC5pyOaHj4AghBJ5IewUymmBVNYIVeWBlwbWhdrHgIRtSqo5p+cH+hRGmHL7lfTYTAQbYNgDQneSHdPNJIzfRAoLWLI/n0xkw/jAhpsv/0akWnajhTm5uK60qf33aXSyz6ZiGQbJAXlo6CSRgpgoBAIs3E5wQVIDUm8FNAVhd5o5qr1qY3CbiCqu/oaBYInw1s0sC4CwhGrhGQG5loRv4nWN7FYagxcmp8vloFnG61GvaEVubFJEsxXcz24zxLKc658k856m8ncypJ7OpDwShQUUtwJuvphr+ljhRe5wMmhDwAATE6Y6f/XOeGVDVqCl74AQ32LBbicF9n3YhPH5pUQXcrZPEFNYJqZuULfKA/gi4WhSXSIryxqFzGwZ7FWjQ+GxILQlXRK7n6qG8LoI9/hmgAYjzY4TtwryPSKDgPO/5kZj9oS0ltK/qop6A/8SLrphfxHQdMlG9EvIAVsOonDgP+fVCwgJzlaaHkJ6IgbvOl2ufq6Y6zjcDDsAyEy6k3Ez28Yi9hVWfy33u1hExyaqKkiu7S2sfZXKBh3PSoMHzIvPeLdSjxZsC+GxdpCGWAqZm19GIvDD3Vt/NYnsRANT01fI96GjYrpBgv4fvJ8QLSb670ta4O3Yd/RLdXw97uNhdAKHDZZlN8lbn7BpRAZtrRdqdVi1JCIwQr0jGtdRxc0+oRbbJHICiiknnMCB2xTctQU4GTDldiGnYw8noFaIACWzZmP79zWUOl7HYq3/9VPF0mhTycfcaJmCRvxYgUV4RMNa/1WaF7YBIa/9Vl7Qmk2cYBqBnOWJ5oXQqL2caZ3dpCrEpFzchPHYRauU8/YdBwgdjpVdxpkcS7AeCIcgUHeVKRSWBEDF42xNswVUYYIRrk6EAzzYp/VQAqNcjEtBYn2d1idJCJgcSoHYtwfJheLRfKyiAL2JWkVRxMQZgpnUiQ+E1IiiF7LdHWPRxnAdAtOE9E5GCL5Zi6wUgyHWCChFUCrU5vGVqGEFzOQh6F0GALfiDJxNHDwg5aoUpbnIqdNIi/MJ0XBZam1JFBDCFg6h+8zV9oec3gpMjPnJxS+aFEsFQYWgXLxhY5VdKB4Eb+FcasDQhQph5o1E8dGgYC9AZwRJ/RpUT/wf/fh2GE1Yzb8A0V63nEUJGiLUod48EbtMTEZ64dr+he4/Yi8pzF6WRSvsHERZ4iWAEhKRBTwAyhxHieZpBiuRnXhyCHBAQO70hg9gURO5SfCQyY8uxSaQEbIxiWbaIjgXnYQgRc/wCYHeTeLX1bo/oa7tXZuuiEZqRMRTRhg1SAUNhEUplgwuxUx0CPgxhIMtYOuHlKGY2AN+4dIlBIv3kTaz0EWBHIryxhRSxIGTmIF7CAOkokgNXVIJBikSRI8VzQY4zE8B4ewNxSTJUGvs1GltUSgbwj+EmEcw3Ec1YGiOEZSOkkK5jiQCEAPM4GQDAYzmFJv9zfGYIMHESGJpI/43PUQAjiZWCBnS1YRd+o2v5QWwuaRExKBBPx39acnkXKUsIkJNxCGILxxAuVhpk9JAVR2U2YxH6VxoJQgAJcAADiRDftxC4IWUBY48I9mvExDpZyZgPlmB2gR+exjfBgpEu1I98EVqbYSBLs05aaIxBkwBtSSgUoXQScV/dckpeSRSUSBfeNhqnQZVLGRGLo0zfZHuHNyoHuRBbOR8L1Ji/eVnuNxQQcopq6Sk6KZYSEWUwSJERQFg6CIyiSTIVUZoRIZcMcZmQ+FgWcSqfSRH9AWmAGBGOE3lToxvW51Q4oW+IQ5Nk5SW0CJzxmVWyKJEW2RgQeHprkp0cUi1HWP8RPgKYyYkQhDNBEjICLhWRcAkRGpJJdjGUMJGZr4mXCoEcA+B7s1Rj31MjWNNPKnc3XtIA8imiXpVajaIgdkE9+3gcTSWK9pRpq1WfS/dcQ7ghC5B4geEnB5EREFlhQKE9h7ImJflpWuNHTnhF85KPEvFlxqKYPrqbMFIouDEcbids1EOfMDOiWXpR0CUYVZWD4KhrahIsg9Ea3jkR+8luRPGZJfmAvtaiDaqmnkEaTSYBM9QBbMYhwUJBYQcUOVUfb0lfuRmjoTdtgcl4DKeBN6clz9Mp9vEc56ilkcpMqnFbj9lWJJGhAjpO9hhHrNmj8rc+jykZb8ghQIpaYQn/Ef3RonWjYwvSWoVnRxPqa/QlnDlERj0Ten65SQMRLL4pqb86RT3UV48pECtycKgooL4YjhNBO3AWSBKhq55qGK1HE6TKIeWCJ4bDSSFlmIZhngspGP8Dq2Aaoc8jG1FVI7wJFN+EJgkArO9qSOO0EmglpINKrMWarLnGgb3Eb/IUihFRhh5hpil3YKsEftI6GgkInZORP4YVo2iqmsbpnmgJMjMmKJh6WNllopShEvDqsU2ksaqIkB9CoRyTUvmai+RzEZpUc4XBi4SkLjz6JigqpwjhqCOGKM4HQt/qU57XrQACL8O0N/2GgQbATX36KAywVIh5qBB4KrXzsVF7/0DtpClBR4aqiinuQqNiFDge+SY/cX2G0V4XumkKCiCuBhTutIFnhigK2zesOhEJeYFQCSBu5Z9nBLYo0ZcBt6yhJ2CzCqpgMhRSS7i78zzbNqCRgarAhhiK52dOyo8oSxxgSHlx4m4TIZgT1CAKwIrA5jOfwbMUkXwQ0YPro1FkC5YesRIEYCJIhy7lZndb+6llmbK1Ubi3SzZDN7HC9z5hy6xxJrkuG6Frgj34oVHU04aY9Bm3CbCXAVKF9BdHKSHWiijewjTFgxMyORnOUmB+mppjqRoPurInYT2TiLvnazE1dSfFwjJ9QSKRVVip9Z80lzjY+YjP+CeO4xh1Q/+H3YOUBhu6EOE/KEi3nPhinOst7cltrYFEwUGVEFGcoykyNwIhRvulApVDGHRoZQmp6OvBsBKydDu3InuiswgRS/oRFLEtCNs35VY8LNxpQQQBwxHAvLa4EbEzz0qUGUu0HkEYPnkyVsO6ZekzZfI8NIo9iYZwdpYYeNeLNbSvGqpQInaVH2zFvDI+N5KDxUIYaDKQEfagdXOYPfUpmnYtJiS+kaNpD+AtbpUCjnKzbzauYpYQBbk5s0oYYVWZFaGiulk6rhl6w2ZLp6hw7XTFhwwr6CpH74g9Xfeifzy8YumQMisRmqRE8jMUb7aOJQsS/ygpfzqzg2qoYqUzfxX/NFPjJ8Iyuph7Tfj7nSeLTbJoV9jTeu6KyLdsJSF8PqYjKV04mEBxAGuoPUsqu6ZLXG3Wr4SKqYCawgqxpP9oxlqDgX7Yr9d5MmAkG4a4p6QRs6P8ETNEAI1bWIocqKE3NYrsq7iszuvxHGjEyTrnU9WzhEuMskZMyQzRrBFRkgyIz5T7KEORk691Gl3nI/F0monCQS8jgFVEWq3he9sivngURB/Ch1Vkoyi5zhkdJM/xSO5IaWuSJXWJsgsSzRdRkrgWMBJ4PDJHFAHdMh2Ga4vDKaRmzecipFsyThySb0YjNX0yIYrKw+MkXoArEKqi0UddHcTasKFH0jBMEcPF/1jFvD4KTFR+nKoaCDsU3F8A7R9vxKAng0YFoS4RzSEfxlv3CsxlO1CkY4AksXNIDdfTgXM/W4nVaBgQK6DvGGaizE8/4T7UKUwKkUoV8MB9Y6onc7FL3CIinawIrMtBJsWndasPFdeV/Rap1R+FlZ/BiyjB4tQL0V5vShHxp0FPeyMjoE53ujnVCScQcLfJacQwAnAWRIZDIRuPKYiWrdtYcaz+UVh6zdnWSM+lYTjdhGt4rcuS8mU4Qb3XctiKM4wcwrkB+icRfCDlOLwmpBieBlG77d1V0Vll9LufE9x/IlkMsMpvpNcVKinNfS3Y2jctQtYjJ8J/sgBxVSp8Zv/VgAsfxVNz3w3gUwHUAoC6zgwSXYfcfstnQpQq8pUA6YRH3HS58zdKkZnesqSnkxJ4CeHef2I1brsmK1inXSvaKhzJtPScWkNZR3kjnYFGbnJ/gii43xzgNS4V4b17BqAvYwiDBOOpi4KUvgZqbLcg1O2FmzLGHZ5lzqkQOjtGlHnPr9xKMDlDm8ksBlZA+uqWIv4p0WNsNg7mTlGrY9yZA7EiT4mp7YJvO0wfTFzfgkqx+SpZ+GIRSn62MsEyID4hyBU7oibVqsHPdR24azvczGWc9Wotk501Yc7oS9FZ/xtKPgQhsxcbpAZGJxgsY0jMwfsxKEMbEIASdj6nMcr/AUMQJ4e4IZTVGiW+1ShJEVRdsR0TLV2p388xTh3c6IzuhPeZEBYs1a0JPuEtsIjlWeNNwigzoQi9PREo6ntNbAwgmlFO7CQLIKkVxsiozIJZbHGI6PNhy7kO7kUVI8/lKM4B6StFFO7CKPFEVW7e5hYBnuWtnSAxeS7j139+TXgDAh+QwQ1C6QJh5KaBV5DVPJ6NwSFDzV2z7c0G7g3PpUYTWsU9OSkuX9miuMMNbNmHPoldzv+J1fJufk1FEqj9hZBLjIFUHBUQAqC0IeRcTaT1wnSpLRgPf9HNjo2BEy5fRSHa8OD+7w8VVzwaVeAlEzcSAfT3GHWBfoIBkbRV/5Gd5sS93gBKL+0g1O0kX7X+DFeJWRz7zvINQtQKTxrDtVQ7NLsMiBx0rjXEEj9COlRcWpbp1/Pg/tiqMdFTJ1+HRiCfosT9Hn/u8+vBGMqwLKAdNQDnBrglXRhOSOekovLIc3VFsQAQXRqLEiM88cLYJNWbCmyGXyy4PvdhjkP0CV1vOnOHhSYNlWd7pl8nvjnqOqQCenMLcG6PROZlpibFUQKevCEZEze+y21c2UqujChCih9kORA8cWhRGPrgnhEvIy6fxOOTYmnCyNfgB+sRkeD8ivdJuT7UhCMbcWrzde6aYSAVUAKKP74+hPAmBiOXk+x/gsI5EnVw78PNP//3QhpTHWGhGZjuGwIQCAQMJDggwEGECQkQZLgg4UOIESVOhGiAIUODFDVu5NgxwICLAxM6iLggpIACHlUifMCwRAUBBh4mOICAQEeTJ0FePLDyocCQCgoMHBDhIFCCPX0mVNBAwAAECRMUKMDgpACHCR/svEqwAACwYcWOJVvW7Fm0adWuZdvW7Vu4ceXOpVvX7l28eQFYvTgg68OhXQWsBCBRQcioFJ0yTOlTwQEGNh8SuOnxauKlDwtn7pggpNKDJCG2DFmZs8aFDFugSICQANeYHAPzhD0Q9NLDFxscJKDgJ0iopwPk9nqTb9fGk2dfHfBA73Po0aVPp17d+nX/7G6XD9wdcfvF5KcNFIAdXuJrghBMe7TIsIFvAnyDc/QMXvj9lQcwrhcNUT9DBjij6YC/HjIAAQNgC6EC07bL6CADEigwgNR4CuA4glrjjIDtfKPogcwIMKAyDAsKqbz1EELqsuxadPFFGGOUcUYX/2MsxYNsPElDnwxoAAIGdBSgAZk0ao+7zK4a7yIeNXqMKgaKxG9KjhaArMnQJkLqNpUeWA4z3riqjQUPeDtJJgW4KgBEM0NqjbiBzJsIRwpR1GgBBBDw0KPjBjhSMKIWSCABOg8CdAAaE1V0UUYbdVS6Ci8yarLaCJIgsxVP3CjSgbBEaLOI/sRI045svA1U/ypT5ai/804TUoA9A3AQgqdsEg1OgmSqLUCEvoszgcUOYHOiBWgd6NKEFmOo0BwZutQAA4aV6NVKmdsop64UeHRbbrv19tsYFTD2IofwTABEAg4YYIADRBwxREBh1ShTlHqMl6E8mW0WQFX7VYnVfivFjNOBYu2gzI9KE3WgYdPMtqOFb9txovpGHQjMye7tikuIACBYgAMOaA1ckks2+WSU0ZLgXimnrPhhiqj1CVuNL57zpFj95YiAPFv2CWAn3+3oJNBozvWhCw56GeQAlh5oPZ4b+I7Xjao1beKEoL3JV4Z8RgjX9OJV79OJtoMgZbTTVnttRV+9qrIIhppvqf8IAIVgI6e784jemr0+yGjbdPboZTk9Avq82TiWqMTYDiLtohQz4ADCoQrQEOwHH5L5WiURUpYg0xbg6gCuvTpPyQR1asDTOcXUlm3YY5d99roWvqq1pRU3gIECEJBWIUD9hqi2Ce8EFIFqB6I645AKFxwigjE2vKPapI8IPYL0PspCiJKmEAEJWv5cANYDeDUlVCMCu+CvYQON4NKJmsjtNi+SPv2IGACpgAVo9/9/AAYwefZLGOQ0tx+JvMxPCOAdUcrnmsUUQHjzE0xjDBC35k2kUoqTCP7uQ6/M/YsjtkPJBHmjLghYD3m10sxBOJCBPxXANP8ZwAPB9sCHVMr/POkqAJGSdaIBDulvxRsfjxamr8WRK4BLZGITTbY+N0HxPX/7zEQeExkSMWkjD0BiEq8irIS8ynrbu4gJn7evi2TmcBBxWkPu8zuIjKCKEMqXRl7GwVD1pYvDeRtfGAetnfjpIQvgHYF+UhAzqq95TmRkIx2ZKLeBh4TsW1lfPII5wTnNedgjir4+h8czImRh2hPhRiYpxDPm4AMhOcjnJjWnBOhpJTxc3d5OEp7tJABsOfuQAYpHIZ6tiwE4amMAHnlMZCZTOks61MYCUEmMDO4ke8zMuEx3vcU0oIsGCNkvQwmR7XhzI2uEiDVZeUYEVCAEF3kAvaj5TbdJqW48/3kVKDkSgWrlrI3K5Gc//RkXxp3IWoBjQATFGQDbwfEhCninctz0TYiGcX8H1Qg5HaoT4SwgMGCEiAJAsEqGqAsxETVlBhHCuAF8x3kQ68ryAvC4pPxTpjOlaVhOGSdmMuYgGFrXRXiZkF1pxZcq2ok2l/IdUpJUqUuxKPR0eBqjOY8B6owXsqDaUMX4NIzNqydCEeST+FVEpzUla1mTGa+UAI5HEZBanuYoEdEVR0UFEdRF7gbWkCR1qXvtSFPBGRKXrmR8jYMID2Bisa6dBilG/SAE2JWihekpJKnrpEoEE0LHxdIAZuVsZ50YL6WsKLBNw6hGIvDVphVUoGWciP8HA0Cv1iCgABCQAFan5Fq+IsSvD4Fmhk5DNIk0oAIlQGycFGufM+rIgoHMqXETgtsCEq0pyiOAZ6173QAO9iJW5RkCfgk45+4siCPFa/ZkhcDcphciu1VIeYQjMIkgYEGrVQp0KVKpRN6Hmwx45RD5GBSPaFcAKewLdg18YLZ9LKSkMyRcuYbDA9ZMAP1VCbBq6bQxUsm+6h2JvQgyWpW48zwDWM2JbMs8LV4PASITEFV8RxHwUtRKQWqe/m6HYBznuGTg/aIuFVI6ez4EUOPD7N82yqYF/PRCJuUwh9kLVAKe5nM4JMAODsu9DnLkTHlkCIVlwxAIKLR+y6II35L/UjoG6FjNa37UeWsGGnOGdCWXTVdBfhpVfBLFa4xbaZNJ+mSlkQqqCCAURzQAhJDc9TS9fYpE8HsQ3IIl0FGeFpavB6j4HYDNm+b0jG760FNKIEgyWYAEJCDO5BXAQyISp4DJnDXyahg/gsovlQD92pMsNQVMdpVcF9pGdlWFoktGrpaAk2Eybkww1e10s51tHQUjh7Q6KY/F2tU0qflKyRK5F8cw1OfczmYA21bVrRdW5DP2AAQpvg+rKzJe31KEzxwRM9nMHKiuJODZ++Y3dOAdzRhH8kSuZppK4K3X/Xp5Z+S+T4nQ3S+/ps+cENaZEvj1PCh2RV+RpVLG5VUi/8s5p98jJ/lcon0SXm0nKhKmc0fS1VNABXklx5G5T2BKEIVD3CcEWEwN+ZoBIoia4vcRuDMn8m1VRTIwsElzyZ3+9LfQBN6rVhayWN6Xgr5YvF8EsE88yCFLK6TeRurcGW/tGoZzZsMHuUAgcz6lf8c6VAUduk+mEndmQ13vey/LyZ8yod4kJKAae3gHIznuBDAXIrK1XH6uwsadDLNLBHfO887uZwKoQARu9Ehvxn6QeV690bndb5AIrmm+pz71PHYWauL+Vo8M8K5D/es1OSLwWC0N3IABVN05c/ml4k8/VxYAiPOXFIp4/F6fF9wn4/cV1Ucf6je/yppwmy4IWP+uzvEagG2DuG3Y7mzZUGYtR5RPPrPjZyq9Yz5LEiAB3//wo+npyPjwWHTu89VpQWy69P1PcvxTHmOiEHVpvKxikraqvJW4N6wom7wyv5YSMrmjiE8bNuEAvh8qiD2Kq8pSif+gquIbDn35GDH7jtdDNuFQAKuYm15huf75PxjsN0a7Cv0JqtZJrPsoHYqYGvE7iaSqlLpjvfASHAyEkAl0tGJzuYGYP5DZCRmCNAPBmUrjCR8pgAOIM+SbCC7KDGBJwgCIswHStxgcQ37DwnuhKJqQDOiBlpWIANKhtIigl7eLsPT4qUwpvNqzlvTrNbsqqdJYidRRJyFBt/UpFIL/iRWwsx9m4Tk9UwlOKj80ChsqNCYyrERn87uuQMEyQyS7qxwvk7QWNC8+8bXjC5RLwqCuOCjXKjXvGifheBVFmwjbSbuSiAEL+I7y2Q7jCwAOFCQ6tL2IqI1aCwBXu41HrJQGsERlfLbBO57MCD3Q0RlmGoBaWjvXEBqKIIAEGMZELD5oOYm/sEYMsaciRKgjhB5BWwoLIK7tQhxRdJI9YcTiG6yHg8YhHMCIoD58mQx1YZeTWEaA7DRMlMKjOkf98kL1qp7okp+VcBoTKkdiu0fXEpL4g4gNIL5OaaGvMQBaXKh4Ga0F4KZc68GriEcJaABDssenCUiWXDMGPAlN/9Qg2KOS7xjGMzq3ALBH1oEuHpwIiEQouquw/ZGSu7s2j/ABFMCI9luJ82vAH+sKPIRCromKdpo426HElsxKBCO8BtMI18LFnYEMNdSIk7Aq9eIb5yAkILHAPHzHiPjJjtiwz+k+j6CAE6Arf4mfp5ASnrGxTGQP8JClR1yWXdFKwzywGbwM4RCV5uiYKLSzqnmoJsNJ/HgVHIJL/FiYXYSIDjAC2uuXkys0hBBChujIv2mAlGqSxBwIjlQTrDxM2OysAIyTv3iApUSIPEMJWqyN3ROxM1KAbYzMfcSPY6yozLDGztOuiMCtcgQVCRjKMZusHNIYvfKJAYoAsIiQ1/+JTe7sLBFJvHhRAKGIE4ZLH4ZiqT/UiM+xycxQFr/IxtmIyc7Tj8cyTg7DPceUiAxAGOHYjiIZoPX4tIYAH/ZMCDMcjO5MUASDlnsjMqjhyMy8pS4yl9vkjEHclAWoUJ1TrzaKN4/wnsVrgAaYQyNELhICk9m8Cr3aMDODPgV9UQN7Pas6jifMGh/rCH2sFz8LgJMgUZVATt7YI8y8kysZngrCiW2UnId4AGvaTL6pjAVATTmbK9Hz0JXgGuyEUS31rK3QmMYQkuRwGCRxnPOMr5J8OQPcK33EDCDFx6Vgphr1yVRxrRWhS4SIFyTykoIAUWOiFxMCNtMwp1dKHln/esndo5g4c9EtXdSa6lCUM5SQyIra6AkbYazFg8mL2Ex/sbBHUypcsVOJWCOeYTHhIJjlOVDWNAzSqQ0YyADym9LTgckSBbPoHAgIkJKbisrhyJOcoRZG/VWaer2U+JjWsB0wlQh9/A62nJLSOdR+YRxkO5w/AdWl4BupABQ6OaUReNUspJhbSjaGQIhOPQi9DDIdqQnHqgnAAlZ29SeWkyFwnLZ48SYwRTkN9TpwJQrbuFfhKIxK2cXDqQ1SEk9bOieEAM+nsI8rUsMgyoEOQIgZNKOAaoz9O1gvDCJq5TLmqI28a1ePfaTXI4pj5cXVYjf/yJ5ok8/+BKwTO862/wwcOX1MA0KonYCA4iGACQEbvTpPZZGhaVUA0lQAB6CAMHEP1LgdcYXDxUoRlQIJyVPPmOML/vlYqn2kZuwKCajUBrGfeJ2TBagMgStQI7lRcgWsM7IvlSQ30ehLCXhSkp1ZConPrSpN1IBQHgUPIdwNDNAAlmA8iguozOHAglsoOnEaOtmMdImMC9JLRCmMqn3cRrpbCUuJB/jaJZWP1jjWx0DJm3CtwQTGjOIKvZFDf4maA0i73oIwkhBTPYTWpGWIJinKFIEu2/lc7jhPCyBan7iK4rkg20IKX5QIAS0wyC1eRiJNXmuVkyoOUekfikDYaOIMbpIl3nQca0K4A/+QANP0SBzMxgSIAOYjCb38T7PNyXSU3mkioaWzRZv71lRxl42oUuOd3yaS3HshlBWrNRHxkNqISnrRVGRdDrfhEb/1jtYrr3C1tY8RKQnynJBAFmslDHS0JJoFFAfYAAQmiGXlDQRAyQ2WWQlrXPod4f8ZXv66EZWYRdcjl8yYTV2llw/+GLENVRnW2GiU14Koku/dxK5JRDUJiR2wgLgUpeR1EtioSCJORV9BABJuYv8ZVeQYkbcCld3pnQAlyORbuglaIZ8z0nvhiDirOdfYsikhiUoplIoJ3oVEv+fKw/eEnn4cAAb42to4F5TSAAzImghAIpXkIPz5jhPzuLj/BQ8nLmT/AdBi4i30gtToXbiYgUNGLq57RMKwIxtKfjX8IAlRQUE2dFPWNVcKhkJROV1kNJ+8ooBb4Yph0qxLNdijDQkf7SjBuBSwGNUD2CxDzuXYuTeaGMkxztRr7V7cGBTKOF9idBPJ1AjLzE9ZhOQL/Bv9aWDOCMk96lFYI7z/SqyDWWPG6Md2ieBN2ZG1A5XSQRZdPuf/udrkBWdorortPdmkwOKDwJXdGE+b2TrQBRWcFTO19KEpEZFt3StiTYjJnVUBwAwHUEmozBuPAORZ6tE9QWeJpp3hJax8FQn8QBVHxeSvqcGo2AygPaHUzMZ+NMunhFneyKZ31gi+/6gAGWpT/BhXhe6K/tKahMgAGpAwKeW8hHjOIYkVo1HZrzmTzZhoo5Yd28UIr9FZfwFDhIRAWP0eD/6y4TxGJKImG4GJPoPpjlBopdhoYN6IC6jSn37ZWHkSf2bmS77ho25r2GkajPUaHcnYaRaafxWTPJWtWmqloAhJyspICiQVerm/bkVWhjisD56S3NQp8HIbXc0AGKjSlhmQB1Q7sdpHt85s2CE4wN5VQpOa2sKPTz5mJtFG1MpGpotkE3mb550mAFCpKSxsWSaIw5rhFi6ISnGI8YmKxOSlB2Bltuu51+sO1vVlKiEkaiwSzV7utBFQbYSNxHg5kGnZ6jGalP/iji56FZlgORy6yoh0y1+G24g4bPaR4IJ0xmeCTnOM1EHiirF5IQJwABD5DwgguMaIH4MAi8c4gFhWa81gbgBHGXXuimiBDbr2w2hqrkVe68AZcNjVCHNCloXxG/AyoaxGiQVIbJwIDMu5X4owZoHNEiUdpJBxXb+DYMaQlsBrrdYKcBc3GeRFORBKqWFEyzpRzPuqoqSeJtRInIRYEVqeYPGOiA8kD6Lo78nw1quzI5NdbwPygIclJ6t+2+qrVdCgOY9w3BffcpJxcPAgOPlMqGfqiupECO3OrCBhQPlUAGx0DWLewST0XehZADliYWvcEih0HNFLJB9J7jZW6Mr/GNrcnRORMkpuzlopASG+hlVUOa0C4XJI/xb7pU48hWrWalb4Uxrg0JBHjFNuTVg5bqgnOV1HnI0nXCGCsJ67DOvbCzuw9goKZUUNpxBB21sPcNWGdObEzGaGABFQEVz0iXRh75Ydr9KhWx+Z0MunEBKlaCcjF8CLMjH0PBqVWIAIyIqA8ppd68PJ4FXgSc/4YA49Wl7ZDjCTtYANuLwlgQDWGSU306oDGZFJHXZ65xagfcmakRMPqpRJuzrTGJ/R0kYfpBDhzOHMgCIZypOsWPWLo1KYBYAKv/HLaCcRFVFS3z/20wifrg0ImJTN2AAL0AAMVonpKr5CGZ/HuB0x//nHem95R+HmKj1UzbwJya5VAaCTw0NpiIgxLhT3DwuAOudpKo+3j/GNewtT2FjsRKu3wUM3C/AAvu08Ay8UBHAsBlCAHFV2BHV5rleUbiTrVIWrd7Fnr/hrCcsK2/mlAKxO8ELyh5hpN3EAyupiM2ey7WgM7UrTd9eYMfI41qEACwA0MbJ0xrgXEe56xJ+RgQStX/uSvc/E/LP5wr2Xnxro5YzfeykA0cjwNiZtWuWN2RgbU/bCjwmi5NBG8MXhmQyAPNYADeDPUZWSkPQQ2O52lNwTTI0XXE583o8RrUdvj3mwe4mKl4wVgJ8IVL1niLDm2+a+1W1zh5dtWrvmLv9DMfc40jHPkFPylAzoAFQWYhxWtdnYjcFyqeLWt9H3ig6lod3vffdvkWK/l5uQx41l/KYxQzlRll3cviEpyYgYLIB4EGAgwYIGDSYQoHAhQ4YDHBRYeODggwENBRwQeLAgAoYHDCBIoDGAxYYEIFyUSMDAxQUlUxLY2CFDhwsBCFx8qZABy4YGDEZsqPHAwgYEFKQ8AABAgKVOn0KNKnUq1apWr2LNqnUr165ev4INK3Ys2bJmz6JNqzZAAqIp3zJMEKAi3IUd6wpAQJCphIsTD66MWZDpRoIMUhbYSEDnz4GCCxtAiXGgTrwVGuo1SOBww8SFByqIgADBgqAKG/f/tDswgeSUlTG6TCm3sIYMJjLcxUvArUIJmlM2nrsgQtDWCpWqTa58OfPmzp9Djy59OvWveDEfQKBgYG64EAJwVvj6sePK5D+jL/jANMPzBNsiEIzA4oDMBiNcZI93wGWHhcMvNNtBCpiGAG8LEaQAAxA0EFwADVzHEAOrQRhgehZYYEJ3cG2nwGju4XRRBAUt0NAADRRwAAHVsdiiiy/CGKOMM9LYVYXXTWgQgG/JlZpsGxGoUAELpDegAdtBlhKSny2QgH72EfRahEX1195GiBUmZUMCFqYfXlASEIEBI6HnAAk6RFhkAF7GRJiXCdQYp5xz0lmnnXe2GKKJMN0k/9iNb2XmJUMODkaAe+kRYFoBhz6QU3p/NvTblMdJaECV4jV1UEoQEJYpW1P+VdiGdQ1waJGEkXABpPqFil6JFzWw3asNIYenrbfimquuu8aIFEMSCDpAcQxIWUABDQiIl2dqqqlfA4MRtGFGn/XFoUFTpkgkAQkkgOSleW00qgDPHiTuW+QqpqV4QprKbAAUWBDAfOMSGV6r0BqkwAHGKaQAvwohwKvAAxNcsMEHQxXBARKsmNCkey5Un7oKuVukuKYaoFOp+JJU13kH0ipmehBJdBBTUsrV6WoPEwmtw+Lpl5ihFdPsGJIGJNCYygMtIIEERL5c1FsrIly00Ucjnf80dRM/LMDEA9Ss3gKCvUUoQbOWfCVc6BK03ls5ckyQAzdNHbZrexnEdFwH+dhveItGHfdNpg2w5AIHMMAe3jmlFLDSfwMeuOCDT9V20w8fUMCJVqfHG7JDFway05od+S+7kFXrU5FjF/nmZ/5OaTWkk620ZGE7y10QpANIYODW+b1GuOyz0177roIe3pAEGS/EL5eoc9SQ5U5DGWVKBYVXWX2EAvBAAqQNtOO4AzG1M1Ocq7xz28tSb+RucEF90L9ch2tRAQYAHzVTej78Zttw2h6//PPTv3T71/0lOabMNl284ZNFj28YIRNBfPSs0XnGegEAyQg8tZQBtUUyBTD/XZEWMJrSRIyCAdQdekA2IpPRjDC+yp2ElrIbBi2gfipcIQtb+JUAHMAi2SGhRxZYl5YhKil1MYi4liSbdjWKVqOqj2A6tRiFVGBjDiSI/gTgoPRtpEmMawrWFNIu9u0vddeioQAkoAAXgjGMYhwjVSI0MbmMjiEaLExKMPgW0+HHRFdzDQM+eJCgieeIOTmPaS7znSV+Ci4E1GJBeOc0HG4Ej1YkZPBoWCsyQjKSkrRdFQ/nGXX9UU0gS4zH0oYZgmCxIeTjzvEIkEaujVAA/WEA3mbDFNwpxI6MHJACZvaZ/w1Si/PKHacm6ctfAvNolZzSAOpjGLggskhvi4mW/7gHmtbc64xsy0+mFCkAEjHkWwKAwIo6BhcBQZFmFoyPKcXDPOMx5FlOGgAD1lgxN97Qmw7Bigc0QIFg4jOf+oQRCbkUgEoyID6notySmjhFBRgARHUZZRAH9Z6UPIAwDVVlUjYIuVkO5E+VSWjZCskQboIsmRULJVzK2RmscGACGdgnS1vqUuX87zpPXGBJJojRAJwtbOhBQANe40wYXuQxoXQmb7Q5uQCkklaFWQCEWFcxc0VsIWBzzPN+klQB/PRqPS2APwfSRMRcFX1XCcAELvDSs6I1rV3RF3uKucPC2LJmCWAAT+54EdOhzgA9ZYBIR/XTHzGxISItiVGvyf+zoBhrm13lWWfcNbyvfUZ/SaohUB4WyONo5QITaIpaO+vZzz4FZykEAO4SUz3ghXMj7AEbYRJQ03atzKEevQgB+3YfxR3giwd5VWEHICDYqu4iUzyI2kwSrrd4qiDjMUgaS8oUbhENAJq9J1UyMAEOgDa72u2slqZapAhIIAHtUiTjgEsQRxUkjg2hoJeG+zkGVCCxtk1uelLCgASI9CDSw4tIr7oTxQC2gA+LqFSmWxUKTMAB210wg/eJO/cWRI8Kye+aLuJdgzw3O+f5n+n8y1kBMySrjuFMrOjLOScdj0kH+Ag6EZNLEUIMmeVyzaFISqhEEZMqBq6KCSbQ4B//A1mS/yteQULTygfJUbWwQo+EBUAkwqSRvUplW0QGcK8Ia+w8nLPhXSOXzoFkzr7pUUCFVLRA8abRpgQRFAE3U8zXGCSmVdPxBKhLlQ5MwANB3jOfWxhmJwMvAsoDznG3hB79hC8Af86ihxCg16zFbVStAsCWh3moSgaqk1F7QBoHMJKUkK/JmlPulErgg6rsmCobmIAF+uzqV8fvAa2MCogjJMuuGUfEjkFMPBXtEQJ01F07Q6BBtixPIXm5sQMxgAT2605m4djQSA2wVy2s4QQ9L0IFmEFZn5IBDIGbBKwGN4Y4+xRxwzrd6pYf9WAZVPo25QEIMBaR89U0vEHA/0u3jpv0yGdsBbyEm8n2T5FTnLrX/IWkODyZhSurbThhoNtO0ewEKm7xi1fczhPf7Lo77vHBHbsuV07PA9ZYXG0z0nCEMvZARONeRU5kXhCIAKTqnZ4Hrvki9lnVQbwUKrpcpwQjcErEzUpnjUuFrEb/ONObbrTSGqDKUAKJSCIL6dhyEdmM7M5EcCYYllNuTD13yPfi4hZjElK9CxEq3VpHHnGt+OQHkDgAio7qOlslpSt1Ot/7LjA586Rl63vJAJ6soym3uC7uBiAjG43QGoI9WmtrJMBCGb7HpFZNuRmA1XAGICg1F3xxQfDS7X50qzgA735fPevxtPhxbWd1PP/D700gWuuq1ZKkETMvvOkrayEpMgGR57Iabw8wPhGSqU47wPNythGmqByUTYuJAX4CANITne4FVj1VJmCC1oM//HHyb0rUHiBFWROH1lRNzhHD+2bhBQLDH12opCeo80SAAchCj8qGyfiDjM6EVJ//vUUBRAX2LYXpTUWqSYUHTEAHiF8ESqCLfJVDuEZnIB/x/Yp25IuWvF96yFnEgN0rLdlABIsoMVeIMUvoLVaFdcbJzdMB0p0Cbh/SQYUFTMAGTOAO8iB0RN11FJezeBJD1Nu8uNUnMQsU7VdnKNhGSI596I/i9A55GI6j0d5nKN7AcdEjPQUCmgUJkEAPiuH/GCZHyPmFKAGHogiE82RHZWjQEl6dTmHYENaFAQzfVQkVclWVfileLplhxMAV00yMXlCFF5JFxGkAGSriIo4FDB2hHBEH8ZCUQCzAkZQHXHgX+REhI70Gg5hTAAzfAkkQBUkJesDhfzkhXCTcgAQFilwEBFRRMRmFVRjiWGjABGAAI+riLnqFIS2EWBnEvxSAQLXfWyQa1pGKzbmLl+jFAzwGy53diMRVQUjOMXYPMiJXl7zF3YiHgJydXEgaAJRTfWhFLfLiOaLjcyQAiqgIrYXgbOjeQjiT+S3U5xjIcNGjexgbpOxbQVTURgjadZiKArRF4ggJPCkEGm1JKEVX/1eYYzpCZERGxyk6GVDVRVexjGOMRHcUwAPQ3DC2ibxEDONUGnoVhn8pBUKYSDVuRGQcpGPskkNc1QCIY1BwXlgEQAdgl0TyZE82R+hNijUu26Q4WmtYWX6QHShV32c4wLa4zrsVxqIpxEgQQA9BSlfhoagRIUSZUEP65FeCpYys38P4hmLEpCrmzsgVxgjghWNIQDExDGW80VACyrx1I0cUk89V4P+EZV/65YzAoDGeB7A1zHW8XjaqSWEdx1wYh6cFwPAIxslBibs9ol8AQGVw4V9q5mY+B5JxUYp8kL1YJMCwRwi2JX1lTwBEgGJ6xqjohbjkiGmuFzZeIGKY0P9LmBZn6uZuMgdUtQ+kTIiHiNeyXZBvnmaRJIA27aEJUtMC8Au60GNdlCVFOg2oQQXOfBFvaud2osUC/YRxTh9ATgwEzAc7jUomjdm3EFFwvSDMpMh2bMuRIE61AWFjced94udyUOekiNRY5hEdngYIEWfVpUDVPBSpaASAAOWoyaYAbAs7Zmd+SuiElsVuBOZFLRvTFM/6VIhvfYbX/KIDnCWCHFNUxdhCCWZgyWN+UGiLumh3GscB3I30VAa6nAQQMpmpEIbkjI2NFdKKNejhNMADAcDdfAQAbMhoveiSMulXGGlD7ojyKUQDjERx5Rdb5VY4pUQDkRQrwWPiHGb/7nhlaCkOA4xpk6JpmnKFa7ET0RBmaOFFQB1K24CpmUXYlsqlMfpi1nGImvrpn06Hf7qXumyMAdDVnipEA2mgAPHpDgHqo0IqTKkizl3jP+FFA/yJs2yZfzaqyEXqp4JqWViOAVYFAaqi1IGi8XWqfelNqLrqq3YFiGLVkV7Fhfqb9K2qMfrN+pgbrPrqr1KFoXBFCL7GkD6FgjnFfo5LAwxPZXbkaQFrtEorWuxGihxIfVwE/DgFsiYrj6yjjDrFA/DLszbP1EzruaKrWtzN/pFWiEUFtzoFUvnirkpFJS5ALaVrvuprc8zbMEoFvEZFJfbqvhJswcYIwBpswios/40g7MI67MNSR8NC7MRSrHJIbMVibMaKxcVqbMd6LFZw7MeK7MhuK8ma7MkeK8qqLMmG7Mq67MK27MvKLMHG7MzaLLrW7M3qLLDm7M76rKv27M8KLaQG7dAarZoW7dEq7ZIm7dI67YQ27dNKLXdG7dRarW5W7dVqrV9m7dZ6rU927deKLUSG7dia7S6W7dmqLRmm7dq67Q627dvKbfjF7dzard/V7d3qLdPl7d76rbr17d8Kbp8F7uAa7o8V7uEqrnYl7uI6bmc17uNK7ktF7uRarj5V7uVq7i9l7uZ6LiR17ueKLhiF7uiargqV7umqbvyk7uq6ruy07uvKLuDE7v/s2u7R1O7t6q7B5O7u+i6v9O7vCu+tBO/wGm+dFO/xKm+NJO/yOi+MNO/zSm916Nn0Wu/1Ym/2au/2cm/3eu/3gm/4iu/4km/5mu/5om/6qu/6sm/7uu/7wm/8yu/80m/92u/94m/+6u/+8m//+u//AnAAC/AAE3ABG/ABI3ACK/ACM3ADO/ADQ3AES/AEU3AFW/AFY3AGa/AGc3AHe/AHg3AIi/AIk3AJm/AJo3AKq/AKs3ALu/ALw3AMy/AM03AN2/AN43AO6/AO83AP+/APA7E+bYAG5GIQH64hYkAHmEnFDez1JZgRH7H2YRzHRUWPQbHhGmJtYABZUTFU4Fm29V6x3z4kADCxVKxaq4WxGGvfU5SxVKBbGu/tGLdxVNxiEcOx3cpxF0MFIt7x3eZxEzsFGPYxHq+xU8xxVOCgDg7y2/7xneXZIjNyIS/FIUOFFUOy2zayVCBY9F7ywmZyVFjXTnby2X4yVGgWII/y1hpiBlxAK1dcK19AIsarJKeyKmsfDk6x9uldLZMyLVdF6tkgL2vtGFeF9wmz2RLzVDggBB6z2CZzMxPy0kGz4OakKMNvQAAAOw==" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "可见，神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ 的输出可以分布在整个布洛赫球表面了，虽然在两级（$|0\\rangle$ 和 $|1\\rangle$）附近的分布会更加密集；而神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 的输出在球面的分布是比较均匀的。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "在单量子比特的低维情形下我们可以借助布洛赫球定性观察量子神经网络的表达能力。而在一般的多量子比特应用中，我们必须借助统计数学的工具对表达能力定量分析。接下来我们将引入量子态之间保真度分布的 K-L 散度作为量化神经网络的表达能力的指标，并计算一种常见拟设的表达能力。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## 定量分析表达能力：K-L 散度" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "### 保真度分布与 K-L 散度" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "在文献 [2] 中，作者提出了基于神经网络输出态之间的保真度概率分布的表达能力量化方法。对任意量子神经网络 $U(\\vec{\\theta})$，采样两次神经网络参数（设为 $\\vec{\\phi}$ 和 $\\vec{\\psi}$），则两个量子电路输出态之间的保真度 $F=|\\langle0|U(\\vec{\\phi})^\\dagger U(\\vec{\\psi})|0\\rangle|^2$ 服从某个概率分布：\n", - "$$\n", - "F\\sim{P}(f).\\tag{4}\n", - "$$\n", - "文献 [2] 指出，量子神经网络 $U$ 能够均匀地分布在所有酉矩阵上时（此时称 $U$ 服从哈尔分布），保真度的概率分布 $P_\\text{Haar}(f)$ 满足\n", - "$$\n", - "P_\\text{Haar}(f)=(2^{n}-1)(1-f)^{2^n-2}.\\tag{5}\n", - "$$\n", - "\n", - "量桨提供了直接从哈尔分布采样酉矩阵的函数。观察哈尔分布酉矩阵输出的量子态保真度服从的概率分布：" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 4, - "source": [ - "from paddle_quantum.utils import haar_unitary, state_fidelity\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.ticker import FuncFormatter\n", - "from scipy import integrate\n", - "\n", - "# 定义绘制直方图的函数\n", - "def plot_hist(data, num_bin, title_str):\n", - " def to_percent(y, position):\n", - " return str(np.around(y*100, decimals=2)) + '%'\n", - " plt.hist(data, weights=[1./len(data)]*len(data), bins=np.linspace(0, 1, num=num_bin), facecolor=\"blue\", edgecolor=\"black\", alpha=0.7)\n", - " plt.xlabel(\"Fidelity\")\n", - " plt.ylabel(\"frequency\")\n", - " plt.title(title_str)\n", - " formatter = FuncFormatter(to_percent)\n", - " plt.gca().yaxis.set_major_formatter(formatter)\n", - " plt.show()\n", - " \n", - " \n", - "# 定义计算哈尔采样输出保真度分布的函数\n", - "def p_F_haar(n, s, b=50, draw=False):\n", - " f_list = list()\n", - " # 开始采样\n", - " for i in range(s):\n", - " # 采样第一个酉变换\n", - " u1 = haar_unitary(n)\n", - " # 输入 |0> 时酉变换的输出\n", - " phi1 = u1[:,0]\n", - " rho1 = np.outer(phi1, phi1.conj())\n", - " # 采样第二个酉变换\n", - " u2 = haar_unitary(n)\n", - " phi2 = u2[:,0]\n", - " # 输入 |0> 时酉变换的输出\n", - " rho2 = np.outer(phi2, phi2.conj())\n", - " # 计算两个采样输出之间的保真度\n", - " f_list.append(state_fidelity(rho1, rho2)**2)\n", - " f_list = np.array(f_list)\n", - " # 绘制概率分布图\n", - " if draw:\n", - " title_str = \"haar, %d qubit(s)\" % num_qubit\n", - " plot_hist(f_list, b, title_str)\n", - " sample_distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", - " # 根据公式计算概率分布函数的理论值，用于后期计算 K-L 散度\n", - " theory_distribution = np.zeros_like(sample_distribution)\n", - " for index in range(len(theory_distribution)):\n", - " def p_continues(f):\n", - " return (2 ** n - 1) * (1 - f) ** (2 ** n - 2)\n", - " lower = 1/b*index\n", - " upper = lower + 1/b\n", - " theory_distribution[index], _ = integrate.quad(p_continues,lower,upper)\n", - " return sample_distribution, theory_distribution\n", - "\n", - "\n", - "num_qubit = 1\n", - "p_haar_1qubit, theory_haar_1qubit = p_F_haar(num_qubit, num_sample, draw=True)\n", - "num_qubit = 2\n", - "p_haar_2qubit, theory_haar_2qubit = p_F_haar(num_qubit, num_sample, draw=True)" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "可见保真度分布大致服从 $P_\\text{Haar}$。类似地，我们也能计算之前定义的单比特量子神经网络 $R_Y(\\theta)$，$R_Y(\\theta_1)R_Z(\\theta_2)$ 和 $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 输出的保真度概率分布：" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 5, - "source": [ - "# 定义计算量子神经网络输出保真度分布的函数\n", - "def p_F_qnn(n, s, g, b=50, draw=False):\n", - " f_list = list()\n", - " rho_sample = outputs_y\n", - " title_str = \"Ry\"\n", - " if g == 2:\n", - " rho_sample = outputs_yz\n", - " title_str = \"Ry-Rz\"\n", - " elif g == 3:\n", - " rho_sample = outputs_yzy\n", - " title_str = \"Ry-Rz-Ry\"\n", - " # 使用之前采样的数据计算保真度分布\n", - " for index in range(int(s / 2)):\n", - " rho1 = rho_sample[index]\n", - " rho2 = rho_sample[index+int(num_sample / 2)]\n", - " f_list.append(state_fidelity(rho1, rho2)**2)\n", - " f_list = np.array(f_list)\n", - " # 绘制概率分布图\n", - " if draw:\n", - " plot_hist(f_list, b, title_str)\n", - " distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", - " return distribution\n", - " \n", - " \n", - "num_qubit = 1\n", - "p_y = p_F_qnn(num_qubit, num_sample, 1, draw=True)\n", - "p_yz = p_F_qnn(num_qubit, num_sample, 2, draw=True)\n", - "p_yzy = p_F_qnn(num_qubit, num_sample, 3, draw=True)" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEWCAYAAACnlKo3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZZElEQVR4nO3de7RkZZ3e8e8jINqCgIKoDW2jIoZ4hc6IsqIyKCIRmCDEGzcXDop3w8SlDpdERybOIAqzHEkLjNxUEkTTTlAgIGHGCGNzGURQadsjdxsF0Qk4NPLLH3u3czh9LtX7nKo61ef7WatW135rV9XvPd2nn9rvu/dbqSokSericcMuQJI0ugwRSVJnhogkqTNDRJLUmSEiSerMEJEkdWaISJI6M0SkAUsyluShJP+U5J4kX0yyxbDrkrowRKTh2L+qtgBeArwU+Ohwy5G6MUSkIaqqe4BLgJckuSnJ/useS7JZkl8keenwKpSmZ4hIQ5RkB+D1wCrgHODQcQ/vB9xdVdcPozapF3HtLGmwkowB2wIFbAFcAbwRWAT8CFhcVb9OciHwD1X1F8OqVZqJRyLScPxRVW0JvBp4PrBtVd0FfAd4Y5KtaY5Qzh9ahVIPDBFpiKrq/wBfBE5um86mGdI6BPhuVd05pNKknmw67AIk8VlgLMmLga8Dfw1sDziMpXnPIxFpyKrqXppJ9ROq6iHgq8BOwEVDLUzqgRPr0jyT5ATgeVV16Iw7S0PmcJY0jyR5CnAUcNiwa5F64XCWNE8k+WPgduCbVXXVsOuReuFwliSpM49EJEmdLbg5kW233baWLl067DIkaaRce+21v6iq7Sa2L7gQWbp0KStXrhx2GZI0UpL8bLJ2h7MkSZ0ZIpKkzgwRSVJnhogkqTNDRJLUmSEiSerMEJEkdWaISJI6M0QkSZ0tuCvWJWljdtBBRzE2tma99qVLn8ZFF5055+9niEjSRmRsbA2LF39jkvb9+/J+DmdJkjozRCRJnRkikqTODBFJUmeGiCSpM0NEktSZISJJ6swQkSR1ZohIkjozRCRJnfUtRJKclWRNkpvGtT0lyWVJbm3/3GaK5x7R7nNrkiPats2TfCvJTUnePW7f5Ul261c/JElT6+eRyBeBfSe0fQS4vKp2Bi5vtx8jyVOAE4GXAX8AnNiGzeuAvwdeBBzW7vtiYJOquq5PfZAkTaNvIVJVVwH3TWg+EDi7vX828EeTPPV1wGVVdV9V3Q9cRhNGa4FFwGZA2n0/ARw/t5VLkno16DmR7avq7vb+PcD2k+yzGLh93PYdbdtlwFLgauC0JAcA11XVXTO9aZKjk6xMsvLee++dTf2SpHGGthR8VVWS2oD9HwHeCpBkM+AS4MAkpwBLgHOqasUUz10OLAdYtmxZz+8pSZreoI9Efp7kGQDtn+t/cwrcCew4bnuHtm28dwPnAHsADwBvAo6d82olSdMadIisAI5o7x8B/M9J9rkE2CfJNu2E+j5tGwBt2xtoQmQR8ChQwBP7WLckaRL9PMX3y8B3gV2S3JHkKOC/Aq9NcivwmnabJMuSnAFQVffRTJh/r719vG1b5wTgk1X1KE24/Fvg+8C5/eqLJGlyfZsTqaq3TPHQ3pPsuxJ4x7jts4CzpnjdD427/1uaIxVJ0hB4xbokqTNDRJLUmSEiSerMEJEkdWaISJI6M0QkSZ0ZIpKkzgwRSVJnhogkqTNDRJLUmSEiSerMEJEkdWaISJI6M0QkSZ0ZIpKkzgwRSVJnhogkqbO+fbPhxuigg45ibGzNeu1Llz6Niy46cwgVSdJwGSIbYGxsDYsXf2OS9v2HUI0kDZ/DWZKkzgwRSVJnhogkqTNDRJLUmSEiSerMEJEkdWaISJI6M0QkSZ0ZIpKkzgwRSVJnQwmRJB9K8oMkNyX5cpInTHh88yQXJFmV5JokS9v2PZPcmGRlkp3btq2TXJrEQJSkARv4f7xJFgPvB5ZV1QuATYA3T9jtKOD+qnou8BngU237scB+wAeBd7VtxwEnVdWjfS5dkjTBsD69bwo8McmmwCLgrgmPHwic3d6/ENg7SYC17f6LgLVJngPsWFVXDqRqSdJjDHwV36q6M8nJwG3AQ8ClVXXphN0WA7e3+z+S5AHgqcCfA+e0zzsMOJnmSGRaSY4GjgZYsmTJHPVEkjSM4axtaI40dgKeCTwpyaG9PLeqbqiqPapqL+DZwN3NS+aCJOcl2X6K5y2vqmVVtWy77babo55IkoYxnPUa4KdVdW9VrQUuAl4xYZ87gR0B2iGvrYBfrnuwHdo6DvgEcCLwYeALNHMtkqQBGUaI3AbskWRRGwZ7A7dM2GcFcER7/2DgiqqqcY8fDlxcVffRzI882t4W9bVySdJjDGNO5JokFwLXAY8A1wPLk3wcWFlVK4AzgXOTrALuY9zZW0kWAUcC+7RNpwAXAw8Dbx1UPyRJQ/p63Ko6kWYYarwTxj3+W+CQKZ77ILDXuO2/A17YhzIlSTPwAj1JUmeGiCSpM0NEktSZISJJ6swQkSR1ZohIkjozRCRJnRkikqTODBFJUmeGiCSpM0NEktSZISJJ6swQkSR1ZohIkjozRCRJnRkikqTODBFJUmczhkiSa5O8J8k2gyhIkjQ6ejkSeRPwTOB7Sb6S5HVJ0ue6JEkjYMYQqapVVfWnwPOALwFnAT9L8l+SPKXfBUqS5q+e5kSSvAj4NPCXwFeBQ4BfA1f0rzRJ0ny36Uw7JLkW+BVwJvCRqvrn9qFrkuzZx9okSfPcjCECHFJVqyd7oKoOmuN6JEkjpJfhrHck2XrdRpJtkvxZ/0qSJI2KXkLk9VX1q3UbVXU/sF/fKpIkjYxeQmSTJJuv20jyRGDzafaXJC0QvcyJnA9cnuRv2u23A2f3ryRJ0qiYMUSq6lNJbgT2bps+UVWX9LcsSdIo6OVIhKr6JvDNPtciSRoxvayddVCSW5M8kOTXSX6T5NeDKE6SNL/1MrH+F8ABVbVVVT25qrasqifP5k2TbJ3kwiQ/THJLkpdPeDxJTkuyKsmNSXZr23dpF4S8cd1zkmya5H8nWTSbmiRJG66XEPl5Vd0yx+97KvCtqno+8GJg4uu/Hti5vR0NfL5tfyfwAZpTjP+kbTsGOK+qHpzjGiVJM+hlTmRlkguArwPrljyhqi7q8oZJtgJeCRzZvs7DwMMTdjsQOKeqCri6PXJ5BrAWWNTe1rYXQe4P7NulFknS7PQSIk8GHgT2GddWQKcQAXYC7gX+JsmLgWuBD1TV/xu3z2Lg9nHbd7RtnwPOoblO5Z3A8cBJVfXodG+Y5GiaIxqWLFnSsWxJ0kS9nOL79j68527A+6rqmiSnAh+hCYSZarkNeDVAkucCOwC3JDkXeDxwfFX9eJLnLQeWAyxbtqzmqB+StOD1cnbW85JcnuSmdvtFSY6bxXveAdxRVde02xfShMp4dwI7jtveoW0b75PAccD7gTOADwMnzqIuSdIG6mVi/QvAR2nmI6iqG4E3d33DqroHuD3JLm3T3sDNE3ZbARzenqW1B/BAVd297sEkrwLuqqpbaeZHHm1vnqElSQPUy5zIoqr6hwnfiPvILN/3fcD5SR4PrAbenuRdAFV1OnAxzRlYq2jmY34/pNZ+Ne9xNF/bC80w1fk0fTlmlnVJkjZALyHyiyTPoZlMJ8nBwN3TP2V6VXUDsGxC8+njHi/gPVM8t4DXjtu+hfWHwyRJA9BLiLyH5tP+85PcCfwUOLSvVUmSRkIvZ2etBl6T5EnA46rqN/0vS5I0Cnr5jvUTJmwDUFUf71NNkqQR0ctw1viLAJ8AvIH1lymRJC1AvQxnfXr8dpKTAb9PRJLU03UiEy2iufhPkrTA9TIn8n3a03uBTYDtAOdDJEk9zYm8Ydz9R2iWhp/txYaSpI1ALyEy8ZTeJ4+/er2q7pvTiiRJI6OXELmOZjHE+4EAWwO3tY8V8Oy+VCZJmvd6mVi/DNi/qratqqfSDG9dWlU7VZUBIkkLWC8hskdVXbxuo6q+CbyifyVJkkZFL8NZd7XfH3Jeu/024K7+lSRJGhW9HIm8hea03q/RfCXudm2bJGmB6+WK9fuADyR50oTvQZckLXC9fD3uK5LcTLteVpIXJ/nrvlcmSZr3ehnO+gzwOuCXAFX1j8Ar+1mUJGk09LR2VlXdPqHpd32oRZI0Yno5O+v2JK8AKslmwAdwKXhJEr0dibyL5ityFwN3Ai9hiu8/lyQtLNMeiSTZBDi1qt42oHokSSNk2iORqvod8Kwkjx9QPZKkEdLLnMhq4DtJVjDuq3Kr6pS+VSVJGglTHokkObe9ewDwt+2+W467SZIWuOmORHZP8kyaZd//akD1SJJGyHQhcjpwObATsHJce/B7RCRJTBMiVXUacFqSz1fVMQOsSZI0g4MOOoqxsTXrta9e/TMWLx5cHb0swGiASNI8Mza2hsWLv7Fe+w9/uOtA6+hp2RNJkiYztBBJskmS65P87SSPbZ7kgiSrklyTZGnbvmeSG5OsTLJz27Z1kkuTGIiSNGDD/I93ujW4jgLur6rn0qwi/Km2/VhgP+CDNMuxABwHnFRVj/avVEnSZIYSIkl2AP4dcMYUuxwInN3evxDYO0mAtcCi9rY2yXOAHavqyv5WLEmaTC9XrPfDZ4EPM/VFi4uB2wGq6pEkDwBPBf4cOAd4CDgMOJnmSGRaSY4GjgZYsmTJLEuXJK0z8CORJG8A1lTVtRv63Kq6oar2qKq9aK5Tubt5yVyQ5Lwk20/xvOVVtayqlm233Xaz64Ak6feGMZy1J3BAkjHgK8AfJjlvwj53AjsCJNkU2Ir2mxXbttAcgXwCOJHmqOYLwPv7Xbwk6V8MPESq6qNVtUNVLQXeDFxRVYdO2G0FcER7/+B2nxr3+OHAxVV1H838yKPtbVFfi5ckPcaw5kTWk+TjwMqqWgGcCZybZBVwH03YrNtvEXAksE/bdApwMfAw8NZB1ixJC91QQ6Q9q+rK9v4J49p/CxwyxXMeBPYat/13wAv7WackaXJeoCdJ6swQkSR1ZohIkjozRCRJnRkikqTODBFJUmeGiCSpM0NEktSZISJJ6mzeLHsiSVrfQQcdxdjYmvXaV6/+GYsXD6GgCQwRSZrHxsbWsHjxN9Zr/+EPdx1CNetzOEuS1JkhIknqzBCRJHVmiEiSOnNifQ6sXv0Tdttt//Xaly59GhdddOYQKpI0SqY6Awvmz1lYUzFE5sDDDzPp2RNjY+sHiyRNNNUZWDB/zsKaiiEiSTOY6kjB0QZDRJJmNNWRgqMNhkhfTTVXAnDPPXfw9KfvsF67n2wkjRJDpI+mmiuBZpxz9939ZCNptHmKrySpM0NEktSZISJJ6swQkSR1ZohIkjozRCRJnXmK7zzjOlzS6PD31RCZd1yHSxod/r4OIUSS7AicA2wPFLC8qk6dsE+AU4H9gAeBI6vquiS7AF8CNgPeWVXfTbIp8C3ggKp6cIBdkTTHplvNdiF9uh8lwzgSeQQ4tg2FLYFrk1xWVTeP2+f1wM7t7WXA59s/3wl8ABijCZk3AscA5xkg0uibbjXbhfTpfpQMPESq6m7g7vb+b5LcAiwGxofIgcA5VVXA1Um2TvIMYC2wqL2tTbI1sD+w7wC7MBSOvUqjb6ojrfn+nSHTGeqcSJKlwEuBayY8tBi4fdz2HW3b52iGwjanOSo5Hjipqh6d4X2OBo4GWLJkyVyUPnALdezVJbi1MZnqSGu+f2fIdIYWIkm2AL4KfLCqft3Lc6rqNuDV7fOfC+wA3JLkXODxwPFV9eNJnrccWA6wbNmympMOaCBcglua34YSIkk2owmQ86vqokl2uRPYcdz2Dm3beJ8EjgPeD5xBM09yEvC2ua53PhvmMNfGcpSwsfRDszOXX1E71e/lKA9bTWUYZ2cFOBO4papOmWK3FcB7k3yFZkL9gXYuZd1rvAq4q6puTbIIeLS9Lepv9fPPMIe5NpajhI2lH5qdufyK2ql+L0d52GoqwzgS2RM4DPh+khvato8BSwCq6nTgYprTe1fRnOL79nVPbkPoOOBNbdNy4HyavhzT//IlSesM4+ysvwcywz4FvGeax147bvsWYLe5rFGS1BuvWN9ITffVvI71b5yc23ksfx6DYYhspKb7al7H+jdOzu08lj+PwTBEpI2cF6qqnwwRaSO3UC9U1WAYIgvQQv1kujEuOSENmyGyAC3UT6Yb45IT0rAZIppznhkmLRyGiOacZ4ZJC4chot9bqHMlG2q6NZbuuecOnv70HdZrn+pnONVrTfU6U7XDaM3tzOX8lHNdw2WI6PcW6lzJhpppjaXdd+/9ZzjdPM1krzNV+7rHRsVczk851zVchohmNIgVSTf006TzLrM3iCPP+XiUsJBW2B0EQ0QzGsSKpBv6adJ5l9kbxJHnfDxKWEgr7A6CISLpMZwb04YwRCQ9hnNj2hCGiAZqlMaj57LWUer3fOXPcH4yRDRQozQePZe1jlK/5yt/hvOTIaKNjp9Y+8Mz4jQZQ0QbHT+x9sd0Z8RdccWuBvcCZYhImjWDe+F63LALkCSNLkNEktSZISJJ6swQkSR1ZohIkjozRCRJnRkikqTODBFJUmeGiCSpM0NEktSZISJJ6mwoIZJk3yQ/SrIqyUcmeXzzJBe0j1+TZGnbvmeSG5OsTLJz27Z1kkuTGIiSNGAD/483ySbA54DXA7sCb0kycZW2o4D7q+q5wGeAT7XtxwL7AR8E3tW2HQecVFWP9rl0SdIEw/j0/gfAqqpaXVUPA18BDpywz4HA2e39C4G9kwRYCyxqb2uTPAfYsaquHEjlkqTHSFUN9g2Tg4F9q+od7fZhwMuq6r3j9rmp3eeOdvsnwMuAHYDTgYeAw4CTgeOr6tYZ3vNo4Oh2cxfgRx3L3xb4Rcfnjir7vDAstD4vtP7C7Pv8rKrabmLjSH2fSFXdAOwBkOSVwN3N3VxAc5RybFX9fJLnLQeWz/b9k6ysqmWzfZ1RYp8XhoXW54XWX+hfn4cxnHUnsOO47R3atkn3SbIpsBXwy3UPtkNbxwGfAE4EPgx8AXh/36qWJK1nGCHyPWDnJDsleTzwZmDFhH1WAEe09w8GrqjHjrsdDlxcVffRzI882t4W9bVySdJjDHw4q6oeSfJe4BJgE+CsqvpBko8DK6tqBXAmcG6SVcB9NEEDQJJFwJHAPm3TKcDFwMPAW/tc/qyHxEaQfV4YFlqfF1p/oU99HvjEuiRp4+EFepKkzgwRSVJnhsgkui7LMqp66O9/THJzu+TM5UmeNYw659JMfR633xuTVJKRPx20lz4n+Q/t3/UPknxp0DXOtR7+bS9J8u0k17f/vvcbRp1zJclZSda019pN9niSnNb+PG5Mstus37SqvI270Uz2/wR4NvB44B+BXSfs827g9Pb+m4ELhl13n/u7F7CovX/MKPe31z63+20JXAVcDSwbdt0D+HveGbge2Kbdftqw6x5An5cDx7T3dwXGhl33LPv8SmA34KYpHt8P+CYQmmvurpnte3oksr7ZLMsyimbsb1V9u6oebDevprm2Z5T18ncMzXVInwJ+O8ji+qSXPv8x8Lmquh+gqtYMuMa51kufC3hye38r4K4B1jfnquoqmjNap3IgcE41rga2TvKM2bynIbK+xcDt47bvaNsm3aeqHgEeAJ46kOrmXi/9He8omk8yo2zGPreH+TtW1f8aZGF91Mvf8/OA5yX5TpKrk+w7sOr6o5c+/2fg0CR30Fwq8L7BlDY0G/r7PqORWvZEw5XkUGAZ8Kph19JP7dcKnEJzPdJCsinNkNaraY42r0rywqr61TCL6rO3AF+sqk8neTnN9WkvKFcF75lHIuub9bIsI6aX/pLkNcCfAgdU1T8PqLZ+manPWwIvAK5MMkYzdrxixCfXe/l7vgNYUVVrq+qnwI9pQmVU9dLno4D/DlBV3wWeQLNQ4caqp9/3DWGIrG8ulmUZJTP2N8lLgf9GEyCjPk4OM/S5qh6oqm2ramlVLaWZBzqgqlYOp9w50cu/66/THIWQZFua4a3VA6xxrvXS59uAvQGS/CuaELl3oFUO1grg8PYsrT2AB6rq7tm8oMNZE9Qsl2UZNT329y+BLYD/0Z4/cFtVHTC0omepxz5vVHrs8yXAPkluBn4H/KeqGtUj7F77fCzwhSQfoplkP3KEPxCS5Ms0HwS2bed5TgQ2A6iq02nmffYDVgEPAm+f9XuO8M9LkjRkDmdJkjozRCRJnRkikqTODBFJUmeGiCSpM0NEmgNJfpfkhnG3pUn+7xT7fjHJwTO83u/3SXJGkl3b+x+b++ql7rxORJobD1XVSya0vWIuXriq3jFu82PASXPxutJcMESkPknyT1W1RbvC818Br6VZ/O7hcfvsTrNO1xbAL2gudrt7wutcCfwJzeoIT0xyA/ADmmXO76uqz7b7fRJYU1Wn9rdn0r9wOEuaG08cN5T1tQmP/XtgF5rvqzic9gglyWY04XJwVe0OnAV8cqo3qKqP0B7xVNXb2v0Pb1/rcTQrJ5w3t92SpueRiDQ3JhvOWueVwJer6nfAXUmuaNt3oVno8bJ2OZlNgJ7XMaqqsSS/bNc22x64fpSXKdFoMkSk4Qnwg6p6+Sxe4wyaJeufTnNkIg2Uw1lS/10FvCnJJu23yO3Vtv8I2K79HguSbJbkX8/wWmvbYbB1vgbsC/wbmoUGpYHySETqv68BfwjcTLP0+HcBqurh9jTe05JsRfP7+FmaSfOpLAduTHJdVb2tfY1vA79qh8ukgXIVX2mEtRPq1wGHVNWtw65HC4/DWdKIai9AXAVcboBoWDwSkSR15pGIJKkzQ0SS1JkhIknqzBCRJHVmiEiSOvv/RPjYTGjgzMoAAAAASUVORK5CYII=" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": { - "scrolled": true - } - }, - { - "cell_type": "markdown", - "source": [ - "可见，$R_Y-R_Z-R_Y$ 门组成的神经网络的输出保真度分布与均匀酉矩阵的表现最为接近。统计数学中的 K-L 散度（也称相对熵）可以衡量两个概率分布之间的差异。两个离散概率分布 $P,Q$ 之间的 K-L 散度定义为\n", - "$$\n", - "D_{KL}(P||Q)=\\sum_jP(j)\\ln\\frac{P(j)}{Q(j)}.\\tag{6}\n", - "$$\n", - "如果将量子神经网络输出的保真度分布记为 $P_\\text{QNN}(f)$，则量子神经网络的表达能力定义为 $P_\\text{QNN}(f)$ 和 $P_\\text{Haar}(f)$ 之间的 K-L 散度 [2]：\n", - "$$\n", - "\\text{Expr}_\\text{QNN}=D_{KL}(P_\\text{QNN}(f)||P_\\text{Haar}(f)).\\tag{7}\n", - "$$\n", - "因此，当 $P_\\text{QNN}(f)$ 越接近 $P_\\text{Haar}(f)$ 时，$\\text{Expr}$ 将越小（越趋近于 0），量子神经网络的表达能力也就越强；反之，$\\text{Expr}$ 越大，量子神经网络的表达能力也就越弱。\n", - "\n", - "我们可以根据该定义直接计算单比特量子神经网络 $R_Y(\\theta)$，$R_Y(\\theta_1)R_Z(\\theta_2)$ 和 $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 的表达能力：" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 6, - "source": [ - "from scipy.stats import entropy\n", - "# 使用 scipy 的 entropy 函数计算相对熵（即 K-L 散度）\n", - "expr_y = entropy(p_y, theory_haar_1qubit)\n", - "expr_yz = entropy(p_yz, theory_haar_1qubit)\n", - "expr_yzy = entropy(p_yzy, theory_haar_1qubit)\n", - "print(\"Ry，Ry-Rz，和 Ry-Rz-Rz 神经网络的表达能力分别为 %.2f，%.2f，和 %.2f。\" %(expr_y, expr_yz, expr_yzy))" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Ry，Ry-Rz，和 Ry-Rz-Rz 神经网络的表达能力分别为 0.23，0.04，和 0.03。\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "### 评估量子神经网络拟设的表达能力" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "现在，我们拥有了定量研究任何量子神经网络拟设表达能力的工具——K-L 散度。作为一个实际应用，我们来探究量桨内置拟设 complex_entangled_layer 的表达能力随电路深度的变化。这里我们设置电路的宽度为 4-qubit。" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 7, - "source": [ - "# 定义计算保真度分布的函数\n", - "def p_F_cel(n, d, s, b=50, draw=False):\n", - " f_list = list()\n", - " for index in range(int(s / 2)):\n", - " if 2 * index % 400 == 0:\n", - " print(\" 采样第 %d 个样本...\" % (2 * index))\n", - " cir1 = UAnsatz(n)\n", - " # 在 0 到 2 pi 间均匀采样参数 theta\n", - " theta1 = paddle.to_tensor(2 * np.pi * random(size=(d, n, 3)), dtype='float64')\n", - " # 作用 complex_entangled_layer 层\n", - " cir1.complex_entangled_layer(theta1, d, range(n))\n", - " # 输出态的态矢量\n", - " rho1 = cir1.run_state_vector()\n", - " cir2 = UAnsatz(n)\n", - " # 在 0 到 2 pi 间均匀采样参数 theta\n", - " theta2 = paddle.to_tensor(2 * np.pi * random(size=(d, n, 3)), dtype='float64')\n", - " # 作用 complex_entangled_layer 层\n", - " cir2.complex_entangled_layer(theta2, d, range(n))\n", - " # 输出态的态矢量\n", - " rho2 = cir2.run_state_vector()\n", - " # 计算保真度\n", - " f_list.append(abs(np.inner(rho1.numpy(), rho2.numpy().conj()))**2)\n", - " print(\" 采样完毕\")\n", - " f_list = np.array(f_list)\n", - " # 绘制概率分布图\n", - " if draw:\n", - " title_str = \"complex entangled layer, %d layer(s)\" % d\n", - " plot_hist(f_list, b, title_str)\n", - " distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", - " return distribution\n", - "\n", - "\n", - "# 设置电路宽度和最大深度\n", - "num_qubit = 4\n", - "max_depth = 3\n", - "# 计算哈尔采样对应的保真度分布\n", - "print(\"哈尔采样输出的保真度服从分布：\")\n", - "p_haar_4qubit, theory_haar_4qubit = p_F_haar(num_qubit, num_sample, draw=True)\n", - "Expr_cel = list()\n", - "# 计算不同深度的神经网络的表达能力\n", - "for DEPTH in range(1, max_depth + 1):\n", - " print(\"正在采样深度为 %d 的电路...\" % DEPTH)\n", - " p_cel = p_F_cel(num_qubit, DEPTH, num_sample, draw=True)\n", - " expr = entropy(p_cel, theory_haar_4qubit)\n", - " Expr_cel.append(expr)\n", - "# 比较不同深度的神经网络的表达能力\n", - "print(\"深度为 1,2,3 的神经网络的表达能力分别为\", np.around(Expr_cel, decimals=4))\n", - "plt.plot(range(1, max_depth + 1), Expr_cel, marker='>')\n", - "plt.xlabel(\"depth\")\n", - "plt.yscale('log')\n", - "plt.ylabel(\"Expr.\")\n", - "plt.xticks(range(1, max_depth + 1))\n", - "plt.title(\"Expressibility vs Circuit Depth\")\n", - "plt.show()" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "哈尔采样输出的保真度服从分布：\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "正在采样深度为 1 的电路...\n", - " 采样第 0 个样本...\n", - " 采样第 400 个样本...\n", - " 采样第 800 个样本...\n", - " 采样第 1200 个样本...\n", - " 采样第 1600 个样本...\n", - " 采样完毕\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "正在采样深度为 2 的电路...\n", - " 采样第 0 个样本...\n", - " 采样第 400 个样本...\n", - " 采样第 800 个样本...\n", - " 采样第 1200 个样本...\n", - " 采样第 1600 个样本...\n", - " 采样完毕\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "正在采样深度为 3 的电路...\n", - " 采样第 0 个样本...\n", - " 采样第 400 个样本...\n", - " 采样第 800 个样本...\n", - " 采样第 1200 个样本...\n", - " 采样第 1600 个样本...\n", - " 采样完毕\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "深度为 1,2,3 的神经网络的表达能力分别为 [0.3046 0.0175 0.0094]\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYoAAAEWCAYAAAB42tAoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAnt0lEQVR4nO3deXhV9dX28e/KHCAJCfOYyCCKICCBtPpateqjtVKtj7MgSJw6WWv72Fo717bWtrba2loEQcFZO1ltrW1tHVozMAmogEKYRMaQAUhIyHr/OJs0piQEOCc7Obk/15XrOtPeZ50h+z77t4dl7o6IiEhLEsIuQEREOjYFhYiItEpBISIirVJQiIhIqxQUIiLSKgWFiIi0SkEhccHM/mRm04PLM8zs1SN5rJlVm9mw2FccHWY2NKg5MQbzXmFmp0d7vtFkZmVmdlbYdcQ7BYU0Cv7p9gYLngN/vwi7rrZw94+5+0NH+1h37+HuawDMbJ6Z3RHNOo+EmR1rZk+Z2XYzqzCzN8zsFjNLdPf1Qc37o/287n6Cu/8jqOFbZrbgEHUe+P5UmdkuM/uXmd1oZlFZznSUz6MrUlBIc1OCBc+Bv89G+wli8es3XpnZcKAI2ACMdfcs4BIgH8g4xLQWrYX0YZji7hlALnAn8GVgTjvXIFGmoJA2MbNfmdkzTa7/0Mz+FiyMTjezjWb21eBXb5mZXdXksfOC6Z83s93AGWY20MyeMbNtZrbWzG5q8vjJZlZqZpVmtsXM7g5uTzOzBWa2I/jFWmJm/YL7/mFm136wZPtF8Av8bTM7s8kdzR/bdCI3sxFmdj1wFXBrsGb1rJn9X9P3IHj8vWZ2z0Hm82Uze7rZbfeY2b3B5Rlmtib49b226fvVzLeBf7n7Le6+GcDdV7r7le6+y8zygpqTmry275nZa8AeYJiZnWBmL5rZzuD9/GqTz6XxF/qBz7HJ9TIzO8vMzgW+ClwWvBdLW6i1kbtXuPsfgMuA6WY2Jphnqpn92MzWB7Xcb2bpTZ//YN+jg30eTZ5ufLCWVWFmT5hZ2qHqk8OTFHYB0ml8EVhiZjOAd4FCYLy7u5kB9Ad6A4OADwHPm1mpu68Mpr8SOA84H0gDXgF+D1wBDAb+amYr3f0F4B7gHnefb2Y9gDHBPKYDWcAQoBYYD+xtod4C4OmgpouA35jZMe6+sy0v1t1nmdnJwEZ3/xqAmQ0AvmVmPYOFdBJwOfCxg8ziceCbZpbh7lXBWtSlwCfNrDtwLzDJ3VcG881poZSzgNvaUnMT04KaVgLpwCrgx8AUIBkYfTgzc/c/m9n3gRHuPvUwpy0OwudUYDmRtYzhRD67OuBR4Bv85zW29D36r8+jiUuBc4Ea4DVgBnD/4dQprdMahTT3u+DX+oG/6wDcfQ+RBdDdwALgc+6+sdm0X3f3Wnf/J/AckX/gA37v7q+5ewMwFujj7t9x933BNoEHiCx0IbIAGWFmvd292t1fb3J7LyILrP3uvtDdK1t4HVuBn7l7nbs/QWSh+fGjeF8IftG/TGToByILp+3uvvAgj10HLAI+Gdz0UWBPk9fSAIwxs3R33+zuK1p42l7A5sMsdZ67r3D3eiLB/L67/8Tda9y9yt2LDnN+R+s9IMcivyiuB77g7jvdvQr4Pv/53A9o7Xt0MPe6+3vBj4BniYSQRJGCQpq70N17Nvl74MAdwQJmDWDAk82mK3f33U2urwMGNrm+ocnlXGBg00AiMrTRL7i/EDgWeDsYXjo/uH0+8ALwuJm9Z2Z3mVlyC69jk3/wjJfN6zlSDwEHflVPDWpqyaNE1pggskb1KEDwPl0G3AhsNrPnzOy4FuaxAxhwmDU2fa+HEFkDDNMgYCfQB+gGLGzyuf85uP2AQ32PDub9Jpf3AD2OumL5AAWFtJmZfQZIJfIL8dZmd2cHQyoHDA0ed0DThfYGYG2zQMpw9/MA3H21u18B9AV+CDxtZt2DtYNvu/to4GQiv5avbqHcQcEv2JbqaYuDnVr5d8CJwZj7+cAjrUz/FHC6mQ0msmbxaOOM3V9w97OJhMDbRNaoDuavwP8eRd0bgJZ2991NZMF9QP82zrPNzGwSkaB4FdhOZKjwhCafe5a7N12wt/Y90qmuQ6KgkDYxs2OBO4j8ip5GZKPi+GYP+7aZpZjZqUQWok+1MLtioCrY4JtuZolmNiZYqGBmU82sTzBMtSuYpsHMzjCzscF4fyWRoaiGFp6jL3CTmSWb2SXA8cDzh/myt9BsIevuNUS2fTwKFLv7+pYmdvdtwD+AuUSC8a3g9fUzswuCBWItUN3K6/gmcLKZ/cjM+gfTj7DIRv2ebXgNfwQGmNnNwYbkDDMrCO5bApxnZjnBvG9uZT5bgDxr415UZpYZrAk+Dixw92XB5/kA8FMz6xs8bpCZndNs8pa+R//1eUj7UFBIc8/aB4+j+G2w0XYB8EN3X+ruq4kMFc03s9RguveBciK//h4BbnT3tw/2BME+/+cTGUteS+SX5mwiG6ohMva/wsyqiWzYvtzd9xL5xfs0kZB4C/gnLQ/9FAEjg3l/D7jY3Xcc5nsxBxgdDJP8rsntDxHZztLasNMBjxLZIP1ok9sSgFuIvFc7gdOATx1sYnd/F/gwkEfkPakAngFKgapDPXmwHeBsIhuy3wdWA2cEd88HlgJlwF+AJ1qZ1YGF9Q4zW9TK4541syoiazK3E9mmdU2T+78MvAO8bmaVRNaYRjW5v7XvUUufh8SYqXGRHC2LHL27wN0Hh1xKuzCzoUSGi/q3sjFdDlNX+x51JlqjEDkMwdDLLcDjCgnpKnQchUgbBdsUthDZE+fckMsRaTcaehIRkVZp6ElERFoVl0NPvXv39ry8vLDLEBHpNBYuXLjd3fsc7L64DIq8vDxKS0vDLkNEpNMws3Ut3aehJxERaZWCQkREWqWgEBGRVikoRESkVQoKERFplYICOO+eV/jab5extbIm7FJERDqcuNw99nC9ubmS1VureGrhRi6ZOJibzhxJ30y13RURAa1RNKrb79TWN/B4yQZOveslrWGIiAQUFM3UN0QC45Hi9Xz2scVhlyMiErq4Cgozm2JmsyoqKo56XueNGcAvrpwQhapERDq3uAoKd3/W3a/Pyso69IObSU400pIS+OSEgfTNSKVo7Q6qa+pjUKWISOcSV0FxpEYPyOSySUN5+ctn8NPLJvDodR/CHabOLmLTrr1hlyciEqq47EeRn5/vR3tSwOWbKrjigdfp0yOVJ2/8ML17pB56IhGRTsrMFrp7/sHu0xpFC8YMymLujEm8V7GXq+cUU7G3LuySRERCoaBoRX5eDr+els/qrVXMnFfCnn3aZiEiXY+C4hBOO7YP91w+gcXry7lh/kJq6/eHXZKISLtSULTBeWMHcOdFJ/LK6u3c/PgS6vc3hF2SiEi7UVC00aWThvD180fzp+Xv85XfLKOhIf52AhARORid6+kwFP6/Y6jcW8c9f1tNRloS3zh/NGYWdlkiIjGloDhMN581kqqaeh58bS2Zacl84exjwy5JRCSmFBSHycz42sePp6rmP2sW1546LOyyRERiRkFxBBISjB9cNJbq2nrueO4tMtOSuXTSkLDLEhGJCW3MPkJJiQn87PLxnDqyN1/5zRs8v2xz2CWJiMSEguIopCYl8utpE5kwNJvPP76Yf67aFnZJIiJRp6A4St1SknhwxiRG9s3ghvmllJTtDLskEZGoUlBEQVZ6Mg8XTmZgVjoz55awfNPR98MQEekoFBRR0rtHKguuLSAzPZmrHyzmna3VYZckIhIVCoooGtgznfmFk0kwmDaniI3le8IuSUTkqCkoomxYnx48PLOA6tp6ps4uYltVbdgliYgcFQVFDIwemMm8ayaxpbKWaXOKqNijXhYi0nkpKGJkYm4Os66eyJptu7lmXjG7a9XLQkQ6JwVFDJ06sg/3XjGBJRt2qZeFiHRacRUUZjbFzGZVVHSc3VPPHdOfuy4ex6vvbOemxxarl4WIdDpxFRTu/qy7X5+VlRV2KR9w8cTBfHPKaF5YsYVbn3lDvSxEpFPRSQHbyTWnHENVTT13v7iKzLRkvjlFvSxEpHNQULSjz310BJV765j96loy05K45X9GhV2SiMghKSjakZlx+8ePp6qmnnv//g4Zaclc9xH1shCRjk1B0c7MjO8HvSy+9/xbZKQlcfnkoWGXJSLSIgVFCBITjJ9eNp7q2npu++0yeqQlcf6JA8MuS0TkoOJqr6fOJCUpgfunTiQ/N5ubH1/CS29vDbskEZGDUlCEKD0lkTkzJjGqfwY3LlhI0ZodYZckIvJfFBQhy0xL5uGZkxmcnU7hQ6Us29hxDhYUEQEFRYfQK+hlkZWezPS5xbyztSrskkREGikoOogBWeksuLaABDOmzi5mw071shCRjkFB0YEc07s7C66dzN66/UydU8TWypqwSxIRUVB0NMf1z2TuNZPYVlXLtDnF7NqzL+ySRKSLU1B0QCcNzeaBq/NZu3030+eWUK1eFiISIgVFB3XKiN78/MoJLN9UwfUPl1JTp14WIhIOBUUHds4J/fnRxSfyr3d38LnHFlOnXhYiEgIFRQd30UmD+c4FJ/Dim1u49Wn1shCR9qdzPXUCV384j6qaen70wkp6pCbxnQtOUC8LEWk3CopO4tOnD6dybx2/fnkNmelJ/N85x4Vdkoh0EQqKTsLM+MrHjqOypo77XnqXjLRkbjxteNhliUgXoKDoRMyMOy4cS1VNPXf+6W0y05K5skC9LEQkthQUnUxignH3pePZXVvP7b+L9LL4xDj1shCR2NFeT51QSlICv7xqIpPycrjliSX8/e0tYZckInFMQdFJpackMmd6PscPyORTCxbxunpZiEiMKCg6sYy0ZB6aOZkhOd0onFfC0g27wi5JROKQgqKTy+mewoLCArK7pzB9bjGrtqiXhYhEl4IiDvTPSuORawtITkxg6uwi1u9QLwsRiR4FRZzI7dWdBYUF1NY3MHVOEVvUy0JEokRBEUdG9c/goZmT2VFdy7Q5RZTvVi8LETl6Coo4M35ITx6Ynk/Zjj3MmFusXhYictQUFHHo5OG9+eWVJ7H8vUoK55Wol4WIHBUFRZw6a3Q/7r50HMVlO/nMI4vUy0JEjpiCIo5dMH4Q37lgDH97eytffHIp+9XLQkSOgM71FOemfSiXqpo67vrzSjLSkrjjwjHqZSEih0VB0QV8+vQRVO6t5/5/vktmejJfPle9LESk7Tp8UJjZMOB2IMvdLw67ns7qy+eOoqqmjl/9410y0pL49Okjwi5JRDqJmG6jMLMHzWyrmS1vdvu5ZrbSzN4xs6+0Ng93X+PuhbGssyswM757wRguGD+Qu/68kvmvrwu7JBHpJGK9RjEP+AXw8IEbzCwRuA84G9gIlJjZH4BE4AfNpp/p7ltjXGOXkZBg/PiScVTX1PON3y8nIzWJCycMCrssEengYhoU7v6ymeU1u3ky8I67rwEws8eBC9z9B8D5saxHIDkxgfuuOokZc4v54lNL6ZGaxFmj+4Vdloh0YGHsHjsI2NDk+sbgtoMys15mdj8wwcxua+Vx15tZqZmVbtu2LXrVxqG05ERmT5/EmIGZfPrRRfzr3e1hlyQiHViHP47C3Xe4+43uPjxY62jpcbPcPd/d8/v06dOeJXZKPVKTmHfNZHJzunHdQ6UsUS8LEWlBGEGxCRjS5Prg4DZpZ9ndU1hwbQG9eqQy/cFiVr6vXhYi8t/CCIoSYKSZHWNmKcDlwB9CqEOAfpmRXhZpyQlMnVPEuh27wy5JRDqYWO8e+xjwb2CUmW00s0J3rwc+C7wAvAU86e4rYlmHtG5ITjcWFBZQv7+Bq2YX8X6FelmIyH+Ye/yd/yc/P99LS0vDLqPTeWPjLq58oIj+WWk8ecOHyemeEnZJItJOzGyhu+cf7L4OvzH7cJjZFDObVVFREXYpndKJg3sye3o+G3buYfqDxVTV1IVdkoh0AHEVFO7+rLtfn5WVFXYpndaHhvXiV1NP4q3NlRQ+VKpeFiISX0Eh0fHR4/px92XjKSnbyacWLGRfvXpZiHRlCgo5qE+MG8j3LhzLSyu3ccuTS9TLQqQL6/Bnj5XwXFkwlKqaOn7wp7fJSEvi+58cq14WIl2QgkJadcNpw6msqeO+l94lIy2Z2z52nMJCpIuJq6AwsynAlBEj1Gshmr70P6Oo3FvPrJfXkJWezGfO0Psr0pXE1TYK7fUUG2bGtz9xAp+cMIgfvbCSh/9dFnZJItKO4mqNQmInIcG46+ITqa6t5xu/X0FGWhKfnDA47LJEpB3E1RqFxFZyYgI/v2ICJw/vxZeeeoMXVrwfdkki0g4UFHJY0pITmXV1PmMHZfG5Rxfz2jvqZSES7xQUctgivSwmcUzv7lz3cCmL1peHXZKIxJCCQo5Iz24pzC+cTJ+MVGY8WMxbmyvDLklEYkRBIUesb2YaCwoL6JaSxLQ5xZRtVy8LkXgUV0Ghs8e2vyE53Vhw7WQa3LlqdhGbK/aGXZKIRFlcBYWOowjHiL4ZPDxzMpV765g6u4gd1bVhlyQiURRXQSHhGTMoizkzJrGxfC9XP1hMpXpZiMQNBYVEzeRjcrh/2kRWvl9F4bwS9u5TLwuReKCgkKg6Y1Rffnb5eErXlXOjelmIxAUFhUTd+ScO5AefHMs/V23jC0+ol4VIZ3fEQWFms6JZiMSXyycP5fbzjue5ZZv56m+W4a6wEOmsDnlSQDNLBG5y9582u+vXsSlJ4sV1HxlGZU0dP//7O2SkJXH7x49XLwuRTuiQQeHu+83sCuCnzW5fGLOqJG7ccvaxVNXUM/vVtWSmJ3PTmSPDLklEDlNbTzP+mpn9AngCaDz81t0XxaSqI6TGRR2PmfGN80dTWVPH3S+uIiMtiWtOOSbsskTkMFhbxo7N7KWD3Ozu/tHol3T08vPzvbS0NOwypIn6/Q18+pFF/OXNLfz4knFcPFG9LEQ6EjNb6O75B7uvTWsU7n5GdEuSriYpMYGfXzmBwnml3Pr0UnqkJnLumAFhlyUibdCmvZ7MrJeZ3Wtmi8xsoZndY2a9Yl2cxJfUpER+PW0i44b05KbHlvDK6m1hlyQibdDW3WMfB7YB/wtcHFx+IlZFSfzqnprEvBmTGdanO9c/vJCF63aGXZKIHEJbg2KAu3/X3dcGf3cA/WJZmMSvrG7JzC8soF9mKjPmlvDme+plIdKRtTUo/mJml5tZQvB3KfBCLAuT+NYnI5UF1xbQIzWJqx8sYs226rBLEpEWtDUorgMeBWqDv8eBG8ysysz0c1COyODsbswvLMAdps4uYtMu9bIQ6YjaFBTunuHuCe6eHPwlBLdluHtmrIuU+DWibw8emjmZqpp6ps0uYrt6WYh0OG3d66mw2fVEM/tmbEqSrmbMoCwevGYS71Xs5eo5xVTsVS8LkY6krUNPZ5rZ82Y2wMzGAK8DGTGs64ioFWrnNSkvh19Py2f11ipmzithz776sEsSkUBbh56uBB4ClgHPATe7+5diWdiRUCvUzu20Y/twz+UTWLy+nBvmL6S2Xo2PRDqCtg49jQQ+DzwDrAOmmVm3WBYmXdN5Ywdw50Un8srq7dz8+BLq96vxkUjY2jr09CzwdXe/ATgNWA2UxKwq6dIunTSEr58/mj8tf5+v/GYZDWp8JBKqtp49drK7V0LkTIDAT8zs2diVJV1d4f87hsq9ddzzt9VkpCXxjfNHq5eFSEhaXaMws1sB3L3SzC5pdveMWBUlAnDzWSO55pQ85r5Wxj1/Wx12OSJd1qGGni5vcvm2ZvedG+VaRD7AzPj6x0dz8cTB/Oyvq5nz6tqwSxLpkg419GQtXD7YdZGoS0gw7rxoLLtr6/nuH98kIzWJSycNCbsskS7lUGsU3sLlg10XiYmkxAR+dvl4Th3Zm6/85g2eX7Y57JJEupRDBcU4M6s0syrgxODygetj26E+EeA/vSwmDM3m848v5p+r1MtCpL20GhTunujumcE5nZKCyweuJ7dXkSIA3VKSeHDGJEb2zeCG+aWUlKmXhUh7aOtxFCIdQlZ6Mg8XTmZgVjoz55awfJNO1yISawoK6XR690hl/rUFZKQlMf3BYt7Zql4WIrEUV0GhkwJ2HYN6prPg2gLMYNqcIjaW7wm7JJG4FVdBoZMCdi3D+vTg4ZkFVNfWM3V2Eduq1MtCJBbiKiik6xk9MJN510xiS2Ut0+YUUbFHvSxEok1BIZ3exNwcZl09kTXbdnPNvGJ216qXhUg0KSgkLpw6sg/3XjGeJRt2qZeFSJQpKCRunDtmAD/83xN59Z3t3PTYYvWyEIkSBYXElUvyh/DNKaN5YcUWbn3mDfWyEImCtvajEOk0rjnlGKpq6rn7xVVkpiXzzSnqZSFyNBQUEpc+99ERVO6tY/ara8lMS+KW/xkVdkkinZaCQuKSmXH7x4+nqqaee//+DhlpyVz3kWFhlyXSKSkoJG6ZGd+/aCzVtfV87/m3yEhL4vLJQ8MuS6TTUVBIXEtMMH562Xiqa+u57bfL6JGWxPknDgy7LJFORXs9SdxLSUrg/qkTyc/N5gtPLOGllVvDLkmkU1FQSJeQnpLInBmTOLZfBjfOX0jRmh1hlyTSaSgopMvITEvm4ZmTGZydTuFDpSzbqLMMi7SFgkK6lF49UllwbQFZ6clMn1vMO1urwi5JpMOLq6BQPwppiwFZkV4WCWZMnV3Mhp3qZSHSmrgKCvWjkLY6pnd35hdOZs++eqbOKWJrZU3YJYl0WHEVFCKH4/gBmcybOZltVbVMm1PMrj37wi5JpENSUEiXdtLQbB64Op+123czfW4J1eplIfJfFBTS5Z0yojc/v3ICyzdVcP3DpdTUqZeFSFMKChHgnBP686OLT+Rf7+7gc48tpk69LEQaKShEAhedNJhvf+IEXnxzC7c+rV4WIgfoXE8iTUw/OY+qmjp+/JdVZKQl8e1PnKBeFtLlKShEmvnMGSOorKln1stryEhL4v/OOS7skkRCpaAQacbMuO1jx1FVU8d9L71LRloyN542POyyREKjoBA5CDPjjgvHUlVTz51/epvMtGSuLFAvC+maFBQiLUhMMO6+dDy7a+u5/XeRXhafGKdeFtL1aK8nkVakJCXwy6smMikvh1ueWMLf394Sdkki7U5BIXII6SmJzJmez/EDMvnUgkW8rl4W0sUoKETaICMtmYdmTmZITjeufaiUNzbuCrskkXajoBBpo5zuKSwoLKBnt2SufrCYVVvUy0K6BgWFyGHon5XGI9cWkJyYwNTZRazfoV4WEv8UFCKHKbdXdxYUFlBb38DUOUVsUS8LiXMKCpEjMKp/Bg/NnMyO6lqmzSmifLd6WUj8UlCIHKHxQ3rywPR8ynbsYcbcYvWykLiloBA5CicP7819V57E8vcqufahEvWykLikoBA5SmeP7sdPLhlH0dqdfOaRReplIXFHQSESBRdOGMR3LhjD397eyhefXMp+9bKQOBJX53oysynAlBEjRoRdinRB0z6US1VNHXf9eSUZaUncceEY9bKQuBBXaxTu/qy7X5+VlRV2KdJFffr0Edx42nAeKVrPXS+sDLsckaiIqzUKkY7gy+eOorKmjl/9410y0pL49Olaw5XOTUEhEmVmxncvGEN1TX0wDJXMtA/lhl2WyBGLq6EnkY4iMcH4yaXjOPO4vnz9d8u56oHX2aojuKWTUlCIxEhyYgL3XXUSAK+9u4NTfvh3vvbbZQoM6XQUFCIxlJac2Hi5br/zWMkGTr3rJQWGdCoKCpF2tL/Bqa1vYEHRei687zVeWrmVir11YZcl0iptzBZpR4kJkeMqeqYns6WyhmvmlmAGo/plkJ+XzaS8HCbmZjOoZ7qOwZAOQ0Eh0g6SE41EMy7OH8JNZ46gb0Yae/bVs2TDLkrLyildV87vFr/HgtfXAzAgK438vBzyc7PJz8vmuP6ZjSEj0t4UFCIxNnpAJiflZjcGxAHdUpI4eXhvTh7eG4gMS618v4rSdTspKSuntGwnzy59D4AeqUlMGNqTSUF4jB/ak24p+veV9mHu8XdOmvz8fC8tLQ27DJGjtmnXXkrLdlJaVk5J2U5WbqnCPTKENWZgJhNzc5iUl83EvOwPhJDI4TKzhe6ef9D7FBQinUfF3joWry9vDI6lG3dRUxc5W21ur27k5+YE2zqyGd6nh7ZzSJspKETi1L76Bla8VxFs54iseewIuu1ld0tmYm42+XmRtY4xg7JITUo8xBylq2otKDTIKdKJpSQlMGFoNhOGZnMdw3B3ynbsoaRsZ2TIal05f31ra+Njxw3OatxIPjE3m57dUkJ+BdIZaI1CJM5tr65l4bpyFq6LDFct31RB3f7I//2x/Xo0bufIz81hSI52y+2qNPQkIo1q6vazdMMuSoPgWLiunKqaSL/vvhmpjcdyTMrL4fgBGSQl6rjcrkBDTyLSKC05kYJhvSgY1guAhgZn1dYqSsrKWVgW2TX3uWWbAeiWksiEoT3Jz81hUl4O44f2pEeqFhtdjdYoROS/bK7YG9lAHgTH2+9X0uCQYDB6YGaTvaty6Jep3XLjgYaeROSoVNXUsXh9ZLiqtGwni9fvYm/dfgCG5KQ3Bkd+bg4j+/YgQUeRdzoaehKRo5KRlsxHju3DR47tA0Dd/gbe2lzZeAT5K6u389vFmwDITEsiv8l2jhMHZ33gLLrS+WiNQkSOmruzfueeyHaO4BQk72ytBiAlMYExgzIjpx8JAiSnu3bL7Wg09CQi7a58977ILrnBgYDLNlawb3/kKPLhfbp/YDtHbq9u2i03ZAoKEQldTd1+lm2qaNxIXrquvLEXR+8eKf/ZzpGXwwkDM0nWbrntStsoRCR0acmJTMqL7GYLw2locN7ZVv2B4PjzivcBSE9OZPyQno3BcdLQnmSkJYf7ArowrVGISIexpbLmA+etenNzJfsbnASDUf0zI2fKDTaSD+yZHna5cUVDTyLSKe2ujTR3KglOtb54fTm790V2yx3UMz0Ijchax7H9MtTc6Sho6ElEOqXuqUmcMqI3p4yINHeq39/A2+9XRQ4EXFdO0dod/CFo7pSRmsRJQXBMzM1h/JCepKdot9xo0BqFiHRa7s7G8r2NXQEXlpWzcksVAEkJxphBWUE72ciG8t49UkOuuOPS0JOIdBm79uxjUdDcqbSsnCUbd7GvPrJb7jG9uzf2Ic/Py2FY7+7aLTegoBCRLqu2fj/LN1U2nrdq4bqdlO+J7Jab0z3lA9s5xgzMIiWpa+6Wq6AQEQm4O+9u2924S25p2U7KduwBIDUpgXFDejb25zgpN5us9K6xW66CQkSkFduqahtPPVK6rpwVmyqob3DM4Ni+GY1HkE/MzWZwdnw2d1JQiIgchj37IrvlLiwrp2RdOYvWlVNdG2nu1D8zLThTbmS46vgBmXGxW652jxUROQzdUpI4eXhvTh4e2S13f4Oz8v2qxr2rSst28sc3Is2deqQmNWnulM34oT3plhJfi1atUYiIHIFNu/ZGtnOURVrKrtxShTskJhgnNGnulJ+bTd9O0NypUw89mdmFwMeBTGCOu//lUNMoKESkvVXsrWNxsFtuSdlOlm7cRU1dZLfcoTndGrdz5OdmM7xPx2vuFFpQmNmDwPnAVncf0+T2c4F7gERgtrvf2YZ5ZQM/dvfCQz1WQSEiYdtX38CK9yo+cO6qHbv3AdCzWzL5uZEjyCflZTN2cBapSeEeRR5mUHwEqAYePhAUZpYIrALOBjYCJcAVRELjB81mMdPdtwbT/QR4xN0XHep5FRQi0tG4O2U79gTnrYrsmrtm224g0tzpxMFZkSPIcyMnPsxu5+ZOoQ49mVke8McmQfFh4Fvufk5w/TYAd28eEgemN+BO4EV3/2srz3M9cD3A0KFDJ65bty6aL0NEJOp2VNdSuq480uCpbCfLN1VQtz+yTB7Zt0djH/JJeTkMyYntbrkdba+nQcCGJtc3AgWtPP5zwFlAlpmNcPf7D/Ygd58FzILIGkWUahURiZlePVI554T+nHNCfyDS3Gnphl2UBsHxxzc281hxZHHZJyO18UDA/LxsRg/IJCkxgfPueYWThvbkpjNHxmyjeYffh8vd7wXuDbsOEZFYS0tOpGBYLwqG9QKgocFZtbUqOOFhZNfc55dFmjt1S0lkwtCevLm5klVbqnhq4UYumTg4JoERRlBsAoY0uT44uE1ERJpISDCO65/Jcf0zmfahXAA2V+z9QFdAgPoGp77BWVC0PiaBEUZQlAAjzewYIgFxOXBlCHWIiHQ6A7LSmTIunSnjBgKQ95XnPnB/bX0DjxSvZ9XWap684cNRec6YnibRzB4D/g2MMrONZlbo7vXAZ4EXgLeAJ919RSzrEBHpCpITjbSkBK4qyOUXV06I2nxjukbh7le0cPvzwPPRfj4zmwJMGTFiRLRnLSLSYSUnGolmXJw/hJvOHEHfjM6/jSJm3P1Z4Nn8/Pzrwq5FRKQ9jB6QyUm52TEJiAPiKihERLqa5z9/asyfo2u2chIRkTZTUIiISKsUFCIi0ioFhYiItCqugsLMppjZrIqKirBLERGJGx2+cdGRMLNtwJGePrY3sD2K5Yg0pe+XxNLRfL9y3b3Pwe6Iy6A4GmZW2tKpdkWOlr5fEkux+n7F1dCTiIhEn4JCRERapaD4b7PCLkDimr5fEksx+X5pG4WIiLRKaxQiItIqBYWIiLRKQREwswfNbKuZLQ+7Fok/ZjbEzF4yszfNbIWZfT7smiR+mFmamRWb2dLg+/XtqM5f2ygizOwjQDXwsLuPCbseiS9mNgAY4O6LzCwDWAhc6O5vhlyaxAEzM6C7u1ebWTLwKvB5d389GvPXGkXA3V8GdoZdh8Qnd9/s7ouCy1VE2gAPCrcqiRceUR1cTQ7+orYWoKAQaWdmlgdMAIpCLkXiiJklmtkSYCvwortH7fuloBBpR2bWA3gGuNndK8OuR+KHu+939/HAYGCymUVtCF1BIdJOgrHjZ4BH3P03Ydcj8cnddwEvAedGa54KCpF2EGxsnAO85e53h12PxBcz62NmPYPL6cDZwNvRmr+CImBmjwH/BkaZ2UYzKwy7JokrpwDTgI+a2ZLg77ywi5K4MQB4yczeAEqIbKP4Y7Rmrt1jRUSkVVqjEBGRVikoRESkVQoKERFplYJCRERapaAQEZFWKShEosDMvmVmXzqC6cY33U32SOcjEksKCpFwjQd0PIV0aAoKkSNkZreb2SozexUYFdw23Mz+bGYLzewVMzsuuH2emd1vZqXBNOebWQrwHeCy4AC8y4JZjzazf5jZGjO7KZxXJ/IfSWEXINIZmdlE4HIiawRJwCIiPSZmATe6+2ozKwB+CXw0mCwPmAwMJ3IunhHAN4B8d/9sMN9vAccBZwAZwEoz+5W717XLCxM5CAWFyJE5Ffitu+8BMLM/AGnAycBTkVM7AZDaZJon3b0BWG1ma4gEwsE85+61QK2ZbQX6ARtj8BpE2kRBIRI9CcCu4FTPB9P8fDktnT+ntsnl/ej/VEKmbRQiR+Zl4EIzSw9am04B9gBrzewSiJwx1szGNZnmEjNLMLPhwDBgJVBFZIhJpMNSUIgcgaCt6RPAUuBPRM7YCXAVUGhmS4EVwAVNJlsPFAePv9Hda4hsqxjdbGO2SIeis8eKtAMzmwf80d2fDrsWkcOlNQoREWmV1ihERKRVWqMQEZFWKShERKRVCgoREWmVgkJERFqloBARkVb9f6xLTLtWvh2tAAAAAElFTkSuQmCC" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": { - "scrolled": true - } - }, - { - "cell_type": "markdown", - "source": [ - "可见随着电路深度的增加，量子神经网络的表达能力也在逐渐增强。感兴趣的读者不妨自己动手尝试一下其他量桨内置拟设的表达能力计算，以及比较不同拟设之间表达能力的差别。" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "_______\n", - "\n", - "## 参考文献\n", - "\n", - "[1] Nielsen, Michael A., and Isaac L. Chuang. \"Quantum Computation and Quantum Information.\" Cambridge University Press, 2010.\n", - "\n", - "[2] Sim, Sukin, Peter D. Johnson, and Alán Aspuru‐Guzik. \"Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum‐classical algorithms.\" [Advanced Quantum Technologies 2.12 (2019): 1900070](https://onlinelibrary.wiley.com/doi/abs/10.1002/qute.201900070)." - ], - "metadata": {} - } - ], - "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 -} \ No newline at end of file diff --git a/tutorial/qnn_research/Expressibility_EN.ipynb b/tutorial/qnn_research/Expressibility_EN.ipynb deleted file mode 100644 index f0037c4..0000000 --- a/tutorial/qnn_research/Expressibility_EN.ipynb +++ /dev/null @@ -1,690 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "# Expressibility of Quantum Neural Network\n", - "\n", - "Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Overview" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "In quantum machine learning, the **expressibility** of quantum neural networks is a crucial factor in quantum machine learning tasks. In general, the stronger the expressiveness of the proposed quantum neural network, the higher the likelihood that quantum machine learning can search for the global optimal solution. This tutorial first introduces the basic concept of the expressibility of quantum neural networks. Then we will show how to exhibit the difference in the expressibility of different ansatz through Bloch spheres in Paddle Quantum. Finally, a method for quantitatively analyzing the expressibility of quantum neural networks is introduced, and the expressibility of quantum neural network templates provided by Paddle Quantum is evaluated at different depths." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Background" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "Let us first review the basic process of quantum machine learning algorithms. In quantum machine learning, we tend to design a loss function $\\mathcal{L}$ and minimize the loss function by optimizing a unitary $U$\n", - "\n", - "$$\n", - "\\min_U\\mathcal{L}(U)=\\min_U \\text{Tr}[HU\\rho_{in}U^\\dagger].\\tag{1}\n", - "$$\n", - "\n", - "The mathematical principle behind the algorithm guarantees that the minimum value that the loss function can take corresponds to the solution of our problem when we have traversed all possible unitaries. In practice, we use quantum neural networks to parameterize the unitaries as follows\n", - "\n", - "$$\n", - "U=U(\\vec{\\theta})=U_D(\\vec{\\theta}_D)\\dots U_1(\\vec{\\theta}_1),\\tag{2}\n", - "$$\n", - "\n", - "where each $U_j(\\vec{\\theta}_j),j\\in[1,D]$ represents a layer of the quantum neural network, and $\\vec{\\theta}_j$ represents the parameters corresponding to that layer. At this point, by adjusting the parameters $\\vec{\\theta}$ in the quantum neural network, we can perform the optimization of the unitary $U$ and thus minimize the loss function $\\mathcal{L}$.\n", - "\n", - "$$\n", - "\\min_{\\vec{\\theta}}\\mathcal{L}(\\vec{\\theta})=\\min_{\\vec{\\theta}} \\text{Tr}[HU(\\vec{\\theta})\\rho_{in}U(\\vec{\\theta})^\\dagger].\\tag{3}\n", - "$$\n", - "\n", - "However, careful readers may have noticed a shortcoming of quantum neural networks at this point: for a given neural network fit, ** traversing all the parameters does not necessarily guarantee traversing all the unitaries**. As a simple example, if we allow only one $R_Y$ rotation gate as a single-qubit quantum neural network $U(\\theta)=R_Y(\\theta)$, it is clear that (up to a global phase) $U(\\theta)$ cannot represent any complex unitary with the imaginary part of matrix elements. And when allowing the use of $R_Y$ and $R_Z$ revolving gates, if we build the quantum neural network as $U(\\vec{\\theta})=R_Z(\\theta_1)R_Y(\\theta_2)R_Z(\\theta_3)$, $U(\\vec{\\theta})$ (up to a global phase) will be able to represent all the single-qubit unitaries [1].\n", - "\n", - "If we define the expressibility of a neural network as **the number of unitaries that the circuit can express when traversing the circuit parameters $\\vec{\\theta}$**, then a quantum neural network with strong expressibility will be more likely to contain those unitaries that globally minimize the loss function $\\mathcal{L}$; conversely, if a quantum neural network $U_{ weak}$ is so weak that it does not contain any unitary that minimize the loss function, then a quantum machine learning task based on optimizing $U_{weak}$ is likely to fail.\n", - "\n", - "Next, we visualize the expressibility of quantum neural networks based on Paddle Quantum by looking at the ability of a single qubit to traverse the Bloch sphere through unitaries." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Intuition: traversing the Bloch sphere" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "In the one qubit case, we can directly observe how a quantum neural network traverses the surface of a Bloch sphere with a fixed input. For a given neural network ansatz $U(\\vec{\\theta})$, since the input to the network tends to be fixed (we set it to $|0\\rangle$), by uniformly sampling the neural network parameters $\\vec{\\theta}$, the output state of the neural network $U(\\vec{\\theta})|0\\rangle$ will be scattered over the surface of the Bloch sphere. Obviously, if the output states are more widely and uniformly distributed on the surface of the sphere, the more expressive the neural network ansatz $U$ will be, and the more likely it will contain the global optimum of the loss function.\n", - "\n", - "To implement this function in Paddle, we first import necessary packages." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 1, - "source": [ - "import numpy as np\n", - "from numpy.random import random\n", - "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import plot_state_in_bloch_sphere" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "First, we allow only one $R_Y$ rotation gate to construct quantum neural network $U(\\theta)=R_Y(\\theta)$. By uniformly sampling the parameter $\\theta$ at $[0,2\\pi]$ and acting $U(\\theta)$ on a fixed input $|0\\rangle$, we obtain the output distribution of the quantum neural network $U(\\theta)$. With the built-in plot_bloch_sphere_from_input function of Paddle Quantum, we can directly observe the distribution of $U(\\theta)|0\\rangle$ on the Bloch sphere as follows." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 2, - "source": [ - "num_qubit = 1 # the number of qubit\n", - "num_sample = 2000 # the number of sample\n", - "outputs_y = list() # save QNN outputs\n", - "\n", - "for _ in range(num_sample):\n", - " # initialize QNN ansatz\n", - " cir = UAnsatz(num_qubit)\n", - " # uniformly sample the parameter between 0 and 2 pi\n", - " theta = paddle.to_tensor(2 * np.pi * random(size=1), dtype='float64')\n", - " # apply Ry\n", - " cir.ry(theta, 0)\n", - " # output a density operator\n", - " rho = cir.run_density_matrix()\n", - " outputs_y.append(rho.numpy())\n", - " \n", - "# built-in function of Paddle Quantum to plot on Bloch sphere\n", - "# plot_state_in_bloch_sphere(outputs_y, save_gif=True, filename='figures/bloch_y.gif')" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "![bloch_y.gif](./figures/expressibility-fig-bloch_y.gif)" - ], - "metadata": {}, - "attachments": { - "bloch_y.gif": { - "image/gif": "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" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "It can be seen that the output of the quantum neural network $U(\\theta)=R_Y(\\theta)$ can only be distributed in a circle on the Bloch sphere (although the distribution is uniform over the circle). Similarly, we consider the neural network $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ with two parameters and the neural network $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ with three parameters. The output distribution is:" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 3, - "source": [ - "outputs_yz = list() # save QNN outputs\n", - "for _ in range(num_sample):\n", - " # initialize QNN ansatz\n", - " cir = UAnsatz(num_qubit)\n", - " # uniformly sample the parameters between 0 and 2 pi\n", - " theta = paddle.to_tensor(2 * np.pi * random(size=2), dtype='float64')\n", - " # apply Ry and Rz\n", - " cir.ry(theta[0], 0)\n", - " cir.rz(theta[1], 0)\n", - " # output a density operator\n", - " rho = cir.run_density_matrix()\n", - " outputs_yz.append(rho.numpy())\n", - "# plot_state_in_bloch_sphere(outputs_yz, save_gif=True, filename='figures/bloch_yz.gif')\n", - " \n", - "outputs_yzy = list() # save QNN outputs\n", - "for _ in range(num_sample):\n", - " # initialize QNN ansatz\n", - " cir = UAnsatz(num_qubit)\n", - " # uniformly sample the parameters between 0 and 2 pi\n", - " theta = paddle.to_tensor(2 * np.pi * random(size=3), dtype='float64')\n", - " # apply Ry, Rz, and Ry\n", - " cir.ry(theta[0], 0)\n", - " cir.rz(theta[1], 0)\n", - " cir.ry(theta[2], 0)\n", - " # output a density operator\n", - " rho = cir.run_density_matrix()\n", - " outputs_yzy.append(rho.numpy())\n", - "# plot_state_in_bloch_sphere(outputs_yzy, save_gif=True, filename='figures/bloch_yzy.gif')" - ], - "outputs": [], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "![bloch_yz.gif](./figures/expressibility-fig-bloch_yz.gif)" - ], - "metadata": {}, - "attachments": { - "bloch_yz.gif": { - "image/gif": "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" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "![bloch_yzy.gif](./figures/expressibility-fig-bloch_yzy.gif)" - ], - "metadata": {}, - "attachments": { - "bloch_yzy.gif": { - "image/gif": "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" - } - } - }, - { - "cell_type": "markdown", - "source": [ - "It can be seen that the output of the neural network $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ can be distributed over the entire surface of the Bloch sphere now, although the distribution is more concentrated near the two polars ($|0\\rangle$ and $|1\\rangle$); and the output of the neural network $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ is more uniformly distributed over the surface of the sphere." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "In the low-dimensional case of single qubit, we can qualitatively observe the expressibility of quantum neural networks with the help of Bloch spheres. In general situations with multiple qubits, we have to analyze the expressibility quantitatively via statistical mathematical tools. Next, we will introduce the K-L divergence of the fidelity distribution among quantum states to quantify the expressibility of a quantum neural network and calculate the expressibility of a commonly used ansatz." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "## Quantitative analysis of expressibility by the K-L divergence" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "### Fidelity distribution and the K-L divergence" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "In [2], the authors proposed a method for quantifying the expressive power based on the probability distribution of fidelity between the output states of a quantum neural network. For any quantum neural network $U(\\vec{\\theta})$, sampling the neural network parameters twice (let them be $\\vec{\\phi}$ and $\\vec{\\psi}$), the fidelity $F=|\\langle0|U(\\vec{\\phi})^\\dagger U(\\vec{\\psi}) |0\\rangle|^2$ subjects to some probability distribution\n", - "$$\n", - "F\\sim{P}(f).\\tag{4}\n", - "$$\n", - "According to [2], when a quantum neural network $U$ can uniformly represent unitaries (now we call that $U$ subjects to the Haar measure), the probability distribution of fidelity $P_\\text{Haar}(f)$ satisfies\n", - "$$\n", - "P_\\text{Haar}(f)=(2^{n}-1)(1-f)^{2^n-2}.\\tag{5}\n", - "$$\n", - "\n", - "Paddle Quantum provides functions that sample unitaries from the Haar measure. We evaluate the probability distribution that the fidelity of the outputs of the Haar random unitaries subjects to:" - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 4, - "source": [ - "from paddle_quantum.utils import haar_unitary, state_fidelity\n", - "import matplotlib.pyplot as plt\n", - "from matplotlib.ticker import FuncFormatter\n", - "from scipy import integrate\n", - "\n", - "# plot histgram\n", - "def plot_hist(data, num_bin, title_str):\n", - " def to_percent(y, position):\n", - " return str(np.around(y*100, decimals=2)) + '%'\n", - " plt.hist(data, weights=[1./len(data)]*len(data), bins=np.linspace(0, 1, num=num_bin), facecolor=\"blue\", edgecolor=\"black\", alpha=0.7)\n", - " plt.xlabel(\"Fidelity\")\n", - " plt.ylabel(\"frequency\")\n", - " plt.title(title_str)\n", - " formatter = FuncFormatter(to_percent)\n", - " plt.gca().yaxis.set_major_formatter(formatter)\n", - " plt.show()\n", - " \n", - " \n", - "# evaluate the probability distribution of F generated by a Haar random unitary\n", - "def p_F_haar(n, s, b=50, draw=False):\n", - " f_list = list()\n", - " # sampling\n", - " for i in range(s):\n", - " # sample a unitary\n", - " u1 = haar_unitary(n)\n", - " # the output of u1\n", - " phi1 = u1[:,0]\n", - " rho1 = np.outer(phi1, phi1.conj())\n", - " # sample a unitary\n", - " u2 = haar_unitary(n)\n", - " phi2 = u2[:,0]\n", - " # the output of u2\n", - " rho2 = np.outer(phi2, phi2.conj())\n", - " # compute fidality\n", - " f_list.append(state_fidelity(rho1, rho2)**2)\n", - " f_list = np.array(f_list)\n", - " # plot histgram\n", - " if draw:\n", - " title_str = \"haar, %d qubit(s)\" % num_qubit\n", - " plot_hist(f_list, b, title_str)\n", - " sample_distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", - " # compute a theoretical distribution\n", - " theory_distribution = np.zeros_like(sample_distribution)\n", - " for index in range(len(theory_distribution)):\n", - " def p_continues(f):\n", - " return (2 ** n - 1) * (1 - f) ** (2 ** n - 2)\n", - " lower = 1/b*index\n", - " upper = lower + 1/b\n", - " theory_distribution[index], _ = integrate.quad(p_continues,lower,upper)\n", - " return sample_distribution, theory_distribution\n", - "\n", - "\n", - "num_qubit = 1\n", - "p_haar_1qubit, theory_haar_1qubit = p_F_haar(num_qubit, num_sample, draw=True)\n", - "num_qubit = 2\n", - "p_haar_2qubit, theory_haar_2qubit = p_F_haar(num_qubit, num_sample, draw=True)" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "It can be seen that the fidelity distribution roughly obeys $P_\\text{Haar}$. Similarly, we can compute the probability distributions of the fidelity of the outputs of the previously defined single-qubit quantum neural networks $R_Y(\\theta)$, $R_Y(\\theta_1)R_Z(\\theta_2)$ and $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 5, - "source": [ - "# evaluate the probability distribution of F generated by QNNs\n", - "def p_F_qnn(n, s, g, b=50, draw=False):\n", - " f_list = list()\n", - " rho_sample = outputs_y\n", - " title_str = \"Ry\"\n", - " if g == 2:\n", - " rho_sample = outputs_yz\n", - " title_str = \"Ry-Rz\"\n", - " elif g == 3:\n", - " rho_sample = outputs_yzy\n", - " title_str = \"Ry-Rz-Ry\"\n", - " # use previously collected data to compute fidelity\n", - " for index in range(int(s / 2)):\n", - " rho1 = rho_sample[index]\n", - " rho2 = rho_sample[index+int(num_sample / 2)]\n", - " f_list.append(state_fidelity(rho1, rho2)**2)\n", - " f_list = np.array(f_list)\n", - " # plot histgram\n", - " if draw:\n", - " plot_hist(f_list, b, title_str)\n", - " distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", - " return distribution\n", - " \n", - " \n", - "num_qubit = 1\n", - "p_y = p_F_qnn(num_qubit, num_sample, 1, draw=True)\n", - "p_yz = p_F_qnn(num_qubit, num_sample, 2, draw=True)\n", - "p_yzy = p_F_qnn(num_qubit, num_sample, 3, draw=True)" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": { - "scrolled": true - } - }, - { - "cell_type": "markdown", - "source": [ - "Evidently, the fidelity distribution of the outputs of the neural network composed of $R_Y-R_Z-R_Y$ gates is closest to that of the Haar random unitary. The K-L divergence (also called relative entropy) in statistical mathematics can measure the difference between two probability distributions. The K-L divergence between two discrete probability distributions $P,Q$ is defined as\n", - "$$\n", - "D_{KL}(P||Q)=\\sum_jP(j)\\ln\\frac{P(j)}{Q(j)}.\\tag{6}\n", - "$$\n", - "If the fidelity distribution of the outputs of a quantum neural network is denoted as $P_\\text{QNN}(f)$, the expressibility of the quantum neural network is defined as the K-L divergence between $P_\\text{QNN}(f)$ and $P_\\text{Haar}(f)$ [2]\n", - "$$\n", - "\\text{Expr}_\\text{QNN}=D_{KL}(P_\\text{QNN}(f)||P_\\text{Haar}(f)).\\tag{7}\n", - "$$\n", - "Therefore, the closer $P_\\text{QNN}(f)$ is to $P_\\text{Haar}(f)$, the smaller the $\\text{Expr}$ will be (more close to 0), and the more expressive the quantum neural network will be; conversely, the larger the $\\text{Expr}$ is, the less expressive the quantum neural network will be.\n", - "\n", - "We can directly calculate the expressibility of single-qubit quantum neural networks $R_Y(\\theta)$, $R_Y(\\theta_1)R_Z(\\theta_2)$ and $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ according to this definition." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 6, - "source": [ - "from scipy.stats import entropy\n", - "# calcutale relative entropy (K-L divergence)\n", - "expr_y = entropy(p_y, theory_haar_1qubit)\n", - "expr_yz = entropy(p_yz, theory_haar_1qubit)\n", - "expr_yzy = entropy(p_yzy, theory_haar_1qubit)\n", - "print(\"The expressiblity of Ry, Ry-Rz, and Ry-Rz-Rz are %.2f, %.2f, and %.2f, respectively.\" %(expr_y, expr_yz, expr_yzy))" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "The expressiblity of Ry, Ry-Rz, and Ry-Rz-Rz are 0.24, 0.04, and 0.03, respectively.\n" - ] - } - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "### Evaluate the expressibility of QNNs" - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "We now have our tool, the K-L divergence, to quantitatively study the expressibility of any quantum neural network ansatz. As a practical application, let us explore the variation of the expressibility of a Paddle Quantum QNN tamplate with different circuit depth. Here we set the width of the circuit to 4-qubit." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 7, - "source": [ - "# evaluate the probability distribution of F generated by the complex entangled QNN\n", - "def p_F_cel(n, d, s, b=50, draw=False):\n", - " f_list = list()\n", - " for index in range(int(s / 2)):\n", - " if 2 * index % 400 == 0:\n", - " print(\" sampling %d-th sample...\" % (2 * index))\n", - " cir1 = UAnsatz(n)\n", - " # uniformly sample the parameters between 0 and 2 pi\n", - " theta1 = paddle.to_tensor(2 * np.pi * random(size=(d, n, 3)), dtype='float64')\n", - " # add complex entangled layers\n", - " cir1.complex_entangled_layer(theta1, d, range(n))\n", - " # output a state vector\n", - " rho1 = cir1.run_state_vector()\n", - " cir2 = UAnsatz(n)\n", - " # uniformly sample the parameters between 0 and 2 pi\n", - " theta2 = paddle.to_tensor(2 * np.pi * random(size=(d, n, 3)), dtype='float64')\n", - " # add complex entangled layers\n", - " cir2.complex_entangled_layer(theta2, d, range(n))\n", - " # output another state vector\n", - " rho2 = cir2.run_state_vector()\n", - " # calculate fidelity\n", - " f_list.append(abs(np.inner(rho1.numpy(), rho2.numpy().conj()))**2)\n", - " print(\" sample finished\")\n", - " f_list = np.array(f_list)\n", - " # plot histgram\n", - " if draw:\n", - " title_str = \"complex entangled layer, %d layer(s)\" % d\n", - " plot_hist(f_list, b, title_str)\n", - " distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", - " return distribution\n", - "\n", - "\n", - "# set the width and maximal depth \n", - "num_qubit = 4\n", - "max_depth = 3\n", - "# evaluate the probability distribution of F generated by a Haar random unitaty\n", - "print(\"F generated by a Haar random unitaty：\")\n", - "p_haar_4qubit, theory_haar_4qubit = p_F_haar(num_qubit, num_sample, draw=True)\n", - "Expr_cel = list()\n", - "# evaluate the expressibility of QNNs with different depth\n", - "for DEPTH in range(1, max_depth + 1):\n", - " print(\"sampling QNNs with depth %d...\" % DEPTH)\n", - " p_cel = p_F_cel(num_qubit, DEPTH, num_sample, draw=True)\n", - " expr = entropy(p_cel, theory_haar_4qubit)\n", - " Expr_cel.append(expr)\n", - "# compare the expressibility\n", - "print(\"The expressibility of depth 1, 2 and 3 is\", np.around(Expr_cel, decimals=4))\n", - "plt.plot(range(1, max_depth + 1), Expr_cel, marker='>')\n", - "plt.xlabel(\"depth\")\n", - "plt.yscale('log')\n", - "plt.ylabel(\"Expr.\")\n", - "plt.xticks(range(1, max_depth + 1))\n", - "plt.title(\"Expressibility vs Circuit Depth\")\n", - "plt.show()" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "F generated by a Haar random unitaty：\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "sampling QNNs with depth 1...\n", - " sampling 0-th sample...\n", - " sampling 400-th sample...\n", - " sampling 800-th sample...\n", - " sampling 1200-th sample...\n", - " sampling 1600-th sample...\n", - " sample finished\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "sampling QNNs with depth 2...\n", - " sampling 0-th sample...\n", - " sampling 400-th sample...\n", - " sampling 800-th sample...\n", - " sampling 1200-th sample...\n", - " sampling 1600-th sample...\n", - " sample finished\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "sampling QNNs with depth 3...\n", - " sampling 0-th sample...\n", - " sampling 400-th sample...\n", - " sampling 800-th sample...\n", - " sampling 1200-th sample...\n", - " sampling 1600-th sample...\n", - " sample finished\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - }, - { - "output_type": "stream", - "name": "stdout", - "text": [ - "The expressibility of depth 1, 2 and 3 is [0.3442 0.0154 0.0098]\n" - ] - }, - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": { - "scrolled": true - } - }, - { - "cell_type": "markdown", - "source": [ - "As we would observe, the expressibility of the quantum neural network is gradually enhanced with the increase of circuit depth. Interested readers are welcome to try to evaluate the expressibility of other Paddle Quantum QNN templates, and compare the difference in expressibility between different templates." - ], - "metadata": {} - }, - { - "cell_type": "markdown", - "source": [ - "_______\n", - "\n", - "## References\n", - "\n", - "[1] Nielsen, Michael A., and Isaac L. Chuang. \"Quantum Computation and Quantum Information.\" Cambridge University Press, 2010.\n", - "\n", - "[2] Sim, Sukin, Peter D. Johnson, and Alán Aspuru‐Guzik. \"Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum‐classical algorithms.\" [Advanced Quantum Technologies 2.12 (2019): 1900070](https://onlinelibrary.wiley.com/doi/abs/10.1002/qute.201900070)." - ], - "metadata": {} - } - ], - "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 -} \ No newline at end of file diff --git a/tutorial/qnn_research/Gradient_CN.ipynb b/tutorial/qnn_research/Gradient_CN.ipynb deleted file mode 100644 index a6840e7..0000000 --- a/tutorial/qnn_research/Gradient_CN.ipynb +++ /dev/null @@ -1,917 +0,0 @@ -{ - "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 deleted file mode 100644 index b4b02ef..0000000 --- a/tutorial/qnn_research/Gradient_EN.ipynb +++ /dev/null @@ -1,861 +0,0 @@ -{ - "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/quantum_simulation/ClassicalShadow_Intro_CN.ipynb b/tutorial/quantum_simulation/ClassicalShadow_Intro_CN.ipynb deleted file mode 100644 index d78f66e..0000000 --- a/tutorial/quantum_simulation/ClassicalShadow_Intro_CN.ipynb +++ /dev/null @@ -1,383 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "prescription-lighter", - "metadata": {}, - "source": [ - "# 未知量子态的经典影子" - ] - }, - { - "cell_type": "markdown", - "id": "loaded-consultation", - "metadata": {}, - "source": [ - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "id": "comfortable-guidance", - "metadata": {}, - "source": [ - "## 概览" - ] - }, - { - "cell_type": "markdown", - "id": "cellular-armstrong", - "metadata": {}, - "source": [ - "对于一个未知量子系统中的量子态 $\\rho$，如何去获取它所包含的信息是一个十分基础且重要的问题。本教程将讨论如何通过经典影子（classical shadow） 技术用经典的数据来描述一个未知的量子态，从而可以高效地对该量子态的诸多性质进行有效估计。在 NISQ （noisy intermediate-scale quantum）时代，这个技术可以很好地帮助我们用经典资源来交换量子资源，在将量子态的信息用经典数据描述后，可以用经典机器学习等方法来解决一些量子问题。并且利用这个方法，一些现有的变分量子算法（例如变分量子本征求解器（variational quantum eigensolver, VQE））实现中的量子电路运行次数等代价将减小，进而提升算法的速度。" - ] - }, - { - "cell_type": "markdown", - "id": "stainless-enemy", - "metadata": {}, - "source": [ - "## 经典影子" - ] - }, - { - "cell_type": "markdown", - "id": "7020ecd5", - "metadata": {}, - "source": [ - "经典影子的直觉来源于现实生活中的影子。我们用一束光垂直照向一个多面体，会在桌面上得到一个它的影子，旋转这个多面体，我们可以看到它不同形状的影子。在多次旋转后，这一系列的影子很自然地就反映了这个多面体的一些信息。类似地，在量子世界，如果我对一个量子态进行一次酉变换，然后进行一次测量，是否也能得到一个量子态的“影子”？经典影子的构建就和这个例子有相似之处，它的过程如下：\n", - "\n", - "首先，我们对 $n$ 个量子比特系统中的一个未知量子态 $\\rho$ 作用一个酉变换：$\\rho \\mapsto U \\rho U^{\\dagger}$ ，然后用计算基态去对每个量子位做测量。对于测量的结果这里用 $|\\hat{b}\\rangle$ 举例解释：对 $|\\hat{b}\\rangle$ 进行之前酉变换的逆变换得到 $U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U$。我们知道，测得的量子态 $|\\hat{b}\\rangle\\langle\\hat{b}|$在计算基态下期望为：\n", - "\n", - "$$\n", - "\\mathbb{E}(|\\hat{b}\\rangle\\langle\\hat{b}|) = \\sum_{b \\in \\{0,1\\}^{n}} \\operatorname{Pr}(|\\hat{b}\\rangle\\langle\\hat{b}| = |b\\rangle\\langle b|)\\cdot |b\\rangle \\langle b|= \\sum_{b \\in \\{0,1\\}^{n}}\\langle b|U\\rho U^{\\dagger} |b\\rangle |b\\rangle \\langle b| \\tag{1}\n", - "$$\n", - "\n", - "那么进行了逆操作后，$U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U$ 的期望就是 $\\sum_{b \\in \\{0,1\\}^{n}}\\langle b|U\\rho U^{\\dagger} |b\\rangle U^{\\dagger}|b\\rangle \\langle b|U$。在这个过程中，酉变换 $U$ 是从一个固定的集合中随机选取。当我们重复这一过程，对每次随机选取的 $U$ 也求平均时，可以得到：\n", - "\n", - "$$\n", - "\\mathbb{E}_{U \\sim \\mathcal{U}\\left(n\\right)}(\\mathbb{E}(U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U))=\\sum_{b \\in \\{0,1\\}^{n}}\\mathbb{E}_{U \\sim \\mathcal{U}\\left(n\\right)}(\\langle b|U\\rho U^{\\dagger} |b\\rangle U^{\\dagger}|b\\rangle \\langle b|U) \\tag{2}\n", - "$$ \n", - "\n", - "其中 $\\mathcal{U}\\left(n\\right)$ 是给定的一个作用在 $n$ 个量子比特上的酉变换集合。\n", - "\n", - "如果把这个期望的结果记作 $\\mathcal{M}(\\rho)$ ，则 $\\mathcal{M}$ 将会是一个从 $\\rho$ 到 $\\mathcal{M}(\\rho)$ 的映射。当 $\\mathcal{M}$ 线性可逆时 [1]，初始的量子态 $\\rho$ 就可以表达为：\n", - "\n", - "$$\n", - "\\rho=\\mathcal{M}^{-1}(\\mathbb{E}_{U \\sim \\mathcal{U} \\left(n\\right)}(\\mathbb{E}(U^{\\dagger}|\\hat{b}\\rangle\\langle \\hat{b}|U))) = \\mathbb{E}_{U \\sim \\mathcal{U} \\left(n\\right)}(\\mathbb{E}(\\mathcal{M}^{-1} (U^{\\dagger}|\\hat{b}\\rangle\\langle \\hat{b}|U))) \\tag{3}\n", - "$$\n", - "\n", - "有了 $\\mathcal{M}^{-1}$后，每一次采样 $U$ ，对 $U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U$ 作用 $\\mathcal{M}^{-1}$ 的结果 $\\hat{\\rho} = \\mathcal{M}^{-1}(U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U)$ 被我们称为 $\\rho$ 的一个快照（snapshot），重复这个过程 $N$ 次后得到 $N$ 个关于 $\\rho$ 的快照的集合：\n", - "\n", - "$$\n", - "\\text{S}(\\rho ; N)=\\{\\hat{\\rho}_{1}=\\mathcal{M}^{-1}(U_{1}^{\\dagger}|\\hat{b}_{1}\\rangle\\langle\\hat{b}_{1}| U_{1}), \\ldots, \\hat{\\rho}_{N}=\\mathcal{M}^{-1}(U_{N}^{\\dagger}|\\hat{b}_{N}\\rangle\\langle\\hat{b}_{N}| U_{N})\\} \\tag{4}\n", - "$$\n", - "\n", - "我们把 $\\text{S}(\\rho; N)$ 就称为 $\\rho$ 的经典影子。值得一提的是，$\\mathcal{M}$ 具体是什么取决于我们选取的采样集合 $\\mathcal{U}$，例如当该集合选定为 Clifford 群时，我们有: \n", - "\n", - "$$\n", - "\\mathcal{M}(\\rho)=\\mathbb{E}_{U \\sim \\operatorname{Cl} \\left(n\\right)}(\\mathbb{E}(U^{\\dagger}|\\hat{b}\\rangle\\langle \\hat{b}|U)) = \\frac{1}{2^{n}+1}\\rho+\\frac{1}{2^{n}+1}I \\tag{5}\n", - "$$\n", - "（有关 $\\mathcal{M}$ 的表达式为何如（5）所示，读者可以参考 [1]）。于是：\n", - "\n", - "$$\n", - "\\mathcal{M}^{-1}(\\frac{1}{2^{n}+1}\\rho+\\frac{1}{2^{n}+1}I)=\\rho \\Rightarrow \\mathcal{M}^{-1}(\\rho) = (2^{n}+1)\\rho-I \\tag{6}\n", - "$$\n", - "\n", - "构建了经典影子之后，它是如何帮助我们有效估计量子态的性质的呢？[1] 中指出，关于量子态 $\\rho$ 的一些线性性质就十分适合用经典影子技术来估计，例如 $\\rho$ 在某个可观测量 $\\mathcal{O}$ 下的期望：$o=\\operatorname{tr}\\left(\\mathcal{O} \\rho\\right)$，我们记 $\\hat{o}=\\operatorname{tr}\\left(\\mathcal{O} \\hat{\\rho}\\right)$，那么根据（3）式，就有 $\\mathbb{E}[\\hat{o}]=\\operatorname{tr}\\left(\\mathcal{O} \\rho\\right)$。与之相关的应用与实现，读者可以阅读另一篇教程：[基于经典影子的量子态性质估计](./ClassicalShadow_Application_CN.ipynb)。\n", - "\n", - "接下来，我们将在量桨中展示对一个随机生成的量子态 $\\rho$ 构建其经典影子的过程，帮助读者更好地理解与感受经典影子这个技术。其中选取 Clifford 群作为酉变换的采样集合。（具体有关 Clifford 群的性质以及如何从中均匀随机采样 Clifford 变换，感兴趣的读者可以参考 [1]、[3] 以及量桨中的 `Clifford` 类）" - ] - }, - { - "cell_type": "markdown", - "id": "chinese-talent", - "metadata": {}, - "source": [ - "## Paddle Quantum 代码实现" - ] - }, - { - "cell_type": "markdown", - "id": "proved-hypothesis", - "metadata": {}, - "source": [ - "首先，我们导入需要用到的包。" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "freelance-steps", - "metadata": { - "scrolled": true - }, - "outputs": [], - "source": [ - "import numpy as np\n", - "import paddle\n", - "import matplotlib.pyplot as plt\n", - "from paddle_quantum.clifford import Clifford\n", - "from paddle_quantum.state import vec_random\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import trace_distance" - ] - }, - { - "cell_type": "markdown", - "id": "blessed-italian", - "metadata": {}, - "source": [ - "接下来，我们随机生成量子态 $\\rho$。" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "measured-boating", - "metadata": {}, - "outputs": [], - "source": [ - "# 设置量子比特数目\n", - "n_qubit = 2\n", - "\n", - "# 随机生成态矢量 phi\n", - "phi_random = vec_random(n_qubit) \n", - "# phi 的密度矩阵表示 rho\n", - "rho_random = np.outer(phi_random, phi_random.conj())\n", - "\n", - "# 定义 |0> 和 |1>\n", - "ket_0 = np.array([[1,0]]).T\n", - "ket_1 = np.array([[0,1]]).T\n", - "\n", - "# 定义单位矩阵与 M 逆的系数\n", - "I = np.identity(1<" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 打印出量子态的近似与初始量子态的迹距离结果图\n", - "fig,ax = plt.subplots(figsize=(10, 10))\n", - "plt.xlabel('number of samples')\n", - "plt.ylabel('trace distance')\n", - "j = range(len(tracedistance)) \n", - "plt.plot(j, tracedistance, 'r', label=\"trace_distance\")\n", - "\"\"\"open the grid\"\"\"\n", - "plt.grid(True)\n", - "plt.legend(bbox_to_anchor=(1.0, 1), loc=1, borderaxespad=0.)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "graphic-oklahoma", - "metadata": {}, - "source": [ - "## 总结" - ] - }, - { - "cell_type": "markdown", - "id": "unavailable-health", - "metadata": {}, - "source": [ - "本教程介绍了经典影子的基本原理与一些理论知识。在展示的案例中，我们基于量桨对一个随机生成的 2 个量子比特量子态构建了其经典影子。直观地感受了经典影子可以对一个未知的量子态做较好的近似。事实上，[2] 中指出在许多场景下，要求对量子系统进行完整的经典描述可能是多余的。相反，准确地估计量子系统的某些特性通常就足够了，这也是经典影子真正的重要性所在。在经典影子应用的教程（[基于经典影子的量子态性质估计](./ClassicalShadow_Application_CN.ipynb)）中，将具体介绍经典影子的应用以及如何在量桨中使用 shadow 功能。" - ] - }, - { - "cell_type": "markdown", - "id": "adopted-taste", - "metadata": {}, - "source": [ - "## 参考文献" - ] - }, - { - "cell_type": "markdown", - "id": "described-swiss", - "metadata": {}, - "source": [ - "[1] Huang, Hsin-Yuan, Richard Kueng, and John Preskill. \"Predicting many properties of a quantum system from very few measurements.\" [Nature Physics 16.10 (2020): 1050-1057.](https://authors.library.caltech.edu/102787/1/2002.08953.pdf)\n", - "\n", - "[2] Aaronson, Scott. \"Shadow tomography of quantum states.\" [SIAM Journal on Computing 49.5 (2019): STOC18-368.](https://dl.acm.org/doi/abs/10.1145/3188745.3188802) \n", - "\n", - "[3] Bravyi, Sergey, and Dmitri Maslov. \"Hadamard-free circuits expose the structure of the Clifford group.\" [IEEE Transactions on Information Theory 67.7 (2021): 4546-4563.](https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=9435351)" - ] - } - ], - "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" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorial/quantum_simulation/ClassicalShadow_Intro_EN.ipynb b/tutorial/quantum_simulation/ClassicalShadow_Intro_EN.ipynb deleted file mode 100644 index ee24916..0000000 --- a/tutorial/quantum_simulation/ClassicalShadow_Intro_EN.ipynb +++ /dev/null @@ -1,351 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "damaged-friendship", - "metadata": {}, - "source": [ - "# The Classical Shadow of Unknown Quantum States" - ] - }, - { - "cell_type": "markdown", - "id": "quarterly-leone", - "metadata": {}, - "source": [ - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "id": "widespread-clone", - "metadata": {}, - "source": [ - "## Overview\n", - "\n", - "For the quantum state $\\rho$ in an unknown quantum system, obtaining the information it contains is a fundamental and essential problem. This tutorial will discuss how to use the classical shadow to describe an unknown quantum state with classical data so that many quantum state properties can be efficiently estimated. In the era of NISQ (noisy intermediate-scale quantum), the classical shadow helps us trade quantum for classical resources. After describing the information of the quantum state with classical data, some quantum problems can be solved by methods such as classical machine learning. And using this method, the cost of the quantum circuit running times in some existing variational quantum algorithms like variational quantum eigensolver (VQE) may be reduced so that an acceleration can be achieved." - ] - }, - { - "cell_type": "markdown", - "id": "remarkable-season", - "metadata": {}, - "source": [ - "## The Classical Shadow\n", - "\n", - "The intuition of the classic shadow comes from shadows in real life. If we use a beam of light to illuminate a polyhedron vertically, we get a shadow of it. Rotating this polyhedron, we can see its different shadows. After many rotations, this series of shadows naturally reflect some information about this polyhedron. Similarly, in the quantum world, if we perform a unitary transformation on a quantum state and then perform a measurement, can we also get a \"shadow\" of the quantum state? The construction of the classical shadow is analogous to this example. Its construction process is as follows:\n", - "\n", - "First, we apply a unitary transformation to an unknown quantum state $\\rho$ in a $n$ qubits system: $\\rho \\mapsto U \\rho U^{\\dagger}$, and then measure each qubit in the computational basis. For the measurement result, we use $|\\hat{b}\\rangle$ as an example. We perform the inverse transformation of the previous unitary on $|\\hat{b}\\rangle$ to get $U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U$. We know that the expectation value of measured quantum state $|\\hat{b}\\rangle\\langle\\hat{b}|$ is: \n", - "\n", - "$$\n", - "\\mathbb{E}(|\\hat{b}\\rangle\\langle\\hat{b}|) = \\sum_{b \\in \\{0,1\\}^{n}} \\operatorname{Pr}(|\\hat{b}\\rangle\\langle\\hat{b}| = |b\\rangle\\langle b|)\\cdot |b\\rangle \\langle b|= \\sum_{b \\in \\{0,1\\}^{n}}\\langle b|U\\rho U^{\\dagger} |b\\rangle |b\\rangle \\langle b| \\tag{1}\n", - "$$\n", - "\n", - "Then after the reverse operation, the expectation value of $U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U$ is $\\sum_{b \\in \\{0,1\\}^{n}}\\langle b|U\\rho U^{\\dagger} |b\\rangle U^{\\dagger}|b\\rangle \\langle b|U$. In this process, the unitary transformation $U$ is randomly selected from a fixed set. \n", - "When we repeat this process and average $U$, we can get:\n", - "\n", - "$$\n", - "\\mathbb{E}_{U \\sim \\mathcal{U}\\left(n\\right)}(\\mathbb{E}(U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U))=\\sum_{b \\in \\{0,1\\}^{n}}\\mathbb{E}_{U \\sim \\mathcal{U}\\left(n\\right)}(\\langle b|U\\rho U^{\\dagger} |b\\rangle U^{\\dagger}|b\\rangle \\langle b|U) \\tag{2}\n", - "$$ \n", - "where $\\mathcal{U}\\left(n\\right)$ is a given unitary transformation set on $n$ qubits.\n", - "\n", - "If this expectation value is recorded as $\\mathcal{M}(\\rho)$, then $\\mathcal{M}$ will be a map from $\\rho$ to $\\mathcal{M}(\\rho)$. When $\\mathcal{M}$ is linear and reversible [1], the initial quantum state $\\rho$ can be expressed as:\n", - "\n", - "$$\n", - "\\rho=\\mathcal{M}^{-1}(\\mathbb{E}_{U \\sim \\mathcal{U} \\left(n\\right)}(\\mathbb{E}(U^{\\dagger}|\\hat{b}\\rangle\\langle \\hat{b}|U))) = \\mathbb{E}_{U \\sim \\mathcal{U} \\left(n\\right)}(\\mathbb{E}(\\mathcal{M}^{-1} (U^{\\dagger}|\\hat{b}\\rangle\\langle \\hat{b}|U))) \\tag{3}\n", - "$$\n", - "\n", - "\n", - "With $\\mathcal{M}^{-1}$, every time $U$ is sampled, we compute $\\hat{\\rho} = \\mathcal{M }^{-1}(U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U)$ and name it a snapshot. After repeating this process $N$ times, we get $N$ collections of snapshots about $\\rho$:\n", - "\n", - "\n", - "$$\n", - "\\text{S}(\\rho ; N)=\\{\\hat{\\rho}_{1}=\\mathcal{M}^{-1}(U_{1}^{\\dagger}|\\hat{b}_{1}\\rangle\\langle\\hat{b}_{1}| U_{1}), \\ldots, \\hat{\\rho}_{N}=\\mathcal{M}^{-1}(U_{N}^{\\dagger}|\\hat{b}_{N}\\rangle\\langle\\hat{b}_{N}| U_{N})\\} .\\tag{4}\n", - "$$\n", - "\n", - "We call $\\text{S}(\\rho; N)$ the classical shadow of $\\rho$. It is worth mentioning that what exactly $\\mathcal{M}$ is depends on the sampling set $\\mathcal{U}$ we select. For example, when we select the Clifford group as the sampling set $\\mathcal{U}$, we have:\n", - "\n", - "$$\n", - "\\mathcal{M}(\\rho)=\\mathbb{E}_{U \\sim \\operatorname{Cl} \\left(n\\right)}(\\mathbb{E}(U^{\\dagger}|\\hat{b}\\rangle\\langle \\hat{b}|U)) = \\frac{1}{2^{n}+1}\\rho+\\frac{1}{2^{n}+1}I. \\tag{5}\n", - "$$\n", - "\n", - "Readers may refer to [1] for details about why $\\mathcal{M}$ is as (5). It follows:\n", - "\n", - "$$\\mathcal{M}^{-1}(\\frac{1}{2^{n}+1}\\rho+\\frac{1}{2^{n}+1}I)=\\rho \\Rightarrow \\mathcal{M}^{-1}(\\rho) = (2^{n}+1)\\rho-I \\tag{6}$$\n", - "\n", - "After constructing the classical shadow, how does it help us to effectively estimate the properties of the quantum state? Some linear properties of quantum state $\\rho$ are very suitable to be estimated by the classical shadow, for example, the expectation value of $\\rho$ of an observable $\\mathcal{O}$: $o =\\operatorname{tr}\\left(\\mathcal{O} \\rho\\right)$ [1]. Let $\\hat{o}=\\operatorname{tr}\\left(\\mathcal{O} \\hat{\\rho}\\right)$, then according to (3), there is $\\mathbb{E}[\\hat{o}]=\\operatorname{tr}\\left(\\mathcal{O} \\rho\\right)$. We provide detailed applications and implementations in our following tutorial: [Estimation of Quantum State Properties Based on the Classical Shadow](./ClassicalShadow_Application_EN.ipynb)." - ] - }, - { - "cell_type": "markdown", - "id": "metropolitan-subdivision", - "metadata": {}, - "source": [ - "Next, we will show the process of constructing the classical shadow for a randomly selected quantum state $\\rho$ in Paddle Quantum to help readers understand how the classical shadow works. And we will use the Clifford group as the sampling set of the unitary transformation (specifically about the properties of the Clifford group and how to sample uniformly distributed Clifford operators from it randomly, readers can refer to [1], [3], and the `Clifford` class in Paddle Quantum)." - ] - }, - { - "cell_type": "markdown", - "id": "regional-binary", - "metadata": {}, - "source": [ - "## Paddle Quantum Implementation" - ] - }, - { - "cell_type": "markdown", - "id": "military-project", - "metadata": {}, - "source": [ - "First, we need to import all the dependencies:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "stopped-kennedy", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import paddle\n", - "import matplotlib.pyplot as plt\n", - "from paddle_quantum.clifford import Clifford\n", - "from paddle_quantum.state import vec_random\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import trace_distance" - ] - }, - { - "cell_type": "markdown", - "id": "activated-found", - "metadata": {}, - "source": [ - "Next, we randomly generate a quantum state $\\rho$." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "union-freedom", - "metadata": {}, - "outputs": [], - "source": [ - "# Number of qubits\n", - "n_qubit = 2\n", - "\n", - "# Randomly generate a state vector\n", - "phi_random = vec_random(n_qubit) \n", - "# Its density matrix form\n", - "rho_random = np.outer(phi_random, phi_random.conj())\n", - "\n", - "# Define |0> and |1>\n", - "ket_0 = np.array([[1,0]]).T\n", - "ket_1 = np.array([[0,1]]).T\n", - "I = np.identity(1<" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Print out the result\n", - "fig,ax = plt.subplots(figsize=(10, 10))\n", - " \n", - "plt.xlabel('number of samples')\n", - "plt.ylabel('trace distance')\n", - "j = range(len(tracedistance)) \n", - "plt.plot(j, tracedistance, 'r', label=\"trace_distance\")\n", - "\"\"\"open the grid\"\"\"\n", - "plt.grid(True)\n", - "plt.legend(bbox_to_anchor=(1.0, 1), loc=1, borderaxespad=0.)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "ambient-actor", - "metadata": {}, - "source": [ - "## Conclusion\n", - "\n", - "This tutorial introduces some theoretical knowledge of the classical shadow. In this example, we constructed the classical shadow of a random 2-qubit quantum state in Paddle Quantum. We can intuitively understand that the classic shadow can make a good approximation to an unknown quantum state. In fact, [2] pointed out demanding full classical descriptions of quantum systems may be excessive for many concrete tasks. Instead, it is often sufficient to accurately predict certain properties of the quantum system. This is where the fundamental importance of the classical shadow lies. Another tutorial ([Estimation of Quantum State Properties Based on the Classical Shadow](./ClassicalShadow_Application_EN.ipynb)) will continue to introduce the applications of the classic shadow and how to use shadow function in Paddle Quantum." - ] - }, - { - "cell_type": "markdown", - "id": "through-order", - "metadata": {}, - "source": [ - "## References\n", - "[1] Huang, Hsin-Yuan, Richard Kueng, and John Preskill. \"Predicting many properties of a quantum system from very few measurements.\" [Nature Physics 16.10 (2020): 1050-1057.](https://authors.library.caltech.edu/102787/1/2002.08953.pdf) \n", - "\n", - "[2] Aaronson, Scott. \"Shadow tomography of quantum states.\" [SIAM Journal on Computing 49.5 (2019): STOC18-368.](https://dl.acm.org/doi/abs/10.1145/3188745.3188802) \n", - "\n", - "[3] Bravyi, Sergey, and Dmitri Maslov. \"Hadamard-free circuits expose the structure of the Clifford group.\" [IEEE Transactions on Information Theory 67.7 (2021): 4546-4563.](https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=9435351)" - ] - } - ], - "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" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorial/quantum_simulation/DistributedVQE_CN.ipynb b/tutorial/quantum_simulation/DistributedVQE_CN.ipynb deleted file mode 100644 index 8a70c91..0000000 --- a/tutorial/quantum_simulation/DistributedVQE_CN.ipynb +++ /dev/null @@ -1,577 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "c1a5f1e6", - "metadata": {}, - "source": [ - "# 基于施密特分解的分布式变分量子本征求解器\n", - "\n", - "*Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.*" - ] - }, - { - "cell_type": "markdown", - "id": "cf44390c", - "metadata": { - "tags": [] - }, - "source": [ - "## 概览\n", - "\n", - "在物理和化学等学科中，一个非常重要的问题就是提取分子、原子等物理系统的基态信息。系统的基态是由系统对应的哈密顿量决定的。目前普遍认为量子计算机在求解哈密顿量基态问题上具有优势。[变分量子本征求解器](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html)（variational quantum eigensolver, VQE），作为有望在近期展现量子优势的算法之一，为研究者们提供了可以在含噪的中等规模量子（NISQ）设备上研究量子化学的可能。然而，目前 NISQ 设备仍存在许多局限性，阻碍了大规模量子算法的运行。例如，受限于现有量子设备所能提供的量子比特数，研究者们无法利用 VQE 在 NISQ 设备上模拟真实的大分子。为了突破这一限制，许多分布式方案 [1-3] 相继被提出。\n", - "在本教程中，我们以 [4] 提出的基于施密特分解的 VQE 为例，向读者展示如何利用 Paddle Quantum 实现分布式量子算法。" - ] - }, - { - "cell_type": "markdown", - "id": "f3fcc1b4", - "metadata": {}, - "source": [ - "## 施密特分解\n", - "\n", - "对于任意处于复合系统 $AB$ 上的纯态 $|\\psi\\rangle$，我们有如下平凡分解:\n", - "\n", - "$$\n", - "|\\psi\\rangle=\\sum_{ij}a_{ij}|i\\rangle\\otimes|j\\rangle,\n", - "\\tag{1}\n", - "$$\n", - "\n", - "其中 $|i\\rangle$ 和 $|j\\rangle$ 分别是子系统 $A$、$B$ 上的计算基底，$a_{ij}$ 是某复矩阵 $a$ 的元素。接下来，我们对矩阵 $a$ 运用[奇异值分解](https://zh.wikipedia.org/wiki/奇异值分解)（singular value decomposition, SVD），即，$a = udv$，其中 $u,v$ 是酉矩阵，$d$ 是对角矩阵。那么，$a_{ij}=\\sum_ku_{ik}d_{kk}v_{kj}$。\n", - "\n", - "通过定义 \n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "|k_A\\rangle\\equiv & \\sum_iu_{ik}|i\\rangle=u|k\\rangle,\\\\\n", - "|k_B\\rangle\\equiv & \\sum_jv_{kj}|j\\rangle=v^T|k\\rangle,\\\\\n", - "\\lambda_k\\equiv & d_{kk},\\end{aligned}\n", - "\\tag{2}\n", - "$$\n", - "\n", - "我们可以把（1）式重写为\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - " |\\psi\\rangle &= \\sum_{ijk}u_{ik}d_{kk}v_{kj}|i\\rangle\\otimes|j\\rangle \\\\\n", - " &= \\sum_{k}\\lambda_{k}\\Big(\\sum_iu_{ik}|i\\rangle\\Big)\\otimes\\Big(\\sum_jv_{kj}|j\\rangle\\Big) \\\\\n", - " &=\\sum_{k}\\lambda_k(u|k\\rangle\\otimes v^T|k\\rangle)\\\\\n", - " &=\\sum_{k}\\lambda_k|k_A\\rangle\\otimes|k_B\\rangle.\n", - "\\end{aligned}\n", - "\\tag{3}\n", - "$$\n", - "\n", - "形如 $|\\psi\\rangle=\\sum_k\\lambda_k|k_A\\rangle\\otimes|k_B\\rangle$ 的分解方式就称为 **施密特分解** [5]。同时，$\\{\\lambda_k\\}_k$ 被称作施密特系数，非零 $\\lambda_k$ 的数量被称为 $|\\psi\\rangle$ 的施密特秩。事实上，奇异值分解的性质还保证了 $\\lambda_k\\in\\mathbb{R}^+$ 及 $\\sum_k\\lambda_k^2=1$。" - ] - }, - { - "cell_type": "markdown", - "id": "620e053c", - "metadata": { - "tags": [] - }, - "source": [ - "## 基于施密特分解的分布式 VQE\n", - "\n", - "作为标准 VQE [6] 的一个变种，分布式 VQE 同样试图寻找一个 $N$ 量子比特哈密顿量 $\\hat{H}=\\sum_tc_t\\hat{H}_t^{(A)}\\otimes\\hat{H}_t^{(B)}$ 的基态及其能量，其中 $\\hat{H}_t^{(A)},\\hat{H}_t^{(B)}$ 是分别作用于子系统 $A$、$B$ 上的哈密顿量分量（我们假设 $A$、$B$ 都包含 $N/2$ 量子比特）。\n", - "\n", - "我们从如下试探波函数开始：\n", - "\n", - "$$\n", - "|\\psi\\rangle\\equiv\\sum_{k=1}^S\\lambda_k\\Big(U(\\boldsymbol{\\theta})|k\\rangle\\Big)\\otimes\\Big(V(\\boldsymbol{\\phi})|k\\rangle\\Big)\n", - "\\tag{4},\n", - "$$\n", - "\n", - "其中 $\\boldsymbol{\\lambda}\\equiv(\\lambda_1, \\lambda_2,...,\\lambda_S)^T$，$1\\leq S\\leq 2^{N/2}$ 是一个用户定义的常数。根据施密特分解，目标基态同样可写成（4）式的形式。因此，通过寻找合适的参数向量 $\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}$ 和 $\\boldsymbol{\\phi}$，我们可以在任意误差内近似目标基态。\n", - "\n", - "接下来，对于所有 $i,j=1,...,S$，我们在一台 $N/2$ 量子比特的量子计算机上计算如下项：\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "E_{ijt}^A(\\boldsymbol{\\theta}) &\\equiv \\langle i|U^\\dagger(\\boldsymbol{\\theta}) \\hat{H}_t^{(A)} U(\\boldsymbol{\\theta})|j\\rangle,\\\\\n", - "E_{ijt}^B(\\boldsymbol{\\phi}) &\\equiv \\langle i|V^\\dagger(\\boldsymbol{\\phi}) \\hat{H}_t^{(B)} V(\\boldsymbol{\\phi}))|j\\rangle.\n", - "\\end{aligned}\n", - "\\tag{5}\n", - "$$\n", - "\n", - "然后，在一台经典计算机上，我们根据如下定义构造一个 $S\\times S$ 维的矩阵 $M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$：\n", - "\n", - "$$\n", - "[M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})]_{ij}\\equiv\\sum_tc_tE_{ijt}^A(\\boldsymbol{\\theta})E_{ijt}^B(\\boldsymbol{\\phi}).\n", - "\\tag{6}\n", - "$$\n", - "\n", - "这样，目标基态能量就可以写为 \n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "E_{tar} &= \\min_{\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}} \\langle{\\psi}|\\hat{H}|\\psi\\rangle \\\\\n", - " &= \\min_{\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}}\\Big(\\sum_{i,j=1}^S\\lambda_i\\lambda_j[M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})]_{ij}\\Big)\\\\\n", - " &= \\min_{\\boldsymbol{\\theta}, \\boldsymbol{\\phi}} E(\\boldsymbol{\\theta},\\boldsymbol{\\phi}),\n", - "\\end{aligned}\n", - "\\tag{7}\n", - "$$\n", - "\n", - "其中 $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})\\equiv\\min_{\\boldsymbol{\\lambda}} \\boldsymbol{\\lambda}^T M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})\\boldsymbol{\\lambda}$。根据线性代数的内容，不难发现，$E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ 正是矩阵 $M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ 的最小特征值，可以通过经典算法求得。\n", - "\n", - "最终，我们重复如上过程，并使用基于梯度下降的优化方法最小化 $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$，使其趋近于 $E_{tar}$。\n", - "\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "id": "f79d3333", - "metadata": { - "tags": [] - }, - "source": [ - "## 量桨实现\n", - "\n", - "首先，我们导入必要的包。由于我们要使用飞桨和量桨的最新功能，请确保您的 *PaddlePaddle* >= 2.2.0 且 *Paddle Quantum* >= 2.1.3。" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "bb7c0db4", - "metadata": {}, - "outputs": [], - "source": [ - "import time\n", - "import numpy as np\n", - "from matplotlib import pyplot as plt\n", - "\n", - "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import pauli_str_to_matrix, schmidt_decompose" - ] - }, - { - "cell_type": "markdown", - "id": "c84dd264", - "metadata": {}, - "source": [ - "定义一些全局常数：" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "27e4ce36", - "metadata": {}, - "outputs": [], - "source": [ - "N = 10 # 量子比特数\n", - "SEED = 16 # 固定随机种子\n", - "ITR = 100 # 设置迭代次数\n", - "LR = 0.1 # 设置学习率\n", - "D = 3 # 设置量子神经网络的层数" - ] - }, - { - "cell_type": "markdown", - "id": "3db38f56", - "metadata": {}, - "source": [ - "下面这一函数经典地计算出哈密顿量 $H$ 的基态信息（基态对能量和施密特秩），以作为后面量子模型的基准参照。" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "32b310ed", - "metadata": {}, - "outputs": [], - "source": [ - "def get_ground_state_info(H):\n", - "\n", - " # 计算 H 的特征值与特征向量\n", - " vals, vecs = paddle.linalg.eigh(H)\n", - " # 获取基态\n", - " ground_state = vecs[:, 0].numpy()\n", - " # 获取基态能量\n", - " ground_state_energy = vals.tolist()[0]\n", - " print(f'The ground state energy is {ground_state_energy:.5f} Ha.')\n", - " # 对基态运用施密特分解\n", - " l, _, _ = schmidt_decompose(ground_state)\n", - " print(f'Schmidt rank of the ground state is {l.size}.')\n", - "\n", - " return ground_state_energy" - ] - }, - { - "cell_type": "markdown", - "id": "8c2c88d3", - "metadata": {}, - "source": [ - "现在，我们生成一个哈密顿量并计算其基态信息。" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "6149b4d4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The ground state energy is -0.99783 Ha.\n", - "Schmidt rank of the ground state is 3.\n" - ] - } - ], - "source": [ - "# 固定随机种子\n", - "np.random.seed(SEED)\n", - "\n", - "# 硬编码一个哈密顿量\n", - "coefs = [-0.8886258, 0.453882]\n", - "pauli_str = ['x0,z1,z2,z4,x5,y6,y7,x8,x9', 'y0,x1,x2,x3,y4,x5,z6,z7,y8,x9']\n", - "pauli_str_A = ['x0,z1,z2,z4', 'y0,x1,x2,x3,y4'] # 子系统 A 的泡利字符串\n", - "pauli_str_B = ['x0,y1,y2,x3,x4', 'x0,z1,z2,y3,x4'] # 子系统 B 的泡利字符串\n", - "\n", - "# 把相关对象转换为张量形式\n", - "H_mtr = paddle.to_tensor(pauli_str_to_matrix(zip(coefs, pauli_str), n=N))\n", - "coefs = paddle.to_tensor(coefs)\n", - "H_A = [pauli_str_to_matrix([[1., pstr]], n=N//2) for pstr in pauli_str_A]\n", - "H_A = paddle.to_tensor(np.stack(H_A))\n", - "H_B = [pauli_str_to_matrix([[1., pstr]], n=N-N//2) for pstr in pauli_str_B]\n", - "H_B = paddle.to_tensor(np.stack(H_B))\n", - "\n", - "# 计算该哈密顿量的基态信息\n", - "ground_state_energy = get_ground_state_info(H_mtr)" - ] - }, - { - "cell_type": "markdown", - "id": "9abf331c", - "metadata": {}, - "source": [ - "准备好一个哈密顿量后，我们可以构建一个分布式 VQE 来求解它。" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "32cacc67", - "metadata": {}, - "outputs": [], - "source": [ - "# 构造参数化量子电路\n", - "def U_theta(param, N, D):\n", - " \n", - " cir = UAnsatz(N) # 初始化一个宽度为 N 量子比特的电路\n", - " cir.complex_entangled_layer(param, D) # 添加量子门\n", - " return cir.U # 获取参数化电路的矩阵\n", - "\n", - "# 把参数化电路作用在计算基底上\n", - "# 并返回一个形状为 [2**N, num_states] 的张量\n", - "def output_states(theta, num_states, N, D):\n", - " # 创建 num_states 个计算基底\n", - " basis = paddle.eye(2**N, num_states)\n", - " \n", - " # 获得参数化电路\n", - " U = U_theta(theta, N, D)\n", - " \n", - " # 把参数化电路作用在这些基底上\n", - " vec = U @ basis \n", - " \n", - " return vec" - ] - }, - { - "cell_type": "markdown", - "id": "0ca5787c", - "metadata": {}, - "source": [ - "以下代码是本教程的核心。请读者仔细阅读，并与前文的公式叙述做比较。" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "6ebf5159", - "metadata": {}, - "outputs": [], - "source": [ - "# 构造分布式模型\n", - "class DistributedVQE(paddle.nn.Layer):\n", - " def __init__(self, N, D, S):\n", - " super().__init__()\n", - " paddle.seed(SEED)\n", - "\n", - " # 定义常数 S\n", - " self.S = S\n", - " self.N, self.D = N, D\n", - " # 初始化参数列表 theta, phi，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " self.theta = self.create_parameter(shape=[D, N//2, 3], dtype=\"float64\",\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*np.pi))\n", - " self.phi = self.create_parameter(shape=[D, N - N//2, 3], dtype=\"float64\",\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*np.pi))\n", - " \n", - " # 分布式 VQE 的核心逻辑\n", - " def forward(self):\n", - " # 分别获得子系统 A、B 上的 U|k> 和 V|k> \n", - " vec_A = output_states(self.theta, self.S, self.N//2, self.D)\n", - " vec_B = output_states(self.phi, self.S, self.N - self.N//2, self.D)\n", - " \n", - " # 计算由前文定义的 E_{ijt}^A 和 E_{ijt}^B 组成的张量 E_A, E_B\n", - " E_A = vec_A.conj().t() @ H_A @ vec_A\n", - " E_B = vec_B.conj().t() @ H_B @ vec_B\n", - " M = (coefs.reshape([-1, 1, 1]) * E_A * E_B).sum(0)\n", - "\n", - " # 计算矩阵 M 的最小特征值\n", - " eigval = paddle.linalg.eigvalsh(M)\n", - " loss = eigval[0]\n", - " \n", - " return loss" - ] - }, - { - "cell_type": "markdown", - "id": "d04669ff", - "metadata": {}, - "source": [ - "定义训练函数。" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "066f5e72", - "metadata": {}, - "outputs": [], - "source": [ - "def train(model):\n", - " start_time = time.time() # 用以计算该函数的运行时长\n", - " \n", - " # 我们使用基于梯度下降的优化器 Adam 来优化 theta 和 phi\n", - " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=model.parameters())\n", - " summary_loss = [] # 记录损失历史\n", - "\n", - " # 迭代优化\n", - " for itr in range(ITR):\n", - "\n", - " # 前向传播，计算损失函数\n", - " loss = model()\n", - "\n", - " # 后向传播，优化损失函数\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - "\n", - " # 更新优化结果\n", - " summary_loss.append(loss.numpy())\n", - "\n", - " # 打印中间结果\n", - " if (itr+1) % 20 == 0:\n", - " print(f\"iter: {itr+1}, loss: {loss.tolist()[0]: .4f} Ha\")\n", - "\n", - " print(f'Ground truth is {ground_state_energy:.4f} Ha')\n", - " print(f'Training took {time.time() - start_time:.2f}s')\n", - " \n", - " plt.plot(list(range(ITR)), summary_loss, color='r', label='loss')\n", - " plt.hlines(y=ground_state_energy, xmin=0, xmax=ITR, linestyle=':', label='ground truth')\n", - " plt.legend()\n", - " plt.title(f'Loss for {type(model).__name__} on a {N}-qubit Hamiltonian')\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "c8770b19", - "metadata": {}, - "source": [ - "现在，我们实例化并训练分布式模型。" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "78b46dcc", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 20, loss: -0.9244 Ha\n", - "iter: 40, loss: -0.9906 Ha\n", - "iter: 60, loss: -0.9968 Ha\n", - "iter: 80, loss: -0.9977 Ha\n", - "iter: 100, loss: -0.9978 Ha\n", - "Ground truth is -0.9978 Ha\n", - "Training took 13.01s\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# 注意，由于我们构造的哈密顿量在两子系统间相互作用较小，我们只需设置 S = 4.\n", - "#（更多解释请见总结部分）\n", - "vqe = DistributedVQE(N, D, S=4)\n", - "train(vqe)" - ] - }, - { - "cell_type": "markdown", - "id": "9eb85055", - "metadata": {}, - "source": [ - "在上图中，我们用虚线画出了真实的基态能量。可以看到，loss 曲线收敛至虚线，表明我们的分布式 VQE 成功找到了该哈密顿量的基态能量。然而，要妥当地评估我们的模型，我们还需将它与标准 VQE 做比较。因此，下面我们构建标准 VQE 模型：" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "2fff9166", - "metadata": {}, - "outputs": [], - "source": [ - "class StandardVQE(paddle.nn.Layer):\n", - " def __init__(self, N, D):\n", - " super().__init__()\n", - " paddle.seed(SEED)\n", - " self.N, self.D = N, D\n", - " self.theta = self.create_parameter(shape=[D, N, 3], dtype=\"float64\",\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*np.pi))\n", - " \n", - " def forward(self):\n", - " vec = output_states(self.theta, 1, self.N, self.D)\n", - " loss = vec.conj().t() @ H_mtr @ vec\n", - " return loss.cast('float64').flatten()" - ] - }, - { - "cell_type": "markdown", - "id": "8bc5dcfd", - "metadata": {}, - "source": [ - "实例化并训练标准 VQE。" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "a35f3eb4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 20, loss: -0.8365 Ha\n", - "iter: 40, loss: -0.9852 Ha\n", - "iter: 60, loss: -0.9958 Ha\n", - "iter: 80, loss: -0.9975 Ha\n", - "iter: 100, loss: -0.9978 Ha\n", - "Ground truth is -0.9978 Ha\n", - "Training took 721.76s\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "svqe = StandardVQE(N, D)\n", - "train(svqe) # 训练标准 VQE" - ] - }, - { - "cell_type": "markdown", - "id": "5688a618", - "metadata": {}, - "source": [ - "有趣的是，通过比较两个模型的运行时间，我们发现，分布式 VQE 的运行速度比标准 VQE 快了五十多倍！事实上，这很容易理解：在分布式模型中，我们只需模拟两个 $N/2$ 量子比特的酉变换，这无论在时间还是空间上，都比标准 VQE 中模拟一个 $N$ 量子比特的酉变换高效得多。" - ] - }, - { - "cell_type": "markdown", - "id": "94cda668", - "metadata": { - "tags": [] - }, - "source": [ - "## 总结\n", - "\n", - "在此教程中，我们构造了一个分布式 VQE 并展示了其部分优势：\n", - "- NISQ 设备的计算范围得以拓展。通过分布式策略，我们可以运行超过硬件量子比特数的量子算法。\n", - "- 计算效率得到提升。对于量子过程的经典模拟而言，分布式算法降低了酉矩阵的维度，因此降低了模拟这些矩阵所需的时间、空间消耗。\n", - "\n", - "同时，需要注意的是，用户定义的常数 $S$ 在训练准确度和效率上扮演了重要角色：\n", - "- 对于子系统间相互作用弱的哈密顿量而言，其基态在子系统间纠缠较弱 [7]。因此，其施密特秩较低，可以被一个较小的 $S$ 精确且高效地模拟。事实上，我们所给的演示及大多数物理、化学中有意义的哈密顿量都具有此性质。\n", - "- 相反的，对于子系统间相互作用强的哈密顿量而言，其基态在子系统间纠缠较强，因此需要一个较大的 $S$ 来模拟。但是，无论如何，$S$ 的上界是 $2^{N/2}$，因此矩阵 $M$ 的维度上界是 $2^{N/2}\\times2^{N/2}$，这仍然比初始哈密顿量的维度（$2^{N}\\times 2^{N}$）小。因此，该算法的效率总是优于纯经典模拟。" - ] - }, - { - "cell_type": "markdown", - "id": "922679aa", - "metadata": { - "jp-MarkdownHeadingCollapsed": true, - "tags": [] - }, - "source": [ - "_______\n", - "\n", - "# 参考文献\n", - "\n", - "[1] Fujii, Keisuke, et al. \"Deep Variational Quantum Eigensolver: a divide-and-conquer method for solving a larger problem with smaller size quantum computers.\" [arXiv preprint arXiv:2007.10917 (2020)](https://arxiv.org/abs/2007.10917).\n", - "\n", - "[2] Zhang, Yu, et al. \"Variational Quantum Eigensolver with Reduced Circuit Complexity.\" [arXiv preprint arXiv:2106.07619 (2021)](https://arxiv.org/abs/2106.07619).\n", - "\n", - "[3] Peng, Tianyi et al. \"Simulating Large Quantum Circuits On A Small Quantum Computer\". [Physical Review Letters 125.15, (2020): 150504](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.125.150504).\n", - "\n", - "[4] Eddins, Andrew, et al. \"Doubling the size of quantum simulators by entanglement forging.\" [arXiv preprint arXiv:2104.10220 (2021)](https://arxiv.org/abs/2104.10220).\n", - "\n", - "[5] Nielsen, Michael A., and Isaac L. Chuang. Quantum Computation and Quantum Information. Cambridge University Press, 2010.\n", - "\n", - "[6] Moll, Nikolaj, et al. \"Quantum optimization using variational algorithms on near-term quantum devices.\" [Quantum Science and Technology 3.3 (2018): 030503](https://iopscience.iop.org/article/10.1088/2058-9565/aab822).\n", - "\n", - "[7] Khatri, Sumeet, and Mark M. Wilde. \"Principles of quantum communication theory: A modern approach.\" [arXiv preprint arXiv:2011.04672 (2020)](https://arxiv.org/abs/2011.04672)." - ] - } - ], - "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/quantum_simulation/DistributedVQE_EN.ipynb b/tutorial/quantum_simulation/DistributedVQE_EN.ipynb deleted file mode 100644 index 95f6080..0000000 --- a/tutorial/quantum_simulation/DistributedVQE_EN.ipynb +++ /dev/null @@ -1,574 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "responsible-handle", - "metadata": {}, - "source": [ - "# Distributed Variational Quantum Eigensolver Based on Schmidt Decomposition\n", - "*Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.*" - ] - }, - { - "cell_type": "markdown", - "id": "superb-sunrise", - "metadata": { - "tags": [] - }, - "source": [ - "## Overview\n", - "\n", - "Retrieving ground state information of a Hamiltonian in amongst the essential questions in physics and chemistry. Currently, it is widely believed that quantum computers are advantageous in solving this kind of problem. As one of the promising algorithms to demonstrate quantum supremacy in the near term, [Variational Quantum Eigensolver (VQE)](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html)\n", - "enables the study of quantum chemistry on Noisy Intermediate-Scale Quantum (NISQ) devices. However, various technical limitations still exist on current NISQ hardware, forbidding the deployment of large-scale quantum algorithms. For example, limited by the number of available qubits, researchers have not been able to simulate realistic large molecules with high precision. To overcome this barrier, researchers have proposed a wide range of distributed strategies [1-3]. In this tutorial, we take the distributed VQE based on Schmidt decomposition, proposed in [4], as an example to demonstrate how to implement distributed quantum algorithms using Paddle Quantum." - ] - }, - { - "cell_type": "markdown", - "id": "illegal-zealand", - "metadata": {}, - "source": [ - "## Schmidt Decomposition\n", - "We start with the following trivial decomposition for any pure state $|\\psi\\rangle$ of a composite system $AB$:\n", - "\n", - "$$\n", - "|\\psi\\rangle=\\sum_{ij}a_{ij}|i\\rangle\\otimes|j\\rangle,\n", - "\\tag{1}\n", - "$$\n", - "\n", - "where $|i\\rangle$ and $|j\\rangle$ are computational bases of subsystems $A$ and $B$ respectively, and $a_{ij}$ are elements of some complex matrix $a$. Then, we apply [singular value decomposition (SVD)](https://en.wikipedia.org/wiki/Singular_value_decomposition)\n", - "on $a$, i.e., $a = udv$ with $u,v$ being unitary and $d$ diagonal. Hence, $a_{ij}=\\sum_ku_{ik}d_{kk}v_{kj}$. \n", - "\n", - "By defining\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "|k_A\\rangle\\equiv & \\sum_iu_{ik}|i\\rangle=u|k\\rangle,\\\\\n", - "|k_B\\rangle\\equiv & \\sum_jv_{kj}|j\\rangle=v^T|k\\rangle,\\\\\n", - "\\lambda_k\\equiv & d_{kk},\n", - "\\end{aligned}\n", - "\\tag{2}\n", - "$$\n", - "\n", - "we may rewrite Eq. (1) as\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - " |\\psi\\rangle &= \\sum_{ijk}u_{ik}d_{kk}v_{kj}|i\\rangle\\otimes|j\\rangle \\\\\n", - " &= \\sum_{k}\\lambda_{k}\\Big(\\sum_iu_{ik}|i\\rangle\\Big)\\otimes\\Big(\\sum_jv_{kj}|j\\rangle\\Big) \\\\\n", - " &=\\sum_{k}\\lambda_k(u|k\\rangle\\otimes v^T|k\\rangle)\\\\\n", - " &=\\sum_{k}\\lambda_k|k_A\\rangle\\otimes|k_B\\rangle.\n", - "\\end{aligned}\n", - "\\tag{3}\n", - "$$\n", - "\n", - "The decomposition of $|\\psi\\rangle$ into the form of $\\sum_k\\lambda_k|k_A\\rangle\\otimes|k_B\\rangle$ is known as its ***Schmidt decomposition*** [5], with $\\{\\lambda_k\\}_k$ called the *Schmidt coefficients* and the number of non-zero $\\lambda_k$'s its *Schmidt rank*. In fact, the property of SVD also guarantees that $\\lambda_k\\in\\mathbb{R}^+$ and $\\sum_k\\lambda_k^2=1$. " - ] - }, - { - "cell_type": "markdown", - "id": "looking-detail", - "metadata": { - "tags": [] - }, - "source": [ - "## Distributed VQE Based on Schmidt Decomposition\n", - "\n", - "As a variation of the standard VQE [6], the distributed VQE also seeks to solve the ground state and its energy of an $N$-qubit Hamiltonian $\\hat{H}=\\sum_tc_t\\hat{H}_t^{(A)}\\otimes\\hat{H}_t^{(B)}$， where $\\hat{H}_t^{(A)},\\hat{H}_t^{(B)}$ are Hamiltonian terms on subsystems $A,B$ respectively (we have assumed that $A$, $B$ both have $N/2$ qubits).\n", - "\n", - "To start with, we write the trial wave function as\n", - "\n", - "$$\n", - "|\\psi\\rangle\\equiv\\sum_{k=1}^S\\lambda_k\\Big(U(\\boldsymbol{\\theta})|k\\rangle\\Big)\\otimes\\Big(V(\\boldsymbol{\\phi})|k\\rangle\\Big),\n", - "\\tag{4}\n", - "$$\n", - "\n", - "for some $\\boldsymbol{\\lambda}\\equiv(\\lambda_1, \\lambda_2,...,\\lambda_S)^T$ and $1\\leq S\\leq 2^{N/2}$ a user-defined constant. According to Schmidt decomposition, the target ground state also has the form of Eq. (4) and hence can be approximated with high precision by choosing appropriate parameters $\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}$ and $\\boldsymbol{\\phi}$.\n", - "\n", - "Now, for all $i,j=1,...,S$, we evaluate the following terms on an $N/2$-qubit quantum computer:\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "E_{ijt}^A(\\boldsymbol{\\theta}) &\\equiv \\langle i|U^\\dagger(\\boldsymbol{\\theta}) \\hat{H}_t^{(A)} U(\\boldsymbol{\\theta})|j\\rangle,\\\\\n", - "E_{ijt}^B(\\boldsymbol{\\phi}) &\\equiv \\langle i|V^\\dagger(\\boldsymbol{\\phi}) \\hat{H}_t^{(B)} V(\\boldsymbol{\\phi}))|j\\rangle.\n", - "\\end{aligned}\n", - "\\tag{5}\n", - "$$\n", - "\n", - "Then, on a classical computer, we construct an $S\\times S$ dimensional matrix $M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ according to\n", - "\n", - "$$\n", - "[M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})]_{ij}\\equiv\\sum_tc_tE_{ijt}^A(\\boldsymbol{\\theta})E_{ijt}^B(\\boldsymbol{\\phi}).\n", - "\\tag{6}\n", - "$$\n", - "\n", - "In this way, the target ground state energy can be written as \n", - "$$\n", - "\\begin{aligned}\n", - "E_{tar} &= \\min_{\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}} \\langle{\\psi}|\\hat{H}|\\psi\\rangle \\\\\n", - " &= \\min_{\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}}\\Big(\\sum_{i,j=1}^S\\lambda_i\\lambda_j[M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})]_{ij}\\Big)\\\\\n", - " &= \\min_{\\boldsymbol{\\theta}, \\boldsymbol{\\phi}} E(\\boldsymbol{\\theta},\\boldsymbol{\\phi}),\n", - "\\end{aligned}\n", - "\\tag{7}\n", - "$$\n", - "\n", - "where $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})\\equiv\\min_{\\boldsymbol{\\lambda}} \\boldsymbol{\\lambda}^T M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})\\boldsymbol{\\lambda}$. By linear algebra, we see that $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ is exactly the minimal eigenvalue of $M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$, which can be solved using classical algorithms.\n", - "\n", - "Finally, we repeat the whole process and minimize $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ to approximate $E_{tar}$ using gradient-based optimization methods." - ] - }, - { - "cell_type": "markdown", - "id": "enabling-bulletin", - "metadata": { - "tags": [] - }, - "source": [ - "## Paddle Quantum implementation\n", - "\n", - "First of all, we import necessary packages. Please make sure that you have *PaddlePaddle* >= 2.2.0 and *Paddle Quantum* >= 2.1.3, as we will use some of their latest features." - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "sized-girlfriend", - "metadata": {}, - "outputs": [], - "source": [ - "import time\n", - "import numpy as np\n", - "from matplotlib import pyplot as plt\n", - "\n", - "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import pauli_str_to_matrix, schmidt_decompose" - ] - }, - { - "cell_type": "markdown", - "id": "central-internet", - "metadata": {}, - "source": [ - "Define some global constants:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "diverse-village", - "metadata": {}, - "outputs": [], - "source": [ - "N = 10 # Number of qubits\n", - "SEED = 16 # Fix a random seed\n", - "ITR = 100 # Set the number of learning iterations\n", - "LR = 0.1 # Set the learning rate\n", - "D = 3 # Set the depth for QNN" - ] - }, - { - "cell_type": "markdown", - "id": "strange-challenge", - "metadata": {}, - "source": [ - "The following function classically calculates the ground state information (the energy and the Schmidt rank of the ground state) of a Hamiltonian $H$, which we will use as the ground truth to benchmark our quantum models." - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "musical-ultimate", - "metadata": {}, - "outputs": [], - "source": [ - "def get_ground_state_info(H):\n", - "\n", - " # Calculate the eigenvalues and eigenvectors of H\n", - " vals, vecs = paddle.linalg.eigh(H)\n", - " # Retrieve the ground state\n", - " ground_state = vecs[:, 0].numpy()\n", - " # Retrieve the ground state energy\n", - " ground_state_energy = vals.tolist()[0]\n", - " print(f'The ground state energy is {ground_state_energy:.5f} Ha.')\n", - " # Run Schmidt decomposition on the ground state.\n", - " l, _, _ = schmidt_decompose(ground_state)\n", - " print(f'Schmidt rank of the ground state is {l.size}.')\n", - "\n", - " return ground_state_energy" - ] - }, - { - "cell_type": "markdown", - "id": "lesbian-employment", - "metadata": {}, - "source": [ - "Now, we generate a Hamiltonian and calculate its ground state information." - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "indie-detroit", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The ground state energy is -0.99783 Ha.\n", - "Schmidt rank of the ground state is 3.\n" - ] - } - ], - "source": [ - "# Fix a random seed\n", - "np.random.seed(SEED)\n", - "\n", - "# Hard code a random a Hamiltonian\n", - "coefs = [-0.8886258, 0.453882]\n", - "pauli_str = ['x0,z1,z2,z4,x5,y6,y7,x8,x9', 'y0,x1,x2,x3,y4,x5,z6,z7,y8,x9']\n", - "pauli_str_A = ['x0,z1,z2,z4', 'y0,x1,x2,x3,y4'] # pauli substring for system A\n", - "pauli_str_B = ['x0,y1,y2,x3,x4', 'x0,z1,z2,y3,x4'] # pauli substring for system B\n", - "\n", - "# Convert relavent object into Tensor form\n", - "H_mtr = paddle.to_tensor(pauli_str_to_matrix(zip(coefs, pauli_str), n=N))\n", - "coefs = paddle.to_tensor(coefs)\n", - "H_A = [pauli_str_to_matrix([[1., pstr]], n=N//2) for pstr in pauli_str_A]\n", - "H_A = paddle.to_tensor(np.stack(H_A))\n", - "H_B = [pauli_str_to_matrix([[1., pstr]], n=N-N//2) for pstr in pauli_str_B]\n", - "H_B = paddle.to_tensor(np.stack(H_B))\n", - "\n", - "# calculate the ground state information\n", - "ground_state_energy = get_ground_state_info(H_mtr)" - ] - }, - { - "cell_type": "markdown", - "id": "dietary-hotel", - "metadata": {}, - "source": [ - "Now that we have prepared a Hamiltonian, we may build a distributed VQE to solve it." - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "id": "international-wesley", - "metadata": {}, - "outputs": [], - "source": [ - "# Construct parameterized circuit\n", - "def U_theta(param, N, D):\n", - " \n", - " cir = UAnsatz(N) # Initialize an N-qubit-width circuit\n", - " cir.complex_entangled_layer(param, D) # Add quantum gates\n", - " return cir.U # Retrieve the unitary matrix for the parameterized circuit\n", - "\n", - "# Apply a parameterized circuit on the conputational bases\n", - "# and return a tensor of shape [2**N, num_states]\n", - "def output_states(theta, num_states, N, D):\n", - " # Create num_states-many computational bases\n", - " basis = paddle.eye(2**N, num_states)\n", - " \n", - " # Acquire a parameterized circuit\n", - " U = U_theta(theta, N, D)\n", - " \n", - " # Apply the parameterized circuit on these bases\n", - " vec = U @ basis \n", - " \n", - " return vec" - ] - }, - { - "cell_type": "markdown", - "id": "disturbed-strap", - "metadata": {}, - "source": [ - "The code below is core to this tutorial. Please compare them with the formulae given in the beginning section and make sure that they are well understood." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "normal-leader", - "metadata": {}, - "outputs": [], - "source": [ - "# Construct the distributed model\n", - "class DistributedVQE(paddle.nn.Layer):\n", - " def __init__(self, N, D, S):\n", - " super().__init__()\n", - " paddle.seed(SEED)\n", - "\n", - " # Define constant S\n", - " self.S = S\n", - " self.N, self.D = N, D\n", - " # Initialize the parameter lists theta, phi, filled by a uniform distribution in [0, 2*pi]\n", - " self.theta = self.create_parameter(shape=[D, N//2, 3], dtype=\"float64\",\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*np.pi))\n", - " self.phi = self.create_parameter(shape=[D, N - N//2, 3], dtype=\"float64\",\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*np.pi))\n", - " \n", - " # The core logic of distributed VQE\n", - " def forward(self):\n", - " # Obtain U|k> and V|k> for subsystems A and B respectively \n", - " vec_A = output_states(self.theta, self.S, self.N//2, self.D)\n", - " vec_B = output_states(self.phi, self.S, self.N - self.N//2, self.D)\n", - " \n", - " # Calculate tensor E_A, E_B, which have elements E_{ijt}^A and E_{ijt}^B, as per defined in above\n", - " E_A = vec_A.conj().t() @ H_A @ vec_A\n", - " E_B = vec_B.conj().t() @ H_B @ vec_B\n", - " M = (coefs.reshape([-1, 1, 1]) * E_A * E_B).sum(0)\n", - "\n", - " # Find the minimal eigenvalue of M\n", - " eigval = paddle.linalg.eigvalsh(M)\n", - " loss = eigval[0]\n", - " \n", - " return loss" - ] - }, - { - "cell_type": "markdown", - "id": "independent-undergraduate", - "metadata": {}, - "source": [ - "Define training function." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "liberal-mountain", - "metadata": {}, - "outputs": [], - "source": [ - "def train(model):\n", - " start_time = time.time() # To calculate the running time of this function\n", - " \n", - " # We will use Adam, a gradient-based optimizer to optimize theta and phi\n", - " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=model.parameters())\n", - " summary_loss = [] # Save loss history\n", - "\n", - " # Optimization iteration\n", - " for itr in range(ITR):\n", - "\n", - " # Forward propagation to calculates the loss function\n", - " loss = model()\n", - "\n", - " # Backward propagation to optimize the loss function\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - "\n", - " # Update optimization result\n", - " summary_loss.append(loss.numpy())\n", - "\n", - " # Print itermediary result\n", - " if (itr+1) % 20 == 0:\n", - " print(f\"iter: {itr+1}, loss: {loss.tolist()[0]: .4f} Ha\")\n", - "\n", - " print(f'Ground truth is {ground_state_energy:.4f} Ha')\n", - " print(f'Training took {time.time() - start_time:.2f}s')\n", - " \n", - " plt.plot(list(range(ITR)), summary_loss, color='r', label='loss')\n", - " plt.hlines(y=ground_state_energy, xmin=0, xmax=ITR, linestyle=':', label='ground truth')\n", - " plt.legend()\n", - " plt.title(f'Loss for {type(model).__name__} on a {N}-qubit Hamiltonian')\n", - " plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "civic-distance", - "metadata": {}, - "source": [ - "Now, we are ready to instantiate the model and train it!" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "compressed-reviewer", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 20, loss: -0.9244 Ha\n", - "iter: 40, loss: -0.9906 Ha\n", - "iter: 60, loss: -0.9968 Ha\n", - "iter: 80, loss: -0.9977 Ha\n", - "iter: 100, loss: -0.9978 Ha\n", - "Ground truth is -0.9978 Ha\n", - "Training took 13.01s\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Note that we manually set S = 4 as the Hamiltonian we just created interacts weakly across the subsystems.\n", - "# (See the Conclusion section for further description)\n", - "vqe = DistributedVQE(N, D, S=4)\n", - "train(vqe)" - ] - }, - { - "cell_type": "markdown", - "id": "convenient-receiver", - "metadata": {}, - "source": [ - "We have plotted the actual ground state energy as a dotted line in the figure above. We see that the loss curve converges to the dotted line, meaning that our distributed VQE successfully found the ground state energy of the Hamiltonian. However, to properly evaluate our model, we need to compare it with the standard VQE, which we build below:" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "intensive-pickup", - "metadata": {}, - "outputs": [], - "source": [ - "class StandardVQE(paddle.nn.Layer):\n", - " def __init__(self, N, D):\n", - " super().__init__()\n", - " paddle.seed(SEED)\n", - " self.N, self.D = N, D\n", - " self.theta = self.create_parameter(shape=[D, N, 3], dtype=\"float64\",\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*np.pi))\n", - " \n", - " def forward(self):\n", - " vec = output_states(self.theta, 1, self.N, self.D)\n", - " loss = vec.conj().t() @ H_mtr @ vec\n", - " return loss.cast('float64').flatten()" - ] - }, - { - "cell_type": "markdown", - "id": "dress-vulnerability", - "metadata": {}, - "source": [ - "Instantiate and train the StandardVQE." - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "a35f3eb4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 20, loss: -0.8365 Ha\n", - "iter: 40, loss: -0.9852 Ha\n", - "iter: 60, loss: -0.9958 Ha\n", - "iter: 80, loss: -0.9975 Ha\n", - "iter: 100, loss: -0.9978 Ha\n", - "Ground truth is -0.9978 Ha\n", - "Training took 721.76s\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "svqe = StandardVQE(N, D)\n", - "train(svqe) # Train the standard VQE " - ] - }, - { - "cell_type": "markdown", - "id": "centered-sheffield", - "metadata": {}, - "source": [ - "Interestingly, by comparing the running time of the two models, we find that the distributed model runs 50 times faster than the standard VQE! In fact, this is easy to understand: in a distributed model, we only need to simulate two $N/2$-qubit unitary transformations, which is, of course, much more time- and space-efficient than simulating an $N$-qubit unitary transformation in the standard VQE." - ] - }, - { - "cell_type": "markdown", - "id": "blocked-determination", - "metadata": { - "tags": [] - }, - "source": [ - "## Conclusion\n", - "\n", - "In this tutorial, we built a distributed VQE and demonstrated some of its advantages:\n", - "- The capability of NISQ devices is expanded. Distributed strategies enable the deployment of quantum algorithms which require qubits that exceed the capability of current hardware.\n", - "- The computation efficiency is improved. For classical simulation of quantum processes, distributed algorithms reduce the dimension of unitary matrices, hence reducing the space and time cost for simulating them.\n", - "\n", - "In the meantime, one must note that $S$, as a user-defined constant, plays a key role in the training accuracy and efficiency:\n", - "- For Hamiltonians which encode weak inter-subsystem interactions, their ground states are weakly entangled across the subsystems [7]. Hence, the Schmidt ranks are small and can be accurately and efficiently simulated by a small $S$. In fact, our example and most physically and chemically interesting Hamiltonians fall into this category.\n", - "- In contrast, for Hamiltonians which encode strong inter-subsystem interactions, their ground states are strongly entangled. Hence, a large $S$ may be required. But anyway, $S$ is upper-bounded by $2^{N/2}$ and thus the dimension of $M$ is upper-bounded by $2^{N/2}\\times2^{N/2}$, which is still much smaller than the dimension of the initial Hamiltonian ($2^{N}\\times 2^{N}$). Consequently, the efficiency of this algorithm is always better than the purely classical simulation." - ] - }, - { - "cell_type": "markdown", - "id": "suspended-monroe", - "metadata": { - "jp-MarkdownHeadingCollapsed": true, - "tags": [] - }, - "source": [ - "_______\n", - "\n", - "# References\n", - "\n", - "[1] Fujii, Keisuke, et al. \"Deep Variational Quantum Eigensolver: a divide-and-conquer method for solving a larger problem with smaller size quantum computers.\" [arXiv preprint arXiv:2007.10917 (2020)](https://arxiv.org/abs/2007.10917).\n", - "\n", - "[2] Zhang, Yu, et al. \"Variational Quantum Eigensolver with Reduced Circuit Complexity.\" [arXiv preprint arXiv:2106.07619(2021)](https://arxiv.org/abs/2106.07619).\n", - "\n", - "[3] Peng, Tianyi et al. \"Simulating Large Quantum Circuits On A Small Quantum Computer\". [Physical Review Letters 125.15, (2020): 150504](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.125.150504).\n", - "\n", - "[4] Eddins, Andrew, et al. \"Doubling the size of quantum simulators by entanglement forging.\" [arXiv preprint arXiv:2104.10220 (2021)](https://arxiv.org/abs/2104.10220).\n", - "\n", - "[5] Nielsen, Michael A., and Isaac L. Chuang. Quantum Computation and Quantum Information. Cambridge University Press, 2010.\n", - "\n", - "[6] Moll, Nikolaj, et al. \"Quantum optimization using variational algorithms on near-term quantum devices.\" [Quantum Science and Technology 3.3 (2018): 030503](https://iopscience.iop.org/article/10.1088/2058-9565/aab822).\n", - "\n", - "[7] Khatri, Sumeet, and Mark M. Wilde. \"Principles of quantum communication theory: A modern approach.\" [arXiv preprint arXiv:2011.04672 (2020)](https://arxiv.org/abs/2011.04672)." - ] - } - ], - "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/quantum_simulation/HamiltonianSimulation_CN.ipynb b/tutorial/quantum_simulation/HamiltonianSimulation_CN.ipynb deleted file mode 100644 index 9c34fcd..0000000 --- a/tutorial/quantum_simulation/HamiltonianSimulation_CN.ipynb +++ /dev/null @@ -1,735 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "fffbbaec", - "metadata": {}, - "source": [ - "# 利用 Product Formula 模拟时间演化\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "id": "e6f9a147", - "metadata": {}, - "source": [ - "## 概述\n", - "\n", - "量子力学中系统的能量由哈密顿量算符 $H$ 描述，求解给定系统的哈密顿量的全部或者部分性质，构成了凝聚态物理、计算化学和高能物理等一系列学科的核心问题。然而，由于系统的自由度随系统增大呈指数级增加，导致一般情况下无法利用经典计算机有效模拟量子系统——即便用光全世界的内存和硬盘也不能直接储存一个仅几百量子比特的系统的态矢量。与经典计算机不同，量子计算机由于其所有的操作都是直接作用在同样为指数级别的态空间上，因而在模拟一个量子系统上量子计算机具有经典计算机无法比拟的优势。实际上，设计一个可控的量子系统来高效模拟自然界中的量子系统，正是费曼在上世纪 80 年代提出量子计算这一概念时的最初想法：\n", - " \n", - "> _\"Nature isn't classical, dammit, and if you want to make a simulation of nature, you'd better make it quantum mechanical, and by golly it's a wonderful problem, because it doesn't look so easy.\"_\n", - ">\n", - "> --- \"Simulating physics with computers\", 1982, Richard P. Feynman [1]\n", - "\n", - "通用量子计算机以及一系列量子模拟器的发展令费曼的设想有了实现的可能。在通用量子计算机上进行数字量子模拟（digital quantum simulation）—— 利用量子门构造量子线路从而实现量子模拟，由于该方法具有较高的可拓展性和通用性，因而被认为是最有潜力的技术路线。\n", - "\n", - "本教程讲述了如何利用 Paddle Quantum 模拟量子系统的时间演化过程，主要分为以下三个部分：\n", - "1. 如何在 Paddle Quantum 中创建并操作一个 `Hamiltonian` 对象\n", - "2. 如何利用 `construct_trotter_circuit` 来构建时间演化电路\n", - "3. Suzuki product formula 方法的原理，以及如何进一步搭建任意阶的 Trotter-Suzuki 电路\n", - "\n", - "\n", - "## 定义系统哈密顿量\n", - "\n", - "在介绍如何搭建时间演化电路之前，读者可以先熟悉一下 Paddle Quantum 中的哈密顿量。目前用户需要通过定义一个列表的形式来创建哈密顿量，列表中的元素应为哈密顿量中的每一项的系数与其泡利算符。作为教程，我们首先考虑一个简单的哈密顿量：\n", - "\n", - "$$\n", - "H = Z \\otimes Z\n", - "\\tag{1}\n", - "$$\n", - "\n", - "该哈密顿量描述了两个量子比特之间的一种简单相互作用：当两个量子比特同时处于 $|0\\rangle$ 态或者 $|1\\rangle$ 态时，系统的能量为 $+1$；相反，当两个量子比特的态不同时，系统的能量为 $-1$。\n", - "\n", - "接下来，用户可以在 Paddle Quantum 中创建这一哈密顿量：" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "1a17d7d8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0 Z0, Z1\n" - ] - } - ], - "source": [ - "from paddle_quantum.utils import Hamiltonian\n", - "\n", - "h = Hamiltonian([[1, 'Z0, Z1']])\n", - "print(h)" - ] - }, - { - "cell_type": "markdown", - "id": "64ef6a63", - "metadata": {}, - "source": [ - "目前，Paddle Quantum 中的哈密顿量类 `Hamiltonian` 支持自动合并同类项，加减法、索引以及拆分等操作：" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "ff08a2a7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0 Z0, Z1\n" - ] - } - ], - "source": [ - "h = Hamiltonian([[0.5, 'Z0, Z1'], [0.5, 'Z1, Z0']], compress=True)\n", - "print(h)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "fec891a5", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "h + h: 2.0 Z0, Z1\n", - "h * 2: 2.0 Z0, Z1\n", - "h: 1.0 Z0, Z1\n" - ] - } - ], - "source": [ - "print('h + h:', h + h)\n", - "print('h * 2:', h * 2)\n", - "print('h:', h[:])" - ] - }, - { - "cell_type": "markdown", - "id": "d2be41b1", - "metadata": {}, - "source": [ - "同时，内置的 `decompose_pauli_words()` 和 `decompose_with_sites()` 方法可以将哈密顿量分解为更加方便处理的形式：" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "40fcc0b6", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pauli words 分解： ([1.0], ['ZZ'])\n", - "Pauli with sites 分解： ([1.0], ['ZZ'], [[0, 1]])\n" - ] - } - ], - "source": [ - "print('Pauli words 分解：', h.decompose_pauli_words())\n", - "print('Pauli with sites 分解：', h.decompose_with_sites())" - ] - }, - { - "cell_type": "markdown", - "id": "95945ddd", - "metadata": {}, - "source": [ - "除此之外，`construct_h_matrix()` 还可以创建其在泡利 $Z$ 基底下的矩阵形式：" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "497ff8fd", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "matrix([[ 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]])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "h.construct_h_matrix()" - ] - }, - { - "cell_type": "markdown", - "id": "719696dd", - "metadata": {}, - "source": [ - "## 模拟时间演化\n", - "\n", - "根据量子力学的基本公理，在确定了一个系统的哈密顿量之后，该系统随时间演化的过程可以由如下方程描述\n", - "\n", - "$$\n", - "i \\hbar \\frac{\\partial}{\\partial t} | \\psi \\rangle = H | \\psi \\rangle,\n", - "\\tag{2}\n", - "$$\n", - "\n", - "$\\hbar$ 为约化普朗克常数。该方程正是著名的薛定谔方程。因此，对于一个不含时的哈密顿量，系统的时间演化方程可以写为\n", - "\n", - "$$\n", - "|\\psi(t) \\rangle = U(t) | \\psi (0) \\rangle, ~ U(t) = e^{- i H t}.\n", - "\\tag{3}\n", - "$$\n", - "\n", - "这里我们取自然单位 $\\hbar=1$，$U(t)$ 为时间演化算符。利用量子线路来模拟时间演化过程的核心思想是利用量子电路构建出的酉变换模拟和近似该时间演化算符。在量桨中，我们提供了 `construct_trotter_circuit(circuit, Hamiltonian)` 函数来构建对应某一个哈密顿量的时间演化电路。下面，就让我们用刚刚创建的哈密顿量来测试一下：" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "3449029b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--*-----------------*--\n", - " | | \n", - "--x----Rz(2.000)----x--\n", - " \n" - ] - } - ], - "source": [ - "from paddle_quantum.trotter import construct_trotter_circuit\n", - "from paddle_quantum.circuit import UAnsatz\n", - "\n", - "cir = UAnsatz(2)\n", - "construct_trotter_circuit(cir, h, tau=1, steps=1) \n", - "print(cir)" - ] - }, - { - "cell_type": "markdown", - "id": "e3dc6c7f", - "metadata": {}, - "source": [ - "可以看到，我们已经创建了针对 `h` 的基本量子模拟电路，它可以根据输入的 `tau` 来模拟任意时间长度的时间演化。\n", - "\n", - "此时，如果检查该电路对应的酉变换的矩阵形式，会发现它与时间演化算符 $e^{-iHt}$ 完全一致。这里，我们先使用 `gate_fidelity` 来计算量子电路的酉矩阵和时间演化算符的酉矩阵之间的保真度。保真度越接近 1 时代表两个酉矩阵代表的演化过程越相似。在下文，我们还会引入更加严格的误差定义。" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "8d312985", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "电路的酉算符和时间演化算符之间的保真度为： 1.000\n" - ] - } - ], - "source": [ - "from scipy import linalg\n", - "from paddle_quantum.utils import gate_fidelity\n", - "\n", - "# 计算 e^{-iHt} 和电路的酉矩阵之间的保真度\n", - "print('电路的酉算符和时间演化算符之间的保真度为： %.3f' \n", - " % gate_fidelity(cir.U.numpy(), linalg.expm(-1 * 1j * h.construct_h_matrix())))" - ] - }, - { - "cell_type": "markdown", - "id": "fa34ba8a", - "metadata": {}, - "source": [ - "实际上，这是因为泡利算符组成的张量积对应的任意角度旋转算符都可以被很好的分解为门电路的形式。比如在这个例子中我们只需要改变电路中 Rz 门的角度，就可以实现任意 $e^{-i Z\\otimes Z t}$ 演化算符的模拟。那么，这是否意味着可以用类似的电路形式来对任意的写成泡利形式的哈密顿量进行完美的模拟呢？答案是否定的。考虑一个稍微复杂一些的哈密顿量：\n", - "\n", - "$$\n", - "H = Z \\otimes Z + X \\otimes I + I \\otimes X.\n", - "\\tag{4}\n", - "$$\n", - "\n", - "同样地，让我们用 `construct_trotter_circuit` 来构建它所对应的时间演化电路：" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "40bcf1e4", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--*-----------------*----Rx(2.000)--\n", - " | | \n", - "--x----Rz(2.000)----x----Rx(2.000)--\n", - " \n", - "电路的酉算符和时间演化算符之间的保真度为： 0.681\n" - ] - } - ], - "source": [ - "h_2 = Hamiltonian([[1, 'Z0, Z1'], [1, 'X0'], [1, 'X1']]) # 不需要写出单位算符\n", - "cir = UAnsatz(2)\n", - "construct_trotter_circuit(cir, h_2, tau=1, steps=1)\n", - "print(cir)\n", - "print('电路的酉算符和时间演化算符之间的保真度为： %.3f' \n", - " % gate_fidelity(cir.U.numpy(), linalg.expm(-1 * 1j * h_2.construct_h_matrix())))" - ] - }, - { - "cell_type": "markdown", - "id": "27f0a4ed", - "metadata": {}, - "source": [ - "可以看到，此时电路对应的酉矩阵和时间演化矩阵之间的保真度 $<1$，说明该电路无法正确地模拟系统的时间演化过程。\n", - "\n", - "其实，对于我们此时构建的电路而言，它对应的酉变换为 $e^{-iZ\\otimes Z t} e^{-i (X\\otimes I + I\\otimes X)t}$，而时间演化算符为 $e^{-iZ\\otimes Z t - i(X\\otimes I + I\\otimes X)t}$。而对于一个量子系统而言，当两个算符不对易，即 $[A, B] \\neq 0$ 时，$e^{A+B} \\neq e^A e^B$。在这里，因为泡利算符 $X$ 和 $Z$ 之间并不对易，所以电路对应的酉变换并不等于正确的时间演化算符。\n", - "\n", - "除了利用保真度来描述量子电路和希望模拟的时间演化算符之间的相似性之外，我们还可以定义如下的误差 $\\epsilon$ 来刻画模拟演化电路和演化算符之间的距离，\n", - "\n", - "$$\n", - "\\epsilon(U) = \\Vert e^{-iHt} - U \\Vert,\n", - "\\tag{5}\n", - "$$\n", - "\n", - "其中 $\\Vert \\cdot \\Vert$ 表示取最大的本征（奇异）值的模。这样的定义比起保真度而言更好的描述了量子态在不同的演化算符作用下产生的偏差，是一种更加严谨的定义模拟时间演化误差的方式。我们在下文中也会多次用到该误差。" - ] - }, - { - "cell_type": "markdown", - "id": "9a0f9969", - "metadata": {}, - "source": [ - "### Product formula 与 Suzuki 分解\n", - "\n", - "Seth Lloyd 在 1996 年的文章中指出，可以将一整段的演化时间 $t$ 拆分为 $r$ 份较短的“时间块”来减小模拟时间演化的误差 [2]。考虑一个更一般的哈密顿量形式 $H = \\sum_{k=1}^{L} h_k$，其中 $h_k$ 是作用在一部分系统上的子哈密顿量。通过泰勒展开，不难发现其模拟误差是一个二阶项，即\n", - "\n", - "$$\n", - "e^{-iHt} = \\prod_{k=1}^{L} e^{-i h_k t} + O(t^2).\n", - "\\tag{6}\n", - "$$\n", - "\n", - "那么，我们令 $\\tau = t/r$，并考虑演化算符 $\\left(e^{-iH \\tau}\\right)^r$，其演化误差为\n", - "\n", - "$$\n", - "e^{-iHt} = \\left(e^{-iH \\tau}\\right)^r = \\left(\\prod_{k=1}^{L} e^{-i h_k \\tau} + O(\\tau^2) \\right)^r = \\left(\\prod_{k=1}^{L} e^{-i h_k \\tau} \\right)^r + O\\left(\\frac{t^2}{r}\\right).\n", - "\\tag{7}\n", - "$$\n", - "\n", - "上式告诉我们，只要将一整段演化时间拆为足够多的“片段”，就可以达到任意高的模拟精度，这就是 product formula 的基本思想。不过，(7) 中给出的误差只是一个粗略的估计。在实际情况中，为了估计达到某一模拟精度所需要的量子电路深度，就需要进一步推导其更严格的误差上界。下面，我们展示一个比较简略的误差上界计算过程，对具体的计算过程不感兴趣的读者可以直接跳至 (11) 阅读这部分的结论。\n", - "\n", - "记函数 $f$ 泰勒展开至 $k$ 阶之后的余项为 $\\mathcal{R}_k(f)$, 我们需要用到如下两个结论：\n", - "\n", - "$$\n", - "\\left\\Vert \\mathcal{R}_k \\left( \\prod_{k=1}^{L} \\exp (-i h_k \\tau) \\right) \\right\\Vert\n", - "\\leq\n", - "\\mathcal{R}_k \\left( \\exp \\left( \\sum_{k=1}^{L} \\vert \\tau \\vert \\cdot \\Vert h_k \\Vert \\right) \\right),\n", - "\\tag{8}\n", - "$$\n", - "\n", - "$$\n", - "\\vert \\mathcal{R}_k(\\exp (\\alpha)) \\vert \\leq \\frac{\\vert \\alpha \\vert^{k+1}}{(k+1)!} \\exp ( \\vert \\alpha \\vert ), ~\n", - "\\forall \\alpha \\in \\mathbb{C}.\n", - "\\tag{9}\n", - "$$\n", - "\n", - "这两个结论的证明略微有一些繁琐，故在此略去，感兴趣的读者可以参考 [3] 中的 F.1 节。利用 (5) 中的定义，模拟误差可以写为\n", - "\n", - "$$\n", - "\\epsilon\\left(e^{-iH\\tau}, U_{\\rm circuit}\\right) = \\left \\Vert \\exp\\left(-i\\sum_{k=1}^L h_k \\tau\\right) - \\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right \\Vert.\n", - "\\tag{10}\n", - "$$\n", - "\n", - "我们已经知道，此时的误差是泰勒展开至一阶后的余项，再利用 (8)，(9) 和三角不等式，可以将 (10) 中的误差上界进行计算：\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "\\left \\Vert \\exp\\left(-i\\sum_{k=1}^L h_k \\tau\\right) - \\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right \\Vert\n", - "=~&\n", - "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\left( -i \\sum_{k=1}^{L} h_k \\tau \\right) - \\prod_{k=1}^{L} \\exp (-i h_k \\tau) \\right) \\right \\Vert\n", - "\\\\\n", - "\\leq~&\n", - "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\left( -i \\sum_{k=1}^{L} h_k \\tau \\right) \\right) \\right \\Vert\n", - "+\n", - "\\left \\Vert \\mathcal{R}_1 \\left( \\prod_{k=1}^{L} \\exp (-i h_k \\tau) \\right) \\right \\Vert\n", - "\\\\\n", - "\\leq~ &\n", - "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\left( \\vert \\tau \\vert \\cdot \\left \\Vert \\sum_{k=1}^{L} h_k \\right \\Vert \\right) \\right) \\right \\Vert\n", - "+ \n", - "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\sum_{k=1}^{L} \\left( \\vert \\tau \\vert \\cdot \\Vert h_k \\Vert \\right) \\right) \\right \\Vert\n", - "\\\\\n", - "\\leq~&\n", - "2 \\mathcal{R}_1 \\left( \\exp ( \\vert \\tau \\vert L \\Lambda ) \\right )\n", - "\\\\\n", - "\\leq~&\n", - " ( \\vert \\tau \\vert L \\Lambda )^2 \\exp ( \\vert \\tau \\vert L \\Lambda ),\n", - "\\end{aligned}\n", - "\\tag{11}\n", - "$$\n", - "\n", - "其中 $\\Lambda = \\max_k \\Vert h_k \\Vert$。随后考虑完整的演化时间 $t = r \\cdot \\tau$，那么模拟长度为 $t$ 的时间演化算符时的误差为：\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "\\left \\Vert \\left ( \\exp\\left(-i\\sum_{k=1}^L h_k \\tau \\right)\\right)^r - \\left (\\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right)^r \\right \\Vert\n", - "\\leq ~&\n", - "r \\left \\Vert \\exp\\left(-i\\sum_{k=1}^L h_k \\tau\\right) - \\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right \\Vert\n", - "\\\\\n", - "=~& r ( \\tau L \\Lambda )^2 \\exp ( \\vert \\tau \\vert L \\Lambda )\n", - "\\\\\n", - "=~& \\frac{( t L \\Lambda )^2}{r} \\exp \\left( \\frac{\\vert t \\vert L \\Lambda}{r} \\right).\n", - "\\end{aligned}\n", - "\\tag{12}\n", - "$$\n", - "\n", - "这里用到了量子电路中误差线性累积的结论，即 $\\Vert U^r - V^r \\Vert \\leq r\\Vert U - V \\Vert$，不熟悉这一结论的读者可以参考 [4] 中的 4.5.3 节。至此，我们就计算出了 product formula 对于一段完整的演化时间 $t$ 的模拟误差上界，即 (7) 式中的二阶项 $O(t^2/r)$。 \n", - "\n", - "实际上，我们还可以通过 Suzuki 分解的方法来进一步优化对每一个“时间块”内的时间演化算符 $e^{-iH\\tau}$ 的模拟精度。对于哈密顿量 $H = \\sum_{k=1}^{L} a_k h_k$，其时间演化算符的 Suzuki 分解可以写为\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "S_1(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\tau)，\n", - "\\\\\n", - "S_2(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\frac{\\tau}{2})\\prod_{k=L}^0 \\exp ( -i h_k \\frac{\\tau}{2})，\n", - "\\\\\n", - "S_{2k}(\\tau) &= [S_{2k - 2}(p_k\\tau)]^2S_{2k - 2}\\left( (1-4p_k)\\tau\\right)[S_{2k - 2}(p_k\\tau)]^2,\n", - "\\end{aligned}\n", - "\\tag{13}\n", - "$$\n", - "\n", - "对于 $k > 1, k\\in\\mathbb{Z}$，其中 $p_k = 1/(4 - 4^{1/(2k - 1)})$。先前推导的 product formula 实际上只使用了一阶的 Suzuki 分解 $S_1(\\tau)$ 来对每个“时间块”进行模拟，因此也被称为一阶 Suzuki product formula，或者简称一阶 product formula。Suzuki product formula 在物理中也经常被称为 Trotter-Suzuki 分解方法。对于更高阶的 product formula 而言，使用 (10-12) 中类似的计算，可以证明第 $2k$ 阶 product formula 的整体误差上界为：\n", - "\n", - "$$\n", - "\\epsilon\\left(e^{-iHt}, \\left(S_{2k}(\\tau)\\right)^r\\right)\n", - "\\leq\n", - "\\frac{(2L5^{k-1}\\Lambda\\vert t \\vert)^{2k+1}}{3r^{2k}} \\exp \\left( \\frac{2L5^{k-1}\\Lambda\\vert t \\vert}{r} \\right),\n", - "~ k > 1.\n", - "\\tag{14}\n", - "$$\n", - "\n", - "在得到了模拟误差上界的基础上，还可以进一步计算达到一定最小精度 $\\epsilon$ 时所需要的电路深度的下界。需要指出的是，(12) 和 (14) 中给出的误差上界的计算是十分宽松的。近年来，许多工作都进一步地给出了更加紧致的上界 [3, 5-6]。此外，也有人提出了不基于 Suzuki 分解的 product formula [7]。" - ] - }, - { - "cell_type": "markdown", - "id": "f3bf6fb2", - "metadata": {}, - "source": [ - "![image.png](./figures/trotter_suzuki_circuit.png)\n", - "
图1：Suzuki product formula 电路的示意图
" - ] - }, - { - "cell_type": "markdown", - "id": "e0c26758", - "metadata": {}, - "source": [ - "### 利用 Paddle Quantum 验证基于 Suzuki-product formula 的时间演化电路\n", - "\n", - "尽管人们不断的在优化 Suzuki-product formula 的误差上界，但是在实际使用中，真实的误差往往和理论上给出的上界有一定差距，也就是说，我们现在能计算的理论上的 product formula 误差依然只是一个十分宽松的上界 [3]。因此，对于一个真实的物理系统，我们往往需要通过数值实验来计算其真实的误差，从而给出一个经验性的误差上界（empirical bound）。这样的数值试验对于计算在一定精度下模拟某一时间演化过程所需要的电路深度十分重要。\n", - "\n", - "在刚刚介绍的 `construct_trotter_circuit` 函数中，用户也可以通过改变传入参数 `tau`、`steps`、`order` 来实现对任意阶 Suzuki product formula 电路的创建。下面，我们就利用该函数的这一功能来验证一下 Suzuki product formula 的误差。\n", - "\n", - "继续使用先前的哈密顿量：" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "86de7992", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "H = 1.0 Z0, Z1\n", - "1.0 X0\n", - "1.0 X1\n" - ] - } - ], - "source": [ - "print('H =', h_2)" - ] - }, - { - "cell_type": "markdown", - "id": "2e183412", - "metadata": {}, - "source": [ - "这里我们通过改变 `tau` 和 `steps` 两个参数来将 $t=1$ 的演化过程进行拆分。（提示：$\\tau \\cdot n_{\\rm steps} = t$）" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "240ed09f", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--*-----------------*----Rx(0.667)----*-----------------*----Rx(0.667)----*-----------------*----Rx(0.667)--\n", - " | | | | | | \n", - "--x----Rz(0.667)----x----Rx(0.667)----x----Rz(0.667)----x----Rx(0.667)----x----Rz(0.667)----x----Rx(0.667)--\n", - " \n", - "电路的酉算符和时间演化算符之间的保真度为： 0.984\n" - ] - } - ], - "source": [ - "# 将长度为 t 的时间演化过程拆为 r 份\n", - "r = 3\n", - "t = 1\n", - "cir = UAnsatz(2)\n", - "# 搭建时间演化电路，tau 为每个“时间块”的演化时间，故为 t/r，steps 是“时间块”的重复次数 r\n", - "construct_trotter_circuit(cir, h_2, tau=t/r, steps=r)\n", - "print(cir)\n", - "print('电路的酉算符和时间演化算符之间的保真度为： %.3f' \n", - " % gate_fidelity(cir.U.numpy(), linalg.expm(-1 * 1j * h_2.construct_h_matrix())))" - ] - }, - { - "cell_type": "markdown", - "id": "4708cad9", - "metadata": {}, - "source": [ - "我们发现，通过将 $t=1$ 的模拟时间拆分为三个“时间块”，模拟误差被成功减小了。\n", - "\n", - "如果进一步地增加拆分后的“时间块”的数量的话，误差还可以被进一步减小：" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "abc3742d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 导入一些作图和计算误差需要的额外包\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "def get_fid(n_steps):\n", - " t = 1\n", - " cir = UAnsatz(2)\n", - " construct_trotter_circuit(cir, h_2, tau=t/n_steps, steps=n_steps)\n", - " return gate_fidelity(cir.U.numpy(), linalg.expm(-1 * 1j * h_2.construct_h_matrix()))\n", - "plt.axhline(1, ls='--', color='black')\n", - "plt.semilogy(np.arange(1, 11), [get_fid(r) for r in np.arange(1, 11)], 'o-')\n", - "plt.xlabel('number of steps', fontsize=12)\n", - "plt.ylabel('fidelity', fontsize=12)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "f8381126", - "metadata": {}, - "source": [ - "不仅如此，我们还可以通过改变 product formula 的阶数来减小模拟误差。目前，`construct_trotter_circuit()` 函数支持通过参数 `order` 来实现任意阶数的 Suzuki product formula。下面，就让我们来分别计算一下一阶和二阶时间演化电路的误差随着 $\\tau$ 大小的变化，并和上文中计算的理论误差上界进行对比：" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "d3256b18", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 计算两个酉矩阵之间的 L1 谱距离，即 (5) 中定义的误差\n", - "def calculate_error(U1, U2):\n", - " return np.abs(linalg.eig(U1 - U2)[0]).max()\n", - "\n", - "# 封装计算误差的函数，自由参数为每个时间块的长度 tau 和 product formula 的阶数 order\n", - "def calculate_total_error(tau, order=1):\n", - " # 注意因为在电路中的多 Pauli 旋转门时会引入一个额外的全局相位，需要在计算误差时扣除\n", - " # 补充：该全局相位不会对实际的量子态产生任何可观测的影响，只是计算理论误差时需要扣除\n", - " h_2 = Hamiltonian([[1, 'Z0, Z1'], [1, 'X0'], [1, 'X1']])\n", - " cir = UAnsatz(2)\n", - " # 应为总时长为 1，故 steps = int(1/tau)，注意传入的 tau 需要可以整除 1\n", - " construct_trotter_circuit(cir, h_2, tau=tau, steps=int(1/tau), order=order)\n", - " cir_U = cir.U.numpy()\n", - " U_evolve = np.exp(1j) * linalg.expm(-1 * 1j * h_2.construct_h_matrix()) #理论上的时间演化算符加上一个全局相位\n", - " return calculate_error(cir_U, U_evolve)\n", - "\n", - "# 不同的参数 tau，注意它们需要可以整除 1\n", - "taus = np.array([0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1])\n", - "errors = []\n", - "\n", - "# 记录对应不同 tau 的总误差\n", - "for tau in taus:\n", - " errors.append(calculate_total_error(tau)) \n", - "\n", - "# 可视化结果\n", - "plt.loglog(taus, errors, 'o-', label='error')\n", - "plt.loglog(taus, (3 * taus**2 * (1/taus) * np.exp(3 * taus)), label='bound') # 按照 (10) 计算的一阶误差上界\n", - "plt.legend()\n", - "plt.xlabel(r'$\\tau$', fontsize=12)\n", - "plt.ylabel(r'$\\Vert U_{\\rm cir} - \\exp(-iHt) \\Vert$', fontsize=12)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "2fdbf168", - "metadata": {}, - "source": [ - "下面，我们将 `order` 设置为 2，并计算二阶 product formula 的误差：" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "a3db610c", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "taus = np.array([0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1])\n", - "errors = []\n", - "\n", - "for tau in taus:\n", - " errors.append(calculate_total_error(tau, order=2)) # 通过 order=2 指定 Suzuki 分解的阶数 \n", - "\n", - "plt.loglog(taus, errors, 'o-', label='error')\n", - "plt.loglog(taus, (2 * taus * 3 )**3 / 3 * (1/taus) * np.exp(3 * taus), '-', label='bound') # 按照 (12) 计算的二阶误差上界\n", - "plt.legend()\n", - "plt.xlabel(r'$\\tau$', fontsize=12)\n", - "plt.ylabel(r'$\\Vert U_{\\rm cir} - \\exp(-iHt) \\Vert$', fontsize=12)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "8c468fd4", - "metadata": {}, - "source": [ - "可以看到，实际计算出的模拟误差都小于其理论上界，说明这样的结果是符合预期的。\n", - "\n", - "## 小结\n", - "\n", - "本教程介绍了 Paddle Quantum 中构建模拟时间演化电路的功能，并对其背后的理论基础——Suzuki product formula 进行了介绍。利用该功能，用户可以通过搭建对于自定义哈密顿量的任意阶 product formula 电路来模拟不同物理系统的时间演化过程。\n", - "\n", - "量子模拟本身是一个比较宽泛的话题，其应用也十分广泛：凝聚态物理中的多体局域化、时间晶体、高温超导、拓扑序的研究；量子化学中的分子动力学模拟、反应模拟；高能物理中的场论模拟；乃至核物理和宇宙学中的相关研究。本教程中介绍的 Suzuki product formula 与基于通用量子计算机的数字量子模拟只是量子模拟的一部分，许多不基于通用量子计算机的量子模拟器，例如在冷原子、超导、离子阱以及光子等平台上做的模拟量子模拟（analogue quantum simulation）也是一个十分重要的方向。鉴于篇幅，本教程中无法进一步对这些内容逐一展开介绍，感兴趣的读者可以阅读 14 年的这篇综述文章 [8]。对于一些更新的结果，也可以参考这篇中文综述 [9]。\n", - "\n", - "在后续的教程 [模拟一维海森堡链的自旋动力学](./SimulateHeisenberg_CN.ipynb) 中，我们以凝聚态物理中的自旋模型为例，进一步地展示了如何利用本文中介绍的内容来进行量子多体模型的动力学模拟。同时，该教程也将介绍如何搭建不基于 Suzuki 分解的自定义时间演化电路。" - ] - }, - { - "cell_type": "markdown", - "id": "01705a8d", - "metadata": {}, - "source": [ - "---\n", - "\n", - "## 参考资料\n", - "\n", - "[1] Feynman, R. P. \"Simulating physics with computers.\" International Journal of Theoretical Physics 21.6 (1982).\n", - " \n", - "[2] Lloyd, Seth. \"Universal quantum simulators.\" [Science (1996): 1073-1078](https://www.jstor.org/stable/2899535).\n", - "\n", - "[3] Childs, Andrew M., et al. \"Toward the first quantum simulation with quantum speedup.\" [Proceedings of the National Academy of Sciences 115.38 (2018): 9456-9461](https://www.pnas.org/content/115/38/9456.short).\n", - "\n", - "[4] Nielsen, Michael A., and Isaac Chuang. \"Quantum computation and quantum information.\" (2002): 558-559.\n", - "\n", - "[5] Tran, Minh C., et al. \"Destructive error interference in product-formula lattice simulation.\" [Physical Review Letters 124.22 (2020): 220502](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.124.220502).\n", - "\n", - "[6] Childs, Andrew M., and Yuan Su. \"Nearly optimal lattice simulation by product formulas.\" [Physical Review Letters 123.5 (2019): 050503](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.123.050503).\n", - "\n", - "[7] Campbell, Earl. \"Random compiler for fast Hamiltonian simulation.\" [Physical Review Letters 123.7 (2019): 070503](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.123.070503).\n", - "\n", - "[8] Georgescu, Iulia M., Sahel Ashhab, and Franco Nori. \"Quantum simulation.\" [Reviews of Modern Physics 86.1 (2014): 153](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.86.153).\n", - "\n", - "[9] 范桁. \"量子计算与量子模拟.\" [物理学报 67.12(2018):16-25](http://wulixb.iphy.ac.cn/article/id/72211)." - ] - } - ], - "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.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorial/quantum_simulation/HamiltonianSimulation_EN.ipynb b/tutorial/quantum_simulation/HamiltonianSimulation_EN.ipynb deleted file mode 100644 index 57243f2..0000000 --- a/tutorial/quantum_simulation/HamiltonianSimulation_EN.ipynb +++ /dev/null @@ -1,734 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "7d09a637", - "metadata": {}, - "source": [ - "# Hamiltonian Simulation with Product Formula\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "id": "280b8be1", - "metadata": {}, - "source": [ - "## Overview\n", - "\n", - "In quantum mechanics, a system's energy is described with a Hamiltonian operator $H$. Solving all or partial properties of the Hamiltonian of a given system constitutes a central problem in many disciplines, including condensed matter physics, computational chemistry, high-energy physics, etc. However, the degrees of freedom of a quantum system grow exponentially with its system size, which leads to the inability to effectively simulate quantum systems using classical computers - the quantum state of several hundred qubits cannot be directly stored even with all the storage resources in the world. Unlike classical computers, quantum computers perform all operations directly on the exponentially large Hilbert space, thus having a natural advantage over classical computer when simulating a quantum system. Matter of fact, designing a controlled quantum system to efficiently simulate quantum systems in nature was Feynman's original idea when he first introduced the concept of quantum computing in the 1980s:\n", - " \n", - "> _\"Nature isn't classical, dammit, and if you want to make a simulation of nature, you'd better make it quantum mechanical, and by golly it's a wonderful problem, because it doesn't look so easy.\"_\n", - ">\n", - "> --- \"Simulating physics with computers\", 1982, Richard P. Feynman [1]\n", - "\n", - "\n", - "The development of universal quantum computers and a series of quantum simulators has made it possible to realize Feynman's vision. Digital quantum simulation on a universal quantum computer (i.e. quantum simulation by constructing quantum circuits through quantum gates) is considered to be to have the largest potential due to its scalability and generality.\n", - "\n", - "In this tutorial, we introduce Hamiltonian simulation in Paddle Quantum. It will be divided into three parts:\n", - "1. How to construct a system's Hamiltonian using `Hamiltonian` class.\n", - "2. How to create the time-evolving circuit with `construct_trotter_circuit()` function.\n", - "3. The Suzuki product formula algorithm and how to create its corresponding circuit up to arbitrary order.\n", - "\n", - "## Define the system's Hamiltonian \n", - "Before demoing how to construct a time-evolving circuit, we will first introduce to readers how to construct a `Hamiltonian` object in Paddle Quantum. Users could create a `Hamiltonian` object by specifying a list of Pauli string containing the coefficients and Pauli operators of each term. First let's consider a simple Hamiltonian:\n", - "\n", - "$$\n", - "H = Z \\otimes Z\n", - "\\tag{1}\n", - "$$\n", - "\n", - "This Hamiltonian describes a simple interaction between two qubits: when both qubits are in $|0\\rangle$ or $|1\\rangle$ , the energy of the system is $+1$; conversely when the two qubits are in different states, the energy of the system is $-1$.\n", - "\n", - "The user could construct this Hamiltonian by:" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "b1546d21", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0 Z0, Z1\n" - ] - } - ], - "source": [ - "from paddle_quantum.utils import Hamiltonian\n", - "\n", - "h = Hamiltonian([[1, 'Z0, Z1']])\n", - "print(h)" - ] - }, - { - "cell_type": "markdown", - "id": "99ff7830", - "metadata": {}, - "source": [ - "The `Hamiltonian` class in Paddle Quantum supports automatic merging of equal terms, addition, subtraction, indexing, and splitting:" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "82fae2f8", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "1.0 Z0, Z1\n" - ] - } - ], - "source": [ - "h = Hamiltonian([[0.5, 'Z0, Z1'], [0.5, 'Z1, Z0']], compress=True)\n", - "print(h)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "37ea39a0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "h + h: 2.0 Z0, Z1\n", - "h * 2: 2.0 Z0, Z1\n", - "h: 1.0 Z0, Z1\n" - ] - } - ], - "source": [ - "print('h + h:', h + h)\n", - "print('h * 2:', h * 2)\n", - "print('h:', h[:])" - ] - }, - { - "cell_type": "markdown", - "id": "34438c9e", - "metadata": {}, - "source": [ - "The `decompose_pauli_words()` and `decompose_with_sites()` methods can decompose the Hamiltonian into more manageable forms:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "8f292d61", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pauli words decomposition: ([1.0], ['ZZ'])\n", - "Pauli with sites decomposition: ([1.0], ['ZZ'], [[0, 1]])\n" - ] - } - ], - "source": [ - "print('Pauli words decomposition:', h.decompose_pauli_words())\n", - "print('Pauli with sites decomposition:', h.decompose_with_sites())" - ] - }, - { - "cell_type": "markdown", - "id": "10254485", - "metadata": {}, - "source": [ - "In addition, `construct_h_matrix()` will construct its matrix in the $Z$ Pauli basis:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "73dac520", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "matrix([[ 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]])" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "h.construct_h_matrix()" - ] - }, - { - "cell_type": "markdown", - "id": "3a320cb9", - "metadata": {}, - "source": [ - "## Simulate the time evolution\n", - "\n", - "According to one of the fundamental axioms of quantum mechanics, the evolution of a system over time can be described by\n", - "\n", - "$$\n", - "i \\hbar \\frac{\\partial}{\\partial t} | \\psi \\rangle = H | \\psi \\rangle,\n", - "\\tag{2}\n", - "$$\n", - "\n", - "$\\hbar$ is the reduced Planck constant. This equation is the well-known Schrödinger equation. Thus, for a time independent Hamiltonian, the time evolution equation of the system can be written as\n", - "\n", - "$$\n", - "|\\psi(t) \\rangle = U(t) | \\psi (0) \\rangle, ~ U(t) = e^{- i H t}.\n", - "\\tag{3}\n", - "$$\n", - "\n", - "Here we take the natural unit $\\hbar=1$ and $U(t)$ is the time evolution operator. The idea of simulating the time evolution process with quantum circuits is to approximate this time evolution operator using the unitary transformation constructed by quantum circuits. In Paddle Quantum, we provide the `construct_trotter_circuit(circuit, Hamiltonian)` function to construct a time-evolving circuit corresponding to a Hamiltonian. Now, let us test it with the Hamiltonian we just constructed:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "f983834e", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--*-----------------*--\n", - " | | \n", - "--x----Rz(2.000)----x--\n", - " \n" - ] - } - ], - "source": [ - "from paddle_quantum.trotter import construct_trotter_circuit\n", - "from paddle_quantum.circuit import UAnsatz\n", - "\n", - "cir = UAnsatz(2)\n", - "construct_trotter_circuit(cir, h, tau=1, steps=1) \n", - "print(cir)" - ] - }, - { - "cell_type": "markdown", - "id": "988ffa8b", - "metadata": {}, - "source": [ - "We can see that a quantum circuit has been constructed for `h`, which can simulate the time evolution of arbitrary time length based on the input `tau`.\n", - "\n", - "By calculating the matrix form of this circuit, one can see that it is identical to the time evolution operator $e^{-iHt}$. Here, we use `gate_fidelity` to calculate the fidelity between the unitary matrix of the quantum circuit and the unitary matrix of the time evolution operator. These two processes are identical when the fidelity is equal to 1. We note that a more formal definition of simulation error will be introduced at the end of this section. For now, let's consider fidelity as the criteria of similarity between two evolution processes (unitary operators)." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "52f3dff9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The fidelity is: 1.000\n" - ] - } - ], - "source": [ - "from scipy import linalg\n", - "from paddle_quantum.utils import gate_fidelity\n", - "\n", - "# calculate the fidelity between e^{-iHt} and the unitary matrix of circuit\n", - "print('The fidelity is: %.3f' \n", - " % gate_fidelity(cir.U.numpy(), linalg.expm(-1 * 1j * h.construct_h_matrix())))" - ] - }, - { - "cell_type": "markdown", - "id": "075faf9a", - "metadata": {}, - "source": [ - "Actually, this is because any rotation associated with a tensor product of the pauli operators can be efficiently decomposed into a circuit. In this example, we could change the angle of the Rz gate to simulate any $e^{-i Z\\otimes Z t}$ evolutionary operator. Does this mean that the time-evolving operator of any Pauli Hamiltonian could be perfectly simulated with a quantum circuit? Unfortunately, the answer is negative. Let us consider a slightly more complicated Hamiltonian:\n", - "\n", - "$$\n", - "H = Z \\otimes Z + X \\otimes I + I \\otimes X.\n", - "\\tag{4}\n", - "$$\n", - "\n", - "Similarly, let's use `construct_trotter_circuit` to construct its corresponding time-evolving circuit:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "8ec1213d", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--*-----------------*----Rx(2.000)--\n", - " | | \n", - "--x----Rz(2.000)----x----Rx(2.000)--\n", - " \n", - "The fidelity is: 0.681\n" - ] - } - ], - "source": [ - "h_2 = Hamiltonian([[1, 'Z0, Z1'], [1, 'X0'], [1, 'X1']]) # no need to write out unit operator\n", - "cir = UAnsatz(2)\n", - "construct_trotter_circuit(cir, h_2, tau=1, steps=1)\n", - "print(cir)\n", - "print('The fidelity is: %.3f' \n", - " % gate_fidelity(cir.U.numpy(), linalg.expm(-1 * 1j * h_2.construct_h_matrix())))" - ] - }, - { - "cell_type": "markdown", - "id": "f75bd0c7", - "metadata": {}, - "source": [ - "This time the fidelity is less than $1$, which means the circuit cannot correctly simulate the time-evolution process of the system.\n", - "\n", - "The reason is that, the unitary transformation of the circuit is $e^{-iZ\\otimes Z t} e^{-i (X\\otimes I + I\\otimes X)t}$, while the time evolution operator is $e^{-iZ\\otimes Z t - i(X\\otimes I + I\\otimes X)t}$. And for a quantum system, $e^{A+B} \\neq e^A e^B$ when $[A, B] \\neq 0$. Here, since $[X, Z] \\neq 0$, the corresponding unitary transformation of the circuit is not equal to the correct time-evolution operator.\n", - "\n", - "In addition to using the fidelity to describe the similarity between the quantum circuit and the time-evolving operator that one wishes to simulate, one can define the error $\\epsilon$ as follows\n", - "\n", - "$$\n", - "\\epsilon(U) = \\Vert e^{-iHt} - U \\Vert,\n", - "\\tag{5}\n", - "$$\n", - "\n", - "where $\\Vert \\cdot \\Vert$ denotes the mode of the largest eigen (singular) value. Such a definition better describes the deviation of the quantum state under different evolution operators and it is a more rigorous way to define the simulation time evolution error. We note that the simulation error of this form will be used repeatedly in the next section." - ] - }, - { - "cell_type": "markdown", - "id": "3109b3f5", - "metadata": {}, - "source": [ - "### Product formula and Suzuki decomposition\n", - "\n", - "In 1996, Seth Lloyd showed that the error in simulating time evolution can be reduced by splitting a whole evolution time $t$ into $r$ shorter \"time blocks\" [2]. Consider a more general Hamiltonian of the form $H = \\sum_{k=1}^{L} h_k$, where $h_k$ acts on a part of the system. By Taylor expansion, it is not difficult to find that the simulation error is a second-order term, i.e.\n", - "\n", - "$$\n", - "e^{-iHt} = \\prod_{k=1}^{L} e^{-i h_k t} + O(t^2).\n", - "\\tag{6}\n", - "$$\n", - "\n", - "Let $\\tau = t/r$ and consider the evolution operator $\\left(e^{-iH \\tau}\\right)^r$, then its error can be derived from \n", - "\n", - "$$\n", - "e^{-iHt} = \\left(e^{-iH \\tau}\\right)^r = \\left(\\prod_{k=1}^{L} e^{-i h_k \\tau} + O(\\tau^2) \\right)^r = \\left(\\prod_{k=1}^{L} e^{-i h_k \\tau} \\right)^r + O\\left(\\frac{t^2}{r}\\right).\n", - "\\tag{7}\n", - "$$\n", - "\n", - "The above equation states that an arbitrarily high simulation accuracy can be achieved by splitting the whole evolution time into enough \"pieces\". This is the basic idea of the product formula. However, the error given in (7) is only a rough estimate. In practice, in order to estimate the depth of the quantum circuit required to achieve a certain simulation accuracy, an exact upper bound on the error needs to be further computed. In the following, we show a relatively abbreviated procedure for calculating the error upper bound and readers who are not interested in details can skip to the conclusion on the error bound in (11).\n", - "\n", - "Let us note the remainder Taylor expansion of the function $f$ up to order $k$ to be $\\mathcal{R}_k(f)$. And the two following statements are needed for the calculating of the error bound:\n", - "\n", - "$$\n", - "\\left\\Vert \\mathcal{R}_k \\left( \\prod_{k=1}^{L} \\exp (-i h_k \\tau) \\right) \\right\\Vert\n", - "\\leq\n", - "\\mathcal{R}_k \\left( \\exp \\left( \\sum_{k=1}^{L} \\vert \\tau \\vert \\cdot \\Vert h_k \\Vert \\right) \\right),\n", - "\\tag{8}\n", - "$$\n", - "\n", - "$$\n", - "\\vert \\mathcal{R}_k(\\exp (\\alpha)) \\vert \\leq \\frac{\\vert \\alpha \\vert^{k+1}}{(k+1)!} \\exp ( \\vert \\alpha \\vert ), ~\n", - "\\forall \\alpha \\in \\mathbb{C}.\n", - "\\tag{9}\n", - "$$\n", - "\n", - "We omit the proofs of these two statements due to length limitations and interested reader could refer to Section F.1 in [3]. As defined in (5), the simulation error can be written as\n", - "\n", - "$$\n", - "\\epsilon\\left(e^{-iH\\tau}, U_{\\rm circuit}\\right) = \\left \\Vert \\exp\\left(-i\\sum_{k=1}^L h_k \\tau\\right) - \\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right \\Vert.\n", - "\\tag{10}\n", - "$$\n", - "\n", - "We already know that simulation error is the reminder of the time-evolving operators' Taylor expansion to the first order. Then using (8), (9) and the triangular inequality, the upper bound on the error in (10) can be calculated as follows\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "\\left \\Vert \\exp\\left(-i\\sum_{k=1}^L h_k \\tau\\right) - \\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right \\Vert\n", - "=~&\n", - "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\left( -i \\sum_{k=1}^{L} h_k \\tau \\right) - \\prod_{k=1}^{L} \\exp (-i h_k \\tau) \\right) \\right \\Vert\n", - "\\\\\n", - "\\leq~&\n", - "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\left( -i \\sum_{k=1}^{L} h_k \\tau \\right) \\right) \\right \\Vert\n", - "+\n", - "\\left \\Vert \\mathcal{R}_1 \\left( \\prod_{k=1}^{L} \\exp (-i h_k \\tau) \\right) \\right \\Vert\n", - "\\\\\n", - "\\leq~ &\n", - "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\left( \\vert \\tau \\vert \\cdot \\left \\Vert \\sum_{k=1}^{L} h_k \\right \\Vert \\right) \\right) \\right \\Vert\n", - "+ \n", - "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\sum_{k=1}^{L} \\left( \\vert \\tau \\vert \\cdot \\Vert h_k \\Vert \\right) \\right) \\right \\Vert\n", - "\\\\\n", - "\\leq~&\n", - "2 \\mathcal{R}_1 \\left( \\exp ( \\vert \\tau \\vert L \\Lambda ) \\right )\n", - "\\\\\n", - "\\leq~&\n", - " ( \\vert \\tau \\vert L \\Lambda )^2 \\exp ( \\vert \\tau \\vert L \\Lambda ),\n", - "\\end{aligned}\n", - "\\tag{11}\n", - "$$\n", - "\n", - "with $\\Lambda = \\max_k \\Vert h_k \\Vert$. Considering the complete evolution time $t = r \\cdot \\tau$, the error when simulating a time evolution operator of length $t$ is\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "\\left \\Vert \\left ( \\exp\\left(-i\\sum_{k=1}^L h_k \\tau \\right)\\right)^r - \\left (\\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right)^r \\right \\Vert\n", - "\\leq ~&\n", - "r \\left \\Vert \\exp\\left(-i\\sum_{k=1}^L h_k \\tau\\right) - \\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right \\Vert\n", - "\\\\\n", - "=~& r ( \\tau L \\Lambda )^2 \\exp ( \\vert \\tau \\vert L \\Lambda )\n", - "\\\\\n", - "=~& \\frac{( t L \\Lambda )^2}{r} \\exp \\left( \\frac{\\vert t \\vert L \\Lambda}{r} \\right).\n", - "\\end{aligned}\n", - "\\tag{12}\n", - "$$\n", - "\n", - "Here we use the conclusion of linear accumulation of errors in quantum circuits, i.e. $\\Vert U^r - V^r \\Vert \\leq r\\Vert U - V \\Vert$, and the reader who is not familiar with this conclusion can refer to Section 4.5.3 in [4]. At this point, we have calculated an upper bound on the simulation error of the product formula for a complete period of evolution time $t$, i.e., the second-order term $O(t^2/r)$ in Eq. (7). \n", - "\n", - "In fact, we can further optimize the simulation accuracy for the time-evolution operator $e^{-iH\\tau}$ within each \"time block\" by the Suzuki decomposition. For the Hamiltonian $H = \\sum_{k=1}^{L} h_k$, the Suzuki decomposition of the time evolution operator can be written as\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "S_1(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\tau),\n", - "\\\\\n", - "S_2(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\frac{\\tau}{2})\\prod_{k=L}^0 \\exp ( -i h_k \\frac{\\tau}{2}),\n", - "\\\\\n", - "S_{2k}(\\tau) &= [S_{2k - 2}(p_k\\tau)]^2S_{2k - 2}\\left( (1-4p_k)\\tau\\right)[S_{2k - 2}(p_k\\tau)]^2,\n", - "\\end{aligned}\n", - "\\tag{13}\n", - "$$\n", - "\n", - "For $k > 1, k\\in\\mathbb{Z}$, where $p_k = 1/(4 - 4^{1/(2k - 1)})$. The previously derived product formula actually uses only the first-order Suzuki decomposition $S_1(\\tau)$ to simulate each \"time block\". Therefore it's also known as the first-order Suzuki product formula, or simply the first-order product formula. In some scenarios, the Suzuki product formula is also referred to as the Trotter-Suzuki decomposition. For higher-order product formulas, using similar calculations as in (10-12), it can be shown that the error bound on the error for the $2k$th order product formula is：\n", - "\n", - "$$\n", - "\\epsilon\\left(e^{-iHt}, \\left(S_{2k}(\\tau)\\right)^r\\right)\n", - "\\leq\n", - "\\frac{(2L5^{k-1}\\Lambda\\vert t \\vert)^{2k+1}}{3r^{2k}} \\exp \\left( \\frac{2L5^{k-1}\\Lambda\\vert t \\vert}{r} \\right),\n", - "~ k > 1.\n", - "\\tag{14}\n", - "$$\n", - "\n", - "With the upper bound on the simulation error obtained, it is possible to further calculate the lower bound on the circuit depth required to reach a certain minimum accuracy $\\epsilon$. It should be noted that the error bounds given in (12) and (14) are calculated very loosely. In recent years, many works have gone further to give tighter upper bounds [3, 5-6]. In addition, product formulas that are not based on the Suzuki decomposition have also been proposed [7]." - ] - }, - { - "cell_type": "markdown", - "id": "f3bf6fb2", - "metadata": {}, - "source": [ - "![image.png](./figures/trotter_suzuki_circuit.png)\n", - "
Fig 1: The circuit of Suzuki product formula
" - ] - }, - { - "cell_type": "markdown", - "id": "0b3ff06a", - "metadata": {}, - "source": [ - "### Verification of Suzuki-product formula-based time-evolving circuits using Paddle Quantum\n", - "\n", - "Although the upper bound on the error of the Suzuki-product formula has been continuously optimized, in practice, the real error is often different from the theoretical upper bound, i.e., the theoretical product formula error that we can calculate now is still only a very loose upper bound [3]. Therefore, for a real physical system, we often need to calculate the real error through numerical experiments to give an empirical bound on the error. Such numerical experiments are important as they could be used to determine the circuit depth needed to simulate a certain time evolution process at a certain accuracy.\n", - "\n", - "In the `construct_trotter_circuit` function, It constructs by default a circuit based on the first order product formula. Users can create simulation circuits of higher order product formulas with more time blocks by manipulating the arguments `tau`, `steps`, `order`. As the last part of this tutorial, we will demonstrate how these options work in Paddle Quantum.\n", - "\n", - "Using the previous Hamiltonian:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "b1609917", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "H = 1.0 Z0, Z1\n", - "1.0 X0\n", - "1.0 X1\n" - ] - } - ], - "source": [ - "print('H =', h_2)" - ] - }, - { - "cell_type": "markdown", - "id": "a6ecb816", - "metadata": {}, - "source": [ - "Here we split the evolution of $t=1$ by changing the `tau` and `steps`. (Hint: $\\tau \\cdot n_{\\rm steps} = t$)" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "e559b726", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "--*-----------------*----Rx(0.667)----*-----------------*----Rx(0.667)----*-----------------*----Rx(0.667)--\n", - " | | | | | | \n", - "--x----Rz(0.667)----x----Rx(0.667)----x----Rz(0.667)----x----Rx(0.667)----x----Rz(0.667)----x----Rx(0.667)--\n", - " \n", - "The fidelity is: 0.984\n" - ] - } - ], - "source": [ - "# Split the time evolution process of length t into r blocks\n", - "r = 3\n", - "t = 1\n", - "cir = UAnsatz(2)\n", - "# Construct the time evolution circuit, tau is the evolution time of each \"time block\", i.e. t/r\n", - "# Steps is the number of repetitions of the \"time block\" r\n", - "construct_trotter_circuit(cir, h_2, tau=t/r, steps=r)\n", - "print(cir)\n", - "print('The fidelity is: %.3f' \n", - " % gate_fidelity(cir.U.numpy(), linalg.expm(-1 * 1j * h_2.construct_h_matrix())))" - ] - }, - { - "cell_type": "markdown", - "id": "5b94d8ec", - "metadata": {}, - "source": [ - "We can see that by splitting the simulation time of $t=1$ into three \"time blocks\", the simulation error was successfully reduced.\n", - "\n", - "The error could be further reduced if we further split the evolution process into more 'pieces':" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "95e891f9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZ4AAAEJCAYAAACkH0H0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAAjuklEQVR4nO3deZhcZZn38e9d1XvS6YTsGySQEAhRyYCoOKCvgWExCOMCRMFBHEEcZwZfwAFceB0QGVGHmVEYcWBwhbBmAFEQGGFEXgyQKKksJIQl6UrIXtXd6U53V93zR1V3ek91uvucWn6f6+qrqs45dc5dlU79+nnOU88xd0dERCQokbALEBGR0qLgERGRQCl4REQkUAoeEREJlIJHREQCVRZ2AYVgwoQJPmvWrLDLEBEpKC+99NIOd5/Yc7mCJwezZs3ixRdfDLsMEZGCYmZv9rVcXW0iIhIoBY+IiARKwSMiIoFS8IiISKAUPCIiEqiSG9VmZqOAW4FW4Lfu/vOQSxIRKSlFETxmdiewGNjm7gu6LD8d+BcgCvyHu98EfBS4390fMbOlgIJHRFi2op6bH19HfE8z08ZWc9Vp8zhn4fSSqyGIOqwYLotgZicDjcBPOoLHzKLAq8CpwGZgObAEOBv4lbuvNLNfuPsnD7T/2tpaP+6447otO/fcc/nCF77A3r17OfPMM3s956KLLuKiiy5ix44dfPzjH++1/rLLLuO8885j06ZNXHjhhb3WX3HFFZx11lmsW7eOSy+9tNf6r371q5xyyimsXLmSyy+/vNf6G2+8kRNPPJHf//73XHvttb3W33LLLRx77LE8+eST3HDDDb3W//CHP2TevHk88sgjfPe73+21/qc//SkzZ85k6dKl3Hbbbb3W33///UyYMIG77rqLu+66q9f6xx57jJqaGm699VbuvffeXut/+9vfAvCd73yHRx99tNu66upqfvWrXwFw/fXX89RTT3VbP378eB544AEArrnmGp5//vlu62fMmMHPfvYzAC6//HJWrlzZbf2RRx7J7bffDsAll1zCq6++2m39scceyy233ALABRdcwObNm7utf9/73se3vvUtAD72sY+xc+fObusXLVrE1772NQDOOOMMmpubu61fvHgxV155JQAf/OAH6Wm4fvfueOpP3PjoKlIVY4i2Jhn31rOM3rk28N+9xvFHsfvQkzvruPLUuVx25rsD/d1rHH8UOw8/HY+Wd25XRpqx63/J6J1rO5eN5O9e4/ij2DXnDNK2vz1gqTbGb/x1Zw1B/O7NWbSEax58hea2VK86Ll70zkH97j3zzDMvufvxPbcrihaPuz9rZrN6LD4B2ODuGwHM7B4yobMZmAGsZIBzXGZ2CXAJQGVl5fAXLSVrQ9s43n/T08T3NBM9+tOMffOZbh9uQVi2op5v//dmUpV1AKQq69h5+OnDtn93J+2OWxS3CJjhRMAi7GpOEd/TzPZmZ8+U40gcehIeKe+s43vPbWdfxatEktAyenrmuWaAgRkvvNnAhqZtrElE2TtuDp5dDpntfrV6B6NGt7BiTyUNExeARTrXgfHTFzYTLSvjD8laElNPwA0S097TLXQA2omwc/Zf0FozCQzAKCsr5/pHV5N254V9M9g5axHZlbgZjVVVXP3An0i7s9znsv2IsZ3rMaOppoYv/uJl3GFF+TvZM/ew7HsDLXWzcOv+kezRcnYcfgaNk94JwO/Kazn/9udxhzUTF7FvTGvnvgGe8FrW/OA5HFg/8yzap6a6rX+ouZbnbnkWd3jjyCWkOxoe2Rp+ums0jff9kVS6e4PEo+XsPvRkYM/B/Dr0UhQtHoBs8DzapcXzceB0d//r7OMLgfcA/wB8H2gBfpfLOZ7jjz/eNXOBDIdlK+p7/TVZXR7lWx99R2dXRjrttKXTtKWc1vY0bak0re1pWlP772duPbOs43HnOqe1PZW57bZ9x3bOshX13WroUFkW4diZY0mlnfZ0JjzaU559nCbt0J5Ok0p1WZ92Uikn1XE/+1MsKqIRLJttETMiZhjZx5HM/YhZdhsjYmBkb7PLIz1uO57T9XlrtiT7reG4w8Z1HtPI7KD7cTPLs/nS7TjWpd5u9+n9XDPjkT/G+6zBgNdv+vCg3jszK94Wz2C4exPwmbDrkOANV791Ou3sbUvRtK+dpn3t7G1N7b9tbc8uT7G3tZ2m1hR792Vum/a18/TabexrT3fbX3Nbii/du5JrH3qFtlQmOIZbedQoj0Yoj0aoKIv0GTpAZ22V5RGqzSiLGNFIJHub+SmLGJGIdS7r/jjSa310gG2vvO+P/db844tPINLlwz5iEI1Y54d7NGL710Ugan2si2Qf91hnZtltMvv/0Hd+SzzR0quG6WOree7qDw3PP8IBvP+mp6nf09xr+fSx1Txw2YmB1ADw8pu7+6xj2tjqYTtGMQdPPTCzy+MZ2WVSgpatqOfqB/9ES1vmg7V+TzNX3f9Hnt+4g3mTx7C3tZ3GjrDoERqN2VDpWNffh3ZfyqPGqMoyRlWUUVMR7RU6HdzhkyccSkXZ/nCoiEYojxoVZdHsbceyCOXZ+xVl1rl9ebRjWaTLMqM8EiESsW7HG+hDbuml7xvEOzs0//ybV/ut4wNH9ppbcsR8+fSj+myJXnXavMBquOq0eaHXEFQdxRw8y4G5ZjabTOCcDxxwIIEUppa2FFsTLcQTzWxNtLAl0cKWRDNb9mTur92apGfvT1vKWbp8/8nZimiEmspoZ0iMqixjVGWUcaNqGFURpaayjFEdyyvK+ti2rNt2NRVlVJR1P4040Af+VxfPH5H3pi+l9CGXi46Wb5gjyvKhhqDqKIpzPGZ2N/BBYALwNnCdu99hZmcCt5AZTn2nu3/zYPavczxDN5Rurv5CZWuihfieFrYmW9jV1NrreeNqyplSV83UuiqeXrutz30bsPLrf0F1RbRXSIyEXM7xBKVUhu5KePo7x1MUwTPSFDxDM9CH7ekLpnRvoeQYKmNrypmaDZX9P9nHY6uZMqaK6opo5/YDtTSC6sPvoA9aKRUKniFQ8AxNfx/6EaNX9xdkQmXKmCqmja1mSl0V0+qqmFJXnb3NBEzXUMlFPrU0REqFRrVJ4Frb0zy15u0+QwcyoXPFqUcydez+lsuUuipqKob/1zJf+s9FRMEjI2DDtkbufXETD7y0mZ1Nrf22bKaPreZvF80NrK5zFk5X0IjkAQWPDIvm1hS/fGULS5e/xfI3dlMWMU45ejLnnTCT3Y2tfGXZqtBHLolIflDwyJCsqk9wz/K3+K8VcRr2tTN7wiiuPuMoPvpn05lUW9W5XSRi6uYSEUDBIwch0dzGwyvruWf5JmLxJJVlET78jqmc9+6ZnDD7EMys13PUzSUiHRQ8khN35w+v72Lp8k388pUt7GtPM3/qGK4/+xg+cux06qrLD7wTEREUPHIA2xv28eDLm1m6fBMbdzRRW1nGx4+bwZITDmXB9LqwyxORAqTgkV5SaefZ9dtZ+odNPLnmbdrTzrtnjeML/2cOZ75jyogMdxaR0qFPEOm0efde7n1xM/e9uIktiRbGj6rg4j+fzbnHz2TOpNFhlyciRULBU+Ja29P8ZvXb3LP8LX63YQcAJ82dyNcWz+eUoycHMn+ZiJQWBU+J2rCtgaXLN/HAy/XsamplWl0Vf/ehuXzi+BnMGFcTdnkiUsQUPEWu64SUU+qq+OC8iax/u5EX38x8yfPU+ZM5790zOWnuRKKR3sOgRUSGm4KniPWcGHNLooW7/7CJibUVXHvmUfzlwhlMrK0MuUoRKTUKniJ28+Pr+rxaZkU0wiUnHxFCRSIioDPHRSzez6zQ8T29ry0vIhIUBU8Rmza2elDLRUSCoOApYledNq/XgAHNCi0iYVPwFLFzFk5n5rhqKqIRjMz1b3TFTREJmwYXFLFU2tnWsI8lJ8zkG2cvCLscERFALZ6i9sbOJva2pjhmmibzFJH8oeApYrF4EoBjpo8JuRIRkf0UPEUsFk9QHjXmTqoNuxQRkU4KniK2Op7kyMm1muhTRPKKPpGKlLsTiyc5Zpq62UQkvyh4itTWZAu7mlo1sEBE8o6Cp0itqs8OLFCLR0TyjIKnSMXiCczg6KkKHhHJLwqeIhWLJ5k9fhSjKvUdYRHJLwqeIrU6nmS+utlEJA8peIrQ7qZW6vc0a2CBiOQlBU8RWr1FAwtEJH8peIpQLJ4AFDwikp8UPEUoFk8yZUwV40dXhl2KiEgvCp4iFIsnWaCJQUUkTyl4ikxza4qN2xuZr4EFIpKnFDxFZs3WJGnX+R0RyV8KniLTeQ0eBY+I5CkFT5FZHU9QV13O9LHVYZciItInBU+R6bgUgpmFXYqISJ8UPEWkLZVm7ZYGdbOJSF5T8BSRDdsaaU2lNVWOiOQ1BU8R0cACESkECp4iEosnqCqPcPjE0WGXIiLSr5INHjM73MzuMLP7w65luMTiSY6aMoZoRAMLRCR/BRY8Zvb3ZrbKzGJmdvkQ9nOnmW0zs1V9rDvdzNaZ2QYzu3qg/bj7Rnf/7MHWkW/SaWdNdkSbiEg+CyR4zGwB8DngBOBdwGIzm9Njm0lmVttjWbdtsu4CTu/jGFHgB8AZwHxgiZnNN7N3mNmjPX4mDcsLyyObdu+lYV+7BhaISN4LqsVzNPCCu+9193bgGeCjPbb5ALDMzCoBzOxzwL/13JG7Pwvs6uMYJwAbsi2ZVuAe4Gx3f8XdF/f42ZZL0WZ2lpndnkgkcn6hYekYWKDJQUUk3wUVPKuAk8xsvJnVAGcCM7tu4O73AY8DS83sU8DFwCcGcYzpwKYujzdnl/UpW8u/AwvN7Jq+tnH3R9z9krq6/G9FxOIJohHjyMm1B95YRCREZUEcxN3XmNk/AU8ATcBKINXHdt82s3uA24Aj3L1xBGvaCXx+pPYftFg8ydxJo6kqj4ZdiojIgAIbXODud7j7ce5+MrAbeLXnNmZ2ErAAeAi4bpCHqKd7K2pGdllJiMWTzNfAAhEpAEGOapuUvT2UzPmdX/RYvxC4HTgb+Aww3sxuGMQhlgNzzWy2mVUA5wMPD0ft+W5bQwvbG/ZpYIGIFIQgv8fzgJmtBh4B/sbd9/RYXwOc6+6vuXsa+DTwZs+dmNndwPPAPDPbbGafBcgOWvgimfNEa4B73T02Yq8mj2jGAhEpJIGc4wFw95MOsP65Ho/bgB/1sd2SAfbxGPDYwdZYqFZng0ddbSJSCEp25oJisqo+waGH1DCmqjzsUkREDkjBUwRimrFARAqIgqfAJVvaeGvXXgWPiBQMBU+BW905sEAj2kSkMCh4CpxGtIlIoVHwFLhYPMGE0ZVMGlMVdikiIjlR8BS41fGkJgYVkYKi4ClgLW0p1m9rVDebiBQUBU8Be/XtBlJp18ACESkoCp4CpoEFIlKIFDwFLBZPUFtZxsxxNWGXIiKSMwVPAYvFkxw9bQyRiIVdiohIzhQ8BSqVdtZuaVA3m4gUHAVPgXp9RyPNbSkNLBCRgqPgKVCr6jWwQEQKk4KnQMXiCSrKIsyZNDrsUkREBkXBU6Bi8STzJtdSHtU/oYgUFn1qFSB31zV4RKRgKXgKUP2eZhLNbQoeESlICp4C1DljwXSNaBORwqPgKUCxeJKIwdFT1OIRkcKTU/CY2UNmdo6ZlY90QXJgq+MJDp84muqKaNiliIgMWq4tnv8Bvg5sNbPbzOzEEaxJDkADC0SkkOUUPO7+PXf/M+BkYA9wt5mtN7Ovm9kRI1mgdLerqZUtiRYFj4gUrEGd43H3mLtfA1wA7AWuA142syfN7F0jUaB0F4snADRVjogUrJyDx8zmmdn1ZvYacDuwFJgFTAYeA5aNRIHSna7BIyKFriyXjczsRTIhsxT4pLu/0GOT75nZ3w5zbdKHWDzJ9LHVjK2pCLsUEZGDklPwADcBD7t7a38buPvs4SlJBhKLJ5iv1o6IFLBcu9q+0lfoZFtCEpCmfe28vqNJ3WwiUtByDZ5eI9fMzIDDh7ccGciaLUncNbBARArbgF1tZvaT7N3KLvc7zAJiI1GU9E0DC0SkGBzoHM9r/dx34DngvmGvSPoViycYV1PO1LqqsEsRETloAwaPu38DwMz+v7s/HkxJ0p9YPMmC6XVkejlFRApTv8FjZie7+7PZh21m9qG+tnP3p0ekMummtT3Nq283cPGfa/CgiBS2gVo8twILsvfv6GcbRwMMArF+WwNtKdfAAhEpeP0Gj7sv6HJff2aHTAMLRKRY6Ho8BWJ1PElNRZTZ40eFXYqIyJAMdI5nE5mutAG5+6HDWpH0KRZPcPTUMUQiGlggIoVtoHM8FwRWhQwonXZWx5N87LgZYZciIjJkA53jeSbIQqR/b+7aS1NrSud3RKQo5Hrp60oz+6aZbTSzRHbZX5jZF0e2PAFdg0dEikuugwv+mczQ6k+x/7xPDLhsJIqS7mLxJGURY+7k0WGXIiIyZLleFuEvgTnu3mRmaQB3rzez6SNXmnRYVZ9g7uRaKsuiYZciIjJkubZ4WukRUmY2Edg57BVJN+6ZgQU6vyMixSLX4LkP+LGZzQYws6nA94F7RqowyXg7uY+dTa0KHhEpGrkGz7XA68ArwFhgPRAHvjEyZUmHjoEFC6ZrYIGIFIeczvFkrz76JeBL2S62He5+wC+XytDF4knM4OipavGISHEYaOaCgSb/rO2Ymt/dNw53UbJfLJ5g1vhRjK7MdRyIiEh+G+jTbAOZodPG/iHUHfO1dG3taKjVCIrFk7xr5tiwyxARGTb9nuNx94i7R909Avw1mYEE84Aq4CjgF8BnA6myRCX2trF5d7MGFohIUcm1/+Z6YK67N2cfrzezS4FXgbtGojCB2BbNWCAixSfXUW0RYFaPZYdRwN1sZna4md1hZveHXUt/VusaPCJShAYzZc7TZnajmV1mZjcCT2WX58TMvmRmMTNbZWZ3m1nVwRRsZnea2TYzW9XHutPNbJ2ZbTCzqwfaj7tvdPe87iqMxZNMHlPJhNGVYZciIjJscgoed78Z+AwwGfgIMAW42N2/ncvzs1Pr/B1wfPbKplHg/B7bTDKz2h7L5vSxu7uA0/s4RhT4AXAGMB9YYmbzzewdZvZoj59JudQdtlg8oW42ESk6OY/RdfdfA78e4rGqzawNqCHzBdSuPgB83szOdPd9ZvY54KNkgqRrHc+a2aw+9n8CsKFjeLeZ3QOc7e7fAhYfTMFmdhZw1pw5feXfyGppS/Ha9iZOO2ZK4McWERlJA32P5yvu/s3s/X/sbzt3//qBDpKdUPQ7wFtAM/CEuz/RY5v7slPyLDWz+4CLgVNzexkATAc2dXm8GXhPfxub2Xjgm8BCM7smG1A9634EeOT444//3CDqGBZrtzaQSrvO74hI0RmoxfMNMh/MAEeQmSj0oJjZOOBsYDawB7jPzC5w95913c7dv51tqdwGHOHujQd7zANx953A50dq/0O1ql4j2kSkOA0UPHu73D/L3Yfyp/cpwOvuvh3AzB4ETgS6BY+ZnUTmuj8PAdcBg7nQXD0ws8vjGdllBSkWTzKmqowZ46rDLkVEZFgNFDyvmdl3yVzwrczMPsP+mQs6ufudORznLeC9ZlZDpqttEfBi1w3MbCFwO5nzMa8DPzezG9z9qzm9ElgOzM1219WTGbzwyRyfm3dWZwcWdExNJCJSLAYKnvOALwNLgArg031s48ABg8fdX8h+X+ZloB1YQSZkuqoBznX31wDM7NPART33ZWZ3Ax8EJpjZZuA6d7/D3duzl+J+nMyouTvdPXag2vJReyrN2q0NXPjew8IuRURk2PUbPO7+KpmpcjCzp9x90VAO5O7Xkek+62/9cz0etwE/6mO7JQPs4zHgsSGUmRde297EvvY0x0zXwAIRKT65fo9nSKEjg9NxDR4NLBCRYpTrzAUSoFg8SWVZhMMnjAq7FBGRYafgyUOxeIKjpo6hLKp/HhEpPvpkyzPuzup4Ul8cFZGipeDJM5t3N5NsaVfwiEjRUvDkGQ0sEJFip+DJM7F4kmjEOGpK7YE3FhEpQAqePBOLJzli4iiqygv2GnsiIgNS8OSZVfW6Bo+IFDcFTx7Z3rCPbQ37NLBARIqagiePaGCBiJQCBU8eicWTAMxXi0dEipiCJ4+sjieZeUg1ddXlYZciIjJiFDx5JBZPcMxUdbOJSHFT8OSJhpY23ti5VwMLRKToKXjyxJotDQC6Bo+IFD0FT57QiDYRKRUKnjwRiyeZMLqCSbWVYZciIjKiFDx5IhZPMn9aHWYWdikiIiNKwZMH9rWnWP92gwYWiEhJUPDkgfVvN9KedgWPiJQEBU8e0MACESklCp48sKo+yejKMg47pCbsUkRERpyCJw/E4gnmTx1DJKKBBSJS/BQ8IUulnTVbGjQxqIiUDAVPyF7f0URzW0oDC0SkZCh4QqaBBSJSahQ8IVsdT1IRjTB38uiwSxERCYSCJ2SxeJIjp4ymPKp/ChEpDfq0C5G76xo8IlJyFDwh2pJoYffeNl0KQURKioInRLF4EkAj2kSkpCh4QhSLJzCDo6YoeESkdCh4QhSLJ5k9YRSjKsvCLkVEJDAKnhCtjif1/R0RKTkKnpDsbmqlfk+zzu+ISMlR8ISkY2DBArV4RKTEKHhCsn+qHLV4RKS0KHhCEosnmVZXxbhRFWGXIiISKAVPSGLxBPPVzSYiJUjBE4K9re1s3NGkbjYRKUkKnhCs2dKAu87viEhpUvCEYHXHwILp6moTkdKj4AlBLJ5kbE050+qqwi5FRCRwCp4QxOJJjpk2BjMLuxQRkcApeALWlkqzbmuDpsoRkZKl4AnYhm2NtKbSGlggIiVLwRMwXYNHREqdgidgsXiC6vIosyeMDrsUEZFQKHgCFosnOXpqLdGIBhaISGlS8AQonXZdg0dESp6CJ0Bv7dpL4752nd8RkZKm4AnQ/oEFavGISOlS8AQoFk9QFjGOnKKBBSJSuhQ8AYrFk8yZNJrKsmjYpYiIhEbBE6CYBhaIiCh4grIt2cKOxn0aWCAiJU/BExDNWCAiklGywWNmh5vZHWZ2fxDHi2WvwTNfwSMiJS6Q4DGzeWa2sstP0swuP8h93Wlm28xsVR/rTjezdWa2wcyuHmg/7r7R3T97MDUcjFg8yWHja6itKg/qkCIieaksiIO4+zrgWAAziwL1wENdtzGzSUCzuzd0WTbH3Tf02N1dwPeBn/R4fhT4AXAqsBlYbmYPA1HgWz32cbG7bxvaqxqcWDzJgulq7YiIhNHVtgh4zd3f7LH8A8AyM6sEMLPPAf/W88nu/iywq4/9ngBsyLZkWoF7gLPd/RV3X9zjJ9DQSba08dauvRrRJiJCOMFzPnB3z4Xufh/wOLDUzD4FXAx8YhD7nQ5s6vJ4c3ZZn8xsvJn9O7DQzK7pZ5uzzOz2RCIxiDJ6W62BBSIinQINHjOrAD4C3NfXenf/NtAC3AZ8xN0bR6oWd9/p7p939yPcvWdXXMc2j7j7JXV1Q2upaKocEZH9gm7xnAG87O5v97XSzE4CFpA5/3PdIPddD8zs8nhGdlnoYvUJJtVWMrG2MuxSRERCF3TwLKGPbjYAM1sI3A6cDXwGGG9mNwxi38uBuWY2O9uyOh94eIj1DovMjAXqZhMRgQCDx8xGkRlx9mA/m9QA57r7a+6eBj4N9ByAgJndDTwPzDOzzWb2WQB3bwe+SOY80RrgXnePDf8rGZyWthQbtjeqm01EJCuQ4dQA7t4EjB9g/XM9HrcBP+pjuyUD7OMx4LEhlDns1m1tIJV2tXhERLJKduaCoGhggYhIdwqeERaLJ6itKmPmIdVhlyIikhcUPCMsFk8yf+oYzCzsUkRE8oKCZwSl0s7arboGj4hIVwqeEbRxeyMtbWkNLBAR6ULBM0KWrajn3B8+D8A//Xoty1bkxXdZRURCF9hw6lKybEU91zz4Cs1tKQC2NezjmgdfAeCchf1OHyciUhLU4hkBNz++rjN0OjS3pbj58XUhVSQikj8UPCMgvqd5UMtFREqJgmcETBvb93d2+lsuIlJKFDwj4KrT5lFdHu22rLo8ylWnzQupIhGR/KHBBSOgYwDBzY+vI76nmWljq7nqtHkaWCAigoJnxJyzcLqCRkSkD+pqExGRQCl4REQkUAoeEREJlIJHREQCpeAREZFAmbuHXUPeM7PtwJth1zFEE4AdYReRJ/RedKf3ozu9H/sN9b04zN0n9lyo4CkRZvaiux8fdh35QO9Fd3o/utP7sd9IvRfqahMRkUApeEREJFAKntJxe9gF5BG9F93p/ehO78d+I/Je6ByPiIgESi0eEREJlIJHREQCpeApYmY208z+28xWm1nMzP4+7JrygZlFzWyFmT0adi1hM7OxZna/ma01szVm9r6wawqLmX0p+/9klZndbWZVYdcUJDO708y2mdmqLssOMbPfmNn67O244TiWgqe4tQNXuPt84L3A35jZ/JBrygd/D6wJu4g88S/Ar939KOBdlOj7YmbTgb8Djnf3BUAUOD/cqgJ3F3B6j2VXA0+5+1zgqezjIVPwFDF33+LuL2fvN5D5UCnpiwSZ2Qzgw8B/hF1L2MysDjgZuAPA3VvdfU+oRYWrDKg2szKgBoiHXE+g3P1ZYFePxWcDP87e/zFwznAcS8FTIsxsFrAQeCHkUsJ2C/BlIB1yHflgNrAd+M9s1+N/mNmosIsKg7vXA98B3gK2AAl3fyLcqvLCZHffkr2/FZg8HDtV8JQAMxsNPABc7u7JsOsJi5ktBra5+0th15InyoA/A25z94VAE8PUlVJosucuziYTxtOAUWZ2QbhV5RfPfPdmWL5/o+ApcmZWTiZ0fu7uD4ZdT8jeD3zEzN4A7gE+ZGY/C7ekUG0GNrt7Ryv4fjJBVIpOAV539+3u3gY8CJwYck354G0zmwqQvd02HDtV8BQxMzMy/fdr3P17YdcTNne/xt1nuPssMieOn3b3kv2r1t23ApvMbF520SJgdYglhekt4L1mVpP9f7OIEh1o0cPDwF9l7/8V8F/DsVMFT3F7P3Ahmb/sV2Z/zgy7KMkrfwv83Mz+BBwL3BhuOeHItvruB14GXiHz2VhSU+eY2d3A88A8M9tsZp8FbgJONbP1ZFqFNw3LsTRljoiIBEktHhERCZSCR0REAqXgERGRQCl4REQkUAoeEREJlIJHJGBm9oaZnRLSsSeb2bNm1mBm3w2jBpGysAsQkUBdAuwAxri+SyEhUYtHpEBlZ1EerMOA1QodCZOCR4TO7q8rzexPZpYws6UdFwIzs4vM7Hc9tnczm5O9f5eZ3WpmvzKzRjN7zsymmNktZrY7e5G1hT0O+e7sBfp2m9l/dr3omJktzs4yscfMfm9m7+xR5z9kZxpo6it8zOxEM1uefR3LzezEjjrJTHvy5Wydvbr7zOzMbF0NZlZvZlcOoq5r+npNZjbBzB7NPm+Xmf2Pmemzp4TpH19kv3PJXAhrNvBO4KJBPverwARgH5mpR17OPr4f6DlX3qeA04AjgCOzzyUbUHcClwLjgR8CD5tZZZfnLiFzTaGx7t7edadmdgjwS+Bfs8//HvBLMxvv7hcBPwe+7e6j3f3JPl7HHcCl7l4LLACeHkRdfb4m4AoyE5JOJDOt/rUM0yzHUpgUPCL7/au7x919F/AImbnLcvWQu7/k7i3AQ0CLu//E3VPAUjLXQurq++6+KXusb5IJE8icg/mhu7/g7il3/zGZIHtvjzo3uXtzH3V8GFjv7j9193Z3vxtYC5yV4+toA+ab2Rh3391xIcEc6+rvNbUBU4HD3L3N3f9HXX2lTcEjst/WLvf3AqMH8dy3u9xv7uNxz31t6nL/TTLXgIHMOZgrst1Se8xsDzCzy/qez+1pWnZ/Xb1J7lee/RhwJvCmmT1jZu87yLq6vqabgQ3AE2a20cxK8po/sp+CR+TAmshcChkAM5syDPuc2eX+oey/zPIm4JvuPrbLT0225dJhoNZCnExIdHUoUJ9LUe6+3N3PBiYBy4B7B1FXn6/J3Rvc/Qp3Pxz4CPB/zWxRLvVIcVLwiBzYH4FjzOzY7Anz/zcM+/wbM5uRPSfzFTLdcQA/Aj5vZu+xjFFm9mEzq81xv48BR5rZJ82szMzOA+YDjx7oiWZWYWafMrO67MXQkuy/RHgudfX5mrKDEuaYmQEJIIUuPV7SFDwiB+DurwL/CDwJrAd+N/AzcvIL4AlgI/AacEP2WC8CnwO+D+wm00V10SBq3QksJnNCfyfwZWCxu+/IcRcXAm+YWRL4PJkBA7nW1edrAuaSee8ayQy6uNXd/zvX1yTFR9fjEZEhs8zlxP+6n5FyIt2oxSMiIoFS8IiISKDU1SYiIoFSi0dERAKl4BERkUApeEREJFAKHhERCZSCR0REAvW/Onds7EFhvXYAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Import the required packages\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "\n", - "def get_fid(n_steps):\n", - " t = 1\n", - " cir = UAnsatz(2)\n", - " construct_trotter_circuit(cir, h_2, tau=t/n_steps, steps=n_steps)\n", - " return gate_fidelity(cir.U.numpy(), linalg.expm(-1 * 1j * h_2.construct_h_matrix()))\n", - "plt.axhline(1, ls='--', color='black')\n", - "plt.semilogy(np.arange(1, 11), [get_fid(r) for r in np.arange(1, 11)], 'o-')\n", - "plt.xlabel('number of steps', fontsize=12)\n", - "plt.ylabel('fidelity', fontsize=12)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "a6b86ebb", - "metadata": {}, - "source": [ - "In addition, we can reduce the simulation error by changing the order of the product formula. Currently, the `construct_trotter_circuit()` supports the Suzuki product formula of any order using the argument `order`. Let us calculate the errors of the first and second-order time-evolving circuits separately, observe their variation with $\\tau$. Then compare them with the theoretical upper bounds calculated above:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "id": "23fd4bee", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Calculate the L1 spectral distance between the two unitary matrices, i.e. the error defined in (5)\n", - "def calculate_error(U1, U2):\n", - " return np.abs(linalg.eig(U1 - U2)[0]).max()\n", - "\n", - "# Encapsulates the function that calculates the error, \n", - "# with the free parameters being the length of each time block tau and the order of the product formula\n", - "def calculate_total_error(tau, order=1):\n", - " # An additional global phase needs to be subtracted from the error calculation because of the multiple Pauli rotating gates in the circuit\n", - " # This global phase does not have any observable effect on the actual quantum state, but only needs to be subtracted when calculating the theoretical error\n", - " h_2 = Hamiltonian([[1, 'Z0, Z1'], [1, 'X0'], [1, 'X1']])\n", - " cir = UAnsatz(2)\n", - " # A total time of 1, so steps = int(1/tau), the input tau needs to be divisible by 1\n", - " construct_trotter_circuit(cir, h_2, tau=tau, steps=int(1/tau), order=order)\n", - " cir_U = cir.U.numpy()\n", - " U_evolve = np.exp(1j) * linalg.expm(-1 * 1j * h_2.construct_h_matrix()) # Theoretical time evolution operator plus a global phase\n", - " return calculate_error(cir_U, U_evolve)\n", - "\n", - "# Different parameters tau, they need to be divisible by 1\n", - "taus = np.array([0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1])\n", - "errors = []\n", - "\n", - "# Record the total error corresponding to different tau\n", - "for tau in taus:\n", - " errors.append(calculate_total_error(tau))\n", - "\n", - "# print the graph\n", - "plt.loglog(taus, errors, 'o-', label='error')\n", - "plt.loglog(taus, (3 * taus**2 * (1/taus) * np.exp(3 * taus)), label='bound') # The first-order error upper bound calculated according to (10)\n", - "plt.legend()\n", - "plt.xlabel(r'$\\tau$', fontsize=12)\n", - "plt.ylabel(r'$\\Vert U_{\\rm cir} - \\exp(-iHt) \\Vert$', fontsize=12)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "9c30f384", - "metadata": {}, - "source": [ - "Next, we set `order` to 2 and calculate the error of the second-order product formula:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "f9fd7378", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "taus = np.array([0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1])\n", - "errors = []\n", - "\n", - "for tau in taus:\n", - " errors.append(calculate_total_error(tau, order=2)) # Specify the order of the Suzuki decomposition \n", - "\n", - "plt.loglog(taus, errors, 'o-', label='error')\n", - "plt.loglog(taus, (2 * taus * 3 )**3 / 3 * (1/taus) * np.exp(3 * taus), '-', label='bound') # The upper bound of the second-order error calculated according to (12)\n", - "plt.legend()\n", - "plt.xlabel(r'$\\tau$', fontsize=12)\n", - "plt.ylabel(r'$\\Vert U_{\\rm cir} - \\exp(-iHt) \\Vert$', fontsize=12)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "f7fff06b", - "metadata": {}, - "source": [ - "As expected, the actual calculated simulation errors are all smaller than their theoretical upper bounds.\n", - "\n", - "## Conclusion\n", - "\n", - "This tutorial introduces how to construct a time-evolving circuit with Paddle Quantum and the theoretical basis behind it, i.e.the Suzuki product formula. Users can construct arbitrary order product formula circuits with custom Hamiltonian to simulate the time evolution of different physical systems.\n", - "\n", - "Quantum simulation is a vast subject and it covers a wide range of applications: the study of many-body localization, time crystals, high-temperature superconductivity, and topological order in condensed matter physics; molecular dynamics simulations and reaction simulations in quantum chemistry; field theory simulations in high-energy physics; even related applications in nuclear physics and cosmology. The Suzuki product formula and digital quantum simulations based on general-purpose quantum computers presented in this tutorial are only part of the quantum simulations. The quantum simulator not based on general-purpose quantum computers, such as analogue quantum simulations on cold atom, superconductor, ion trap and photon platforms also constitute very important topics. For readers who are interested on its applications and general background, we recommend this review [8]. \n", - "\n", - "In the subsequent tutorial [Simulating spin dynamics in one-dimensional Heisenberg chains](./SimulateHeisenberg_EN.ipynb), using the spin model in condensed matter physics as an example, we further show how to perform dynamics simulations of quantum many-body models. In the meantime, we also demonstrate how to design a customized time evolving circuit not based on the Suzuki decomposition.\n" - ] - }, - { - "cell_type": "markdown", - "id": "0705577b", - "metadata": {}, - "source": [ - "---\n", - "\n", - "## References\n", - "\n", - "[1] Feynman, R. P. \"Simulating physics with computers.\" International Journal of Theoretical Physics 21.6 (1982).\n", - " \n", - "[2] Lloyd, Seth. \"Universal quantum simulators.\" [Science (1996): 1073-1078](https://www.jstor.org/stable/2899535).\n", - "\n", - "[3] Childs, Andrew M., et al. \"Toward the first quantum simulation with quantum speedup.\" [Proceedings of the National Academy of Sciences 115.38 (2018): 9456-9461](https://www.pnas.org/content/115/38/9456.short).\n", - "\n", - "[4] Nielsen, Michael A., and Isaac Chuang. \"Quantum computation and quantum information.\" (2002): 558-559.\n", - "\n", - "[5] Tran, Minh C., et al. \"Destructive error interference in product-formula lattice simulation.\" [Physical Review Letters 124.22 (2020): 220502](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.124.220502).\n", - "\n", - "[6] Childs, Andrew M., and Yuan Su. \"Nearly optimal lattice simulation by product formulas.\" [Physical Review Letters 123.5 (2019): 050503](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.123.050503).\n", - "\n", - "[7] Campbell, Earl. \"Random compiler for fast Hamiltonian simulation.\" [Physical Review Letters 123.7 (2019): 070503](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.123.070503).\n", - "\n", - "[8] Georgescu, Iulia M., Sahel Ashhab, and Franco Nori. \"Quantum simulation.\" [Reviews of Modern Physics 86.1 (2014): 153](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.86.153)." - ] - } - ], - "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" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorial/quantum_simulation/SimulateHeisenberg_CN.ipynb b/tutorial/quantum_simulation/SimulateHeisenberg_CN.ipynb deleted file mode 100644 index 4220034..0000000 --- a/tutorial/quantum_simulation/SimulateHeisenberg_CN.ipynb +++ /dev/null @@ -1,606 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "9d3716bb", - "metadata": {}, - "source": [ - "# 模拟一维海森堡链的自旋动力学\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "id": "c0832e9f", - "metadata": {}, - "source": [ - "## 概述\n", - "\n", - "模拟一个量子系统的性质，是量子计算机的重要应用之一。一般来说，分析一个量子系统的性质需要先写出其哈密顿量 $H$，而对于不同尺度下的物理系统而言，这个哈密顿量往往具有不同的形式。以量子化学为例，一个分子的性质主要由电子-电子之间的库伦相互作用而决定，因此其哈密顿量中的每一项都是由作用在电子波函数上的费米子算符写成的。而量子计算机的基本组成单元量子比特（qubit）以及常用的泡利算符，对应着物理上的自旋和自旋算符。因此，若想在量子计算机上对分子性质进行模拟，则往往需要进行从费米子算符到泡利算符的转换，例如 Jordan-Wigner 变换、Bravyi-Kitaev 变换等等。这也就使得量子计算机需要消耗更多的资源来进行分子哈密顿量的模拟。因此，对于近期的量子设备而言，最有可能率先实现的便是对量子自旋系统的量子模拟——因为这些系统的哈密顿量可以直接写成泡利算符的形式。\n", - "\n", - "在本教程中，我们选取了一个比较经典的量子自旋模型——海森堡模型，并将展示如何利用 Paddle Quantum 来进行一维海森堡自旋链的时间演化模拟。我们主要会使用 `construct_trotter_circuit()` 函数来搭建基于 product formula 的模拟时间演化电路，在先前的教程 [利用 Product Formula 模拟时间演化](./HamiltonianSimulation_CN.ipynb) 中有对该方法较为详细的理论介绍，在本教程中也会有较为简略的回顾。本教程将主要着眼于实际的应用，可以分为两个部分：\n", - "- 海森堡模型的物理背景以及利用 Paddle Quantum 对其时间演化进行模拟 \n", - "- 基于随机置换来搭建自定义时间演化电路" - ] - }, - { - "cell_type": "markdown", - "id": "988b3a47", - "metadata": {}, - "source": [ - "---\n", - "在进一步介绍本教程中涉及的物理背景之前，我们先来回顾一下利用量子电路来模拟时间演化的基本思想，对这部分内容已经比较熟悉的读者可以直接跳至 **海森堡自旋链与其动力学模拟** 继续阅读。\n", - "\n", - "### 利用 Suzuki product formula 模拟时间演化\n", - "\n", - "让我们先回顾一下使用 Suzuki product formula 来模拟时间演化的基本思想：对于一个被不含时的哈密顿量 $H = \\sum_k^L h_k$ 描述的量子系统，其时间演化算符可以写为\n", - "\n", - "$$\n", - "U(t) = e^{-iHt},\n", - "\\tag{1}\n", - "$$\n", - "\n", - "该算符可以被进一步拆分为 $r$ 份，即\n", - "\n", - "$$\n", - "e^{-iHt} = \\left( e^{-iH \\tau} \\right)^r, ~\\tau=\\frac{t}{r}.\n", - "\\tag{2}\n", - "$$\n", - "\n", - "对于每一个 $e^{-iH \\tau}$ 算符而言，其 Suzuki 分解为\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "S_1(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\tau),\n", - "\\\\\n", - "S_2(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\frac{\\tau}{2})\\prod_{k=L}^0 \\exp ( -i h_k \\frac{\\tau}{2}),\n", - "\\\\\n", - "S_{2k+2}(\\tau) &= [S_{2k}(p_k\\tau)]^2S_{2k}\\left( (1-4p_k)\\tau\\right)[S_{2k}(p_k\\tau)]^2.\n", - "\\end{aligned}\n", - "\\tag{3}\n", - "$$\n", - "\n", - "回到完整的时间演化算符 $U(t)$，利用第 $k$ 阶的 Suzuki 分解，它可以被写为\n", - "\n", - "$$\n", - "U(t) = e^{-iHt} = \\left( S_{k}\\left(\\frac{t}{r}\\right) \\right)^r.\n", - "\\tag{4}\n", - "$$\n", - "\n", - "这种模拟时间演化的方法被称为 Suzuki product formula，它可以有效地模拟时间演化过程至任意精度 [1]。在另一份教程 [利用 Product Formula 模拟时间演化](./HamiltonianSimulation_CN.ipynb) 中，我们展示了其误差上界的计算过程，感兴趣的读者可以前往阅读。\n", - "\n", - "---" - ] - }, - { - "cell_type": "markdown", - "id": "ab3f7311", - "metadata": {}, - "source": [ - "## 海森堡模型与其动力学模拟\n", - "\n", - "海森堡（Heisenberg）模型，是量子磁性以及量子多体物理研究中十分重要的一个模型。它的哈密顿量为\n", - "\n", - "$$\n", - "H = \\sum_{\\langle i, j\\rangle} \n", - "\\left( J_x S^x_{i} S^x_{j} + J_y S^y_{i} S^y_{j} + J_z S^z_{i} S^z_{j} \\right)\n", - "+\n", - "\\sum_{i} h_z S^z_i, \n", - "\\tag{5}\n", - "$$\n", - "\n", - "其中 $\\langle i, j\\rangle$ 取决于具体的格点几何结构，$J_x, J_y, J_z$ 分别为 $xyz$ 三个方向上的自旋耦合强度，$h_z$ 是 $z$ 方向上的外加磁场。若取 $J_z = 0$，(5) 式也可以用来描述 XY 模型的哈密顿量；取 $J_x = J_y = 0$，(5) 式则可以用来描述伊辛模型（Ising model）的哈密顿量。注意在这里，我们使用了量子多体物理里面比较常用的多体自旋算符 $S^x_i, S^y_i, S^z_i$，它是一个作用在多体波函数上的算符。\n", - "对于自旋-1/2 系统而言，多体自旋算符可以被简单地写为泡利算符的张量积形式（省略一个 $\\hbar/2$ 的系数）\n", - "\n", - "$$\n", - "S^P_{i} = \\left ( \\otimes_{j=0}^{i-1} I \\right ) \\otimes \\sigma_{P} \\otimes \\left ( \\otimes_{j=i+1}^{L} I \\right ),\n", - "P \\in \\{ x, y, z \\},\n", - "\\tag{6}\n", - "$$\n", - "\n", - "其中 $\\sigma_{P}$ 是泡利算符，我们也经常用 $XYZ$ 算符来表示它们。需要说明的是，海森堡模型并不是一个假想模型：从描述电子在格点系统上运动的赫巴德模型（Hubbard model）出发，在一定的极限条件下，电子会被固定在格点上并形成半满填充。此时，描述电子的赫巴德模型就退化为了描述自旋的海森堡模型，而 (5) 式中的自旋-自旋相互作用则是电子-电子之间的相互作用在这个极限下的一种有效交换相互作用 [2]。尽管做了许多的近似，但是海森堡模型依然成功地预言了许多实际材料在低温下的性质 [3]。比如读者可能在高中课本上就学习过的 $\\rm Cu(NO_3)_2 \\cdot 2.5 H_2 O$ 二点五水合硝酸铜在 $\\sim 3K$ 的低温下的行为就可以被自旋-1/2 一维交错海森堡链所描述 [4]。\n", - "\n", - "取决于其具体的格点结构，海森堡模型上可以展示出丰富的量子现象。一维海森堡链可以被用来描述铁磁性与反铁磁性，对称性破缺以及无能隙激发。在二维阻挫格点系统上，海森堡模型可以被用来描述量子自旋液体态-这是一种包含了长程纠缠的新奇量子物态 [5]。若考虑一个外加的无序磁场时，海森堡模型还可以用来研究多体局域化现象（many-body localization, MBL），这是一种违反了热化假说的奇特现象，指的是一个量子多体系统经过了无穷长的时间演化后也不会热化，依然保留着其初态有关的信息 [6]。\n", - "\n", - "模拟海森堡模型的时间演化过程，也被称为动力学模拟，可以帮助人们探索量子系统非平衡态相关的性质，从而用来寻找新奇的量子物相：例如前文提到的多体局域相，又或者更加有趣的时间晶体相 [7]。除了理论，动力学模拟对于实际的物理实验也有着重要的意义。这是因为自旋关联函数（也通常被称为动力学结构因子）直接决定了散射实验中的截面，或者是核磁共振实验的结果 [3]，该函数则是由含时的自旋算符 $\\langle S(t) S(0) \\rangle$ 的积分决定的。因此，通过计算不同理论模型的动力学演化，人们可以进一步对真实材料中的物理模型进行分析。\n", - "\n", - "### 利用 Paddle Quantum 实现海森堡链的动力学模拟" - ] - }, - { - "cell_type": "markdown", - "id": "aea361f7", - "metadata": {}, - "source": [ - "下面，我们则会通过一个实际的例子：链长为 5 的含有无序外磁场的海森堡链，来展示如何在 Paddle Quantum 中搭建其时间演化电路。首先，我们引入相关的包。" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "5c873819", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import scipy\n", - "from scipy import linalg\n", - "import matplotlib.pyplot as plt\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import SpinOps, Hamiltonian, gate_fidelity\n", - "from paddle_quantum.trotter import construct_trotter_circuit, get_1d_heisenberg_hamiltonian" - ] - }, - { - "cell_type": "markdown", - "id": "6c81929b", - "metadata": {}, - "source": [ - "接下来，我们利用 `get_1d_heisenberg_hamiltonian()` 函数来得到一个一维海森堡链的哈密顿量： " - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "88fa56fe", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "系统的哈密顿量为：\n", - "1.0 X0, X1\n", - "1.0 Y0, Y1\n", - "2.0 Z0, Z1\n", - "1.0 X1, X2\n", - "1.0 Y1, Y2\n", - "2.0 Z1, Z2\n", - "1.0 X2, X3\n", - "1.0 Y2, Y3\n", - "2.0 Z2, Z3\n", - "1.0 X3, X4\n", - "1.0 Y3, Y4\n", - "2.0 Z3, Z4\n", - "-0.8540490813629811 Z0\n", - "-0.017499184685274338 Z1\n", - "0.08600328703303406 Z2\n", - "0.9440767245343289 Z3\n", - "-0.9640203537370211 Z4\n" - ] - } - ], - "source": [ - "h = get_1d_heisenberg_hamiltonian(length=5, j_x=1, j_y=1, j_z=2, h_z=2 * np.random.rand(5) - 1,\n", - "periodic_boundary_condition=False)\n", - "print('系统的哈密顿量为：')\n", - "print(h)" - ] - }, - { - "cell_type": "markdown", - "id": "0793414b", - "metadata": {}, - "source": [ - "得到了哈密顿量之后，可以进一步通过 `construct_trotter_circuit()` 来构建时间演化电路。此外，若直接写出演化算符的矩阵形式，也可以计算系统随时间演化的精确解。这里我们用到了量桨中的 `Hamiltonian.construct_h_matrix()` 方法，它可以计算给定哈密顿量在泡利 $Z$ 基底下的矩阵形式。通过比较 `cir.U`，即电路的酉矩阵形式，以及精确的演化算符，可以计算出该电路模拟时间演化的保真度。" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "5052fb32", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "电路的酉矩阵与正确的演化算符之间的保真度为：0.55\n" - ] - } - ], - "source": [ - "# 计算演化时长为 t 时的精确演化算符\n", - "def get_evolve_op(t): return scipy.linalg.expm(-1j * t * h.construct_h_matrix())\n", - "\n", - "# 设置演化时长以及模拟的步长\n", - "t = 3\n", - "r = 10\n", - "# 搭建模拟演化电路\n", - "cir_evolve = UAnsatz(5)\n", - "construct_trotter_circuit(cir_evolve, h, tau=t/r, steps=r, order=2)\n", - "# 得到电路的酉矩阵并计算与精确演化算符之间的保真度\n", - "U_cir = cir_evolve.U.numpy()\n", - "print('电路的酉矩阵与正确的演化算符之间的保真度为：%.2f' % gate_fidelity(get_evolve_op(t), U_cir))" - ] - }, - { - "cell_type": "markdown", - "id": "ce487d74", - "metadata": {}, - "source": [ - "#### 根据对易关系重新排列哈密顿量\n", - "\n", - "对于 product formula 而言，可以通过重新排列哈密顿量中的每一项减小其模拟误差。因为 product formula 的误差是由哈密顿量中不对易项所产生的，所以一种自然的重新排列思路就是将哈密顿量中相互对易的项放在一起。比如，我们可以将哈密顿量分解为四个部分\n", - "\n", - "$$\n", - "H = H_x + H_y + H_z + H_{\\rm other},\n", - "\\tag{7}\n", - "$$\n", - "\n", - "其中 $H_x, H_y, H_z$ 分别为仅由泡利 $X, Y, Z$ 算符构成的项，$H_{\\rm other}$ 为剩余项。对于 (5) 中的海森堡链的哈密顿量而言，所有的项都可以被分类为 $H_x, H_y, H_z$ 三项。不仅如此，对于一维最近邻相互作用系统而言，它也可以被分为奇偶两个部分\n", - "\n", - "$$\n", - "H = H_{\\rm even} + H_{\\rm odd},\n", - "\\tag{8}\n", - "$$\n", - "\n", - "其中 $H_{\\rm even}$ 为 $(0, 1), (2, 3), ...$ 格点上的相互作用项，$H_{\\rm odd}$ 为 $(1, 2), (3, 4), ...$ 格点上的相互作用项。 不过需要指出的是，这两种排列方式都不能减少其理论上的误差上界。并且从经验的角度来说，它们也不是总能减小实际的模拟误差。实际上，确定对于某一类哈密顿量而言模拟误差的排列方式，是一个十分值得探索的问题。对于量桨中的 `construct_h_matrix()` 函数而言，用户可以通过指定 `grouping='xyz'` 或者 `grouping='even_odd'` 来实现上文中提到的两种重新排列方式，此外，通过传入参数 `permutation` 也可以指定自定义排列顺序。关于后一点，本教程将在下文章节 **设计基于随机置换的自定义时间演化电路** 中进一步介绍。下面，先让我们来看一下关于 `grouping` 参数的使用方法：" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "b2eaca4c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "原始保真度为： 0.5515968012823682\n", - "XYZ 排列后的模拟保真度为： 0.703033891885116\n", - "奇偶排列后的模拟保真度为： 0.744121841784116\n" - ] - } - ], - "source": [ - "# 保持同样的时间演化参数，但是在通过 'grouping=\"xyz\"' 和 'groping=\"even_odd\"' 指定哈密顿量排列\n", - "cir_evolve_xyz = UAnsatz(5)\n", - "cir_evolve_even_odd = UAnsatz(5)\n", - "construct_trotter_circuit(cir_evolve_xyz, h, tau=t/r, steps=r, order=2, grouping='xyz')\n", - "construct_trotter_circuit(cir_evolve_even_odd, h, tau=t/r, steps=r, order=2, grouping='even_odd')\n", - "U_cir_xyz = cir_evolve_xyz.U.numpy()\n", - "U_cir_even_odd = cir_evolve_even_odd.U.numpy()\n", - "print('原始保真度为：', gate_fidelity(get_evolve_op(t), U_cir))\n", - "print('XYZ 排列后的模拟保真度为：', gate_fidelity(get_evolve_op(t), U_cir_xyz))\n", - "print('奇偶排列后的模拟保真度为：', gate_fidelity(get_evolve_op(t), U_cir_even_odd))" - ] - }, - { - "cell_type": "markdown", - "id": "f18e3f16", - "metadata": {}, - "source": [ - "#### 初态制备以及对演化后的末态进行观测\n", - "\n", - "下面，我们来制备系统的初态。一般来说，在研究量子多体系统的动力学行为时，一种做法是将系统的初态制备为各种不同的直积态。在量桨中，我们默认的初态为 $\\vert 0...0 \\rangle$，这里我们可以通过 $X$ 门来将奇数格点上的自旋进行翻转，这样系统的初态就制备为了 $\\vert 01010 \\rangle$ 态，用自旋来标记的话则是 $\\vert \\downarrow \\uparrow \\downarrow \\uparrow \\downarrow \\rangle$ 态。" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "e0ff6736", - "metadata": {}, - "outputs": [], - "source": [ - "# 创建一个用于制备初态的电路，并通过演化得到初态\n", - "cir = UAnsatz(5)\n", - "cir.x(1)\n", - "cir.x(3)\n", - "init_state = cir.run_state_vector()" - ] - }, - { - "cell_type": "markdown", - "id": "ffa62418", - "metadata": {}, - "source": [ - "通过将系统的初态 `init_state` 传入方法 `UAnsatz.run_state_vector(init_state)`，我们可以利用刚刚定义的量子线路来演化该初态，并得到演化后的末态。对于演化后的末态，可以使用 `UAnsatz.expecval()` 方法来测量其上的可观测量。这里我们简单地考虑对每个格点上的自旋状态进行观测，即测量可观测量 $\\langle S^z_i \\rangle$，其对应的 Pauli string 为 `[[1, 'Zi']]`（i 为格点下标）。" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "88d5e1b9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "演化后格点 0 上自旋的 z 方向期望为： 0.9206501927076486\n" - ] - } - ], - "source": [ - "cir_evolve_even_odd.run_state_vector(init_state)\n", - "print('演化后格点 0 上自旋的 z 方向期望为：', cir_evolve_even_odd.expecval([[1, 'Z0']]).numpy()[0])" - ] - }, - { - "cell_type": "markdown", - "id": "e70d9fba", - "metadata": {}, - "source": [ - "类似地，通过调整模拟演化的时间长度以及测量的量子比特编号，我们可以绘制出系统中的每个自旋的状态随着时间的完整变化过程。注意这里为了计算理论上的精确解，我们使用了 `SpinOps` 类来构建 $S_i^z$ 算符的矩阵形式，并通过 $\\langle \\psi(t) \\vert S_i^z \\vert \\psi(t) \\rangle$ 来计算其期望值。" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "6c4c03ea", - "metadata": {}, - "outputs": [], - "source": [ - "def get_evolution_z_obs(h, t_total, order=None, n_steps=None, exact=None):\n", - " \"\"\"\n", - " 该函数可以计算演化过程 t 中系统每个格点上的 Sz 可观测量的变化过程\n", - " 通过 order, n_steps 控制 trotter-suzuki 分解的步长和阶数\n", - " 通过设置 exact=True 可以计算对应的精确解\n", - " \"\"\"\n", - " z_obs_total = []\n", - " for t in np.linspace(0., t_total, t_total * 3 + 1):\n", - " z_obs = []\n", - " # 通过演化算符或者运行电路得到末态\n", - " if exact:\n", - " spin_operators = SpinOps(h.n_qubits)\n", - " fin_state = get_evolve_op(t).dot(init_state)\n", - " else:\n", - " cir_evolve = UAnsatz(5)\n", - " construct_trotter_circuit(cir_evolve, h, tau=t/n_steps, steps=n_steps, order=order, grouping='even_odd')\n", - " fin_state = cir_evolve.run_state_vector(init_state)\n", - " # 对每个格点上的可观测量进行观测\n", - " for site in range(h.n_qubits):\n", - " if exact:\n", - " z_obs.append(fin_state.conj().T.dot(spin_operators.sigz_p[site]).dot(fin_state))\n", - " else:\n", - " z_obs.append(cir_evolve.expecval([[1, 'Z' + str(site)]]).numpy()[0])\n", - " z_obs_total.append(z_obs)\n", - " return np.array(z_obs_total).real \n", - "\n", - "def plot_comparison(**z_obs_to_plot):\n", - " \"\"\" \n", - " 绘制不同的演化结果进行对比，默认每个传入的参数都是 get_evolution_z_obs() 函数的输出并具有同样的演化时间\n", - " \"\"\"\n", - " fig, axes = plt.subplots(1, len(z_obs_to_plot), figsize = [len(z_obs_to_plot) * 3, 5.5])\n", - " \n", - " ax_idx = 0\n", - " for label in z_obs_to_plot.keys():\n", - " im = axes[ax_idx].imshow(z_obs_to_plot[label], cmap='coolwarm_r', interpolation='kaiser', origin='lower')\n", - " axes[ax_idx].set_title(label, fontsize=15)\n", - " ax_idx += 1\n", - "\n", - " for ax in axes:\n", - " ax.set_xlabel('site', fontsize=15)\n", - " ax.set_yticks(np.arange(0, z_obs_total_exact.shape[0], 3))\n", - " ax.set_yticklabels(np.arange(0, z_obs_total_exact.shape[0]/3, 1))\n", - " ax.set_xticks(np.arange(z_obs_total_exact.shape[1]))\n", - " ax.set_xticklabels(np.arange(z_obs_total_exact.shape[1]))\n", - "\n", - " axes[0].set_ylabel('t', fontsize=15)\n", - " cax = fig.add_axes([0.92, 0.125, 0.02, 0.755])\n", - " \n", - " \n", - " fig.colorbar(im, cax)\n", - " cax.set_ylabel(r'$\\langle S^z_i (t) \\rangle$', fontsize=15)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "3735e79a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# 分别计算时长为 3 时，通过步长为 25、5 的电路得到的演化过程，以及精确解\n", - "z_obs_total_exact = get_evolution_z_obs(h, t_total=3, exact=True)\n", - "z_obs_total_cir = get_evolution_z_obs(h, order=1, n_steps=25, t_total=3)\n", - "z_obs_total_cir_short = get_evolution_z_obs(h, order=1, n_steps=5, t_total=3)\n", - "\n", - "plot_comparison(\n", - " Exact=z_obs_total_exact,\n", - " L25_Circuit=z_obs_total_cir,\n", - " L5_Circuit=z_obs_total_cir_short)" - ] - }, - { - "cell_type": "markdown", - "id": "707ecfdf", - "metadata": {}, - "source": [ - "我们观察到当线路的深度为 25 时（注意这里的深度指的是时间块的数量而不是量子门的层数），量子电路可以较好的模拟系统在完整演化时间内的自旋动力学。若使用较浅的量子线路，则只能正确模拟系统的行为至一定的时间。\n", - "\n", - "**思考：** 读者是否可以尝试来测量自旋空间关联函数 $\\langle S_i^z S_j^{z} \\rangle$ 并观察其随时间的变化？" - ] - }, - { - "cell_type": "markdown", - "id": "af97d494", - "metadata": {}, - "source": [ - "## 设计基于随机置换的自定义时间演化电路\n", - "\n", - "### 随机置换\n", - "\n", - "尽管从物理的角度上看来，将哈密顿量中的对易项重新排列在一起来减小模拟误差是符合直觉的，但是许多证据都表明，固定一种哈密顿量排列的演化策略将会导致模拟误差不断地累积，反而不如将哈密顿量的排列顺序在每个“时间块”中都进行随机置换来得有效 [8, 9]。人们发现，通过不断地将哈密顿量的排列顺序进行随机置换，其演化过程中造成的随机误差比起固定排列时的累积误差来说更加“无害” [8]。无论是在理论上的误差上界与经验性的实验都表明，这种随机排列的演化策略比起固定排列的 Suzuki product formula 具有更小的误差 [9]。" - ] - }, - { - "cell_type": "markdown", - "id": "63f289c5", - "metadata": {}, - "source": [ - "### 搭建自定义时间演化电路\n", - "\n", - "量桨中的 `construct_trotter_circuit()` 函数会默认根据 Suzuki product formula 以及输入哈密顿量的顺序来添加时间演化电路。同时，用户可以通过设置 `method='custom'` 并同时向参数 `permutation` 以及 `coefficient` 传入数组的方式来自定义时间演化策略。\n", - "\n", - "**提醒：** 用户在使用 `coefficient`、`tau` 以及 `steps` 参数时需要小心它们之间的关系。一般情况下，传入 `coefficient` 的数组应当是归一化的，即它本身描述的是 $t=1$ 的时间演化过程。在这个基础上，通过设置更多的 `steps`，该函数会将传入的自定义参数所描述的时间演化策略作为一个基本的“时间块”并进行重复，其中每个时间块的演化时长由参数 `tau` 决定。举个例子，若设置 `permutation=np.arange(h.n_qubits)` 且 `coefficient=np.ones(h.n_qubits)`，此时通过 `tau` 与 `steps` 来定义的时间演化电路与一阶 product formula 电路是完全一致的。" - ] - }, - { - "cell_type": "markdown", - "id": "e72345ac", - "metadata": {}, - "source": [ - "让我们进一步实际展示一下该自定义功能：考虑和之前相同的哈密顿量，现在我们通过设计一个时间演化电路来测试上文提到的随机置换的结论，即我们希望搭建一个类似于一阶 product formula 的电路，只不过在每个”时间块“内的哈密顿量排列是完全随机且独立的。通过传入一个形状为 `(n_steps, h.n_terms)` 且其每一行都是一个随机置换 $P(N)$ 的数组至参数 `permutation`，就可以实现这一想法：" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "1740ec7f", - "metadata": {}, - "outputs": [], - "source": [ - "# 自定义 permutation 参数的一个例子\n", - "permutation = np.vstack([np.random.permutation(h.n_terms) for i in range(100)])" - ] - }, - { - "cell_type": "markdown", - "id": "23a1eb6d", - "metadata": {}, - "source": [ - "接下来，为了验证，可以分别计算该随机电路以及一阶 product formula 在不同电路深度下与精确解之间的保真度来进行比较：" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "73084cfc", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def compare(n_steps):\n", - " \"\"\"\n", - " 比较一阶 product formula 以及随机置换方法在同样的步长的情况下对于固定演化时长 t=2 时的保真度\n", - " 输入参数控制步长，输出分别为一阶 product formula 以及随机置换的保真度\n", - " \"\"\"\n", - " t = 2\n", - " cir_evolve = UAnsatz(5)\n", - " construct_trotter_circuit(cir_evolve, h, tau=t/n_steps, steps=n_steps, order=1)\n", - " U_cir = cir_evolve.U.numpy()\n", - " fid_suzuki = gate_fidelity(get_evolve_op(t), U_cir)\n", - " cir_permute = UAnsatz(5)\n", - " permutation = np.vstack([np.random.permutation(h.n_terms) for i in range(n_steps)])\n", - " # 当不指定 coefficient 参数时，会默认根据 permutation 的形状设置一个归一化且均匀的 coefficient\n", - " construct_trotter_circuit(cir_permute, h, tau=t, steps=1, method='custom', permutation=permutation)\n", - " U_cir = cir_permute.U.numpy()\n", - " fid_random = gate_fidelity(get_evolve_op(t), U_cir)\n", - " return fid_suzuki, fid_random\n", - "\n", - "# 比较在不同步长时的两种方案的保真度\n", - "# 出于运行时间的考虑，只进行一次试验，感兴趣的读者可以进行多次重复实验并计算其 error bar\n", - "n_range = [100, 200, 500, 1000]\n", - "result = [compare(n) for n in n_range]\n", - "\n", - "result = 1 - np.array(result)\n", - "plt.loglog(n_range, result[:, 0], 'o-', label='1st order PF')\n", - "plt.loglog(n_range, result[:, 1], 'o-', label='Random')\n", - "plt.xlabel(r'Trotter number $r$', fontsize=12)\n", - "plt.ylabel(r'Error: $1 - {\\rm Fid}$', fontsize=12)\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "85f72361", - "metadata": {}, - "source": [ - "图中，“1st order PF” 指按照固定顺序搭建的一阶 product formula 电路。与预期一样，随机置换确实可以在相同的电路深度下达到比一阶 product formula 更好的模拟效果。\n", - "\n", - "**思考：** 在 [9] 中，作者指出这种随机的策略在没有利用任何与哈密顿量有关的信息的前提下就取得了更小的误差，那么有理由相信存在一种方法可以在利用哈密顿量信息的同时进一步减小该误差。这对于人们设计更好的模拟时间演化策略带来了启发。" - ] - }, - { - "cell_type": "markdown", - "id": "4f193c11", - "metadata": {}, - "source": [ - "## 小结\n", - "\n", - "对于量子多体系统的动力学性质进行研究，是理解新奇量子物态的重要手段。由于其高度纠缠的量子力学本质，无论是在理论上还是在实验上的研究都是十分困难的。时至今日，人们对于不同几何结构，不同相互作用下的二维，乃至包含了无序性的一维系统上的物理现象都没能完全理解。另一方面，通用量子计算机以及量子模拟器的快速发展给这一问题的解决带来了新的希望。以通用量子计算机为例，通过搭建量子电路，其优势在于可以模拟各种复杂情况下的系统演化过程，例如，模拟其哈密顿量随时间周期性变化的系统从而寻找“时间晶体”的存在。随着量子比特数目和控制能力的进一步提高，通用量子计算机有望在近未来内在模拟量子系统时间演化这一任务上超越经典计算机，这其中，最有希望最先取得进展的就是量子自旋系统的模拟。\n", - "\n", - "本教程主要介绍了如何在量桨中模拟一个真实量子自旋模型的时间演化过程，并且进一步探讨了基于量桨来设计新的时间演化策略的可能性。通过 `construct_trotter_circuit()` 函数以及 `Hamiltonian` 和 `SpinOps` 类中提供的各种方法，用户现在可以简单地设计并测试不同搭建时间演化的策略。我们也鼓励读者在更多的物理系统上尝试不同的时间演化策略，并一起探索更加高效的量子模拟电路。" - ] - }, - { - "cell_type": "markdown", - "id": "ff5b39fa", - "metadata": {}, - "source": [ - "---\n", - "\n", - "## 参考文献\n", - "\n", - "[1] Childs, Andrew M., et al. \"Toward the first quantum simulation with quantum speedup.\" [Proceedings of the National Academy of Sciences 115.38 (2018): 9456-9461](https://www.pnas.org/content/115/38/9456.short).\n", - "\n", - "[2] Eckle, Hans-Peter. Models of Quantum Matter: A First Course on Integrability and the Bethe Ansatz. [Oxford University Press, 2019](https://oxford.universitypressscholarship.com/view/10.1093/oso/9780199678839.001.0001/oso-9780199678839).\n", - "\n", - "[3] Mikeska, Hans-Jürgen, and Alexei K. Kolezhuk. \"One-dimensional magnetism.\" Quantum magnetism. Springer, Berlin, Heidelberg, 2004. 1-83.\n", - "\n", - "[4] Berger, L., S. A. Friedberg, and J. T. Schriempf. \"Magnetic Susceptibility of $\\rm Cu(NO_3)_2·2.5 H_2O$ at Low Temperature.\" [Physical Review 132.3 (1963): 1057](https://journals.aps.org/pr/abstract/10.1103/PhysRev.132.1057).\n", - "\n", - "[5] Broholm, C., et al. \"Quantum spin liquids.\" [Science 367.6475 (2020)](https://science.sciencemag.org/content/367/6475/eaay0668).\n", - "\n", - "[6] Abanin, Dmitry A., et al. \"Colloquium: Many-body localization, thermalization, and entanglement.\" [Reviews of Modern Physics 91.2 (2019): 021001](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.91.021001).\n", - "\n", - "[7] Medenjak, Marko, Berislav Buča, and Dieter Jaksch. \"Isolated Heisenberg magnet as a quantum time crystal.\" [Physical Review B 102.4 (2020): 041117](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.102.041117).\n", - "\n", - "[8] Wallman, Joel J., and Joseph Emerson. \"Noise tailoring for scalable quantum computation via randomized compiling.\" [Physical Review A 94.5 (2016): 052325](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.94.052325).\n", - "\n", - "[9] Childs, Andrew M., Aaron Ostrander, and Yuan Su. \"Faster quantum simulation by randomization.\" [Quantum 3 (2019): 182](https://quantum-journal.org/papers/q-2019-09-02-182/)." - ] - } - ], - "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.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorial/quantum_simulation/SimulateHeisenberg_EN.ipynb b/tutorial/quantum_simulation/SimulateHeisenberg_EN.ipynb deleted file mode 100644 index 5ea889e..0000000 --- a/tutorial/quantum_simulation/SimulateHeisenberg_EN.ipynb +++ /dev/null @@ -1,620 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "9d3716bb", - "metadata": {}, - "source": [ - "# Simulate the Spin Dynamics on a Heisenberg Chain\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "id": "c0832e9f", - "metadata": {}, - "source": [ - "## Introduction\n", - "\n", - "The simulation of quantum systems is one of the many important applications of quantum computers. In general, the system's properties are characterized by its Hamiltonian operator $H$. For physical systems at different scales, their Hamiltonian takes different forms. For example in quantum chemistry, where we are often interested in the properties of molecules, which are determined mostly by electron-electron Coulomb interactions. As a consequence, a molecular Hamiltonian is usually written in the form of fermionic operators which act on the electron's wave function. On the other hand, the basic computational unit of a quantum computer - qubit, and its corresponding operations, correspond to spin and spin operators in physics. So in order to simulate a molecular Hamiltonian on a quantum computer, one needs to first map fermionic operators into spin operators with mappings such as Jordan-Wigner or Bravyi-Kitaev transformation, etc. Those transformations often create additional overhead for quantum simulation algorithms, make them more demanding in terms of a quantum computer's number of qubits, connectivity, and error control. It was commonly believed that one of the most near-term applications for quantum computers it the simulation of quantum spin models, whose Hamiltonian are natively composed of Pauli operators. \n", - "\n", - "This tutorial will demonstrate how to simulate the time evolution process of a one-dimensional Heisenberg chain, one of the most commonly studied quantum spin models. This tutorial is based on the `construct_trotter_circuit()`, which can construct the Trotter-Suzuki or any custom trotterization circuit to simulate the time-evolving operator. We have already covered some of the basic usage as well as the theoretical background in another tutorial [Hamiltonian Simulation with Product Formula](./HamiltonianSimulation_EN.ipynb). A brief introduction of the Suzuki product formula is provided below for readers who are not familiar with it. In the remainder of this tutorial, we will be focusing on two parts:\n", - "- Simulating the spin dynamics on a Heisenberg chain\n", - "- Using randomized permutation to build a custom trotter circuit" - ] - }, - { - "cell_type": "markdown", - "id": "988b3a47", - "metadata": {}, - "source": [ - "---\n", - "Before discussing the physical background of the Heisenberg model, let's go over the basic concepts of time evolution simulation with a quantum circuit. Readers already familiar with this or uninterested in such details could choose to skip to the section of **Heisenberg model and its dynamical simulation** to continue reading.\n", - "\n", - "### Simulate the time evolution with Suzuki product formula\n", - "\n", - "The core idea of the Suzuki product formula can be described as follows: First, for a time-independent Hamiltonian $H = \\sum_k^L h_k$, the system's time evolution operator is \n", - "\n", - "$$\n", - "U(t) = e^{-iHt}.\n", - "\\tag{1}\n", - "$$\n", - "\n", - "Further dividing it into $r$ pieces, we have\n", - "\n", - "$$\n", - "e^{-iHt} = \\left( e^{-iH \\tau} \\right)^r, ~\\tau=\\frac{t}{r}.\n", - "\\tag{2}\n", - "$$\n", - "\n", - "This strategy is sometimes referred to as \"Totterization\". \n", - "\n", - "And for each $e^{-iH \\tau}$ operator, its Suzuki decompositions are\n", - "\n", - "$$\n", - "\\begin{aligned}\n", - "S_1(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\tau),\n", - "\\\\\n", - "S_2(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\frac{\\tau}{2})\\prod_{k=L}^0 \\exp ( -i h_k \\frac{\\tau}{2}),\n", - "\\\\\n", - "S_{2k+2}(\\tau) &= [S_{2k}(p_k\\tau)]^2S_{2k}\\left( (1-4p_k)\\tau\\right)[S_{2k}(p_k\\tau)]^2.\n", - "\\end{aligned}\n", - "\\tag{3}\n", - "$$\n", - "\n", - "Back to the original time evolution operator $U(t)$, with the $k$-th order Suzuki decomposition, it can be reformulated as\n", - "\n", - "$$\n", - "U(t) = e^{-iHt} = \\left( S_{k}\\left(\\frac{t}{r}\\right) \\right)^r.\n", - "\\tag{4}\n", - "$$\n", - "\n", - "The above scheme is referred to as the Suzuki product formula or Trotter-Suzuki decomposition. It is proven that it could efficiently simulate any time evolution process of a system with a k-local Hamiltonian up to arbitrary precision [1]. In another tutorial [Hamiltonian Simulation with Product Formula](./HamiltonianSimulation_EN.ipynb), we have shown how to calculate its error upper bound.\n", - "\n", - "---" - ] - }, - { - "cell_type": "markdown", - "id": "ab3f7311", - "metadata": {}, - "source": [ - "## Heisenberg Model and Its Dynamic Simulation\n", - "\n", - "The Heisenberg model is arguably one of the most commonly used model in the research of quantum magnetism and quantum many-body physics. Its Hamiltonian can be expressed as \n", - "\n", - "$$\n", - "H = \\sum_{\\langle i, j\\rangle} \n", - "\\left( J_x S^x_{i} S^x_{j} + J_y S^y_{i} S^y_{j} + J_z S^z_{i} S^z_{j} \\right)\n", - "+\n", - "\\sum_{i} h_z S^z_i, \n", - "\\tag{5}\n", - "$$\n", - "\n", - "with $\\langle i, j\\rangle$ depends on the specific lattice structure, $J_x, J_y, J_z$ describe the spin coupling strength respectively in the $xyz$ directions and $h_z$ is the magnetic field applied along the $z$ direction. When taking $J_z = 0$, the Hamiltonian in (5) can be used to describe the XY model; or when taking $J_x = J_y = 0$, then (5) is reduced to the Hamiltonian of Ising model. Note that here we used a notation of many-body spin operators $S^x_i, S^y_i, S^z_i$ which act on each of the local spins, this is slightly different from our usual notations but are very common in the field of quantum many-body physics. For a spin-1/2 system, when neglecting a coefficient of $\\hbar/2$, the many-body spin operators are simple tensor products of Pauli operators, i.e.\n", - "\n", - "$$\n", - "S^P_{i} = \\left ( \\otimes_{j=0}^{i-1} I \\right ) \\otimes \\sigma_{P} \\otimes \\left ( \\otimes_{j=i+1}^{L} I \\right ),\n", - "P \\in \\{ x, y, z \\},\n", - "\\tag{6}\n", - "$$\n", - "\n", - "where the $\\sigma_{P}$ are Pauli operators, which can also be represented as $XYZ$. It is worth noting that while the Heisenberg model is an important theoretical model, but it also describes the physics in realistic materials (crystals). Starting from the Hubbard model, which describes the interactions and movement of electrons on a lattice, under certain conditions, the electrons are fixed to each site and form a half-filling case. In this case, the only left-over interaction is an effective spin-spin exchange interaction and the Hubbard model is reduced to the Heisenberg model [2]. While it seems that many approximations are made, the Heisenberg model has successfully described the properties of many crystal materials at low temperatures [3]. For example, many readers might be familiar with the copper nitrate crystal ($\\rm Cu(NO_3)_2 \\cdot 2.5 H_2 O$), and its behavior at $\\sim 3k$ can be described by an alternating spin-1/2 Heisenberg chain [4].\n", - "\n", - "Depending on the lattice structure, the Heisenberg model can host highly non-trivial quantum phenomena. As a one-dimensional chain, it demonstrates ferromagnetism and anti-ferromagnetism, symmetry breaking and gapless excitations [3]. On frustrated two-dimension lattices, some Heisenberg models constitute candidate models for quantum spin liquids, a long-range entangled quantum matter [5]. When under a disordered external magnet field, the Heisenberg model also can be used in the research of a heated topic, many-body localization, where the system violates the thermalization hypothesis and retains memories of its initial state after infinitely long time's evolution [6]. \n", - "\n", - "Simulating the time evolution of a Heisenberg model, i.e. the dynamical simulation, could help us to investigate the non-equilibrium properties of the system, and it might help us to locate novel quantum phases such as the many-body localized (MBL) phase introduced above or even more interestingly, time crystal phases [7]. Other than developing theories, the dynamic simulation plays a vital role for experimentalists, as the spin correlation function (also referred to as dynamical structure factors) is directly linked to the cross sections for scattering experiments or line shapes in nuclear magnetic resonance (NMR) experiments [3]. And this function, which we omit its exact form here, is a function of integration over $\\langle S(t) S(0) \\rangle$. So that in order to bridge the experiment and theory, one also need to compute the system's evolution in time.\n", - "\n", - "### Use Paddle Quantum to simulate and observe the time evolution process of a Heisenberg chain" - ] - }, - { - "cell_type": "markdown", - "id": "ca09d58d", - "metadata": {}, - "source": [ - "Now, we will take a one dimensional Heisenberg chain under disordered field of length 5 as an example, and demonstrate how the construct its time evolving circuit in Paddle Quantum. First we need to import relevant packages." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "id": "5c873819", - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import scipy\n", - "from scipy import linalg\n", - "import matplotlib.pyplot as plt\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import SpinOps, Hamiltonian, gate_fidelity\n", - "from paddle_quantum.trotter import construct_trotter_circuit, get_1d_heisenberg_hamiltonian" - ] - }, - { - "cell_type": "markdown", - "id": "d96d3bcb", - "metadata": {}, - "source": [ - "Then we use `get_1d_heisenberg_hamiltonian()` function to generate the Hamiltonian of a Heisenberg chain." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "id": "88fa56fe", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The Hamiltoninan is:\n", - "1.0 X0, X1\n", - "1.0 Y0, Y1\n", - "2.0 Z0, Z1\n", - "1.0 X1, X2\n", - "1.0 Y1, Y2\n", - "2.0 Z1, Z2\n", - "1.0 X2, X3\n", - "1.0 Y2, Y3\n", - "2.0 Z2, Z3\n", - "1.0 X3, X4\n", - "1.0 Y3, Y4\n", - "2.0 Z3, Z4\n", - "0.30554627625735065 Z0\n", - "0.6025258365109716 Z1\n", - "-0.1545550348192246 Z2\n", - "0.9823722719316286 Z3\n", - "-0.6157481417955128 Z4\n" - ] - } - ], - "source": [ - "h = get_1d_heisenberg_hamiltonian(length=5, j_x=1, j_y=1, j_z=2, h_z=2 * np.random.rand(5) - 1,\n", - " periodic_boundary_condition=False)\n", - "print('The Hamiltoninan is:')\n", - "print(h)" - ] - }, - { - "cell_type": "markdown", - "id": "0793414b", - "metadata": {}, - "source": [ - "After obtaining its Hamiltonian, we can then pass it to the `construct_trotter_circuit()` function to construct its time evolution circuit. Also, with `Hamiltonian.construct_h_matrix()` who returns the matrix form of a `Hamiltonian` object, we can calculate its exponential, i.e. the exact time-evolving operator. By taking the quantum circuit's unitary matrix `UAnsatz.U` and comparing it to the exact time-evolving operator by calculating their fidelity, we can evaluate how well the constructed circuit could describe the correct time evolution process." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "5052fb32", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The fidelity between the circuit's unitary and the exact evolution operator is : 0.58\n" - ] - } - ], - "source": [ - "# calculate the exact evolution operator of time t\n", - "def get_evolve_op(t): return scipy.linalg.expm(-1j * t * h.construct_h_matrix())\n", - "\n", - "# set the total evolution time and the number of trotter steps\n", - "t = 3\n", - "r = 10\n", - "# construct the evolution circuit\n", - "cir_evolve = UAnsatz(5)\n", - "construct_trotter_circuit(cir_evolve, h, tau=t/r, steps=r, order=2)\n", - "# get the circuit's unitary matrix and calculate its fidelity to the exact evolution operator\n", - "U_cir = cir_evolve.U.numpy()\n", - "print('The fidelity between the circuit\\'s unitary and the exact evolution operator is : %.2f' % gate_fidelity(get_evolve_op(t), U_cir))" - ] - }, - { - "cell_type": "markdown", - "id": "ce487d74", - "metadata": {}, - "source": [ - "#### Permute the Hamiltonian according to commutation relationships\n", - "\n", - "It has been shown that the product formula's simulating error can be reduced by rearranging different terms. Since the error of simulation arises from the non-commuting terms in the Hamiltonian, one natural idea is to permute the Hamiltonian so that commuting terms are put together. For example, we could divide a Hamiltonian into four parts,\n", - "\n", - "$$\n", - "H = H_x + H_y + H_z + H_{\\rm other},\n", - "\\tag{7}\n", - "$$\n", - "\n", - "where $H_x, H_y, H_z$ contain terms only composed of $X, Y, Z$ operators, and $H_{\\rm other}$ are all the other terms. For Hamiltonian describe in (5), all terms can be grouped into $H_x, H_y, H_z$.\n", - "\n", - "Another approach is to decompose the Hamiltonian according to the system geometry. Especially for one-dimensional nearest-neighbor systems, the Hamiltonian can be divided into even and odd terms, \n", - "\n", - "$$\n", - "H = H_{\\rm even} + H_{\\rm odd}.\n", - "\\tag{8}\n", - "$$\n", - "\n", - "where $H_{\\rm even}$ are interactions on sites $(0, 1), (2, 3), ...$ and $H_{\\rm odd}$ are interactions on sites $(1, 2), (3, 4), ...$.\n", - "\n", - "Note that these two permutation strategies do **not** reduce the bound on simulation error, and empirical results return a more case-by-case effect on the error. Nevertheless, we provide the above two decompositions as a built-in option of the `construct_trotter_circuit()` function. By setting the argument `grouping='xyz'` or `grouping='even_odd'`, the function will automatically try to rearrange the Hamiltonian when adding the trotter circuit. Besides, users can also customize permutation by using the argument `permutation`, which we will introduce shortly in the next section. For now, let's test the `grouping` option and check the variations in fidelity:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "b2eaca4c", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Original fidelity： 0.5777594967189371\n", - "XYZ permuted fidelity： 0.7009189629323416\n", - "Even-odd permuted fidelity： 0.7301965802081132\n" - ] - } - ], - "source": [ - "# using the same evolution parameters, but set 'grouping=\"xyz\"' and 'grouping=\"even_odd\"'\n", - "cir_evolve_xyz = UAnsatz(5)\n", - "cir_evolve_even_odd = UAnsatz(5)\n", - "construct_trotter_circuit(cir_evolve_xyz, h, tau=t/r, steps=r, order=2, grouping='xyz')\n", - "construct_trotter_circuit(cir_evolve_even_odd, h, tau=t/r, steps=r, order=2, grouping='even_odd')\n", - "U_cir_xyz = cir_evolve_xyz.U.numpy()\n", - "U_cir_even_odd = cir_evolve_even_odd.U.numpy()\n", - "print('Original fidelity：', gate_fidelity(get_evolve_op(t), U_cir))\n", - "print('XYZ permuted fidelity：', gate_fidelity(get_evolve_op(t), U_cir_xyz))\n", - "print('Even-odd permuted fidelity：', gate_fidelity(get_evolve_op(t), U_cir_even_odd))" - ] - }, - { - "cell_type": "markdown", - "id": "f18e3f16", - "metadata": {}, - "source": [ - "#### Initial state preparation and final state observation\n", - "\n", - "Now let's prepare the system's initial state. Generally speaking, one common approach when studying the dynamics of a quantum system is to start the evolution from different direct product states. In Paddle Quantum, the default initial state is $\\vert 0...0 \\rangle$, so we can simply apply $X$ gate to different qubits to get a direct product initial state. For example, here we apply $X$ gate to qubits representing spins on odd sites, so the initial state will become $\\vert 01010 \\rangle$, as in spin notation, $\\vert \\downarrow \\uparrow \\downarrow \\uparrow \\downarrow \\rangle$." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "id": "e0ff6736", - "metadata": {}, - "outputs": [], - "source": [ - "# create a circuit used for initial state preparation\n", - "cir = UAnsatz(5)\n", - "cir.x(1)\n", - "cir.x(3)\n", - "# run the circuit the get the initial state\n", - "init_state = cir.run_state_vector()" - ] - }, - { - "cell_type": "markdown", - "id": "e7d5b832", - "metadata": {}, - "source": [ - "By passing the initial state `init_state` into the method `UAnsatz.run_state_vector(init_state)`, we can evolve the initial state with a quantum circuit. Then by `UAnsatz.expecval()` method, the expectation value of a user-specified observable on the final state could be measured. For simplicity, we only consider a single-spin observable $\\langle S_i^z \\rangle$ here, its corresponding Pauli string is `[[1, 'Zi']]` (i being an integer)." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "id": "88d5e1b9", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sz observable on the site 0 is： 0.6516225940072864\n" - ] - } - ], - "source": [ - "cir_evolve_even_odd.run_state_vector(init_state)\n", - "print('Sz observable on the site 0 is：', cir_evolve_even_odd.expecval([[1, 'Z0']]).numpy()[0])" - ] - }, - { - "cell_type": "markdown", - "id": "e70d9fba", - "metadata": {}, - "source": [ - "Similarly, by adjusting the simulation time length and changing the observable, we could plot the entire evolution process of different spins. Note here in order to compute the exact solution, we need to construct the matrix form of each observable $S_i^z$ using `SpinOps` class and calculate their expectation value with $\\langle \\psi(t) \\vert S_i^z \\vert \\psi(t) \\rangle$." - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "id": "6c4c03ea", - "metadata": {}, - "outputs": [], - "source": [ - "def get_evolution_z_obs(h, t_total, order=None, n_steps=None, exact=None):\n", - " \"\"\" \n", - " a function to calculate a system's Sz observable on each site for an entire evolution process t\n", - " specify the order the trotter length by setting order and n_steps\n", - " set exact=True to get the exact results\n", - " \"\"\"\n", - " z_obs_total = []\n", - " for t in np.linspace(0., t_total, t_total * 3 + 1):\n", - " z_obs = []\n", - " # get the final state by either evolving with a circuit or the exact operator\n", - " if exact:\n", - " spin_operators = SpinOps(h.n_qubits)\n", - " fin_state = get_evolve_op(t).dot(init_state)\n", - " else:\n", - " cir_evolve = UAnsatz(5)\n", - " construct_trotter_circuit(cir_evolve, h, tau=t/n_steps, steps=n_steps, order=order, grouping='even_odd')\n", - " fin_state = cir_evolve.run_state_vector(init_state)\n", - " # measure the observable on each site\n", - " for site in range(h.n_qubits):\n", - " if exact:\n", - " z_obs.append(fin_state.conj().T.dot(spin_operators.sigz_p[site]).dot(fin_state))\n", - " else:\n", - " z_obs.append(cir_evolve.expecval([[1, 'Z' + str(site)]]).numpy()[0])\n", - " z_obs_total.append(z_obs)\n", - " return np.array(z_obs_total).real \n", - "\n", - "def plot_comparison(**z_obs_to_plot):\n", - " \"\"\"\n", - " plot comparison between different evolution results\n", - " assume each argument passed into it is returned from get_evolution_z_obs() function for the same t_total\n", - " \"\"\"\n", - " fig, axes = plt.subplots(1, len(z_obs_to_plot), figsize = [len(z_obs_to_plot) * 3, 5.5])\n", - " \n", - " ax_idx = 0\n", - " for label in z_obs_to_plot.keys():\n", - " im = axes[ax_idx].imshow(z_obs_to_plot[label], cmap='coolwarm_r', interpolation='kaiser', origin='lower')\n", - " axes[ax_idx].set_title(label, fontsize=15)\n", - " ax_idx += 1\n", - "\n", - " for ax in axes:\n", - " ax.set_xlabel('site', fontsize=15)\n", - " ax.set_yticks(np.arange(0, z_obs_total_exact.shape[0], 3))\n", - " ax.set_yticklabels(np.arange(0, z_obs_total_exact.shape[0]/3, 1))\n", - " ax.set_xticks(np.arange(z_obs_total_exact.shape[1]))\n", - " ax.set_xticklabels(np.arange(z_obs_total_exact.shape[1]))\n", - "\n", - " axes[0].set_ylabel('t', fontsize=15)\n", - " cax = fig.add_axes([0.92, 0.125, 0.02, 0.755])\n", - " \n", - " \n", - " fig.colorbar(im, cax)\n", - " cax.set_ylabel(r'$\\langle S^z_i (t) \\rangle$', fontsize=15)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "id": "3735e79a", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# calculate the evolution process with circuits of trotter number 25 and 5, and the exact result\n", - "z_obs_total_exact = get_evolution_z_obs(h, t_total=3, exact=True)\n", - "z_obs_total_cir = get_evolution_z_obs(h, order=1, n_steps=25, t_total=3)\n", - "z_obs_total_cir_short = get_evolution_z_obs(h, order=1, n_steps=5, t_total=3)\n", - "\n", - "plot_comparison(\n", - " Exact=z_obs_total_exact,\n", - " L25_Circuit=z_obs_total_cir,\n", - " L5_Circuit=z_obs_total_cir_short)" - ] - }, - { - "cell_type": "markdown", - "id": "707ecfdf", - "metadata": {}, - "source": [ - "Observed that with 25 trotter blocks, the circuit could very well simulate the spin dynamics for the entire period. In contrast, the shorter circuit with only 5 trotter blocks could only describe the system's behavior correctly up to a certain time until the simulation breaks down.\n", - "\n", - "**Exercise：** Could the readers try to observe the evolution of spatial spin correlation function $\\langle S_i^z S_j^{z} \\rangle$？" - ] - }, - { - "cell_type": "markdown", - "id": "af97d494", - "metadata": {}, - "source": [ - "## Design customized trotter circuit with random permutation\n", - "\n", - "### Random permutation\n", - "\n", - "Although it seems more physically reasonable to group the commuting terms in the Hamiltonian to achieve better simulation performance, many evidence has shown that using a fixed order Hamiltonian for each trotter block might cause the errors to accumulate. On the other hand, evolving the Hamiltonian according to an random ordering might \"wash-out\" some of the coherent error in the simulation process and replace it with less harmful stochastic noise [8]. Both theoretical analyses on the error upper bound and empirical evidences show that this randomization could effectively reduce the simulation error [9]." - ] - }, - { - "cell_type": "markdown", - "id": "9ecc2ea0", - "metadata": {}, - "source": [ - "### Customize trotter circuit construction\n", - "\n", - "By default, the function `construct_trotter_circuit()` constructs a time evolving circuit according to the Suzuki product formula. However, users could choose to customize both the coefficients and permutations by setting `method='custom'` and passing custom arrays to arguments `permutation` and `coefficient`. \n", - "\n", - "**Note:** The user should be very cautious when using arguments `coefficient`, `tau` and `steps` altogether. By setting `steps` other than 1 and `tau` other than $t$ (the total evolution time), it is possible to further trotterize the custom coefficient and permutation. For example, when setting `permutation=np.arange(h.n_qubits)` and `coefficient=np.ones(h.n_qubits)`, the effect of `tau` and `steps` is exactly the same as constructing the first-order product formula circuit." - ] - }, - { - "cell_type": "markdown", - "id": "8afa9fe1", - "metadata": {}, - "source": [ - "Let us further demonstrate the customization function with a concrete example. With the same spin chain Hamiltonian, now we wish to design an evolution strategy similar to the first-order product formula, however the ordering of the Hamiltonian terms within each trotter block is independently random. We could implement this by pass an arraying of shape `(n_steps, h.n_terms)` to the argument `permutation`, and each row of that array is a random permutation $P(N)$." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "id": "f70ab81b", - "metadata": {}, - "outputs": [], - "source": [ - "# An example for customize permutation\n", - "permutation = np.vstack([np.random.permutation(h.n_terms) for i in range(100)])" - ] - }, - { - "cell_type": "markdown", - "id": "8d189064", - "metadata": {}, - "source": [ - "Then, we compare the fidelity of such strategy with the first order product formula under different trotter length." - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "id": "6d6910c9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def compare(n_steps):\n", - " \"\"\"\n", - " compare the first order product formula and random permutation's fidelity for a fixed evolution time t=2\n", - " input n_steps is the number of trotter steps\n", - " output is respectively the first order PF and random permutations' fidelity \n", - " \"\"\"\n", - " t = 2\n", - " cir_evolve = UAnsatz(5)\n", - " construct_trotter_circuit(cir_evolve, h, tau=t/n_steps, steps=n_steps, order=1)\n", - " U_cir = cir_evolve.U.numpy()\n", - " fid_suzuki = gate_fidelity(get_evolve_op(t), U_cir)\n", - " cir_permute = UAnsatz(5)\n", - " permutation = np.vstack([np.random.permutation(h.n_terms) for i in range(n_steps)])\n", - " # when coefficient is not specified, a normalized uniform coefficient will be automatically set\n", - " construct_trotter_circuit(cir_permute, h, tau=t, steps=1, method='custom', permutation=permutation)\n", - " U_cir = cir_permute.U.numpy()\n", - " fid_random = gate_fidelity(get_evolve_op(t), U_cir)\n", - " return fid_suzuki, fid_random\n", - "\n", - "# compare the two fidelity for different trotter steps\n", - "# as a demo, we only run the experiment once. Interested readers could run multiple times to calculate the error bar\n", - "n_range = [100, 200, 500, 1000]\n", - "result = [compare(n) for n in n_range]\n", - "\n", - "result = 1 - np.array(result)\n", - "plt.loglog(n_range, result[:, 0], 'o-', label='1st order PF')\n", - "plt.loglog(n_range, result[:, 1], 'o-', label='Random')\n", - "plt.xlabel(r'Trotter number $r$', fontsize=12)\n", - "plt.ylabel(r'Error: $1 - {\\rm Fid}$', fontsize=12)\n", - "plt.legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "id": "48fc79ff", - "metadata": {}, - "source": [ - "The 1st order PF refers to the first order product formula circuit with a fixed order. As expected, there is a good improvement in the fidelity for randomized trotter circuit over the first order product formula. \n", - "\n", - "**Note:** In [9], the authors noted that the randomization achieved better performance without even utilizing any specific information about the Hamiltonian, and there should be a even more efficient algorithm compared to the simple randomization." - ] - }, - { - "cell_type": "markdown", - "id": "bfe2c24e", - "metadata": {}, - "source": [ - "## Conclusion" - ] - }, - { - "cell_type": "markdown", - "id": "92832953", - "metadata": {}, - "source": [ - "Dynamical simulation plays a central role in the research of exotic quantum states. Due to its highly entangled nature, both experimental and theoretical research constitute highly challenging topics. Up until now, people haven't been able to fully understand the physics on some of the two-dimensional or even one-dimensional spin systems. On the other hand, the rapid development of general quantum computers and a series of quantum simulators give researchers new tools to deal with these challenging problems. Take the general quantum computer as an example, it could use digital simulation to simulate almost any quantum system's evolution process under complex conditions (for example a time-dependent Hamiltonian), which is beyond the reach of any classical computer. As the number of qubits and their precisions grow, it seems more like a question of when will the quantum computer surpass its classical counterpart on the tasks of quantum simulation. And among those tasks, it is commonly believed that the simulation of quantum spin systems will be one of the few cases where this breakthrough will first happen. \n", - "\n", - "We have presented in this tutorial a hands-on case of simulating dynamical process on a quantum spin model with Paddle Quantum, and further discussed the possibility of designing new time-evolving strategies. Users can now easily design and benchmark their time evolution circuits with the `construct_trotter_circuit()` function and methods provided in the `Hamiltonian` and `SpinOps` class. We encourage our users to experiment and explore various time evolution strategies on different quantum systems. " - ] - }, - { - "cell_type": "markdown", - "id": "ff5b39fa", - "metadata": {}, - "source": [ - "---\n", - "\n", - "## References\n", - "\n", - "[1] Childs, Andrew M., et al. \"Toward the first quantum simulation with quantum speedup.\" [Proceedings of the National Academy of Sciences 115.38 (2018): 9456-9461](https://www.pnas.org/content/115/38/9456.short).\n", - "\n", - "[2] Eckle, Hans-Peter. Models of Quantum Matter: A First Course on Integrability and the Bethe Ansatz. [Oxford University Press, 2019](https://oxford.universitypressscholarship.com/view/10.1093/oso/9780199678839.001.0001/oso-9780199678839).\n", - "\n", - "[3] Mikeska, Hans-Jürgen, and Alexei K. Kolezhuk. \"One-dimensional magnetism.\" Quantum magnetism. Springer, Berlin, Heidelberg, 2004. 1-83.\n", - "\n", - "[4] Berger, L., S. A. Friedberg, and J. T. Schriempf. \"Magnetic Susceptibility of $\\rm Cu(NO_3)_2·2.5 H_2O$ at Low Temperature.\" [Physical Review 132.3 (1963): 1057](https://journals.aps.org/pr/abstract/10.1103/PhysRev.132.1057).\n", - "\n", - "[5] Broholm, C., et al. \"Quantum spin liquids.\" [Science 367.6475 (2020)](https://science.sciencemag.org/content/367/6475/eaay0668).\n", - "\n", - "[6] Abanin, Dmitry A., et al. \"Colloquium: Many-body localization, thermalization, and entanglement.\" [Reviews of Modern Physics 91.2 (2019): 021001](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.91.021001).\n", - "\n", - "[7] Medenjak, Marko, Berislav Buča, and Dieter Jaksch. \"Isolated Heisenberg magnet as a quantum time crystal.\" [Physical Review B 102.4 (2020): 041117](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.102.041117).\n", - "\n", - "[8] Wallman, Joel J., and Joseph Emerson. \"Noise tailoring for scalable quantum computation via randomized compiling.\" [Physical Review A 94.5 (2016): 052325](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.94.052325).\n", - "\n", - "[9] Childs, Andrew M., Aaron Ostrander, and Yuan Su. \"Faster quantum simulation by randomization.\" [Quantum 3 (2019): 182](https://quantum-journal.org/papers/q-2019-09-02-182/)." - ] - } - ], - "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.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/tutorial/quantum_simulation/VQE_CN.ipynb b/tutorial/quantum_simulation/VQE_CN.ipynb deleted file mode 100644 index 96cf6c5..0000000 --- a/tutorial/quantum_simulation/VQE_CN.ipynb +++ /dev/null @@ -1,549 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 变分量子本征求解器\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 概览\n", - "\n", - "目前普遍认为，量子计算在近期很有前景的一个应用是处理量子化学问题 [1-2]。**变分量子本征求解器** （VQE）作为这个研究方向的核心应用之一，为研究者们提供了可以在目前含噪的中等规模量子设备（NISQ device）上研究量子化学的可能 [1-4]。其核心任务是求解一个量子尺度上封闭物理系统的哈密顿量 $\\hat{H}$ 的基态能量及其对应的量子态。主要的实现方法是通过在量子设备上准备一个参数化的试探波函数 $|\\Psi(\\boldsymbol\\theta)\\rangle$ 然后结合经典机器学习中的优化算法（例如梯度下降法）去不断地调整、优化参数 $\\boldsymbol\\theta$ 使得期望值 $\\langle \\Psi(\\boldsymbol\\theta)|\\hat{H}|\\Psi(\\boldsymbol\\theta)\\rangle$ 最小化。这套方案的基本原理是基于 **Rayleigh-Ritz 变分原理**。 \n", - "\n", - "$$\n", - "E_0 = \\min_{\\boldsymbol\\theta} \\langle \\Psi(\\boldsymbol\\theta)|\\hat{H}|\\Psi(\\boldsymbol\\theta)\\rangle.\n", - "\\tag{1}\n", - "$$\n", - "\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", - "\\tag{2}\n", - "$$\n", - "\n", - "其中 $c_k$ 表示权重系数, $\\sigma_j^{(k)} \\in \\{I,X,Y,Z\\}$ 并且 $M$ 表示所需的量子比特个数。这样一种哈密顿量的表示形式被称为 **泡利字符串**。以下为一个2量子比特的具体例子，\n", - "\n", - "$$\n", - "H= 0.12~Y_0 \\otimes I_1-0.04~X_0\\otimes Z_1.\n", - "\\tag{3}\n", - "$$\n", - "\n", - "在下一节，我们会补充一些关于电子结构问题的背景知识。本质上讨论的就是上述哈密顿量 $H$ 是如何计算的。对于熟悉相关背景的读者，或者主要关心如何在量桨上实现 VQE 的读者，请直接跳转至第三节分析氢分子（$H_2$）基态的具体例子。 " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 背景： 电子结构问题\n", - "\n", - "这里，我们集中讨论下量子化学中的一个基本问题 -- **电子结构问题**。更准确的说，我们关心的是给定分子（molecule）的低位能量本征态。这些信息可以帮助我们预测化学反应的速率和分子的稳定结构等等 [6]。假设一个分子由 $N_n$ 个原子核和 $N_e$ 个电子组成，描述该分子系统总能量的哈密顿量算符 $\\hat{H}_{mol}$ 在一次量子化表示下可以写为，\n", - "\n", - "$$\n", - "\\begin{align}\n", - "\\hat{H}_{\\text{mol}} & = -\\sum_{i}\\frac{\\nabla_{R_i}^2}{2M_i} - \\sum_{i} \\frac{\\nabla_{r_i}^2}{2} -\\sum_{i,j}\\frac{Z_i}{\\lvert R_i - r_j\\lvert} + \\sum_{i,j>i}\\frac{Z_iZ_j}{\\lvert R_i - R_j\\lvert} + \\sum_{i, j>i}\\frac{1}{\\lvert r_i - r_j\\lvert}, \n", - "\\tag{4}\n", - "\\end{align}\n", - "$$\n", - "\n", - "其中 $R_i、M_i$ 和 $Z_i$ 分别表示第 $i$ 个原子核的位置、质量和原子序数（原子核内质子数），第 $i$ 个电子的位置则表示为 $r_i$。以上公式右边前两项分别代表原子核和电子的总动能。第三项表示带正电的质子和带负电的电子之间的库伦相互吸引作用。最后两项则表示原子核-原子核之间，电子-电子之间的相互排斥作用。这里，分子哈密顿量 $\\hat{H}_\\text{mol}$ 使用的是原子单位制能量 **哈特里能量**（Hartree），记为 Ha。$1$ 哈特里能量的大小为 $[\\hbar^2/(m_ee^2a_0^2)] = 27.2$ 电子伏或 $630$ 千卡/摩尔，其中 $m_e、e$ 和 $a_0$ 分别表示电子质量、基本电荷和玻尔半径。\n", - "\n", - "**注释1：** 在处理电子结构问题时，我们不考虑自旋-轨道耦合以及超精细结构。如果出于计算需要，可以作为微扰加入。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 玻恩-奥本海默近似\n", - "\n", - "由于原子核的质量要远大于电子，因而在同样的相互作用下电子的运动速度会比原子核快很多。所以，将原子核所处的位置看成固定 $R_i =$常数 是一种合理的近似。这种通过在时间尺度上将电子行为和原子核行为去耦合的近似处理思想被称为玻恩-奥本海默近似。作为近似的直接结果，公式（4）中原子核的动能项会被消去并且表示原子核-原子核相互排斥作用的项可以被认为是一个能量移位（这个项是与电子位置 $r_i$ 无关的）从而也可以作为常数项被忽略。经过这些步骤后，我们可以把哈密顿量近似为：\n", - "\n", - "$$\n", - "\\begin{align}\n", - "\\hat{H}_{\\text{electron}} & = - \\sum_{i} \\frac{\\nabla_{r_i}^2}{2} -\\sum_{i,j}\\frac{Z_i}{\\lvert R_i - r_j\\lvert} + \\sum_{i, j>i}\\frac{1}{\\lvert r_i - r_j\\lvert} \n", - "\\tag{5},\n", - "\\end{align}\n", - "$$\n", - "\n", - "在经过以上近似后，分子中多电子结构的能级在理论上可以通过求解以下不含时薛定谔方程获得：\n", - "\n", - "$$\n", - "\\hat{H}_{\\text{electron}} |\\Psi_n \\rangle = E_n |\\Psi_n \\rangle,\n", - "\\tag{6}\n", - "$$\n", - "\n", - "其中 $n$ 指代能级。值得注意的是，电子哈密顿量中电子-电子相互排斥作用的求和项数会随着电子数 $N_e$ 的增多至 $N_e(N_e-1)/2$ 项。这意味着对于一个含有16个电子的氧分子（$O_2$）我们需要计算多达120项的相互排斥作用项。 一般来说，这样的问题是无法从理论上精确求解的。正如狄拉克在 [Quantum mechanics of many-electron systems](https://royalsocietypublishing.org/doi/10.1098/rspa.1929.0094) [7] 所指出的那样，\n", - "\n", - "> *The underlying physical laws necessary for the mathematical theory of a large part of physics and the whole of chemistry are thus completely known, and the difficulty is only that the exact application of these laws leads to equations much too complicated to be soluble.* \n", - "> \n", - "> -- Paul Dirac (1929)\n", - "\n", - "由于解析的方法太复杂，那么我们可以采用数值方法来处理。一个最简单的数值方法（离散化方法）就是把上述作用中无限维度希尔伯特空间离散化为等间距排开的立方体晶格点。在这样一个离散化的空间里，主要运算规则为复数域的线性代数。假设空间的每个轴都离散为等间距排开的 $k$ 个点，则 $N$-电子（为了方便去掉下标 $e$）的多体波函数可以写为 [2]：\n", - "\n", - "$$\n", - "|\\Psi \\rangle = \\sum_{\\mathbf{x_1}, \\ldots, \\mathbf{x_N}} \\psi(\\mathbf{x_1}, \\ldots, \\mathbf{x_N}) \\mathcal{A}(|\\mathbf{x_1}, \\ldots, \\mathbf{x_N}\\rangle).\n", - "\\tag{7}\n", - "$$\n", - "\n", - "其中坐标 $|\\mathbf{x_j}\\rangle = |r_j\\rangle |\\sigma_j\\rangle$ 记录第 $j$ 个电子的空间位置信息和自旋，$|r_j\\rangle = |x_j,y_j,z_j\\rangle$ 且 $j\\in \\{1,2,\\cdots,N\\}$, $x_j,y_j,z_j \\in \\{0,1,\\cdots,k-1\\}$ 同时 $\\sigma_j \\in \\{\\downarrow,\\uparrow\\}$ 表示自旋向下和向上。这样一种离散化方式共计需要 $k^{3N}\\times 2^{N}$ 个数据来表示波函数。在这里，$\\mathcal{A}$ 表示反对称化操作（根据泡利不相容原理）并且 $\\psi(\\mathbf{x_1}, \\mathbf{x_2}, \\ldots, \\mathbf{x_N})=\\langle\\mathbf{x_1}, \\mathbf{x_2}, \\ldots, \\mathbf{x_N}|\\Psi\\rangle$。 可以看出，经典计算机存储这样一个波函数需要的内存是随着电子个数呈指数增长的。这使得基于这种离散化的经典数值方法，无法模拟超过几十个电子的系统。那么，我们是不是能够通过量子设备来存储和准备这样一个波函数然后求解基态能量 $E_0$ 呢？在下一节中，我们将以最简单的分子系统 -- 氢分子（$H_2$）为例，讲解 VQE 算法。\n", - "\n", - "**注释2：** 关于量子化学和现有数值计算方法的综述也超过了本教程的处理范围，我们推荐感兴趣的读者去查阅以下经典教材 Helgaker 等人撰写的 *'Molecular Electronic-Structure Theory'* [6] 以及 Szabo & Ostlund 撰写的 *'Modern Quantum Chemistry: Introduction to Advanced Electronic Structure Theory'* [8]。 如果需要弥补量子计算和量子化学之间知识空缺，请参考以下综述文章 [Quantum chemistry in the age of quantum computing](https://pubs.acs.org/doi/10.1021/acs.chemrev.8b00803) [1] 和 [Quantum computational chemistry](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.92.015003) [2] 。\n", - "\n", - "**注释3：** 对于量子化学中的能量计算，我们期望能够达到 **化学精度**（chemical accuracy）$1.6\\times10^{-3}$ Ha 或者 1 千卡/摩尔。\n", - "\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 氢分子 $H_2$ 基态能量\n", - "\n", - "### 构造电子哈密顿量\n", - "\n", - "首先，让我们通过下面几行代码引入必要的 library 和 package。量桨的量子化学工具包是基于 `psi4` 和 `openfermion` 进行开发的，所以需要读者先行安装这两个语言包。在进入下面的教程之前，我们强烈建议您先阅读[哈密顿量的构造](./BuildingMolecule_CN.ipynb)教程，该教程介绍了如何使用量桨的量子化学工具包。\n", - "\n", - "**注意：关于环境设置，请参考 [README_CN.md](https://github.com/PaddlePaddle/Quantum/blob/master/README_CN.md).**" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:13:45.528201Z", - "start_time": "2021-04-30T09:13:43.385553Z" - } - }, - "outputs": [], - "source": [ - "import paddle\n", - "import paddle_quantum.qchem as qchem\n", - "from paddle_quantum.utils import Hamiltonian\n", - "from paddle_quantum.circuit import UAnsatz\n", - "\n", - "import os\n", - "import matplotlib.pyplot as plt\n", - "\n", - "import numpy\n", - "from numpy import pi as PI\n", - "from numpy import savez, zeros\n", - "\n", - "# 无视警告\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "对于具体需要分析的分子，我们需要其**几何构型** (geometry)、**基组**（basis set，例如 STO-3G 基于高斯函数）、**多重度**（multiplicity）以及**分子的净电荷数** (charge) 等多项信息来建模计算出该分子单体积分 (one-body integrations)，双体积分(two-body integrations) 以及哈密顿量等信息。接下来，通过量桨的量子化学工具包将分子的哈密顿量提取出来并储存为 paddle quantum 的 `Hamiltonian` 类，方便我们下一步的操作。" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:13:45.545018Z", - "start_time": "2021-04-30T09:13:45.531302Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "FCI energy for H2_sto-3g_singlet (2 electrons) is -1.1372838344855134.\n", - "\n", - "The generated h2 Hamiltonian is \n", - " -0.0970662686176252 I\n", - "-0.04530261550868938 X0, X1, Y2, Y3\n", - "0.04530261550868938 X0, Y1, Y2, X3\n", - "0.04530261550868938 Y0, X1, X2, Y3\n", - "-0.04530261550868938 Y0, Y1, X2, X3\n", - "0.1714128263940238 Z0\n", - "0.16868898168693292 Z0, Z1\n", - "0.12062523481381847 Z0, Z2\n", - "0.1659278503225078 Z0, Z3\n", - "0.17141282639402383 Z1\n", - "0.1659278503225078 Z1, Z2\n", - "0.12062523481381847 Z1, Z3\n", - "-0.22343153674664024 Z2\n", - "0.17441287610651632 Z2, Z3\n", - "-0.2234315367466403 Z3\n" - ] - } - ], - "source": [ - "geo = qchem.geometry(structure=[['H', [-0., 0., 0.0]], ['H', [-0., 0., 0.74]]])\n", - "# geo = qchem.geometry(file='h2.xyz')\n", - "\n", - "# 将分子信息存储在 molecule 里，包括单体积分（one-body integrations），双体积分（two-body integrations），分子的哈密顿量等\n", - "molecule = qchem.get_molecular_data(\n", - " geometry=geo,\n", - " basis='sto-3g',\n", - " charge=0,\n", - " multiplicity=1,\n", - " method=\"fci\",\n", - " if_save=True,\n", - " if_print=True\n", - ")\n", - "# 提取哈密顿量\n", - "molecular_hamiltonian = qchem.spin_hamiltonian(molecule=molecule,\n", - " filename=None, \n", - " multiplicity=1, \n", - " mapping_method='jordan_wigner',)\n", - "# 打印结果\n", - "print(\"\\nThe generated h2 Hamiltonian is \\n\", molecular_hamiltonian)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**注释4：** 生成这个哈密顿量的几何构型中，两个氢原子间的原子间隔（interatomic distance）为 $d = 74$ pm。\n", - "\n", - "除了输入分子的几何结构外，我们还支持读取分子的几何构型文件 (`.xyz` 文件)，关于量子化学工具包更多的用法请参考[哈密顿量的构造](./BuildingMolecule_CN.ipynb)教程。如果你需要测试更多分子的几何构型，请移步至这个[数据库](http://smart.sns.it/molecules/index.html)。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 搭建量子神经网络（QNN）和试探波函数\n", - "\n", - "在实现VQE的过程中，我们首先需要设计量子神经网络QNN（也可以理解为参数化量子电路）来准备试探波函数 $|\\Psi(\\boldsymbol\\theta)\\rangle$。这里，我们提供一个预设好的的深度为 $D$ 层的 4-量子比特的量子电路模板，图中的虚线框内为一层：\n", - "\n", - "![Utheta.jpg](https://release-data.cdn.bcebos.com/PIC%2FUtheta.jpg)\n", - "\n", - "- 我们预设一些该参数化电路的参数，比如宽度为 $N = 4$ 量子位。\n", - "\n", - "- 初始化其中的变量参数，${\\bf{\\theta }}$ 代表我们量子神经网络中的参数组成的向量。\n", - "\n", - "接下来我们根据上图中的电路设计，通过 Paddle Quantum 的 `UAnsatz` 函数和内置的 `real_entangled_layer(theta, D)` 电路模板来高效搭建量子神经网络。 " - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "def U_theta(theta, Hamiltonian, N, D):\n", - " \"\"\"\n", - " Quantum Neural Network\n", - " \"\"\"\n", - " \n", - " # 按照量子比特数量/网络宽度初始化量子神经网络\n", - " cir = UAnsatz(N)\n", - " \n", - " # 内置的 {R_y + CNOT} 电路模板\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", - " # 量子神经网络作用在默认的初始态 |0000> 上\n", - " fin_state = cir.run_state_vector()\n", - " \n", - " # 计算给定哈密顿量的期望值\n", - " expectation_val = cir.expecval(Hamiltonian)\n", - "\n", - " return expectation_val, cir, fin_state" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 配置训练模型 - 损失函数\n", - "\n", - "现在我们已经有了数据和量子神经网络的架构，我们将进一步定义训练参数、模型和损失函数。通过作用量子神经网络 $U(\\theta)$ 在初始态 $|0..0\\rangle$ 上，我们将得到输出态 $\\left| {\\psi \\left( {\\bf{\\theta }} \\right)} \\right\\rangle $。进一步，在VQE模型中的损失函数一般由量子态 $\\left| {\\psi \\left( {\\bf{\\theta }} \\right)} \\right\\rangle$ 关于哈密顿量 $H$ 的期望值 (能量期望值 expectation value) 给出，\n", - "\n", - "$$\n", - "\\min_{\\boldsymbol\\theta} \\mathcal{L}(\\boldsymbol \\theta) = \\min_{\\boldsymbol\\theta} \\langle \\Psi(\\boldsymbol\\theta)|H |\\Psi(\\boldsymbol\\theta)\\rangle\n", - "= \\min_{\\boldsymbol\\theta} \\sum_k c_k~\\langle \\Psi(\\boldsymbol\\theta)| \\bigotimes_j \\sigma_j^{(k)}|\\Psi(\\boldsymbol\\theta)\\rangle.\n", - "\\tag{8}\n", - "$$" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "class StateNet(paddle.nn.Layer):\n", - " \"\"\"\n", - " Construct the model net\n", - " \"\"\"\n", - "\n", - " def __init__(self, shape, dtype=\"float64\"):\n", - " super(StateNet, self).__init__()\n", - " \n", - " # 初始化 theta 参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # 定义损失函数和前向传播机制\n", - " def forward(self, N, D):\n", - " \n", - " # 计算损失函数/期望值\n", - " loss, cir, fin_state = U_theta(self.theta, molecular_hamiltonian.pauli_str, N, D)\n", - "\n", - " return loss, cir, fin_state" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 配置训练模型 - 模型参数\n", - "\n", - "在进行量子神经网络的训练之前，我们还需要进行一些训练的超参数设置，主要是学习速率（LR, learning rate）、迭代次数（ITR, iteration）和量子神经网络计算模块的深度（D, Depth）。这里我们设定学习速率为 0.5, 迭代次数为 50 次。读者不妨自行调整来直观感受下超参数调整对训练效果的影响。" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:14:03.744957Z", - "start_time": "2021-04-30T09:14:03.738881Z" - } - }, - "outputs": [], - "source": [ - "ITR = 80 # 设置训练的总迭代次数\n", - "LR = 0.4 # 设置学习速率\n", - "D = 2 # 设置量子神经网络中重复计算模块的深度 Depth\n", - "N = molecular_hamiltonian.n_qubits # 设置参与计算的量子比特数" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 进行训练\n", - "\n", - "当训练模型的各项参数都设置完成后，我们将数据转化为 Paddle 中的张量，进而进行量子神经网络的训练。过程中我们用的是Adam Optimizer，也可以调用Paddle中提供的其他优化器。我们将训练过程中的结果存储在summary_data文件中。" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 20 loss: -1.0861\n", - "iter: 20 Ground state energy: -1.0861 Ha\n", - "iter: 40 loss: -1.1304\n", - "iter: 40 Ground state energy: -1.1304 Ha\n", - "iter: 60 loss: -1.1363\n", - "iter: 60 Ground state energy: -1.1363 Ha\n", - "iter: 80 loss: -1.1372\n", - "iter: 80 Ground state energy: -1.1372 Ha\n", - "\n", - "训练后的电路：\n", - "--Ry(1.572)----*--------------x----Ry(1.568)----*--------------x----Ry(0.012)--\n", - " | | | | \n", - "--Ry(4.724)----x----*---------|----Ry(4.722)----x----*---------|----Ry(1.619)--\n", - " | | | | \n", - "--Ry(-0.03)---------x----*----|----Ry(4.954)---------x----*----|----Ry(-0.41)--\n", - " | | | | \n", - "--Ry(4.288)--------------x----*----Ry(1.564)--------------x----*----Ry(3.137)--\n", - " \n" - ] - } - ], - "source": [ - "# 确定网络的参数维度\n", - "net = StateNet(shape=[D + 1, N, 1])\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, fin_state = net(N, D)\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", - "# 储存训练结果到 output 文件夹\n", - "os.makedirs(\"output\", exist_ok=True)\n", - "savez(\"./output/summary_data\", iter = summary_iter, \n", - " energy=summary_loss)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 测试效果\n", - "我们现在已经完成了量子神经网络的训练，通过 VQE 得到的基态能量的估计值大致为 $E_0 \\approx -1.137$ Ha，这与通过 `Psi4` 在 sto-3g 基底下使用 FCI (full configuration-interaction) 方法计算得到的基态能量值 $E_0 = -1.13728$ Ha 是在化学精度 $\\varepsilon = 1.6 \\times 10^{-3}$ Ha 内相符合的。" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:14:21.341323Z", - "start_time": "2021-04-30T09:14:20.710152Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "result = numpy.load('./output/summary_data.npz')\n", - "\n", - "eig_val, eig_state = numpy.linalg.eig(\n", - " molecular_hamiltonian.construct_h_matrix())\n", - "min_eig_H = numpy.min(eig_val.real)\n", - "min_loss = numpy.ones([len(result['iter'])]) * min_eig_H\n", - "\n", - "plt.figure(1)\n", - "func1, = plt.plot(result['iter'], result['energy'], \n", - " alpha=0.7, marker='', linestyle=\"-\", color='r')\n", - "func_min, = plt.plot(result['iter'], min_loss, \n", - " alpha=0.7, marker='', linestyle=\":\", color='b')\n", - "plt.xlabel('Number of iteration')\n", - "plt.ylabel('Energy (Ha)')\n", - "\n", - "plt.legend(handles=[\n", - " func1,\n", - " func_min\n", - "],\n", - " labels=[\n", - " r'$\\left\\langle {\\psi \\left( {\\theta } \\right)} '\n", - " r'\\right|H\\left| {\\psi \\left( {\\theta } \\right)} \\right\\rangle $',\n", - " 'Ground-state energy',\n", - " ], loc='best')\n", - "plt.text(-15.5, -1.145, f'{min_eig_H:.5f}', fontsize=10, color='b')\n", - "#plt.savefig(\"vqe.png\", bbox_inches='tight', dpi=300)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 通过 VQE 确定原子间隔\n", - "\n", - "还记得在前面的注释中提到我们默认使用的两个氢原子间原子间隔为 $74$ pm 吗？VQE 的另一个用法便是通过在不同的原子间隔下多次运行然后观察运行结果的最小值是在什么原子间隔发生的，这个间隔即为估计得真实原子间隔。\n", - "\n", - "![vqe-fig-dist](figures/vqe-fig-distance.png)\n", - "\n", - "从上图可以看出，最小值确实发生在 $d = 74$ pm (1 pm = $1\\times 10^{-12}$ m) 附近，这是与[实验测得数据](https://cccbdb.nist.gov/exp2x.asp?casno=1333740&charge=0)相符合的 $d_{exp} (H_2) = 74.14$ pm." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "_______\n", - "\n", - "## 参考文献\n", - "\n", - "[1] Cao, Yudong, et al. Quantum Chemistry in the Age of Quantum Computing. [Chemical reviews 119.19 (2019): 10856-10915.](https://pubs.acs.org/doi/10.1021/acs.chemrev.8b00803)\n", - "\n", - "[2] McArdle, Sam, et al. Quantum computational chemistry. [Reviews of Modern Physics 92.1 (2020): 015003.](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.92.015003)\n", - "\n", - "\n", - "[3] Peruzzo, A. et al. A variational eigenvalue solver on a photonic quantum processor. [Nat. Commun. 5, 4213 (2014).](https://www.nature.com/articles/ncomms5213)\n", - "\n", - "[4] Moll, Nikolaj, et al. Quantum optimization using variational algorithms on near-term quantum devices. [Quantum Science and Technology 3.3 (2018): 030503.](https://iopscience.iop.org/article/10.1088/2058-9565/aab822)\n", - "\n", - "[5] 徐光宪, 黎乐民, 王德民. 量子化学: 基本原理和从头计算法(上)[M], 第二版. 北京: 科学出版社, 2012; \n", - "\n", - "[6] Helgaker, Trygve, Poul Jorgensen, and Jeppe Olsen. Molecular electronic-structure theory. John Wiley & Sons, 2014.\n", - "\n", - "[7] Dirac, Paul Adrien Maurice. Quantum mechanics of many-electron systems. [Proceedings of the Royal Society of London. Series A, Containing Papers of a Mathematical and Physical Character 123.792 (1929): 714-733.](https://royalsocietypublishing.org/doi/10.1098/rspa.1929.0094)\n", - "\n", - "[8] Szabo, Attila, and Neil S. Ostlund. Modern quantum chemistry: introduction to advanced electronic structure theory. Courier Corporation, 2012." - ] - } - ], - "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.8.0" - }, - "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 -} diff --git a/tutorial/quantum_simulation/VQE_EN.ipynb b/tutorial/quantum_simulation/VQE_EN.ipynb deleted file mode 100644 index 3f6aa4a..0000000 --- a/tutorial/quantum_simulation/VQE_EN.ipynb +++ /dev/null @@ -1,558 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Variational Quantum Eigensolver\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Overview\n", - "\n", - "It is widely believed that one of the most promising applications of quantum computing in the near future is solving quantum chemistry problems [1-2]. **Variational Quantum Eigensolver** (VQE) is a strong proof to this possibility of studying quantum chemistry with **Noisy Intermediate-Scale Quantum** (NISQ) devices [1-4]. The core task is to solve the ground state of any molecular Hamiltonian $\\hat{H}$ by preparing a parametrized wave function ansatz $|\\Psi(\\boldsymbol\\theta)\\rangle$ on a quantum computer and adopt classical optimization methods (e.g. gradient descent) to adjust the parameters $\\boldsymbol\\theta$ to minimize the expectation value $\\langle \\Psi(\\boldsymbol\\theta)|\\hat{H}|\\Psi(\\boldsymbol\\theta)\\rangle$. This approach is based on the **Rayleigh-Ritz variational principle**. \n", - "\n", - "$$\n", - "E_0 = \\min_{\\boldsymbol\\theta} \\langle \\Psi(\\boldsymbol\\theta)|\\hat{H}|\\Psi(\\boldsymbol\\theta)\\rangle.\n", - "\\tag{1}\n", - "$$\n", - "\n", - "where $E_0$ denotes the ground state energy. Numerically, it can be understood as finding the smallest eigenvalue $\\lambda_{\\min}$ of a **discretized** Hamiltonian $H$ (hermitian matrix) and its corresponding eigenvector $|\\Psi_0\\rangle$. How such a discretization can be done on a classical computer belongs to the art of quantum chemistry and is far beyond the scope of this tutorial. We will discuss this part with a few words in the background section. In general, such a Hamiltonian $H$ is expressed as a weighted sum of Pauli spin operators $\\{X,Y,Z\\}$ (native to quantum devices) such that this information can be processed on a quantum computer.\n", - "\n", - "$$\n", - "H = \\sum_k c_k ~ \\bigg( \\bigotimes_{j=0}^{M-1} \\sigma_j^{(k)} \\bigg),\n", - "\\tag{2}\n", - "$$\n", - "\n", - "where $\\sigma_j^{(k)} \\in \\{I,X,Y,Z\\}$ and $M$ stands for qubit number. We refer this form of Hamiltonian as **Pauli strings**. For example, \n", - "\n", - "$$\n", - "H= 0.12~Y_0 \\otimes I_1-0.04~X_0\\otimes Z_1.\n", - "\\tag{3}\n", - "$$\n", - "\n", - "In the next section, we will provide a brief review on the electronic structure problem which essentially tells us how to calculate the Hamiltonian $H$. For those who are already familiar with this topic or only interested in how to implement VQE on Paddle Quantum, please skip this part and jump into the illustrative example of hydrogen molecule $H_2$.\n", - "\n", - "## Background: the electronic structure problem\n", - "\n", - "In this section, we focus on one of the fundamental problems in quantum chemistry -- **the electronic structure problem**. To be more specific, we are interested in the low lying energy eigenstates of any given molecule. These knowledge could help predict reaction rates and location of stable structures [5]. Suppose a molecule consists of $N_n$ nuclei and $N_e$ electrons, the first quantized (canonical quantization) Hamiltonian operator $\\hat{H}_{mol}$ describing the total energy of this molecular system can be written as\n", - "\n", - "$$\n", - "\\begin{align}\n", - "\\hat{H}_{\\text{mol}} & = -\\sum_{i}\\frac{\\nabla_{R_i}^2}{2M_i} - \\sum_{i} \\frac{\\nabla_{r_i}^2}{2} -\\sum_{i,j}\\frac{Z_i}{\\lvert R_i - r_j\\lvert} + \\sum_{i,j>i}\\frac{Z_iZ_j}{\\lvert R_i - R_j\\lvert} + \\sum_{i, j>i}\\frac{1}{\\lvert r_i - r_j\\lvert}, \n", - "\\tag{4}\n", - "\\end{align}\n", - "$$\n", - "\n", - "where $R_i, M_i,$ and $Z_i$ denote the position, mass and atomic number (the number of protons) of the $i^{th}$ nucleus, and the positions of electrons are $r_i$. The first two sums describe the kinetic energy of nuclei and electrons, respectively. The third sum describes the attractive Coulomb interaction between the positively charged nuclei and the negatively charged electrons. The last two terms represent the repulsive nuclei-nuclei and electron-electron interactions. Here, the molecular Hamiltonian $\\hat{H}_\\text{mol}$ is already in atomic units of energy, **Hartree**. $1$ Hartree is $[\\hbar^2/(m_ee^2a_0^2)] = 27.2$ eV or $630$ kcal/mol, where $m_e, e,$ and $a_0$ stand for the mass of electron, charge of electron, and Bohr radius. \n", - "\n", - "\n", - "**Note:** The spin-orbit interaction and hyperfine interaction are not considered in this picture. They can be treated as perturbations if necessary. \n", - "\n", - "### Born-Oppenheimer approximation\n", - "\n", - "Since the nuclei are much heavier than electrons, the electrons will move much faster than the nuclei. It is reasonable to treat the positions of nuclei as fixed, $R_i =$ constants. This is known as the Born-Oppenheimer approximation by decoupling the behavior of nuclei and electrons in time scale. Consequently, the kinetic energy term of nuclei will disappear and the nuclei-nuclei repulsive interaction term can be viewed as an energy shift (independent of electron positions $r_i$). We could derive the electronic Hamiltonian $\\hat{H}_{\\text{electron}}$ as\n", - "\n", - "$$\n", - "\\begin{align}\n", - "\\hat{H}_{\\text{electron}} & = - \\sum_{i} \\frac{\\nabla_{r_i}^2}{2} -\\sum_{i,j}\\frac{Z_i}{\\lvert R_i - r_j\\lvert} + \\sum_{i, j>i}\\frac{1}{\\lvert r_i - r_j\\lvert} \n", - "\\tag{5},\n", - "\\end{align}\n", - "$$\n", - "\n", - "The energy levels of the electrons in the molecule can be found by solving the time independent Schrödinger equation\n", - "\n", - "$$\n", - "\\hat{H}_{\\text{electron}} |\\Psi_n \\rangle = E_n |\\Psi_n \\rangle,\n", - "\\tag{6}\n", - "$$\n", - "\n", - "where $n$ stands for the energy level. Notice the electron repulsion terms scale as $N_e(N_e-1)/2$ which means for the Oxygen molecule $O_2$ carrying 16 electrons there will be 120 electron repulsion terms in total! In general, this problem cannot be solved analytically. As Dirac concluded in [Quantum mechanics of many-electron systems](https://royalsocietypublishing.org/doi/10.1098/rspa.1929.0094) [6],\n", - "\n", - "> *The underlying physical laws necessary for the mathematical theory of a large part of physics and the whole of chemistry are thus completely known, and the difficulty is only that the exact application of these laws leads to equations much too complicated to be soluble.* \n", - ">\n", - "> ​\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t-- Paul Dirac (1929)\n", - "\n", - "A straightforward numerical approach is discretizing the infinite-dimensional Hilbert space into equidistant grid points where linear algebra guides the whole calculation. Suppose each axis of space is discretized into $k$ points, the $N$-electron (drop the subscript e for simplicity) wave function can be written as [2]\n", - "\n", - "$$\n", - "|\\Psi \\rangle = \\sum_{\\mathbf{x_1}, \\ldots, \\mathbf{x_N}} \\psi(\\mathbf{x_1}, \\ldots, \\mathbf{x_N}) \\mathcal{A}(|\\mathbf{x_1}, \\ldots, \\mathbf{x_N}\\rangle).\n", - "\\tag{7}\n", - "$$\n", - "\n", - "where coordinate $|\\mathbf{x_j}\\rangle = |r_j\\rangle |\\sigma_j\\rangle$ records the spatial location and spin of the $j^{th}$ electron, $|r_j\\rangle = |x_j,y_j,z_j\\rangle$ for $j\\in \\{1,2,\\cdots,N\\}$, $x_j,y_j,z_j \\in \\{0,1,\\cdots,k-1\\}$ and $\\sigma_j \\in \\{\\downarrow,\\uparrow\\}$ for spin down or up. There will be $k^{3N}\\times 2^{N}$ complex amplitudes in total. Here, $\\mathcal{A}$ denotes anti-symmetrization and a consequence of the Pauli exclusion principle (electrons are fermion), and $\\psi(\\mathbf{x_1}, \\mathbf{x_2}, \\ldots, \\mathbf{x_N})=\\langle\\mathbf{x_1}, \\mathbf{x_2}, \\ldots, \\mathbf{x_N}|\\Psi\\rangle$. One can see that storing such a wave function already requires **exponentially growing memory** with respect to the number of electrons $N$. This would make classical simulation methods based on this naive numerical approach intractable for systems size larger than few tens of electrons. Now, the question becomes can we prepare such a wave function $|\\Psi\\rangle$ directly on a quantum computer and measure the expectation value $E_0$? In the next section, let's take the simplest molecular system -- hydrogen molecule $H_2$ as a concrete example.\n", - "\n", - "\n", - "\n", - "**Note:** A detailed review on quantum chemistry and existing classical computational methods are far beyond the scope of this tutorial, we refer the enthusiastic readers to the standard textbooks *'Molecular Electronic-Structure Theory'* [5] by Helgaker and *'Modern Quantum Chemistry: Introduction to Advanced Electronic Structure Theory'* [7] by Szabo & Ostlund. To bridge to knowledge gap between quantum chemistry and quantum computing, please check the following review papers [Quantum computational chemistry](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.92.015003) [2] and [Quantum Chemistry in the Age of Quantum Computing](https://pubs.acs.org/doi/10.1021/acs.chemrev.8b00803) [1].\n", - "\n", - "**Note:** For energy calculation, it is desired to reach the **chemical accuracy** of $1.6\\times10^{-3}$ Hartree or 1 kcal/mol . " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Ground state of the hydrogen molecule $H_2$\n", - "\n", - "### Building electronic Hamiltonian\n", - "\n", - "First of all, let us import the necessary libraries and packages.`qchem` module in Paddle Quantum is developed basing on `psi4` and `openfermion`, so you need to install these two packages before executing the following codes. We strongly encourage you to read the tutorial [Building molecular Hamiltonian](./BuildingMolecule_EN.ipynb) first, which introduces how to utilize our quantum chemistry toolkit `qchem`.\n", - "\n", - "**Note: As to the environment setting, please refer to [README.md](https://github.com/PaddlePaddle/Quantum/blob/master/README.md).**" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:14:44.970178Z", - "start_time": "2021-04-30T09:14:40.895128Z" - } - }, - "outputs": [], - "source": [ - "import paddle\n", - "import paddle_quantum.qchem as qchem\n", - "from paddle_quantum.utils import Hamiltonian\n", - "from paddle_quantum.circuit import UAnsatz\n", - "\n", - "import os\n", - "import matplotlib.pyplot as plt\n", - "\n", - "import numpy\n", - "from numpy import pi as PI\n", - "from numpy import savez, zeros\n", - "\n", - "# Eliminate noisy python warnings\n", - "import warnings\n", - "warnings.filterwarnings(\"ignore\")" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "To analyze specific molecules, we need several key information such as **geometry**, **basis set** (such as STO-3G), **multiplicity**, and **charge** to model the molecule and achieve more information about the molecule, such as one-body integrations, two-body integrations, and others. Next, through our built-in quantum chemistry toolkit, we could set a `Hamiltonian` class to carry molecule Hamiltonian information, which may simplify the following calculations." - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:14:44.982005Z", - "start_time": "2021-04-30T09:14:44.975892Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "FCI energy for H2_sto-3g_singlet (2 electrons) is -1.1372838344855134.\n", - "\n", - "The generated h2 Hamiltonian is \n", - " -0.0970662686176252 I\n", - "-0.04530261550868938 X0, X1, Y2, Y3\n", - "0.04530261550868938 X0, Y1, Y2, X3\n", - "0.04530261550868938 Y0, X1, X2, Y3\n", - "-0.04530261550868938 Y0, Y1, X2, X3\n", - "0.1714128263940238 Z0\n", - "0.16868898168693292 Z0, Z1\n", - "0.12062523481381847 Z0, Z2\n", - "0.1659278503225078 Z0, Z3\n", - "0.17141282639402383 Z1\n", - "0.1659278503225078 Z1, Z2\n", - "0.12062523481381847 Z1, Z3\n", - "-0.22343153674664024 Z2\n", - "0.17441287610651632 Z2, Z3\n", - "-0.2234315367466403 Z3\n" - ] - } - ], - "source": [ - "geo = qchem.geometry(structure=[['H', [-0., 0., 0.0]], ['H', [-0., 0., 0.74]]])\n", - "# geo = qchem.geometry(file='h2.xyz')\n", - "\n", - "# Save molecule information in to variable molecule, including one-body integrations, one-body integrations, molecular and Hamiltonian\n", - "molecule = qchem.get_molecular_data(\n", - " geometry=geo,\n", - " basis='sto-3g',\n", - " charge=0,\n", - " multiplicity=1,\n", - " method=\"fci\",\n", - " if_save=True,\n", - " if_print=True\n", - ")\n", - "# Recall Hamiltonian\n", - "molecular_hamiltonian = qchem.spin_hamiltonian(molecule=molecule,\n", - " filename=None, \n", - " multiplicity=1, \n", - " mapping_method='jordan_wigner',)\n", - "# Print results\n", - "print(\"\\nThe generated h2 Hamiltonian is \\n\", molecular_hamiltonian)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Note:** This Hamiltonian is generated with an interatomic distance of $d = 74$ pm. \n", - "\n", - "In addition to inputting molecular geometry directly, inputting molecular geometry file (.xyz file) is also allowed. For more information about quantum chemistry toolkit, please refer to the tutorial [Building molecular Hamiltonian](./BuildingMolecule_EN.ipynb). If you need to test the geometric configuration of more molecules, please check out this [database](http://smart.sns.it/molecules/index.html)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Building QNN and trial wave function\n", - "\n", - "To implement VQE, we firstly need to design a quantum neural network QNN to prepare the wave function ansatz $|\\Psi(\\boldsymbol\\theta)\\rangle$. Here, we provide a 4-qubit quantum circuit template with a depth of $D$ blocks. The dotted frame in the figure below denotes a single block:\n", - "\n", - "\n", - "![Utheta.jpg](https://release-data.cdn.bcebos.com/PIC%2FUtheta.jpg)\n", - "\n", - "Next, we use the `UAnsatz` class and the built-in `real_entangled_layer(theta, D)` circuit template in Paddle Quantum to realize this QNN.\n", - "\n" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:14:50.083041Z", - "start_time": "2021-04-30T09:14:50.062255Z" - } - }, - "outputs": [], - "source": [ - "def U_theta(theta, Hamiltonian, N, D):\n", - " \"\"\"\n", - " Quantum Neural Network\n", - " \"\"\"\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", - " 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 |0000>\n", - " fin_state = cir.run_state_vector()\n", - " \n", - " # Calculate the expectated value of the given Hamiltonian\n", - " expectation_val = cir.expecval(Hamiltonian)\n", - "\n", - " return expectation_val, cir, fin_state" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Setting up the loss function and model\n", - "\n", - "Now that we have the target Hamiltonian and QNN, we will further define the training model and loss function. By applying the QNN $U(\\theta)$ on the initial state $|0..0\\rangle$, we get the output state $|\\psi(\\boldsymbol\\theta)\\rangle $. Then, the loss function to be minimized is the expectation value, \n", - "\n", - "\n", - "$$\n", - "\\min_{\\boldsymbol\\theta} \\mathcal{L}(\\boldsymbol \\theta) = \\min_{\\boldsymbol\\theta} \\langle \\Psi(\\boldsymbol\\theta)|H |\\Psi(\\boldsymbol\\theta)\\rangle\n", - "= \\min_{\\boldsymbol\\theta} \\sum_k c_k~\\langle \\Psi(\\boldsymbol\\theta)| \\bigotimes_j \\sigma_j^{(k)}|\\Psi(\\boldsymbol\\theta)\\rangle.\n", - "\\tag{8}\n", - "$$" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:14:50.183996Z", - "start_time": "2021-04-30T09:14:50.167892Z" - } - }, - "outputs": [], - "source": [ - "class StateNet(paddle.nn.Layer):\n", - " \"\"\"\n", - " Construct the model net\n", - " \"\"\"\n", - "\n", - " def __init__(self, shape, dtype=\"float64\"):\n", - " super(StateNet, self).__init__()\n", - " \n", - " # Initialize the list of theta parameters, filling the initial values with a uniform distribution of [0, 2* PI] \n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # Define loss function and forward propagation mechanism\n", - " def forward(self, N, D):\n", - " \n", - " # Calculate loss function/expected value\n", - " loss, cir, fin_state = U_theta(self.theta, molecular_hamiltonian.pauli_str, N, D)\n", - "\n", - " return loss, cir, fin_state" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Hyper-parameters\n", - "\n", - "Before training the QNN, we also need to set some training hyper-parameters, mainly the learning rate (LR), the number of iterations (ITR), and the depth (D) of repeated blocks. " - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:14:50.222465Z", - "start_time": "2021-04-30T09:14:50.187093Z" - } - }, - "outputs": [], - "source": [ - "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 = molecular_hamiltonian.n_qubits # Set number of qubits" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Training\n", - "\n", - "After all the training model parameters are set, we convert the data into Tensor in the Paddle, and then train the quantum neural network. The results of the training process is stored in the summary_data file.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:15:52.165788Z", - "start_time": "2021-04-30T09:15:29.625076Z" - } - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "iter: 20 loss: -1.0487\n", - "iter: 20 Ground state energy: -1.0487 Ha\n", - "iter: 40 loss: -1.1070\n", - "iter: 40 Ground state energy: -1.1070 Ha\n", - "iter: 60 loss: -1.1152\n", - "iter: 60 Ground state energy: -1.1152 Ha\n", - "iter: 80 loss: -1.1165\n", - "iter: 80 Ground state energy: -1.1165 Ha\n", - "\n", - "Circuit after training:\n", - "--Ry(4.725)----*--------------x----Ry(-0.01)----*--------------x----Ry(-1.56)--\n", - " | | | | \n", - "--Ry(4.718)----x----*---------|----Ry(3.132)----x----*---------|----Ry(4.703)--\n", - " | | | | \n", - "--Ry(4.720)---------x----*----|----Ry(3.124)---------x----*----|----Ry(4.721)--\n", - " | | | | \n", - "--Ry(1.574)--------------x----*----Ry(6.291)--------------x----*----Ry(1.552)--\n", - " \n" - ] - } - ], - "source": [ - "# Determine the parameter dimensions of the network \n", - "net = StateNet(shape=[D + 1, N, 1])\n", - "\n", - "# In general, we use the Adam optimizer to obtain relatively good convergence,\n", - "# Of course 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", - "# Optimize iterations\n", - "for itr in range(1, ITR + 1):\n", - "\n", - " # Forward propagation calculates the loss function\n", - " loss, cir, fin_state = net(N, D)\n", - "\n", - " # Back propagation minimizes the loss function\n", - " loss.backward()\n", - " opt.minimize(loss)\n", - " opt.clear_grad()\n", - "\n", - " # Update optimization results\n", - " summary_loss.append(loss.numpy())\n", - " summary_iter.append(itr)\n", - "\n", - " # Print results\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(\"\\nCircuit after training:\") \n", - " print(cir)\n", - "\n", - "# Save the training results in the Output folder\n", - "os.makedirs(\"output\", exist_ok=True)\n", - "savez(\"./output/summary_data\", iter = summary_iter, \n", - " energy=summary_loss)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Benchmarking\n", - "We have now completed the training of the quantum neural network, and the estimated value of the ground state energy obtained is $E_0 \\approx -1.137 $ Hartree. The estimation obtained with VQE is consistent with the value of the ground state energy $E_0 = -1.13728$ Hartree calculated by `Psi4` at sto-3g basis using the full configuration-interaction (FCI) method within the chemical accuracy $\\varepsilon = 1.6 \\times 10^{-3}$ Hartree.\n" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:15:18.096944Z", - "start_time": "2021-04-30T09:15:17.481250Z" - } - }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "result = numpy.load('./output/summary_data.npz')\n", - "\n", - "eig_val, eig_state = numpy.linalg.eig(\n", - " molecular_hamiltonian.construct_h_matrix())\n", - "min_eig_H = numpy.min(eig_val.real)\n", - "min_loss = numpy.ones([len(result['iter'])]) * min_eig_H\n", - "\n", - "plt.figure(1)\n", - "func1, = plt.plot(result['iter'], result['energy'], \n", - " alpha=0.7, marker='', linestyle=\"-\", color='r')\n", - "func_min, = plt.plot(result['iter'], min_loss, \n", - " alpha=0.7, marker='', linestyle=\":\", color='b')\n", - "plt.xlabel('Number of iteration')\n", - "plt.ylabel('Energy (Ha)')\n", - "\n", - "plt.legend(handles=[\n", - " func1,\n", - " func_min\n", - "],\n", - " labels=[\n", - " r'$\\left\\langle {\\psi \\left( {\\theta } \\right)} '\n", - " r'\\right|H\\left| {\\psi \\left( {\\theta } \\right)} \\right\\rangle $',\n", - " 'Ground-state energy',\n", - " ], loc='best')\n", - "plt.text(-15.5, -1.145, f'{min_eig_H:.5f}', fontsize=10, color='b')\n", - "#plt.savefig(\"vqe.png\", bbox_inches='tight', dpi=300)\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Determining the interatomic distance\n", - "\n", - "Recall the above calculation is done with an interatomic distance $d = 74$ pm between two hydrogen atoms. Another interesting aspect we can try with VQE is determining the true interatomic distance by modifying the `h2.xyz` file. The results are summarize in figure below,\n", - "\n", - "![vqe-fig-dist](figures/vqe-fig-distance.png)\n", - "\n", - "The lowest value is found around $d = 74$ pm (1 pm = $1\\times 10^{-12}$m), which is consistent with the [experimental data](https://cccbdb.nist.gov/exp2x.asp?casno=1333740&charge=0) $d_{exp} (H_2) = 74.14$ pm." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "_______\n", - "\n", - "## References\n", - "\n", - "[1] Cao, Yudong, et al. Quantum Chemistry in the Age of Quantum Computing. [Chemical reviews 119.19 (2019): 10856-10915.](https://pubs.acs.org/doi/10.1021/acs.chemrev.8b00803)\n", - "\n", - "[2] McArdle, Sam, et al. Quantum computational chemistry. [Reviews of Modern Physics 92.1 (2020): 015003.](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.92.015003)\n", - "\n", - "\n", - "[3] Peruzzo, A. et al. A variational eigenvalue solver on a photonic quantum processor. [Nat. Commun. 5, 4213 (2014).](https://www.nature.com/articles/ncomms5213)\n", - "\n", - "[4] Moll, Nikolaj, et al. Quantum optimization using variational algorithms on near-term quantum devices. [Quantum Science and Technology 3.3 (2018): 030503.](https://iopscience.iop.org/article/10.1088/2058-9565/aab822)\n", - "\n", - "[5] Helgaker, Trygve, Poul Jorgensen, and Jeppe Olsen. Molecular electronic-structure theory. John Wiley & Sons, 2014.\n", - "\n", - "[6] Dirac, Paul Adrien Maurice. Quantum mechanics of many-electron systems. [Proceedings of the Royal Society of London. Series A, Containing Papers of a Mathematical and Physical Character 123.792 (1929): 714-733.](https://royalsocietypublishing.org/doi/10.1098/rspa.1929.0094)\n", - "\n", - "[7] Szabo, Attila, and Neil S. Ostlund. Modern quantum chemistry: introduction to advanced electronic structure theory. Courier Corporation, 2012." - ] - } - ], - "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.8.0" - }, - "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": { - "height": "calc(100% - 180px)", - "left": "10px", - "top": "150px", - "width": "426.667px" - }, - "toc_section_display": true, - "toc_window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_CN.ipynb b/tutorials/combinatorial_optimization/ArbitrageOpportunityOptimation_CN.ipynb similarity index 96% rename from tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_CN.ipynb rename to tutorials/combinatorial_optimization/ArbitrageOpportunityOptimation_CN.ipynb index a1b3dc6..9e4669d 100644 --- a/tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_CN.ipynb +++ b/tutorials/combinatorial_optimization/ArbitrageOpportunityOptimation_CN.ipynb @@ -2,26 +2,27 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "source": [ "# 量子金融应用：最佳套利机会\n", "\n", " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## 概览\n", "\n", "当前量子计算应用到金融问题上的解决方案通常可分为三类量子算法，即量子模拟，量子优化以及量子机器学习 [1,2]。许多的金融问题本质上是一个组合优化问题，解决这些问题的算法通常具有较高的时间复杂度，实现难度较大。得益于量子计算强大的计算性能，未来有望通过量子算法解决这些复杂问题。\n", "\n", "量桨的 Quantum Finance 模块主要讨论的是量子优化部分的内容，即如何通过一些量子算法解决实际金融应用中的优化问题。本文主要介绍如何使用量子算法求解最佳套利机会问题 [3]。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## 最佳套利机会问题\n", "\n", @@ -30,11 +31,11 @@ "这个问题可以用图论的语言来描述：给定一个带权重的有向图 $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", + "metadata": {}, "source": [ "## 编码最佳套利机会问题\n", "\n", @@ -79,21 +80,27 @@ "这里 $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", + "metadata": {}, "source": [ "## Paddle Quantum 实现\n", "\n", "要在量桨上实现用参数化量子电路解决量子金融中的最佳套利机会问题，首先要做的便是加载需要用到的包。其中 `networkx` 包可以帮助我们方便地查看和处理图。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + }, + "outputs": [], "source": [ "#加载需要的包\n", "import numpy as np\n", @@ -102,29 +109,41 @@ "\n", "#加载飞桨，量桨相关的模块\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\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", + "metadata": {}, "source": [ "接下来，我们先生成用于最佳套利机会问题的图 $G$。为了运算方便，图中的顶点从0开始计数。\n", "\n", "同时，为了方便运算验证，这里构造的加权有向图中对权值做了特殊设定。在实际使用过程中用户可以自行构造需要计算的货币类型，设置真实的货币汇率。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.212260Z", + "start_time": "2021-05-17T08:00:15.918792Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# n 代表图形 G 的顶点数量————指不同国家的货币\n", "n = 3\n", @@ -162,38 +181,27 @@ "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", + "metadata": {}, "source": [ "### 编码哈密顿量\n", "\n", "这里我们将式（4）中的二进制变量用式（5）替换，从而构建哈密顿量 $H_C$。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.237497Z", + "start_time": "2021-05-17T08:00:16.219567Z" + } + }, + "outputs": [], "source": [ "# 惩罚参数 等于构造的有向图中权值最大的边\n", "penalty = 4 \n", @@ -201,21 +209,15 @@ "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", + "metadata": {}, "source": [ "### 计算损失函数\n", "\n", - "我们使用 $U_3(\\vec{\\theta})$ 和 $\\text{CNOT}$ 门构造的参数化量子电路，通过调用量桨内部的 [`complex entangled layer`](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html) 来实现。\n", + "我们使用 $U_3(\\vec{\\theta})$ 和 $\\text{CNOT}$ 门构造的参数化量子电路，通过调用量桨内部的 [`complex_entangled_layer()`](https://qml.baidu.com/api/paddle_quantum.ansatz.circuit.html#Circuit.complex_entangled_layer) 来实现。\n", "\n", "上述电路会给出一个输出态 $|\\vec{\\theta}\\rangle$，由此输出态，我们可以定义最佳套利机会问题在经典-量子混合模型下的损失函数：\n", "\n", @@ -225,98 +227,78 @@ "$$\n", "\n", "之后我们利用经典的优化算法寻找最优参数 $\\vec{\\theta}^*$。下面的代码给出了通过量桨和飞桨搭建的完整网络：" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.258893Z", + "start_time": "2021-05-17T08:00:16.241066Z" + } + }, + "outputs": [], "source": [ "class AONet(paddle.nn.Layer):\n", "\n", - " def __init__(self, n, p, K, dtype=\"float64\"):\n", + " def __init__(self, num_qubits, p, 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", + " self.depth = p\n", + " self.num_qubits = num_qubits\n", + " self.cir = Circuit(self.num_qubits)\n", + " self.cir.complex_entangled_layer(depth=self.depth)\n", + " \n", "\n", - " def forward(self, hamiltonian):\n", + " def forward(self):\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" - } - } + " # 运行电路\n", + " state = self.cir(init_state)\n", + " # 计算损失函数\n", + " loss = loss_func(state)\n", + " \n", + " return loss, self.cir" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 训练量子神经网络\n", "\n", "定义好了量子神经网络后，我们使用梯度下降的方法来优化其中的参数，使得式（6）的期望值最小。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 6, + "metadata": {}, + "outputs": [], "source": [ "SEED = 100 # 随机数种子\n", "p = 1 # 量子电路的层数\n", "ITR = 120 # 迭代次数\n", "LR = 0.4 # 梯度下降优化速率 " - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "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())" - ], + "execution_count": 9, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "循环数： 10 损失: 0.4704\n", "循环数： 20 损失: 0.1302\n", @@ -333,10 +315,34 @@ ] } ], - "metadata": {} + "source": [ + "# 固定 paddle 随机种子\n", + "paddle.seed(SEED)\n", + "# 定义电路所需比特数\n", + "num_qubits = n * K\n", + "# 定义量子神经网络\n", + "net = AONet(num_qubits, p)\n", + "# 定义初始态\n", + "init_state = paddle_quantum.state.zero_state(num_qubits)\n", + "# 使用 Adam 优化器\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "# 定义损失函数\n", + "loss_func = paddle_quantum.loss.ExpecVal(hamiltonian)\n", + "# 梯度下降优化循环\n", + "for itr in range(1, ITR + 1):\n", + " # 运行上面定义的网络\n", + " loss, cir = net()\n", + " #计算梯度并优化\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + " if itr % 10 == 0:\n", + " print(\"循环数：\", itr, \" 损失:\", \"%.4f\"% loss.numpy())" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 解码量子答案\n", "\n", @@ -350,76 +356,94 @@ "在量子参数化电路表达能力足够的情况下，某个比特串出现的概率越大，意味着其是最佳套利机会问题最优解的可能性越大。\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)" - ], + "execution_count": 12, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "利用哈密顿量找到的解的比特串形式： 100001010\n" ] } ], - "metadata": {} + "source": [ + "# 模拟重复测量电路输出态 1024 次\n", + "final_state = cir(init_state)\n", + "prob_measure = final_state.measure(shots=1024)\n", + "arbitrage_opportunity_route = max(prob_measure, key=prob_measure.get)\n", + "print(\"利用哈密顿量找到的解的比特串形式：\", arbitrage_opportunity_route)" + ] }, { "cell_type": "markdown", + "metadata": {}, "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)" - ], + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:02:14.554317Z", + "start_time": "2021-05-17T08:02:14.500593Z" + } + }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "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" - } - } + "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)" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "为了清晰地表达资产的交易路径，依然选择以图的形式呈现：\n", "* 顶点中的数字代表交易到该货币市场的顺序，字母代表不同的货币类型\n", "* 红色的有向边表示找到的最佳路线" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:02:14.571954Z", + "start_time": "2021-05-17T08:02:14.559634Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1MAAADnCAYAAAD7CwxiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA4PUlEQVR4nO3deXiU9b3//+d9ZyaTjQAh7IRA2BeVYgLI4sJSScT14FrUywWX6jnaY63oOWgrHvXXWrUesRWqbYW6Yn+1aoKCcARRCIsLu0hCSNhDlJB9lvv7x5BADGGGMMlsr8d1cZXMfefOZ+LVefO635/78zEsy7IQERERERGR02IGewAiIiIiIiLhSGFKRERERESkBRSmREREREREWkBhSkREREREpAUUpkRERERERFpAYUpERERERKQFFKZERERERERaQGFKRERERESkBRSmREREREREWkBhSkREREREpAUUpkRERERERFpAYUpERERERKQFFKZERERERERaQGFKRERERESkBRSmREREREREWkBhSkREREREpAUUpkRERERERFpAYUpERERERKQFFKZERERERERaQGFKRERERESkBWzBHkCo8ngsisqqKCytoMbpwen2YI8xibOb9E1NIj0lAdM0gj1MERGRNqX6KCJynMLUMR6PxaqdpSzbdpC1u8rYcbAC0zCwmQYWFpYFhgEGBi6PhceyGNAliaw+KUwc3IVx/VJVPEREJOKoPoqINM+wLMsK9iCC6Ui1k7fXFTN/ZQGVtS6q6tyczi/EABJiY0h02Jg5IYNrMtNoH29vreGKiIi0CdVHERHfojZMVde5eSpvK2+tK8YwoMbpOeNrxttNPBZcm5nGw9lDiI+NCcBIRURE2o7qo4iI/6IyTOUXlnHvGxsor3ZS4zrzIvFjcTaT5Hg7c28YSVaflIBfX0REpDWoPoqInJ6oClO1LjdzPtjCog0lAbnT5kuc3WT6yF7MnjYUh0134UREJDSpPoqItEzUhKnKWhczXlnD1n3lrXK3rTlxNpOhPZJZcOtoEh1a70NEREKL6qOISMtFRZiqrHUx/eXPKThUSW0bFop6DptJRudEFt05VgVDRERChuqjiMiZifhNe2tdbma8siZohcI7Bg8Fhyq58dU11LrcQRmDiIjIiVQfRUTOXMSHqTkfbGHrvvKgFYp6tS4PW/aWM+eDrUEdh4iICKg+iogEQkSHqfzCMu/DtEEuFPVqXB4WbShm7a6yYA9FRESimOqjiEhgRGyYqq5zc+8bG9pkVaLTUeP0cM/rG6iu03QGERFpe6qPIiKBE7Fh6sm8rZRXO4M9jJMqr3by1GJNZxARkban+igiEjgRGaaOVDt5e11xyExf+LEal4e31hZzJESLmYiIRCbVRxGRwIrIMPX2umIMI9ijODXTgHfWFQd7GCIiEkVUH0VEAiviwpTHYzF/ZUHIzQX/sWqnh3krC/B4In6bLxERCQGqjyIigRdxYWrVzlIqa13BHoZfKmpdfF5wONjDEBGRKKD6KCISeBEXppZtO0hVmKwEVO10s2zbwWAPQ0REooDqo4hI4EVcmFq7q4xwmRhgWbB2l+68iYhI61N9FBEJPFuwBxBIHo/FjoMVDV+fm96Ruy/ox7npHUmwx7C/vIbl2w/xP7lbcLotdj11CQCb9x7hkv/9DICfDu3KvBszKfm+ivG/Xc5bM8cwOqMTS7YcYOaCdQB0TLCz7IEL6ZgQy5wPt/DKZ4XNjumyc3owY3Q6/TonkhBrY3dZFa+sKuTtYw/XfnugAsuyMEL9iWAREQlbqo8iIq0jojpTRWVVmMc+dC89uztvzRzD5CFd2fdDNf/4cg+7y6r42ejexNtjGn3fsB7tuXhYt5Ne8+H/fyO1TjdThnZl8pAuADySPYSOCbF8VfwDf1nVfKEAOH9AKr06xrNiRylri8oY1K0dv/23s5k02Hst0zAoOlx1pm9dRESkWaqPIiKtI6I6U4WlFdhMgzi7yeOXD8cWY/KPL0t44J2vsY7NbeidkkC1s/GccY/H4v5JA/ho8/4m1yworeSFZd/x4MWDeGzaMGqcHv5tZC+cbg+z/vENvhYbenXVLn717vHz3pw5hjEZnRg/IJVPth3EZhoUllbSJzUxEL8CERGRJlQfRURaR0R1pmqcHiwsMtNT6JgQC8CLy75rKBQAu8uqcLobf8LnbtrHkO7J5Aw/+d23l1fsZOu+ctJSEnjl5kxM02DeigK27T/qc0xb9pU3Kij2GO+vfP+RGgAsoMYVHg8Ei4hIeFJ9FBFpHREVppxuD5YFnZJiG17b80O1z+/76+e7OFxRy32TBp50brbLYzHrH9/g9lg4bDEUlFbwwrIdpz2+28b35dz0jhSWVvL3NbsBsCyLuhDdiV5ERCKD6qOISOuIqDBljzExDDhcUdfwWs8O8T6/r6rOzbyVBQzq1o5pZ3U/6TlflxxhfdH3ALy+Zje1p/kBf/+kAcy+ZChFhyv52Z9XU3Fsrw/DMIi1RdR/BhERCTGqjyIirSOiPqXi7CYGBuuLvueHKm/BuHdif068mdazQzw2s+ndtb99sYtDR2u5pJliAeA5Nh/CY/m/uKxhwJzLh3P/5IFs2nOE6X/6gr3HpjAAGECcLab5C4iIiJwh1UcRkdYRUQtQ9E1NwuWxqHa6eez9zTx79Qiu+kkvBndtx1clR+ia7GB8/1Sy/mcp5TWNd4GvcXp4ecVO/vuSoX7/vF4d4vnsoYkAnP2bj5pcE+CBKYO4cUw6bo/F5r3l3H1hPwB2Ha7ktS+KcHks+urhWhERaUWqjyIirSOiwlR6SkLDXbH3vtrLvh9quOuCfozs3YF+XZLYf6SGN9cWN1mtqN6C1UXcMSGDLslx/v3AYzfwPB4LdzPLFnVLdgAQYxpcm5XW8PrqgsO89kURHssivVOCn+9QRETk9Kk+ioi0DsOyTqMnHwam/e9KNu0tb5OfNWVIV+bflMlrX+zi0X9tbtE1zuqZzPv3TsDj8bBz506++uorvvnmGzIzM7n88ssDPGIREYlWYVcfk03ef2ASxMb6PllEJEgiqjMFkNUnhc17y2mLhDi2fyd2Ha7kqbxtLfp+w4CesTV06dKFH374AafT2XAsLS1NYUpERAImrOqjx0PW0n/Ck9fApEmQne3907t3YAcqInKGImoBCoCJg7uQENs2D6z+5v0tXPjM/zU7LcKXeHsMtYXrOXToUKMgBZCamsqePXsCMUwREZHwqo8xMNFTChUV8N57cNddkJ4Ow4bBgw/CsmVQV+f7QiIirSziwtS4fqkkOsKj4dbOYWP+nAe55pprmhz78ssv6dWrF+eccw4PP/wwK1asaBK4RERE/BVW9TEpnrGf/AN274Z58+DKK6FdO9iyBZ55xtut6tQJrrgCXn7Ze56ISBBE3DNTAPNXFvD7JdupcYbuZn/xdpMHpgzi9gkZWJbFb3/7W2bNmtVwfPLkyXz++edUVVU1vJacnMyUKVPIzs5m6tSp9OzZMxhDFxGRMBVu9bGRujpYtQry8rx/Nm1qfHzoUMjJ8U4HHD9ez1qJSJuIyDB1pNrJqCeXnvbGgW3JYTPJf2Qy7ePtDa+98sor3HHHHYwaNYovvviC2tpaVqxYQV5eHnl5eWzb1nju+dlnn01OTg7Z2dmcd9552O32H/8YERGRBuFaH0+quBgWL/YGq6VL4ejR48eSkvSslYi0iYgMUwCPvreJt9cVUxOCBSPOZnJNVhqPXza8ybGCggJSUlLo0KFDk2O7du1qCFaffPKJulYiInLawrU+npK6ViISJBEbpqrr3FzwzHIOHq0N9lCa6Jrs4P8euIj4M3gQWF0rERFpiUivj0DjrtWSJd6FLOqpayUiARSxYQpg7a4ybnx1TUjNDY+zmyy8dTSZfVICel11rURExF/RVB/VtRKR1hTRYQrgv/+5kUXrS0JiOkOczWT6uWk8ccVpTl84TTU1NaxcuVJdKxERaVY01kfgeNcqN9f7rJW6ViJyBiI+TNW63Fw/fzWb95YH9YFbh81kWI9k3pg5Boetbfb5qFdYWMjixYvJzc1l2bJl6lqJiIjqI6hrJSJnLOLDFEBlrYvpL39OwaHKoBQMh80ko3Mii+4cG/Q9PtS1EhGReqqPP6KulYicpqgIU+AtGDe+uoYte8vbdEpDnM1kaI9kFtw6OjQKxY+oayUiEt1UH5vhq2s1bNjxYKWulUjUipowBd4pDXM+2MqiDcVt8tBtnN1k+sg0Zk8b0vZTF1pAXSsRkeik+uiH4uLjwUpdKxE5JqrCVL21u8q45/UNlFc7W+UuXJzNJDneztwbRpIV6FWJ2pC6ViIi0UX10U/qWonIMVEZpsC7z8ZTi7fy1tpiTAOqA3AnLt5u4rHg2qw0Hp465Mz3yQgh6lqJiEQH1ccWUNdKJGpFbZiqd6TayTvripm3soCKWhfVTjen8xsxDIi3x5DksHHHhAyuzkyjfXzkB4nCwsKGYKWulYhI5FF9bKH6rlVurjdcbd7c+Li6ViIRJerDVD2Px2LVzlKWbz9EfuFhdhyswDQMYkw4evQophlDYmIiBuDyWHgsi4Fdk8jq04mJg7swNqMTpmkE+20EhbpWIiKRq7n6aDMNLMCyLAzDUH1szu7d3hUC1bUSiUgKU83weCx2l1WxfkcxN91yGx1SUvnzvD8RZ4uhb2oi6Z0SMIwoLg6noK6ViEjkqq+PhaWV1Ljc1Lk8xNpM1Ud/qGslEnEUpnzYt28fPXr0oFu3buzbty/Ywwk76lqJiESw//kfmDMH5s2Dm24K9mjCjz9dq/pNg9PSgjdOEWmWwpQPClOB5W/XKjs7mx49egRxpCIickpOJ6SmQnk5pKdDYaH3QSlpGXWtRMKSwpQPClOtp75rlZubS15eHtu3b290/JxzzmkIVupaiYiEmFdfhdtuO/714sVw8cXBG0+k8dW1mjz5eLhS10okaBSmfFCYajvqWomIhAmnEwYN8naj6o0ZA59/ru5Ua6irg88+O778urpWIiFDYcoHhangUNdKRCSELVwIN97Y9PVly+Cii9p+PNFGXSuRkKEw5YPCVGho7a5VTU0NcXFxgRyyiEjk+vvfvWHqxH9C2Gzef+BPmhS8cUUjda1EgkphygeFqdAT6K7Vn//8Z/7+979z8OBBnn76aaZNm6ZlfUVEfCkvh1mz4I9/hN/8Bv7zP71dEQmu3buPB6tPPlHXSqSVKUz5oDAV+vzpWt1yyy1kZ2djmmaj783Pz+e6665j9erVbN68md/97ne8++67xMfHN5zjdruJiYlps/cjIhI2HngAnn0WnnnG+3cJLa3Qtdq0aRM9e/akY8eOrTRokfBi+j5FJLT17duXn//857z//vscPnyYjz76iPvvv59BgwZRXl7Ou+++y/bt2/F4PI2+r6qqig8//JBbbrmFLl260K9fPwDKysoaznG73cybN4+xY8cyZ84cNmzY0KbvTUREpMViY2HiRPjd72DTJigqgj/9CS6/3Nul2rzZG4QnTYJOneDKK717hpWUnPRyP/zwAy+99BLjx49nzJgxfPTRR238hkRCj8KURJS4uDh++tOf8txzz7Ft2zYKCgqYO3cuP/vZz7DZbI3OLSkpYf/+/Uw6Nr+/rKyMIUOG8O233zacc/DgQfbt28fQoUNxuVw8+uijfPDBB236nkRERAKid2+480745z/h8GHvNMBf/tLboaqo8L5+553wi180nh54jMPh4KmnnmLz5s08/vjjvPTSS41mg4hEI5vvU0TCV33X6mT27dtHZWUl55xzDgAHDhygvLycPn36NJxTUlLC4cOHmT17Nunp6QC4XK5WH7eIiEirqu9a1XeuTnzW6rrrTvr8W3x8PA6HA4BevXpx+PBhampqSEhIaOvRi4QMhSmJWuXl5ezdu5fExETKy8vZsWMHKSkp9O3bt+GcsrIyPvzwQwoLC7n77rvJzs5u0uESEREJe/VdqzvvbLxK4wnq6uqIPfZc1fz58xk5cqRWwpWop2l+ErXatWtHamoqAB9//DGffvopV1xxBUDD81UXXngh69at47rrruO1115j9+7dwRquiIhI22hmRdvY2Fj27t3LtGnTOHz4MPfee+/xrtSBA1Bc3IaDFAkNClMStcaPH09aWhrdunXjL3/5C/fccw/Dhw8HaFj1z+FwkJqayk033UT//v159tlnG11DU/5ERCQaVFZW8uabbzJjxgzOP/98XnrpJQYOHOg9WFUFTz3l7W4NHw4PPgjLl3tXExSJcApTErVsNhu///3v2b9/P3/961+58MIL+dvf/saCBQsAWLVqFXv37m04/+uvv254nsqyLFwuFy+++CIjRozg4YcfZsWKFTidzmC8FRERkVZTV1fHzTffzP333899993Hr371K5JOfKbKbvcGpxNXCJw4sfEKgepaSYTSPlM+aJ+p6ON0OrHb7bz44ovMmzePzp070717d+rq6vjDH/5A9+7dAe9duunTp7N48eKG723fvj1TpkwhOzubqVOn0qNHj2C9DRGR1qd9pqKC2+3m7bffJi8vj507d2JZFrNmzeLSSy9tvMn9ifta5ebCli2NLzRsGOTkePe1GjfOr32tREKdwpQPClOyZs0adu7cydVXX43dbm90rKamhhUrVjRsGrx9+/ZGx8855xyys7PJzs7mvPPOa/L9IiJhTWEqKq1Zswabzca555576hOLimDxYm+4WroUKiuPH0tKgsmTj28anJbWuoMWaSUKUz4oTMnpKCgoaAhWy5Yto7q6uuGYulYiEnEUpsRftbXHu1Z5eU27VsOHHw9W6lpJGFGY8kFhSlrK365VTk4O5513npZcF5HwozAlLaWulUQIhSkfFKYkUNS1EpGIozAlgaCulYQxhSkfFKakNfjTtcrJyWl41kpdKxEJSQpT0hrUtZIwojDlg8KUtAV1rUQkLClMSWtT10pCnMKUDwpT0tZ8da1GjBjRaIVAda1EJGgUpqSt1XetcnPhk08ad63atYNJk44vv96rV/DGKVFDYcoHhSkJNnWtRCRkKUxJMKlrJSFAYcoHhSkJJSd2rXJzc/n2228bHVfXyjePx6KorIrC0gpqnB6cbg/2GJM4u0nf1CTSUxIwTcP3hUREYUpCi7pWZ0T1sWUUpnxQmJJQ5k/XKicnh6lTp9K9e/cgjjR4PB6LVTtLWbbtIGt3lbHjYAWmYWAzDSwsLAsMAwwMXB4Lj2UxoEsSWX1SmDi4C+P6pap4iDRHYUpClbpWPqk+BobClA8KUxIu1LVq7Ei1k7fXFTN/ZQGVtS6q6tyczoedASTExpDosDFzQgbXZKbRPt7eWsMVCU8KUxIufHWtTlwhMMK7VqqPgaUw5YPClISraO1aVde5eSpvK2+tK8YwoMbpOeNrxttNPBZcm5nGw9lDiI+NCcBIRSKAwpSEoyjtWqk+tg6FKR8UpiQSREvXKr+wjHvf2EB5tZMa15kXiR+Ls5kkx9uZe8NIsvqkBPz6ImFHYUoiQVHR8WAVoV0r1cfWozDlg8KURKJTda06dOjQaIXAcOha1brczPlgC4s2lATkTpsvcXaT6SN7MXvaUBy26LsLJ9JAYUoijb9dq5wcb9fKHtrT21QfW5/ClA8KUxLpwr1rVVnrYsYra9i6r7xV7rY1J85mMrRHMgtuHU2iI7R+JyJtRmFKIl0Yd61UH9uGwpQPClMSbcKpa1VZ62L6y59TcKiS2jYsFPUcNpOMzoksunNsVBQMkSYUpiSa+NO1ql96PchdK9XHtqMw5cORI0f4r//6L5KTk3nyySeDPRyRNuVv1yonJ4cxY8a0adeq1uXmunmr2bKvPCiFop7DZjKsRzJvzBwTNVMaRBooTEk0C9Gulepj21KY8sGyLGpqajAMg7i4uGAPRySoQqlr9d//3Mii9SVtOnWhOXE2k+nnpvHEFcODPRSRtqUwJeJV37XKzfWGq61bGx9vw66V6mPbUpgSkRapqanh008/bQhXJ+ta5eTkkJ2dHfCuVX5hGTf9ZU2bPEzrrzi7yYJbR0fdKkYS5RSmRE4uSF0r1ce2pzAlIgHRVl2r6jo3FzyznINHawMx7IDq0s7Bp7+8KCr32ZAopTAl4puvrtVZZzXe16qFXSvVx+BQmBKRgGvNrtXs9zbxzrrikJi+8GNxNpNrstJ4/LLInc4g0ojClMjpa2nXqqQEHn0U7rwTRo9uclnVx+BQmBKRVheortWRaiejnlwa1AdqfXHYTPIfmUz7+NDee0QkIBSmRM7M6XSt3nsPnn8e4uPhnXfgkksaTlN9DB6FKT+53W7Wrl3Lnj17AOjZsyejRo3CNM0gj0wkvPjqWv3kJz9p2Nfqx12r+SsL+P2S7SE1F/zH4u0mD0wZxO0TMoI9FJHWpzAlElin6lqZJniO1b+YGPjrX2HGDED1MZgUpvywePFi7r33Xvr370/v3r0BKC4uZseOHbz44otMnTo1yCMUCV/+dq1+evHFXPnXLSE5F/zHurRzsHrWJEzTCPZQRFqXwpRI66mthZUrvcHqvfdg586m59x9N54X5zLm6U9UH4NEYcoPgwYN4uOPPyY9Pb3R60VFRVx88cVs27YtSCMTiSyn6lol9c+k57W/psYdxAH6KSE2hnk3ZjK+f2qwhyLSulasgC+/hAkTYOTIYI9GJHL96U9w991NX+/YkZVrtnPXwvVU1oV+gYzE+hjZWxIHiMfjOelzHD169MDjCd12qki4iYuL4+KLL+biiy/m+eefb9S12hw3lNrQrxMAVDvdLNt2MKKKhchJnX++94+ItK7YWO//JiTA2Wd7n6Vq3x5uvpll2w5SFQZBCiKzPipM+eG2225j1KhRXHfddfQ6tqpKSUkJb775JrfddluQRycSuTIyMrjnnnu45557mPa/K9m0t7zR8c9+dRG9OiZwx4J1DO2ezP2TBzYcq3G62V1Wxd/X7OZvX+ziF5MHct+kAew7Us3kZz9tuIP31swxjM7oxJItB5i5YN0pxzOkWzsenTaMn/TuQLXTzeJN+3niwy1N7gZaFqzddThAvwUREYl6t9wC06ZBp07e56VOsHb5Sn48zUz1se1o9QQ/zJo1izfeeAPDMMjPzyc/Px/DMHjzzTd56KGHgj08kYjn8VjsOFjh17lFhyt5dVUhy7YdpH/nJH5z2TCuy0pj7vLv+O5gBd3bx/OLKd6i8m8jezI6oxPlNU5mv7fplNdNjI1hwW2jOa9fJ5ZtO0jJ99VcP6o3T1111knP//ZABZpFLSIiAWEY0KVLkyCl+hh8ClN+eOyxxxgyZAgPPfQQL7zwAi+88AIPPfQQgwcPDvbQRKJCUVkVpuHfw6rb9x/l8Q+28PPXN7Bs+0EALhrUhTq3h1n/+AaPx+Lm8/owqk8Ks6YOAeC3H21nf3nNKa97bVYaqUkOlm49wM9f38C1876gxunmkrN6kNYxvsn5pmFQdLjqNN+piIiI/1Qfg09hyg9ZWVnBHoJIVCssrcB2miv/dE12kNE5EYCyyjoA1hV9z+v5u7HHmCy4bRSd2zlYu6uMhauLfF5vWI/2AGzccwSAqjo3Ow9VEGMaDOme3OR8m2lQWFrZ5HUREZFAUX0MPj0z5Ydp06YFewgiUa3G6cFqMiP85H46rBu7njq+keH3VXXMX1nQ8PX/t3gbk4d0pVv7OGpdbmb9Y6Nf101N8j78W1nranit/oHfzkmOJudbQI0rPB4IFmmpjRs30r17d1JTmz5MXltbi8PR9P8bIhI4qo/Bp86UH+6//36+++67Jq9XVFTw8ssvB2FEItHF6fbg7/Tq+jnhc5d/x0PvfsP5v11OwQl3wI7Wunh7fTEAK3eUsvOQf3PNSyu8d+8SHcfvQSXGeueuH6poureHZVnUhfBO9CKBcPPNN2O32xu+rl/htqqqivO1yp9Iq1N9DD6FKT8sXbqU/v37N3z90ksvAZCUlMTcuXODNSyRqGGPMfFzSnjDnPDffbydt9YVc/SEO2X1PB6r0f/6Y8uxlQTP6dUB8BaKfp2T8Hgstu0/2uR8wzCItekjViKbx+Ohffv2DV+fe+65ACQkJFBXVxesYYlEDdXH4Iucd9KKYuvX9j/m2Wefbfh7zI9WVRGRwIuzmxi07m7pn/3qInY9dQk/Hdr1pMffXLubsso6Jg7uwks3jOStO87DYY8hd9M+dpc1fZDWAOJs+nyQyObxeKiurgagvLycnTt3UlVVhdvtxuVq+g81EQks1cfg0zNTfujYsSPvv/8+06ZN46233sLpdPLGG2+QlJREu3btgj08kYjXNzUJ10nuktWvYOR0B26J1ZP9HIDKOjc3vrKG2dOGMnFwF2qcbt5aW8ycD7c0e52+qYkBG5dIKLr22mu5+OKLmTJlCsuXL+eee+7h/PPPx2azMX369GAPTyTiqT4Gn2FF0kLvrWTr1q3cfPPNfPvtt1xxxRXMnj2b//iP/8Dj8fDcc89piXSRVubxWAx5bDG1J8yx7tUxnv974EJsMSZTnvvU7302TiY5zsaXs3/Ktv3lXD53VbMF43Q4bCbbHp+K4e/8C5EwlZuby7Zt25g6dSpDhw5l7dq1WJbFqFGjgj00kYin+hh86kz5YciQIeTn5zd67cMPPwzSaEQik9vtZsyYMezdu5cRI0YwYsQIhg0bxtlnn83w4cMZ0CWJTcfmZf/HxP7cPiEDW4zJxj1H+M7Ph2Sbc16/VFweD//59tcBKRQAA7smRUyhEDmVnJwccnJyGr7WdiIibaSkBDMvjwGVsWxyeFfUVH1sewpTfli4cCHjx4+nT58+jV6vqalh48aNKhwiAeDxeNi0aRM1NTXs3buX3NzchmO5ublk9enN5r3lWEBaxwRq6tys+PYQT+Zu9Xslo+Z8tHk/g2YvPrOLnMAwIKtPp4BdTyRkFRTAnj3Qty/06hXs0YhENqcTVq2CvDzvn43epcuzJs1kc+alWIap+hgEClN+ePrpp/n6668bvs7Pz2fUqFHExsZyxx138OWXXwZxdCLhrba2ls8++4zc3NyTLuhit9vp378/SXTg7XXFVNa5efDdb4IwUv/F22OYOLhLsIch0vrmzoVnn4VnnoEHHgj2aEQiT0nJ8fC0dCkcPWF1vMREmDSJiReN5e0yG5VOj+pjEChM+SE2NrbRP/JuvfVWNm3ahGlqMUSRligqKiIvL4+8vDw++eQTKitPvhN6RkYGy5YtIz09nX4ei0SHjcq60N/or53DxtiMyLrzJiIibaCZ7lODoUMhO9v7Z/x4cDgY57FIfPoTKp1N93QKNZFYHxWm/GCaJkVFRaSnp7N9+3Z2795NYWEh8fHxwR6aSFg4sfuUl5fH1q1bGx0fPnw4OTk5nH322cyYMQOAzMxMcnNz6dy5MwCmaTBzQga/X7KdGmfobvYXbzeZOSED04yc+eAiItKK/Og+kZMDU6dCenqTb1d9DC6FKT889thjjBs3jkGDBlFRUcGCBQsYO3YsHo+Hl19+OdjDEwlJp+o+tWvXjsmTJ5Odnc3UqVNJS0trOLZy5UrKy8t5+eWXm2w9cE1mGs98vL3N3kNLeCy4OjPN94kiIhKdWtB98kX1MXgUpvxw6aWXMm7cOHbt2sXw4cOJjY3l0ksvBdBUP5Fj6rtPeXl55ObmNtt9ys7OZuzYsU02w673pz/9qdmf0T7ezrWZaby9rpgaV+jdfYuzmVyTlUb7eHuwhyIiIqGkpAQWL/aGpyVLTt59qg9QJ+k++aL6GDwKU35KSUkhJSWl4WuFKJGWd5/OxMPZQ1i8eT81R0Nvbnj7BDsPTx0S7GGIiEiwtUL3yRfVx+BQmBIRv53YfcrLy2PLlsa7m/vbfToT8bExzL1hJDe+uiak5obH2U3mXj+S+NimKxKKiEgUaOXuky+qj8GhMOVDZWUlb7zxBgkJCdxwww3BHo5ImwtG98mXrD4pTB/Zi0XrS0JiOkOczWT6yDQy+6T4PllERCKDr+7TkCHe4JSTE7Duky+qj21PYcqH8vJyZs6cSbdu3RSmJCqEQvfJH7OnDWXLvnI27y2nNogFw2EzGdojmdnTInP6goiInCDI3Sd/qD62LYUpEQnJ7pMvDlsMC24dzfSXP6fgUGVQCobDZpLROZEFt47GYYvM6QsiIlEtBLtPvqg+ti2FKZEoFC7dJ18SHTYW3TmWG19dw5a95W06pSHu2B23BbeOJtGhj1IRkYgRBt0nX1Qf207kv0MRAWD37t0Ny5aHS/fJH4kOG2/MHMOcD7ayaENxmzx0G2f3zgGfPW1IxN9xExGJeGHYffKH6mPbUJgSiVD+dJ+ys7PJzs5m3LhxIdt98ofDFsMTVwzn8hE9uOf1DZRXO1vlLlyczSQ53s7cG0aSFcEP04qIRLw9e46Hp1N1n6ZOhT59gjbMM6X62PoUpkQiSKR2n/yV1SeFT395EU8t3spba4sxDagOwJ24eLuJx4JrstJ4eOqQiF3eVUQkYjmd8PnnkJt76u5TdjZMmBA23Sd/qT62HoUpkTAWTd0nf8XHxvD4ZcN5YMog3llXzLyVBVTUuqh2urEs/69jGBBvjyHJYeOOCRlcnRmZO7eLiESsE7tPS5dCefnxYxHUffKX6mPrUJgSCTPR3n3yV/t4O7dPyODWcX1ZtbOU5dsPkV94mB0HKzANA5tpYAGWZWEYBgbg8lh4LIuBXZPI6tOJiYO7MDajE6ZpBPvtiIiIL1HeffKX6mNgKUyJhLi6ujpWrlyp7lMLmabBhAGdmTCgMwAej8XusioKSyupcbmpc3mItZnE2WLom5pIeqcEDEPFQUQkLJyq+5SQ0HjlvSjoPp0O1cfAUJgSCUH13af6fZ8qKioajqn7dGZM06BPaiJ9UhODPRQRETld6j61GtXHllGYEgkB6j6JiIg0Q90nCWEKUyJBou6TiIjISaj7JGFEYUqkjaj7JCIi0gx1nyRMKUyJtCJ1n0REJFpUV1cTHx/fsArcKfnqPg0eDDk56j5JyFOYEgmgurq6hn2fcnNz1X0SEZGIlp+fz5IlS1i+fDndunVj4cKFzQcpdZ8kAilMiZwhdZ9ERCRaVFRUkJSU1PD1mDFjuP3223n66afJzMw8+TcdPAhTpsA33zR+Xd0niQAKUyInWLVqFb/+9a/5+c9/zpVXXonH48E0zUbnqPskIiLRpLS0lHnz5vHxxx9z9OhRZs6cySWXXEJaWhoTJ07ksssuIzMzs/npfcnJsHevuk8SkRSmRKAhNH377bfs2bOHzz77jCuvvLKhKFiWxfr163niiSfUfRIRkahQH46++uorvv/+e5577jni4uJ45pln2LNnD3PmzOGqq65ixowZXHvttZSWljJ9+nSuv/76phdbtgwGDlT3SSKOwpQIYJomTqeTjz76iF//+tcsXLiw0VQGwzBISEjgvffeA9R9EhGRyFJQUMAf/vAHYmJiuOGGGxp1ms455xx+8pOf0KlTJwAmTJjA6tWrAbj++ut5//33mTx5MgMHDuSaa64hPj6eSy+9lJiYGO/F4+LgrLOC9dZEWpXClAjeu28//PAD7du3p2/fviQmJrJx40bOO++8hmIyYMAA/va3v3HRRRep+yQiIhGjurqa5557DtM06du3L7/4xS945ZVXGDhwIACdO3cGjs/iWLx4MTNmzACgY8eO5OXlNVxr5syZrFmzhuzs7ONhSiSCKUxJ1DpxbrdhGLz55puMHTuWrKwsBg4cyNtvv027du0YPnw4AHa7nZtuuimYQxYREQm4iooK3n//fXbt2gV4w9Urr7zCo48+SmJiIuCtmaZpsmPHDkpLSxk8ePBJr+VyuaiqqsLhcPi3RLpImFOYkqhSv/Le119/zTPPPENCQgLgLRIej4clS5awZs0a/vWvf1FVVcWAAQMawpSIiEgkcrvdjBgxgh07djBgwADGjRvHggUL+OabbxrN0ACYP38+WVlZ9O/fv+F7d+7cyZ///Gc2bNhAZWUl8+bNA1CQkqhg+j5FJHzV1dWxbNkyHnzwQYYPH056ejp33XUXf/zjHyk/YX8LwzD44YcfOHr0KH379uWll15i/PjxXHfddUEcvYiISOuz2Wykp6ez8djGub169SI1NZXNmzcD3huOAEVFReTn53PvvfeycOFCHnnkEWJiYnA6nSQlJfHEE0/wxRdfcJaej5Ioos6URJxT7fuUlJTE5MmTycnJabRPBsCjjz7acBft6NGjLF26lA0bNjB58uQ2Hb+IiEircDrh88+9y5Rfdhkcm8LXoUMHevfuTX5+PldddRUdO3akpqamYcGJ+i1CXnvtNVasWMG0adMYNmwYOTk5uN1uhg0bxrBhw4L2tkSCSWFKwt6J+z7l5eU13Emr5+/Ke4Zh4Ha7G1bue+GFF9pi+CIiIq1nzx5YvBhyc2HpUigvh5QUuOqqhlNsNhsXXHABd911F0eOHKF9+/asXr2a66+/ntzcXHbu3Mm///u/M2bMGPLz85vfnFckCilMSVgqLi5uCE9Lly5ttvt0uvs+aeUhEREJa/Xdp7w8759vvml8fPBg74a5TmejPZ8yMzMZM2YMd955J1u2bGHw4MEMHjyYnj17MmHCBACmTJnSlu9EJCwoTDXD5XKRk5PD+vXrAThw4ACdO3fmZz/7Gc8//3xwBxeFAtV9EhERiTgn6z7VS0iAiRMhJwemToW+fZu9zHPPPceaNWtwuVxceOGFAA2r+YnIySlMncKaNWsaFimwLIvS0tKGcCWtz5/uU32A0r5PIiISNfztPmVnw4QJ3k1z/WC32xk/fnwrDFgkcilMNcNms3HfffcxZ86cRq8/8MADQRpR5FP3SUREpBn13ae8PFiypMXdJxEJLIWpU7j//vt5/vnnOXr0KAAjRozg8ssvD/KoIou6TyIiIifRSt0nEQkshalTSElJ4bbbbmt4Ruqxxx7TBnRnqK6ujlWrVpGbm3vS7lP9UqvqPomISNRR90kk7ChM+TBr1ixefPFFOnTooK5UC/nbfZo6dSq9e/cO4khFRETakNMJX3zhXThC3SeRsKQw5UPXrl2prKwkJiZGXSk/1Xef8vLyyM3NPWn3KTs7m5ycHHWfREQkuqj7JBJRFKaa4fFYFJVVUVhaQY3Tg9PtwR5jEmc36ZuaRHpKAqapcFVP3ScRkejQqD6mDMA59ALs8WnEbTug+ngy9d2nvDxvB0rdJ5GIYliWZQV7EKHA47FYtbOUZdsOsnZXGTsOVmAaBjbTwMLCssAwwMDA5bHwWBYDuiSR1SeFiYO7MK5falQVjxO7T3l5eWzatKnRcXWfREQig8/66HJj2GJUH0/kT/epPkCp+yQS1qI+TB2pdvL2umLmryygstZFVZ2b0/mFGEBCbAyJDhszJ2RwTWYa7ePtrTXcoFL3SUQkeqg+ngZ1n0SiVtSGqeo6N0/lbeWtdcUYBtQ4PWd8zXi7iceCazPTeDh7CPGxMQEYafD4233Kzs5m/Pjx6j6JiEQA1Uc/7d17fNlydZ9EolZUhqn8wjLufWMD5dVOalxnXiR+LM5mkhxvZ+4NI8nqkxLw67cmdZ9ERKKX6uMpnNh9ysuDr79ufFzdJ5GoFFVhqtblZs4HW1i0oSQgd9p8ibObTB/Zi9nThuKwheZdOHWfRERE9bEZ6j6JiA9RE6Yqa13MeGUNW/eVt8rdtubE2UyG9khmwa2jSXSExuKJJSUlDcuWf/LJJxw9erThWFJSEpMmTSInJ0fdJxGRKKD6eAJ1n0TkNEVFmKqsdTH95c8pOFRJbRsWinoOm0lG50QW3Tk2KAVD3ScRETmZaK+PgLf7tHixd+EIdZ9E5DRFfJiqdbm5bt5qtuwrD0qhqOewmQzrkcwbM8e0yZQGf7pP9QFK3ScRkegTrfVR3ScRCaSID1P//c+NLFpf0qZTF5oTZzOZfm4aT1wxPODXVvdJREROR7TUR+B496n+2acjR44fU/dJRM5AiExSbh35hWXeh2lDoFAA1Lg8LNpQzOUjegRkFaP67lP9ynvqPomIiD8ivT6q+yQibSViO1PVdW4ueGY5B4/WBnsoTXRp5+DTX1502vts+Oo+DR06lJycHHWfRESkWWFdH2tqmg8+6j6JSBBEbGfqybytlFc7gz2MkyqvdvLU4q08fpnv6QzqPomISCCFZX10OuGOO+C112DZMrjgAt/dp0GDvMEpJ0fdJxFpNRHZmTpS7WTUk0uD+kCtLw6bSf4jk2kfb2/0utPpZNWqVeTm5qr7JCIiARWW9bGqCq6+2rvaHniDUdeu6j6JSEiIyM7U2+uKMYxgj+LUTAPeWVfM7RMy1H0SEZE2EW71kYMHYdIkOPHG4sqVx/+u7pOIBFnEdaY8HosxT38SknPBfyzOqsX24a/ZvGljo9fVfRIRkUALp/rYpZ2D1bMmYfboDgcOND3hkUfg9tvVfRKRoIu4ztSqnaVU1rqCPQy/VDk9HDpqkpiYyOTJk8nOzmbq1Kmkp6cHe2giIhJhwqk+VtS6+LzgMON79jx5mOrRQ0FKREJCxIWpZdsOUlXnDvYw/GLGxvGzXz3N3NsuwuFwBHs4IiISwcKpPlY73SzbdpDx69d7V/DbvBm++sr7p6QEJk8O9hBFRIAIDFN3XdCPxy4dxh0L1vHxFu/drEenDeXWcX1ZtL6YXy76BoCx/Trxn5MHMqhbO0zD4FBFLZv2HOHeN74EYPrIXjxz9TkA1Lk8VNW52HW4io+37OeVzwpP6+Hdcf06cf/kgZzVsz1x9hhWFxzmuvmrAYMDnkQFKRERaXVrd5Wx8lcX0atjQljUyLW7DntPiIuDc8/1/hERCTERFaY8Hgun2/cHeNdkB3++KRN7jMniTfs5WusiIzWRyUO6Njn3cEUt//pmL2kdEzh/QGdGpHVg8pCuXD9/td/Fom/nJOLtMWw/cJRzenVodOzbAxVYloUR6k8Ei4hI2PJ4LHYcrPDr3FCpkaqPIhIOIipMFZVVERtj+jxvRFpHEmJtLNmyn39/88uG13+8TDnAgfIafvP+FgCG9UjmH3ePZWTvjtw6ri9//HSnX+NauLqIhauLuHVcnyZhyjQMig5X0Sc10a9riYiInK6isipMP0NJqNRI1UcRCQe+k0cYKSytAD9qxaGjNQBMHNyVBbeO4heTB5DVpyPlNafexHDz3nI+3uydFjFpcJczHi+AzTQoLK0MyLVEREROprC0ApvpX5gKlRqp+igi4SCiwlSN078pBRt2/8DLK3ZiWRYTBnTmvkkDeefOsfzrnvEkx526Wbfnh2oAOiUF5jknC6hxhccDwSIiEp5qnB4s/NsJJVRqpOqjiISDiApTTreHGqf3g9d+wnS/+ql/1SeErafytpH55FLueX0Dr68pos7l4aye7bk6M+2UP6Nnh3jAO088ECzLoi6Ed6IXEZHw53R7sKzjNx3DoUaqPopIOIioMGWPMSn5vgqAkb07AN6d1Eekef++67B3ukCP9nH0TknghyonH27cxyP/3MT/bT8IQJKj+btuw3ok89Nh3gdwP9l2MCBjNgyDWFtE/WcQEZEQY48xMQwoKvPWwXCokaqPIhIOImoBiji7ybvrS7hgYBduG5/BuekptI+30zc1kfIaJ//6ei8Ag7snM//GTL7c/T07D1USH2ty0eAueDwWq74rbXTNrslxPHbpUHp1SOCCgZ2JtZls2P09r64qBGBM3xTevOM8yqudnP34xycdV2Z6R67LSqN/l3YA9OucyDPTz2bnoUoWri4izhbTir8VERGJdnF2EwODN/OLmTS4a1jUyJLvq1UfRSTkRVSY6puaxJKtB7nvrS+5fXwG/TonUuvysGLHIX730XYOHfVOO/j2wFH+saGEzD4pDOmejAVs33+UeSsLWFf0faNrdkpyMGN0OpW1LrbsO8JHmw/wymeF1B1bgr1+yVaXp/m56H06JTL93ONTIzq3i2P6uWmsLjjMXz/fRV+tVCQiIq2ob2oSLo/Fkq0HwqZG5heW0aWd9mEUkdBmWJbl3xOpYcDjsRjy2OLT2izwTN0ytg+PXTqMJ3O3Mm9lwWl/v8Nmsu3xqdpHQ0REWk0w6iOcWY1UfRSRcBBRk5FN02BAl6Q2/Zlj+6WydlcZ8z87/SAFMLBrkgqFiIi0qmDURzizGqn6KCLhIKKm+QFk9Ulh895yPxeAPXMzF6xr8fcaBmT16RTA0YiIiJxcW9dHaHmNVH0UkXARUZ0pgImDu5AQGx4PrMbbY5gYoM1/RURETkX1UUQk8CIuTI3rl0riKZZuDSXtHDbGZujOm4iItD7VRxGRwIu4MGWaBjMnZBBnD+23Fm83mTkhA9PUfHAREWl9qo8iIoEX2p+oLXRNZhqhvkahx8LnTvIiIiKBpPooIhJYERmm2sfbuTYzjbgQ3Tk9zmZybVYa7ePtwR6KiIhEEdVHEZHACs1P0wB4OHsIySH6Ydw+wc7DU4cEexgiIhKFVB9FRAInYsNUfGwMc28YGXJzw+PsJnOvH0l8mKyoJCIikUX1UUQkcELrkzTAsvqkMH1kr5CZzhBnM5k+Mo3MPinBHoqIiEQx1UcRkcAIjU/RVjR72lCG9kjGEeSC4bCZDO2RzOxpmr4gIiLBp/ooInLmIj5MOWwxLLh1NBmdE4NWMBw2k4zOiSy4dTQOm6YviIhI8Kk+ioicuYgPUwCJDhuL7hzLsB7JbT6lIc5mMqxHMovuHBs2myWKiEh0UH0UETkzhmWF+o4TgVPrcjPng60s2lBMjdPT6j8vzu6dAz572hDdcRMRkZCl+igi0jJRFabqrd1Vxj2vb6C82kmNK/BFI85mkhxvZ+4NI8nSw7QiIhImVB9FRE5PVIYpgOo6N08t3spba4sxDagOwJ24eLuJx4Jrs9J4eOoQLe8qIiJhR/VRRMR/URum6h2pdvLOumLmrSygotZFtdPN6fxGDAPi7TEkOWzcMSGDqzO1c7uIiIQ/1UcREd+iPkzV83gsVu0sZfn2Q+QXHmbHwQpMw8BmGliAZVkYhoEBuDwWHstiYNcksvp0YuLgLozN6IRpGsF+GyIiIgGl+igi0jyFqWZ4PBa7y6ooLK2kxuWmzuUh1mYSZ4uhb2oi6Z0SMAwVBxERiS6qjyIixylMiYiIiIiItEBU7DMlIiIiIiISaApTIiIiIiIiLaAwJSIiIiIi0gIKUyIiIiIiIi2gMCUiIiIiItICClMiIiIiIiItoDAlIiIiIiLSAgpTIiIiIiIiLaAwJSIiIiIi0gIKUyIiIiIiIi2gMCUiIiIiItICClMiIiIiIiItoDAlIiIiIiLSAgpTIiIiIiIiLaAwJSIiIiIi0gIKUyIiIiIiIi2gMCUiIiIiItICClMiIiIiIiItoDAlIiIiIiLSAgpTIiIiIiIiLfD/AC1EX2oXctz7AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "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", @@ -438,46 +462,29 @@ "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", + "metadata": {}, "source": [ "上面给出的左图展示了未被选中的交易路线，右图展示了该算法找到的最优套利回路。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 结语\n", "\n", "在本教程中，针对套利问题，给出了一种寻找最优套利回路的经典量子混合算法。对于 $n$ 个货币市场，在该解决方案中，我们需要 $n^2$ 个量子比特。在样例中，我们设定的不同市场间的汇率比较特殊且把交易成本包含在内，所以会产生高达 $150\\%$ 的正向收益率。用户在使用时可以根据需求，自行设定真实的货币汇率。\n", "\n", "在实际的金融市场中，一般不会有如此高的投资回报率，而且考虑的货币市场数量比较大，需要考虑的因素也更多。因此，随着货币数量的增加，所需的量子比特数也急速增加，实现难度也就越大。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "_______\n", "\n", @@ -488,8 +495,7 @@ "[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": { @@ -497,8 +503,9 @@ "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" }, "kernelspec": { - "name": "python3", - "display_name": "Python 3.7.11 64-bit ('pq_env': conda)" + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -510,7 +517,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.11" + "version": "3.9.7" }, "toc": { "base_numbering": 1, @@ -528,4 +535,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_EN.ipynb b/tutorials/combinatorial_optimization/ArbitrageOpportunityOptimation_EN.ipynb similarity index 65% rename from tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_EN.ipynb rename to tutorials/combinatorial_optimization/ArbitrageOpportunityOptimation_EN.ipynb index aba02f2..129bd58 100644 --- a/tutorial/combinatorial_optimization/ArbitrageOpportunityOptimation_EN.ipynb +++ b/tutorials/combinatorial_optimization/ArbitrageOpportunityOptimation_EN.ipynb @@ -2,39 +2,40 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "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", + "metadata": {}, "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", + "metadata": {}, "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", + "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", + "metadata": {}, "source": [ "### Encoding Arbitrage Opportunity Optimization Problem\n", "\n", @@ -67,9 +68,9 @@ "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", + "In this equation, $V$ is the number of vertices of the graph, $E$ is the edge set of the graph and $K$ is 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", + "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", @@ -79,21 +80,27 @@ "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", + "metadata": {}, "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, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + }, + "outputs": [], "source": [ "# Import packages needed\n", "import numpy as np\n", @@ -102,29 +109,41 @@ "\n", "# Import related modules from Paddle Quantum and PaddlePaddle\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\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", + "metadata": {}, "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, + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.212260Z", + "start_time": "2021-05-17T08:00:15.918792Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1MAAADnCAYAAAD7CwxiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAA2QUlEQVR4nO3deXyU9b3+/2vuzGSyESBsCoRAZAcVMSiyqECoJMX14I76KIpo9RztofagPWorHvVnqdoecYFqF2xVpP1p1SQKhCMISlhUdkQSIAFkixCyz2Tu7x80I5FlJmEm98w9r+c/JZnJ5DP46Ly57utz37fDNE1TAAAAAIBmMaxeAAAAAABEI8IUAAAAALQAYQoAAAAAWoAwBQAAAAAtQJgCAAAAgBYgTAEAAABACxCmAAAAAKAFCFMAAAAA0AKEKQAAAABoAcIUAAAAALQAYQoAAAAAWoAwBQAAAAAtQJgCAAAAgBYgTAEAAABACxCmAAAAAKAFCFMAAAAA0AKEKQAAAABoAcIUAAAAALQAYQoAAAAAWoAwBQAAAAAt4LR6AZHK5zO1s7xaJQcrVevxydPgkyvOUILLUK+OKcpIS5JhOKxeJgAArYr5CADfI0z9i89navn2gyrcsl+rdpRr2/5KGQ6HnIZDpkyZpuRwSA455PWZ8pmm+nRO0bCeaRrbv7NGntOR4QEAsB3mIwCcmsM0TdPqRVjpSI1H81eXau6yYlXVeVVd36Dm/IU4JCXFxynZ7dTU0Zm6IStdbRNd4VouAACtgvkIAIHFbJiqqW/Q0/mb9fbqUjkcUq3Hd8avmegy5DOlG7PS9XDOACXGx4VgpQAAtB7mIwAELybDVFFJue5/c60qajyq9Z75kPihBKeh1ESXZt8yVMN6poX89QEACAfmIwA0T0yFqTpvg2Z+sEkL1paF5EhbIAkuQ5OGdtejEwfK7eQoHAAgMjEfAaBlYiZMVdV5Nfm1ldq8tyIsR9tOJcFpaGDXVM2bcrGS3VzvAwAQWZiPANByMRGmquq8mvTqChUfqFJdKw6KRm6nocxOyVowbQQDAwAQMZiPAHBmbH/T3jpvgya/ttKyQXFsDT4VH6jSba+vVJ23wZI1AABwPOYjAJw524epmR9s0ua9FZYNikZ1Xp827anQzA82W7oOAAAk5iMAhIKtw1RRSfmxk2ktHhSNar0+LVhbqlU7yq1eCgAghjEfASA0bBumauobdP+ba1vlqkTNUevx6b6/rVVNPdsZAACtj/kIAKFj2zD1VP5mVdR4rF7GSVXUePR0AdsZAACtj/kIAKFjyzB1pMaj+atLI2b7wg/Ven16e1WpjkToMAMA2BPzEQBCy5Zhav7qUjkcVq/i9AyH9M7qUquXAQCIIcxHAAgt24Upn8/U3GXFEbcX/IdqPD7NWVYsn8/2t/kCAEQA5iMAhJ7twtTy7QdVVee1ehlBqazzakXxIauXAQCIAcxHAAg924Wpwi37VR0lVwKq8TSocMt+q5cBAIgBzEcACD3bhalVO8oVLRsDTFNatYMjbwCA8GM+AkDoOa1eQCj5fKa27a8M+vkXZrTXvZedowsz2ivJFadvK2q1ZOsB/U/eJm17MleStHHPEf34fz+VJP1oYBfNuS1LZd9Va9SzS/T21OG6OLODFm7ap6nzVkuS2ie5VDj9crVPitfMDzfptU9LTruGr/dVyjRNOSL9jGAAQNRiPgJAeNiqmdpZXi0jyA/dK887W29PHa7sAV2093CN/vHFbu0qr9atF/dQoivO/7xBXdvqikFnnfQ1Hv7/16vO06DxA7soe0BnSdIjOQPUPileX5Ye1h+Xn35QSJLhcGjnoeqg1gwAQEswHwEgPGzVTJUcrJTTCDwsElyGnrh6sJxxhv7xRZmmv/OVzH/tfeiRlqQaz/d7yn0+Uw+O66OPNn57wusUH6zS7wu/0UNX9NPjEwep1uPTvw3tLk+DTzP+sU7BXIjIaThUcrBKPTsmB/0+AQBoDuYjAISHrZqpWo9PZhA7wrMy0tQ+KV6S9GLhN/5BIUm7yqvlafj+G3kb9mrA2anKHXzyo2+vLt2uzXsrlJ6WpNfuyJJhODRnabG2fHs0qDWbkmq90XFCMAAgOjEfASA8bBWmPA2+Jh/8p9IhJd7/592Ha0773D+t2KFDlXV6YFzfk+7b9vpMzfjHOjX4TLmdcSo+WKnfF24Les2maao+Qu9EDwCwB+YjAISHrcKUK84I6s7uhyrr/X/u1i7xtM+trm/QnGXF6ndWG0089+yTPuersiNas/M7SdLfVu5SXTM+/B0Oh+KdtvrPAACIMMxHAAgPW31KJbgMORR4WqzZ+Z0OVx8bGPeP7d1kwHRrl3jCvvI/f7ZDB47W6cenGBaS5PvXIT9fMIf+juOQlOCMC/g8AABaivkIAOFhqzDVq2OKvEGc1VrjadDj729Ug8/UdRd014f3j9JT156r1+7IUuH0y5QU3/TDu9bj06tLt8sI4uTd5vL6TPXi5FoAQBgxHwEgPGwVpjLSkoI+8vXel3t089zPVbhlv7q2S9S/De2m3p1S9Naq0iZXK2o07/Od2l9RG+oly2eayuiQFPLXBQCgEfMRAMLDYZrN7N0j3MT/XaYNeyqsXkbQzu2WqvfvHy2fz6ft27fryy+/1Lp165SVlaWrr77a6uUBAGwi2uZjz1RDH08fp/j4+MBPBgCL2Oo+U5I0rGeaNu6pCOICsNZzOKRu8bXq3LmzDh8+LI/H438sPT2dMAUACJlomo+mz6d1i95Vh6du0Lhx45STk6OcnBz16NHD6qUBQBO22uYnSWP7dz5hT3ekSnTFqa5kjQ4cONAkSElSx44dtXv3botWBgCwm2iaj/FxUhffQVVWVuq9997TPffco4yMDA0aNEgPPfSQCgsLVV9fH/iFACDMbLfNz+czNfyZxdp/tM7qpQTUpY1by38xRrfeeovmz59/0uecd955ys3NVU5Oji655BK5XK5WXiUAwA6ibT5+NmOcdu8uU0FBgfLz87Vo0SIdPfr9DX9TUlJorQBYznZhSpLmLivWbxduVa0ncm/2l+gyNH18P901OlOmaerZZ5/VjBkz/I9nZ2drxYoVqq6u9n8vNTVV48ePV05OjiZMmKBu3bpZsXQAQJSKtvl4vPr6ei1fvlz5+fnKz8/Xhg0bmjw+cOBA/8HHUaNGca4VgFZhyzB1pMaji55a1KybA7Y2t9NQ0SPZapv4fdP02muv6e6779ZFF12kzz77THV1dVq6dKl/cGzZsqXJa9BaAQCaI1rn48mUlpbSWgGwnC3DlCQ99t4GzV9dqtoIHBgJTkM3DEvXE1cNPuGx4uJipaWlqV27dic8tmPHDn+wWrx4Ma0VAKDZonU+ng6tFQCr2DZM1dQ36LJZSyJyb3iXVLf+b/oYJZ7BicC0VgCAlrD7fJSatlYLFy5UZWWl/zFaKwChZNswJUmrdpTrttdXRtTe8ASXoTemXKysnmkhfV1aKwBAsGJpPtJaAQgnW4cpSfrvd9drwZqyiNjOkOA0NOnCdD15TfO2LzRXbW2tli1bRmsFADilWJyP0vetVV5enhYtWkRrBeCM2D5M1XkbdPPcz7VxT4WlJ9y6nYYGdU3Vm1OHy+1s3ft8lJSU+AdHYWEhrRUAgPkoWisAZ872YUqSquq8mvTqChUfqLJkYLidhjI7JWvBtBFKdjtb/fcfj9YKANCI+dgUrRWA5oqJMCUdGxi3vb5Sm/ZUtOqWhgSnoYFdUzVvysURMSh+iNYKAGIb8/HkArVWgwYN8gcrWisgdsVMmJKObWmY+cFmLVhb2ion3Sa4DE0amq5HJw5o9a0LLUFrBQCxifkYWGlpqX8+0loBaBRTYarRqh3luu9va1VR4wnLUbgEp6HURJdm3zJUw0J8VaLWRGsFALGF+RgcWisAjWIyTEnH7rPxdMFmvb2qVIZDqgnBkbhElyGfKd04LF0PTxhwxvfJiCS0VgAQG5iPzUdrBcSumA1TjY7UePTO6lLNWVasyjqvajwNas7fiMMhJbrilOJ26u7Rmbo+K11tE+0fJEpKSvyDg9YKAOyH+dgyja1VXl6e8vPztXHjxiaP01oB9hLzYaqRz2dq+faDWrL1gIpKDmnb/koZDofiDOno0aMyjDglJyfLIcnrM+UzTfXtkqJhPTtobP/OGpHZQYbhsPptWILWCgDs61Tz0Wk4ZEoyTVMOh4P5eAq7du1SQUEBrRVgU4SpU/D5TO0qr9aabaW6/Sd3ql1aR/1hzitKcMapV8dkZXRIksMRu8PhdGitAMC+GudjycEq1XobVO/1Kd5pMB+DQGsF2A9hKoC9e/eqa9euOuuss7R3716rlxN1aK0AwL7+53/+RzNnztScOXN0++23W72cqBNMa9U4I9PT0y1cKYBTIUwFQJgKrWBbq5ycHHXt2tXClQIATsfj8ahjx46qqKhQRkaGSkpKaKTOAK0VEJ0IUwEQpsKnsbVqHBxbt25t8vj555/vHxy0VgAQWV5//XXdeeed/q8LCgp0xRVXWLgiewnUWmVnZ/tnJK0VYB3CVACEqdZDawUA0cHj8ahfv34qKSnxf2/48OFasWIF7VQY1NfX69NPP/XPSForIHIQpgIgTFmD1goAItcbb7yh22677YTvFxYWasyYMRasKLbQWgGRgzAVAGEqMoS7taqtrVVCQkIolwwAtvXXv/5Vt912m47/J4TT6VRBQYHGjRtn4cpiD60VYC3CVACEqcgT6tbqD3/4g/76179q//79euaZZzRx4kS2qQBAABUVFZoxY4Zefvll/frXv9Z//ud/KiUlxeplxbxdu3b5g9XixYtprYAwI0wFQJiKfMG0Vj/5yU+Uk5MjwzCa/GxRUZFuuukmff7559q4caN+85vf6O9//7sSExP9z2loaFBcXFyrvR8AiBbTp0/Xc889p1mzZmn69OlWLwc/EI7WasOGDerWrZvat28frmUDUcUI/BQgsvXq1Us//elP9f777+vQoUP66KOP9OCDD6pfv36qqKjQ3//+d23dulU+n6/Jz1VXV+vDDz/UT37yE3Xu3FnnnHOOJKm8vNz/nIaGBs2ZM0cjRozQzJkztXbt2lZ9bwAAtFR8fLzGjh2r3/zmN9qwYYN27typV155RVdffbVSUlK0ceNGzZo1S+PGjVOHDh107bXXas6cOSorKzvp6x0+fFgvvfSSRo0apeHDh+ujjz5q5XcERB7CFGwlISFBP/rRj/T8889ry5YtKi4u1uzZs3XrrbfK6XQ2eW5ZWZm+/fZb//7+8vJyDRgwQF9//bX/Ofv379fevXs1cOBAeb1ePfbYY/rggw9a9T0BABAKPXr00LRp0/Tuu+/q0KFDWrx4sX7+859r0KBBqqys1Lvvvqtp06bpZz/7WZPtgY3cbreefvppbdy4UU888YReeumlJrtBgFjkDPwUIHo1tlYns3fvXlVVVen888+XJO3bt08VFRXq2bOn/zllZWU6dOiQHn30UWVkZEiSvF5v2NcNAEA4NbZWjc3V8eda3XTTTSc9/y0xMVFut1uS1L17dx06dEi1tbVKSkpq7eUDEYMwhZhVUVGhPXv2KDk5WRUVFdq2bZvS0tLUq1cv/3PKy8v14YcfqqSkRPfee69ycnJOaLgAAIh2ja3VtGnTdKrT6evr6/3nVc2dO1dDhw7lSriIeWzzQ8xq06aNOnbsKEn6+OOP9cknn+iaa66RJP/5VZdffrlWr16tm266SX/5y1+0a9cuq5YLAECrONUVbePj47Vnzx5NnDhRhw4d0v333+9vpfbt26fS0tLWXCYQEQhTiFmjRo1Senq6zjrrLP3xj3/Ufffdp8GDB0uS/6p/brdbHTt21O23367evXvrueeea/IabPkDAMSCqqoqvfXWW5o8ebIuvfRSvfTSS+rbt6+kYxd0evrpp9WjRw8NHjxYDz30kJYsWaL6+nqLVw2EH2EKMcvpdOq3v/2tvv32W/3pT3/S5Zdfrj//+c+aN2+eJGn58uXas2eP//lfffWV/3wq0zTl9Xr14osvasiQIXr44Ye1dOlSeTweK94KAABhU19frzvuuEMPPvigHnjgAf3iF79ock6Vy+VSfX19kysEjh07tskVAmmtYFfcZyoA7jMVezwej1wul1588UXNmTNHnTp10tlnn636+nr97ne/09lnny3p2FG6SZMmqaCgwP+zbdu21fjx45WTk6MJEyaoa9euVr0NAAg77jMVGxoaGjR//nzl5+dr+/btMk1TM2bM0JVXXtlkS+Dx97XKy8vTpk2bmrzOoEGDlJubq5ycHI0cOTKo+1oBkY4wFQBhCitXrtT27dt1/fXXy+VyNXmstrZWS5cu9V8BaevWrU0eP//88/03RLzkkktO+HkAiGaEqdi0cuVKOZ1OXXjhhad93s6dO1VQUKD8/HwtWrRIVVVV/sdSUlKUnZ3tn5Hp6enhXjYQFoSpAAhTaI7i4mJ/sCosLFRNTY3/MVorAHZDmEKw6urq/K1Vfn7+Ca3V4MGD/cGK1grRhDAVAGEKLRVsa5Wbm6tLLrmES64DiDqEKbQUrRXsgjAVAGEKoUJrBcBuCFMIBVorRDPCVACEKYRDMK1V40m6tFYAIhVhCuFAa4VoQpgKgDCF1kBrBSAaEaYQbrRWiHSEqQAIU2htgVqrIUOGNLlCIK0VAKsQptDaGlurvLw8LV68uElr1aZNG40bN86/s6N79+4WrhSxgjAVAGEKVqO1AhCpCFOwEq0VIgFhKgDCFCLJ8a1VXl6evv766yaP01oF5vOZ2llerZKDlar1+ORp8MkVZyjBZahXxxRlpCXJMByBXwgAYQoRhdbqzDAfW4YwFQBhCpEsmNYqNzdXEyZM0Nlnn23hSq3j85lavv2gCrfs16od5dq2v1KGwyGn4ZApU6YpORySQw55faZ8pqk+nVM0rGeaxvbvrJHndGR4AKdAmEKkorUKjPkYGoSpAAhTiBa0Vk0dqfFo/upSzV1WrKo6r6rrG9ScDzuHpKT4OCW7nZo6OlM3ZKWrbaIrXMsFohJhCtEiUGt1/BUC7d5aMR9DizAVAGEK0SpWW6ua+gY9nb9Zb68ulcMh1Xp8Z/yaiS5DPlO6MStdD+cMUGJ8XAhWCkQ/whSiUay2VszH8CBMBUCYgh3ESmtVVFKu+99cq4oaj2q9Zz4kfijBaSg10aXZtwzVsJ5pIX99INoQpmAHO3fu9Acru7ZWzMfwIUwFQJiCHZ2utWrXrl2TKwRGQ2tV523QzA82acHaspAcaQskwWVo0tDuenTiQLmdsXcUDmhEmILdBNta5ebmauTIkXK5Int7G/Mx/AhTARCmYHfR3lpV1Xk1+bWV2ry3IixH204lwWloYNdUzZtysZLdkfV3ArQWwhTsLppbK+Zj6yBMBUCYQqyJptaqqs6rSa+uUPGBKtW14qBo5HYayuyUrAXTRsTEwAB+iDCFWBJMa9V46XWrWyvmY+shTAVw5MgR/fKXv1Rqaqqeeuopq5cDtKpgW6vc3FwNHz68VVurOm+DbprzuTbtrbBkUDRyOw0N6pqqN6cOj5ktDUAjwhRiWaS2VszH1kWYCsA0TdXW1srhcCghIcHq5QCWiqTW6r/fXa8Fa8padevCqSQ4DU26MF1PXjPY6qUArYowBRzT2Frl5eUpPz9fmzdvbvJ4a7ZWzMfWRZgC0CK1tbX65JNP/OHqZK1V4+AIdWtVVFKu2/+4slVOpg1WgsvQvCkXx9xVjBDbCFPAyVnVWjEfWx9hCkBItFZrVVPfoMtmLdH+o3WhWHZIdW7j1ic/HxOT99lAbCJMAYEFaq3OPffcJve1amlrxXy0hmH1AgDYQ2Zmpu677z598MEHKi8vV0FBgR544AH17dtXhw8f1jvvvKMpU6aoa9euuuCCC/TLX/5Sn376qbxeb7N+z1P5m1VR4wnTuzgzFTUePV2wOfATAQAxw+12a9y4cfrtb3+rTZs2aceOHXr55Zd11VVXKTk5WevXr9ezzz6rMWPGqEOHDrruuus0d+5clZWVNXmdsrIyTZkyRStXrjzp72E+WoNmCkDYhaq1OlLj0UVPLbL0hNpA3E5DRY9kq21iZN97BAgFmingzDSntXrvvff0wgsvKDExUe+8845+/OMf+5/HfLQOYSpIDQ0NWrVqlXbv3i1J6tatmy666CIZBuUe0ByBzrW64IIL/IPjh+dazV1WrN8u3BpRe8F/KNFlaPr4frprdKbVSwHCjjAFhNbpzrUyDEM+37H5FxcXpz/96U+aPHmyJOajlQhTQSgoKND999+v3r17q0ePHpKk0tJSbdu2TS+++KImTJhg8QqB6BVsa/WjK67QtX/aFJF7wX+ocxu3Pp8xTobhsHopQFgRpoDwqaur07Jly5Sfn6/33ntP27dvP+E59957r158cbaGP7OY+WgRwlQQ+vXrp48//lgZGRlNvr9z505dccUV2rJli0UrA+zldK1VSu8sdbvxV6ptsHCBQUqKj9Oc27I0qndHq5cChNXSpUv1xRdfaPTo0Ro6dKjVywFs65VXXtG99957wvfbt2+v91Zu1T1vrFFVfeQPSDvOR3vfkjhEfD7fSc/j6Nq1q79uBXDmEhISdMUVV+iKK67QCy+80KS12pgwUHWRPyckSTWeBhVu2W+rYQGczKWXXqpLL73U6mUAthcfHy9JSkpK0nnnnadzzz1Xbdu21R133KG/b9mv6igIUpI95yPNVBCeeeYZvfXWW7rpppv89wIoKyvTW2+9pZtvvln/9V//ZfEKAfub+L/LtGFPRdDP//QXY9S9fZLunrdaA89O1YPZff2P1XoatKu8Wn9duUt//myHfpbdVw+M66O9R2qU/dwn/qN7b08droszO2jhpn2aOm91s9Z7brdUvX//6Gb9DAAAJ2Oapg4cOKAOHTooLq7p5cWbOx8la2ek3eYjV08IwowZM/Tmm2/K4XCoqKhIRUVFcjgceuuttwhSQCvw+Uxt2195xq+z81CVXl9eosIt+9W7U4p+fdUg3TQsXbOXfKNv9lfq7LaJ+tn4YwPl34Z208WZHVRR69Gj721o9u/6el+lOFYFAAgFh8Ohzp07nxCkQjUfpdabkXabj2zzC8Ljjz+uX//61xowYIDVSwFi0s7yahmOMz9Zdeu3R/XEB5skSX+4PUvZA7poTL/OemtVqWb8Y53m332J7rikpz7euE8zJhz7//uzH23VtxW1zf5dhsOhnYeq1bNj8hmvGwCAkwnVfJRab0babT7STAVh2LBhVi8BiGklByvlDOGVf7qkupXZ6diHeHlVvSRp9c7v9LeiXXLFGZp350Xq1MatVTvK9cbnO1v0O5yGQyUHqwI/EQCAFgr1fJTCPyPtNh9ppoIwceJEq5cAxLRaj0+mznxLwI8GnaUdT39/k8Pvqus1d1mx/+v/r2CLsgd00VltE1TnbdCMf6xv8e8yJdV6o+OEYKCl1q9fr7PPPlsdO554MnldXZ3cbrcFqwJiR6jmo9R6M9Ju85FmKggPPvigvvnmmxO+X1lZqVdffdWCFQGxxdPgUyi2VzfuB5+95Bv919/X6dJnl6j4uKNjR+u8mr+mVJK0bNtBbT/Q8n3opmmqPoLvRA+Ewh133CGXy+X/uvEKt9XV1VzlD2gFoZqPUuvNSLvNR8JUEBYtWqTevXv7v37ppZckSSkpKZo9e7ZVywJihivOUCi2hDfuB//Nx1v19upSHa3znvAcn89s8r8t5XA4FO/kIxb25vP51LZtW//XF154oaRjl2+ur6+3allAzAjVfJRab0babT7a552EUeO1/Rs999xz/j//8KoqAEIvwWXIoei6W7pDUoKTzwfYm8/nU01NjSSpoqJC27dvV3V1tRoaGuT1nvgPMQChxXy0HudMBaF9+/Z6//33NXHiRL399tvyeDx68803lZKSojZt2li9PMD2enVMkbeZR8Ear27kabDm8qten6leNrlSEXAqN954o6644gqNHz9eS5Ys0X333adLL71UTqdTkyZNsnp5gO21ZD5K1s5Iu81HbtobhM2bN+uOO+7Q119/rWuuuUaPPvqo/uM//kM+n0/PP/+8+vfvb/USAVvz+UwNeLxAdUHuse7ePlH/N/1yOeMMjX/+k5Ddg6M53E5DW56YIEeo9l8AESovL09btmzRhAkTNHDgQK1atUqmaeqiiy6yemmA7TV3PkrWz0i7zUeaqSAMGDBARUVFTb734YcfWrQawJ4aGho0fPhw7dmzR0OGDNGQIUM0aNAgnXfeeRo8eLD6dE4J6g7v/zG2t+4anSlnnKH1u4/omzO4iMSZ6NslxTaDAjid3Nxc5ebm+r/mdiJA6ygrK1N+fr7iquIl94lX1DyZSJiRdpuPhKkgvPHGGxo1apR69uzZ5Pu1tbVav349gwMIAZ/Ppw0bNqi2tlZ79uxRXl6e/7G8vDwN69lDG/dUBLwAbHr7JNXWN2jp1wf0VN7mkF3lqDkcDmlYzw6t/4uBVlZcXKzdu3erV69e6t69u9XLAWzN4/Fo+fLlys/PV35+vtavP3Zp8vbjpio160rJEfhSCFbPSDvOR8JUEJ555hl99dVX/q+Liop00UUXKT4+Xnfffbe++OILC1cHRLe6ujp9+umnysvLO+kFXVwul3r37q0UtdP81aWqqj/9vSke+vu6cC01aImuOI3t39nqZQBhN3v2bD333HOaNWuWpk+fbvVyANtpbJ/y8/O1aNEiHT161P9YcnKyxo0bpwFjRuif5U5VewJv9bN6RtpxPhKmghAfH9/kH3lTpkzRhg0bZBhcDBFoiZ07d/qHw+LFi1VVdfI7oWdmZqqwsFAZGRk6x2cq2e0MGKYiQRu3UyMy7XXkDQAQfqdqnxoNHDhQOTk5ysnJ0ahRo+R2u+XzmSp8ZrGqPXUWrTp4dpyPhKkgGIahnTt3KiMjQ1u3btWuXbtUUlKixMREq5cGRIXj26f8/Hxt3ry5yeODBw9Wbm6uzjvvPE2ePFmSlJWVpby8PHXq1EmSZBgOTR2dqd8u3KraII6+WSXRZWjq6EwZhn32gwMAwieY9ik3N1cTJkxQRkbGCT/PfLQWYSoIjz/+uEaOHKl+/fqpsrJS8+bN04gRI+Tz+fTqq69avTwgIp2ufWrTpo2ys7OVk5OjCRMmKD093f/YsmXLVFFRoVdfffWEWw/ckJWuWR9vbbX30BI+U7o+Kz3wEwEAMakl7VMgzEfrEKaCcOWVV2rkyJHasWOHBg8erPj4eF155ZWSxFY/4F8a26f8/Hzl5eWdsn3KycnRiBEjTrgZdqNXXnnllL+jbaJLN2ala/7qUtU24zKwrSXBaeiGYelqm+iyeikAgAhSVlamgoIC5efna+HChSdtnxoD1Mnap0CYj9YhTAUpLS1NaWlp/q8JUUDL26cz8XDOABVs/Fa1RyNvb3jbJJcenjDA6mUAACwWjvYpEOajNQhTAIJ2fPuUn5+vTZs2NXk82PbpTCTGx2n2LUN12+srI2pveILL0Oybhyox/sQrEgIA7C/c7VMgzEdrEKYCqKqq0ptvvqmkpCTdcsstVi8HaHVWtE+BDOuZpklDu2vBmrKI2M6Q4DQ0aWi6snqmBX4yAMAWArVPAwYMUE5OjnJzc0PWPgXCfGx9hKkAKioqNHXqVJ111lmEKcSESGifgvHoxIHatLdCG/dUqM7CgeF2GhrYNVWPTrTn9gUAwPesbp+CwXxsXYQpABHZPgXidsZp3pSLNenVFSo+UGXJwHA7DWV2Sta8KRfL7bTn9gUAiGWR2D4FwnxsXYQpIAZFS/sUSLLbqQXTRui211dq056KVt3SkPCvI27zplysZDcfpQBgF9HQPgXCfGw99n+HACRJu3bt8l+2PFrap2Aku516c+pwzfxgsxasLW2Vk24TXMf2gD86cYDtj7gBgN1FY/sUDOZj6yBMATYVTPvUeGRt5MiREds+BcPtjNOT1wzW1UO66r6/rVVFjScsR+ESnIZSE12afctQDbPxybQAYHe7d+/2z8fTtU8TJkxQz549rVvoGWI+hh9hCrARu7ZPwRrWM02f/HyMni7YrLdXlcpwSDUhOBKX6DLkM6UbhqXr4QkDbHt5VwCwK4/HoxUrVigvL++07VNOTo5Gjx4dNe1TsJiP4UOYAqJYLLVPwUqMj9MTVw3W9PH99M7qUs1ZVqzKOq9qPA0yzeBfx+GQEl1xSnE7dffoTF2fZc87twOAXR3fPi1atEgVFRX+x+zUPgWL+RgehCkgysR6+xSstoku3TU6U1NG9tLy7Qe1ZOsBFZUc0rb9lTIcDjkNh0xJpmnK4XDIIcnrM+UzTfXtkqJhPTtobP/OGpHZQYbhsPrtAAACiPX2KVjMx9AiTAERrr6+XsuWLaN9aiHDcGh0n04a3aeTJMnnM7WrvFolB6tU621QvdeneKehBGecenVMVkaHJDkcDAcAiAana5+SkpKaXHkvFtqn5mA+hgZhCohAje1T432fKisr/Y/RPp0Zw3CoZ8dk9eyYbPVSAADNRPsUPszHliFMARGA9gkAgJOjfUIkI0wBFqF9AgDgRLRPiCaEKaCV0D4BAHBytE+IVoQpIIxonwAAsaKmpkaJiYn+q8CdTqD2qX///srNzaV9QsQjTAEhVF9f77/vU15eHu0TAMDWioqKtHDhQi1ZskRnnXWW3njjjVMGKdon2BFhCjhDtE8AgFhRWVmplJQU/9fDhw/XXXfdpWeeeUZZWVkn/Zn9+/dr/PjxWrduXZPv0z7BDghTwHGWL1+uX/3qV/rpT3+qa6+9Vj6fT4ZhNHkO7RMAIJYcPHhQc+bM0ccff6yjR49q6tSp+vGPf6z09HSNHTtWV111lbKysk65vS81NVV79uyhfYItEaYAyR+avv76a+3evVuffvqprr32Wv9QME1Ta9as0ZNPPkn7BACICY3h6Msvv9R3332n559/XgkJCZo1a5Z2796tmTNn6rrrrtPkyZN144036uDBg5o0aZJuvvnmE16rsLBQffv2pX2C7RCmAEmGYcjj8eijjz7Sr371K73xxhtNtjI4HA4lJSXpvffek0T7BACwl+LiYv3ud79TXFycbrnlliZN0/nnn68LLrhAHTp0kCSNHj1an3/+uSTp5ptv1vvvv6/s7Gz17dtXN9xwgxITE3XllVcqLi5OkpSQkKBzzz3XsvcGhBNhCtCxo2+HDx9W27Zt1atXLyUnJ2v9+vW65JJL/MOkT58++vOf/6wxY8bQPgEAbKOmpkbPP/+8DMNQr1699LOf/Uyvvfaa+vbtK0nq1KmTpO93cRQUFGjy5MmSpPbt2ys/P9//WlOnTtXKlSuVk5PjD1OAnRGmELOO39vtcDj01ltvacSIERo2bJj69u2r+fPnq02bNho8eLAkyeVy6fbbb7dyyQAAhFxlZaXef/997dixQ9KxcPXaa6/pscceU3JysqRjM9MwDG3btk0HDx5U//79T/paXq9X1dXVcrvdQV0iHYh2hCnElMYr73311VeaNWuWkpKSJB0bEj6fTwsXLtTKlSv1z3/+U9XV1erTp48/TAEAYEcNDQ0aMmSItm3bpj59+mjkyJGaN2+e1q1b12SHhiTNnTtXw4YNU+/evf0/u337dv3hD3/Q2rVrVVVVpTlz5kgSQQoxwQj8FCB61dfXq7CwUA899JAGDx6sjIwM3XPPPXr55Zeb3N/C4XDo8OHDOnr0qHr16qWXXnpJo0aN0k033WTh6gEACD+n06mMjAz/jXO7d++ujh07auPGjZKOHXCUpJ07d6qoqEj333+/3njjDT3yyCOKi4uTx+NRSkqKnnzySX322WecH4WYQjMF2zndfZ9SUlKUnZ2t3NzcJvfJkKTHHnvMfxTt6NGjWrRokdauXavs7OxWXT8AAOHg8Xi0YsUK7dmzR1dddZV/C1+7du3Uo0cPFRUV6brrrlP79u1VW1vrv+BE4y1C/vKXv2jp0qWaOHGiBg0apNzcXDU0NGjQoEEaNGiQZe8LsBJhClHv+Ps+5efn+4+kNQr2ynsOh0MNDQ3+K/f9/ve/b43lAwAQNrt371ZBQYHy8vK0aNEiVVRUKC0tTdddd53/OU6nU5dddpnuueceHTlyRG3bttXnn3+um2++WXl5edq+fbv+/d//XcOHD1dRUdEpb84LxCLCFKJSaWmpPzwtWrTolO1Tc+/7xJWHAADRrLF9apyR69ata/J4//79lZOTI4/H0+SeT1lZWRo+fLimTZumTZs2qX///urfv7+6deum0aNHS5LGjx/fqu8FiAaEqVPwer3Kzc3VmjVrJEn79u1Tp06ddOutt+qFF16wdnExKFTtEwAAdnOy9qlRUlKSxo4d6z/A2KtXr1O+zvPPP6+VK1fK6/Xq8ssvlyT/VkAAJ0eYOo2VK1f6P5BM09TBgwf94QrhF0z71BiguO8TACBWBNs+5eTkaPTo0UpISAjqdV0ul0aNGhWOJQO2RZg6BafTqQceeEAzZ85s8v3p06dbtCL7o30CAODkGtun/Px8LVy4sMXtE4DQIkydxoMPPqgXXnhBR48elSQNGTJEV199tcWrshfaJwAAThSu9glAaBGmTiMtLU133nmn/xypxx9/nBvQnaH6+notX75ceXl5J22fGi+1SvsEAIg1tE9A9CFMBTBjxgy9+OKLateuHa1UCwXbPk2YMEE9evSwcKUAALQej8ejzz77zH+AkfYJiD6EqQC6dOmiqqoqxcXF0UoFqbF9ys/PV15e3knbp5ycHOXm5tI+AQBiCu0TYC+EqVPw+UztLK9WycFK1Xp88jT45IozlOAy1KtjijLSkmQYhKtGtE8AEBuOn4+VaX2UNPAyHUxMV+GWfczHk2hsnxoPMNI+AfbiME3TtHoRkcDnM7V8+0EVbtmvVTvKtW1/pQyHQ07DIVOmTFNyOCSHHPL6TPlMU306p2hYzzSN7d9ZI8/pGFPD4/j2KT8/Xxs2bGjyOO0TANhDoPno9TbI6YxjPh4nmPapMUDRPgHRLebD1JEaj+avLtXcZcWqqvOqur5BzfkLcUhKio9TstupqaMzdUNWutomusK1XEvRPgFA7GA+Bo/2CYhdMRumauob9HT+Zr29ulQOh1Tr8Z3xaya6DPlM6casdD2cM0CJ8XEhWKl1gm2fcnJyNGrUKNonALAB5mNw9uzZ45+PtE9A7IrJMFVUUq7731yrihqPar1nPiR+KMFpKDXRpdm3DNWwnmkhf/1won0CgNjFfDy149un/Px8ffXVV00ep30CYlNMhak6b4NmfrBJC9aWheRIWyAJLkOThnbXoxMHyu2MzKNwtE8AAObjydE+AQgkZsJUVZ1Xk19bqc17K8JytO1UEpyGBnZN1bwpFyvZHRkXTywrK/Pv6168eLGOHj3qfywlJUXjxo3zX5aV9gkA7I35+D3aJwDNFRNhqqrOq0mvrlDxgSrVteKgaOR2GsrslKwF00ZYMjBonwAAJxPr81E61j4VFBQoLy+P9glAs9k+TNV5G3TTnM+1aW+FJYOikdtpaFDXVL05dXirbGkIpn1qHA60TwAQe2J1PtI+AQgl24ep/353vRasKWvVrQunkuA0NOnCdD15zeCQvzbtEwCgOWJlPkrft0+N5z4dOXLE/xjtE4AzERmblMOkqKT82Mm0ETAoJKnW69OCtaW6ekjXkFzFqLF9arzyHu0TACAYdp+PtE8AWottm6ma+gZdNmuJ9h+ts3opJ+jcxq1Pfj6m2ffZCNQ+DRw4ULm5ubRPAIBTiub5WFtbe8rgQ/sEwAq2baaeyt+sihqP1cs4qYoaj54u2Kwnrgq8nYH2CQAQStE4Hz0ej+6++2795S9/UWFhoS677LKA7VO/fv2Uk5Oj3Nxc2icAYWPLZupIjUcXPbXI0hNqA3E7DRU9kq22ia4m3/d4PFq+fLny8vJonwAAIRWN87G6ulrXX3+98vLyJEmjR49Wly5daJ8ARARbNlPzV5fK4bB6FadnOKR3VpfqrtGZtE8AgFYRbfNx//79GjduXJMDi8uWLfP/mfYJgNVs10z5fKaGP7M4IveC/1CCWSfnh7/Sxg3rm3yf9gkAEGrRNB87t3Hr8xnj1LXr2dq3b98Jjz/yyCO66667aJ8AWM52zdTy7QdVVee1ehlBqfb4dOCooeTkZGVnZysnJ0cTJkxQRkaG1UsDANhMNM3HyjqvVhQfUrdu3U4aprp27UqQAhARbBemCrfsV3V9g9XLCIoRn6Bbf/GMZt85Rm632+rlAABsLJrmY42nQYVb9mvNmjWqra3Vxo0b9eWXX+rLL79UWVmZsrOzrV4iAEiyYZhataNcgfYtfvqLMerePkl3z1utjzcdO+L12MSBmjKylxasKdXPF6zTiHM66D+z+6rfWW1kOBw6UFmnDbuP6P43v5AkTRraXbOuP1+SVO/1qbreqx2HqvXxpm/12qclQZ7c69A+XzJBCgAQdtE0H01TWrXjkCQpISFBF154oS688MKWv3kACBNbhSmfz9S2/ZVn/DpdUt36w+1ZcsUZKtjwrY7WeZXZMVnZA7qc8NxDlXX657o9Sm+fpEv7dNKQ9HbKHtBFN8/9PKiB8fW+SpmmKUeknxEMAIhazEcACA9bhamd5dUyQvChOyS9vZLinVq46Vv9+1tf+L//w8uYS9K+ilr9+v1NkqRBXVP1j3tHaGiP9poyspde/mR7wN9lOBzaeahaPTsmn/G6AQA4GeYjAISHYfUCQqnkYKWcxpkPiwNHayVJY/t30bwpF+ln2X00rGd7VdSe/iaHG/dU6OONx7ZFjOvfOajf5TQcKjlYdWYLBgDgNJiPABAetgpTtR6fzIA7wgNbu+uwXl26XaZpanSfTnpgXF+9M22E/nnfKKUmnL7M2324RpLUISW486BMSbXe6DghGAAQnZiPABAetgpTngafgrlrVq3n2F5tV9z3bz/+X3+u+ddjT+dvUdZTi3Tf39bqbyt3qt7r07nd2ur6rPTTvna3domSju0VD4ZpmqqP4DvRAwCiH/MRAMLDVmHKFWcEdWf3neXHtg0M7dFO0rG7rQ9JP/bnHYeq1LVtgnqkJelwtUcfrt+rR97doP/bul+SlOI+9ZG3QV1T9aNBx07CXbxlf1Brdjgcinfa6j8DACDCMB8BIDxsdQGKBJchhwJPi7eKSjWufxfdOSpTF2akqW2iS706Jqui1qN/frVH53Zrq7m3ZemLXd9p+4EqJcYbGtO/s3w+U8u/OdjktbqkJujxKweqe7skXda3k+Kdhtbu+k6vLy8Jas0OSQnOuJa8XQAAgsJ8BIDwsFWY6tUxRV5f4H0MCzfv0wNvf6G7RmXqnE7JqvP6tHTbAf3mo606cLROX+87qn+sLVNWzzQNODtVpqSt3x7VnGXFWr3zuyav1SHFrckXZ6iqzqtNe4/oo4379NqnJapvCG5rgtdnqhdXKgIAhBHzEQDCw2Gaweyijg4+n6kBjxcEecPcyOB2GtryxATuowEACBvmIwCEh602IxuGQ306p1i9jGbp2yWFQQEACCvmIwCEh63ClCQN65kWxK7wyOBwSMN6drB6GQCAGMB8BIDQs12YGtu/s5Lio+OE1URXnMYGefNCAADOBPMRAELPdmFq5DkdlXyay7NGkjZup0ZkcuQNABB+zEcACD3bhSnDcGjq6EwluCL7rSW6DE0dnSnDiJZNFwCAaMZ8BIDQi+xP1Ba6ISs9qDu9W8lnKuDd4gEACCXmIwCEli3DVNtEl27MSldChN45PcFp6MZh6Wqb6LJ6KQCAGMJ8BIDQisxP0xB4OGeAUiP0w7htkksPTxhg9TIAADGI+QgAoWPbMJUYH6fZtwyNuL3hCS5Ds28eqsQouaISAMBemI8AEDqR9UkaYsN6pmnS0O4Rs50hwWlo0tB0ZfVMs3opAIAYxnwEgNCIjE/RMHp04kAN7Joqt8UDw+00NLBrqh6dyPYFAID1mI8AcOZsH6bczjjNm3KxMjslWzYw3E5DmZ2SNW/KxXI72b4AALAe8xEAzpztw5QkJbudWjBthAZ1TW31LQ0JTkODuqZqwbQRUXOzRABAbGA+AsCZcZhmpN9xInTqvA2a+cFmLVhbqlqPL+y/L8F1bA/4oxMHcMQNABCxmI8A0DIxFaYardpRrvv+tlYVNR7VekM/NBKchlITXZp9y1AN42RaAECUYD4CQPPEZJiSpJr6Bj1dsFlvryqV4ZBqQnAkLtFlyGdKNw5L18MTBnB5VwBA1GE+AkDwYjZMNTpS49E7q0s1Z1mxKuu8qvE0qDl/Iw6HlOiKU4rbqbtHZ+r6LO7cDgCIfsxHAAgs5sNUI5/P1PLtB7Vk6wEVlRzStv2VMhwOOQ2HTEmmacrhcMghyesz5TNN9e2SomE9O2hs/84akdlBhuGw+m0AABBSzEcAODXC1Cn4fKZ2lVer5GCVar0Nqvf6FO80lOCMU6+OycrokCSHg+EAAIgtzEcA+B5hCgAAAABaICbuMwUAAAAAoUaYAgAAAIAWIEwBAAAAQAsQpgAAAACgBQhTAAAAANAChCkAAAAAaAHCFAAAAAC0AGEKAAAAAFqAMAUAAAAALUCYAgAAAIAWIEwBAAAAQAsQpgAAAACgBQhTAAAAANAChCkAAAAAaAHCFAAAAAC0AGEKAAAAAFqAMAUAAAAALUCYAgAAAIAWIEwBAAAAQAsQpgAAAACgBf4fIe67fW4rSBoAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# n is the number of vertices in the graph G\n", "n = 3\n", @@ -163,27 +182,27 @@ "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", + "metadata": {}, "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, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.237497Z", + "start_time": "2021-05-17T08:00:16.219567Z" + } + }, + "outputs": [], "source": [ "# Penalty parameter: in this case, it is equal to the maximum weight of the edges in the directed graph\n", "penalty = 4 \n", @@ -191,21 +210,15 @@ "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", + "metadata": {}, "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", + "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 method [`complex_entangled_layer()`](https://qml.baidu.com/api/paddle_quantum.ansatz.circuit.html#Circuit.complex_entangled_layer).\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", @@ -216,100 +229,76 @@ "$$\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, + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.258893Z", + "start_time": "2021-05-17T08:00:16.241066Z" + } + }, + "outputs": [], "source": [ "class AONet(paddle.nn.Layer):\n", - " def __init__(self, n, p, K, dtype=\"float64\"):\n", + " def __init__(self, num_qubits, p, 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", + " self.depth = p\n", + " self.num_qubits = num_qubits\n", + " self.cir = Circuit(self.num_qubits)\n", + " self.cir.complex_entangled_layer(depth=self.depth)\n", "\n", - " def forward(self, hamiltonian):\n", + " def forward(self):\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", + " state = self.cir(init_state)\n", " # Calculate the loss function\n", - " loss = cir.expecval(hamiltonian)\n", + " loss = loss_func(state)\n", "\n", - " return loss, cir" - ], - "outputs": [], - "metadata": { - "ExecuteTime": { - "end_time": "2021-05-17T08:00:16.258893Z", - "start_time": "2021-05-17T08:00:16.241066Z" - } - } + " return loss, self.cir" + ] }, { "cell_type": "markdown", + "metadata": {}, "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, + "execution_count": 13, + "metadata": {}, + "outputs": [], "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", + "metadata": {}, "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())" - ], + "execution_count": 16, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "iter: 10 loss: 0.4704\n", "iter: 20 loss: 0.1302\n", @@ -326,10 +315,34 @@ ] } ], - "metadata": {} + "source": [ + "# Fix paddle random seed\n", + "paddle.seed(SEED)\n", + "# define the number of qubits need for circuit\n", + "num_qubits = n * K\n", + "# Building Quantum Neural Networks\n", + "net = AONet(num_qubits, p)\n", + "# Define initial state\n", + "init_state = paddle_quantum.state.zero_state(num_qubits)\n", + "# Use Adam optimizer\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "# define loss function\n", + "loss_func = paddle_quantum.loss.ExpecVal(hamiltonian)\n", + "# Gradient descent iteration\n", + "for itr in range(1, ITR + 1):\n", + " # Run the network defined above\n", + " loss, cir = net()\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())" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Decoding the quantum solution\n", "\n", @@ -340,82 +353,100 @@ "\\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", + "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 the 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)" - ], + "execution_count": 17, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "The bit string form of the solution: 100001010\n" ] } ], - "metadata": {} + "source": [ + "# Repeat the simulated measurement of the circuit output state 1024 times\n", + "final_state = cir(init_state)\n", + "prob_measure = final_state.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)" + ] }, { "cell_type": "markdown", + "metadata": {}, "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)" - ], + "execution_count": 18, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:02:14.554317Z", + "start_time": "2021-05-17T08:02:14.500593Z" + } + }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "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" - } - } + "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)" + ] }, { "cell_type": "markdown", + "metadata": {}, "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, + "execution_count": 19, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:02:14.571954Z", + "start_time": "2021-05-17T08:02:14.559634Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "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", @@ -434,46 +465,29 @@ "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", + "metadata": {}, "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", + "metadata": {}, "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", + "metadata": {}, "source": [ "_______\n", "\n", @@ -484,8 +498,7 @@ "[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": { @@ -493,8 +506,9 @@ "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" }, "kernelspec": { - "name": "python3", - "display_name": "Python 3.7.11 64-bit ('pq_env': conda)" + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -506,7 +520,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.11" + "version": "3.9.7" }, "toc": { "base_numbering": 1, @@ -524,4 +538,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/tutorials/combinatorial_optimization/DC-QAOA_CN.ipynb b/tutorials/combinatorial_optimization/DC-QAOA_CN.ipynb new file mode 100644 index 0000000..9bdba4c --- /dev/null +++ b/tutorials/combinatorial_optimization/DC-QAOA_CN.ipynb @@ -0,0 +1,734 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 大规模量子近似优化分治算法\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 概览\n", + "\n", + "[量子近似优化算法](./QAOA_CN.ipynb)（quantum approximate optimization algorithm, QAOA）是一个将量子与经典结合起来，用于解决组合优化问题的算法。但是，由于现阶段量子比特数量的限制，该算法无法处理大规模问题，且该算法的运行时间随着问题规模的增大，成指数增长。关于量子近似优化算法更详细的讨论见 [1]。\n", + "\n", + "分治法（divide-and-conquer, DC）是可以解决上述瓶颈的一种方法。主要是将一个大问题拆分若干个相似的子问题，将这些子问题解决之后再将子问题合并，从而得到母问题的解。Junde Li 等人在2021年提出量子近似优化的分治算法 [2] 将上述技术应用于解决较大规模的最大割问题。本教程所使用的方法在该论文的基础之上做出了一些改进。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 具体算法" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 大图分割\n", + "\n", + "在图论中，我们用一个图形的边 $E$ 和顶点 $V$ 定义一个图形 $G=(V,E)$。假设它有 $|V| = n$ 个顶点，但是含噪中型量子（noisy intermediate-scale quantum, NISQ）设备上最多可以运行 $k$ 个量子比特（$n > k$）。这种情况下，我们使用``大图分割 LGP``的方法将图形 $G$ 拆分两个子图 $G_0$ 和 $G_1$。为了防止遗漏任意一条边，在拆分的时候至少有一个点被两个子图共同拥有。我们把这些共有的顶点叫做分离顶点（集合），并且约束这个集合的大小小于 $k$。以下的代码定义了如何进行大图分割。" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-16T03:41:44.449329Z", + "start_time": "2021-05-16T03:41:43.034272Z" + } + }, + "outputs": [], + "source": [ + "import networkx as nx # networkx的版本 >= 2.5\n", + "import matplotlib.pyplot as plt\n", + "from itertools import combinations\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# 将一个图形分割成两个有重合的分离顶点子图\n", + "def NaiveLGP(g, k):\n", + " E = list(g.edges)\n", + " E = [(min([u, v]),max([u, v])) for (u, v) in E]\n", + " E.sort(key=lambda tup:tup[0])\n", + " V = list(g.nodes)\n", + " V.sort()\n", + "\n", + " counter = 1\n", + " while counter < k:\n", + " num_nodes = counter\n", + " nodes_combo = list(combinations(V, num_nodes))\n", + " # 找有效的分离顶点\n", + " for p in nodes_combo:\n", + " V1 = [x for x in V if x not in p]\n", + " E1 = [e for e in g.edges if e not in g.edges(p)]\n", + " G1 = nx.Graph()\n", + " G1.add_nodes_from(V1)\n", + " G1.add_edges_from(E1)\n", + " S = [G1.subgraph(c).copy() for c in nx.connected_components(G1)]\n", + " if len(S) == 2:\n", + " # 将分离顶点加入不相连的子图中\n", + " V_S0 = list(S[0].nodes)\n", + " E_S0 = list(S[0].edges) \n", + " V_S1 = list(S[1].nodes)\n", + " E_S1 = list(S[1].edges)\n", + " for (u, v) in g.edges(p):\n", + " if u in V_S0 or v in V_S0:\n", + " S[0].add_edges_from([(u, v)])\n", + " if u in V_S1 or v in V_S1:\n", + " S[1].add_edges_from([(u, v)])\n", + " if u in p and v in p:\n", + " S[0].add_edges_from([(u, v)])\n", + " S[1].add_edges_from([(u, v)])\n", + "\n", + " return S\n", + "\n", + " counter += 1\n", + " print(\"G的连接度大于k\")\n", + "\n", + " return {}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们给了以下的例子去说明``大图分割``是如何进行的。假设一个随机图形有10个顶点，但是 NISQ 设备最多支持9个量子比特，即 $k=9$。那么根据``大图分割``，红色的顶点0和2将被选为分离顶点。首先将这些分离顶点去掉，剩下的图将是一个不连接图形并可以被分成两个子图，比如下图中的顶点3-9和顶点1。随后，我们再将这些分离顶点和相关边分别加回两个子图中，从而保证所有的边都不会被遗漏。" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-16T03:41:44.839484Z", + "start_time": "2021-05-16T03:41:44.455664Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 生成一个有 10 个顶点的图形\n", + "n = 10\n", + "G = nx.Graph()\n", + "G.add_nodes_from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n", + "G.add_edges_from([(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (1, 7),\n", + " (5, 6), (6, 7), (7, 8), (8, 9), (9, 0)])\n", + " \n", + "k = 9 # 设定量子比特的最大数量\n", + "S = NaiveLGP(G,k) # 利用大图分割对图形 G 进行分割\n", + "sep_node = list(set(S[0].nodes).intersection(set(S[1].nodes))) # 找到分离顶点\n", + "\n", + "# 图形示例\n", + "options = {\n", + " \"with_labels\": True,\n", + " \"font_color\": \"white\"\n", + "}\n", + "node_color1 = [\"red\" if i in sep_node else \"blue\" for i in range(n)]\n", + "node_color2 = [\"red\" if list(S[0].nodes)[i] in sep_node else \"blue\" for i in range(len(S[0].nodes))]\n", + "node_color3 = [\"red\" if list(S[1].nodes)[i] in sep_node else \"blue\" for i in range(len(S[1].nodes))]\n", + "\n", + "fig, ax = plt.subplots(1, 3, figsize=(15, 4))\n", + "for i, a in enumerate(ax):\n", + " a.axis('off')\n", + " a.margins(0.20)\n", + "nx.draw_networkx(G, pos=nx.circular_layout(G), ax=ax[0], **options, node_color=node_color1)\n", + "nx.draw_networkx(S[0], pos=nx.circular_layout(S[0]), ax=ax[1], **options, node_color=node_color2)\n", + "nx.draw_networkx(S[1], pos=nx.circular_layout(S[1]), ax=ax[2], **options, node_color=node_color3)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "值得提醒的一点是，我们的例子中 $k=9$，``大图分割``得到的两个子图的顶点数都小于或等于 $k$，那么两个子图的最大割问题可以直接被``量子近似优化算法``解决。但如果得到的子图的顶点数依然大于 $k$，那我们将对子图重复之前的做法，直至所有的子图顶点都小于或等于 $k$。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 图形重构\n", + "\n", + "当``量子近似优化（分治）算法``被应用到分离的子图上之后，所有的顶点会被分成两个部分，即 $S_0$ 和 $S_1$。我们需要将子图的最大割进行整合，得到母图的最大割。因为两个子图有共同的顶点，即分离顶点，我们要确保它们所在的最大割集合吻合，即 $S_0$ 还是 $S_1$ 需要吻合。比如，如果对于一个子图来说，分离顶点在它的最大割当中所在的分割集合都是 $S_0$，而另一个子图的最大割中，分离顶点们在的分割集合是 $S_1$，那么相应的两个最大割将不能被整合。所以为了解决这一问题，对于每个子图，我们将提供多个可能的最大割，从而在这些可能的最大割当中寻找可以整合的且可能性最高的进行整合，从而得到母图的最大割。" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-16T03:41:46.108438Z", + "start_time": "2021-05-16T03:41:45.970323Z" + } + }, + "outputs": [], + "source": [ + "def GR(str_cnt1, str_cnt2):\n", + " com_cnt = []\n", + " n = len(str_cnt1[0][0])\n", + " com_index = []\n", + " for i in range(n):\n", + " if str_cnt1[0][0][i] != \"x\" and str_cnt2[0][0][i] != \"x\":\n", + " com_index.append(i)\n", + "\n", + " for (str1, cnt1) in str_cnt1:\n", + " for (str2, cnt2) in str_cnt2: \n", + " # 检查分离顶点在两个子图所在的集合是否一致\n", + " validity = [str1[i] == str2[i] for i in com_index]\n", + " if False not in validity:\n", + " com_str = [[0]] * n\n", + " for i in range(n):\n", + " if str1[i] != \"x\":\n", + " com_str[i] = str(str1[i])\n", + " else:\n", + " com_str[i] = str(str2[i])\n", + " com_cnt.append((\"\".join(com_str), min(cnt1, cnt2)))\n", + "\n", + " # 将{最大割：频率}按频率从大到小排列\n", + " com_cnt.sort(key=lambda tup:tup[1])\n", + " return com_cnt[::-1]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们将延续上述10个顶点的圆的例子对``图形重构（graph reconstruction, GR）``进行说明。对于所分得的两个子图，我们先用``量子近似优化算法``求解最大割，再用``图形重构``将子图的最大割整合，得到原图的最大割。下面所给的代码实现了这一步骤。代码中的参数 $t$，代表想要保留最有可能的最大割的数量。如果 $t$ 大于 $2^n$，那么所有可能的最大割，即所有可能的顶点分类，都将被保留用于整合。" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-16T03:42:41.303385Z", + "start_time": "2021-05-16T03:41:47.071053Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "第一个子图的最大割：\n", + "{'01101010xx': 0.07865697145462036, '10010101xx': 0.07865697145462036, '01010101xx': 0.07865694910287857, '10101010xx': 0.07865694910287857, '01010010xx': 0.04094246029853821, '10101101xx': 0.04094246029853821, '01011010xx': 0.04005919396877289, '01010110xx': 0.04005919396877289, '10101001xx': 0.04005919396877289, '10100101xx': 0.04005919396877289}\n", + "第二个子图的最大割：\n", + "{'1xxxxxx010': 0.4556591808795929, '0xxxxxx101': 0.4556591808795929, '0xxxxxx011': 0.025223204866051674, '1xxxxxx100': 0.025223204866051674, '0xxxxxx110': 0.010825536213815212, '1xxxxxx001': 0.010825536213815212, '0xxxxxx111': 0.002283714711666107, '1xxxxxx000': 0.002283714711666107, '1xxxxxx011': 0.00228371424600482, '0xxxxxx100': 0.00228371424600482}\n", + "母图的最大割：\n", + "{'1010101010': 0.07865694910287857, '0101010101': 0.07865694910287857, '1010010100': 0.025223204866051674, '1010100100': 0.025223204866051674, '0101011011': 0.025223204866051674, '0101101011': 0.025223204866051674, '1010110100': 0.025223204866051674, '0101001011': 0.025223204866051674, '1001010100': 0.025223204866051674, '0110101011': 0.025223204866051674}\n" + ] + } + ], + "source": [ + "# 我们利用 量子近似优化算法 计算上面例子两个子图的最大割\n", + "# 在下一小章中，我们将使用 量子近似优化分治算法 计算子图的最大割，因为子图顶点数量有可能超过量子比特的限制。\n", + "import paddle\n", + "from paddle_quantum.QAOA.maxcut import find_cut\n", + "\n", + "# 设定 量子近似优化算法 中的参数\n", + "p = 3 # 量子电路的层数\n", + "ITR = 100 # 训练迭代的次数\n", + "LR = 0.5 # 基于梯度下降的优化方法的学习率\n", + "# 设定 图形重构 中的参数\n", + "t = 10 # 想要保留最有可能的最大割的数量\n", + "paddle.seed(999) # 固定随机种子\n", + "\n", + "# 图形重构完整过程\n", + "S_str_cnt = []\n", + "for si in S:\n", + " siv = list(si.nodes)\n", + " \n", + " # 计算子图的最大割\n", + " tmp, si_str_cnt_relabeled = find_cut(si, p, ITR, LR)\n", + " \n", + " # 填充子图的最大割结果，使它们和原图的顶点数量和顺序吻合\n", + " si_str_cnt = []\n", + " for str_relabeled in si_str_cnt_relabeled:\n", + " strr = \"\"\n", + " for i in range(len(G.nodes)):\n", + " if i in siv:\n", + " strr += str_relabeled[siv.index(i)]\n", + " else:\n", + " strr += \"x\"\n", + " si_str_cnt.append((strr, si_str_cnt_relabeled[str_relabeled]))\n", + " si_str_cnt.sort(key=lambda tup:tup[1])\n", + " S_str_cnt.append(si_str_cnt[::-1][:t])\n", + "\n", + "# 当子图的最大割被找到之后，我们开始图形重构这一步\n", + "print(\"第一个子图的最大割：\\n\" + str(dict(S_str_cnt[0])))\n", + "print(\"第二个子图的最大割：\\n\" + str(dict(S_str_cnt[1])))\n", + "out_cnt = GR(S_str_cnt[0], S_str_cnt[1])\n", + "print(\"母图的最大割：\\n\" + str(dict(out_cnt[:t])))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "就以上例子来说，对于第一个子图而言，最有可能的几个最大割将包括 {'01010101xx', '10010101xx', '01101010xx', '10101010xx'}，而第二个子图最有可能的最大割将包括 {'0xxxxxx101,'1xxxxxx010'}。这些字符串中的 'x' 代表不在这个子图却在母图的顶点。\n", + "\n", + "从这个例子中我们看到，分离顶点 0 和 7 在第一个子图中可能的最大割，'01010101xx' 中分别属于 $S_0$ 和 $S_1$，它们在第二个子图的最大割，'0xxxxxx101'，中也分别属于 $S_0$ 和 $S_1$，所以我们可以整合这两个最大割并得到母图的最大割，'0101010101'，如下图第三张图所示。\n", + "\n", + "以下为图形展示，前两个图为两个子图的最大割实例，最右的图为母图的最大割。红色点和蓝色点分别表示被分在在 $S_0$ 和 $S_1$ 中的顶点，虚线表示被切割的边。" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-16T03:42:41.647686Z", + "start_time": "2021-05-16T03:42:41.309407Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# 计算出的两个子图的最大割\n", + "strr1 = '01010101xx'\n", + "strr2 = '0xxxxxx101' \n", + "strr = '0101010101'\n", + "\n", + "# 图形示例展示\n", + "options0 = {\n", + " \"node_color\": [\"red\" if strr1[i] == '0' else \"blue\" for i in S[0].nodes],\n", + " \"style\": [\"solid\" if strr1[u] == strr1[v] else \"dashed\" for (u, v) in list(S[0].edges)]\n", + "}\n", + "options1 = {\n", + " \"node_color\": [\"red\" if strr2[i] == '0' else \"blue\" for i in S[1].nodes],\n", + " \"style\": [\"solid\" if strr2[u] == strr2[v] else \"dashed\" for (u, v) in list(S[1].edges)]\n", + "}\n", + "options2 = {\n", + " \"node_color\": [\"red\" if strr[i] == '0' else \"blue\" for i in range(n)],\n", + " \"style\": [\"solid\" if strr[u] == strr[v] else \"dashed\" for (u, v) in list(G.edges)]\n", + "}\n", + "\n", + "fig, ax = plt.subplots(1, 3, figsize=(15,4))\n", + "for i, a in enumerate(ax):\n", + " a.axis('off')\n", + " a.margins(0.20)\n", + "nx.draw_networkx(S[0], pos=nx.circular_layout(S[0]), ax=ax[0], **options, **options0)\n", + "nx.draw_networkx(S[1], pos=nx.circular_layout(S[1]), ax=ax[1], **options, **options1)\n", + "nx.draw_networkx(G, pos=nx.circular_layout(G), ax=ax[2], **options, **options2)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 量子近似优化分治法\n", + "\n", + "为了找到一个大图 $G$ 的最大割，我们采用``量子近似优化分治法``。这个方法像上面描述的一样，先递归性地利用``大图分割``分割图形，再利用``图形重构``递归性地整合两个子图的最大割。\n", + "\n", + "首先如果输入图形的顶点数大于量子比特数量限制 $k$，它将被``大图分割``分成两个子图。反之，可以直接求解它的最大割（不用拆分）。每一个子图将递归性地被输入进``量子近似优化分治法``，直到它的最大割被返回。最大割被返回说明在某一步，它某些递归的子图的顶点数量小于$k$，直接被``量子近似优化分治法``解得，再一层一层地经历``图形重构``，直到返回这个子图所在层。\n", + "\n", + "下面是利用``图形重构``和``大图分割``完成的``量子近似优化分治法``的代码。``量子近似优化分治法``将返回最有可能的最大割和前 $t$ 个最有可能的最大割。" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-16T03:44:13.784486Z", + "start_time": "2021-05-16T03:42:41.653981Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "最有可能的 t 个图形 G 的最大割: {'1010100100': 413, '1010101100': 405, '0101010011': 390, '0101011011': 379, '0100101011': 255, '1001010100': 253, '1011010100': 245, '0110101011': 230, '1010110100': 214, '0101010101': 212}\n", + "量子近似优化分治算法找到的图形 G 的（最有可能的）最大割: 1010100100\n" + ] + } + ], + "source": [ + "def DC_QAOA(g, p, t, s, k, ITR, LR):\n", + " if len(g.nodes) > k:\n", + " # 利用 大图分割 得到两个子图\n", + " S = NaiveLGP(g, k)\n", + "\n", + " S_str_cnt = []\n", + " for si in S:\n", + " siv = list(si.nodes)\n", + " # 递归性地计算子图的最大割\n", + " _, si_str_cnt_relabeled = DC_QAOA(si, p, t, s, k, ITR, LR)\n", + " # 填充子图的最大割结果，使其和母图的顶点吻合\n", + " si_str_cnt = []\n", + " for str_relabeled in si_str_cnt_relabeled:\n", + " strr = \"\"\n", + " for v in g.nodes:\n", + " if v in siv:\n", + " strr += str_relabeled[siv.index(v)]\n", + " else:\n", + " strr += \"x\" \n", + " si_str_cnt.append((strr, si_str_cnt_relabeled[str_relabeled]))\n", + " si_str_cnt.sort(key = lambda tup:tup[1])\n", + " S_str_cnt.append(si_str_cnt[::-1][:t])\n", + "\n", + " # 利用 图形重构 整合子图最大割\n", + " out_cnt = GR(S_str_cnt[0], S_str_cnt[1])\n", + " else:\n", + " if len(g.nodes) == 1:\n", + " return [(\"0\", 99999), (\"1\", 99999)]\n", + " _, out_cnt = find_cut(g, p, ITR, LR, shots=3000)\n", + " # 将词典格式转成列表格式，易于排序\n", + " out_cnt = [(k, v) for k, v in out_cnt.items()]\n", + " # 将{最大割：频率}按频率从大到小排列\n", + " out_cnt.sort(key=lambda tup:tup[1])\n", + " out_cnt = out_cnt[::-1]\n", + "\n", + " # 只保留最有可能的t个最大割\n", + " out_cnt = out_cnt[:t]\n", + " # 等比例调节频率的显示\n", + " cnt_sum = sum(cnt for (str,cnt) in out_cnt)\n", + " out_cnt = [(k, int(s * v / cnt_sum)) for (k, v) in out_cnt]\n", + "\n", + " return out_cnt[0][0], dict(out_cnt)\n", + "\n", + "# 设定 量子近似优化算法 中的参数\n", + "p = 2 # 量子电路的层数\n", + "ITR = 100 # 训练迭代的次数\n", + "LR = 0.5 # 基于梯度下降的优化方法的学习率\n", + "\n", + "# 设定 量子近似优化分治算法 中的参数\n", + "s = 3000 # 等比例调节频率的比例\n", + "t = 10 # 想要保留最有可能的最大割的数量\n", + "k = 5 # 量子比特的数量限制\n", + "\n", + "# 量子近似优化分治算法使用\n", + "max_cut, out_cnt = DC_QAOA(G, p, t, s, k, ITR, LR)\n", + "print(\"最有可能的 t 个图形 G 的最大割: \" + str(out_cnt))\n", + "print(\"量子近似优化分治算法找到的图形 G 的（最有可能的）最大割: \" + str(max_cut))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 应用范围\n", + "\n", + "**以上表述的``量子近似优化分治法``可以估计一个图形的最大割，当且仅当，它和它递归出来的顶点数量大于 $k$，且子图的伪连接度（pseudo-connectivity）都小于 $k$**。伪连接度的定义为：一个连接图变成不连接的两个子图所需要移除的最小的顶点数量。\n", + "\n", + "当 $k > 1$ 的时候，圆圈就是一个例子。因为只需要移除两个点，圆圈就会被拆成两条不相连的子图，所以所有圆圈的伪连接度都是2。我们拿六个顶点的圆 $C_6$ 并且 $k=4$ 举例。``大图分割``会将它分成 $P_5$（顶点数量为5的子图）和 $P_2$，$P_2$ 的顶点数量在 $k$ 之下，可以直接使用``近似优化算法``计算。而子图 $P_5$ 是一个链状结构，他的伪连接度是 $1 < k$。所以``大图分割``将继续分割 $P_5$，并把它分成了 $P'_4$ 和 $P'_2$。新的子图的顶点数量都小于或等于 $k$，我们都不再需要考虑他们伪连接度。\n", + "\n", + "``量子近似优化分治法``不可解的图包括顶点数量大于 $k$ 的完全图（complete graph）。对于完全图来说，无论怎么移除顶点，剩余的图都是连接图。有些图是否适用决定于 $k$ 的大小，我们以下给了个这样的例子。\n", + "\n", + "最左的图就是实例图，这个图的伪连接度是2。如果 $k=2$，那么分离点的数量只能为1个，如果分离点是4,那么这个图被拆分成三部分而不是两部分（下图中间所示）；如果分离点是其他的几个，这个图仍然连在一起，没有被拆开。此外，该图的伪连接度为2并不小于 $k$，不满足条件，所以``量子近似优化分治法``并不适用于这个例子。但如果 $k=3$，伪连接度是 $2 < k$，这个图可以进行拆分成两个子图，其中一个的顶点数量小于等于 $k$，另一个的伪连接度显而易见是 $1" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(value_dc_qaoa_ls, label=\"DC-QAOA\")\n", + "plt.plot(ubound_sdp_ls, label=\"SDP upper bound\", linestyle=\"--\")\n", + "plt.title('Max-Cut Performancce')\n", + "plt.xlabel('Random Graph')\n", + "plt.ylabel('Calculated Optimal Max Cut')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "从上面的线形图中，我们可以说明``量子近似优化分治法``找到的最大割和理论上限接近。\n", + "\n", + "## 应用\n", + "\n", + "最大割问题属于应用范围很广的二次无约束二值优化（quadratic unconstrained binary optimization, QUBO）问题。此类问题的应用范围十分广泛，上至为NP-困难问题创建模型，下到找自旋玻璃的基态 [5]。同时最大割问题本身也有很广泛的应用。\n", + "\n", + "最大割问题和很多领域都有紧密的联系，比如超大规模集成电路（VLSI circuit）设计，统计物理。减少超大规模集成电路设计所用的孔和寻找自选玻璃基态都可以归约到最大割问题 [6]。更重要的是，最大割问题给很多算法或者技术提供了一个测试台。比如适用于最大割问题的半正定规划方法被后续用在了数据集合设计 [7] 和相位检索上 [8, 9]。\n", + "\n", + "更多关于最大割的应用可以在 [10-12] 里找到。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Akshay, V., et al. \"Reachability deficits in quantum approximate optimization.\" [Physical Review Letters 124.9 (2020): 090504.](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.124.090504)\n", + "\n", + "[2] Li, Junde, Mahabubul Alam, and Swaroop Ghosh. \"Large-scale Quantum Approximate Optimization via Divide-and-Conquer.\" [arXiv preprint arXiv:2102.13288 (2021).](https://arxiv.org/abs/2101.03717)\n", + "\n", + "[3] Goemans, Michel X., and David P. Williamson. \"Improved approximation algorithms for maximum cut and satisfiability problems using semidefinite programming.\" [Journal of the ACM (JACM) 42.6 (1995): 1115-1145.](http://www-math.mit.edu/~goemans/PAPERS/maxcut-jacm.pdf)\n", + "\n", + "[4] Burer, Samuel, and Renato DC Monteiro. \"Local minima and convergence in low-rank semidefinite programming.\" [Mathematical Programming 103.3 (2005): 427-444.](https://link.springer.com/article/10.1007/s10107-004-0564-1)\n", + "\n", + "[5] Kochenberger, Gary, et al. \"The unconstrained binary quadratic programming problem: a survey.\" [Journal of Combinatorial Optimization 28.1 (2014): 58-81.](https://link.springer.com/article/10.1007/s10878-014-9734-0)\n", + "\n", + "[6] Barahona, Francisco, et al. \"An application of combinatorial optimization to statistical physics and circuit layout design.\" [Operations Research 36.3 (1988): 493-513.](https://www.jstor.org/stable/170992?seq=1)\n", + "\n", + "[7] Poland, Jan, and Thomas Zeugmann. \"Clustering pairwise distances with missing data: Maximum cuts versus normalized cuts.\" [International Conference on Discovery Science. Springer, Berlin, Heidelberg, 2006.](https://link.springer.com/chapter/10.1007/11893318_21)\n", + "\n", + "[8] Candes, Emmanuel J., et al. \"Phase retrieval via matrix completion.\" [SIAM review 57.2 (2015): 225-251.](https://epubs.siam.org/doi/10.1137/110848074)\n", + "\n", + "[9] Waldspurger, Irene, Alexandre d’Aspremont, and Stéphane Mallat. \"Phase recovery, maxcut and complex semidefinite programming.\" [Mathematical Programming 149.1 (2015): 47-81.](https://link.springer.com/article/10.1007/s10107-013-0738-9)\n", + "\n", + "[10] Deza, Michel, and Monique Laurent. \"Applications of cut polyhedra—I.\" [Journal of Computational and Applied Mathematics 55.2 (1994): 191-216.](https://www.sciencedirect.com/science/article/pii/0377042794900205)\n", + "\n", + "[11] Deza, Michel, and Monique Laurent. \"Applications of cut polyhedra—II.\" [Journal of Computational and Applied Mathematics 55.2 (1994): 217-247.](https://www.sciencedirect.com/science/article/pii/0377042794900213)\n", + "\n", + "[12] Poljak, Svatopluk, and Zsolt Tuza. \"Maximum cuts and largest bipartite subgraphs.\" [DIMACS Series 20 (1995): 181-244.](https://arxiv.org/pdf/1810.12144.pdf)" + ] + } + ], + "metadata": { + "celltoolbar": "Raw Cell Format", + "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.8.13" + }, + "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 +} diff --git a/tutorial/combinatorial_optimization/DC-QAOA_EN.ipynb b/tutorials/combinatorial_optimization/DC-QAOA_EN.ipynb similarity index 71% rename from tutorial/combinatorial_optimization/DC-QAOA_EN.ipynb rename to tutorials/combinatorial_optimization/DC-QAOA_EN.ipynb index 06fca63..339f847 100644 --- a/tutorial/combinatorial_optimization/DC-QAOA_EN.ipynb +++ b/tutorials/combinatorial_optimization/DC-QAOA_EN.ipynb @@ -77,7 +77,7 @@ " G1.add_edges_from(E1)\n", " S = [G1.subgraph(c).copy() for c in nx.connected_components(G1)]\n", " if len(S) == 2:\n", - " # Add the seperate paths to two subgraphs\n", + " # Add the separate paths to two subgraphs\n", " V_S0 = list(S[0].nodes)\n", " E_S0 = list(S[0].edges) \n", " V_S1 = list(S[1].nodes)\n", @@ -118,7 +118,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1MAAADnCAYAAAD7CwxiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABKwElEQVR4nO3dd5hcdfXH8fcnvRBCr0rviFQLvWNCl04ggFKkKr0oSO8ISBeB0Kt0aSKCVGkiICDlh9RQAyFl03N+f3xvJNmd2TKZmTvl83qefZSdO3fOZmfv3PMt5ygiMDMzMzMzs67plncAZmZmZmZm9cjJlJmZmZmZWQmcTJmZmZmZmZXAyZSZmZmZmVkJnEyZmZmZmZmVwMmUmZmZmZlZCZxMmZmZmZmZlcDJlJmZmZmZWQmcTJmZmZmZmZXAyZSZmZmZmVkJnEyZmZmZmZmVwMmUmZmZmZlZCZxMmZmZmZmZlcDJlJmZmZmZWQmcTJmZmZmZmZXAyZSZmZmZmVkJnEyZmZmZmZmVwMmUmZmZmZlZCZxMmZmZmZmZlcDJlJmZmZmZWQmcTJmZmZmZmZXAyZSZmZmZmVkJnEyZmZmZmZmVwMmUmZmZmZlZCZxMmZmZmZmZlcDJlJmZmZmZWQmcTJmZmZmZmZXAyZSZmZmZmVkJnEyZmZmZmZmVwMmUmZmZmZlZCZxMmZmZmZmZlcDJlJmZmZmZWQmcTJmZmZmZmZXAyZSZmZmZmVkJeuQdgBUmMSewO7AaMDswGngDuCqC9/OMrbMkugE/AbYB5gMC+AS4A3g4gqk5hmdmNUpiADAEWAuYE2gB3gWGRfBGnrGZWfOSELAmsDOwIOk++nPgfuDuCCblGJ7lRBGRdww2HYnvA78GtgKmAv2me3hi9r2ngdMieKT6EXYsuxHaHzgU6AsMmO7hAMaSksPfAZdFMLbqQZpZzZFYHDgK2JV0res/3cOTgMnAv4HTgbsi8AeYmVWcRC/g58CRwNyke7PpV3eNBqYAFwHnRzCi6kFabpxM1RCJnYArgd5A9w4ObwHOBX5bSzcUEgsCj5FGbPp2cPg44D1ggwg+rWxkZlbLJDYC7gT60PGqibHArcA+EUyudGxm1rwkBgIPACsy4wB3IeOBkcB6EbxZ4dCsRjiZqhES2wPX0HECMr2xwO8j+E1louoaibmAfwHz0vklpJOA4cDKEXxdodDMrIZJrEO6WenoRmV6LaTka2gtDSiZWeOQ6As8AyxDGujujKnAN8AqEbxXodCshrgARQ2QWBK4mq4lUpCWwBwssWnZgyrN7aTp767sxesJzE8aZTazJiMxB/BnupZIkR2/NbBPuWMyM8tcAixF5xMpSPfWswJ/yfZYWYNzMlUbDiYlFW1cdx0MHw7ffANvvgl77tnmkH7A8ZUNr2MSywE/AHpN//1eveCKK+C992DUKHjpJRg0qM3TewFrSSxRlWDNrJbsSZFlzZ24/vUHjvMNi5mVW1YIbCcKDHQvsww88giMHAlvvw1bb93m6d1JA8XrVzhMqwFOpnIm0R/YgyLJ1OmnwyKLwMCBsOWWcMopsMoqbQ77vsQyFQ20YwdT4Gfo0QM+/BDWXTf9DMceC7feCgsv3Ob53YGDKh+mmdWKrOLnoRSZlerk9W8gvmExs/L7ObStOty9O9x9N/z5zzDHHLDPPnD99bDkkm2e3x84ogpxWs6cTOVvWwr8sU7z+uswcWL6/xHpa/HF2xzWHdivQvF1SKI3sAsFlve1tMCJJ8L776fY77sP/vtfWHXVNqfpCewpuVy/WRNZlxkr9s2gk9e//qTBHDOzcvoVBQZ6llkGFlgAzjsPpk6FRx+Fp56CoUPbPF/A+hLzVCFWy5GTqfwtSTs3EwAXXwxjx6ZlLp98Avff3+aQnsD3KhRfZ3T6QjHPPLDUUvDaawUf7k7qqWVmzWFJOqhc2onrn4BlKxSfmTWhbOnw/F04nu8VvgsbD7Rdi2MNxclU/uaA9tf7H3AADBgAa60Fd9wBEyYUOuqFDSRFHl+w7AcwqsPN4z16wA03wDXXpBujAqYwY08qM2tsA+igYE3nrn/tD0iZmXVRHyhcJfTNN+Hzz+GII9J9zcYbp60M/YrfBfm+psE5mcrfCIr8wU5v6tQ0jfyd78B+BRf0rfZIRCiPL3jjuzBrS3vxS2kz+cSJcOCBRQ/rDozq6N/CzBrGKOi4T1TH1z/GlDswM2tq4yky0D15cio4sdlm8OmncNhhaS/4Rx8VPZfvaxqc96fk703SjUCnRi569Ci4Z2AS8HJ5w+qSzzs64MorYd55YdNN04WoiEngXlNmTeQtmBqdHdcrfP2LAF7vYILfzKzTIgiJj4CFCj3+6quw3nrf/vdTT6VVNwX0BveaanSemcrfHRS5C5h7bthxR+jfH7p1g002gZ13TuU4W5kCXFrhOIuKYCKpT9akQo9feiksuyxssQWMH1/0NBOBP0YwpSJBmlnNkNRb0rbQ7RD4tODimM5f/1qAQStKOlrSdysevJk1i/OAsYUeWGEF6N0b+vZNM1Pzzw9XX93msAAejuDLyoZpeXMylbMIxkFcCVPazNdEpCUtH30EX38N55wDBx8M997b5jQvRvBONeJtxwUUWK6z0EKw776w0kppOnz06PQ1ZEjrI6cGcFEV4jSzHChZXdKlwHDgQIi7od+vSRnRDDp//ev3AfxtKLAY8LKkv0raXZL3KZjZzLiaIgVyhg5NBXE+/xw23DDtm5pWeXQ6Y4FzKhui1QJFdLhdxypI0tyw4jXw9CDoV8o6lRbgpxH8pdyxdZXEX4G16FqncGDSZPjbVBi0L3B1+E1p1jAkLQbsCgwlzaJfC9wQEe+nx5mNtAxmYAmnHwscFMGw7LX6AFsAuwFrA/dmr/e3iPCst5l1icQfYPIe0KNX1545ZSp0+w/oexEd74u3+uaZqRxJ2gZ4BV5+DSZsD4zr4ilagDNqIZHKbA98QpHlfkVMhJ7vwanrk3o63CNpgUoEZ2bVIWk2SXtLegJ4FpgbGAIsGxGnTUukACIYCQymwOxUB1qAm0mjx9m5YnxE3BYRWwBLAc8DpwMfSDpL0goz8WOZWRORJBj4PrwKTC1cR7SgmAKjp8Jyb4O6mIRZPXIylQNJc0i6ATgT2C4ijoiY/XZS49sWOq5uFdlxJwOnVDTYLojga+DHwNt07saoBXgDWD3i8aeBHwIvAf+StEu6kJlZPZDUU9Lmkm4F3gd+ApwNLBgRB0XE88VmnSN4BhgEjCbtn+zIWGAYsE+xUd+I+DwiLoiI1YCNSbNi90t6SdIhkubr8g9pZk1BUnfgIhi1I5z8Pej2DEX2T7UyDjQcPloB/jMZeEjSbBUN1nLnZX5VJmkz4HLgT8AxEdEy4+MsAxwB7AxMZcb+KdPKN/yVNCP1VOUj7jqJfsCepJ9jdtLPMC0xmkpKor4EzgKGRTB+xudrNeAaUqXDfSOiw2qBZlZ92YDHKqRldTsB75CW1d0aEV2uzCmxEHAIsFf2rVmme3gi6frxLHBmBA+UEG93YN0s3q2AZ7J4746Irq4MMLMGJKkfcCPp3mXbiBgl0YM04H0ksAhpO8P0+6lGk1YXnQdcFsFISd2A35EGcwZHxIfV+ymsmpxMVYmkgaQ/svWBn0XEY+0fz6ykZTErA3MC35CSi+si+KSy0ZZH1kF8XWBLYNoo8KfAncCT7a0jzvY+nADsARwUEbdVNFgz67Ssat4upKSkDykhuT4iylIIR6Ivadnwj0lLBMcC75Kuf/8tz2uoP7A16Wf4Aem6dC3wRERMLcdrmFl9kTQXaa/l28BeEdFmplxiVWAHYEGgJ+m+5i/Ag4UqEks6BDgU2CwiXqlg+JYTJ1NVIGkT4ArgPuDIiBidc0h1Q9KPSbNULwEHRMSInEMya0pZdbxtSMnHSqTZ9euAp+q9aEy2T3MIsDup59/1wHUR8WaugZlZ1UhaHHgAuBU4rpzXNUnbAxcDO0dE2wY3VtecTFVQdvNxNrApsGdEPJxzSHVJUl/gVNIyon0j4p6cQzJrCtmyuA1Jlfi2AB4nJVD3RkTxrnF1Klu2uCLp5x0CfECarbrZAzlmjUvSD4C7gRMj4g8Veo21SYNQh0fEdZV4DcuHC1BUiKT1gVdIU8ArOJEqXUSMi4hDgR2B8yRdK2n2vOMyy4PEIhLnSHwuMVFiisRoiQclNsyW187ka2gFSWeRkolTgeeAJSNiy6xaXsMlUgCR/CsiDgO+CxwPrAn8n6Q7JW0jqYutH9qS+K7E6RKfSkzIfodjJB6R+Inkz2azapG0OWnl0C8qlUgBRMQTpK0eJ0s6xkW2GodnpsosW4d/Omk5zC8i4r6cQ2ookmYhVUHcEtg7Ih7MOSSzqpBYGLgKWIM0ENa65G6Q9hZ9A/wygju6dn7NRyp8sxswF98udXt9JkOve5JmBbYl/dusANxGmrH6R1eWAkksSPodrkMqylMoMRtN+j0eGsFNMxm6mbVD0i9I+7O3iojnqvSaC5CSt3+Q9oR3VMHZapyTqTKStCap58mzwC8j4qt8I2pckjYErgQeBg6LiFE5h2RWMRLfBx4lNbbt3sHhkCpmnhDB2e2fV31JVe12A1YnLXO5FnjMRRgKk7Qw3xbf6E5a9nhdRLRbGENiWdIyydmAHp14qRbgrAhOnKmAzayNbFboZNKKl8HlKp7ThdcfQFryN4G0j6ozZdetRjmZKoPshuRk0gfs/hFxZ84hNYVstHha2dE9vanTGlFWLvwlUpuBriwLaSHNUF054/nUDViblAxsQxr8uQ64yx/onZfdjK3Gt2Xh3yD9O94WESNnPJYFgH+RZvy6+js8KoKLyhCymQGSegF/BJYGtoiIL3KKoyepVc5yWRxuA1OnnEzNJEk/JFWbe5VUbS6XP8pmJmkQ6cJ4D3BURIzJOSSzspH4C7ABnZuRam08sFAEX0hamlRYYVdgFGkG6saIGF62YJtUdnM2mPTvuzHwICmxeigiJkncBWxG52akWhsPLBHBx2UK16xpZYOwfyL1hNq5da/PHOIRaZnhLsCgas+QWXl4k2uJJPWWdCqpH8EJEbGDE6l8ZPumViA1+HxZ0jo5h2RWFhLfJc0iFU2kllgCxo2D6wrWhpoacMcfJT0LPAb0Je0N+H5EnONEqjwiYmJE3B0R2wGLkpZkHgN8JC19OUwdTKtEqlcvuOIKeO89GDUKXnoJBg0q+hL7VjB8s6aQ7VV6nNRcfJu8Eyn4X9Gb40l7wZ+Q9KO8Y7Kua9qZKYl5gJ+TmkLOTtrw+x/gjxG80f5ztTJpNupdUqnuTyscrnWSpC2BS0l9In4dEeOKH0svUtPOnwLzAlOBT4CbKdJ8z6yaJE4HDqFwoQIAHnoI+vaF99+HoUMLHTFyAiy4DbT8xRudq0vSEnDT5bDVetB3huV9/frBEUfA1VfDBx/AppvCTTfBCiuk32UrXwPzRjCpOpGbNRZJy5OKPlwGnFmLvfEkbQYMIzULdguYOtJ0yZTEysBxpCUZQRqpnWYyMAl4DTg1grtmfK56Ar8GDgAOA66vxT/IZidpTuAiYBVg94j4x4yPMwdwOLAfacR/QKtTjCYtrTkPuCAC7yOxXEgMB+Yv9viOO8I228Drr6cZqsLJFKOBjSN4tkJhWjsk3iXNVnXo5ZfhxBPhjrZ1GEcBW0XwWHmjM2t8ktYlDbAeFhHX5x1PeyStRtqycHJEXJp3PNY5TbXMT2Jn4ElS9ao+zJhIQVqG0Ze0qfh6iYultLxG0vdIZSx/BKwcEdc5kapNETEiInYGfgPcJelMSX0AJJYg9f86lFRVq3UiRfa9uUlJ9wsS81UlcLO2Ziv2wIABcNJJcOihHZ5jKjBPGWOyrpmjMwfNMw8stRS89lrRQ+YuW0RmTULSjqRWBkNqPZECiIgXgLWAgyWd7l5U9aFpkimJ7UiltPvRuZ+7P7AHTLlE6n4MaQ38JcBmEeGNwHUgIv4EfB9YAnhR+vlg4BnSSH9nGm/2zZ77jFT8ptasgorulTr5ZLjySvi446uRSM3DLR8dFp3o0QNuuAGuuQbefLPgIaJtXzEzK0LJocDZwEb1VO03It4lNQtfF7g2K3BjNawpkimJRUl7nFrPRHWkH0zcC/YdAqwWEVd6Nqq+ZKVGt4Nup8Jh98CUOeja+74HKfm6oSIBmrWv4BLTFVeEjTaC887r1DmCtOfG8jG6vQelVDxk4kQ48MCih03Fv0OzTpHUnbRM/2fAGhHxSs4hdVlEfAlsSBrYv1/SwJxDsnY0RTIF/JJ2Rgfbr4bVtxtc1D0i2m4JtrqQEuAp/wfLToTuM7znDzgAnn8exo+HYcOKnqI3sIHEIhUO1ay1v5NupGew3nqwyCKpcMEnn8Dhh8O228KLLxY8Ry/gnxWN0trzCBQvZnPllTDvvOn3N7l4eZA+wHMViM2soWR9P28BVgTWjoiPcg6pZFkBre1JPeyekPSdnEOyIho+mZLoC+xFO0skLr443VC3c5aFJVYrd2xWVYdBtz6tvzl8OJxyClx1VYfPF7B/JQIza8c5pH4oM7j8clh8cVhppfR12WVw333wk5+0ef5k4NYIvql4pFbMucCEQg9ceiksuyxssUUa0CliKnBPBF9WKD6zhpAVn3oYmEjq2TQy34hmXkRMIU0IXAc8ne3ftxrT8MkUsCVpmUtBO+4II0fCI+2vpu1NquBndUhiAOl90Ob9fuedcPfdMGJEh6fpDewr4c2gVk1PA5+1/ua4cfDZZ99+jRmTbsa/bHu7PZG03MVyEsE/gfdaf3+hhWDffVMy/OmnMHp0+hoypM0pxgG/q3igZnVM0qLAU6QiY7tGRMEBjHqU9aI6GzgK+Juk9fOOyWZUSjf2erM4qehEG9OqYW2wAey1V7vn6A4sW4HYrDrmJ91UdqboRHv6kNYvj5npiMw6IYKQOAj4E+3s+TzxxILfHkfql/ZyZaKzLvglqcH7/36HH3yQ9kt1YBypyaiX+JkVIWlVUjnx0yLi4rzjqZSIuEnSp8DNkg6OiJvyjsmSZpiZGkCRilhdqIY17TxWn2ahndnJLpiM3wdWZRHcT+qL1tKFp40DXgbaznNY1UXwCGl1Q9Em4gWMIzWS3y6iLNcvs4YjaTDwAHBAIydS00TEo6TCFGdIOsKl02tDM8xMfUO6CZ7hZ51WDWvllTt9nlFljsuqZzTlGTjoid8HloMILpEYATEMxvdOhXEKmkyahb0f2DWi8F4dq74IhkmMBK4nDe70L3zkJKDbeOj+CLBDRJcSMLOmIWlP4BRgq4h4Ju94qiUi/i1pDdJ1fqFslqpokRurvGZIpt4gjfDNMKMwfTUsgFlmge7dYbnlYNVV25xjMvBSpQO1ivmYdvr1dMEoujY7YFY2EdwirTIZNr0QTpkKGsiMVeJ6kUr4nx9B8davlpsI7pSYHxgKHAHMRfp8maYXvPwqHD464rEtcgnSrMZlszHHk/6O1o2It3IOqeoi4mNJ6wC3A3+SNCSr/mc5UKO3TZLoSdrAPfv03+/bF2ad9dv/PvzwlFztt1/BTdzjgFUjeKOiwVrFSFwJ7EarAYTu3VPDzOOPh+98B/beO5UnntJ2jGcccGYEhXenmFWBpMeAP0LcSCr9Oy8pifoaeDmi/Z5GVjuyYjYrAPOR9nOOBF4BTQL+S7pJ/E9+EZrVHkk9gT+Q/nY2j4g2BXqaSdbQ9ypgMWDLrD+VVVnDJ1MAEieRRgHblMae5vjjU7+poUMLPvx8BD+sUHhWBRIrAM/SahP/8cfDCSfMeOwJJxTc0D8eWDSCTysVo1l7JK0O3AgsGRHFOxJZ3ZN0HLBIROyZdyxmtULSAOA20mzujhFRsKl5s8lm6k4FtiOVhH8355CaTrMkU/MDb5EKEXRVC2kD8APljcqqTeIx4Md0varfOOCOCHYte1BmnSTpLuDhZthk3ewkzQG8DaxYz01HzcpF0vzAfcALwP4eUGpL0n7AcaQ9ZO12T7XyaoZqfkTwCanPUFf3u7SQlnY5kWoMPwU+LbiIr7jxwJukxs9muZC0HGkgoOP20lb3IuIrYBhwaN6xmOVN0jKknnu3A79wIlVYRFwK7AvcJ2mzvONpJk2RTAFE8CgpoRpDqnbVnqmkROok4OQKh2ZVEsHXsOUB8HbA1M5s1BwLPA+sG8H4Codn1p4jgQu8wbipnAfsIWnOvAMxy4uktYDHgBMi4tRohuVUMyEi7gG2AK6QtHfe8TSLpljmNz2JhYFfQcsvoeck6Dn9PqpxgEjlJs+K4NlcgrSKkDQf8AJ85yD4cB7SDeq8pKbO03o1TIHxggkfwsDjgJsjmJRTyGZIWohUTXTxiBiZczhWRZKuAD6IiJPyjsWs2iRtC1wK7BoRf8k7nnoiaUlS/60bgeOdhFZW0yVTAJLmhT5vwvBDYfblgLlJ/aj+D7gxgi/yjdDKLasA9FfgsYg4Pn0PAWsAg4D5STOSw2FoL7h+4YjYJbeAzTKSfg9MiIgj847FqkvS0sATwKLebG/NRNKvSIXDNo+If+UcTl2SNA9wL6lF0N4R4YHhCmnWZOpA4EcRUbh2nzUcSecAy5MuzO3umZI0N2nz94K+gbE8SZqLVDznexExPO94rPok/Ql4PCIuyDsWs0qT1A04GxgMDI6I93MOqa5J6g/cRKpmvV1EjMo5pIbUNHumWhlCenNZE5C0A7ANsEtnuoRHxBfAM6R1x2Z5Ogj4kxOppnYmcFg2u27WsCT1Id2brQas6URq5mUDwtuQVl79XdICOYfUkJoumZK0KLAk8HDesVjlZVXQLga2zSpkddaNpKTbLBeSZgH2J43SWpPKShy/DeycdyxmlSJpduCh7D9/EhFf5xlPI8mqH+4P3AI8nd0XWRk1XTIF7EQa6fXa0QYnaVbgDuCIiHipi0+/C1g36/diloe9gUcj4u28A7HcnQEclS2BMmsokhYGniL1kNo5Ilw9t8wiOYPUh+pRSWvnHVMjacYL8xDSrIM1sKwj+DBSwYmru/r8iBhNGiXbtsyhmXVIUi9Sj6Ez847FasIjpGqzm+cdiFk5SVqJlEhdHhGHRcTUnENqaBFxHbALcLuk7fOOp1E0VTIlaQVgIOkP1xrbEcB3gF/NxDluwkv9LB+7AG9ExIt5B2L5y8oanwEckw0UmdU9SZsAfwEOjojzcw6naUTEX4GNgXMlHZJ3PI2gqZIp0przmz3y0dgkbQAcQqpcM2EmTvUAsKKkBcsTmVnHsqVcR5Funs2muROYE/DyHKt7knYHrgW2iYg/5R1Ps4mIl0mtYfaUdL6k7nnHVM+aJpnKRvN2xkv8Gpqk7wI3kCr3fTgz58rWbd8F7FiG0Mw6aytgFPBo3oFY7cgqkZ4FHJ13LGalUnIscAKwXkQ8mXNITSu7R1oLWBG4RVLfnEOqW02TTAE/BsYDL+cdiFWGpN7AbcB5EfG3Mp32RlxFy6okG/Q5GjjDHeutgOtIs+Ur5R2IWVdJ6gH8AfgpsHpE/CfnkJpeRIwEBgGTgIdddKs0zZRM7Qzc6BuUhnY+MJzylpJ+FPiupCXLeE6zYtYj7eu8K98wrBZly5bPIy0DNasbWfPYu4CFSDNSn+YbkU2TXVd2AZ4GnpK0SL4R1Z+mSKay0ZAdcaPehiVpD2ADYI9yJszZ0ppb8OyUVcfRwFne12ntuBzYWNLieQdi1hmS5gUeAz4Htsiq5VoNiYipEXEkcAkpoVol75jqSVMkU6Sb7Pcj4p28A7Hyk7QyaTbqpxExqgIvcSMwxFW0rJKyD6/lSXv+zArKrnGXAYfnHYtZRyQtRZrxuA/Y0z0+a1tEXAgcCDwoaVDe8dSLZkmmXHiiQWXre28HDoiI1yv0Ms8BPYGVK3R+M0hLt86dyQqU1hwuAHaUNF/egZgVI2l14O/AaRFxgrdZ1IeIuBPYGrha0s9zDqcuqNHf25L6AJ8Ay0fE8LzjsfLJSkjfB7weEYdV+LVOAXpHxBGVfB1rTtmevKeBxbwExjpD0kXA6Ig4Ju9YzFqTtDVpSeruEfFAzuFYCSQtDdxPKmF/kpPh4pphZmpT4J9OpBrSb4F+VKdU8E3ATlkCZ1ZuhwOXOpGyLvgdsI+kgXkHYjY9SQcAFwODnUjVr4h4k9SLagvgj5J65hxSzWqGG8MhuPBEw5G0GbAXsGM11mBHxGvAV6SeDGZlI2l+YHvgwrxjsfoREf8lNRbfN+9YzCCtFpF0BnAQsFZEvJh3TDZzIuIzUpXZBYC7Jc2Sb0S1qaGX+UmaFfgQWCQivs47HiuPrIrV06SCE09X8XWPJr2XfPNiZSPpTKBvRPwy71isvkhaAfgLsGjWZNwsF1mfx6uARYAtI2JEvhFZOWVVsS8FVgE2c2n7GTX6zNRPgcecSDUOSf1IBSdOrmYilbkZ2FZSryq/rjUoSbORZlh/l3MoVoci4lXgBWD3vGOx5pVdxx4A+gAbOZFqPBExGdiH1Cvs6Ww/lWUaPZlyFb8GkpUmvwz4N2k9dlVFxHvAW8DG1X5ta1j7A3+OiPfzDsTq1hnAkdnIsVlVSfou8ATwKrBDRIzLOSSrkEhOBk4C/i5pzbxjqhUNm0xJmgf4MXBv3rFY2ewLrAjsk2NVmRtJ+/DMZoqkvsAvgbPyjsXqV0Q8BQwHts07Fmsukr5PWnI/DDg4a3JvDS4iribNht8pydcdGjiZIm3o/nNEtOQdiM28rF/FicC2Of9ObwM2k9Q/xxisMfwMeDYrbmI2M84AjnZjcasWSRsAfwUOj4hzXTa7uUTEQ8BPgAskNf1+30ZOpobgJX4NQdK8wK2k7unv5BlLRHwO/INUKtSsJNmSrCNIN8FmM+t+oAfp5sasoiTtQqqSvH1E3JJ3PJaPiHgJWBPYT9LZzdw6piF/cEmLAEsBD+ccis2k7KbzZuDqiKiVJZs3kfbjmZVqB+CDiHgm70Cs/mWzAmdQnZ571qSUHA2cBmwQEX/POybLV7aXfE3Stpobs6qOTachkylgJ+BP1eg/ZBV3OjABOCHnOKZ3J7CepDnyDsTqT7YU62g8K2XldQuwcLYk2qysJHUnFX7aCVjdy5Ntmoj4ilSYqzvwkKTZcw6p6hoimZLoLTG7RPfsW27U2wAkbQdsB+xSSxtbI2IUqbfLNgBIfZFmo4mnuK0wiW4Ss0n0ne7bg4EAHswpLGtAWenic4Cjpn1Ponv22diUo8XWDklI/ZAGdvTZlbUkuQNYElgnIoZXJUarG1mfux2BfwJPSlqoveMlJDGLxKwSdb/Xs25v/iQWlThX4hugBfgUmCRN+BgO+y6893LOIdpMkLQsqUHcdrXYs+IX8PRdcDLSOGA08BkwCelVpF1p0qluA4k+EkMl/g1MIr03RkuMk7gKfnwScIY3bFsFDIPZ1pBeOUXiPdL771OgReIbid9JLJJrhJYvaWWk64FxwCjgc9Jn10tIO9Gqj6KkuYG/ASNJzVpHVTtkqw8RMTUiDgWuIPWiWmn6x7MEan2J+4CJwNfAl8AkiUclBkv1mZeo3j7PJeYBbgDWIiWDBRqoTpgEvScDlwBHRVAzsxrWMUkDgOeAsyPiqrzjmYG0FHBLwNKToW/PwkeNzv73OOAC6u2PzEqSja4dwrdLUge0PWrqFJjQDXr/C7rtEEGuBVWscUj0AM6GSQfCFKBPob5TE0izok8AQyL4spoxWo6k5Uj7jxcHesP/VvJMbzTp/XE0EZdKWoLUjPcW4DgPAFlnSdqetCx0l4h4WGI94BpgDqA/FJyNGgOMBfaK4M/VirUc6iqZykbUngbmAorcx86ghfShsUUE3j9VB7L9JLcBIyLiF3nHMwPpB6RSsLPQuVndFtLF4wAnVI0tS6QuA3YF+nXiKVNJNy4bRvBiJWOzxifRi1TRb3U69/6bSBoRXj2CDyoZm9UAaQ3gIYrfxLbW8hbctQxsEHBCRPyhsgFaI5K0NvAnuOg2OODnMMNy9/aMAw6N4LLKRVdedZNMScwBvAQsSOERlWJagHtIo3D18cM2MUmHkyqdrR0RE/KO53+kxYEXgYFdfOZY4CwiTip/UFYrJE4mzUp1tf/YSGCVCP5b9qCsKWSJ/C3A5nT+ZgXS9NWHwMoRjKxAaFYLpGVIKz0KzJQXNxbiWbh6g4ifVyYwawbSHbvD4GHQt6v7osYBu0RwZyXiKrd6Wpv4W2BeWiVSjz4K48bB6NHp6z//afO8fqQPmQ2qEqWVTNL6wOGkfVK1k0gll1How2j22eGOO2DMGHjvPdi5TcX0/sAxpHL91oAkFgcOo0Ai1Ynr0wDS3kCzUm0MbEqrROqAA+D552H8eBg2rODzugPzk5YjW+O6gkKDPB18dvUHbQA7Iy1YnTCt0aT9T9ucXiiRWnhhuO8++Oor+OQTuPBC6D7jNElf4Op6KZ5TF8lUVglrTyj8j3rggTBgQPpaZpmCp+hPukm3GiXpO6S9cLtGRG0tO0lVadam0N/LxRfDxIkw77ywyy5w6aWw3HJtzgAcWPlALScH0c5seQfXp+7AehK+YbFSHUGBpX3Dh8Mpp8BV7e867Q3sXS83LNZFac/TqpT+2QWwb4WjtMa1MWlbRBuXXAKffw7zzw8rrQTrrgv779/mMAHbVjbE8qiLZIq07GtmlugJ37DUrKzJ223ABRHx17zjKaDtnzhAv36w7bZw3HEwdiw89RTccw8MHdr6yN7APq7w13imG+gpUAin0wLYrzwRWTORWIhUjKnNyO+dd8Ldd8OIztVC3a7MoVltKDzQ0/nPrj7AAUid2aNu1tqRFEmmFl0Ubr0VJkyAzz6DBx+E5Zdvc9gApmv1UMvqJZkaSjvrfU8/Hb74Ap58MmW3RUwFtqhAbDbzziWV7z0z70CK2JlCs6JLLQWTJ8Pbb3/7vZdfLnhFIN0wr1Wh+Cw/a5OuLUV14vrUB9ilArFZ49uCmRtohPTZulsZYrHasyOFinV17bOrO/DDCsVnDSorirMuRQqenH8+7LQT9O0LCywAgwenhKqApbMq3jWtXpKpeYs9cNRRsNhisOCCcPnlcO+96b8L6EOqAmg1RNJuwEbAHjVcdrVwN+9ZZoFRrVpufPNNWs9VmN9/jWdu2qmO1YXr02wVis8a29ykz7aZVfM3K1aSwgWTuvbZFfizy7pudiheRfvxx1PuPmoUfPwxvPAC3HVXwUMnUgfvv3pJporG+dxzaf/kxIlw7bVptnrTTQseqvbOY9WXNXT7HbBNRHyTczjtKfy+GTMGZp11xu/NOmuqNNCW33+NqRvtJFNduD75vWGlKNf7xu+/xuTPLstLN4rMmktpFuqOO6B/f5hzzlQP5czCa5OCOnj/1XyAmc6t+gYi0i+qgAmkbstWAyTNDtwOHBQRr+UdTwcKfsLw1lvQowcsscS331txRXit4I8zFb//GtFX0Pmm4O1cn0YV/K5Z+74ijdyW4zzWeMYU/G7XPrsCf3ZZ131NkaJxc8yRqvlddFEaaPzqq1RxtMhAYy/q4P1XL8nUnaR+PTMYOBA22QR6904lFYcMgXXWKbruMoCHKxyndYKkbsD1wD0RcXPe8XTCfcDkNt9taUlDKyedlDb0rrEGbLUVXHddoXP0IjWctsbyFEU+MLpwfZoE9dXt3WrGwxRJ5rt3//a9N/3/L2AscEcFY7T8PEih90fXPrt6As9XOE5rMBGMB14p9NiIEfDuu7DffumaNHAg7L47vFLwaD4Dhlcw1LKol2TqagpUpOnZM5V+/eIL+PJLOOgg2HrrGfdUTufVCNp2ebE8HEva9Hxk3oF00vkUW/u7//5pB+Xnn8NNN6Wrw+uvtz5qMnArEZ59aDBZs9PbKXDD0oXr02Tg95WO1RpPBK8BbxZ67NhjU4+pY45JRdrGj0/fK6AbcG0Fw7T8nEtaldNW5z67JgHXENFmMNusE86kyMqebbaBQYPS5+M778CkSXDIIW0OGwucEzHTRXYqTrW7539GEtcDO9FOP5d2jAH2iOD28kZlXSVpMPBHYLWI+DTveDpN+iewconPbgHWIOLlMkZkNUJiFeAJCvT66aTnIvhRGUOyJiKxI6kxa8ESxB2YDNwQwR5lDcpqh/Q6sGyJzx4HrExEwYTdrD1ZRb8vgFk7OraIccB8EbW/DL5eZqYgzWYUXv/bvgnAa8Dd5Q3HukrSYqRZxp3qKpFK9iclRV3VAtzpRKpxRfBP4F5Kf3+4obPNjDvgy0+LTUB0YAxwfJnjsdqyL+mmtKtagBucSFmpIpgIHxwD49ttH1LEWODYekikoI6SqQjeAzYhTRl2djptPPBfYFBEgT0vVjWS+pKWQ50aEU/mHU+XRfwD2JWufSi1AP8AflaRmKyW7EbaV9CVhKoF2DnC+xFsZmgvWHoWmPoh6TOvM4L0WbpxBO9XLjbLXcTjpM+grn52PY6bidtMkLQ4LHww3P4ERFc/G68CzqtMZOVXN8kUQATPAasDH9JuUjVlKunC8Xfgh9m+BsuJJAGXAq8DF+YcTuki7gQ2A76OYhX+kgmkm5qbgZ8QUbTXgjWGNALHxsCtpN99O9MEY6dCfA0MjuCeqgRoDUdSN0mnAwfDV2tC3+8BT6bdB5OLDThOS6I+AH4UwQtVCtfyFHELsDXwDe1/do3Pvq4BNifCg9BWEkk/IC1/Pzdil/VAvyQlSe3tv2shvf9OAH5VD3ulpqmbPVPTk+hGunE5EliTdOOS1aKf0gtuboEd1oro2WY3pVWfpH2BA4AfRyNsZJV63QzHfR8OXS4NSEwkvf+6k0qgXwpcTMSHeYZp+ZBYmLQsdF/S+2MKqVdLL4jXYI954N5fRHz1QJ5xWv2S1Is0crsosGVEjMi+3wNWehfueBkW3ZC0J2oq6f3XmzTbcDbwSASlLL2xeib1BrYBjgaWYsbPrsnAxcClRHycW4xW9yRtTro+7RkR9377fQaQVvgcRWo4Pm2guQepPcg5wLCI2i+F3lpdJlPTk5gbWIC0+fsb+OJ9mOffwNbhfSq5k/Qj0n6SNSOicJ3FOiTpSuD1gJuAeUk3KiOBd4koR98Xq3PZ5tvFgNlIAz6fRTBc0lDgZxGxQZ7xWX2SNJBUyvwbYJeIGDfdYzsBB0TE2hL9gYWBgaQR348j+DKPmK0GSd8B5uHbPj7vehWFzSxJvyDNLG0VEc8VPgYBiwBzkgYcvwLerecBnrpPpgqRdBrQPSKOyjuWZiZpHuAF4MCIaJjlTEqje58A34+Ij/KOx+qLpJ7AO8AOEfFs3vFY/VC6Ab6ftIT94IiYMt1jAl4CfhMR9+UUopk1oez6czKwIzA4It7JOaSqqqs9U11wE7BT1hzWcpCWm3AzcG0jJVKZwcArTqSsFJFGf88hLXUw6xRJK5Aaf18L/HL6RCrzE9JyrfurHZuZNa9s2fHVpO03azRbIgUNmkxFxKuk9Zdr5B1LEzuVtAa7EcvuDgFuzDsIq2tXAmtKKrX/izURSRsAjwBHRsQ5UXhJydHAGUUeMzMrO0mzAvcBswPrR8QXOYeUi4ZMpjI3kW56rcokbUua6h1SYPS0rkkaQBoBdgNoK1lEtAAXAUfkHYvVNklDSJ9nO0TEzUWOWZ20P+qWasZmZs1L0gKkojZvA9tkn2tNqSH3TAFIWhR4FlgwvKmyaiQtQ/rj2jQiGq7sblY8YIeI2CLvWKy+SZqDtHdqxXDlR2sl24NwBKkS6qYR8Vo7x94FPBwRF1cpPDNrYpKWJ81IXQac2ewz4g07MxUR/wX+D9go71iaRTZrcwdwTCMmUpmd8RI/K4OI+AoYBhySdyxWWyR1J/Xk24W0B6G9RGo54Mek95KZWUVJWhf4G3BsRHhpMQ08MwUg6SDgBxGxW96xNLpsFPUW4JuI2DvveCpB0tyk6ewFG6JfluUuq872CrDktF5B1twk9SMN2MwCbBsR33Rw/NXAWxFxWhXCM7MmJmlH0kDPzhHxSN7x1IqGnZnK3ApsmX04WWUdQuqpc1DegVTQdsD9TqSsXLKKkHeSlnJZk5M0F6nQxGjS0r6OEqmFgC2AS6oQnpk1KSWHkSrRbuREakYNnUxFxGfAc8BmecfSyLIp3yNJo6jj846ngqZtBDcrp7OBAyX1zzsQy4+kxUmlz/8G7Bada/59KHBlRIysZGxm1ryyZcfnAz8jLTt+Jd+Iak9DJ1MZV/WrIEkLkv6Nh0bE+3nHUynZCPCywEN5x2KNJSL+AzwB7Jl3LJYPST8gvQfOjYjfdGYPQjaLtRvpJsfMrOwk9SVt4fg+sJaLJRXWDMnUHcAGkmbLO5BGkzVquw24KCIezjueCtsJuL2To8VmXXUGcJiknnkHYtUlaXNSVaxfRMRlXXjqgcCfImJ4ZSIzs2YmaU7gYWAiMMgz4MU1fDKVrTn/K7BN3rE0oN8BX5BuBBudl/hZxUTE86TiJjvnHYtVj6R9gD8Cm0fEvV143izA/qQlomZmZZW1F3oKeBLYNSIm5BxSTWv4ZCrjpX5lJmlXYBCwe0RMzTueSspKD89FWoZjVilnAEdLapbrctPKNnOfTOojtXZEPNfFU+wNPBYRb5c/OjNrZpJWJSVRF0bE0Y1+j1cOzfKhfR+wqqT58w6kEUhaETiP1PF6ZM7hVMPOwC0RMSXvQKyhPQK0kKqzWYPKlkdfDWxC2sz9TgnPPxQ4s/zRmVkzkzQYeBA40E3AO68pkqmIGAfcA+yQdyz1TtLswO3ALyPi1bzjqbSsf5Yb9VrFZUUHzgCOyd531mAkzQr8GZgdWD8ivijhNLsAb0TEi2UNzsyamqQ9Sc2/t4yIO/OOp540RTKVuRHvR5gp2fKja4H7IqJZ9g/9AJgK/DPvQKwp3AnMAayTdyBWXpIWAB4H3iHN6reUcI5uwFE0xz5VM6uCbNnxCcCvgXUi4pmcQ6o7zZRMPQIsmvXysNL8hjSienjegVTRzsCNnSlVbDazsqWkZwFH5x2LlY+k5Uk9pG4GDoiIySWeaitgFPBouWIzs+aVVZC9ktSPdY2IeCvnkOpS0yRT2YfXbaQS19ZFkgYB+wLbR8SkvOOphqxR3Y64ip9V13XA9yWtlHcgNvOypuZ/A46NiDNKHZjJln4eDZR8DjOzaSQNAO4F5gHWi4jPcg6pbjVNMpW5CdjF+xG6JiuReQ2wU0R8knc8VbQu8ElEvJl3INY8shK055GWc1kdk7QDaRBvSERcP5OnWw8YCNw1k+cxsyaXFWT7O/ABsHVEjM05pLrWbMnUM0A/Uidn64Ss+/WfgNMjotlKgw/BhScsH5cDG3tZcn3K9iAcSurFt1FEPFKG0x4NnOkyxWY2MyQtS1p2fAepWXipy44to2ZbLSDpdNLP7T0JHchm8K4E+pJGVpvmzSKpNzAcWDEiPso7Hms+kk4B5oyI/fKOxTovWx78O2AjYHBEfFiGc64C3A0sHhETZ/Z8ZtacJK1Fqsh8VERcnXM4DaPZZqYgLfXb2Y0xO2Vv4IfA3s2USGUGAa86kbIcXQDsKGm+vAOxzslm8m8BVgTWKkcilTkKONeJlJmVStK2pNmooU6kyqsZE4pXgdHA6nkHUssk/RA4hVTCd0ze8eRgCC48YTmKiM9Jy0x/lXcs1jFJcwIPA5OAQeVqaC5pSWAD4I/lOJ+ZNR9JvwJ+D2wSEX/JO55G03TL/AAk/QZYICIOyDuWWiRpbuAF4FcRcVfO4VRdVuHmI2CxiBiRdzzWvLLiLy+Q3ovf5B2PFZb9nh4gLcU7ppz7miT9Afg0Io4v1znNrDlkq7DOBgaTlh2/n3NIDalZk6nFgH/Al1vAnMuRKiSNBd4H/hZB027Gk9QDeBB4LiJ+nXc8lSYxP7A+qVFqAF/CCrPBvzePiC1yDc4MkHQ9acnpmXnHYm1JWhW4h1Sk56Iyn3t+4DVgqYj4spznNrPGJqkPqRLzfKSKfV/nHFLD6pF3ANUm0RdiXXhvAAz8OzCZ9O8wJfuaKHEBcHkEn+YZa05OJiUVx+UdSKVICFiH1Hx4Y2Ai0JP0c0+GF/vD/z0rsVoEL+QYqhnAmcBfJP0+IsbnHYx9S9Jg0s3KLyLizgq8xMHAdU6kzKwrJM1BaqPwCfATf3ZUVlPNTEksDTwGzJJ9FTOOdGM9JIK7qxBaTZD0U+B8YLWI+CLncCpCog+p78v6pDL5RXqOxRTQBNKelX0jmFKtGM1ak/Rn4N6I+EPesVgiaU/gVOCnEfFMBc4/G/B/wCpemmNmnSVpYdKy4weAI9xOofKaJpmSWBb4BymJ6mzhjXHAzyK4pWKB1QhJSwNPAJtFxPN5x1MJEr1IyfRKpHLvndEC/AXYNgJfkCwXWTnba4Cl3RMkX1nLiOOBoaQ9CG9V6HWOAZaJiN0rcX4zazySVgL+DJwTEefnG03zaIpqfhIDSTfRA+jaz9wXuEriB5WIq1ZImoVULvM3jZpIZa4klSzubCIFafZqY1JlQ7NcRMSTpOUa2+YdSzOT1JN0HdkMWKOCiVRfUhXHsypxfjNrPJI2IQ3+HuxEqrqaIpkC9iDNSBVc0rXjjvD66zBmDLzzDqy11gwP9yXtI2pI2SjrFaRZuytyDqdiJBYGtiMlRzNYZhl45BEYORLefhu23rrN0/sDB0vMWuk4zdpxOnB09jdrVZZV+bwXmBdYPyI+q+DL7QE8GxGvVfA1zKxBSNoduJbUzuZPecfTbBo+mcqKDRxBgZtogI02gjPPhJ/9DAYMgHXWgXffnfEUwLoS36l8tLn4FbAkcGCDN+bdnwLJdPfucPfd8Oc/wxxzwD77wPXXw5JLtnn+VGDXKsRpVsz9pGI5mwBI9JdYWGIJibmya51VQFZV7+/AB8BWZeu9J/VDWghpSaS5kZRVVD0COKMsr2FmDStdMnQscAKwXraKwaqs4fdMSaxPKltbsODEU0/BlVfCVVe1e5rxwLkR/Kb8EeZH0jrArcCPI+K9nMOpGImewJfQdmZp+eXhH/9IifQ0Dz0Ezz4Lv/1tm1O9H8EilYvUrH1Sr11h68Ph1i+AdUmVKINUjfJzUj+RayNwT6oykbQMaSP3lcCpMz3olGYW1yclTBsy4+9wxL3wyJ6w+OcRa87U65hZQ8sGXi4BVgM2jYhmrEBdExp+Zor0Jutd6IFu3WC11WDuudPyrg8/hAsvhD592hzah3Tj0jAkLQDcDOzeyIlU5rtA984eLMH3vlfwoe9k1QDNqk7iRzDhTLjq+xAbkm6++5MGinqT3uenA59IHO+ZqpmXFf54DDgxIk4pQyK1CvAeqbnvT2j7O1xgI9jlE1gN6TRSw00zsxlke93vBhYC1nUila9muFDPTvrAamPeeaFXL9huO1h7bVhpJVh5ZTj22ILnma1yIVaXpF6k8uCXRMRDecdTBQOhcGnzN9+Ezz+HI46AHj1g441h3XWhX8FFoUykgd4HVj8kBgF/Ay0Asyil/AX1J+3zPAK4xglV6SRtSyrMs1tEXF2GE25Aqpi6EO3s4e0L3bpDL+CXwK1OqMxsepLmBR4FPgO2iIjROYfU9JrhIj0OCpe0Hjcu/e+FF8Knn8KIEXDuubDppkXP0yjOBkYAp+UdSJWMp8iNy+TJqeDEZpul98Bhh8Gtt8JHHxU8T3ca631gdUBiFeB2iuz7LKI/sA3ed1MSSb8Cfk9qdvmXMpxwBdIocld/h4OyOMzMkLQU8DRwH7BnREzKOSSjOZKpjyhyAzxyZFraN/3CjSKLOIK0NKPuSRpCKuu7WxM1cvuUNNJb0KuvwnrrwVxzwaBBsNhi8NxzBQ8NwCNAVm1/pMhNeAeVSPsDv5S8z6+zJHWT9DvgF8CaEfFSmU59Cen38a3Ro2f8mjwZLrig9fP6A3uS9m2ZWROTtDqpEM5pEXFCgxcNqyvNkEzdSTv7ZYYNg4MOSvumZpsNDjkkVXZrZQxwWeVCrA5J3yeNcm4TESNzDqdqIvgaeJKUDLWxwgrQuzf07ZtmpuafH66+us1hk4Eb3bjXqklieWDZQo91ohIppGv8gRUOsyFI6gPcBPwAWCsi3i/TiRcHVqX17PiAAd9+zTdfWipx222FztCDtOTPzJqUpK1Js9s/j4grcw7HWmn4ZCqCkaT9QQX3zJx8Mjz/PLz1FrzxBrz0Epx6apvDRgF/q2igFSZpNtJSoUMi4pWcw8nD2RBjCz0wdCh88knaO7Xhhmnf1MSJbQ6bCJxf4RjNWjuYIns+TzwRTjopVZ6MgOHD01crvYB9pMJFeCyRNDvwECnh2SQivirj6Q8iJUTFbbttugA98UShR3sCuyP1L/SgmTU2SQcAFwODI+KBvOOxthq+NDqAxErAU3RtvXqmJeCKp+BXg8vWW6TKlDYw3wW8HxEH5RxOLqR+P4J3n4R5epQwhjAFeDmCVSsQmllREl8Ac7X+frduaSLjt7+FvfZKFUjvuisVUhk/vs1pRgGbR1DwTr3ZSVqYVPr8AeCIsi9/lj4CFmz3mEcegccfTxlyYd8AO1CO/VtmVheye7fTga1IidR/cw7Jimj4mSmACP4FnAwUnJlox3jo8Tgc9l/gX5LWLntw1XEMMCdwWN6BVJuk3pJOhXH3wAm/gW5dfQ8E6WZ02wqEZ9aRAYW+2cVKpEH6+7dWJK1EGmi7PCIOq9A+0oHtPrrQQqmE6DXXtHdUN2COcgZlZrVLUm/gemAt0v5NJ1I1rCmSqcyZpGVaLZ08vgV4BnptFjFpN+BQ4BZJ50nqW6EYy07SJsABwPYR0XbxWgOTtDLwPPA9YMWIy84CBpOKSHTmpmkK8BWwXkRjFCCxxtC1SqQjB8LWd0oKf834BbxEmjU6r1KvMbpIw/j/GToUnnwS3nuvrO8RM6tP2baMB0i95zaKiBH5RmQdaZpkKoKI4FhgN+Bt0ixVoRvq0aQb6NOATSLSbFZE3AOsAMxHmqX6cVUCnwmSFgGuBXaOiLa7KRqUpJ6SjiftgTgb2HpaQ7tsqdMPgAeBCaSy6a21ZN+/HVgpgmbcY2a1oWD1yC5UIgVmGwV3rRMR8lf6AvYAPgcq/u8yAD5u9ze8224dzUpB+qwq5z4uM6tBkr5L6kf3KrBDRLgdSx1oij1TrWWNLH9Amm1albSUZhyp/PnvgT9HMLn487UdcBFwNXBCRBS6Ic9VVpnqSeCGiDgv73iqRdL3gGtIN0p7RUTRGxmJBUglkLcjNeOdCnwNXAdcFYFHgyxXEn8k3fi3KWBw4okweHDqkTZpEtxzDzz2WNpH1cpoYO4IJlQ63lonScBvgD2BTSPijSq86PnA/hQqJLL66vDww6ma35h2t+S2APMQhYvomFn9yyou3wecB5zn0uf1oymTqXKQNA+pXPrSpJ5NL+Yc0gwkXUFKEndqhj9IST2AI0gJ8tHAVc3wc1tjy0qjPw+0WVrcowf8/vcwZEgqOnHrrXDkkTBhxpRpInBhBIdXJ+LalV0jLgFWAzaLiE+q9MKLA/8G+rR57LLLoF+/NDtV3CTgCiL2r0yAZpY3SRuSWjMcFBG35B2PdY2TqZmQjXLuTBpF+ANwSi3sS5K0Fymp+GG9ViDsCqWGlleT+oHtGeXqD2NWAyReBFYp8enjgWWbfc+fUlnxW0gzfNtHRHWbb0tPAGvSutdU54wDVibizfIGZWa1QNKuwO9Iy/r+nnc81nVNs2eqEiK5EViZdLPzrKQV84xJ0g9I+71+2uiJlKTukg4lLWe8ltQfxomUNZq96XzhnOmNBS5wIqV5gcdIS3+3qHoilexH16vJkj3nSidSZo1HyTHAqcAGTqTql5OpMsiKO2wBXAD8VdKx2ZKSqpI0F6lB8S+iwT98JS1BukHaGvhRRFwSlSlrbJarCP5JKs3flYRqLHAHaclr05K0FPA0aR/CnhExKZdAIv4NbEnXEqqxpIpev6pITGaWG0ndSY14dwRWj4jXcg7JZoKTqTLJZqmGkWao1gaekbRctV4/+8O8Cbg5Iu6s1utWm6Rukg4E/kGqtrdeRPxfzmGZVVQEDwIbkCrDjSH1jipkLGlZ2FnA7hFFj2t4klYHHgdOi4gTct9DGfEosA7wAe3/DqdVE70A2BEPEpk1FEn9SINdS5IqijZNteVG5T1TFZDtpdqHNHV7FvC7iJhS4dc8Ffgx8JOIKFqJsJ5lpd6vIm3G36PRZ9/MWpPoBmwIHAmsSypOMBXoBXxKagVwbQSjcguyBkjaGvgjqTjQAzmHM6P0+bAeqWDORnz7O+wJjCD9Dq8mYmROEZpZhUiaG7gXeBPYuxb22dvMczJVQZIWJd389ybd/L9VodfZCrgQWC0iPq/Ea+QpS073JiWnZ1OF5NSs1kn0B+YkJVJfA18180zUNJIOAH4NbFlrVVbbSCPUc5I+I0YCI/CHsllDyrYnPADcDPw299lyKxsnUxUmqRtwAHA8cDJwYTn39mR7Ap4ENo+I58p13loh6TvAFcBcwO5eV2xmhWTX2tOBrYDBEfHfnEMyMwNA0o+Au0i9Sf+QczhWZk6mqkTSkqTy3ZOBn0XEux09gbS+fnlgVtJeiPeAB8k2UWflfp8lJWg1+ccp8R1gE2CO7FsjgIciaHeNcDYbtTtpmeQFwJm5bR43s+pKf/+rkZqqDyTtIfoYuI+IcQUO7w0MAxYmzUi54baZVYY0J7ApMDfQnbQy4DEi3il8uLYEriTd+/25anFa1TiZqqKsSMTBwDHAccAf2sxSSQOBPYDDgdlIf6g9SUnYRNLa+ovHwaX90pK3CcDPa2m6WEKkfR1HkBLCyaRlLJDi7Qk8ApwDPNZ6aZKk+YHLgYVIex5erlLoZpantOxtJ+AoYEFSkaSewBTS9U+kpdMXTrtxkTQbaTP3SGCXKJBsmZnNNOmHwGGkypyTSPc13Uj3Nd2BF0kDwPeRbUWQtC9pZdJWjbh6yBInUzmQtCxwDTCKlAh9kD2wCvAw6Q+0fzunGD8Juv0cProevldLNw8SfUjl2dcj/QzFmlQGqWrVQ8CQCCa0aoJ8OXCyN2eaNQlpcVK7g9mAWdo5ciIpuTpUqeT5/cCjwCHeS2lmZZcGwi8CdgP60H4l7DHAqyNh8OypUND2pGXHrjrcwJxM5STrQ3UkcAhw9CR4uUe6IWgvAZnBVBjfDfYg4pYKhtppEr1IP8PKpIp7ndECPA8rDYGXLwSWIRXreL5CYZpZrZEWA14gLenrVMuOKTD+tzD+NDgFOLeWZufNrEGkQd6bgM1pf5D7fwImDIcJ34P/jEz72b+oZIiWPydTOZO0wvxww5uwzIC0nKWrWoC1ifhnuWPrKolhwA5Av649c/IEuHYK7HkRcHxEjK9AeGZWi6Q+wNvAAnSx9+FkmNgDtiLiwYrEZmbNTfo1qTpopxKpaSbC1G7wWI+IDSsTmNUSN+3NWUS8+j7c3qfQbNTo0TN+TZ4MF1zQ+qi+pPW4uZJYgLTXoU0itfDCcN998NVX8MkncOGF0L379Ef06A179IA4x4mUWdPZgbS0r+3n0eyzwx13wJgx8N57sPPOMzzcI5WFP6MKMZpZs5H6kva4z5hIdeLerBd06wE/Rvp+9QK2vDiZypvUvScc1BN6tHlswIBvv+abD8aNg9tua3MGYBOk+aoRbjv2LfbAJZfA55/D/PPDSivBuuvC/vu3PqrbFGCvSgZoZjXpKIrtkbr4Ypg4EeadF3bZBS69FJZbrvVRS/qGxcwqYHso0Luvc/dmkAZ7Dq5siFYLnEzlb1PSH1z7tt02ZSRPPFHsiH3KGVRXSHQHDiRtzGxj0UXh1lthwgT47DN48EFYfvk2h/UFDpH8njRrGtLKwCIFH+vXL133jjsOxo6Fp56Ce+6BoUNbH9mLtPfUzKycjgQGtHtE+/dmPYCdkNo/h9U937jmb1Xar1yV7L47XHttsUf7AGuVMaaumpciiRTA+efDTjtB376wwAIweHBKqAoYSFruY2bNYRUKjfwCLLVUWj7z9tvffu/llwuNxPQAVq9QfGbWjFLhiWU6PK79ezNIJdSXLFNUVqOcTOVvLjqq3rfQQmlt3DXXtHfU7OUMqosGknpJFfT44+n+Z9Qo+PhjeOEFuOuugodOys5lZs1hIMUK78wyS7poTO+bb9LSmrY88mtm5VR0gPh/OndvFvi+puE5mcrf6A6PGDoUnnwybcAu4u+wmqTI4wsWeR3GFLyZkdIs1B13QP/+MOecaU/5mWcW/DG6ATXTM8vMKm4cqWdUW2PGwKyzzvi9WWdNG77bcuEaMyunCXR0j9yJe7OM72sanJOp/H1AKm9e3G67dTTyMXVdGBYRyuML3usPs0woFNgcc6RqfhddlPaRf/UVDBsGm25a8OfoBnzVuX82M2sAH5JmpNt66y3o0QOWWOLb7624Irz2WqGjP6hEcGbWpCKmAl+3e0zH92YAvYGPyxSV1SgnU/m7lfZ+D6uvDgsuWKxSzDTjgD+UOa5Oi6AFuB+Y2vqxESPg3Xdhv/1SOfSBA9MS41deaXOaKcDtEUysfMRmViP+UvSRlpY0pX3SSakYxRprwFZbwXXXtT5yNHBRJYM0s6b0R9IMVVuduzcDeIWID8sdmNUWJ1N5ixgB3EOBRARImce0PivFDQeeK39wXXIORaayt9kGBg2CL76Ad96BSZPgkLa1tyYA51Y4RjOrJRETgUspdsOy//6pcs3nn8NNN6VRmddfb33UFNI11MysnC6hWIGczt2bjQbOqkBcVmMUUfh9YlUkrQb8nQINbzthLHAQEcPKG1TXSAh4g1S1pqtJ+hTg9QjcK8as2UgLAf8htUfoqnHA2UTk3rjczBqQ9CCwAcUK5bTvS2ABIgovZbaG4ZmpWhDxAnAaKTHqinHAg8DV5Q6pqyIIYAug3WGaQk8ljd5sVfagzKz2RXwA/IKO9o62NQF4CTi17DGZmSVDSUlR4UI5xbUAmzqRag5OpmrHacD5dP6GYiwpkRpCjUwvRvA2sB5p02ZnLjyTSQUn1o3gvxUMzcxqWcR1wKF0vupVC/AiMDhbKmhmVn4RXwBrkLZTdOZaE6RB5c2JeL6SoVntcDJVKyKCiGOBXYDXSDcLrROSabM4w4GjgO1q7UYigpeAlUiFNcZTODkcmz12E7BiBG3LUZhZc4n4A7Ap8CwpqSo0ojsaGAGcDqxHxKgCx5iZlU/Ee6T7mqtI9y+FVuCMz77uBX5IxKPVCs/y5z1TtUpaBfgVsAqpIWUL8A5wAfBIrcxGtUdidmAPYAgwBykZHAHcCFwTwcjcgjOz2iUtTbr+rUlqeDmeVP78YuA+Ioo2CTczqxipP7AT8HNgHqA7MBK4G/gDEZ/mF5zlxcmUmZmZmZlZCbzMz8zMzMzMrAROpszMzMzMzErgZMrMzMzMzKwETqbMzMzMzMxK4GTKzMzMzMysBE6mzMzMzMzMSuBkyszMzMzMrAROpszMzMzMzErgZMrMzMzMzKwETqbMzMzMzMxK4GTKzMzMzMysBE6mzMzMzMzMSuBkyszMzMzMrAROpszMzMzMzErgZMrMzMzMzKwETqbMzMzMzMxK4GTKzMzMzMysBE6mzMzMzMzMSuBkyszMzMzMrAROpszMzMzMzErgZMrMzMzMzKwETqbMzMzMzMxK4GTKzMzMzMysBE6mzMzMzMzMSuBkyszMzMzMrAROpszMzMzMzErgZMrMzMzMzKwETqbMzMzMzMxK4GTKzMzMzMysBE6mzMzMzMzMSuBkyszMzMzMrAROpszMzMzMzErgZMrMzMzMzKwETqbMzMzMzMxK4GTKzMzMzMysBP8PRq1rtrcBITYAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -128,14 +128,14 @@ } ], "source": [ - "# Gnerate a connected graph with 10 vertices\n", + "# Generate a connected graph with 10 vertices\n", "n = 10\n", "G = nx.Graph()\n", "G.add_nodes_from([0,1,2,3,4,5,6,7,8,9])\n", "G.add_edges_from([(0,1),(1,2),(2,3),(3,4),(4,5),(1, 7),(5,6),(6,7),(7,8),(8,9),(9,0)])\n", " \n", "k = 9 # Set qubit (vertex) limit\n", - "S = NaiveLGP(G,k) # Partition G into two subgrahs once\n", + "S = NaiveLGP(G,k) # Partition G into two subgraphs once\n", "sep_node = list(set(S[0].nodes).intersection(set(S[1].nodes))) # Obtain seperation nodes of the partition\n", "\n", "# Show graph illustration\n", @@ -231,11 +231,11 @@ "output_type": "stream", "text": [ "Max cut for the first partitioned subgraph: \n", - "{'01010101xx': 0.07887396513978905, '10010101xx': 0.07887396513978903, '01101010xx': 0.078873965139789, '10101010xx': 0.078873965139789, '10101101xx': 0.040906327139884305, '01010010xx': 0.0409063271398843, '01010110xx': 0.04004434869249364, '10100101xx': 0.04004434869249363, '01011010xx': 0.040044348692493625, '10101001xx': 0.040044348692493625}\n", + "{'01010101xx': 0.07865689694881439, '10101010xx': 0.07865689694881439, '01101010xx': 0.0786568820476532, '10010101xx': 0.0786568820476532, '01010010xx': 0.04094248265028, '10101101xx': 0.04094248265028, '01011010xx': 0.04005919024348259, '10100101xx': 0.04005919024348259, '01010110xx': 0.04005918651819229, '10101001xx': 0.04005918651819229}\n", "Max cut for the second partitioned subgraph: \n", - "{'0xxxxxx101': 0.4556003303152275, '1xxxxxx010': 0.45560033031522745, '1xxxxxx100': 0.0254542520553071, '0xxxxxx011': 0.025454252055307092, '0xxxxxx110': 0.010740876742244158, '1xxxxxx001': 0.010740876742244157, '1xxxxxx000': 0.0022930869455346486, '0xxxxxx111': 0.002293086945534646, '0xxxxxx100': 0.002293086945534642, '1xxxxxx011': 0.002293086945534638}\n", + "{'1xxxxxx010': 0.45565909147262573, '0xxxxxx101': 0.45565909147262573, '0xxxxxx011': 0.02522321417927742, '1xxxxxx100': 0.02522321417927742, '0xxxxxx110': 0.010825542733073235, '1xxxxxx001': 0.010825542733073235, '0xxxxxx111': 0.002283707959577441, '1xxxxxx000': 0.002283707959577441, '1xxxxxx011': 0.0022837070282548666, '0xxxxxx100': 0.0022837070282548666}\n", "Combined max cut for the original graph: \n", - "{'0101010101': 0.07887396513978905, '1010101010': 0.078873965139789, '1010100100': 0.0254542520553071, '1010010100': 0.0254542520553071, '1010110100': 0.0254542520553071, '1001010100': 0.0254542520553071, '0101101011': 0.025454252055307092, '0101011011': 0.025454252055307092, '0101001011': 0.025454252055307092, '0110101011': 0.025454252055307092}\n" + "{'1010101010': 0.07865689694881439, '0101010101': 0.07865689694881439, '1010100100': 0.02522321417927742, '0101011011': 0.02522321417927742, '1010010100': 0.02522321417927742, '0101101011': 0.02522321417927742, '1010110100': 0.02522321417927742, '0101001011': 0.02522321417927742, '1001010100': 0.02522321417927742, '0110101011': 0.02522321417927742}\n" ] } ], @@ -272,7 +272,7 @@ " si_str_cnt.sort(key=lambda tup:tup[1])\n", " S_str_cnt.append(si_str_cnt[::-1][:t])\n", "\n", - "# Once we have already obatined max cut strings for two paritions, we perform the graph reconstruction (GR)\n", + "# Once we have already obtained max cut strings for two partitions, we perform the graph reconstruction (GR)\n", "print(\"Max cut for the first partitioned subgraph: \\n\" + str(dict(S_str_cnt[0])))\n", "print(\"Max cut for the second partitioned subgraph: \\n\" + str(dict(S_str_cnt[1])))\n", "out_cnt = GR(S_str_cnt[0], S_str_cnt[1])\n", @@ -300,7 +300,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -365,8 +365,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "First t possible approximate maxcut for graph G: {'0101011011': 408, '0101010011': 393, '1010101100': 386, '1010100100': 350, '1001010100': 257, '0101010101': 250, '1011010100': 248, '0101001011': 244, '0110101011': 235, '0100101011': 225}\n", - "Max cut found by DC-QAOA algorithms: 0101011011\n" + "First t possible approximate maxcut for graph G: {'0101010011': 404, '1010101100': 404, '0101011011': 402, '1010100100': 402, '1011010100': 255, '0110101011': 247, '1010110100': 230, '0100101011': 218, '0101010101': 216, '1001010100': 216}\n", + "Max cut found by DC-QAOA algorithms: 0101010011\n" ] } ], @@ -407,7 +407,7 @@ "\n", " # retain only top t (str,cnt) pairs by sorted order\n", " out_cnt = out_cnt[:t]\n", - " # resacle total numer of counts to s or around\n", + " # rescale total number of counts to s or around\n", " cnt_sum = sum(cnt for (str, cnt) in out_cnt)\n", " out_cnt = [(k, int(s * v / cnt_sum)) for (k, v) in out_cnt]\n", "\n", @@ -474,7 +474,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "First t possible approximate maxcut for graph G: {'11010': 535, '01001': 515, '00001': 495, '11110': 495, '10110': 488, '00101': 472}\n" + "First t possible approximate maxcut for graph G: {'01001': 523, '11010': 506, '11110': 500, '00001': 499, '00101': 492, '10110': 480, '11111': 0, '11101': 0, '10111': 0, '10101': 0}\n" ] } ], @@ -500,7 +500,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2021-05-11T06:54:47.679276Z", @@ -528,7 +528,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2021-05-11T07:02:35.277145Z", @@ -544,29 +544,29 @@ "Node = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "\n", "Random graph 1\n", - "Edges = [(0, 1), (0, 5), (0, 6), (0, 7), (1, 3), (1, 4), (1, 6), (1, 8), (1, 9), (2, 3), (2, 4), (2, 6), (2, 8), (3, 5), (3, 6), (3, 8), (4, 5), (4, 7), (4, 8), (5, 8), (5, 9), (6, 7), (6, 8), (6, 9), (7, 8), (7, 9)]\n", - "SDP upper bound: 21.03787674994891\n", - "DC-QAOA node partition: 1001100011, max cut = 21.0\n", + "Edges = [(0, 1), (0, 3), (0, 5), (0, 7), (0, 8), (1, 2), (1, 3), (1, 4), (1, 6), (1, 7), (1, 8), (1, 9), (2, 3), (2, 4), (2, 5), (2, 6), (2, 7), (2, 8), (3, 4), (3, 8), (3, 9), (4, 5), (4, 6), (4, 8), (4, 9), (5, 6), (5, 7), (7, 8), (7, 9)]\n", + "SDP upper bound: 20.590903254825506\n", + "DC-QAOA node partition: 0100110110, max cut = 18.0\n", "\n", "Random graph 2\n", - "Edges = [(0, 1), (0, 2), (0, 4), (0, 8), (0, 9), (1, 2), (1, 3), (1, 5), (1, 6), (1, 7), (1, 8), (2, 3), (2, 6), (2, 8), (3, 8), (4, 8), (4, 9), (5, 9), (6, 8), (6, 9)]\n", - "SDP upper bound: 16.028382190698274\n", - "DC-QAOA node partition: 1011011100, max cut = 14.0\n", + "Edges = [(0, 1), (0, 2), (0, 5), (0, 6), (1, 2), (1, 3), (1, 4), (1, 5), (1, 7), (1, 9), (2, 4), (2, 5), (2, 8), (2, 9), (3, 4), (3, 9), (4, 5), (4, 7), (4, 8), (5, 7), (6, 9), (7, 8), (7, 9)]\n", + "SDP upper bound: 17.52909721355493\n", + "DC-QAOA node partition: 0111001100, max cut = 17.0\n", "\n", "Random graph 3\n", - "Edges = [(0, 2), (0, 5), (0, 6), (0, 7), (1, 2), (1, 3), (1, 4), (1, 5), (1, 6), (1, 7), (1, 9), (2, 3), (2, 5), (2, 6), (2, 9), (3, 4), (3, 6), (3, 7), (4, 6), (4, 7), (4, 8), (5, 6), (5, 7), (6, 7)]\n", - "SDP upper bound: 17.0971057189657\n", - "DC-QAOA node partition: 0010111100, max cut = 15.0\n", + "Edges = [(0, 2), (0, 3), (0, 6), (0, 8), (1, 3), (1, 6), (1, 9), (2, 3), (2, 4), (2, 5), (2, 7), (2, 9), (3, 4), (3, 5), (3, 6), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (5, 6), (5, 7), (5, 8), (6, 9), (7, 9), (8, 9)]\n", + "SDP upper bound: 20.99999938244524\n", + "DC-QAOA node partition: 0110001110, max cut = 19.0\n", "\n", "Random graph 4\n", - "Edges = [(0, 1), (0, 2), (0, 3), (0, 4), (0, 6), (0, 7), (0, 8), (0, 9), (1, 7), (1, 8), (1, 9), (2, 3), (2, 6), (2, 7), (2, 9), (3, 4), (3, 5), (3, 7), (3, 8), (3, 9), (4, 7), (4, 8), (5, 6), (5, 8), (5, 9), (6, 7), (6, 9), (7, 8), (7, 9)]\n", - "SDP upper bound: 20.153931079390457\n", - "DC-QAOA node partition: 1111101000, max cut = 17.0\n", + "Edges = [(0, 2), (0, 6), (0, 8), (0, 9), (1, 3), (1, 8), (1, 9), (2, 4), (2, 6), (2, 7), (3, 4), (3, 7), (3, 8), (4, 6), (4, 7), (5, 6), (5, 7), (5, 8), (5, 9), (6, 8), (7, 8), (8, 9)]\n", + "SDP upper bound: 16.92829208950866\n", + "DC-QAOA node partition: 1001001101, max cut = 16.0\n", "\n", "Random graph 5\n", - "Edges = [(0, 1), (0, 2), (0, 6), (1, 2), (1, 4), (1, 5), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 6), (2, 8), (2, 9), (3, 6), (3, 7), (3, 8), (4, 7), (4, 9), (5, 7), (5, 8), (6, 7), (6, 9), (7, 9), (8, 9)]\n", - "SDP upper bound: 18.82486962324589\n", - "DC-QAOA node partition: 1010000110, max cut = 18.0\n" + "Edges = [(0, 1), (0, 6), (0, 8), (0, 9), (1, 2), (1, 3), (1, 5), (1, 7), (1, 8), (2, 3), (2, 4), (2, 5), (2, 7), (3, 4), (3, 5), (3, 7), (3, 8), (3, 9), (4, 5), (4, 6), (4, 7), (4, 8), (5, 6), (5, 7), (5, 9), (7, 8), (8, 9)]\n", + "SDP upper bound: 19.302543017206013\n", + "DC-QAOA node partition: 1000010110, max cut = 17.0\n" ] } ], @@ -613,7 +613,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2021-05-11T07:02:35.547590Z", @@ -623,7 +623,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -639,7 +639,7 @@ "\n", "plt.plot(value_dc_qaoa_ls, label=\"DC-QAOA\")\n", "plt.plot(ubound_sdp_ls, label=\"SDP upper bound\", linestyle=\"--\")\n", - "plt.title('Max-Cut Performancce')\n", + "plt.title('Max-Cut Performance')\n", "plt.xlabel('Random Graph')\n", "plt.ylabel('Calculated Optimal Max Cut')\n", "plt.legend()\n", @@ -700,10 +700,10 @@ "metadata": { "celltoolbar": "Raw Cell Format", "interpreter": { - "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" + "hash": "f7cfecff1ef1940b21a48efa1b88278bb096bd916f13c2df11af4810c38b47e1" }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.0 ('pq')", "language": "python", "name": "python3" }, @@ -717,7 +717,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.11" + "version": "3.8.0" }, "toc": { "base_numbering": 1, diff --git a/tutorial/combinatorial_optimization/MAXCUT_CN.ipynb b/tutorials/combinatorial_optimization/MAXCUT_CN.ipynb similarity index 73% rename from tutorial/combinatorial_optimization/MAXCUT_CN.ipynb rename to tutorials/combinatorial_optimization/MAXCUT_CN.ipynb index a73ce5f..f1e2dab 100644 --- a/tutorial/combinatorial_optimization/MAXCUT_CN.ipynb +++ b/tutorials/combinatorial_optimization/MAXCUT_CN.ipynb @@ -136,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 16, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:11:08.078417Z", @@ -147,8 +147,10 @@ "source": [ "# 加载量桨、飞桨的相关模块\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import pauli_str_to_matrix\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.qinfo import pauli_str_to_matrix\n", + "from paddle_quantum.loss import ExpecVal\n", + "from paddle_quantum import Hamiltonian\n", "\n", "# 加载额外需要用到的包\n", "import numpy as np\n", @@ -168,7 +170,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:11:08.411878Z", @@ -178,7 +180,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -224,7 +226,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:11:08.426170Z", @@ -264,7 +266,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:11:08.792299Z", @@ -322,33 +324,19 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:11:10.245237Z", - "start_time": "2021-04-30T09:11:10.238838Z" - } - }, + "execution_count": 6, + "metadata": {}, "outputs": [], "source": [ - "def circuit_QAOA(p, gamma, beta):\n", + "def circuit_QAOA(p):\n", " # 初始化 n 个量子比特的量子电路\n", - " cir = UAnsatz(n)\n", + " cir = Circuit(n)\n", " # 制备量子态 |s>\n", " cir.superposition_layer()\n", - " # 搭建 p 层电路\n", - " for layer in range(p):\n", - " # 搭建 U_D 的电路\n", - " for (u, v) in E:\n", - " cir.cnot([u, v])\n", - " cir.rz(gamma[layer], v)\n", - " cir.cnot([u, v])\n", - "\n", - " # 搭建 U_B 的电路，即添加一层 R_x 门\n", - " for v in V:\n", - " cir.rx(beta[layer], v)\n", - "\n", - " return cir" + " # 搭建p层U_D电路\n", + " cir.qaoa_layer(E,V,p)\n", + " \n", + " return cir\n" ] }, { @@ -371,45 +359,17 @@ "\\tag{15}\n", "$$\n", "\n", - "要最大化该目标函数等价于最小化 $-F_p$。因此我们定义 $L(\\vec{\\gamma},\\vec{\\beta}) = -F_p(\\vec{\\gamma},\\vec{\\beta})$ 为损失函数，即要最小化的函数，然后利用经典的优化算法寻找最优参数 $\\vec{\\gamma},\\vec{\\beta}$。下面的代码给出了通过量桨和飞桨搭建的完整 QAOA 网络：" + "要最大化该目标函数等价于最小化 $-F_p$。因此我们定义 $L(\\vec{\\gamma},\\vec{\\beta}) = -F_p(\\vec{\\gamma},\\vec{\\beta})$ 为损失函数，即要最小化的函数，然后利用经典的优化算法寻找最优参数 $\\vec{\\gamma},\\vec{\\beta}$。下面的代码给出了通过量桨构造的损失函数：" ] }, { "cell_type": "code", - "execution_count": 9, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:11:11.218109Z", - "start_time": "2021-04-30T09:11:11.206471Z" - } - }, + "execution_count": 7, + "metadata": {}, "outputs": [], "source": [ - "class Net(paddle.nn.Layer):\n", - " def __init__(\n", - " self,\n", - " p,\n", - " dtype=\"float64\",\n", - " ):\n", - " super(Net, self).__init__()\n", - "\n", - " self.p = p\n", - " self.gamma = self.create_parameter(shape=[self.p], \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*np.pi),\n", - " dtype=dtype, is_bias=False)\n", - " self.beta = self.create_parameter(shape=[self.p], \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*np.pi),\n", - " dtype=dtype, is_bias=False)\n", - "\n", - " def forward(self):\n", - " # 定义 QAOA 的量子电路\n", - " cir = circuit_QAOA(self.p, self.gamma, self.beta)\n", - " # 运行该量子电路\n", - " cir.run_state_vector()\n", - " # 计算损失函数\n", - " loss = -cir.expecval(H_D_list)\n", - "\n", - " return loss, cir" + "# 构造损失函数\n", + "loss_func = ExpecVal(Hamiltonian(H_D_list))" ] }, { @@ -422,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:11:12.968989Z", @@ -441,18 +401,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "这里，我们在飞桨中优化上面定义的网络。" + "这里，我们在飞桨中优化上面定义的损失函数。" ] }, { "cell_type": "code", - "execution_count": 11, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:11:54.550338Z", - "start_time": "2021-04-30T09:11:21.244581Z" - } - }, + "execution_count": 17, + "metadata": {}, "outputs": [ { "name": "stdout", @@ -469,48 +424,26 @@ "iter: 90 loss: -2.9321\n", "iter: 100 loss: -2.9325\n", "iter: 110 loss: -2.9327\n", - "iter: 120 loss: -2.9328\n", - "\n", - "训练后的电路：\n", - "--H----*-----------------*--------------------------------------------------x----Rz(2.379)----x----Rx(2.503)-----------------------------------*-----------------*--------------------------------------------------x----Rz(1.230)----x----Rx(0.792)-----------------------------------*-----------------*--------------------------------------------------x----Rz(4.375)----x----Rx(5.180)-----------------------------------*-----------------*--------------------------------------------------x----Rz(0.711)----x----Rx(2.353)---------------------------------\n", - " | | | | | | | | | | | | | | | | \n", - "--H----x----Rz(2.379)----x----*-----------------*---------------------------|-----------------|--------*---------------------*----Rx(2.503)----x----Rz(1.230)----x----*-----------------*---------------------------|-----------------|--------*---------------------*----Rx(0.792)----x----Rz(4.375)----x----*-----------------*---------------------------|-----------------|--------*---------------------*----Rx(5.180)----x----Rz(0.711)----x----*-----------------*---------------------------|-----------------|--------*---------------------*----Rx(2.353)--\n", - " | | | | | | | | | | | | | | | | | | | | | | | | \n", - "--H---------------------------x----Rz(2.379)----x----*-----------------*----|-----------------|--------|---------------------|----Rx(2.503)---------------------------x----Rz(1.230)----x----*-----------------*----|-----------------|--------|---------------------|----Rx(0.792)---------------------------x----Rz(4.375)----x----*-----------------*----|-----------------|--------|---------------------|----Rx(5.180)---------------------------x----Rz(0.711)----x----*-----------------*----|-----------------|--------|---------------------|----Rx(2.353)--\n", - " | | | | | | | | | | | | | | | | | | | | | | | | \n", - "--H--------------------------------------------------x----Rz(2.379)----x----*-----------------*--------x--------Rz(2.379)----x----Rx(2.503)--------------------------------------------------x----Rz(1.230)----x----*-----------------*--------x--------Rz(1.230)----x----Rx(0.792)--------------------------------------------------x----Rz(4.375)----x----*-----------------*--------x--------Rz(4.375)----x----Rx(5.180)--------------------------------------------------x----Rz(0.711)----x----*-----------------*--------x--------Rz(0.711)----x----Rx(2.353)--\n", - " \n", - "优化后的参数 gamma:\n", - " [2.37918879 1.22914743 4.37582352 0.71142941]\n", - "优化后的参数 beta:\n", - " [2.50287593 0.79179726 5.17941547 2.35294027]\n" + "iter: 120 loss: -2.9328\n" ] } ], "source": [ "paddle.seed(SEED)\n", "\n", - "net = Net(p)\n", + "cir = circuit_QAOA(p)\n", "# 使用 Adam 优化器\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", - "# 梯度下降循环\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=cir.parameters())\n", + "\n", "for itr in range(1, ITR + 1):\n", - " # 运行上面定义的网络\n", - " loss, cir = net()\n", + " state = cir()\n", " # 计算梯度并优化\n", + " loss = -loss_func(state)\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", - " if itr % ITR == 0:\n", - " print(\"\\n训练后的电路：\")\n", - " print(cir)\n", - "\n", - "gamma_opt = net.gamma.numpy()\n", - "print(\"优化后的参数 gamma:\\n\", gamma_opt)\n", - "beta_opt = net.beta.numpy()\n", - "print(\"优化后的参数 beta:\\n\", beta_opt)" + " print(\"iter:\", itr, \" loss:\", \"%.4f\" % loss.numpy())\n" ] }, { @@ -532,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 14, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:11:55.548009Z", @@ -542,7 +475,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -554,8 +487,9 @@ } ], "source": [ + "state = cir()\n", "# 模拟重复测量电路输出态 1024 次\n", - "prob_measure = cir.measure(plot=True)" + "prob_measure = state.measure(shots=1024, plot=True)" ] }, { @@ -572,7 +506,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 15, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:11:55.906817Z", @@ -589,7 +523,7 @@ }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAb4AAAEuCAYAAADx63eqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAArzElEQVR4nO3deXQUVdoG8Kc7a3cIaTYhCYu4gEMQUEA0AuHzIAok4AwDqOxRNh0QEcUZFJhx/BQEZHFkU3YVhHEhyOIoiElw2D6RTRIiIAaiYCCRLJ2t7/fHtZskZK/qruqu53dOzkl3kqpXTPrpW/ete01CCAEiIiKDMGtdABERkScx+IiIyFAYfEREZCgMPiIiMhQGHxERGQqDj4iIDIXBR0REhsLgIyIiQ2HwERGRoTD4iIjIUBh8RERkKAw+IiIyFAYfEREZCoOPiIgMhcFHRESGwuAjIiJDYfAREZGhMPiIiMhQGHxERGQoDD4iIjIUBh8RERkKg4+IiAyFwUdERIbC4CMiIkNh8BERkaEw+IiIyFAYfEREZCgMPiIiMhQGHxERGQqDj4iIDIXBR0REhsLgIyIiQ2HwERGRofhrXQCREdjtwNGjwOHDwIULwLVrQHExEBICNGgAdOwIdO4MNG2qdaVEvo/BR+QmR44Ab70F7N4N/PQTYLXKsMvLK/t9/v4yAO12+T133QXExwN//jMQFKRJ6UQ+zSSEEFoXQeQr7HZgyxZgzhzgzBmgoAAoKan9cerVA0wmYPx44C9/AVq1Ur9WIqNi8BGpZNs2YNQooLAQyMlR55iBgYDZDIweDcybJ0eGRKQMg49IoatXgXHjgO3bb7yMqRaLBbDZgE2bgB493HMOIqNg8BEp8OWXwODBMvAKCtx/PotFzv8tWgT4+bn/fES+iMFHVEdbtgAjRwL5+Z49r9UK9OoFfPQRm1+I6oLBR1QHH34o5908HXpOFgsQHQ3s2AEEBGhTA5G3YvAR1dLnnwOPPKJd6DlZLEDfvnLkaTJpWwuRN+HKLUS1cPkyMGSI9qEHyBp27QJWrtS6EiLvwhEfUS3ExgL/+Y+8ZUEvQkKAkyeBli21roTIO3DER1RDmzcDe/boK/QA2U362GMA38IS1QyDj6gGrl0Dxo513316ShQXA999B6xbp3UlRN6BwUdUA+vWyYDRq9xc4JVXOOojqgnO8RFVQwigdWvgxx+1rqRqISFy/vG++7SuhEjfOOIjqkZiIvDrr8qP07s3sGAB8NVXQHa2DFTnR0yM8uPn5cn1PImoatyWiKgaCxaoM7f39NPy/j93EUKuF3rlCtCwofvOQ+TtOOIjqkZiojpzZ0LITWgTEoD33lN+vIoEBgIHDrjn2ES+gsFHVIVLl2TjiBqGDQOaNwcGDHDfTed5ecDBg+45NpGvYPARVeHwYSA4WJ1jeWK1l+JiYO9e95+HyJsx+IiqcPCgeiM+TzlyROsKiPSNwUdUhdRUfd+/V5HMTMDh0LoKIv1i8BFVwdtGe4DcoNYTm+ISeSsGH1EVioq0rqD2zGbvrJvIUxh8RFWwWLSuoPaKi72zbiJPYfARVaFBA60rqD2zGfDn0hREleKfB1EVOneWN5ursXLLkCFA167y8xYtyn5t4kS51x8gO0k//LDu52ndmjuyE1WFwUdUhc6d1Rs99e0LjB5d8deGDr3++Zo1yoKPi1QTVY2XOomqcOednrnxXC1WK9C9u9ZVEOkbtyUiqsbttwNpaVpXUTOhoXKX+M6dta6ESL844iOqxvDh6i1b5m5BQUCnTlpXQaRvDD6iaowf7x07m1sswJQp8gZ2Iqocg4+oGs2aAQ8+qP9OSYcDGDtW6yqI9I/BR1QDzz8vG0f0ymwG+vUDbrpJ60qI9I/NLUQ1IATQo4fAN9844HDo71qixQJ8+y3Qtq3WlRDpH0d8RDVw+nQq7PY/weHQ370NISHAjBnFOHp0M/g+lqh6DD6iKpSUlGDBggXo2LEjDh/+BPXrz0JwsH72KTKbgVtvBXJyZmPIkCGIjY3FhQsXtC6LSNcYfESVSElJQc+ePfHcc8/Bbrdj1KhROHv2Jdxzjz+CgrSuTgoOlqu8tG//B9hsNmzfvh1RUVFYs2YNR39EleAcH1EFCgoK0Lp1a2RkZCAiIgIrVqxA//79AQDZ2cA99wBnz2q7/Y/FAnz0EfDww/LxxYsXMX78eGzbtg0A0K9fP6xYsQKRkZHaFUmkQww+okqsXbsWe/bswZtvvokG5bZpuHQJuPdeID1dm/CzWIC1a4HBg8s+L4TAhg0bMHnyZGRlZSEsLAyHDh3Cbbfd5vkiiXSKwUcEOZe3aNEiBAQEYNKkSTX6mStXgJgY4IcfPLeep8kkQ2/zZnn7QmWco7+SkhJ89tlnMOn9JkQiD2LwkeGlpqZizJgx2LdvH4KDg3HmzBmEh4fX6Gfz84EXXgDefdf94We1yu2MNm+Wi2dXRwiBvLw8hISEAJBzlvv27cPo0aMZhGRobG4hwyrdsblv3z6Eh4dj8+bNNQ49QI6+liwBvvgCiIx0z87nzlHeCy8Ax47VLPTkz5lcoVdSUoL4+HjEx8ez85MMj8FHhpSamlqmY3PkyJE4ceIEYp27wdZSdDRw+jQwebLcIaFePeU1BgbKrs1evYD9+4FZs4CAgLody2w2Y8KECez8JAIvdZJB9e7dG19++SXCw8OxYsWKOgdeRQoKgC1bgDlz5PwfUPMd3P395SVNIYAJE4CnnwZatVKtNHZ+EoHBRwYihHDNbaWmpmLu3Ll44403bujYVNPJk0ByMpCUBHzzDXDunAy3/PwcAAJWayiKioCwMOCuu+TorksX2TTjrnsFy3d+NmvWDGfOnIHFHddpiXSIwUc+z9mxmZycjC1btmja2FFYCGRmAhERtwDww/nzp1G/vgw+T3OO/nr16oXnnnvO8wUQaYTBRz6tdMcmAHz11VeIiYnRuCq4wlfrPz8hBIQQMJvldP8HH3wAu93Ozk/yaWxuIZ9UUcdmQkKCLkJPT0wmkyv0Ll++jIkTJ7Lzk3weg498jtodm0bRuHFjLFmypEzn5+rVqzUflRKpjcFHPmfDhg1lRnlr1651awOLrzCZTBgxYgROnjyJuLg4ZGdnc/RHPolzfOQTCgsLERgYCEAuMP2Pf/wD06ZN023g6WWOrzLlOz/vv/9+JCUlaV0WkSoYfOTVnB2bb731Fg4dOoSGDRtqXVKN6D34nDIyMvDUU09hxowZ6NKli9blEKmCwUdeq3zH5vLlyzFu3DiNq6oZbwm+ikyaNAmdO3fGqFGj2PlJXonBR17HOcqbMWMG7Ha7W1ZfcTdvDb5vvvkG0dHRALjqC3kvNreQV2HHprbuvfderFu3jmt+kldj8JFXSU9PZ8emhpydn843G9nZ2RgzZgw7P8mr8FIn6V5mZiYaNWrkerx+/XrExsZ6deB566XO0sp3fk6ePBmLFi3SuiyiajH4SLecc3kvv/wyduzYgZ49e2pdkmp8IficMjIyMGvWLMybNw/169cHUHZBcCK94aVO0qXSc3l5eXnYtWuX1iVRJZzNRc7Qy8vLQ7du3Tj3R7rF4CNdqWyNzVdffVXr0qiG3nvvPRw8eJBzf6RbvNRJunHu3DkMGzbMdV/eyJEjsXDhQq+ey6uML13qLK/83F9YWBgWLlzI+/5INxh8pBuXL19GVFQU/P39ve6+vNry5eBz4m7vpFcMPtJUWloaWrVqhYCAAADA/v370aZNG58c5ZVmhOADbhz9bdq0CUOGDNG6LDI4zvGRJpxzeXfeeSdee+011/PdunXz+dAzktL3/c2dOxeDBw92fS0/P1/DysjIGHzkceVXX/npp598fuRjdBEREXj++eddI92jR4+iVatW3O+PNMHgI4+prGNz5cqVbHowmPfeew+XL1/mfn+kCc7xkUdcvXoVsbGxhujYrAmjzPFVpqLOzzfffBOjR4/mmyByO474yCNsNhssFgvX2CQAVe/2fvHiRa3LIx/HER+5TWpqKgIDA3HzzTcDkO3tFouFgQeO+EorPforKirCsWPH0Lp1a63LIh/G4CPVld4vr1u3bti9ezfMZl5cKI3Bd6OMjAwcOXIEffv2BQA4HA5cunQJzZo107gy8jV8NSJVle/YbNWqFex2u9ZlkRcIDw93hR4ALF26FHfccQc7P0l1DD5SRWUdm2vXroXVatW6PPJCycnJZeb+2PlJauGlTlLM4XCgd+/e2LNnDwB2bNYEL3VWj52f5C4c8ZFiZrMZvXv3Zscmqaqyzs/+/fvjypUrWpdHXowjPqqT1NRUnDt3Dn369AEAFBcX49q1awy8GuKIr3ZKj/5uueUW/Pe//3Wt70pUWww+qpXSHZtWqxUnTpxg110dMPjqJiMjAzk5Obj99tsBAJcuXUJRURF3fKBa4aVOqrHyHZuxsbEICgrSuiwykPDwcFfoCSEwceJEREVFcbd3qhUGH1Wrqo5NXtokrdjtdhQWFiI7O5u7vVOtMPioWvHx8a5R3siRI3HixAmf3iSWvIPFYsHWrVuxbt062Gw2bN++HVFRUbzvj6rFOT6q1r59+zB06FAsXbqUgacSzvGpq/xu7/3798enn34KPz8/jSsjPeKIj26QkpKCefPmuR5HR0cjLS2NoUe6FRERUWb016ZNG4YeVYojPnIpKSnBwoUL8dJLL8Fut2PXrl2u2xVIXRzxuU9GRgbCwsJcKwYdPHgQERER7PwkF474CIAc5fXs2RPTpk2D3W7HqFGj0LVrV63LIqq18PBwV+j99ttvGDRoEDs/qQwGn8GVlJRg/vz56NSpE/bt24eIiAhs27YNa9asYccmeb2CggJ07NiRnZ9UBoPP4F5//fUyo7zjx4+jf//+WpdFpIomTZpU2PnJ0Z+xcY7P4LKystCnTx/MmjWLgedBnOPzvPKdn0888QTeeecdjasiLXDEZzCpqakYPXq0a488m82G/fv3M/TI55Xv/PzjH/+odUmkEQafQZSUlODNN99Ex44dsXbtWsyZM8f1NW7xQkbh3PHh7NmzZd7srV+/nnN/BsLgM4DU1FTExMRg6tSprtVXJk+erHVZRJqx2Wyuzw8cOIDRo0dz7s9AGHw+rPQoLzk5GeHh4di6dSvX2CQqpUWLFujfvz87Pw2EzS0+bNu2bYiLiwPAXdH1hs0t+lLRbu8LFy7EqFGjOBXggxh8PkwIgfHjxyMuLs4VgKQPDD59Kt/5+corr+Cll17SuCpSG4NPDcXFQH4+YDIBFgug0RqBqampmDhxIpYsWYJ27dppUgPVDINPv5yjv9mzZyMxMRERERFaFwTY7UBhIRAUJD84ClWEwVdbp08DBw4A33wDJCUBp07JX0hn2BUXA1YrEBUF9OwJdOsmP1q2dFtJpXdFt9vtGDhwID755BO3nY+UY/DpX3FxMfz9/QHIv7EXX3wRzzzzDJo3b+6+k+bmAgcPAocOAV99BRw+DPzyC2A2yw+HQ35ERgJduwIxMUDnzkCXLkBwsPvq8jWCqpeXJ8Tq1ULccYcQFosQ9eoJId+HVf1hNgsRGipEcLAQXbsKsWWLEIWFqpaWkpIioqOjBQABQIwcOVJcuXJF1XOQ+pz/v8g7LFiwQAAQYWFhYtWqVcLhcKh7ghMnhBg7Vr6+1K8vRGBgzV5jgoLk99erJ8Qzzwjxww/q1uWj+JdXlStXhJg8Wf5S1TTsqvoIDRXCZhNi5kwZpgoUFxeL+fPni+DgYAFAhIeHi4SEBJX+w8ndGHze5eLFiyIuLs71/61fv34iPT1d+YF37RKic2cZeP7+yl5fAgLkm+wePYRISlJemw/jX15ltm4VokED+Y5KaeCV/7BYhIiMFCI5uc7lnT17VlgsFo7yvBSDz/s4HA6xbt06YbPZlI/+rl4VYuhQIaxW9V9fnK8xEyYIkZur+r+DL+AcX3lXrwLjxgHbtwN5ee49l8UCxMcDb7whP69GSUkJzGaza35o9erVaNKkCTeI9UKc4/NeGRkZGD9+PBISEgAAW7ZswaBBg2p+gO3bgREj5HxeQYGbqoR8TbHZgE2bgB493HceL8TgKy0tDbj/fiA7272/kKVZLECLFkBiInDTTZV+W2pqKsaMGYMxY8bgySef9Ext5DYMPu8mfu/83Lx5Mz7++OOa7fYuBPDyy8Cbb7r/TXVpFgvw+usAV2tyYfA5HT8u3xVlZ8tfUE8KCACaNgX++1/ZrVVK+Y7NO+64A8ePH6/ZHxrpFoPP96Snp2PatGmYP3/+jbu9CwH85S/AmjWeDT0nqxWYPh2YOdPz59YhLlkGAD/8IG89yMryfOgBQFERkJEBREcDly+7nk5NTUXPnj3x3HPPudbY3LdvH0OPSIemTZuGTZs2Vbzm5/Tp2oUeIM87Zw4wb54259cbjeYW9ePaNSEiIuStB+6YZK5tV1aHDqLYbmfHpo8Dm1t8zoULF0RsbOyNnZ8rVriviaW2H1arEB9/rPU/leZ4qTM+HvjgA7kygh6EhKB4+nR03rIFR48e5RqbPoqXOn2TEGXX/GwfGor/KyhAQGGh1qVdZ7PJfoZGjbSuRDPGDr7du4G4OO0uP1TGYsH3Gzbgh8BAdmz6KAafb8vIyMD4cePw4rZt6AogQOuCSgsMBPr2BQy8upNxg+/aNeC224BLl7Su5EYmE9CuHXDkCPD7kknkWxh8vk8sXYriZ59FgKc6xGvDagU2bAAMugu9cZtbliyR4adHQgDnzgFbtmhdCRHVhd0O0/Tp+gw9QF7levppue6nARkz+EpKgIUL5Y4KepWbC8ydq3UVRFQXW7Zo0yFeG9euAV98oXUVmjBm8O3cqZ9mlqqcOiXvLyQi7zJnDpCTo3UVVcvJMeyba2MG39y5yi9z2mzAyJHAO+/IrUMuXJCrvWRnyy1F/v53QGknZmGhXOWBiLzHt98CZ84oP07DhsCrrwJHj8rXq2vX5Oevvqr8tcUpORk4f16dY3kR4zW3XLsm23iLipQdZ9Cg6ufgLl4EHngASEmp+3nq1QN++40bT/oYNrf4sOnTgfnz5ZRKXUVFAZ9/DlS2Ce7Fi0CfPsCJE3U/ByD38Pvf/wWefVbZcbyM8UZ8334rO5rUkpUFbNwo1+CbN0/+QjpFRADLlys7fkmJId+REXmtvXuVhV5wMPDRR9dD7+pVeZVqzhz5OSC/9u9/y93YlbDbZb0GY7xe+cOH1Znfu3IFeOYZYOXKsk0yc+bIebmmTeXjHj3kqK2u1/sDAmTNrVopr5mI3EsI5fPyw4YBbdpcf/z447IvAZAhtX27/LxtW/m9q1YpO9+hQ8p+3gsZb8S3d686Oy/s2QMsXnxjZ+ivv8qdFpzMZnnDaF3l5MjFq4lI/86fV36LQOl767Kzr4ceID//7bfrj//0J2XnAuS9zHq9tctNjBd8337r/nPcccf1z9PS5OiwrhwO4JtvlNdERO733XfyKo0SnTpd//zs2bJfE6Lscx07KjsXIKd+DNY9brzgc3eL8cyZQPv2ZR8rlZ2t/BhE5H7Z2cpHfKXX0Cw9uqvoucaNlZ2rqvP4MOPN8blrsViTSTa3TJ16/bnZs+UC2ErpdfUHIirLbld3NZSKurnV7vAWwjvua1aR8YLP7IZBbr16MuCcC0o7HMALL8iWZjVw/z0i7+DnpzyYMjOvb0hdv/6NXy/93K+/KjsXIOs12GuM8YJPaftveS1bAgkJQIcO8nFuLjBiBPDxx+qdIzhYvWMRkftYLMrfXB85cj34WreWweS839Nkks85ffedsnM5WSzqHMdLGG+Or1kz9Y7VrRuwf//10PvpJ6B7d3VDD5DhSkT6FxmpfMRXerug+vXlFkJOffsCoaHXH6vxWlNSUvmN8j7KeCu3PPUUsHSp8uPcdx/w5ZfX3ykVF8uFr3/++cbv3bQJSE+v23mCgoDXXjPcygq+jiu3+Cg1VoYKDpYjOee9fFlZ1xfCGDfu+nJlqamyq1Pp/FxQkLxSZaDLnca71HnffcD69cq7O9u0KXt5wN8fmDat4u89dKjuwRccDHTuXLefJSLPCg0FmjQpu4JTbdnt8v68//wHCA+X6wJPn172ezIy5Peo0ZTSpo2hQg8w4qVObwuRvDzgrru0roKIaqpLF+XHOHFC3hb12mvy89xc+XHihHyufXvl63Q6de+uznG8iPEudZaUyHdQet8yxOnWW+VN8ORTeKnThy1dKq/+5OVpXUn1QkPlkmd//rPWlXiU8UZ8fn7AE08oX13BE0JCOLdH5G0ee8x7djY3mYC4OK2r8DjjBR8ATJrkHde0HQ55awQReQ+bTW5bpvfXmMBAYPx49W/x8gLGDL5bbwW6dtW6iqr5+wOPPlrxDaxEpG9Tp+o/UMxm4Omnta5CE8YMPgCYMUNeStSrgADguee0roKI6uLuu4G2bSH0uoG0vz/Qq5dhtzszbvA99BDQu7eyLYPcJA/AyZgYiHbttC6FiOrox1dfRYFegy84WO4lalDGDT4AeOcd3S3V4wBwCcBdO3diwIABuKjkfiAi8jiHw4FFixbhD4MG4R8OB3K1Lqi8kBC52Ebz5lpXohljB1/jxsDq1XI/Kp0wWSw4/vLLsISFYdu2bYiKisL69evZ9k7kBdLS0tCrVy9MmTIF+fn5SH/sMQTdcYf6OyrUlb+/vJc5Pl7rSrQlSIgxY4SwWoWQS8Fq92G1CvHKK0IIIdLT00W/fv0EAAFAxMbGiszMTI3/oUgtzv+v5DvefvttYbFYBADRtGlT8cknn8gvpKQIUb++9q8vJpMQjRsLkZ6u7T+UDhh7xOe0ciXw4IPaXva0WuX9hTNmAAAiIyOxbds2rF69GmFhYTh37hxC9NyMQ2RweXl5yM/Px7Bhw3Dy5EkMHDhQfqFNG2D3bm2b6UwmICwMSE6+vvODgRlv5ZbKFBXJ2wd27vT8igtWKzBhgtzItoJLIhcuXEB2djba/d7scuXKFRQUFCA8PNyzdZJquHKL93M4HDh16pTr77KkpAR79+7FAw88UPEPHDgg32B7erdzs1neW5iYCLBhDoDR5/hKCwgANm8GnnzScyM/k0mea/ZsuWltJfMAkZGRrj8uAJg0aRLatWvHuT8ijaSlpSEmJgbR0dG4cOECAMDPz6/y0AOAe+65PuLy1GuM1Qrccgtw+DBDrxQGX2lmM7BokRz1hYe795fTapWXQPbvB55/vsY/VlBQgKtXryIrKwsjR47EwIED2flJ5CHOjs0OHTogKSkJwcHBOHfuXM0P0L693E4oPt69ry/ON9VTpwInTwI33+y+c3kjbacYdSw3V4gJE4SwWIQICFBvgjkoSB5z9mwhCgvrVJrD4RCrVq0SYWFhAoCw2Wxi3bp1wuFwqPyPQO4CNrd4ndOnT4vu3bu7/t8NGzZMWcNZcrIQkZFC1KunbhNLvXpC3H67EEeOqPcf72P4l1edlBQhnnpKiJAQ+VHXX8bQUCFsNiH+9jchfvpJldJ++ukn0bdvX9cfYlxcnCgqKlLl2OReDD7v8v7771fcsalUQYEQGzcKcddd8g2xn1/dXl8CAoQIDhYiOlqITz8Vgq8DVeKlzuq0aQP861/ApUvyMujdd8s1+EJC5JYeFc3Lmc1yjU2rVX7cf7+8Wf7SJeDVV1W7cbR58+b47LPPsGrVKoSFhaF58+bw9zfe3sJE7nb77bejsLDwxo5NpQIDgaFDgf/7P9n8MmqUnGYJCJBdmJWt9xkcLF9j/P2BFi3kYtNHj8o5xAED5PNUKXZ11oXDAZw+LSeMDxwAfvlFbhJpMslAbN5cTmR37iyvrXvg5tX09HTYbDbUq1cPAHDkyBHcdNNNiIiIcPu5qfbY1alvDocDn3/+OR5++GHXcykpKWjbtq1nCsjOBr79Vr7GHD0q9w8tKLgeeB07yteXTp2A3//mqeYYfD4oNzcXHTp0wJUrV7B48WIMHz7c9UJL+sDg06+0tDTEx8cjMTERW7duRZwB96vzdbzU6YPy8vLQtm3bMp2fGRkZWpdFpGulOzYTExPRtGlTTh34KAafD2rSpEmZub+EhATe90dUhfJrbDrn8vr27at1aeQGvNTp49LT0zFu3Djs2LEDABAfH493331X46qIlzr1Y/fu3YiNjUV+fj6aNm2K5cuXq9e8QrrEEZ+PK9/52a9fP61LItKVLl26oEmTJup3bJJuccRnIJmZmWjUqJHr8Ycffoju3buz81MDHPFpx+FwYNWqVXj88cdh/X1LsvJ/G+TbOOIzkNJ/2EeOHMGwYcO43x8ZinMub+zYsZjx+04oABh6BsPgM6gmTZrgwQcfZOcnGUJFHZu9evXSuizSCIPPoCIjI9n5SYZQWccm5/KMi3N8dEPn59///nfMnDlT46p8G+f4POOHH37AnXfeyY5NKoPBRwDkC/CaNWswa9YsJCYmolWrVlqX5NMYfJ4zePBgBAUFYfHixWjYsKHW5ZAOMPiojMLCQgQGBgKQ8yKzZs3CxIkT2fmpMgafezgcDrz11luIiYlBx44dAZT9nSYCOMdH5ZR+gVi2bBn++c9/svOTvIJzLu+ZZ57BmDFjUFJSAgAMPboBg48qNXDgQPTr18/V+TlgwADu9k66U1HH5qxZs+Dn56d1aaRTvNRJVRJCYO3atZgyZQqys7Nhs9m444MKeKlTHaV3UgCAYcOGcS6PqsXgoxq5cOECxo0bh+3btwMANm7ciKFDh2pclfdi8CmXn5+Pm2++GZcuXWLHJtUKg49qzDn6e//997F9+3Zu2aIAg08dS5cuRXJyMkd5VCsMPqo1IYTrhfvnn3/GtGnTMHfuXHZ+1gKDr/YcDgeWLFkCq9WKsWPHAij7u0hUUww+UmTEiBHYsGED5/5qicFXO2lpaRgzZgySkpIQEhKCM2fO4KabbtK6LPJS7OokRV5//XV2fpLblO7YTEpKQrNmzfD+++8z9EgRjvhIMXZ+1h5HfNUrPcoDgOHDh2PRokWcyyPFGHykmtKdn2azGceOHUO7du20LkuXGHzV69mzJxITE9GsWTMsX74cAwYM0Lok8hEMPlKVc/R3/vx5LnRdBQZf9Y4dO4b58+djwYIFHOWRqhh85HY7d+7E22+/jWXLlrHz83cMvrKca2wePHgQ69at4yVycisGH7mVEAIdOnTA8ePHOfdXCoPvuvKrryQnJyM6OlrjqsiXsauT3MpkMmHHjh3o27cvOz+pjIrW2Pz4448ZeuR2HPGRRzj3+3v22WfZ+QmO+MqP8h5//HEsXrwYjRo10rgyMgIGH3lU6d3eIyMj8f333yM0NFTrsjzO6MH3wgsv4I033kDTpk2xbNkyPPLII1qXRAbC4COPc3Z+hoeH46GHHgIAFBcXw8/PzzCjPyMGX3FxsWt917y8PMycORN//etfOcojj2PwkS688MILOHXqFJYvX47w8HCty3E7IwWfc43NpUuXYv/+/QgLC9O6JDI4NreQ5rKysvDuu+8iISEB7dq1427vPsS5K/qUKVOQkpKCLVu2aF0SEYOPtGez2fDdd9+V6fwcOHAgMjIytC6N6qiijs1PPvkETzzxhNalEfFSJ+mHkTo/fflSJ3dFJ73jiI90w2QyYcyYMTh+/Lhr9MdLY94nJSWlzChvw4YNDD3SFY74SJeEEFi3bh369OnjanbJyspCWFiYT4z+fG3El5WVBZvN5nq8cuVKDBo0iIFHusTgI69QXFyM6Oho10r93t756SvB5+zYfPnll/HFF1/gnnvu0bokomrxUid5hZMnTyI1NZWdnzpSumPz2rVrSEhI0Lokohph8JFXcC50zc5P7VXWsfnKK69oXRpRjfBSJ3mVijo/3377bTz22GNal1Yr3nqp88cff8SIESPYsUlejSM+8ioVdX5evnxZ67IMIyAgAMeOHWPHJnk1jvjIawkhkJCQgNjYWJjN8j1cWloabr31Vt13fnrTiO/s2bNo2bIl/Pz8AABff/012rdvz8Ajr8URH3ktk8mEAQMGuELv/PnzuPvuu7nfn0qcc3lRUVFYsGCB6/mePXsy9MirMfjIZ5w6dQpmsxnbtm1DVFQUOz8VSEtLQ0xMDKZMmYL8/HykpqZqXRKRahh85DP69OmDEydOoF+/ftztvY5Kd2wmJSWhWbNm+PTTT7Fy5UqtSyNSDef4yOc49/ubMmWKq/Nz/fr1iI2N1bo0Fz3O8WVmZuKRRx5BUlISAGD48OFYtGgRL2uSz+GIj3yOyWTC6NGjXaO/nJwcNG/eXOuydM9ms0EI4RrlrV+/nqFHPokjPvJpQggcPXoUHTt2dD339ddfo0ePHpp2fuplxJeWlgaLxYLIyEgAskGoXr16DDzyaRzxkU8zmUxlQu+jjz5CTEyMx1d9KSgADh8GVqwAZs8GgDcALMTf/gbMnQvs2gX8+qvHyikzl/fkk0+6Arhly5YMPfJ5/loXQORJRUVFCAsLQ0JCAhITE92639+xY8C//gV8+SXw449AcDBQUgLk5QHANADAa68BAQGAxQLY7UBoKHD33cATTwB//CMQGKh6WTfsl9eoUSPY7XZYLBb1T0akQ7zUSYaTnp6OcePGYceOHQCA2NhYLF++HBEREYqPXVgIfPQRMGcOkJIiH5eU1P44oaGA2QxMmAA8/TTQooXi0lw7Kfz1r39Ffn4+mjZtiuXLl2PgwIHKD07kRRh8ZEgVdX7u2LED9957b52PuX07MHKkDLtr19SpMygIMJnkCHDuXMBqrdtxSkpK8OCDD2LPnj0A2LFJxsY5PjKk8p2fDRs2xJ133lmnY2VlAY8+CgweDGRmqhd6gJwbtNuBVauANm2A5OS6HcfPzw/3338/OzaJwBEfEYQQ+OWXX9CsWTMAQE5ODj777DMMGTKk2rm/r74CBg0CcnNlSLmbxQKMHQssWAD8vnRmpdLS0nDhwgXExMQAAAoLC5GTk8PAI8PjiI8Mz2QyuUIPAF588UU8+uij1XZ+fvwx0K8fcOWKZ0IPAPLzgXfekY0vhYUVf0/pjs2hQ4ciMzMTABAYGMjQIwKDj+gGXbt2dXV+Vrbb+7//DQwbJoPI0/LygC++AOLigOLisl8rvSt6fn4+evfurfudKog8jZc6iSpQvvMzLi4Oy5cvR3h4OL78EhgwwHlbgnasVqB/f2DTJkAIdmwS1RSDj6gS5Xd7b9CgAfbuPYEePcKRna11dVJICLBwIbB37whs2LABAHdFJ6oOg4+oGs7Rn81mQ27u+9i5s/L5NS2EhADvvJOMqVMHY+nSpRzlEVWDwUdUA0IIbNxYiCefDNL8Emd5/v7AvfcCu3blw2rl6itE1WHwEdXAtWtAy5bynj09CgkBli0Dhg/XuhIi/WNXJ1ENbNgAFBVpXUXlcnPl4td8G0tUPY74iKohBHDLLcC5c1pXUrWQEHmbg4JV14gMgSM+omokJQGXLys/zuzZwNatwOnT8qb3oiIgOxs4ehR4+22gfXtlx8/PB+bNU14nka/jiI+oGn/6E/DJJ8ovI1b384WFcr3PrVvrfo7gYODiRaBBg7ofg8jXMfiIqtGokRyhKfXzz3L0eOaMPF69ekCfPkDXrte/5+RJICqq7ucIC5M3tD/0kPJ6iXwVg4+oCpcvA82bu+++PZMJ+P57oG1b+Tg/v+5bDwFyU9uZM4GXXlKnPiJfxDk+oiocPix3RFCbyQQ0bCi3M2rZ8vrzx44pO25Rkdwxgogq5691AUR6duCAvFVALa1aVd4d+uuvwOTJys9x5IjyYxD5Mo74iKqQmnrjDgjucPIk8D//A+zfr/xYmZmAw6H8OES+iiM+oiqoOdoDZFPLtGlymbFmzYDYWOC224B27eToMj4e2LhR2Tn8/OT+gO64REvkC9jcQlSF2Fjgs8/cd3w/P2DnTqB3b/k4Nxe49Vbgl1/qfsyAAHnZtH59dWok8jW81ElUheBg9x6/pARISLj+OCQE6NZN2TGLi91fN5E3Y/ARVUGtLe169Kj4pnKTCejbt+xzSq/BmM1y1EdEFeMcH1EV7r5b3lendCui+HjgscfkrQbffit3eWjcGOjXT87vOWVnA3v3KjvXzTfLQCWiijH4iKrQubNsRFFDUJBcUaWyVVV++03e1/fbb8rOc999yn6eyNcx+Iiq0KGDXE1FqXfflYF2771yJZhGjeTzV68CKSlyV4UVK4BLl5Sdx2oFundXXi+RL2NXJ1E1brsN+OEHrauomdBQYPduoEsXrSsh0i82txBV4/HHvadLMigIuOsurasg0jcGH1E1Jk70jp3Ng4OBZ56R9wYSUeUYfETVCA+XN5h7Q6fkuHFaV0Ckfww+ohp4/nll2wW5m9kMPPwwcNNNWldCpH9sbiGqASFkt+SBA55ZtLq2LBa5hdIf/qB1JUT6xxEfUQ2YTMAHH8jmEb0JCZEbzzL0iGqGwUdUQy1bAvPmyaDRC5MJaN0amD5d60qIvAcvdRLVghBy3c2DB4HCQq2rkfOOhw5xtEdUGxzxEdWCySR3U2jRQr2lzOrKYgE+/JChR1RbDD6iWmrQAEhOBiIjtdsFwWKRy6D176/N+Ym8GS91EtXRr78CMTHAmTOA3e6Zc5pMMvQ2bgTi4jxzTiJfwxEfUR01bixvbxg9WoaRu1mtct3QffsYekRKcMRHpIKvv5ZbCmVlqbObQ2kmk1yObOpUYNYsbjJLpBSDj0gleXkymJYtk49zcpQdLzBQrsjStSuweDHQqZPiEokIDD4i1eXnA5s3A3PmAOfOyVsgajoK9PeXlzQdDmDsWGDSJHmfHhGph8FH5EZHj8oO0KQkYP9+4Px5eanSbJaXMB0OoKhI3hTfqZNslunaFXjgAe/ZConI2zD4iDyooAC4fFmOAEtKZLjVrw80bKh1ZUTGweAjIiJD4e0MRERkKAw+IiIyFAYfEREZCoOPiIgMhcFHRESGwuAjIiJDYfAREZGhMPiIiMhQGHxERGQoDD4iIjIUBh8RERkKg4+IiAyFwUdERIbC4CMiIkNh8BERkaEw+IiIyFAYfEREZCgMPiIiMhQGHxERGQqDj4iIDIXBR0REhsLgIyIiQ2HwERGRoTD4iIjIUBh8RERkKAw+IiIyFAYfEREZCoOPiIgMhcFHRESGwuAjIiJDYfAREZGhMPiIiMhQGHxERGQo/w9aFCJRiVNAFQAAAABJRU5ErkJggg==\n", + "image/png": "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", "text/plain": [ "
" ] @@ -666,7 +600,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.11" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/combinatorial_optimization/MAXCUT_EN.ipynb b/tutorials/combinatorial_optimization/MAXCUT_EN.ipynb similarity index 73% rename from tutorial/combinatorial_optimization/MAXCUT_EN.ipynb rename to tutorials/combinatorial_optimization/MAXCUT_EN.ipynb index dc81947..061d041 100644 --- a/tutorial/combinatorial_optimization/MAXCUT_EN.ipynb +++ b/tutorials/combinatorial_optimization/MAXCUT_EN.ipynb @@ -139,7 +139,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:07:40.001750Z", @@ -150,8 +150,10 @@ "source": [ "# 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.ansatz import Circuit\n", + "from paddle_quantum.qinfo import pauli_str_to_matrix\n", + "from paddle_quantum.loss import ExpecVal\n", + "from paddle_quantum import Hamiltonian\n", "\n", "# Import additional packages needed\n", "import numpy as np\n", @@ -172,7 +174,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:07:40.192343Z", @@ -182,7 +184,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -228,7 +230,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:07:40.206426Z", @@ -268,7 +270,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:07:40.501135Z", @@ -325,33 +327,19 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:07:41.987233Z", - "start_time": "2021-04-30T09:07:41.977734Z" - } - }, + "execution_count": 6, + "metadata": {}, "outputs": [], "source": [ - "def circuit_QAOA(p, gamma, beta):\n", + "def circuit_QAOA(p):\n", " # Initialize the quantum circuit of n qubits\n", - " cir = UAnsatz(n)\n", + " cir = Circuit(n)\n", " # Prepare quantum state |s>\n", " cir.superposition_layer()\n", - " # Build a circuit with p layers\n", - " for layer in range(p):\n", - " # Build the circuit of U_D\n", - " for (u, v) in E:\n", - " cir.cnot([u, v])\n", - " cir.rz(gamma[layer], v)\n", - " cir.cnot([u, v])\n", - "\n", - " # Build the circuit of U_B, that is, add a layer of R_x gates\n", - " for v in V:\n", - " cir.rx(beta[layer], v)\n", - "\n", - " return cir" + " # Build a circuit with p layers of U_D\n", + " cir.qaoa_layer(E,V,p)\n", + " \n", + " return cir\n" ] }, { @@ -379,41 +367,17 @@ "\\tag{15}\n", "$$\n", "\n", - "To maximize the objective function is equivalent to minimizing $-F_p$. Therefore, we define $L(\\vec{\\gamma},\\vec{\\beta}) = -F_p(\\vec{\\gamma},\\vec{\\beta})$ as the loss function, that is, the function to be minimized. Then, we use a classical optimization algorithm to find the optimal parameters $\\vec{\\gamma},\\vec{\\beta}$. The following code shows a complete QAOA network built with Paddle Quantum and PaddlePaddle:" + "To maximize the objective function is equivalent to minimizing $-F_p$. Therefore, we define $L(\\vec{\\gamma},\\vec{\\beta}) = -F_p(\\vec{\\gamma},\\vec{\\beta})$ as the loss function, that is, the function to be minimized. Then, we use a classical optimization algorithm to find the optimal parameters $\\vec{\\gamma},\\vec{\\beta}$. The following code shows the loss function constructed with Paddle Quantum:" ] }, { "cell_type": "code", - "execution_count": 8, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:07:43.856891Z", - "start_time": "2021-04-30T09:07:43.846753Z" - } - }, + "execution_count": 7, + "metadata": {}, "outputs": [], "source": [ - "class Net(paddle.nn.Layer):\n", - " def __init__(self, p, dtype=\"float64\",):\n", - " super(Net, self).__init__()\n", - "\n", - " self.p = p\n", - " self.gamma = self.create_parameter(shape=[self.p], \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * PI), \n", - " dtype=dtype, is_bias=False)\n", - " self.beta = self.create_parameter(shape=[self.p], \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * PI), \n", - " dtype=dtype, is_bias=False)\n", - "\n", - " def forward(self):\n", - " # Define QAOA's quantum circuit\n", - " cir = circuit_QAOA(self.p, self.gamma, self.beta)\n", - " # Run the quantum circuit\n", - " cir.run_state_vector()\n", - " # Calculate the loss function\n", - " loss = -cir.expecval(H_D_list)\n", - "\n", - " return loss, cir" + "# construct the loss function\n", + "loss_func = ExpecVal(Hamiltonian(H_D_list))" ] }, { @@ -427,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:07:44.907375Z", @@ -446,76 +410,49 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Here, we optimize the network defined above in PaddlePaddle." + "Here, we optimize the loss function defined above in PaddlePaddle." ] }, { "cell_type": "code", - "execution_count": 10, - "metadata": { - "ExecuteTime": { - "end_time": "2021-04-30T09:10:00.930860Z", - "start_time": "2021-04-30T09:09:27.825635Z" - } - }, + "execution_count": 9, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iter: 10 loss: -1.8359\n", - "iter: 20 loss: -2.5392\n", - "iter: 30 loss: -2.7250\n", - "iter: 40 loss: -2.8061\n", - "iter: 50 loss: -2.8748\n", - "iter: 60 loss: -2.9134\n", - "iter: 70 loss: -2.9302\n", - "iter: 80 loss: -2.9321\n", - "iter: 90 loss: -2.9321\n", - "iter: 100 loss: -2.9325\n", - "iter: 110 loss: -2.9327\n", - "iter: 120 loss: -2.9328\n", - "\n", - "The trained circuit:\n", - "--H----*-----------------*--------------------------------------------------x----Rz(2.379)----x----Rx(2.503)-----------------------------------*-----------------*--------------------------------------------------x----Rz(1.230)----x----Rx(0.792)-----------------------------------*-----------------*--------------------------------------------------x----Rz(4.375)----x----Rx(5.180)-----------------------------------*-----------------*--------------------------------------------------x----Rz(0.711)----x----Rx(2.353)---------------------------------\n", - " | | | | | | | | | | | | | | | | \n", - "--H----x----Rz(2.379)----x----*-----------------*---------------------------|-----------------|--------*---------------------*----Rx(2.503)----x----Rz(1.230)----x----*-----------------*---------------------------|-----------------|--------*---------------------*----Rx(0.792)----x----Rz(4.375)----x----*-----------------*---------------------------|-----------------|--------*---------------------*----Rx(5.180)----x----Rz(0.711)----x----*-----------------*---------------------------|-----------------|--------*---------------------*----Rx(2.353)--\n", - " | | | | | | | | | | | | | | | | | | | | | | | | \n", - "--H---------------------------x----Rz(2.379)----x----*-----------------*----|-----------------|--------|---------------------|----Rx(2.503)---------------------------x----Rz(1.230)----x----*-----------------*----|-----------------|--------|---------------------|----Rx(0.792)---------------------------x----Rz(4.375)----x----*-----------------*----|-----------------|--------|---------------------|----Rx(5.180)---------------------------x----Rz(0.711)----x----*-----------------*----|-----------------|--------|---------------------|----Rx(2.353)--\n", - " | | | | | | | | | | | | | | | | | | | | | | | | \n", - "--H--------------------------------------------------x----Rz(2.379)----x----*-----------------*--------x--------Rz(2.379)----x----Rx(2.503)--------------------------------------------------x----Rz(1.230)----x----*-----------------*--------x--------Rz(1.230)----x----Rx(0.792)--------------------------------------------------x----Rz(4.375)----x----*-----------------*--------x--------Rz(4.375)----x----Rx(5.180)--------------------------------------------------x----Rz(0.711)----x----*-----------------*--------x--------Rz(0.711)----x----Rx(2.353)--\n", - " \n", - "Optimized parameters gamma:\n", - " [2.37918879 1.22914743 4.37582352 0.71142941]\n", - "Optimized parameters beta:\n", - " [2.50287593 0.79179726 5.17941547 2.35294027]\n" + "iter: 10 loss: -1.8359\n", + "iter: 20 loss: -2.5392\n", + "iter: 30 loss: -2.7250\n", + "iter: 40 loss: -2.8061\n", + "iter: 50 loss: -2.8748\n", + "iter: 60 loss: -2.9134\n", + "iter: 70 loss: -2.9302\n", + "iter: 80 loss: -2.9321\n", + "iter: 90 loss: -2.9321\n", + "iter: 100 loss: -2.9325\n", + "iter: 110 loss: -2.9327\n", + "iter: 120 loss: -2.9328\n" ] } ], "source": [ "paddle.seed(SEED)\n", "\n", - "net = Net(p)\n", + "cir = circuit_QAOA(p)\n", "# Use Adam optimizer\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", - "# Gradient descent iteration\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=cir.parameters())\n", + "\n", "for itr in range(1, ITR + 1):\n", - " # Run the network defined above\n", - " loss, cir = net()\n", + " state = cir()\n", " # Calculate the gradient and optimize\n", + " loss = -loss_func(state)\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", - " if itr == ITR:\n", - " print(\"\\nThe trained circuit:\") \n", - " print(cir)\n", - "\n", - "gamma_opt = net.gamma.numpy()\n", - "print(\"Optimized parameters gamma:\\n\", gamma_opt)\n", - "beta_opt = net.beta.numpy()\n", - "print(\"Optimized parameters beta:\\n\", beta_opt)" + " if itr % 10 == 0:\n", + " print(\"iter:\", itr, \" loss:\", \"%.4f\" % loss.numpy())\n" ] }, { @@ -538,7 +475,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:10:21.794006Z", @@ -548,7 +485,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -560,8 +497,9 @@ } ], "source": [ + "state = cir()\n", "# Repeat the simulated measurement of the circuit output state 1024 times\n", - "prob_measure = cir.measure(plot=True)" + "prob_measure = state.measure(plot=True)" ] }, { @@ -578,7 +516,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:10:36.652097Z", @@ -595,7 +533,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -671,7 +609,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.11" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/combinatorial_optimization/PortfolioDiversification_CN.ipynb b/tutorials/combinatorial_optimization/PortfolioDiversification_CN.ipynb similarity index 88% rename from tutorial/combinatorial_optimization/PortfolioDiversification_CN.ipynb rename to tutorials/combinatorial_optimization/PortfolioDiversification_CN.ipynb index 53df7c6..cbb4fbf 100644 --- a/tutorial/combinatorial_optimization/PortfolioDiversification_CN.ipynb +++ b/tutorials/combinatorial_optimization/PortfolioDiversification_CN.ipynb @@ -2,37 +2,38 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "source": [ "# 量子金融应用：投资组合分散化\n", "\n", " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## 概览\n", "\n", "当前量子计算应用到金融问题上的解决方案通常可分为三类量子算法，即量子模拟，量子优化以及量子机器学习 [1,2]。许多的金融问题本质上是一个组合优化问题，解决这些问题的算法通常具有较高的时间复杂度，实现难度较大。得益于量子计算强大的计算性能，未来有望通过量子算法解决这些复杂问题。\n", "\n", "量桨的 Quantum Finance 模块主要讨论的是量子优化部分的内容，即如何通过一些量子算法解决实际金融应用中的优化问题。本文主要介绍如何使用量子算法求解被动投资管理中投资组合分散化问题。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## 投资组合分散化问题\n", "\n", "普通用户受专业知识和市场经验的不足的限制，在实际的投资中偏向于被动投资策略。指数投资就是一种常见的被动投资例子，比如说投资者长期购买并持有标普 $500$ 指数（Standard & Poor’s $500$）。作为投资人，假如你不想投资已有的指数，那么你也可以自己创建特定的指数投资组合，在市场中挑选合适的股票加入到创建的指数投资组合中。\n", "\n", "分散化是投资组合中平衡风险和收益的一个重要方法。对投资组合分散化的一个具体描述如下：当前可投资的股票数量为 $n$，指数投资组合中包含的股票数量为 $K$，需要对这 $n$ 个股票进行聚类，根据相似性将可选的股票划分为 $K$ 个类别，再从每个类别中选出最能代表该类别的股票，将其加入到指数组合中来，便于更好的控制风险，提高收益。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 编码投资组合分散化问题\n", "\n", @@ -100,21 +101,27 @@ "这里 $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", + "metadata": {}, "source": [ "## Paddle Quantum 实现\n", "\n", "要在量桨上实现用参数化量子电路解决量子金融中的投资组合分散化问题，首先要做的便是加载需要用到的包。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + }, + "outputs": [], "source": [ "#加载额外需要的包\n", "import numpy as np\n", @@ -123,20 +130,14 @@ "\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" - } - } + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.finance import DataSimulator, portfolio_diversification_hamiltonian" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 准备实验数据\n", "\n", @@ -144,40 +145,49 @@ "* 第一种是根据一定的条件，随机生成数据。\n", "\n", "如果采用这种方法准备实验数据，用户在初始化数据时，就需要给出可投资股票的名字列表，交易数据的开始日期和结束日期。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, + "metadata": {}, + "outputs": [], "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)) \n", "data.randomly_generate() # 随机生成实验数据" - ], - "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" } - } + }, + "source": [ + "* 第二种是用户可以选择读取本地收集到的真实数据集用于实验。考虑到文件中包含的股票数可能会很多，用户可以指定用于该实验的股票数量，即上面初始化的 `num_assets`。\n", + "\n", + "我们收集了 $12$ 支股票 $35$ 个交易日的收盘价格存放到 `realStockData_12.csv` 文件中，在这里我们只选择读取前 $3$ 个股票的信息。\n", + "\n", + "在本教程中，我们选择读取的真实数据作为实验数据。" + ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "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" + ] + } + ], "source": [ "df = pd.read_csv('realStockData_12.csv')\n", "dt = []\n", @@ -187,67 +197,58 @@ "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", + "metadata": {}, "source": [ "### 编码哈密顿量\n", "\n", "这里我们将式（2）中的二进制变量用式（3）替换，从而构建哈密顿量 $H_C$。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "在编码哈密顿量的过程中，首先需要计算各股票之间的相似矩阵 $\\rho$。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, + "metadata": {}, + "outputs": [], "source": [ "rho = data.get_similarity_matrix()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "根据计算的相似矩阵和给定的参数构建哈密顿量。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, + "metadata": {}, + "outputs": [], "source": [ "q = 2 # 指数组合中需要的股票数目\n", "penalty = num_assets # 惩罚参数：不小于可投资股票的数目\n", "hamiltonian = portfolio_diversification_hamiltonian(penalty, rho, q)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 计算损失函数\n", "\n", - "调用量桨内置的 [`complex entangled layer`](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html) 构造参数化量子电路。该电路会返回一个输出态 $|\\vec{\\theta}\\rangle$，由此输出态，我们可以定义投资组合分散化问题在经典-量子混合模型下的损失函数：\n", + "调用量桨内置的 [`complex_entangled_layer()`](https://qml.baidu.com/api/paddle_quantum.ansatz.circuit.html#Circuit.complex_entangled_layer) 构造参数化量子电路。该电路会返回一个输出态 $|\\vec{\\theta}\\rangle$，由此输出态，我们可以定义投资组合分散化问题在经典-量子混合模型下的损失函数：\n", "\n", "$$\n", "L(\\vec{\\theta}) = \\langle\\vec{\\theta}|H_C|\\vec{\\theta}\\rangle.\n", @@ -255,119 +256,119 @@ "$$\n", "\n", "之后我们利用经典的优化算法寻找最优参数 $\\vec{\\theta}^*$。下面的代码给出了通过量桨和飞桨搭建网络的过程。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 2, + "metadata": {}, + "outputs": [], "source": [ "class PDNet(paddle.nn.Layer):\n", "\n", - " def __init__(self, n, p, dtype=\"float64\"):\n", + " def __init__(self, num_qubits, p, dtype=\"float64\"):\n", " super(PDNet, self).__init__()\n", + " self.num_qubits = num_qubits\n", + " self.depth = p\n", + " self.cir = Circuit(self.num_qubits)\n", + " self.cir.complex_entangled_layer(depth=self.depth)\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", + " def forward(self):\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", + " state = self.cir(init_state)\n", + " loss = loss_func(state)\n", "\n", - " return loss, cir" - ], - "outputs": [], - "metadata": {} + " return loss, self.cir" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 训练量子神经网络\n", "\n", "定义好了量子神经网络后，我们使用梯度下降的方法来更新其中的参数，使得式（4）的期望值最小。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, + "metadata": {}, + "outputs": [], "source": [ "SEED = 1100 # 随机数种子\n", "p = 2 # 量子电路的层数\n", "ITR = 150 # 迭代次数\n", "LR = 0.4 # 梯度下降优化速率 " - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "使用飞桨，优化上面定义的网络。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "循环数: 10 损失: 7.7805\n", + "循环数: 20 损失: 5.4413\n", + "循环数: 30 损失: 3.6023\n", + "循环数: 40 损失: 3.2911\n", + "循环数: 50 损失: 1.9415\n", + "循环数: 60 损失: 0.3871\n", + "循环数: 70 损失: 0.1342\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" + ] + } + ], "source": [ "# 比特数量\n", "n = len(rho)\n", - "\n", "# 固定随机数种子\n", "paddle.seed(SEED)\n", - "\n", + "# 电路所需的比特数量\n", + "num_qubits = n * (n+1)\n", "# 定义量子神经网络\n", - "net = PDNet(n, p)\n", - "\n", + "net = PDNet(num_qubits, p)\n", + "# 定义初始态\n", + "init_state = paddle_quantum.state.zero_state(num_qubits)\n", + "# 定义损失函数\n", + "loss_func = paddle_quantum.loss.ExpecVal(hamiltonian)\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", + " # 运行上面定义的网络\n", + " loss, cir = net()\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 损失: 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", + "metadata": {}, "source": [ "### 解码量子答案\n", "\n", @@ -381,47 +382,48 @@ "在量子参数化电路表达能力足够的情况下，某个比特串出现的概率越大，意味着其是投资组合优化问题最优解的可能性越大。\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)" - ], + "execution_count": 17, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "利用哈密顿量找到的解的比特串形式： 100001001101\n" ] } ], - "metadata": {} + "source": [ + "# 模拟重复测量电路输出态 2048 次\n", + "state = cir(init_state)\n", + "prob_measure = state.measure(shots=2048)\n", + "investment = max(prob_measure, key=prob_measure.get)\n", + "print(\"利用哈密顿量找到的解的比特串形式：\", investment)" + ] }, { "cell_type": "markdown", + "metadata": {}, "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", + "metadata": {}, "source": [ "### 结语\n", "\n", "在本教程中，我们主要讨论了分散化投资中如何对可投资项目进行分类，以及如何挑选具有代表性的到我们的投资组合中来。在本问题中，每个投资项目都需要 $n$ 位量子比特来表示分类，$1$ 位量子比特表示是否被选中。受量子比特数目的限制，目前能够处理的投资项目数还比较少。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "_______\n", "\n", @@ -430,8 +432,7 @@ "[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": { @@ -439,7 +440,7 @@ "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -453,7 +454,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.9.7" }, "toc": { "base_numbering": 1, @@ -471,4 +472,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/tutorial/combinatorial_optimization/PortfolioDiversification_EN.ipynb b/tutorials/combinatorial_optimization/PortfolioDiversification_EN.ipynb similarity index 74% rename from tutorial/combinatorial_optimization/PortfolioDiversification_EN.ipynb rename to tutorials/combinatorial_optimization/PortfolioDiversification_EN.ipynb index db29901..9bd79cc 100644 --- a/tutorial/combinatorial_optimization/PortfolioDiversification_EN.ipynb +++ b/tutorials/combinatorial_optimization/PortfolioDiversification_EN.ipynb @@ -2,47 +2,48 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "source": [ "# Quantum Finance Application on Portfolio Diversification\n", "\n", " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "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", + "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 diversification problem." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "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", + "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 in an existing index portfolio, you can also create your 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": {} + "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 represents that category. Adding representatives of each category to the index portfolio is better for investment management." + ] }, { "cell_type": "markdown", + "metadata": {}, "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", + "To transform the portfolio diversification problem into a problem applicable for parameterized quantum circuits, we need to encode the 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", + "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 stocks 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 the 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 for the index portfolio:\n", "\n", "$$\n", "x_{ij}=\n", @@ -78,7 +79,7 @@ "\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", + "Since the loss function is to be optimized using the gradient descent method, some modifications made to the loss function based on the model equation and constraints:\n", "\n", "$$\n", "\\begin{aligned}\n", @@ -87,9 +88,9 @@ "\\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", + "The first term represents 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", + "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", @@ -100,21 +101,27 @@ "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", + "metadata": {}, "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, + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + }, + "outputs": [], "source": [ "# Import packages needed\n", "import numpy as np\n", @@ -123,61 +130,64 @@ "\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" - } - } + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.finance import DataSimulator, portfolio_diversification_hamiltonian" + ] }, { "cell_type": "markdown", + "metadata": {}, "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", + "In this tutorial, we choose stocks as 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": {} + "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 the end date of the trading data." + ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, + "metadata": {}, + "outputs": [], "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), end = datetime.datetime(2016, 1, 30)) \n", "data.randomly_generate() # Generate random data" - ], - "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" } - } + }, + "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." + ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "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" + ] + } + ], "source": [ "df = pd.read_csv('realStockData_12.csv') \n", "dt = []\n", @@ -188,67 +198,58 @@ "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", + "metadata": {}, "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", + "metadata": {}, "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, + "execution_count": 4, + "metadata": {}, + "outputs": [], "source": [ "rho = data.get_similarity_matrix()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "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, + "execution_count": 5, + "metadata": {}, + "outputs": [], "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", + "metadata": {}, "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", + "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 method [`complex_entangled_layer()`](https://qml.baidu.com/api/paddle_quantum.ansatz.circuit.html#Circuit.complex_entangled_layer).\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", @@ -259,119 +260,119 @@ "$$\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, + "execution_count": 6, + "metadata": {}, + "outputs": [], "source": [ "class PDNet(paddle.nn.Layer):\n", "\n", - " def __init__(self, n, p, dtype=\"float64\"):\n", + " def __init__(self, num_qubits, p, dtype=\"float64\"):\n", " super(PDNet, self).__init__()\n", + " self.num_qubits = num_qubits\n", + " self.depth = p\n", + " self.cir = Circuit(self.num_qubits)\n", + " self.cir.complex_entangled_layer(depth=self.depth)\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", + " def forward(self):\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", + " state = self.cir(init_state)\n", + " loss = loss_func(state)\n", "\n", - " return loss, cir" - ], - "outputs": [], - "metadata": {} + " return loss, self.cir" + ] }, { "cell_type": "markdown", + "metadata": {}, "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, + "execution_count": 7, + "metadata": {}, + "outputs": [], "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", + "metadata": {}, "source": [ "Here, we optimize the network defined above in PaddlePaddle." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 10 loss: 7.7805\n", + "iter: 20 loss: 5.4413\n", + "iter: 30 loss: 3.6023\n", + "iter: 40 loss: 3.2911\n", + "iter: 50 loss: 1.9415\n", + "iter: 60 loss: 0.3871\n", + "iter: 70 loss: 0.1342\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" + ] + } + ], "source": [ "# number of qubits\n", "n = len(rho)\n", - "\n", "# Fix paddle random seed\n", "paddle.seed(SEED)\n", - "\n", + "# number of qubits need in circuit\n", + "num_qubits = n * (n+1)\n", "# Building Quantum Neural Networks\n", - "net = PDNet(n, p)\n", - "\n", + "net = PDNet(num_qubits, p)\n", + "# Define the initial state\n", + "init_state = paddle_quantum.state.zero_state(num_qubits)\n", + "# Define loss function\n", + "loss_func = paddle_quantum.loss.ExpecVal(hamiltonian)\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", + " # run circuit\n", + " loss, cir = net()\n", + " # compute 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())\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", + "metadata": {}, "source": [ "### Decoding the quantum solution\n", "\n", @@ -382,52 +383,52 @@ "\\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", + "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 to 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 2048 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)" - ], + "execution_count": 15, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "The bit string form of the solution: 100001001101\n" ] } ], - "metadata": {} + "source": [ + "# Repeat the simulated measurement of the circuit output state 2048 times\n", + "final_state = cir(init_state)\n", + "prob_measure = final_state.measure(shots=2048)\n", + "investment = max(prob_measure, key=prob_measure.get)\n", + "print(\"The bit string form of the solution: \", investment)" + ] }, { "cell_type": "markdown", + "metadata": {}, "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": {} + "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 for 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 for 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." + ] }, { "cell_type": "markdown", + "metadata": {}, "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": {} + "In this tutorial, we focus on how to classify investable stocks and how to select representative ones for our portfolio. In this problem, each investment item requires $n$ qubits to represent the classification and $1$ qubit to represent whether it is selected for the portfolio or not. Due to the limitation of the number of qubits, the number of investment items that can be handled is still small." + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "_______\n", "\n", @@ -436,8 +437,7 @@ "[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": { @@ -445,8 +445,9 @@ "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" }, "kernelspec": { - "name": "python3", - "display_name": "Python 3.7.11 64-bit ('pq_env': conda)" + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -458,7 +459,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.11" + "version": "3.9.7" }, "toc": { "base_numbering": 1, @@ -476,4 +477,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/tutorial/combinatorial_optimization/PortfolioOptimization_CN.ipynb b/tutorials/combinatorial_optimization/PortfolioOptimization_CN.ipynb similarity index 87% rename from tutorial/combinatorial_optimization/PortfolioOptimization_CN.ipynb rename to tutorials/combinatorial_optimization/PortfolioOptimization_CN.ipynb index be04ba3..3e6dbf7 100644 --- a/tutorial/combinatorial_optimization/PortfolioOptimization_CN.ipynb +++ b/tutorials/combinatorial_optimization/PortfolioOptimization_CN.ipynb @@ -2,15 +2,16 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "source": [ "# 量子金融应用：投资组合优化\n", "\n", " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "\n", "## 概览\n", @@ -18,22 +19,22 @@ "当前量子计算应用到金融问题上的解决方案通常可分为三类量子算法，即量子模拟，量子优化以及量子机器学习 [1,2]。许多的金融问题本质上是一个组合优化问题，解决这些问题的算法通常具有较高的时间复杂度，实现难度较大。得益于量子计算强大的计算性能，未来有望通过量子算法解决这些复杂问题。\n", "\n", "量桨的 Quantum Finance 模块主要讨论的是量子优化部分的内容，即如何通过一些量子算法解决实际金融应用中的优化问题。本文主要介绍如何使用量子算法求解主动投资管理中投资组合优化问题。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## 投资组合优化问题\n", "\n", "投资组合是金融投资的集合，比如股票、债权、现金等。投资组合优化是许多主动型投资管理者需要面对的问题，它需要从业者应用相关数学理论方法，根据目标收益和风险对一笔资金进行投资，以期在收益一定的情况下风险最小化或者是风险一定的情况下投资收益最大化。\n", "\n", "对投资组合优化的一个具体描述如下：假如你是一位资产管理人，想要将数额为 $K$ 的资金一次性投入到 $N$ 个可投资的项目中，各项目都有自己的投资回报率和风险，你的目标就是在考虑到市场影响和交易费用的的基础上找到一个最佳的投资组合空间，使得该笔资产以最优的投资方案实施。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 编码投资组合优化问题\n", "\n", @@ -81,21 +82,27 @@ "这里 $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", + "metadata": {}, "source": [ "## Paddle Quantum 实现\n", "\n", "要在量桨上实现用参数化量子电路解决量子金融中的投资组合优化问题，首先要做的便是加载需要用到的包。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + }, + "outputs": [], "source": [ "#加载需要的包\n", "import numpy as np\n", @@ -104,59 +111,63 @@ "\n", "#加载飞桨，量桨相关的模块\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\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", + "metadata": {}, "source": [ "### 准备实验数据\n", "在本问题中，我们选定的投资项目为股票。对于实验测试要用的数据，提供了两种选择：\n", "* 第一种方法是根据设定的条件，随机生成实验数据。\n", "\n", "如果采用这种方法准备数据，用户在初始化数据时，就需要给出可投资股票的名字列表，交易数据的开始日期和结束日期。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, + "metadata": {}, + "outputs": [], "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", "data.randomly_generate() # 随机生成实验数据" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.212260Z", + "start_time": "2021-05-17T08:00:15.918792Z" + } + }, "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, + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "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" + ] + } + ], "source": [ "df = pd.read_csv('realStockData_12.csv')\n", "dt = []\n", @@ -166,79 +177,70 @@ "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", + "metadata": {}, "source": [ "### 编码哈密顿量\n", "\n", "这里我们将式（2）中的二进制变量用式（3）替换，从而构建哈密顿量 $H_C$。\n", "\n", "在编码哈密顿量的过程中，首先需要计算各股票回报率之间的协方差矩阵 $S$。量桨平台的 finance 模块有支持计算该协方差矩阵的函数，用户可以直接调用。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, + "metadata": {}, + "outputs": [], "source": [ "s = data.get_asset_return_covariance_matrix()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "第二个是需要计算出各个股票的平均投资回报率向量 $\\mu$。同样的，量桨也提供有计算各股票平均投资回报率的函数。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, + "metadata": {}, + "outputs": [], "source": [ "mu = data.get_asset_return_mean_vector()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "下面根据设定和计算出来的参数来构建哈密顿量，这里我们设置惩罚参数为可投资的股票数量。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, + "metadata": {}, + "outputs": [], "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", + "metadata": {}, "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", + "我们使用 $U_3(\\vec{\\theta})$ 和 $\\text{CNOT}$ 门构造的参数化量子电路，通过调用量桨内置的 [`complex_entangled_layer()`](https://qml.baidu.com/api/paddle_quantum.ansatz.circuit.html#Circuit.complex_entangled_layer) 构造实现。该电路会返回一个输出态 $|\\vec{\\theta}\\rangle$，根据该参数便可以计算投资组合优化问题在经典-量子混合模型下损失的函数:\n", "\n", "$$\n", "L(\\vec{\\theta}) = \\langle\\vec{\\theta}|H_C|\\vec{\\theta}\\rangle.\n", @@ -246,152 +248,153 @@ "$$\n", "\n", "之后我们利用经典的优化算法寻找最优参数 $\\vec{\\theta}^*$。下面的代码给出了通过量桨和飞桨搭建网络的过程。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 15, + "metadata": {}, + "outputs": [], "source": [ "class PONet(paddle.nn.Layer):\n", "\n", - " def __init__(self, n, p, dtype=\"float64\"):\n", + " def __init__(self, num_qubits, 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", + " self.depth = p\n", + " self.num_qubits = num_qubits\n", + " self.cir = Circuit(self.num_qubits)\n", + " self.cir.complex_entangled_layer(depth=self.depth)\n", + "\n", "\n", - " def forward(self, hamiltonian):\n", + " def forward(self):\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", + " state = self.cir(init_state)\n", + " loss = loss_func(state)\n", "\n", - " return loss, cir" - ], - "outputs": [], - "metadata": {} + " return loss, self.cir" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 训练量子神经网络\n", "\n", "定义好了量子神经网络后，我们使用梯度下降的方法来更新其中的参数，使得式（4）的期望值最小。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 16, + "metadata": {}, + "outputs": [], "source": [ "SEED = 1000 # 随机数种子\n", "p = 2 # 量子电路的层数\n", "ITR = 600 # 迭代次数\n", "LR = 0.4 # 梯度下降优化速率 " - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "使用飞桨，优化上面定义的网络。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "循环数: 50 损失: 0.0399189\n", + "循环数: 100 损失: 0.0098760\n", + "循环数: 150 损失: 0.0085572\n", + "循环数: 200 损失: 0.0074596\n", + "循环数: 250 损失: 0.0066504\n", + "循环数: 300 损失: 0.0061929\n", + "循环数: 350 损失: 0.0059874\n", + "循环数: 400 损失: 0.0059097\n", + "循环数: 450 损失: 0.0058763\n", + "循环数: 500 损失: 0.0058761\n", + "循环数: 550 损失: 0.0058756\n", + "循环数: 600 损失: 0.0058689\n" + ] + } + ], "source": [ "# 比特数量\n", - "n = len(mu)\n", - "\n", + "num_qubits = len(mu)\n", "# 固定随机数种子\n", "paddle.seed(SEED)\n", - "\n", "# 定义量子神经网络\n", - "net = PONet(n, p)\n", - "\n", + "net = PONet(num_qubits, p)\n", + "# 定义初始态\n", + "init_state = paddle_quantum.state.zero_state(num_qubits)\n", + "# 定义损失函数\n", + "loss_func = paddle_quantum.loss.ExpecVal(hamiltonian)\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", + " # 运行上面定义的网络\n", + " loss, cir = net()\n", + " #计算梯度并优化\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", + "metadata": {}, "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()))" - ], + "execution_count": 21, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "理论最小损失值： 0.0058710575103759766\n", - "实际最小损失值： 0.005870710695958458\n" + "理论最小损失值： 0.0058722496\n", + "实际最小损失值： 0.0058689117431640625\n" ] } ], - "metadata": {} + "source": [ + "H_C_matrix = hamiltonian.construct_h_matrix()\n", + "print(\"理论最小损失值：\", np.linalg.eigvalsh(H_C_matrix)[0]) \n", + "print(\"实际最小损失值：\", float(loss.numpy()))" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "在这个例子中，上面参数化电路优化出来的的最小损失和理论最小损失是非常接近的，这代表着我们之后给出的投资方案是最优的。如果两个值不太吻合，可以通过改变随机种子 `SEED`，量子电路的层数 `p`，迭代次数 `ITR` 和梯度下降优化速率 `LR` 等参数重新计算。 " - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 解码量子答案\n", "\n", @@ -405,47 +408,48 @@ "在量子参数化电路表达能力足够的情况下，某个比特串出现的概率越大，意味着其是投资组合优化问题最优解的可能性越大。\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)" - ], + "execution_count": 22, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "利用哈密顿量找到的解的比特串形式： 0100110\n" ] } ], - "metadata": {} + "source": [ + "# 模拟重复测量电路输出态 2048 次\n", + "final_state = cir(init_state)\n", + "prob_measure = final_state.measure(shots=2048)\n", + "investment = max(prob_measure, key=prob_measure.get)\n", + "print(\"利用哈密顿量找到的解的比特串形式：\",investment)" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "我们的测量结果是表示投资组合优化问题答案的比特串：字符串中该位置为 $1$，表示该笔资产被选定投资。如上面的结果 `0100110` 就表示在可选的 $7$ 支可投资的项目中，选择了第二、第五、第六三支股票。同时，字符串中 $1$ 的数量应该和预算数相同。如果最后的情况不是这样，读者依然可以通过调整参数化量子电路的参数值或参数化量子电路的结构来获得更好的训练效果。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 结语\n", "\n", "本教程中，投资组合优化问题的最优解是在均值-方差组合优化方法基础上通过变分量子本征求解器（Variational Quantum Eigensolver, VQE）近似得到的。在给定投资预算和可投资项目信息以及投资风险的基础上，通过计算投资项目的回报率以及各投资项目回报率之间的协方差矩阵，应用参数化量子电路寻找最优的投资组合。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "_______\n", "\n", @@ -456,8 +460,7 @@ "[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": { @@ -465,7 +468,7 @@ "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -479,7 +482,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.9.7" }, "toc": { "base_numbering": 1, @@ -497,4 +500,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/tutorial/combinatorial_optimization/PortfolioOptimization_EN.ipynb b/tutorials/combinatorial_optimization/PortfolioOptimization_EN.ipynb similarity index 80% rename from tutorial/combinatorial_optimization/PortfolioOptimization_EN.ipynb rename to tutorials/combinatorial_optimization/PortfolioOptimization_EN.ipynb index 04c6411..2657fc5 100644 --- a/tutorial/combinatorial_optimization/PortfolioOptimization_EN.ipynb +++ b/tutorials/combinatorial_optimization/PortfolioOptimization_EN.ipynb @@ -2,41 +2,42 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "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", + "metadata": {}, "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", + "metadata": {}, "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", + "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 in various projects, according to their target returns and risks. This aims to minimize the risk given a certain return or maximize the return given a 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": {} + "A 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 return and risk, your goal is to find an optimal way to invest in the projects, taking into account the market impact and transaction costs." + ] }, { "cell_type": "markdown", + "metadata": {}, "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", + "To transform the portfolio optimization problem into a problem applicable for parameterized quantum circuits, we need to encode the 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", @@ -71,7 +72,7 @@ "\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", + "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", @@ -81,21 +82,27 @@ "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", + "metadata": {}, "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, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + }, + "outputs": [], "source": [ "# Import packages needed\n", "import numpy as np\n", @@ -104,61 +111,64 @@ "\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", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\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", + "metadata": {}, "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", + "In this tutorial, we choose stocks as an 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": {} + "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 the end date of the trading data." + ] }, { "cell_type": "code", "execution_count": 2, + "metadata": {}, + "outputs": [], "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), end = datetime.datetime(2016, 1, 30))\n", "data.randomly_generate() # Generate random data" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.212260Z", + "start_time": "2021-05-17T08:00:15.918792Z" + } + }, "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, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "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" + ] + } + ], "source": [ "df = pd.read_csv('realStockData_12.csv')\n", "dt = []\n", @@ -169,79 +179,70 @@ "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", + "metadata": {}, "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, + "metadata": {}, + "outputs": [], "source": [ "s = data.get_asset_return_covariance_matrix()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "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": {} + "The second step is to compute the expected return vector $\\mu$ for each stock. Similarly, paddle quantum also supports this function for users." + ] }, { "cell_type": "code", "execution_count": 5, + "metadata": {}, + "outputs": [], "source": [ "mu = data.get_asset_return_mean_vector()" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "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, + "metadata": {}, + "outputs": [], "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", + "metadata": {}, "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", + "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 method [`complex_entangled_layer()`](https://qml.baidu.com/api/paddle_quantum.ansatz.circuit.html#Circuit.complex_entangled_layer).\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", @@ -252,89 +253,104 @@ "$$\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, + "metadata": {}, + "outputs": [], "source": [ "class PONet(paddle.nn.Layer):\n", "\n", - " def __init__(self, n, p, dtype=\"float64\"):\n", + " def __init__(self, num_qubits, 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", + " self.depth = p\n", + " self.num_qubits = num_qubits\n", + " self.cir = Circuit(self.num_qubits)\n", + " self.cir.complex_entangled_layer(depth=self.depth)\n", "\n", - " def forward(self, hamiltonian):\n", + " def forward(self):\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": {} + " state = self.cir(init_state)\n", + " loss = loss_func(state)\n", + "\n", + " return loss, self.cir" + ] }, { "cell_type": "markdown", + "metadata": {}, "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, + "metadata": {}, + "outputs": [], "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", + "metadata": {}, "source": [ "Here, we optimize the network defined above in PaddlePaddle." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 50 loss: 0.0399189\n", + "iter: 100 loss: 0.0098760\n", + "iter: 150 loss: 0.0085572\n", + "iter: 200 loss: 0.0074596\n", + "iter: 250 loss: 0.0066504\n", + "iter: 300 loss: 0.0061929\n", + "iter: 350 loss: 0.0059874\n", + "iter: 400 loss: 0.0059097\n", + "iter: 450 loss: 0.0058763\n", + "iter: 500 loss: 0.0058761\n", + "iter: 550 loss: 0.0058756\n", + "iter: 600 loss: 0.0058689\n" + ] + } + ], "source": [ "# number of qubits\n", - "n = len(mu)\n", - "\n", + "num_qubits = len(mu)\n", "# Fix paddle random seed\n", "paddle.seed(SEED)\n", - "\n", "# Building Quantum Neural Networks\n", - "net = PONet(n, p)\n", - "\n", + "net = PONet(num_qubits, p)\n", + "# Define initial state\n", + "init_state = paddle_quantum.state.zero_state(num_qubits)\n", + "# Define loss function\n", + "loss_func = paddle_quantum.loss.ExpecVal(hamiltonian)\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", + " loss, cir = net()\n", " # Calculate the gradient and optimize\n", " loss.backward()\n", " opt.minimize(loss)\n", @@ -342,121 +358,102 @@ " 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", + "metadata": {}, "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()))" - ], + "execution_count": 11, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "Theoretical minimum loss value: 0.0058710575103759766\n", - "Practical minimum loss value: 0.005870710695958458\n" + "Theoretical minimum loss value: 0.0058722496\n", + "Practical minimum loss value: 0.0058689117431640625\n" ] } ], - "metadata": {} + "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()))" + ] }, { "cell_type": "markdown", + "metadata": {}, "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", + "metadata": {}, "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", + "After obtaining the minimum value of the loss function and the corresponding set of parameters $\\vec{\\theta}^*$, our task has not been completed. 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", + "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 to 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 2048 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)" - ], + "execution_count": 13, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "The bit string form of the solution: 0100110\n" ] } ], - "metadata": {} + "source": [ + "# Repeat the simulated measurement of the circuit output state 2048 times\n", + "final_state = cir(init_state)\n", + "prob_measure = final_state.measure(shots=2048)\n", + "investment = max(prob_measure, key=prob_measure.get)\n", + "print(\"The bit string form of the solution: \", investment)" + ] }, { "cell_type": "markdown", + "metadata": {}, "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": {} + "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." + ] }, { "cell_type": "markdown", + "metadata": {}, "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": {} + "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 are applied to find the optimal portfolio by calculating the returns of investment projects and the covariance matrix between the returns of each investment project. " + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "_______\n", "\n", @@ -467,8 +464,7 @@ "[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": { @@ -476,7 +472,7 @@ "hash": "3b61f83e8397e1c9fcea57a3d9915794102e67724879b24295f8014f41a14d85" }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -490,7 +486,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.9.7" }, "toc": { "base_numbering": 1, @@ -508,4 +504,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/tutorial/combinatorial_optimization/QAOA_CN.ipynb b/tutorials/combinatorial_optimization/QAOA_CN.ipynb similarity index 97% rename from tutorial/combinatorial_optimization/QAOA_CN.ipynb rename to tutorials/combinatorial_optimization/QAOA_CN.ipynb index d56f338..b3600ab 100644 --- a/tutorial/combinatorial_optimization/QAOA_CN.ipynb +++ b/tutorials/combinatorial_optimization/QAOA_CN.ipynb @@ -1,351 +1,351 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# 量子近似优化算法\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 概览\n", - "\n", - "量子近似优化算法（quantum approximate optimization algorithm, QAOA）是可以在近期的有噪中等规模量子（noisy intermediate-scale quantum, NISQ）设备上运行且具有广泛应用前景的量子算法。QAOA 由 Edward Farhi 等人于 2014 年提出 [1]，其目的是近似地求解组合优化问题（combinatorial optimization problems）。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 组合优化问题\n", - "\n", - "在应用数学和理论计算机科学的领域中，组合优化是在一个有限的对象集中找出最优对象的一类课题。简单来说，组合优化问题是指问题的所有解是由离散变量组成的，然后在离散的解集中寻找最优解。组合优化问题涉及的范围很广，且常见于实际生活中，例如飞机航线的设计、快递物流路线的规划等。\n", - "\n", - "具体来说，一个组合优化问题可以由 $n$ 个比特（bit）和 $m$ 个子句（clause）描述。每个比特是一个二进制变量，其取值为 $0$ 或 $1$，我们用 $z_j$ 表示第 $j$ 个比特的取值。因此，这 $n$ 个比特的取值可以由比特串 $z=z_1z_2\\dots z_n$ 表示。每个子句都是对部分比特的一个限制条件，例如一个子句可以要求第 $2$ 个比特的取值为 $0$，或者可以要求第 $3$ 个比特和第 $5$ 个比特的取值相同，等等。对于第 $j$ 个子句，我们定义一个与之相关的函数\n", - "\n", - "$$\n", - "C_j(z)=\n", - "\\begin{cases}\n", - "1 & \\text{如果 $n$ 个比特的取值 $z$ 满足子句 $j$ 表明的条件}\\\\\n", - "0 & \\text{如果 $n$ 个比特的取值 $z$ 不满足子句 $j$ 表明的条件}\n", - "\\end{cases}.\n", - "\\tag{1}\n", - "$$\n", - "\n", - "例如，如果第一个子句要求第二个比特的取值为 0，那么我们有 $C_1(z_10z_3\\dots z_n)=1$ 和 $C_1(z_11z_3\\dots z_n)=0$。\n", - "\n", - "由公式（1）中我们对于每个子句定义的函数 $C_j$，我们可以定义该组合优化问题的目标函数（objective function）\n", - "\n", - "$$\n", - "C(z)=\\sum_{j=1}^m w_jC_j(z),\n", - "\\tag{2}\n", - "$$\n", - "\n", - "其中 $w_j$ 是第 $j$ 个子句的权重（weight）。组合优化问题就是要找到一个取值 $z$ 使得目标函数 $C(z)$ 的值最大，即\n", - "\n", - "$$\n", - "\\underset{z}{\\operatorname{argmax}} C(z).\n", - "\\tag{3}\n", - "$$\n", - "\n", - "在理论计算机科学中，有一个著名的问题叫作布尔可满足性问题（Boolean satisfiability problem, SAT），它是指对于输入的一组 $n$ 个比特和 $m$ 个子句，判断是否存在一种 $n$ 个比特的取值同时满足所有 $m$ 个子句。而一个与之相关的优化问题叫作最大布尔可满足性问题（MAX-SAT），该问题是要寻找一种 $n$ 个比特的取值以同时满足尽可能多的子句。值得注意的是，上面定义组合优化问题的方式其实就是将其抽象为了 MAX-SAT，更准确地说，是 MAX-SAT 的一个推广版本，即加权 MAX-SAT（weighted MAX-SAT）。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## 量子近似优化算法\n", - "\n", - "在实际生活中，许多组合优化问题都属于 NP 完全（NP-complete）问题甚至是 NP 困难（NP-hard）问题，这意味着计算机很可能无法高效地解决这样的问题。此时，一种替代方案便是寻找这类问题的近似最优解，而这样的任务通常是可以高效完成的。QAOA 就是一个可以寻找到一个组合优化问题的近似最优解的量子算法。\n", - "\n", - "### 编码组合优化问题\n", - "\n", - "对于上述的一个组合优化问题，有 $n$ 个比特和 $m$ 个子句。QAOA 算法将这个问题转化为了在 $n$ 个量子比特系统上的优化问题，该量子系统的每个计算基态 $|z\\rangle \\in \\{0,1\\}^n$ 对应着原问题中 $n$ 个比特的一种取值 $z$。同时，对于原问题中的第 $j$ 个子句，我们定义一个对角（diagonal）哈密顿量 $H_{C_j}$ 使其满足\n", - "\n", - "$$\n", - "H_{C_j}|z\\rangle = C_j(z)|z\\rangle.\n", - "\\tag{4}\n", - "$$\n", - "\n", - "具体我们可以通过下式来构造哈密顿量 $H_{C_j}$：\n", - "\n", - "$$\n", - "H_{C_j} = \\sum_{z\\in\\{0,1\\}^n} C_j(z)|z\\rangle\\langle z|.\n", - "\\tag{5}\n", - "$$\n", - "\n", - "例如，假设满足第 $j$ 个子句的取值有 $z^{(1)}$ 和 $z^{(2)}$，那么我们可以定义\n", - "\n", - "$$\n", - "H_{C_j} = |z^{(1)}\\rangle\\langle z^{(1)}| + |z^{(2)}\\rangle\\langle z^{(2)}|.\n", - "\\tag{6}\n", - "$$\n", - "\n", - "由此，QAOA 将组合优化问题的目标函数 $C$ 编码成了 $n$ 个量子比特系统上的哈密顿量\n", - "\n", - "$$\n", - "H_C = \\sum_{j=1}^m w_jH_{C_j},\n", - "\\tag{7}\n", - "$$\n", - "\n", - "并且\n", - "\n", - "$$\n", - "H_C|z\\rangle = \\sum_{j=1}^m w_jH_{C_j}|z\\rangle = \\sum_{j=1}^m w_jC_j(z)|z\\rangle = C(z)|z\\rangle.\n", - "\\tag{8}\n", - "$$\n", - "\n", - "值得注意的是，假设原问题的一个最优解是 $z_\\text{opt}$，那么我们有\n", - "\n", - "$$\n", - "\\langle z_\\text{opt}|H_C|z_\\text{opt}\\rangle = \\langle z_\\text{opt}|C(z_\\text{opt})|z_\\text{opt}\\rangle = C(z_\\text{opt})\\langle z_\\text{opt}|z_\\text{opt}\\rangle = C(z_\\text{opt}).\n", - "\\tag{9}\n", - "$$\n", - "\n", - "因此，原组合优化问题的最优解是哈密顿量 $H_C$ 的一个拥有最大本征值（eigenvalue）的本征态（eigenstate）。此外，对于任意量子态 $|\\psi\\rangle$，\n", - "\n", - "$$\n", - "\\langle\\psi|H_C|\\psi\\rangle \\leq C(z_\\text{opt}),\n", - "\\tag{10}\n", - "$$\n", - "\n", - "且该式取等号当且仅当 $|\\psi\\rangle$ 是几个最优解的叠加态。由式（9）和式（10）可以得到，\n", - "\n", - "$$\n", - "\\max_{|\\psi\\rangle} \\langle\\psi|H_C|\\psi\\rangle = C(z_\\text{opt})，\n", - "\\tag{11}\n", - "$$\n", - "\n", - "并且寻找原组合优化问题的最优解等同于寻找哈密顿量 $H_C$ 的一个拥有最大本征值的本征态，即寻找一个量子态 $|\\psi\\rangle$ 使得\n", - "\n", - "$$\n", - "H_C|\\psi\\rangle = C(z_\\text{opt})|\\psi\\rangle.\n", - "\\tag{12}\n", - "$$\n", - "\n", - "找到这样一个量子态 $|\\psi\\rangle$ 后，它很可能并不是一个计算基态，而是几个计算基态的叠加，这其中的每个计算基态都是原组合优化问题的一个最优解。因此，我们对 $|\\psi\\rangle$ 进行计算基上的测量，便能得到原组合优化问题的一个最优解。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 寻找近似最优解\n", - "\n", - "尽管将要解决的组合优化问题的目标函数编码成一个量子系统的哈密顿量 $H_C$ 较为简单，但想要根据式（11）从偌大的希尔伯特空间中找到代表最优解的量子态 $|\\psi\\rangle$ 并不容易。为了找到这样一个量子态，我们需要借助另一个哈密顿量\n", - "\n", - "$$\n", - "H_B = \\sum_{j=1}^n X_j,\n", - "\\tag{13}\n", - "$$\n", - "\n", - "其中 $X_j$ 表示作用在第 $j$ 个量子比特上的 Pauli $X$ 门。Pauli $X$ 门的两个本征态分别是 $|+\\rangle$ 和 $|-\\rangle$，它们对应的本征值分别是 $1$ 和 $-1$：\n", - "\n", - "$$\n", - "\\begin{align}\n", - "X|+\\rangle &=\n", - "\\begin{bmatrix}\n", - "0&1\\\\1&0\n", - "\\end{bmatrix}\n", - "\\frac{1}{\\sqrt{2}}\n", - "\\begin{bmatrix}\n", - "1\\\\1\n", - "\\end{bmatrix}\n", - "= \\frac{1}{\\sqrt{2}}\n", - "\\begin{bmatrix}\n", - "1\\\\1\n", - "\\end{bmatrix}\n", - "= |+\\rangle,\\tag{14}\\\\\n", - "X|-\\rangle &=\n", - "\\begin{bmatrix}\n", - "0&1\\\\1&0\n", - "\\end{bmatrix}\n", - "\\frac{1}{\\sqrt{2}}\n", - "\\begin{bmatrix}\n", - "1\\\\-1\n", - "\\end{bmatrix}\n", - "= \\frac{1}{\\sqrt{2}}\n", - "\\begin{bmatrix}\n", - "-1\\\\1\n", - "\\end{bmatrix}\n", - "= -|-\\rangle.\\tag{15}\n", - "\\end{align}\n", - "$$\n", - "\n", - "因此，$H_B$ 的拥有最大本征值的本征态为\n", - "\n", - "$$\n", - "|s\\rangle \\equiv \\underbrace{|+\\rangle\\otimes\\cdots\\otimes|+\\rangle}_{\\text{共 $n$ 个 }|+\\rangle} = |+\\rangle^{\\otimes n}.\n", - "\\tag{16}\n", - "$$\n", - "\n", - "我们将把这个量子态 $|s\\rangle$ 作为算法的初始态。构造出哈密顿量 $H_C$ 和 $H_B$ 后，我们就可以开始寻找原组合优化问题的一个近似最优解了。根据哈密顿量 $H_C$ 和 $H_B$，分别定义酉变换\n", - "\n", - "$$\n", - "U_C(\\gamma) = e^{-i\\gamma H_C}\n", - "\\tag{17}\n", - "$$\n", - "\n", - "和酉变换\n", - "\n", - "$$\n", - "U_B(\\beta) = e^{-i\\beta H_B},\n", - "\\tag{18}\n", - "$$\n", - "\n", - "其中 $\\gamma$ 和 $\\beta$ 是实数，为可调节的参数。给定任意一个整数 $p\\geq1$ 以及参数 $\\vec{\\gamma}=(\\gamma_1,\\dots,\\gamma_p)$ 和 $\\vec{\\beta}=(\\beta_1,\\dots,\\beta_p)$，我们定义\n", - "\n", - "$$\n", - "|\\vec{\\gamma},\\vec{\\beta}\\rangle = U_B(\\beta_p)U_C(\\gamma_p)\\cdots U_B(\\beta_1)U_C(\\gamma_1)|s\\rangle.\n", - "\\tag{19}\n", - "$$\n", - "\n", - "可以看到，整数 $p$ 表示用到的 $U_C,U_B$ 的层数，即分别将 $U_C$ 和 $U_B$ 交替地作用在初始态 $|s\\rangle$ 上 $p$ 次。我们记 $F_p(\\vec{\\gamma},\\vec{\\beta})$ 为哈密顿量 $H_C$ 在式（19）的量子态下的期望值，\n", - "\n", - "$$\n", - "F_p(\\vec{\\gamma},\\vec{\\beta}) = \\langle\\vec{\\gamma},\\vec{\\beta}|H_C|\\vec{\\gamma},\\vec{\\beta}\\rangle.\n", - "\\tag{20}\n", - "$$\n", - "\n", - "通过调整参数 $\\vec{\\gamma},\\vec{\\beta}$，我们可以得到\n", - "\n", - "$$\n", - "M_p = \\max_{\\vec{\\gamma},\\vec{\\beta}} F_p(\\vec{\\gamma},\\vec{\\beta})\n", - "\\tag{21}\n", - "$$\n", - "\n", - "作为给定层数 $p$ 下的近似最优解。至此，我们将寻找量子态 $|\\psi\\rangle$ 的问题转变为了搜寻参数 $\\vec{\\gamma},\\vec{\\beta}$ 的问题。值得注意的是，$p$ 层酉变换 $U_C,U_B$ 的表达能力强于 $p-1$ 层的表达能力，因此\n", - "\n", - "$$\n", - "M_p \\geq M_{p-1}.\n", - "\\tag{22}\n", - "$$\n", - "\n", - "事实上，当 $p$ 足够大时，\n", - "\n", - "$$\n", - "\\lim_{p\\to\\infty} M_p = \\max_z C(z).\n", - "\\tag{23}\n", - "$$" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 解码量子答案\n", - "\n", - "在上一段中，尽管我们将寻找量子态 $|\\psi\\rangle$ 转变为了寻找参数化量子态 $|\\vec{\\gamma},\\vec{\\beta}\\rangle$ 以方便我们的搜索，但同时我们也缩小了搜索的空间，也就是说，在给定层数 $p$ 的情况下，可能并不存在参数 $\\vec{\\gamma},\\vec{\\beta}$ 使得 $F_p(\\vec{\\gamma},\\vec{\\beta}) = C(z_\\text{opt})$。假设参数 $\\vec{\\gamma}^*$ 和 $\\vec{\\beta}^*$ 使得 $F_p$ 最大，即 $F_p(\\vec{\\gamma}^*,\\vec{\\beta}^*) = M_p$，那么在理想情况下量子态 $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ 包含了最优解的信息。但要注意的是，这里只使用了 $p$ 层，因此很可能 $M_p < C(z_\\text{opt})$。因此，一般情况下 $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ 只包含了近似最优解的信息。进一步地，我们假设量子态 $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ 是 $l$ 个计算基态的叠加态，即\n", - "\n", - "$$\n", - "|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle = c_1|z^{(1)}\\rangle + \\cdots + c_l|z^{(l)}\\rangle.\n", - "\\tag{24}\n", - "$$\n", - "\n", - "通常情况下，一个态 $|z^{(j)}\\rangle$ 在计算基上测量得到的概率 $|c_j|^2$ 越大，意味着其对应的比特串 $z^{(j)}$ 是最优解的可能性越大。那么我们制备 $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ 并测量，得到一个比特串 $z$ 并计算 $C(z)$ 的值。重复多次这个过程，便能得到一个 $z$ 使得 $C(z)$ 接近甚至超过 $M_p$。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### 绝热定理\n", - "\n", - "为什么可以用上述的方法来构造量子态 $|\\vec{\\gamma},\\vec{\\beta}\\rangle$？ QAOA 试图找到一个优化问题的近似最优解，一个与之类似的算法是量子绝热算法 [2]（quantum adiabatic algorithm, QAA）。但不同的是，QAA 是为了找到优化问题的最优解而非近似最优解。与 QAOA 类似，QAA 将一个优化问题转化为了求一个哈密顿量的基态的问题，并利用绝热定理（adiabatic theorem）对其求解。考虑一个量子系统的哈密顿量\n", - "\n", - "$$\n", - "H(t) = (1-\\frac tT)H_B + \\frac tT H_C,\n", - "\\tag{25}\n", - "$$\n", - "\n", - "初始时，时间 $t=0$，该系统的哈密顿量为 $H(0) = H_B$。随着时间的流逝，该系统的哈密顿量逐渐由 $H_B$ 变为 $H_C$。当 $t=T$ 时，该系统的哈密顿量变为 $H(T) = H_C$。量子力学中的绝热定理告诉我们，如果初始时该系统处于 $H_B$ 的一个本征态，那么只要时间 $T$ 足够长，当系统的哈密顿量完全演化为 $H_C$ 时，该系统会处于 $H_C$ 的对应能级的本征态。因此，如果初始时该系统处于 $|s\\rangle$，即 $H_B$ 拥有最大本征值的本征态，经过足够长的演化时间 $T$，该系统的量子态会变为 $H_C$ 拥有最大本征值的本征态。[3]\n", - "\n", - "一种模拟哈密顿量 $H(t)$ 随着时间 $t$ 演化的方法便是交替地在该量子系统上作用酉变换 $U_C(\\gamma)$ 和 $U_B(\\beta)$，而模拟的精度取决于 $\\gamma,\\beta$ 的取值。另外，为了让系统的演化遵循绝热定理，需要足够长的演化时间，所以要求 $p$ 的取值足够大。因此，结合公式（22）可以推出公式（23）中的结论。" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "_______\n", - "\n", - "## 参考文献\n", - "\n", - "[1] Farhi, E., Goldstone, J. & Gutmann, S. A Quantum Approximate Optimization Algorithm. [arXiv:1411.4028 (2014).](https://arxiv.org/abs/1411.4028)\n", - "\n", - "[2] Farhi, E., Goldstone, J., Gutmann, S. & Sipser, M. Quantum computation by adiabatic evolution. [arXiv:quant-ph/0001106 (2000).](https://arxiv.org/abs/quant-ph/0001106)\n", - "\n", - "[3] Duan, R. Quantum Adiabatic Theorem Revisited. [arXiv:2003.03063 (2020).](https://arxiv.org/abs/2003.03063)" - ] - } - ], - "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.0" - }, - "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 - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 量子近似优化算法\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 概览\n", + "\n", + "量子近似优化算法（quantum approximate optimization algorithm, QAOA）是可以在近期的有噪中等规模量子（noisy intermediate-scale quantum, NISQ）设备上运行且具有广泛应用前景的量子算法。QAOA 由 Edward Farhi 等人于 2014 年提出 [1]，其目的是近似地求解组合优化问题（combinatorial optimization problems）。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 组合优化问题\n", + "\n", + "在应用数学和理论计算机科学的领域中，组合优化是在一个有限的对象集中找出最优对象的一类课题。简单来说，组合优化问题是指问题的所有解是由离散变量组成的，然后在离散的解集中寻找最优解。组合优化问题涉及的范围很广，且常见于实际生活中，例如飞机航线的设计、快递物流路线的规划等。\n", + "\n", + "具体来说，一个组合优化问题可以由 $n$ 个比特（bit）和 $m$ 个子句（clause）描述。每个比特是一个二进制变量，其取值为 $0$ 或 $1$，我们用 $z_j$ 表示第 $j$ 个比特的取值。因此，这 $n$ 个比特的取值可以由比特串 $z=z_1z_2\\dots z_n$ 表示。每个子句都是对部分比特的一个限制条件，例如一个子句可以要求第 $2$ 个比特的取值为 $0$，或者可以要求第 $3$ 个比特和第 $5$ 个比特的取值相同，等等。对于第 $j$ 个子句，我们定义一个与之相关的函数\n", + "\n", + "$$\n", + "C_j(z)=\n", + "\\begin{cases}\n", + "1 & \\text{如果 $n$ 个比特的取值 $z$ 满足子句 $j$ 表明的条件}\\\\\n", + "0 & \\text{如果 $n$ 个比特的取值 $z$ 不满足子句 $j$ 表明的条件}\n", + "\\end{cases}.\n", + "\\tag{1}\n", + "$$\n", + "\n", + "例如，如果第一个子句要求第二个比特的取值为 0，那么我们有 $C_1(z_10z_3\\dots z_n)=1$ 和 $C_1(z_11z_3\\dots z_n)=0$。\n", + "\n", + "由公式（1）中我们对于每个子句定义的函数 $C_j$，我们可以定义该组合优化问题的目标函数（objective function）\n", + "\n", + "$$\n", + "C(z)=\\sum_{j=1}^m w_jC_j(z),\n", + "\\tag{2}\n", + "$$\n", + "\n", + "其中 $w_j$ 是第 $j$ 个子句的权重（weight）。组合优化问题就是要找到一个取值 $z$ 使得目标函数 $C(z)$ 的值最大，即\n", + "\n", + "$$\n", + "\\underset{z}{\\operatorname{argmax}} C(z).\n", + "\\tag{3}\n", + "$$\n", + "\n", + "在理论计算机科学中，有一个著名的问题叫作布尔可满足性问题（Boolean satisfiability problem, SAT），它是指对于输入的一组 $n$ 个比特和 $m$ 个子句，判断是否存在一种 $n$ 个比特的取值同时满足所有 $m$ 个子句。而一个与之相关的优化问题叫作最大布尔可满足性问题（MAX-SAT），该问题是要寻找一种 $n$ 个比特的取值以同时满足尽可能多的子句。值得注意的是，上面定义组合优化问题的方式其实就是将其抽象为了 MAX-SAT，更准确地说，是 MAX-SAT 的一个推广版本，即加权 MAX-SAT（weighted MAX-SAT）。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 量子近似优化算法\n", + "\n", + "在实际生活中，许多组合优化问题都属于 NP 完全（NP-complete）问题甚至是 NP 困难（NP-hard）问题，这意味着计算机很可能无法高效地解决这样的问题。此时，一种替代方案便是寻找这类问题的近似最优解，而这样的任务通常是可以高效完成的。QAOA 就是一个可以寻找到一个组合优化问题的近似最优解的量子算法。\n", + "\n", + "### 编码组合优化问题\n", + "\n", + "对于上述的一个组合优化问题，有 $n$ 个比特和 $m$ 个子句。QAOA 算法将这个问题转化为了在 $n$ 个量子比特系统上的优化问题，该量子系统的每个计算基态 $|z\\rangle \\in \\{0,1\\}^n$ 对应着原问题中 $n$ 个比特的一种取值 $z$。同时，对于原问题中的第 $j$ 个子句，我们定义一个对角（diagonal）哈密顿量 $H_{C_j}$ 使其满足\n", + "\n", + "$$\n", + "H_{C_j}|z\\rangle = C_j(z)|z\\rangle.\n", + "\\tag{4}\n", + "$$\n", + "\n", + "具体我们可以通过下式来构造哈密顿量 $H_{C_j}$：\n", + "\n", + "$$\n", + "H_{C_j} = \\sum_{z\\in\\{0,1\\}^n} C_j(z)|z\\rangle\\langle z|.\n", + "\\tag{5}\n", + "$$\n", + "\n", + "例如，假设满足第 $j$ 个子句的取值有 $z^{(1)}$ 和 $z^{(2)}$，那么我们可以定义\n", + "\n", + "$$\n", + "H_{C_j} = |z^{(1)}\\rangle\\langle z^{(1)}| + |z^{(2)}\\rangle\\langle z^{(2)}|.\n", + "\\tag{6}\n", + "$$\n", + "\n", + "由此，QAOA 将组合优化问题的目标函数 $C$ 编码成了 $n$ 个量子比特系统上的哈密顿量\n", + "\n", + "$$\n", + "H_C = \\sum_{j=1}^m w_jH_{C_j},\n", + "\\tag{7}\n", + "$$\n", + "\n", + "并且\n", + "\n", + "$$\n", + "H_C|z\\rangle = \\sum_{j=1}^m w_jH_{C_j}|z\\rangle = \\sum_{j=1}^m w_jC_j(z)|z\\rangle = C(z)|z\\rangle.\n", + "\\tag{8}\n", + "$$\n", + "\n", + "值得注意的是，假设原问题的一个最优解是 $z_\\text{opt}$，那么我们有\n", + "\n", + "$$\n", + "\\langle z_\\text{opt}|H_C|z_\\text{opt}\\rangle = \\langle z_\\text{opt}|C(z_\\text{opt})|z_\\text{opt}\\rangle = C(z_\\text{opt})\\langle z_\\text{opt}|z_\\text{opt}\\rangle = C(z_\\text{opt}).\n", + "\\tag{9}\n", + "$$\n", + "\n", + "因此，原组合优化问题的最优解是哈密顿量 $H_C$ 的一个拥有最大本征值（eigenvalue）的本征态（eigenstate）。此外，对于任意量子态 $|\\psi\\rangle$，\n", + "\n", + "$$\n", + "\\langle\\psi|H_C|\\psi\\rangle \\leq C(z_\\text{opt}),\n", + "\\tag{10}\n", + "$$\n", + "\n", + "且该式取等号当且仅当 $|\\psi\\rangle$ 是几个最优解的叠加态。由式（9）和式（10）可以得到，\n", + "\n", + "$$\n", + "\\max_{|\\psi\\rangle} \\langle\\psi|H_C|\\psi\\rangle = C(z_\\text{opt})，\n", + "\\tag{11}\n", + "$$\n", + "\n", + "并且寻找原组合优化问题的最优解等同于寻找哈密顿量 $H_C$ 的一个拥有最大本征值的本征态，即寻找一个量子态 $|\\psi\\rangle$ 使得\n", + "\n", + "$$\n", + "H_C|\\psi\\rangle = C(z_\\text{opt})|\\psi\\rangle.\n", + "\\tag{12}\n", + "$$\n", + "\n", + "找到这样一个量子态 $|\\psi\\rangle$ 后，它很可能并不是一个计算基态，而是几个计算基态的叠加，这其中的每个计算基态都是原组合优化问题的一个最优解。因此，我们对 $|\\psi\\rangle$ 进行计算基上的测量，便能得到原组合优化问题的一个最优解。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 寻找近似最优解\n", + "\n", + "尽管将要解决的组合优化问题的目标函数编码成一个量子系统的哈密顿量 $H_C$ 较为简单，但想要根据式（11）从偌大的希尔伯特空间中找到代表最优解的量子态 $|\\psi\\rangle$ 并不容易。为了找到这样一个量子态，我们需要借助另一个哈密顿量\n", + "\n", + "$$\n", + "H_B = \\sum_{j=1}^n X_j,\n", + "\\tag{13}\n", + "$$\n", + "\n", + "其中 $X_j$ 表示作用在第 $j$ 个量子比特上的 Pauli $X$ 门。Pauli $X$ 门的两个本征态分别是 $|+\\rangle$ 和 $|-\\rangle$，它们对应的本征值分别是 $1$ 和 $-1$：\n", + "\n", + "$$\n", + "\\begin{align}\n", + "X|+\\rangle &=\n", + "\\begin{bmatrix}\n", + "0&1\\\\1&0\n", + "\\end{bmatrix}\n", + "\\frac{1}{\\sqrt{2}}\n", + "\\begin{bmatrix}\n", + "1\\\\1\n", + "\\end{bmatrix}\n", + "= \\frac{1}{\\sqrt{2}}\n", + "\\begin{bmatrix}\n", + "1\\\\1\n", + "\\end{bmatrix}\n", + "= |+\\rangle,\\tag{14}\\\\\n", + "X|-\\rangle &=\n", + "\\begin{bmatrix}\n", + "0&1\\\\1&0\n", + "\\end{bmatrix}\n", + "\\frac{1}{\\sqrt{2}}\n", + "\\begin{bmatrix}\n", + "1\\\\-1\n", + "\\end{bmatrix}\n", + "= \\frac{1}{\\sqrt{2}}\n", + "\\begin{bmatrix}\n", + "-1\\\\1\n", + "\\end{bmatrix}\n", + "= -|-\\rangle.\\tag{15}\n", + "\\end{align}\n", + "$$\n", + "\n", + "因此，$H_B$ 的拥有最大本征值的本征态为\n", + "\n", + "$$\n", + "|s\\rangle \\equiv \\underbrace{|+\\rangle\\otimes\\cdots\\otimes|+\\rangle}_{\\text{共 $n$ 个 }|+\\rangle} = |+\\rangle^{\\otimes n}.\n", + "\\tag{16}\n", + "$$\n", + "\n", + "我们将把这个量子态 $|s\\rangle$ 作为算法的初始态。构造出哈密顿量 $H_C$ 和 $H_B$ 后，我们就可以开始寻找原组合优化问题的一个近似最优解了。根据哈密顿量 $H_C$ 和 $H_B$，分别定义酉变换\n", + "\n", + "$$\n", + "U_C(\\gamma) = e^{-i\\gamma H_C}\n", + "\\tag{17}\n", + "$$\n", + "\n", + "和酉变换\n", + "\n", + "$$\n", + "U_B(\\beta) = e^{-i\\beta H_B},\n", + "\\tag{18}\n", + "$$\n", + "\n", + "其中 $\\gamma$ 和 $\\beta$ 是实数，为可调节的参数。给定任意一个整数 $p\\geq1$ 以及参数 $\\vec{\\gamma}=(\\gamma_1,\\dots,\\gamma_p)$ 和 $\\vec{\\beta}=(\\beta_1,\\dots,\\beta_p)$，我们定义\n", + "\n", + "$$\n", + "|\\vec{\\gamma},\\vec{\\beta}\\rangle = U_B(\\beta_p)U_C(\\gamma_p)\\cdots U_B(\\beta_1)U_C(\\gamma_1)|s\\rangle.\n", + "\\tag{19}\n", + "$$\n", + "\n", + "可以看到，整数 $p$ 表示用到的 $U_C,U_B$ 的层数，即分别将 $U_C$ 和 $U_B$ 交替地作用在初始态 $|s\\rangle$ 上 $p$ 次。我们记 $F_p(\\vec{\\gamma},\\vec{\\beta})$ 为哈密顿量 $H_C$ 在式（19）的量子态下的期望值，\n", + "\n", + "$$\n", + "F_p(\\vec{\\gamma},\\vec{\\beta}) = \\langle\\vec{\\gamma},\\vec{\\beta}|H_C|\\vec{\\gamma},\\vec{\\beta}\\rangle.\n", + "\\tag{20}\n", + "$$\n", + "\n", + "通过调整参数 $\\vec{\\gamma},\\vec{\\beta}$，我们可以得到\n", + "\n", + "$$\n", + "M_p = \\max_{\\vec{\\gamma},\\vec{\\beta}} F_p(\\vec{\\gamma},\\vec{\\beta})\n", + "\\tag{21}\n", + "$$\n", + "\n", + "作为给定层数 $p$ 下的近似最优解。至此，我们将寻找量子态 $|\\psi\\rangle$ 的问题转变为了搜寻参数 $\\vec{\\gamma},\\vec{\\beta}$ 的问题。值得注意的是，$p$ 层酉变换 $U_C,U_B$ 的表达能力强于 $p-1$ 层的表达能力，因此\n", + "\n", + "$$\n", + "M_p \\geq M_{p-1}.\n", + "\\tag{22}\n", + "$$\n", + "\n", + "事实上，当 $p$ 足够大时，\n", + "\n", + "$$\n", + "\\lim_{p\\to\\infty} M_p = \\max_z C(z).\n", + "\\tag{23}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 解码量子答案\n", + "\n", + "在上一段中，尽管我们将寻找量子态 $|\\psi\\rangle$ 转变为了寻找参数化量子态 $|\\vec{\\gamma},\\vec{\\beta}\\rangle$ 以方便我们的搜索，但同时我们也缩小了搜索的空间，也就是说，在给定层数 $p$ 的情况下，可能并不存在参数 $\\vec{\\gamma},\\vec{\\beta}$ 使得 $F_p(\\vec{\\gamma},\\vec{\\beta}) = C(z_\\text{opt})$。假设参数 $\\vec{\\gamma}^*$ 和 $\\vec{\\beta}^*$ 使得 $F_p$ 最大，即 $F_p(\\vec{\\gamma}^*,\\vec{\\beta}^*) = M_p$，那么在理想情况下量子态 $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ 包含了最优解的信息。但要注意的是，这里只使用了 $p$ 层，因此很可能 $M_p < C(z_\\text{opt})$。因此，一般情况下 $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ 只包含了近似最优解的信息。进一步地，我们假设量子态 $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ 是 $l$ 个计算基态的叠加态，即\n", + "\n", + "$$\n", + "|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle = c_1|z^{(1)}\\rangle + \\cdots + c_l|z^{(l)}\\rangle.\n", + "\\tag{24}\n", + "$$\n", + "\n", + "通常情况下，一个态 $|z^{(j)}\\rangle$ 在计算基上测量得到的概率 $|c_j|^2$ 越大，意味着其对应的比特串 $z^{(j)}$ 是最优解的可能性越大。那么我们制备 $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ 并测量，得到一个比特串 $z$ 并计算 $C(z)$ 的值。重复多次这个过程，便能得到一个 $z$ 使得 $C(z)$ 接近甚至超过 $M_p$。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 绝热定理\n", + "\n", + "为什么可以用上述的方法来构造量子态 $|\\vec{\\gamma},\\vec{\\beta}\\rangle$？ QAOA 试图找到一个优化问题的近似最优解，一个与之类似的算法是量子绝热算法 [2]（quantum adiabatic algorithm, QAA）。但不同的是，QAA 是为了找到优化问题的最优解而非近似最优解。与 QAOA 类似，QAA 将一个优化问题转化为了求一个哈密顿量的基态的问题，并利用绝热定理（adiabatic theorem）对其求解。考虑一个量子系统的哈密顿量\n", + "\n", + "$$\n", + "H(t) = (1-\\frac tT)H_B + \\frac tT H_C,\n", + "\\tag{25}\n", + "$$\n", + "\n", + "初始时，时间 $t=0$，该系统的哈密顿量为 $H(0) = H_B$。随着时间的流逝，该系统的哈密顿量逐渐由 $H_B$ 变为 $H_C$。当 $t=T$ 时，该系统的哈密顿量变为 $H(T) = H_C$。量子力学中的绝热定理告诉我们，如果初始时该系统处于 $H_B$ 的一个本征态，那么只要时间 $T$ 足够长，当系统的哈密顿量完全演化为 $H_C$ 时，该系统会处于 $H_C$ 的对应能级的本征态。因此，如果初始时该系统处于 $|s\\rangle$，即 $H_B$ 拥有最大本征值的本征态，经过足够长的演化时间 $T$，该系统的量子态会变为 $H_C$ 拥有最大本征值的本征态。[3]\n", + "\n", + "一种模拟哈密顿量 $H(t)$ 随着时间 $t$ 演化的方法便是交替地在该量子系统上作用酉变换 $U_C(\\gamma)$ 和 $U_B(\\beta)$，而模拟的精度取决于 $\\gamma,\\beta$ 的取值。另外，为了让系统的演化遵循绝热定理，需要足够长的演化时间，所以要求 $p$ 的取值足够大。因此，结合公式（22）可以推出公式（23）中的结论。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Farhi, E., Goldstone, J. & Gutmann, S. A Quantum Approximate Optimization Algorithm. [arXiv:1411.4028 (2014).](https://arxiv.org/abs/1411.4028)\n", + "\n", + "[2] Farhi, E., Goldstone, J., Gutmann, S. & Sipser, M. Quantum computation by adiabatic evolution. [arXiv:quant-ph/0001106 (2000).](https://arxiv.org/abs/quant-ph/0001106)\n", + "\n", + "[3] Duan, R. Quantum Adiabatic Theorem Revisited. [arXiv:2003.03063 (2020).](https://arxiv.org/abs/2003.03063)" + ] + } + ], + "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.0" + }, + "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 + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/combinatorial_optimization/QAOA_EN.ipynb b/tutorials/combinatorial_optimization/QAOA_EN.ipynb similarity index 98% rename from tutorial/combinatorial_optimization/QAOA_EN.ipynb rename to tutorials/combinatorial_optimization/QAOA_EN.ipynb index 69ee649..bdddb68 100644 --- a/tutorial/combinatorial_optimization/QAOA_EN.ipynb +++ b/tutorials/combinatorial_optimization/QAOA_EN.ipynb @@ -1,346 +1,346 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": { - "ExecuteTime": { - "end_time": "2021-01-06T07:10:17.389768Z", - "start_time": "2021-01-06T07:10:17.379639Z" - } - }, - "source": [ - "# Quantum Approximate Optimization Algorithm\n", - "\n", - " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Overview\n", - "\n", - "Quantum Approximate Optimization Algorithm (QAOA) is a quantum algorithm that can run on recent Noisy Intermediate-Scale Quantum (NISQ) devices and has a wide range of applications. QAOA was proposed by Edward Farhi et al. in 2014 [1], and its purpose is to solve combinatorial optimization problems approximately." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Combinatorial optimization problem\n", - "\n", - "In applied mathematics and theoretical computer science, combinatorial optimization is a type of topic that finds the optimal object in a discrete set of objects. In simple terms, the combinatorial optimization problem means that all solutions of the problem are composed of discrete variables, and the optimal solution is to be found in the discrete solution set. Combinatorial optimization problems involve a wide range of areas and are common in real life, such as the design of aircraft routes and the planning of express delivery routes.\n", - "\n", - "Specifically, a combinatorial optimization problem can be described by $n$ bits and $m$ clauses. Each bit is a binary variable whose value is $0$ or $1$, and we use $z_j$ to denote the value of the $j$th bit. Therefore, the value of these $n$ bits can be represented by the bit string $z=z_1z_2\\dots z_n$. Each clause is a restriction on some bits. For example, a clause can require the value of the $2$nd bit to be $0$, or it can require the value of the $3$rd bit and the $5$th bit to be the same. For the $j$th clause, we define a function\n", - "\n", - "$$\n", - "C_j(z)=\n", - "\\begin{cases}\n", - "1 & \\text{If the value $z$ of $n$ bits satisfies the condition indicated by clause $j$}\\\\\n", - "0 & \\text{if the value $z$ of $n$ bits does not satisfy the condition indicated by clause $j$}\n", - "\\end{cases}.\n", - "\\tag{1}\n", - "$$\n", - "\n", - "For example, if the first clause requires the value of the second bit to be 0, then we have $C_1(z_10z_3\\dots z_n)=1$ and $C_1(z_11z_3\\dots z_n)=0$.\n", - "\n", - "From the definition of $C_j$ in equation (1), we can define the objective function of the combinatorial optimization problem\n", - "\n", - "$$\n", - "C(z)=\\sum_{j=1}^m w_jC_j(z),\n", - "\\tag{2}\n", - "$$\n", - "\n", - "where $w_j$ is the weight of the $j$th clause. The combinatorial optimization problem is to find a value $z$ that maximizes the value of the objective function $C(z)$, namely\n", - "\n", - "$$\n", - "\\underset{z}{\\operatorname{argmax}} C(z).\n", - "\\tag{3}\n", - "$$\n", - "\n", - "In theoretical computer science, there is a famous problem called the Boolean satisfiability problem (SAT). This problem asks that, given $n$ bits and $m$ clauses as inputs, if there exists a value these bits can take so that all the $m$ clauses are satisfied simultaneously. An optimization problem related to SAT is MAX-SAT, which asks that what value these $n$ bits should take so that as many as possible clauses are satisfied. It is worth noting that the way we define a combinatorial optimization problem above is to formulate it as MAX-SAT, or more precisely, weighted MAX-SAT." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Quantum approximate optimization algorithm\n", - "\n", - "Many combinatorial optimization problems are NP-complete or even NP-hard problems, which means that computers may not be able to solve such problems efficiently. An alternative is to find the approximate optimal solution to such problems, and this task can usually be completed efficiently. QAOA is a quantum algorithm that can find an approximate optimal solution to a combinatorial optimization problem.\n", - "\n", - "### Encoding combinatorial optimization problem\n", - "\n", - "For the above combinatorial optimization problem, there are $n$ bits and $m$ clauses. The QAOA algorithm transforms this problem into an optimization problem on an $n$-qubit system. Each computational basis state $|z\\rangle \\in \\{0,1\\}^n$ of the quantum system corresponds to a value $z$ of $n$ bits in the original problem. At the same time, for the $j$th clause in the original problem, we define a diagonal Hamiltonian $H_{C_j}$ satisfying\n", - "\n", - "$$\n", - "H_{C_j}|z\\rangle = C_j(z)|z\\rangle.\n", - "\\tag{4}\n", - "$$\n", - "\n", - "Specifically, we can construct the Hamiltonian $H_{C_j}$ through the following equation:\n", - "\n", - "$$\n", - "H_{C_j} = \\sum_{z\\in\\{0,1\\}^n} C_j(z)|z\\rangle\\langle z|.\n", - "\\tag{5}\n", - "$$\n", - "\n", - "For example, assuming that $z^{(1)}$ and $z^{(2)}$ are the values ​​satisfying the $j$th clause, then we can define\n", - "\n", - "$$\n", - "H_{C_j} = |z^{(1)}\\rangle\\langle z^{(1)}| + |z^{(2)}\\rangle\\langle z^{(2)}|.\n", - "\\tag{6}\n", - "$$\n", - "\n", - "Therefore, QAOA encodes the objective function $C$ of the combinatorial optimization problem into the Hamiltonian $H_C$ on a system with $n$ qubits, where\n", - "\n", - "$$\n", - "H_C = \\sum_{j=1}^m w_jH_{C_j},\n", - "\\tag{7}\n", - "$$\n", - "\n", - "and\n", - "\n", - "$$\n", - "H_C|z\\rangle = \\sum_{j=1}^m w_jH_{C_j}|z\\rangle = \\sum_{j=1}^m w_jC_j(z)|z\\rangle = C(z)|z\\rangle .\n", - "\\tag{8}\n", - "$$\n", - "\n", - "It is worth noting that if an optimal solution to the original problem is $z_\\text{opt}$, then we have\n", - "\n", - "$$\n", - "\\langle z_\\text{opt}|H_C|z_\\text{opt}\\rangle = \\langle z_\\text{opt}|C(z_\\text{opt})|z_\\text{opt}\\rangle = C( z_\\text{opt})\\langle z_\\text{opt}|z_\\text{opt}\\rangle = C(z_\\text{opt}).\n", - "\\tag{9}\n", - "$$\n", - "\n", - "Therefore, an optimal solution of the original combinatorial optimization problem is an eigenstate with the largest eigenvalue of the Hamiltonian $H_C$. In addition, for any quantum state $|\\psi\\rangle$,\n", - "\n", - "$$\n", - "\\langle\\psi|H_C|\\psi\\rangle \\leq C(z_\\text{opt}),\n", - "\\tag{10}\n", - "$$\n", - "\n", - "and the equation takes the equal sign if and only if $|\\psi\\rangle$ is a superposition state of optimal solutions. It can be obtained from equation (9) and equation (10) that\n", - "\n", - "$$\n", - "\\max_{|\\psi\\rangle} \\langle\\psi|H_C|\\psi\\rangle = C(z_\\text{opt}),\n", - "\\tag{11}\n", - "$$\n", - "\n", - "and finding the optimal solution of the original combinatorial optimization problem is equivalent to finding an eigenstate with the largest eigenvalue of the Hamiltonian $H_C$, that is, finding a quantum state $|\\psi\\rangle$ such that\n", - "\n", - "$$\n", - "H_C|\\psi\\rangle = C(z_\\text{opt})|\\psi\\rangle.\n", - "\\tag{12}\n", - "$$\n", - "\n", - "When we find such a quantum state $|\\psi\\rangle$, it is probably not a computational basis state, but a superposition of several computational basis states, each of which is an optimal solution of the original combinatorial optimization problem. Therefore, we can obtain an optimal solution to the original combinatorial optimization problem by performing computational basis measurements on $|\\psi\\rangle$.\n", - "\n", - "### Finding an approximate optimal solution\n", - "\n", - "Although it is relatively simple to encode the objective function of the combinatorial optimization problem to be solved into the Hamiltonian $H_C$ of a quantum system, finding the quantum state $|\\psi\\rangle$ representing an optimal solution from the huge Hilbert space according to equation (11) is not easy. In order to find such a quantum state, we need another Hamiltonian\n", - "\n", - "$$\n", - "H_B = \\sum_{j=1}^n X_j,\n", - "\\tag{13}\n", - "$$\n", - "\n", - "where $X_j$ represents the Pauli $X$ gate acting on the $j$th qubit. The two eigenstates of Pauli $X$ gate are $|+\\rangle$ and $|-\\rangle$, and their corresponding eigenvalues ​​are $1$ and $-1$, respectively:\n", - "\n", - "$$\n", - "\\begin{align}\n", - "X|+\\rangle &=\n", - "\\begin{bmatrix}\n", - "0&1\\\\1&0\n", - "\\end{bmatrix}\n", - "\\frac{1}{\\sqrt{2}}\n", - "\\begin{bmatrix}\n", - "1\\\\1\n", - "\\end{bmatrix}\n", - "= \\frac{1}{\\sqrt{2}}\n", - "\\begin{bmatrix}\n", - "1\\\\1\n", - "\\end{bmatrix}\n", - "= |+\\rangle,\\tag{14}\\\\\n", - "X|-\\rangle &=\n", - "\\begin{bmatrix}\n", - "0&1\\\\1&0\n", - "\\end{bmatrix}\n", - "\\frac{1}{\\sqrt{2}}\n", - "\\begin{bmatrix}\n", - "1\\\\-1\n", - "\\end{bmatrix}\n", - "= \\frac{1}{\\sqrt{2}}\n", - "\\begin{bmatrix}\n", - "-1\\\\1\n", - "\\end{bmatrix}\n", - "= -|-\\rangle.\\tag{15}\n", - "\\end{align}\n", - "$$\n", - "\n", - "Therefore, the eigenstate with the largest eigenvalue of $H_B$ is\n", - "\n", - "$$\n", - "|s\\rangle \\equiv \\underbrace{|+\\rangle\\otimes\\cdots\\otimes|+\\rangle}_\\text{$n$ terms} = |+\\rangle^{\\otimes n }.\n", - "\\tag{16}\n", - "$$\n", - "\n", - "We will use this quantum state $|s\\rangle$ as the initial state for the algorithm. After constructing the Hamiltonian $H_C$ and $H_B$, we can start to find an approximate optimal solution to the original combinatorial optimization problem. According to the Hamiltonian $H_C$ and $H_B$, respectively define the unitary transformation\n", - "\n", - "$$\n", - "U_C(\\gamma) = e^{-i\\gamma H_C}\n", - "\\tag{17}\n", - "$$\n", - "\n", - "and unitary transformation\n", - "\n", - "$$\n", - "U_B(\\beta) = e^{-i\\beta H_B},\n", - "\\tag{18}\n", - "$$\n", - "\n", - "where $\\gamma$ and $\\beta$ are adjustable real parameters. Given any integer $p\\geq1$ and the parameters $\\vec{\\gamma}=(\\gamma_1,\\dots,\\gamma_p)$ and $\\vec{\\beta}=(\\beta_1,\\dots,\\beta_p) $, we define\n", - "\n", - "$$\n", - "|\\vec{\\gamma},\\vec{\\beta}\\rangle = U_B(\\beta_p)U_C(\\gamma_p)\\cdots U_B(\\beta_1)U_C(\\gamma_1)|s\\rangle.\n", - "\\tag{19}\n", - "$$\n", - "\n", - "It can be seen that the integer $p$ represents the number of layers of $U_C, U_B$, that is, the $U_C$ and $U_B$ are alternately applied to the initial state $|s\\rangle$ $p$ times. Let us denote $F_p(\\vec{\\gamma},\\vec{\\beta})$ as the expected value of the Hamiltonian $H_C$ in the quantum state of equation (19):\n", - "\n", - "$$\n", - "F_p(\\vec{\\gamma},\\vec{\\beta}) = \\langle\\vec{\\gamma},\\vec{\\beta}|H_C|\\vec{\\gamma},\\vec{\\beta}\\rangle .\n", - "\\tag{20}\n", - "$$\n", - "\n", - "By adjusting the parameters $\\vec{\\gamma},\\vec{\\beta}$, we can get\n", - "\n", - "$$\n", - "M_p = \\max_{\\vec{\\gamma},\\vec{\\beta}} F_p(\\vec{\\gamma},\\vec{\\beta})\n", - "\\tag{21}\n", - "$$\n", - "\n", - "as the approximate optimal solution under a given number of layers $p$. So far, we have transformed the problem of searching for the quantum state $|\\psi\\rangle$ into a problem of searching for the parameters $\\vec{\\gamma},\\vec{\\beta}$. It is worth noting that the search space given by $p$ layers of $U_C, U_B$ is larger than that of $p-1$ layers, so\n", - "\n", - "$$\n", - "M_p \\geq M_{p-1}.\n", - "\\tag{22}\n", - "$$\n", - "\n", - "In fact, when $p$ is large enough,\n", - "\n", - "$$\n", - "\\lim_{p\\to\\infty} M_p = \\max_z C(z).\n", - "\\tag{23}\n", - "$$\n", - "\n", - "### Decoding the quantum solution\n", - "\n", - "In the previous paragraph, we simplify the search for the quantum state $|\\psi\\rangle$ into the search for the parameterized quantum state $|\\vec{\\gamma},\\vec{\\beta}\\rangle$, but at the same time, we have also reduced the search space. That is to say, given the number of layers $p$, there may be no parameters $\\vec{\\gamma},\\vec{\\beta}$ such that $F_p(\\vec{\\gamma},\\vec{\\beta}) = C(z_\\text{opt})$. Suppose that the parameters $\\vec{\\gamma}^*$ and $\\vec{\\beta}^*$ make $F_p$ the largest, that is, $F_p(\\vec{\\gamma}^*,\\vec{\\beta}^* ) = M_p$. Then under ideal circumstances, the quantum state $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ contains the information of an optimal solution. But it should be noted that only $p$ layers are used here, so it is very likely that $M_p < C(z_\\text{opt})$. Therefore, in general $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ only contains information about an approximate optimal solution. Furthermore, we assume that the quantum state $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ is the superposition state of $l$ computational basis state, namely\n", - "\n", - "$$\n", - "|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle = c_1|z^{(1)}\\rangle + \\cdots + c_l|z^{(l)}\\rangle.\n", - "\\tag{24}\n", - "$$\n", - "\n", - "Normally, the larger the probability $|c_j|^2$ that a state $|z^{(j)}\\rangle$ is measured on the computational basis, the more likely that the corresponding bit string $z^{(j) }$ is an optimal solution. Thus, we prepare $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ and measure it to get a bit string $z$ and calculate the value of $C(z)$. Repeat this process many times, and we can get a bit string $z$ that makes $C(z)$ close to or even exceed $M_p$.\n", - "\n", - "### Adiabatic theorem\n", - "\n", - "Why do we use the above method to construct the quantum state $|\\vec{\\gamma},\\vec{\\beta}\\rangle$? QAOA tries to find an approximate optimal solution to an optimization problem. A similar algorithm is the quantum adiabatic algorithm [2] (QAA). The difference is that QAA is designed to find an optimal solution to the optimization problem rather than an approximate one. Similar to QAOA, QAA transforms an optimization problem into a problem of finding the ground state of a Hamiltonian, and uses the adiabatic theorem to solve it. Consider the Hamiltonian\n", - "\n", - "$$\n", - "H(t) = (1-\\frac tT)H_B + \\frac tT H_C,\n", - "\\tag{25}\n", - "$$\n", - "\n", - "of a quantum system. At initial, time $t=0$, and the Hamiltonian of the system is $H(0) = H_B$. As time passes, the Hamiltonian of the system gradually changes from $H_B$ to $H_C$. When $t=T$, the Hamiltonian of the system becomes $H(T) = H_C$. The adiabatic theorem in quantum mechanics tells us that if the system is in an eigenstate of $H_B$ at the beginning, then as long as the evolution time $T$ is long enough, the system will be in the eigenstate of the corresponding energy level of $H_C$ when the Hamiltonian of the system completely evolves to $H_C$. Therefore, if the system is initially in $|s\\rangle$, that is, the eigenstate with the largest eigenvalue of $H_B$, after a sufficiently long evolution time $T$, the quantum state of the system will become the eigenstate with the largest eigenvalue of $H_C$. [3]\n", - "\n", - "One way to simulate the evolution of the Hamiltonian $H(t)$ over time $t$ is to alternately apply the unitary transformations $U_C(\\gamma)$ and $U_B(\\beta)$ on the quantum system, and the accuracy of simulation depends on the value of $\\gamma,\\beta$. In addition, in order for the evolution of the system to follow the adiabatic theorem, a sufficiently long evolution time is required, so the value of $p$ is required to be large enough. Therefore, combining equation (22) we can deduce the conclusion in equation (23)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "_______\n", - "\n", - "## References\n", - "\n", - "[1] Farhi, E., Goldstone, J. & Gutmann, S. A Quantum Approximate Optimization Algorithm. [arXiv:1411.4028 (2014).](https://arxiv.org/abs/1411.4028)\n", - "\n", - "[2] Farhi, E., Goldstone, J., Gutmann, S. & Sipser, M. Quantum computation by adiabatic evolution. [arXiv:quant-ph/0001106 (2000).](https://arxiv.org/abs/quant-ph/0001106)\n", - "\n", - "[3] Duan, R. Quantum Adiabatic Theorem Revisited. [arXiv:2003.03063 (2020).](https://arxiv.org/abs/2003.03063)" - ] - } - ], - "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.8.3" - }, - "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": { - "height": "calc(100% - 180px)", - "left": "10px", - "top": "150px", - "width": "426.667px" - }, - "toc_section_display": true, - "toc_window_display": false - }, - "varInspector": { - "cols": { - "lenName": 16, - "lenType": 16, - "lenVar": 40 - }, - "kernels_config": { - "python": { - "delete_cmd_postfix": "", - "delete_cmd_prefix": "del ", - "library": "var_list.py", - "varRefreshCmd": "print(var_dic_list())" - }, - "r": { - "delete_cmd_postfix": ") ", - "delete_cmd_prefix": "rm(", - "library": "var_list.r", - "varRefreshCmd": "cat(var_dic_list()) " - } - }, - "types_to_exclude": [ - "module", - "function", - "builtin_function_or_method", - "instance", - "_Feature" - ], - "window_display": false - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "ExecuteTime": { + "end_time": "2021-01-06T07:10:17.389768Z", + "start_time": "2021-01-06T07:10:17.379639Z" + } + }, + "source": [ + "# Quantum Approximate Optimization Algorithm\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "Quantum Approximate Optimization Algorithm (QAOA) is a quantum algorithm that can run on recent Noisy Intermediate-Scale Quantum (NISQ) devices and has a wide range of applications. QAOA was proposed by Edward Farhi et al. in 2014 [1], and its purpose is to solve combinatorial optimization problems approximately." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Combinatorial optimization problem\n", + "\n", + "In applied mathematics and theoretical computer science, combinatorial optimization is a type of topic that finds the optimal object in a discrete set of objects. In simple terms, the combinatorial optimization problem means that all solutions of the problem are composed of discrete variables, and the optimal solution is to be found in the discrete solution set. Combinatorial optimization problems involve a wide range of areas and are common in real life, such as the design of aircraft routes and the planning of express delivery routes.\n", + "\n", + "Specifically, a combinatorial optimization problem can be described by $n$ bits and $m$ clauses. Each bit is a binary variable whose value is $0$ or $1$, and we use $z_j$ to denote the value of the $j$th bit. Therefore, the value of these $n$ bits can be represented by the bit string $z=z_1z_2\\dots z_n$. Each clause is a restriction on some bits. For example, a clause can require the value of the $2$nd bit to be $0$, or it can require the value of the $3$rd bit and the $5$th bit to be the same. For the $j$th clause, we define a function\n", + "\n", + "$$\n", + "C_j(z)=\n", + "\\begin{cases}\n", + "1 & \\text{If the value $z$ of $n$ bits satisfies the condition indicated by clause $j$}\\\\\n", + "0 & \\text{if the value $z$ of $n$ bits does not satisfy the condition indicated by clause $j$}\n", + "\\end{cases}.\n", + "\\tag{1}\n", + "$$\n", + "\n", + "For example, if the first clause requires the value of the second bit to be 0, then we have $C_1(z_10z_3\\dots z_n)=1$ and $C_1(z_11z_3\\dots z_n)=0$.\n", + "\n", + "From the definition of $C_j$ in equation (1), we can define the objective function of the combinatorial optimization problem\n", + "\n", + "$$\n", + "C(z)=\\sum_{j=1}^m w_jC_j(z),\n", + "\\tag{2}\n", + "$$\n", + "\n", + "where $w_j$ is the weight of the $j$th clause. The combinatorial optimization problem is to find a value $z$ that maximizes the value of the objective function $C(z)$, namely\n", + "\n", + "$$\n", + "\\underset{z}{\\operatorname{argmax}} C(z).\n", + "\\tag{3}\n", + "$$\n", + "\n", + "In theoretical computer science, there is a famous problem called the Boolean satisfiability problem (SAT). This problem asks that, given $n$ bits and $m$ clauses as inputs, if there exists a value these bits can take so that all the $m$ clauses are satisfied simultaneously. An optimization problem related to SAT is MAX-SAT, which asks that what value these $n$ bits should take so that as many as possible clauses are satisfied. It is worth noting that the way we define a combinatorial optimization problem above is to formulate it as MAX-SAT, or more precisely, weighted MAX-SAT." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quantum approximate optimization algorithm\n", + "\n", + "Many combinatorial optimization problems are NP-complete or even NP-hard problems, which means that computers may not be able to solve such problems efficiently. An alternative is to find the approximate optimal solution to such problems, and this task can usually be completed efficiently. QAOA is a quantum algorithm that can find an approximate optimal solution to a combinatorial optimization problem.\n", + "\n", + "### Encoding combinatorial optimization problem\n", + "\n", + "For the above combinatorial optimization problem, there are $n$ bits and $m$ clauses. The QAOA algorithm transforms this problem into an optimization problem on an $n$-qubit system. Each computational basis state $|z\\rangle \\in \\{0,1\\}^n$ of the quantum system corresponds to a value $z$ of $n$ bits in the original problem. At the same time, for the $j$th clause in the original problem, we define a diagonal Hamiltonian $H_{C_j}$ satisfying\n", + "\n", + "$$\n", + "H_{C_j}|z\\rangle = C_j(z)|z\\rangle.\n", + "\\tag{4}\n", + "$$\n", + "\n", + "Specifically, we can construct the Hamiltonian $H_{C_j}$ through the following equation:\n", + "\n", + "$$\n", + "H_{C_j} = \\sum_{z\\in\\{0,1\\}^n} C_j(z)|z\\rangle\\langle z|.\n", + "\\tag{5}\n", + "$$\n", + "\n", + "For example, assuming that $z^{(1)}$ and $z^{(2)}$ are the values ​​satisfying the $j$th clause, then we can define\n", + "\n", + "$$\n", + "H_{C_j} = |z^{(1)}\\rangle\\langle z^{(1)}| + |z^{(2)}\\rangle\\langle z^{(2)}|.\n", + "\\tag{6}\n", + "$$\n", + "\n", + "Therefore, QAOA encodes the objective function $C$ of the combinatorial optimization problem into the Hamiltonian $H_C$ on a system with $n$ qubits, where\n", + "\n", + "$$\n", + "H_C = \\sum_{j=1}^m w_jH_{C_j},\n", + "\\tag{7}\n", + "$$\n", + "\n", + "and\n", + "\n", + "$$\n", + "H_C|z\\rangle = \\sum_{j=1}^m w_jH_{C_j}|z\\rangle = \\sum_{j=1}^m w_jC_j(z)|z\\rangle = C(z)|z\\rangle .\n", + "\\tag{8}\n", + "$$\n", + "\n", + "It is worth noting that if an optimal solution to the original problem is $z_\\text{opt}$, then we have\n", + "\n", + "$$\n", + "\\langle z_\\text{opt}|H_C|z_\\text{opt}\\rangle = \\langle z_\\text{opt}|C(z_\\text{opt})|z_\\text{opt}\\rangle = C( z_\\text{opt})\\langle z_\\text{opt}|z_\\text{opt}\\rangle = C(z_\\text{opt}).\n", + "\\tag{9}\n", + "$$\n", + "\n", + "Therefore, an optimal solution of the original combinatorial optimization problem is an eigenstate with the largest eigenvalue of the Hamiltonian $H_C$. In addition, for any quantum state $|\\psi\\rangle$,\n", + "\n", + "$$\n", + "\\langle\\psi|H_C|\\psi\\rangle \\leq C(z_\\text{opt}),\n", + "\\tag{10}\n", + "$$\n", + "\n", + "and the equation takes the equal sign if and only if $|\\psi\\rangle$ is a superposition state of optimal solutions. It can be obtained from equation (9) and equation (10) that\n", + "\n", + "$$\n", + "\\max_{|\\psi\\rangle} \\langle\\psi|H_C|\\psi\\rangle = C(z_\\text{opt}),\n", + "\\tag{11}\n", + "$$\n", + "\n", + "and finding the optimal solution of the original combinatorial optimization problem is equivalent to finding an eigenstate with the largest eigenvalue of the Hamiltonian $H_C$, that is, finding a quantum state $|\\psi\\rangle$ such that\n", + "\n", + "$$\n", + "H_C|\\psi\\rangle = C(z_\\text{opt})|\\psi\\rangle.\n", + "\\tag{12}\n", + "$$\n", + "\n", + "When we find such a quantum state $|\\psi\\rangle$, it is probably not a computational basis state, but a superposition of several computational basis states, each of which is an optimal solution of the original combinatorial optimization problem. Therefore, we can obtain an optimal solution to the original combinatorial optimization problem by performing computational basis measurements on $|\\psi\\rangle$.\n", + "\n", + "### Finding an approximate optimal solution\n", + "\n", + "Although it is relatively simple to encode the objective function of the combinatorial optimization problem to be solved into the Hamiltonian $H_C$ of a quantum system, finding the quantum state $|\\psi\\rangle$ representing an optimal solution from the huge Hilbert space according to equation (11) is not easy. In order to find such a quantum state, we need another Hamiltonian\n", + "\n", + "$$\n", + "H_B = \\sum_{j=1}^n X_j,\n", + "\\tag{13}\n", + "$$\n", + "\n", + "where $X_j$ represents the Pauli $X$ gate acting on the $j$th qubit. The two eigenstates of Pauli $X$ gate are $|+\\rangle$ and $|-\\rangle$, and their corresponding eigenvalues ​​are $1$ and $-1$, respectively:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "X|+\\rangle &=\n", + "\\begin{bmatrix}\n", + "0&1\\\\1&0\n", + "\\end{bmatrix}\n", + "\\frac{1}{\\sqrt{2}}\n", + "\\begin{bmatrix}\n", + "1\\\\1\n", + "\\end{bmatrix}\n", + "= \\frac{1}{\\sqrt{2}}\n", + "\\begin{bmatrix}\n", + "1\\\\1\n", + "\\end{bmatrix}\n", + "= |+\\rangle,\\tag{14}\\\\\n", + "X|-\\rangle &=\n", + "\\begin{bmatrix}\n", + "0&1\\\\1&0\n", + "\\end{bmatrix}\n", + "\\frac{1}{\\sqrt{2}}\n", + "\\begin{bmatrix}\n", + "1\\\\-1\n", + "\\end{bmatrix}\n", + "= \\frac{1}{\\sqrt{2}}\n", + "\\begin{bmatrix}\n", + "-1\\\\1\n", + "\\end{bmatrix}\n", + "= -|-\\rangle.\\tag{15}\n", + "\\end{align}\n", + "$$\n", + "\n", + "Therefore, the eigenstate with the largest eigenvalue of $H_B$ is\n", + "\n", + "$$\n", + "|s\\rangle \\equiv \\underbrace{|+\\rangle\\otimes\\cdots\\otimes|+\\rangle}_\\text{$n$ terms} = |+\\rangle^{\\otimes n }.\n", + "\\tag{16}\n", + "$$\n", + "\n", + "We will use this quantum state $|s\\rangle$ as the initial state for the algorithm. After constructing the Hamiltonian $H_C$ and $H_B$, we can start to find an approximate optimal solution to the original combinatorial optimization problem. According to the Hamiltonian $H_C$ and $H_B$, respectively define the unitary transformation\n", + "\n", + "$$\n", + "U_C(\\gamma) = e^{-i\\gamma H_C}\n", + "\\tag{17}\n", + "$$\n", + "\n", + "and unitary transformation\n", + "\n", + "$$\n", + "U_B(\\beta) = e^{-i\\beta H_B},\n", + "\\tag{18}\n", + "$$\n", + "\n", + "where $\\gamma$ and $\\beta$ are adjustable real parameters. Given any integer $p\\geq1$ and the parameters $\\vec{\\gamma}=(\\gamma_1,\\dots,\\gamma_p)$ and $\\vec{\\beta}=(\\beta_1,\\dots,\\beta_p) $, we define\n", + "\n", + "$$\n", + "|\\vec{\\gamma},\\vec{\\beta}\\rangle = U_B(\\beta_p)U_C(\\gamma_p)\\cdots U_B(\\beta_1)U_C(\\gamma_1)|s\\rangle.\n", + "\\tag{19}\n", + "$$\n", + "\n", + "It can be seen that the integer $p$ represents the number of layers of $U_C, U_B$, that is, the $U_C$ and $U_B$ are alternately applied to the initial state $|s\\rangle$ $p$ times. Let us denote $F_p(\\vec{\\gamma},\\vec{\\beta})$ as the expected value of the Hamiltonian $H_C$ in the quantum state of equation (19):\n", + "\n", + "$$\n", + "F_p(\\vec{\\gamma},\\vec{\\beta}) = \\langle\\vec{\\gamma},\\vec{\\beta}|H_C|\\vec{\\gamma},\\vec{\\beta}\\rangle .\n", + "\\tag{20}\n", + "$$\n", + "\n", + "By adjusting the parameters $\\vec{\\gamma},\\vec{\\beta}$, we can get\n", + "\n", + "$$\n", + "M_p = \\max_{\\vec{\\gamma},\\vec{\\beta}} F_p(\\vec{\\gamma},\\vec{\\beta})\n", + "\\tag{21}\n", + "$$\n", + "\n", + "as the approximate optimal solution under a given number of layers $p$. So far, we have transformed the problem of searching for the quantum state $|\\psi\\rangle$ into a problem of searching for the parameters $\\vec{\\gamma},\\vec{\\beta}$. It is worth noting that the search space given by $p$ layers of $U_C, U_B$ is larger than that of $p-1$ layers, so\n", + "\n", + "$$\n", + "M_p \\geq M_{p-1}.\n", + "\\tag{22}\n", + "$$\n", + "\n", + "In fact, when $p$ is large enough,\n", + "\n", + "$$\n", + "\\lim_{p\\to\\infty} M_p = \\max_z C(z).\n", + "\\tag{23}\n", + "$$\n", + "\n", + "### Decoding the quantum solution\n", + "\n", + "In the previous paragraph, we simplify the search for the quantum state $|\\psi\\rangle$ into the search for the parameterized quantum state $|\\vec{\\gamma},\\vec{\\beta}\\rangle$, but at the same time, we have also reduced the search space. That is to say, given the number of layers $p$, there may be no parameters $\\vec{\\gamma},\\vec{\\beta}$ such that $F_p(\\vec{\\gamma},\\vec{\\beta}) = C(z_\\text{opt})$. Suppose that the parameters $\\vec{\\gamma}^*$ and $\\vec{\\beta}^*$ make $F_p$ the largest, that is, $F_p(\\vec{\\gamma}^*,\\vec{\\beta}^* ) = M_p$. Then under ideal circumstances, the quantum state $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ contains the information of an optimal solution. But it should be noted that only $p$ layers are used here, so it is very likely that $M_p < C(z_\\text{opt})$. Therefore, in general $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ only contains information about an approximate optimal solution. Furthermore, we assume that the quantum state $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ is the superposition state of $l$ computational basis state, namely\n", + "\n", + "$$\n", + "|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle = c_1|z^{(1)}\\rangle + \\cdots + c_l|z^{(l)}\\rangle.\n", + "\\tag{24}\n", + "$$\n", + "\n", + "Normally, the larger the probability $|c_j|^2$ that a state $|z^{(j)}\\rangle$ is measured on the computational basis, the more likely that the corresponding bit string $z^{(j) }$ is an optimal solution. Thus, we prepare $|\\vec{\\gamma}^*,\\vec{\\beta}^*\\rangle$ and measure it to get a bit string $z$ and calculate the value of $C(z)$. Repeat this process many times, and we can get a bit string $z$ that makes $C(z)$ close to or even exceed $M_p$.\n", + "\n", + "### Adiabatic theorem\n", + "\n", + "Why do we use the above method to construct the quantum state $|\\vec{\\gamma},\\vec{\\beta}\\rangle$? QAOA tries to find an approximate optimal solution to an optimization problem. A similar algorithm is the quantum adiabatic algorithm [2] (QAA). The difference is that QAA is designed to find an optimal solution to the optimization problem rather than an approximate one. Similar to QAOA, QAA transforms an optimization problem into a problem of finding the ground state of a Hamiltonian, and uses the adiabatic theorem to solve it. Consider the Hamiltonian\n", + "\n", + "$$\n", + "H(t) = (1-\\frac tT)H_B + \\frac tT H_C,\n", + "\\tag{25}\n", + "$$\n", + "\n", + "of a quantum system. At initial, time $t=0$, and the Hamiltonian of the system is $H(0) = H_B$. As time passes, the Hamiltonian of the system gradually changes from $H_B$ to $H_C$. When $t=T$, the Hamiltonian of the system becomes $H(T) = H_C$. The adiabatic theorem in quantum mechanics tells us that if the system is in an eigenstate of $H_B$ at the beginning, then as long as the evolution time $T$ is long enough, the system will be in the eigenstate of the corresponding energy level of $H_C$ when the Hamiltonian of the system completely evolves to $H_C$. Therefore, if the system is initially in $|s\\rangle$, that is, the eigenstate with the largest eigenvalue of $H_B$, after a sufficiently long evolution time $T$, the quantum state of the system will become the eigenstate with the largest eigenvalue of $H_C$. [3]\n", + "\n", + "One way to simulate the evolution of the Hamiltonian $H(t)$ over time $t$ is to alternately apply the unitary transformations $U_C(\\gamma)$ and $U_B(\\beta)$ on the quantum system, and the accuracy of simulation depends on the value of $\\gamma,\\beta$. In addition, in order for the evolution of the system to follow the adiabatic theorem, a sufficiently long evolution time is required, so the value of $p$ is required to be large enough. Therefore, combining equation (22) we can deduce the conclusion in equation (23)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## References\n", + "\n", + "[1] Farhi, E., Goldstone, J. & Gutmann, S. A Quantum Approximate Optimization Algorithm. [arXiv:1411.4028 (2014).](https://arxiv.org/abs/1411.4028)\n", + "\n", + "[2] Farhi, E., Goldstone, J., Gutmann, S. & Sipser, M. Quantum computation by adiabatic evolution. [arXiv:quant-ph/0001106 (2000).](https://arxiv.org/abs/quant-ph/0001106)\n", + "\n", + "[3] Duan, R. Quantum Adiabatic Theorem Revisited. [arXiv:2003.03063 (2020).](https://arxiv.org/abs/2003.03063)" + ] + } + ], + "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.8.3" + }, + "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": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "426.667px" + }, + "toc_section_display": true, + "toc_window_display": false + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorials/combinatorial_optimization/TSP_CN.ipynb b/tutorials/combinatorial_optimization/TSP_CN.ipynb new file mode 100644 index 0000000..6b1e602 --- /dev/null +++ b/tutorials/combinatorial_optimization/TSP_CN.ipynb @@ -0,0 +1,600 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 旅行商问题\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 概览\n", + "\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）的问题。哈密顿回路为一个通过且仅通过每一个顶点一次的回路。 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 使用量子神经网络解旅行商问题\n", + "\n", + "使用量子神经网络方法解决旅行商问题，需要首先将该问题编码为量子形式。\n", + "具体的包括以下两部分：\n", + "\n", + "1. 旅行商经过城市的顺序将编码进量子态 —— ${\\rm qubit}_{i,t} = |1\\rangle$ 对应于在时间 $t$ 经过城市$i$。\n", + " 1. 以两城市$\\{A,B\\}$举例。先经过$A$再经过$B$ 将由$|1001\\rangle$表示，对应于旅行商在时间 $1$ 经过城市$A$，在时间 $2$ 经过城市$B$。\n", + " 2. 类似的 $|0110\\rangle$对应于先经过$B$再经过$A$.\n", + " 3. 注意：$|0101\\rangle$意味着在时间 $2$ 同时经过城市 $A$、$B$，而这是不可能的。为避免此类量子态，我们会通过引入代价函数的方式 (具体见下一节)。\n", + "\n", + "2. 总距离被编码进损失函数： \n", + "\n", + "$$\n", + "L(\\psi(\\vec{\\theta})) = \\langle\\psi(\\vec{\\theta})|H_C|\\psi(\\vec{\\theta})\\rangle \\, ,\n", + "\\tag{1}\n", + "$$\n", + "其中 $|\\psi(\\vec{\\theta})\\rangle$ 对应于参数化量子电路的输出。\n", + "\n", + "在下一节中将详细介绍如何编码旅行商问题为对应量子问题。通过优化损失函数，我们将得到对应最优量子态。再通过解码，将得到最终的路线规划" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 编码旅行商问题\n", + "\n", + "为了将旅行商问题转化成一个参数化量子电路（parameterized quantum circuits, PQC）可解的问题，我们首先需要编码旅行商问题的哈密顿量。\n", + "\n", + "我们先将此问题转化为一个整数规划问题：假设图形 $G$ 的顶点数量为 $|V| = n$ 个，那么对于每个顶点 $i \\in V$，我们定义 $n$ 个二进制变量 $x_{i,t}$，$t \\in [0,n-1]$：\n", + "\n", + "$$\n", + "x_{i, t}=\n", + "\\begin{cases}\n", + "1, & \\text{如果在最后的哈密顿回路中，顶点 } i \\text { 的顺序为 $t$，即在时间 $t$ 的时候被旅行商访问}\\\\\n", + "0, & \\text{其他情况}\n", + "\\end{cases}.\n", + "\\tag{2}\n", + "$$\n", + "\n", + "因为 $G$ 有 $n$ 个顶点，所以我们共有 $n^2$ 个变量 $x_{i,t}$，所有这些变量的取值我们用 $x=x_{1,1}x_{1,2}\\dots x_{n,n}$ 来表示。现在我们假设 $x$ 对应了一条哈密顿回路，那么对于图中的每一条边 $(i,j,w_{i,j}) \\in E$，条件 $x_{i,t} = x_{j,t+1} = 1$（也可以等价地写成 $x_{i,t}\\cdot x_{j,t+1} = 1$）成立当且仅当该哈密顿回路中的第 $t$ 个顶点是顶点 $i$ 并且第 $t+1$ 个顶点是顶点 $j$；否则，$x_{i,t}\\cdot x_{j,t+1} = 0$。所以我们可以用下式计算哈密顿回路的长度\n", + "\n", + "$$\n", + "D(x) = \\sum_{i,j} w_{i,j} \\sum_{t} x_{i,t} x_{j,t+1}.\n", + "\\tag{3}\n", + "$$\n", + "\n", + "根据哈密顿回路的定义，$x$ 如果对应一条哈密顿回路需要满足如下的限制：\n", + "\n", + "$$\n", + "\\sum_t x_{i,t} = 1 \\quad \\forall i \\in [0,n-1] \\quad \\text{ 和 } \\quad \\sum_i x_{i,t} = 1 \\quad \\forall t \\in [0,n-1],\n", + "\\tag{4}\n", + "$$\n", + "\n", + "其中第一个式子用来保证找到的 $x$ 所代表的路线中每个顶点仅出现一次，第二个式子保证在每个时间只有一个顶点可以出现。这两个式子共同保证了参数化量子电路找到的 $x$ 是个哈密顿回路。所以，我们可以定义在此限制下的代价函数：\n", + "\n", + "$$\n", + "C(x) = D(x)+ A\\left( \\sum_{i} \\left(1-\\sum_t x_{i,t}\\right)^2 + \\sum_{t} \\left(1-\\sum_i x_{i,t}\\right)^2 \\right).\n", + "\\tag{5}\n", + "$$\n", + "\n", + "其中 $A$ 是惩罚参数，它保证了上述的限制被遵守。因为我们想要在找哈密顿回路的长度 $D(x)$ 的最小值的同时保证 $x$ 确实表示一个哈密顿回路，所以我们需要设置一个大一点的 $A$，最起码大过图 $G$ 中边的最大的权重，从而保证不遵守限制的路线不会成为最终的路线。\n", + "\n", + "我们现在需要将代价函数 $C(x)$ 转化为一个哈密顿量从而完成旅行商问题的编码。每一个二进制变量可以取0和1两个值，分别对应量子态 $|0\\rangle$ 和 $|1\\rangle$。**每个二进制变量都对应一个量子比特，所以我们需要 $n^2$ 个量子比特来解决旅行商问题。** 和最大割问题相似，因为泡利 $Z$ 的两个本征态和我们需要的量子态 $|0\\rangle$、$|1\\rangle$ 一样，这两个本征态所对应的本征值分别是 1 和 -1，所以我们考虑利用泡利 $Z$ 矩阵将代价函数编码为哈密顿量。\n", + "\n", + "我们现在将二进制变量映射到泡利 $Z$ 矩阵上，从而使 $C(x)$ 转化成哈密顿矩阵：\n", + "\n", + "$$\n", + "x_{i,t} \\mapsto \\frac{I-Z_{i,t}}{2}, \\tag{6}\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} |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$ 的基态即为旅行商问题的最优解。在接下来的章节中，我们将展示怎么用参数化量子电路找到这个矩阵的基态，即对应最小本征值的本征态。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Paddle Quantum 实现\n", + "\n", + "要在量桨上实现用参数化量子电路解决旅行商问题，首先要做的便是加载需要用到的包。其中 `networkx` 包可以帮助我们方便地处理图。" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:15.901429Z", + "start_time": "2021-05-17T08:00:12.708945Z" + } + }, + "outputs": [], + "source": [ + "# 加载量桨、飞桨的相关模块\n", + "import paddle\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum import Hamiltonian\n", + "\n", + "# 旅行商问题相关函数\n", + "from paddle_quantum.QAOA.tsp import tsp_hamiltonian # 构造旅行商问题哈密顿量的函数\n", + "from paddle_quantum.QAOA.tsp import solve_tsp_brute_force # 暴力求解旅行商问题\n", + "\n", + "# 用于生成图\n", + "import networkx as nx\n", + "\n", + "# 加载额外需要用到的包\n", + "from numpy import pi as PI\n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "import time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 生成该旅行商问题中的图 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "接下来，我们生成该旅行商问题中的图 $G$。为了运算方便，图中的顶点从0开始计数。" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.212260Z", + "start_time": "2021-05-17T08:00:15.918792Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# n 代表图形 G 的顶点数量\n", + "n = 4\n", + "E = [(0, 1, 3), (0, 2, 2), (0, 3, 10), (1, 2, 6), (1, 3, 2), (2, 3, 6)] # 线段参数(顶点1， 顶点2， 权重(距离))\n", + "G = nx.Graph()\n", + "G.add_weighted_edges_from(E)\n", + "\n", + "# 将生成的图 G 打印出来\n", + "pos = nx.spring_layout(G)\n", + "options = {\n", + " \"with_labels\": True,\n", + " \"font_weight\": \"bold\",\n", + " \"font_color\": \"white\",\n", + " \"node_size\": 2000,\n", + " \"width\": 2\n", + "}\n", + "nx.draw_networkx(G, pos, **options)\n", + "nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=nx.get_edge_attributes(G,'weight'))\n", + "ax = plt.gca()\n", + "ax.margins(0.20)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 编码哈密顿量\n", + "\n", + "量桨中，哈密顿量可以以 ``list`` 的形式输入。这里我们将式（4）中的二进制变量用式（5）替换，从而构建哈密顿量 $H_C$。具体的形式可以通过内置函数 tsp_hamiltonian(G, A, n)直接得到。\n", + "\n", + "**注意：** 对于旅行商问题，由于我们总可以选定某一个城市为第一个抵达的城市，故实际所需量子比特数可以从 $n^2$ 降到了 $(n-1)^2$。在我们接下来的实现当中都会使用改进过的哈密顿量来计算。" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.237497Z", + "start_time": "2021-05-17T08:00:16.219567Z" + } + }, + "outputs": [], + "source": [ + "# 以 list 的形式构建哈密顿量 H_C -- 通过内置函数tsp_hamiltonian(G, A, n)\n", + "A = 20 # 惩罚参数\n", + "H_C_list = tsp_hamiltonian(G, A, n)\n", + "# 生成哈密顿量\n", + "H_C = Hamiltonian(H_C_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 计算损失函数\n", + "\n", + "在最大割问题（[Max-Cut 教程](./MAXCUT_CN.ipynb)）中，我们用 QAOA 构建了我们的参数化量子电路，但除了 QAOA 电路，其他的电路也可以用来解决组合优化问题。对于旅行商问题，我们将使用 $U_3(\\vec{\\theta})$ 和 $\\text{CNOT}$ 门构造的参数化量子电路。这可以通过调用量桨内部的 [`complex entangled layer`](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html) 来实现。\n", + "\n", + " \n", + "
图 1: 旅行商问题使用的参数化电路
\n", + "\n", + "上述电路会给出一个输出态 $|\\psi(\\vec{\\theta})\\rangle$，由此输出态，我们可以计算最大割问题的目标函数，也就是旅行商问题的损失函数：\n", + "\n", + "$$\n", + "L(\\psi(\\vec{\\theta})) = \\langle\\psi(\\vec{\\theta})|H_C|\\psi(\\vec{\\theta})\\rangle.\n", + "\\tag{7}\n", + "$$\n", + "\n", + "然后我们利用经典的优化算法寻找最优参数 $\\vec{\\theta}^*$。下面的代码给出了通过量桨和飞桨搭建的完整网络：" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# 此处使用内置量子电路：complex_entangled_layer()\n", + "def cir_TSP(N: int, DEPTH: int) -> Circuit:\n", + " cir = Circuit(N)\n", + " cir.complex_entangled_layer(depth=DEPTH)\n", + " return cir" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# 定义损失函数\n", + "def loss_func(cir: Circuit, H: Hamiltonian) -> paddle.Tensor:\n", + " state = cir()\n", + " loss = paddle_quantum.loss.ExpecVal(H)\n", + " return loss(state)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 训练量子神经网络\n", + "\n", + "定义好了量子神经网络后，我们使用梯度下降的方法来更新其中的参数，使得式（7）的期望值最小。" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:00:16.274144Z", + "start_time": "2021-05-17T08:00:16.264684Z" + } + }, + "outputs": [], + "source": [ + "DEPTH = 2 # 量子电路的层数\n", + "ITR = 120 # 训练迭代的次数\n", + "LR = 0.5 # 基于梯度下降的优化方法的学习率\n", + "SEED = 1000 #设置随机数种子" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "这里，我们在飞桨中优化上面定义的网络。" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:02:14.495970Z", + "start_time": "2021-05-17T08:00:16.496407Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "循环数: 10 损失: 46.0240 用时: 1.7304351329803467\n", + "循环数: 20 损失: 22.6653 用时: 3.757274627685547\n", + "循环数: 30 损失: 16.6194 用时: 5.594370603561401\n", + "循环数: 40 损失: 14.3720 用时: 7.301747560501099\n", + "循环数: 50 损失: 13.5547 用时: 9.344748735427856\n", + "循环数: 60 损失: 13.1736 用时: 11.30988073348999\n", + "循环数: 70 损失: 13.0661 用时: 13.120512962341309\n", + "循环数: 80 损失: 13.0219 用时: 14.732549905776978\n", + "循环数: 90 损失: 13.0035 用时: 16.409778356552124\n", + "循环数: 100 损失: 13.0033 用时: 18.174597024917603\n", + "循环数: 110 损失: 13.0008 用时: 19.95359969139099\n", + "循环数: 120 损失: 13.0004 用时: 21.790847778320312\n", + "得到最小路程: [13.000355]\n" + ] + } + ], + "source": [ + "# 固定 paddle 随机种子\n", + "paddle.seed(SEED)\n", + "# 记录运行时间\n", + "time_start = time.time()\n", + "\n", + "# 总qubit数取为：(城市数-1)**2\n", + "num_qubits = (len(G) - 1) ** 2\n", + "\n", + "# 创建电路\n", + "cir = cir_TSP(num_qubits, DEPTH)\n", + "\n", + "# 使用 Adam 优化器\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=cir.parameters())\n", + "\n", + "# 梯度下降循环\n", + "for itr in range(1, ITR + 1):\n", + " # 计算梯度并优化\n", + " loss = loss_func(cir, H_C)\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + " # 输出迭代中performance\n", + " if itr % 10 == 0:\n", + " print(\"循环数:\", itr, \"损失:\", \"%.4f\"% loss.numpy(), \"用时:\", time.time()-time_start)\n", + "\n", + "# 显示QNN得到最小路程\n", + "print('得到最小路程:', loss.numpy())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "最理想的情况是我们使用的量子神经网络可以找到最短哈密顿回路，同时最后的损失值应该等于这条回路上的权重之和，即旅行商所需要走的最短长度。但如果最后的情况不是这样，读者可以通过调整参数化量子电路的参数值，即 DEPTH，ITR 和 LR，来获得更好的训练效果。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 解码量子答案\n", + "\n", + "当求得损失函数的最小值以及相对应的一组参数 $\\vec{\\theta}^*$后，我们的任务还没有完成。为了进一步求得旅行商问题的近似解，需要从电路输出的量子态 $|\\psi(\\vec{\\theta})^*\\rangle$ 中解码出经典优化问题的答案。物理上，解码量子态需要对量子态进行测量，然后统计测量结果的概率分布（我们的测量结果是表示旅行商问题答案的比特串）：\n", + "\n", + "$$\n", + "p(z) = |\\langle z|\\psi(\\vec{\\theta})^*\\rangle|^2.\n", + "\\tag{8}\n", + "$$\n", + "\n", + "通常情况下，某个比特串出现的概率越大，意味着其对应旅行商问题最优解的可能性越大。\n", + "\n", + "量桨提供了查看参数化量子电路输出状态的测量结果概率分布的函数：" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:02:14.554317Z", + "start_time": "2021-05-17T08:02:14.500593Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "利用改进后的哈密顿量找到的解的比特串形式： 010001100\n" + ] + } + ], + "source": [ + "# 模拟重复测量电路输出态 1024 次\n", + "state = cir()\n", + "prob_measure = state.measure(shots=1024)\n", + "reduced_salesman_walk = max(prob_measure, key=prob_measure.get)\n", + "print(\"利用改进后的哈密顿量找到的解的比特串形式：\", reduced_salesman_walk)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "因为我们之前为了减少所需要的量子比特数改进了一下旅行商问题对应的哈密顿量，上面显示的比特串缺少了顶点 $n-1$ 的信息，以及所有顶点在时间 $t =n-1$ 的时候的信息。所以我们需要将这些信息加回找到的比特串中。\n", + "\n", + "首先为了加上对于 $i \\in [0，n-2]$， $x_{i,n-1} = 0$ 这一信息，我们需要在每 $(n-1)$ 个比特之后加上一个 $0$。接着在比特串的最后，我们为了加上顶点 $n-1$在每个时间的状态，我们加上包含 $n-1$ 个 '0' 的 '00...01'，用来表示对于$t \\in [0,n-2]$来说，$x_{n-1,t} = 0$，同时 $x_{n-1,n-1} = 0$。\n", + "\n", + "以下代码通过测量，找到了出现几率最高的比特串，每一个比特都包含了式（1）定义的 $x_{i,t}$ 的信息。我们将找到的比特串映射回经典解，即转化成了 ``dictionary`` 的形式。其中 ``key`` 代表顶点编号，``value`` 代表顶点在哈密顿回路中的顺序，即访问城市的顺序。在以下代码中，我们还将量子电路找到的最优解和暴力算法找到的相比较，从而说明量子算法的正确性。" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:02:14.571954Z", + "start_time": "2021-05-17T08:02:14.559634Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "参数化量子电路找到的最优解： {0: 1, 1: 2, 2: 0, 3: 3} ，最短距离为： 13\n", + "经典暴力算法找到的最优解： {0: 0, 1: 1, 2: 3, 3: 2} ，最短距离为： 13\n" + ] + } + ], + "source": [ + "# 参数化量子电路找到的最优解\n", + "str_by_vertex = [reduced_salesman_walk[i:i + n - 1] for i in range(0, len(reduced_salesman_walk) + 1, n - 1)]\n", + "salesman_walk = '0'.join(str_by_vertex) + '0' * (n - 1) + '1'\n", + "solution = {i:t for i in range(n) for t in range(n) if salesman_walk[i * n + t] == '1'}\n", + "distance = sum([G[u][v][\"weight\"] if solution[u] == (solution[v] + 1) % n \n", + " or solution[v] == (solution[u] + 1) % n else 0\n", + " for (u, v) in G.edges])\n", + "print(\"参数化量子电路找到的最优解：\", solution, \"，最短距离为：\", distance)\n", + "\n", + "# 经典暴力算法找到的最优解\n", + "salesman_walk_brute_force, distance_brute_force = solve_tsp_brute_force(G)\n", + "solution_brute_force = {i:salesman_walk_brute_force.index(i) for i in range(n)}\n", + "print(\"经典暴力算法找到的最优解：\", solution_brute_force, \"，最短距离为：\", distance_brute_force)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "以下的代码将字典形式的经典解用图的形式展示了出来：\n", + "* 顶点中的第一个数字代表城市编号\n", + "* 顶点中的第二个数字代表旅行商访问此城市的顺序\n", + "* 红色的边表示找到的最佳路线" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:02:14.864346Z", + "start_time": "2021-05-17T08:02:14.576418Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "label_dict = {i: str(i) + \", \" + str(t) for i, t in solution.items()}\n", + "edge_color = [\"red\" if solution[u] == (solution[v] + 1) % n\n", + " or solution[v] == (solution[u] + 1) % n else \"black\"\n", + " for (u, v) in G.edges]\n", + "label_dict_bf = {i: str(i) + \", \" + str(t) for i, t in solution_brute_force.items()}\n", + "edge_color_bf = [\"red\" if solution_brute_force[u] == (solution_brute_force[v] + 1) % n\n", + " or solution_brute_force[v] == (solution_brute_force[u] + 1) % n else \"black\"\n", + " for (u, v) in G.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(G, pos=pos, labels=label_dict, edge_color=edge_color, ax=ax[0], **options)\n", + "nx.drawing.nx_pylab.draw_networkx_edge_labels(G, pos=pos, ax=ax[0], edge_labels=nx.get_edge_attributes(G, 'weight'))\n", + "nx.draw(G, pos=pos, labels=label_dict_bf, edge_color=edge_color_bf, ax=ax[1], **options)\n", + "nx.drawing.nx_pylab.draw_networkx_edge_labels(G, pos=pos, ax=ax[1], edge_labels=nx.get_edge_attributes(G, 'weight'))\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "上面给出的左图展示了参数化量子电路找到的旅行商问题的最优解，右图展示了经典暴力算法找到的最优解。我们不难看出，即使旅行商访问每个城市的绝对顺序不一样，但路线是一致的，即相对顺序一样。这说明在这个例子中，参数化量子电路找到了旅行商问题的最优解。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 实际应用\n", + "\n", + "旅行商问题可以直接应用在很多交通和物流规划中，例如规划校车接送学生的路线。管理科学领域的先锋 Merrill Flood 在上世纪40年代就受到校车问题的启发，展开了对于旅行商问题的早期研究。更多近期的应用包括了路线规划 [1] 和电线公司对于电力传输的规划 [2]。\n", + "\n", + "除了交通运输问题，旅行商问题同样在管理问题中有很广泛的应用，比如计划机器在电路板上钻孔的顺序 [3]、重构 DNA 上的不明片段 [4] 以及规划最佳建筑路线 [5]。 一些咨询公司，比如 [Nexus](https://nexustech.com.ph/company/newsletter/article/Finding-the-shortest-path-Optimizing-food-trips) 也通过旅行商问题给外界提供管理咨询服务。\n", + "\n", + "同时作为最著名的组合优化问题之一，旅行商问题为很多用于解决组合问题的通用算法提供了测试平台。它经常被作为研究者测试他们提出的新的算法的首选例子。\n", + "\n", + "对于旅行商问题更多的应用和解法，详见 [6]。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Bräysy, Olli, et al. \"An optimization approach for communal home meal delivery service: A case study.\" [Journal of Computational and Applied Mathematics 232.1 (2009): 46-53.](https://www.sciencedirect.com/science/article/pii/S0377042708005438)\n", + "\n", + "[2] Sloane, Thomas H., Frank Mann, and H. Kaveh. \"Powering the last mile: an alternative to powering FITL.\" [Proceedings of Power and Energy Systems in Converging Markets. IEEE, 1997.](https://ieeexplore.ieee.org/document/646046)\n", + "\n", + "[3] Onwubolu, Godfrey C. \"Optimizing CNC drilling machine operations: traveling salesman problem-differential evolution approach.\" [New optimization techniques in engineering. Springer, Berlin, Heidelberg, 2004. 537-565.](https://link.springer.com/chapter/10.1007/978-3-540-39930-8_22)\n", + "\n", + "[4] Caserta, Marco, and Stefan Voß. \"A hybrid algorithm for the DNA sequencing problem.\" [Discrete Applied Mathematics 163 (2014): 87-99.](https://www.sciencedirect.com/science/article/pii/S0166218X12003253)\n", + "\n", + "[5] Klanšek, Uroš. \"Using the TSP solution for optimal route scheduling in construction management.\" [Organization, technology & management in construction: an international journal 3.1 (2011): 243-249.](https://www.semanticscholar.org/paper/Using-the-TSP-Solution-for-Optimal-Route-Scheduling-Klansek/3d809f185c03a8e776ac07473c76e9d77654c389)\n", + "\n", + "[6] Matai, Rajesh, Surya Prakash Singh, and Murari Lal Mittal. \"Traveling salesman problem: an overview of applications, formulations, and solution approaches.\" [Traveling salesman problem, theory and applications 1 (2010).](https://www.sciencedirect.com/topics/computer-science/traveling-salesman-problem)" + ] + } + ], + "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.8.13" + }, + "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 +} diff --git a/tutorials/combinatorial_optimization/TSP_EN.ipynb b/tutorials/combinatorial_optimization/TSP_EN.ipynb new file mode 100644 index 0000000..bcfb344 --- /dev/null +++ b/tutorials/combinatorial_optimization/TSP_EN.ipynb @@ -0,0 +1,609 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Travelling Salesman Problem\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview\n", + "\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}$. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Use QNN to solve TSP\n", + "\n", + "To use QNN to solve travelling salesman problem, we need to first encode the classical problem to quantum. \n", + "The encoding consists of two parts:\n", + "\n", + "1. The route how the salesman visits each city is encoded in quantum states -- ${\\rm qubit}_{i,t} = |1\\rangle$ corresponds to salesman visiting city $i$ at time $t$. \n", + " 1. As an example, if there are two cities $\\{A,B\\}$, visiting $A$ then $B$ will be in state $|1001\\rangle$, as the salesman visits the city $A$ at time $1$ and the city $B$ at time $2$.\n", + " 2. Similarly, $|0110\\rangle$ means visiting $B$ then $A$.\n", + " 3. Note: $|0101\\rangle$ means visiting $A$ and $B$ both at time $2$, so it is infeasible. To avoid such states, a penalty function will be used (see the next section for details.)\n", + "\n", + "2. The total distance is encoded in a loss function: \n", + "\n", + "$$\n", + "L(\\psi(\\vec{\\theta})) = \\langle\\psi(\\vec{\\theta})|H_C|\\psi(\\vec{\\theta})\\rangle,\n", + "\\tag{1}\n", + "$$\n", + "\n", + "where $|\\psi(\\vec{\\theta})\\rangle$ is the output state from a parameterized quantum circuit. \n", + "\n", + "The details about how to encode the classical problem to quantum is given in detail in the next section. \n", + "After optimizing the loss function, we will obtain the optimal quantum state. Then a decoding process will be performed to get the final route." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Encoding the TSP\n", + "\n", + "To transform the TSP into a problem applicable for parameterized quantum circuits, we need to encode the TSP into a Hamiltonian. \n", + "\n", + "We realize the encoding by first constructing an integer programming problem. Suppose there are $n=|V|$ vertices in graph $G$. Then for each vertex $i \\in V$, we define $n$ binary variables $x_{i,t}$, where $t \\in [0,n-1]$, such that\n", + "\n", + "$$\n", + "x_{i, t}=\n", + "\\begin{cases}\n", + "1, & \\text {if in the resulting Hamiltonian cycle, vertex } i \\text { is visited at time } t\\\\\n", + "0, & \\text{otherwise}\n", + "\\end{cases}.\n", + "\\tag{2}\n", + "$$\n", + "\n", + "As there are $n$ vertices, we have $n^2$ variables in total, whose value we denote by a bit string $x=x_{1,1}x_{1,2}\\dots x_{n,n}$. Assume for now that the bit string $x$ represents a Hamiltonian cycle. Then for each edge $(i,j,w_{i,j}) \\in E$, we will have $x_{i,t} = x_{j,t+1}=1$, i.e., $x_{i,t}\\cdot x_{j,t+1}=1$, if and only if the Hamiltonian cycle visits vertex $i$ at time $t$ and vertex $j$ at time $t+1$; otherwise, $x_{i,t}\\cdot x_{j,t+1}$ will be $0$. Therefore the length of a Hamiltonian cycle is\n", + "\n", + "$$\n", + "D(x) = \\sum_{i,j} w_{i,j} \\sum_{t} x_{i,t} x_{j,t+1}.\n", + "\\tag{3}\n", + "$$\n", + "\n", + "For $x$ to represent a valid Hamiltonian cycle, the following constraint needs to be met:\n", + "\n", + "$$\n", + "\\sum_t x_{i,t} = 1 \\quad \\forall i \\in [0,n-1] \\quad \\text{ and } \\quad \\sum_i x_{i,t} = 1 \\quad \\forall t \\in [0,n-1],\n", + "\\tag{4}\n", + "$$\n", + "\n", + "where the first equation guarantees that each vertex is only visited once and the second guarantees that only one vertex is visited at each time $t$. Then the cost function under the constraint can be formulated below, with $A$ being the penalty parameter set to ensure that the constraint is satisfied:\n", + "\n", + "$$\n", + "C(x) = D(x)+ A\\left( \\sum_{i} \\left(1-\\sum_t x_{i,t}\\right)^2 + \\sum_{t} \\left(1-\\sum_i x_{i,t}\\right)^2 \\right).\n", + "\\tag{5}\n", + "$$\n", + "\n", + "Note that as we would like to minimize the length $D(x)$ while ensuring $x$ represents a valid Hamiltonian 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 TSP. Each variable $x_{i,j}$ 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 TSP.** Similar as in the Max-Cut problem, we consider the Pauli $Z$ operator as it has two eigenstates, $|0\\rangle$ and $|1\\rangle$. Their corresponding eigenvalues are 1 and -1, respectively.\n", + "\n", + "Now we would like to consider the mapping\n", + "\n", + "$$\n", + "x_{i,t} \\mapsto \\frac{I-Z_{i,t}}{2}, \\tag{6}\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}|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 quantization 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" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Paddle Quantum Implementation\n", + "\n", + "To investigate the TSP using Paddle Quantum, there are some required packages to import, which are shown below. The ``networkx`` package is the tool to handle graphs." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:24:17.197426Z", + "start_time": "2021-05-17T08:24:12.896488Z" + } + }, + "outputs": [], + "source": [ + "# Import related modules from Paddle Quantum and PaddlePaddle\n", + "import paddle\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum import Hamiltonian\n", + "\n", + "# Functions for Salesman Problem\n", + "from paddle_quantum.QAOA.tsp import tsp_hamiltonian # Get the Hamiltonian for salesman problem\n", + "from paddle_quantum.QAOA.tsp import solve_tsp_brute_force # Solve the salesman problem by brute force\n", + "\n", + "# Create Graph\n", + "import networkx as nx\n", + "\n", + "# Import additional packages needed\n", + "from numpy import pi as PI\n", + "import matplotlib.pyplot as plt\n", + "import random\n", + "import time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate a weighted complete graph" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, we generate a weighted complete graph $G$ with four vertices. For the convenience of computation, the vertices here are labeled starting from $0$." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:24:24.302458Z", + "start_time": "2021-05-17T08:24:24.060967Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# n is the number of vertices in the graph G\n", + "n = 4\n", + "E = [(0, 1, 3), (0, 2, 2), (0, 3, 10), (1, 2, 6), (1, 3, 2), (2, 3, 6)] # Parameters for edges: (vertex1, vertex2, weight(distance))\n", + "G = nx.Graph()\n", + "G.add_weighted_edges_from(E)\n", + "\n", + "# Print out the generated graph G\n", + "pos = nx.spring_layout(G)\n", + "options = {\n", + " \"with_labels\": True,\n", + " \"font_weight\": \"bold\",\n", + " \"font_color\": \"white\",\n", + " \"node_size\": 2000,\n", + " \"width\": 2\n", + "}\n", + "nx.draw_networkx(G, pos, **options)\n", + "nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=nx.get_edge_attributes(G,'weight'))\n", + "ax = plt.gca()\n", + "ax.margins(0.20)\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Encoding Hamiltonian\n", + "\n", + "In Paddle Quantum, a Hamiltonian can be input in the form of ``list``. Here we construct the Hamiltonian $H_C$ of Eq. (4) with the replacement in Eq. (5). It can be realized with a build-in function \"tsp_hamiltonian(G, A, n)\".\n", + "\n", + "**Note:** For the salesman problem, the number of qubits can be reduced to $(n-1)^2$ since we can always select city $0$ to be the first city." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:24:25.956145Z", + "start_time": "2021-05-17T08:24:25.950463Z" + } + }, + "outputs": [], + "source": [ + "# Construct the Hamiltonian H_C in the form of list -- with build-in function tsp_hamiltonian(G, A, n)\n", + "A = 20 # Penalty parameter\n", + "H_C_list = tsp_hamiltonian(G, A, n)\n", + "# Generate the Hamiltonian\n", + "H_C = Hamiltonian(H_C_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Calculating the loss function \n", + "\n", + "In the [Max-Cut tutorial](./MAXCUT_EN.ipynb), we use a circuit given by QAOA to find the ground state, but we can also use other circuits to solve combinatorial optimization problems. For the TSP, we adopt a parametrized quantum circuit constructed by $U_3(\\vec{\\theta})$ and $\\text{CNOT}$ gates, which we call the [`complex entangled layer`](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html).\n", + "\n", + " \n", + "
Figure 1: Parametrized Quantum Circuit used for TSM Problem
\n", + "\n", + "After running the quantum circuit, we obtain the output state $|\\psi(\\vec{\\theta})\\rangle$. From the output state of the circuit we can calculate the objective function, and also the loss function of the TSP:\n", + "\n", + "$$\n", + "L(\\psi(\\vec{\\theta})) = \\langle\\psi(\\vec{\\theta})|H_C|\\psi(\\vec{\\theta})\\rangle.\n", + "\\tag{7}\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." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# In this tutorial we use build-in PQC: complex_entangled_layer()\n", + "def cir_TSP(N: int, DEPTH: int) -> Circuit:\n", + " cir = Circuit(N)\n", + " cir.complex_entangled_layer(depth=DEPTH)\n", + " return cir" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:24:26.790290Z", + "start_time": "2021-05-17T08:24:26.768068Z" + } + }, + "outputs": [], + "source": [ + "# Define the loss function\n", + "def loss_func(cir: Circuit, H: Hamiltonian) -> paddle.Tensor:\n", + " state = cir()\n", + " loss = paddle_quantum.loss.ExpecVal(H)\n", + " return loss(state)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training the quantum neural network\n", + "\n", + "After defining the quantum neural network, we use gradient descent method to update the parameters to minimize the expectation value in Eq. (7). " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:24:27.958085Z", + "start_time": "2021-05-17T08:24:27.952965Z" + } + }, + "outputs": [], + "source": [ + "DEPTH = 2 # Number of layers in the quantum circuit\n", + "ITR = 120 # Number of training iterations\n", + "LR = 0.5 # Learning rate of the optimization method based on gradient descent\n", + "SEED = 1000 # Set a global RNG seed " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, we optimize the network defined above in PaddlePaddle." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:26:08.098742Z", + "start_time": "2021-05-17T08:24:28.741155Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 10 loss: 46.0240 run time: 2.0117030143737793\n", + "iter: 20 loss: 22.6653 run time: 3.6998016834259033\n", + "iter: 30 loss: 16.6194 run time: 5.470264673233032\n", + "iter: 40 loss: 14.3720 run time: 7.512751579284668\n", + "iter: 50 loss: 13.5547 run time: 9.417967319488525\n", + "iter: 60 loss: 13.1736 run time: 11.14768385887146\n", + "iter: 70 loss: 13.0661 run time: 13.029551029205322\n", + "iter: 80 loss: 13.0219 run time: 14.56725525856018\n", + "iter: 90 loss: 13.0035 run time: 16.211774110794067\n", + "iter: 100 loss: 13.0033 run time: 17.93900489807129\n", + "iter: 110 loss: 13.0008 run time: 19.850960731506348\n", + "iter: 120 loss: 13.0004 run time: 22.275184869766235\n", + "The final minimum distance from QNN: [13.000355]\n" + ] + } + ], + "source": [ + "# Fix paddle random seed\n", + "paddle.seed(SEED)\n", + "# Record run time\n", + "time_start = time.time()\n", + "\n", + "# Total qubits number: (city number-1)**2\n", + "num_qubits = (len(G) - 1) ** 2\n", + "\n", + "# Create the circuit\n", + "cir = cir_TSP(num_qubits, DEPTH)\n", + "\n", + "# Use Adam optimizer\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=cir.parameters())\n", + "\n", + "# Gradient descent iteration\n", + "for itr in range(1, ITR + 1):\n", + " # Calculate the gradient and optimize\n", + " loss = loss_func(cir, H_C)\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + " if itr % 10 == 0:\n", + " print(\"iter:\", itr, \" loss:\", \"%.4f\"% loss.numpy(), \"run time:\", time.time()-time_start)\n", + " \n", + "# The final minimum distance from QNN\n", + "print('The final minimum distance from QNN:', loss.numpy())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that ideally the training network will find the shortest Hamiltonian cycle, and the final loss above would correspond to the total weights of the optimal cycle, i.e. the distance of the optimal path for the salesman. If not, then one should adjust parameters of the parameterized quantum circuits above for better training performance." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "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 TSP, it is necessary to decode the solution to the classical optimization problem from the quantum state $|\\psi(\\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, where a measurement result is a bit string that represents an answer for the TSP: \n", + "\n", + "$$\n", + "p(z) = |\\langle z|\\psi(\\vec{\\theta})^*\\rangle|^2.\n", + "\\tag{8}\n", + "$$\n", + "\n", + "Usually, the greater the probability of a certain bit string, the greater the probability that it corresponds to an optimal solution of the TSP.\n", + "\n", + "Paddle Quantum provides a function to read the probability distribution of the measurement results of the state output by the quantum circuit:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:26:08.152206Z", + "start_time": "2021-05-17T08:26:08.103516Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The reduced bit string form of the walk found: 010001100\n" + ] + } + ], + "source": [ + "# Repeat the simulated measurement of the circuit output state 1024 times\n", + "state = cir()\n", + "prob_measure = state.measure(shots=1024)\n", + "reduced_salesman_walk = max(prob_measure, key=prob_measure.get)\n", + "print(\"The reduced bit string form of the walk found:\", reduced_salesman_walk)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As we have slightly modified the TSP Hamiltonian to reduce the number of qubits used, the bit string found above has lost the information for our fixed vertex $n-1$ and the status of other vertices at time $n-1$. So we need to extend the found bit string to include these information.\n", + "\n", + "We need to add a $0$ after every $(n-1)$ bits to represent $x_{i,n-1} = 0$ for $i \\in [0, n-2]$. Then at last, we need to add the bit string representation for vertex $n-1$, i.e. '00...01' with $n-1$ 0s to represent $x_{n-1,t} = 0$ for all $t \\in [0,n-2]$. \n", + "\n", + "After measurement, we have found the bit string with the highest probability of occurrence, the optimal walk in the form of the bit string. Each qubit contains the information of $x_{i,t}$ defined in Eq. (1). The following code maps the bit string back to the classic solution in the form of `dictionary`, where the `key` represents the vertex labeling and the `value` represents its order, i.e. when it is visited. \n", + "\n", + "Also, we have compared it with the solution found by the brute-force algorithm, to verify the correctness of the quantum algorithm." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:26:08.169372Z", + "start_time": "2021-05-17T08:26:08.156656Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The walk found by parameterized quantum circuit: {0: 1, 1: 2, 2: 0, 3: 3} with distance 13\n", + "The walk found by the brute-force algorithm: {0: 0, 1: 1, 2: 3, 3: 2} with distance 13\n" + ] + } + ], + "source": [ + "# Optimal walk found by parameterized quantum circuit\n", + "str_by_vertex = [reduced_salesman_walk[i:i + n - 1] for i in range(0, len(reduced_salesman_walk) + 1, n - 1)]\n", + "salesman_walk = '0'.join(str_by_vertex) + '0' * (n - 1) + '1'\n", + "solution = {i:t for i in range(n) for t in range(n) if salesman_walk[i * n + t] == '1'}\n", + "distance = sum([G[u][v][\"weight\"] if solution[u] == (solution[v] + 1) % n \n", + " or solution[v] == (solution[u] + 1) % n else 0\n", + " for (u, v) in G.edges])\n", + "print(\"The walk found by parameterized quantum circuit:\", solution, \"with distance\", distance)\n", + "\n", + "# Optimal walk found by brute-force algorithm for comparison\n", + "salesman_walk_brute_force, distance_brute_force = solve_tsp_brute_force(G)\n", + "solution_brute_force = {i:salesman_walk_brute_force.index(i) for i in range(n)}\n", + "print(\"The walk found by the brute-force algorithm:\", solution_brute_force, \"with distance\", distance_brute_force)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, we draw the corresponding optimal walk in the form of graph representation suggested to the salesman:\n", + "* The first number in the vertex represents the city number.\n", + "* The second number in the vertex represents the order the salesman visits the corresponding city.\n", + "* The red edges represent the found optimal route for the salesman." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2021-05-17T08:26:08.431841Z", + "start_time": "2021-05-17T08:26:08.172882Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1MAAADnCAYAAAD7CwxiAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABbnElEQVR4nO3deViU5foH8O/7MsMuuCAqSiC4oLki5N5ipbmkLS7lyRYVqU6nzu9Up+W0nazTcqrTenLcKjUzw2OauS8pqamISwruoCAqIAoCwzDL+/vjCWQc1GGZeWf5fq7LK8BZbhLmnvt57+d+JEVRFBAREREREVGdyGoHQERERERE5I5YTBEREREREdUDiykiIiIiIqJ6YDFFRERERERUDyymiIiIiIiI6oHFFBERERERUT2wmCIiIiIiIqoHFlNERERERET1wGKKiIiIiIioHlhMERERERER1QOLKSIiIiIionpgMUVERERERFQPLKaIiIiIiIjqgcUUERERERFRPbCYIiIiIiIiqgcWU0RERERERPXAYoqIiIiIiKgeWEwRERERERHVA4spIiIiIiKiemAxRUREREREVA8atQMgsofFouBkUTmyCktRYbTAaLZA6yPDXyujfVgwopoHQpYltcMkIiJyOuZIIvWwmCKXZLEo2Hq8EBsP5WNXdhGO5pdCliRoZAkKFCgKIEmABAkmiwKLoqBjeDASo5tjSFw4BsaGMXEQEZFHYo4kch2SoiiK2kEQVSnWG7E4LQezUk+gzGBCeaUZdfkBlQAE+vogyE+DpMExGJ8QidAAraPCJSIichrmSCLXw2KKXIK+0ox3VmXi+7QcSBJQYbQ0+DEDtDIsCjAhIRIvDe+CAF+fRoiUiIjIuZgjiVwXiylS3c6sIjz1XTpK9EZUmBqeIK7kr5EREqDFFxPjkRjdvNEfn4iIyFGYI4lcG4spUo3BZMb0FRlISc9tlFW26/HXyhgb3w6vjuoKPw1X4IiIyHUxRxK5BxZTpIoygwkPzdmBzDMlDllpuxp/jYyuESGYP7kvgvw4f4WIiFwPcySR+2AxRU5XZjBhrG4bThSUweDEJFHFTyMjpmUQUpIHMFkQEZFLYY4kci88tJecymAy46E5O1RLEiIGC04UlGHS3B0wmMyqxEBERHQl5kgi98Niipxq+ooMZJ4pUS1JVDGYLMjIK8H0FZmqxkFERFSFOZLI/bCYIqfZmVUkNtKqnCSqVJgsSEnPwa7sIrVDISIiL8ccSeSeWEyRU+grzXjqu3SnTCSqiwqjBX9emA59JVsZiIhIHcyRRO6LxRQ5xb9WZaJEb1Q7jFqV6I14ZzVbGYiISB3MkUTui8UUOVyx3ojFaTku07pwpQqTBd/vykGxiyYyIiLyXMyRRO6NxRQ53OK0HEiS2lFcmywBP6TlqB0GERF5GeZIIvfGYoocymJRMCv1hMv1gV9Jb7RgZuoJWCw8do2IiJyDOZLI/bGYIofaerwQZQaT2mHYpdRgwrYT59UOg4iIvARzJJH7YzFFDrXxUD7K3WQKkN5oxsZD+WqHQUREXoI5ksj9sZgih9qVXQR3aQpQFGBXNlfdiIjIOZgjidyfRu0AyHNZLAqO5pfaddvJA6Mxrk8kOrVqAh9Zwsfrj+DjDUfr9HzP3tkJt8eFo13zQABA5pkS/HvNYaSdvGD3Yxw5VwpFUSC5+m5gIiJya87OkaN7RmDKoPbo0joEvhoZKbtz8FzK/jo9BnMkkS1emSKHOVlUDtnOF9xubUNRrDfiTLG+3s93b++2kCQJq34/i7yLevRt3wJfPZqI8CZ+dj+GLEk4eb683jEQERHZw9k5Mq51E5gtCk6eL6v3YzBHEtnilSlymKzCUmhk+xLF3xbvAwDMfKgP2jULrNfzPb1oL9JPiatQgb4+2PXyHWjir0XvG5phzcGzdj2GRpaQVViG6LCgesVARERkD2fnyPfXHAYAvDaqKzq2alKvx2COJLLFK1PkMBVGCxQndoNXFVIAIAHQ+IgkdbYOK3kKgAqTe2wGJiIi9+XsHNkYmCOJbLGYIocxmi1QVMgTPrKED8b1hJ/GByv252FfbrHd91UUBZUuego9ERF5DrVyZEMwRxLZYpsfOYzWR3b6qe7+Whn/ndgHQ+LCseHQuerWCHtJkgRfDdcYiIjIsdTIkQ3FHElki8UUOYy/VoYE52WK0AAt5j6SiD5RzbAkPRd/X7If5jqe1i4B8Nf4OCZAIiKiPzg7RzYG5kgiWyymyGHahwXDZGcxMyEhEonRzXBj21AAwNCurdCuWQDWZpzD2oxzGBvfDh+M64mMvGKM+OzXWh9jzsMJ6BPVDBfLK1GiN+IfI7oAADYfKcDmIwV2xWGyKGjPjbVERORgzs6RQ7u2wtCurdCzXVMAQEJ0c3wwtgd2ZV/A92k5dsXBHElki8UUOUxU80BY7GwIT4xuhrF9Iqs/7xoRiq4Roci9oMfajHPVrRDXSjytQ/0BAE0DffHYwPbVXy/RG+0upiyKgqgW9ZuUREREZC9n58iubUKsHiO6RRCiW4jCyN5iijmSyBaLKXIYWZbQMTwYB/JKrnvb51L2X/PwwLjWYozrjM3Hr3qbQe9vqnuQV+jUKpiHERIRkcM5O0d+vOFonQ/6vRJzJJEt7iIkh0qMbt4oHeEDYsOwfN9prDxg33lR9SFJQGJ0C4c9PhERUU3MkUTuj1emyKGGxIVjcVoOyiobdi7F8E9TGymiqwvQ+mBIXLjDn4eIiAhgjiTyBLwyRQ41MDYMQX7uUbOXXijE0hnv4siRI2qHQkREXsCdcmTFpYs4vm0V9Hq92qEQuRQWU+RQsiwhaXAM/LUu/qNmqsTF35bgow8/ROfOnTFkyBAsXrwYlZWVakdGREQeyl1ypMVYgcJfv8ejjzyMtm3b4v/+7/9w6NAhtcMicgmu/dtLHmF8QqTLn/Lu5++PHz96AZMnT0ZAQAA2bdqECRMmIDIyEi+++CJOnDihdohEROSB3CFHBgQE4q3JI9GnTx9cuHABH3/8Mbp06YJbb70V3333HQwGg9ohEqmGxRQ5XGiAFhMSIuHvoqem+2tkTEiMxJBB/TBnzhzk5eXhs88+Q7du3ZCfn4/33nsPsbGxGDp0KP73v//BaDSqHTIREXkId8mRTz8+FWlpaUhLS0NSUhKCgoKwefNmTJw4Ee3atcPzzz+Po0cbNi2QyB1JiuLq6yHkCfSVZtzywSbkX3K91atWIX745dnbEOBrfaq7oijYvn07dDodFi9ejIqKCgBA69atMWXKFCQlJSEqKkqNkImIyIO4Y44sKSnBt99+C51Oh3379lV//fbbb0dycjLGjBkDX19fZ4dL5HQspshpdmUXYdLcHagwWtQOpZq/VsaCyX2REN38mrcrKirCvHnzoNPpqvvEJUnCXXfdhccffxwjRoyARuMem4iJiMj1uGuOVBQFO3fuhE6nw6JFi6oHVISHh2Py5MlISkpCTEyMs0ImcjoWU+RUr/z4O1J256LCpH6y8NfIGNsnEm/d083u+yiKgtTUVOh0OqSkpFQPqGjbti2mTp2KqVOnol27do4KmYiIPJi758iLFy9i/vz50Ol0OHjwIACx8Dh06FAkJydj1KhR0Gq1jgqZSBUspsipDCYzHpz1Gw7mlcCgYrLw08i4MSIE3yX1g5/G5/p3qEVhYSG+/vprzJw5s7pPXJZljBo1CsnJyRg2bBh8fOr32ERE5H2qc2TuRRhUrKcamiMVRcG2bduq2+SrBlS0adOmuk3+hhtuaOywiVTBYoqcrqzCiLGv/oATij8MWj+nP7+fRkZMyyCkJA9olPM9FEXBpk2boNPpsHTp0uoBFTfccAOSkpIwZcoUtGnTpsHPQ0REnq8s8wjG/mcDToS08ogcef78+eo2+cOHDwMQV6tGjBiB5ORkjBgxgguP5NZYTJHzvfkmyt56B5MefBsZ7Tqjwomrb/4aGV0jQjB/cl+HHJR47tw5fPXVV5g5cyaysrIAAD4+PhgzZgySk5Nxxx13QJZdc2ITERGpLD8fGDAAZadOY1LyZ8ho2tapLX+OzJGKomDLli3VbfJVC4/t2rWrbpNv27Ztoz4nkTOwmCLnmjMHmDoVkGUYfliC6XIHpKTnOGXDrb9Wxtj4SLw6qku9W/vsZbFYsH79euh0OixbtgxmsxkAEBMTg6SkJDz22GNo1aqVQ2MgIiI3UloK3HYbkJYG9OkDw7oNmL45xyNzZEFBQXWb/LFjxwCIhceqNvmhQ4fyahW5DRZT5Dw//wyMGQOYzcCXXwKPPw5ATDD688J0lOiNDlmB89fICAnQ4ouJ8Ui8ztQ+R8jLy8PcuXMxa9YsnDp1CgCg1Wpx7733Ijk5GbfddhskSXJ6XERE5CKMRmD0aGD1aiAmBti2Dfhjwc2Tc6TFYsHGjRuh0+nw448/wmQyAQCioqIwbdo0TJ48Ga1bt3ZqTER1xWKKnGPHDrHiptcDr7wCTJ9u9df6SjPeWZ2J73flQJYAfSOswgVoZVgUYEJiJF66q4vNGRnOZjabsWbNGuh0OqxYsQIWi/geO3bsiOTkZDzyyCMICwtTNUYiInIyRQEeewz45hsgLEwUUh07Wt3EG3Lk2bNnq9vks7OzAQAajaa6Tf72229nmzy5JBZT5HhHjgADBwKFhSJhzJkDXOVKTLHeiB/ScjAz9QRKDSbojWbU5SdUslgQIFkQHBKEaYNjMC4hEqEBrjeGNScnB3PmzMHs2bNx+vRpAICvry/Gjh2L5ORkDB48mFeriIi8wSuvAG+/DQQGAps2ATfddNWbNkqO9NMg2F/rsjnSYrFg7dq10Ol0+Omnn6rb5GNjYzFt2jQ8+uijCA8PVzlKostYTJFjnT0LDBgAZGUBw4cDy5YBdpwxYbEo2Hq8EJsOF2Bn1nkczS+FLEnQyBIUiI2skiRBAmCyKLAoCjoFAonr/4ch5bkY8OvPkH1cfwXLZDJh5cqVmDFjBlavXo2qX8cuXbogOTkZDz/8MJo1a6ZylERE5BBffgk8+STg4yPy48iRdt2tXjny0jkk/r4VQ0b1x4BnHoMsu/6C3enTp6vb5HNycgCINvn77rsPycnJuPXWW7nwSKpjMUWOc+kScOutQHo6kJAgVtyCg+v1UBaLglNF5cgqLEOFyYxKkwW+Ghn+Gh+0DwtCVItASBYL0KYNUFAA/P470M3+gwZdQXZ2NmbPno05c+bg7NmzAAB/f3+MHz8eycnJ6N+/P5MGEZGnWLoUuP9+0eY3Zw4weXK9H8quHPn11+I5hg0Te7PciNlsxqpVq6DT6bBy5crqNvnOnTtj2rRpeOSRR9CiRQuVoyRvxWKKHKOyErj7bmDtWqBDB2DrVsAZl+UnTwa++gp46y3gH/9w/PM5gNFoxPLly6HT6bBu3brqr3fv3h3Jycl46KGHEBoaqmKERETUIL/+CtxxB2AwAG++Cbz6quOfs6BADLXQaETbfUiI45/TAU6dOlXdJp+XlwcA8PPzq26THzRoEBceyalYTFHjUxTgkUeA+fOBli2B7duB2FjnPPePPwL33it6znfscM5zOtDx48cxa9YszJ07FwUFBQCAwMBAPPDAA0hOTkZiYiKTBhGRO8nIAAYNAi5cAJKTRaufs17HBw0Si5uLFwPjxjnnOR3EZDJhxYoV0Ol0WLNmTXWbfNeuXZGcnIxJkyaxTZ6cgsUUNb4XXwTeew8ICgJ++UW0+DlLWZmYhlRRAZw+DUREOO+5HaiyshJLly6FTqfDpk2bqr/eq1cvTJ8+HSNHjrxqUbVu3Tr06tULLVu2dFa4RERUm9Ongf79gZwcMQp9yRJxpchZ/v1v4O9/B/70J2DBAuc9r4NlZWVVt8mfO3cOgGiTnzBhAj799FOEXOMqHHMkNRSLKWpcn30GPP20SA4//QTcdZfzYxg9Wjz3jBli1c/DHDlyBDNnzsTXX3+N8+fPY8WKFRg+fLjNyNht27Zh0aJFyMnJQUZGBuLj4/HFF1+geXPnn7VFROT1iouBwYPFnt7+/YH168UEP2c6cgTo3Blo2hTIz7drIJQ7MRqNWLZsGXQ6HdavX4/o6GhkZGQgICDA5rbMkdRYWExR40lJAcaPF21+X38tWv3UMGcOMHUqMGKEOCjYQ1VUVODnn3/GqFGj4OfnZ/V3FosFw4YNw4QJEzB16lQAwA8//IBbbrmFI2WJiJzNYBCLi7/8IoqZrVsBtQYmxMUBhw8DGzeK8x891LFjx3D69Gn069ePOZIcyvVnR5N72LIFeOghUUi9/bZ6hRQAjBol+s83bABKS9WLw8H8/f1x//332yQJAFi5ciUuXLiAsrIy/PrrrwCAcePGcdoREZGzWSwiJ/7yC9C6tZikp+Zr8Zgx4r/LlqkXgxN06NABt9xyC3MkORyLKWq4gwfFi7PBIM7LeOkldeNp1Qro10/Es2aNurGoZM6cOQgICEBYWBheeOEFzJw5EwDg46PuCfdERF7nueeA778HmjQBVq0CoqPVjadmMeWlzUnMkdSYnLjrkTxSTo5oXbh4UUzR+/RT500lupYxY8QUweXLxTkeXiYzMxMpKSno1q0bAgMDsXnzZpSXlyMwMBCVlZXIyclBrLMmLBIReasPPwT+8x+xN2npUqBXL7UjAvr2FZN2s7OBAweA7t3VjsjprpUj8/LyEBoaiqCgILXDJDfBK1NUfxcvAsOHA7m5wMCBwLffilPcXcHo0eK/K1YAJpO6sTjZqVOn0KNHD3T749Dipk2bIjs7u3ps7L59+9ChQwfcfPPN+Pbbb1FRUaFmuEREnum778RVKQD45hvg9tvVjaeKj484BxLw+Fa/2lwrR5aUlGDKlClo27Yt/vKXv+DAgQMqR0vugMUU1U9Fhbj6c/Ag0KWLuAJUy7Qc1cTFAR07AkVFYqOvF7nhhhsQGRmJoUOH4s0338SCBQvQr18/BAUFwWw2Y+/evQgODkZqaioeeughtGvXDs899xyOHDmiduhERJ5hw4bLe4c/+AB48EF147mSl+ybqs21cqSvry9KSkpQXFyMzz//HN27d8fAgQMxb9486PV6tUMnF8VpflR3ZjPwwANiel9EhGinu+EGtaOy9fzzIon97W+i1cLL/Pjjj9i4cSMefvhh3HjjjVajYS9duoSFCxdCp9Nhz5491V+/7bbbkJycjHvvvRe+vr5qhE1E5N727gVuvhm4dAn461+Bjz5yjfb3msrLxZmMer3oLmnbVu2InO5aOXLfvn3Q6XRYsGABLl26BABo1qwZHnnkESQnJyMuLk6tsMkFsZiiulEU4JlnxHlSISHAr7+6br91aqpIaLGxwNGjrpfMXICiKEhLS4NOp8N3332H8vJyAEDLli0xefJkJCUlcW8VEZG9srPFGVJnzwITJgALFwKyizYBjRkjukq+/BJ4/HG1o3FJpaWlWLRoEXQ6HdLS0qq/fvPNNyM5OfmqE3XJu7CYorp5/33ghRcAX18x3tWVz6gwm8UY2sJCscn2xhvVjsilFRcXY8GCBdDpdPj999+rv37nnXciOTkZo0ePhtbDDngkImo058+L/cOHDwO33ipypCu/0Z47F5gyRQyRWrVK7Whc3u7du6HT6bBw4UKUlZUBAMLCwvDoo49i2rRp6Nixo8oRklpYTJH9FiwAJk0SHy9aJFbdXN1jj4kDhN9+G3j5ZbWjcQuKomD79u3Q6XRYvHhx9YCK1q1bY8qUKUhKSkJUVJTKUdafxaLgZFE5sgpLUWG0wGi2QOsjw18ro31YMKKaB0KWeRWTiOpArxcDJrZvF90aqalAaKjaUV3buXNAmzZi0mBhoRjdTtdVUlKChQsXYsaMGdi3b1/114cMGYLk5GTcc889btsmz/xYPyymyD7r1gEjRojJeP/5j+gDdwdLlwL33SdGwf72m9rRuJ2ioiLMnz8fOp0OmZmZAABJknDXXXchOTkZI0eOhEbj2icsWCwKth4vxMZD+diVXYSj+aWQJQkaWYICBYoiOkAlSDBZFFgUBR3Dg5EY3RxD4sIxMDaMyYOIrs5kAsaOFcMcbrgB2LbNffYgDRwo4v3hB/E9kN0URcHOnTuh0+mwaNGi6gEV4eHh1W3yMTExKkd5bcyPjYPFFF1fejpwyy1AaakY8/rvf6sdkf3KysQm24oKIC9PrMJRnSmKgtTUVOh0OqSkpKCyshIA0LZtW0ydOhVTp05Fu3btVI7SWrHeiMVpOZiVegJlBhPKK82oy4udBCDQ1wdBfhokDY7B+IRIhAawzZGIalAU4IknAJ0OaNZMTI/t0kXtqOxX1br/0EPA/PlqR+O2Ll68iAULFmDGjBk4ePBg9deHDh2K5ORk3H333S7VJs/82LhYTNG1ZWWJzbTnzgETJ4oXW1fdTHs1d98tzpvS6YBp09SOxu0VFhbim2++gU6nw9GjRwEAsixj5MiRSE5Oxl133aXqKfL6SjPeWZWJ79NyIElAhdHS4McM0MqwKMCEhEi8NLwLAnxd5Dw1IlLXW28Br74K+PuLDo5Bg9SOqG4OHRLFX7NmIs+70Bt+d6QoCrZt21bdJm8wGAAAbdq0wZQpUzB16lRV2+SZHx2DxRRdXWEhMGCAmIR3++3AypVi8IS7mTVLFFEjR4qiihqFoijYtGkTdDodli5dCqPRCECc4ZGUlIQpU6agjZOvBO7MKsJT36WjRG9EhanhSeJK/hoZIQFafDExHonRzRv98YnIjVQNcJAkYMkS4N571Y6ofjp3Bo4cATZtEoMzqFGcP38e8+bNg06nw+HDhwGINvkRI0YgOTkZI0aMcOrCI/Oj47CYotqVlYkCascOoGdPYMsWMQrdHZ09K87D8vUVBWJwsNoReZz8/Hx89dVXmDlzJk6cOAEA8PHxwZgxY5CcnIw77rgDsgOvaBpMZkxfkYGU9NxGWWm7Hn+tjLHx7fDqqK7w03jfKhyR1/v5ZzFa3GwGvvgCePJJtSOqv7//XbTv//WvYk80NSpFUbBly5bqNvmqhcd27dpVt8m3deAeO+ZHx2MxRbZMJrHCtmIFEBUlphO5+16j/v3FAIolS8RACnIIi8WC9evXQ6fTYdmyZTCbzQCAmJgYJCUl4bHHHkOrVq0a9TnLDCY8NGcHMs+UOGS17Wr8NTK6RoRg/uS+CPJz7SEcRNSIdu4Ux4KUl4spsW+/rXZEDbN1q2hPbN8eOH6cZzI6UEFBAb7++mvMnDkTx44dAyAWHkeNGoXk5GQMHTq0Ua9WMT86B4spsqYooiVu9mygeXPxIusJJ32/845Ieo88Ikalk8OdOXMGc+fOxaxZs3Dy5EkAgFarxb333ovk5GTcdtttkBqYtMsMJozVbcOJgjIYnJgoqvhpZMS0DEJK8gCvSBhEXu/oUdH+Xlgo8slXX7l/8WE2iwXTggLg99+Bbt3UjsjjWSwWqzZ5k8kEAIiKikJSUhImT57c4DZ55kfnYTFF1t54A/jnP8Vm2g0bRNLwBBkZ4tDeFi1E25+Lj/P2JGazGWvWrIFOp8OKFStgsYgX9Y4dO2LatGl49NFHERYWVufHNZjMeGDmb8g4U6JKoqjip5FxY0QIvkvq5zUtDURe6dw50eWQlSUOul2+3HMGNkyeLArDt94C/vEPtaPxKmfPnq1uk8/OzgYAaDSa6jb522+/vc5t8syPzsViii6rGtQgy+J8ptGj1Y6o8SgK0KkTcOwYsHkzcPPNakfklXJzczFnzhzMnj0bubm5AABfX1+MHTsWycnJGDx4sN1Xq1758Xek7M51auvC1fhrZIztE4m37uGKLpFHunRJDGdITwcSEsSwBk/af7tsGXDPPUBiomhjJKezWCxYt24ddDodli9fXt0mHxsbW90mHx4ebtdjMT86F4spEn76SbyQWizAjBlAcrLaETW+554DPvwQePZZ4IMP1I7Gq5lMJqxcuRI6nQ6rVq1C1ctQly5dMG3aNDz88MNo3vzq04B2ZhXh4a92OGUzrb38tTLmT+7rdVOMiDye0SiO2FizBoiNFYfc2vmm1m3UPJPx9GkxtIlUk5eXhzlz5mDWrFnIyckBINrk77vvPiQnJ+PWW2+96sIj86PzsZgiMZhhyBBArxfnZbz5ptoROcaWLeLw4Q4dxBhYd+9z9xAnT57E7NmzMXv2bJw9exYA4O/vj/HjxyM5ORn9+/e3Shr6SjNu+WAT8i8Z1Ar5qsKb+GHzc7d55TkbRB5JUYBHHwXmzQNathSFVIcOakflGKNHi4VVT11QdUNmsxmrV6+GTqfDzz//XN0m36lTp+o2+RYtWlTfnvlRHW52+io1usOHgVGjRCE1ZYrYL+WpBgwQe6aOHQMyM9WOhv4QFRWF6dOn49SpU1iyZAmGDh2KiooKzJs3DwMHDkSPHj3w+eefo7i4GADwr1WZKNEbVY66diV6I95ZzZ8tIo/xj3+IQiowUIxD99RCChCj3gHR8kcuwcfHByNHjsTy5cuRnZ2N1157DREREThy5Aiee+45tG3bFg899BBSU1OhKArzo0p4ZcqbFRUBffoA2dnAiBHiBdTTBzM8+ijwzTdiut+LL6odDV3F8ePHMWvWLMydOxcFBQUAgICAAIyd+DC2t7obLtS9YMNPI2Pny3cgNMBDNqYTeSudDnj8ccDHR1yxGT5c7Ygc69w5MdVPqwXOn/esPWEexGQy4eeff8aMGTOwZs2ay23yPfvAMPx1mF34Oomn5kfX/T9OjhcYKNr7broJWLzY8wsp4PJQDa68ubTY2Fi8++67yM3Nxffff48hQ4ZAr9fjx/3nYKioUDu8a5Il4Ie0HLXDIKKGMJtFfmzdWhwV4umFFAC0agX06wdUVor9YeSSqib9rVq1CidOnMDLL7+MVq1aIdc3EsbKSrXDuyZPzY+8MuXtystFT3hQkNqROEdpqdhkW1kJ5OWJRElu4dDhw7jnq4OokPzUDuW6wpv44bcXb4csc18ekduqrBTDJ7wlPwLAe++Jro1Jk0R7I7kFg6ESiW+vQYnR9a+ReGJ+dP3/69RgmZmZyM/Pr964aCUw0LsSRXAwcMcdooBcsULtaKgOCuTm8PELVDsMu5QaTNh24rzaYRDRdVwzP/r6ihzpTaq6N37+GfjjIFlyfTtPFcMsuUfrnCfmRxZTHm769Ol45plncP/992PBggVqh+Ma2OrnljYeykd5pVntMOyiN5qx8VC+2mEQ0TXYlR+9beprXBzQsaPYU711q9rRkJ2YH9XlBZtkvFfVGT6bN2/GypUrsXjxYgwfPhwtW7ZUOzR13X23GPu6fr04W8Obrsy5sV3ZRbCnJ/mde7sjIaoZIpoGoNJswd6ci/jXykwczS+1+7kkCXhmSEdMSIxE8yBfHM8vxftrD+OXwwV23V9RgF3ZnrXyRuRJmB+vQpLEVL8PPhALjrfconZEZAd78yPQODny78M6Y3TPCLQM9kOFyYLDZy/hP+uPYLsdV5w8MT/yypSHslgsyMzMxKeffgqtVguLxYK0tDRMmjQJr7/+OtLT09UOUT1t2gB9+4rDCdetUzsasoPFotj9Qv/gTTeg1GDC8n15KK0w4bbO4Zg3+Sb4aex/uXv85lj89Y5OMJkVrNh/BrEtgzF7UgI6hts/3erIuVJwSyqR62F+vI6q7o3ly8U7X3JpdcmPQOPkyMhmgdiXW4zFu3NxqqgcN7VvjrmPJCJAa98ZUp6WH3llykPJsoyPP/4YAFBcXIwPP/wQn3/+OeLi4jB37lx8/fXXiI+PVzdINY0eDezYIVbe7rlH7WjoOk4WlUO2s93mvi+3If3UBQBAu6YB+PWFIWgTGoAO4cE4mFdy3fv7yBKSBscAAJ74djcO5JXg9EU9nh7SEck3x+C5lP12xSFLEk6eL0d0GK98ErkS5sfrGDBADGo6fhzIyABuvFHtiOga6pIfgYbnSAD4y6I91R+HBmix77WhCPD1QViwL3Iu6K97f0/Lj7wy5QVCQ0OxatUq3HnnnYiMjMSUKVOQnZ2NwsJCtUNTT9XhhCtWiBG45NKyCkuhsXPyT1WSAADtHyttZoti94nwbUL90TzIF2aLggN/JJbfc8WBwV3bhNgds0aWkFVYZvfticj5mB9r4eMDjBolPubeYpdXl/wINDxHVhndMwL/HH0jFkzpCwBYsT/PrkIK8Lz8yGLKCyiKguAah+/pdDr4+/sjLCxMxahU1rUrEBsLFBYC27erHQ1dR4XRAsXujnAh0NcHH4ztCQCYlXoCBXYmipbBYvS63ni5yC6vFFOtWjaxfyy7AqDCxEKdyJUxP15FzVY/cmn1yY9A/XNklZs7huGR/tHo3jYUF8srkXrU/gUIT8uPLKY8VWWlOEMKgCRJkCQJRqMR06dPx6ZNmzjZT5I41c+NGM2WOrXuNwvUYuHUfugT1QwLd57Cu6sP2X3fglKRUAK0PtWDvIL8REd0XZKNoiioNNUybpmI1GcwACYT8+PVDB0K+PuLdvgzZ9SOhq6hrvkRaFiOrPJcyn50fGUlxum2QZYlvHd/D/SJambXfT0tP7KY8kQVFeIspS++APSXL7maTCbExcVh6dKl8PX1VTFAF1HV6rdsGTfZujitj2z3hOK2TQOQ8vgA9Ipsiv/+cgwvL/29Ts91prgCF8or4SNL6N42FADQo11TAEDm2Ut2P44kSfCtw4ZeInKS9euB7t1FkfBHmzfz4xWCgsT7CAD46Sd1Y6Frqkt+BBqeIzWyBF8fkduMZgW7si8gv0QsNMbYuQfK0/Kj53wnJJjNwEMPAampwCefiMLqDwEBARg3bhxHv1YZOBBo3hw4ehQ4fFjtaOga/LUyJNiXLZY8PgCxLYORe6Ec/lofvDaqK14b1RU924nCaGx8O2S/MxIr/zKo1vubLQpmpZ4AAPx3Yjw+HNcTSYPaw2S2QLfluN0xSwD8NfZNNiIiJ9mzB7j3XvG6P2uW2B8E5sdasdXPLdQlPwINz5GtQ/yx8+Xb8d+J8Zg+phuWPjEAHcKDoa80Y2d2kV0xeFp+5DQ/T6IowF//CixZAoSGAqtWAc3su+TqlTQascl23jxxdSouTu2I6EqFhcCOHWj/216YDDcCPtc/4b11qD8AoF2zQEwe2L766xl5JdiXW1y9gmeyXP1q5IzNx+Gv9cH4PpG4u0cEjheU4t9rD+PIOfvHz5osCtp7yKQiIo+QlQWMGAGUlgIPPAC88YbaEbm2u+8WLfHr14v/Z8H2Hw1BTmA2AxkZaJ+aBlNFc0Cy7y19Q3PkJYMJ+3IvIjG6OUIDtCjWV2LjoXx88csxnDxfblcMnpYfWUx5kvfeAz7/HPD1BX78UbQx0LWNHg0cOwbccIPakVBFhVg13rlT9Onv2AGcEFeIoiDB8mwKYMdCVvRLP1/z7+NaNwEgCqarsSjAR+uO4KN1R+yP3+YxFES1CKz3/YmoERUWAnfdBZw9C9x2G/D114DM5pxrat0auPNOoFUrccA9iyl1nT4t8mJVjkxLA0pLL+dHrX1v6RuaI4v1Rjzy1a66xX4FT8uPLKY8xbx5wEsviVWkBQuAW29VOyL3cN99IlkEBKgdiXexWESbTc3Cad8+wGi0vl1gINCnD+S+fdExRIsD9i16XdOA2DAs33caKw+cbfiDXUOnVsGQ6tLITkSOUV4urrIcOQL06AEsXQr42T+Z06v9/LPYe92kidqReJfSUmD37sv5cccOUUxdKSpK5McABQdMjfPUzsiRnpYfWUx5gjVrgClTxMcffwyMG6dqOG5FkoAQ+88OonoqKLAunHbuBC5etL6NJInDIfv2FX9uugno1k20YwJI/OkgDm7LrscAWGvDP01t4CNcnyQBidEtHP48RHQdJpNo6fvtN9GBsGqVaIMn+2g0LKQc7Y92PavC6eBBsehYU0iIyItV+bFvX3HVEI2XHwHH50hPzI8sptzd7t3A/feLhPH888DTT6sdEXm7qna9mokhK8v2dm3aWCeFhIRrFrZD4sKxOC0HZZWufzZFgNYHQ+LC1Q6DyLspCvDkk2IaXbNmwOrVQESE2lGRt6tq16v6k5Ym2ihr0miAXr0u58e+fYHOna/amsr8qC4WU+7sxAmxmbasDPjTn4B331U7IvI2Ve16NRPDvn2iuK8pMFAUSzUTQ7t2qMs814GxYQjy07hFsmjip8GAGM9aeSNyO9Oni4l9/v7AihVAly5qR0TeprRUFEs1uzJqa9eLjrbOj/Hxddp+wPyoLhZT7qqgABg2DMjPF2dBzJ3LzbSNTFEUHDp0CD/99BP+/ve/qx2OaygosE4K9rTr9e0rPtc07OVGliUkDY7Bh+sOo8Louof9BWhlJA2OgSx7Tj84kduZPRt4/XWRF7/7DhgwQO2IPArzYy3MZtGeV3NIxPXa9aq6M/5o16sv5kd1sZhyR2VlYqT3sWPiMvCSJWKCH9Wb2WyGj8/lUXGKokCSJISHh+N///sf+vXrh5tvvlnFCFWg19tO17tWu17Vn4QEh/XYj0+IxAdrXftMMIsCjEuIVDsMIu+1YgXw+OPi4y++AO65R9Vw3B3z41Xk5tpO17tau17NHNmpk0MWv5kf1cNiyt2YTMCECeKXNzpabKblAIUGe+utt3DkyBG89tpr6Ny5MyRJgsFgQIsWLfDAAw9g0aJFnp0s6tquV3NFrY7teg0RGqDFhIRILE7LQYXJ9Vbf/DUyxidGIjTg+udhEZED7NgBjB8vrhK88srloorqzevzI2DbrrdjB5CXZ3u76Gjrwql3b6dNC2Z+VA+LKXeiKEByshhV2qKF2EzburXaUXkEi8WCdevWQf5jtejuu+/G+PHjUVJSgnPnzqFNmzYqR9jIarbr7dgB7NpVe7tet27WhVMjtOs11EvDu2D173kumSxCA7V46S7uyyBSxZEjwMiR4qr6Y48Bb76pdkQewevyY812vao/GRm27XqhodbT9RqhXa+hXhreBasPnkXFJYOqcdTGk/OjpChKY0xSJGd4/XWRHAICgI0bgX791I7IYxw/fhxJSUnYuHEj5s2bh59//hkZGRmIioqCoij45JNP0KFDB7XDrJ+qdr2aiSE72/Z2ERG20/VccSRuejp2TXsek279Myq0rnNWjL9WxoLJfZEQ3VztUIi8z9mzYl9UVhYwfDiwbBmg9bwVcDV4dH4ELrfrVf3Zvbv2dr2ePa33OjmoXa9BzGbseuV9TDJ2Zn50IhZT7kKnE+0Ksgz8+KM4gJAaVbdu3fDjjz+iQ4cOqKysRGZmJrRaLSIjI9HEFYuK2lgsYnW25pAIe9r1qqbrubpvvhG/BxUVeGXSG0i5IREVZvVfwvw1Msb2icRb93RTOxQi73PpkjioPj0dSEwENm0CgoLUjsqjeER+BMTPSlW7XtVeJxdr16u38+eBiROBtWvxyrAnkdL7LlRA/WLPG/Ijiyl3sHw5cO+94o3yzJlAUpLaEXmkb775Bp07d0Y/d7ril59vnRR27gSKi61vU9t0va5dVW/Xq5PKSuBvfxObyQFg2jQYPvoYD85Lx8G8EhhUbPnz08i4MSIE3yX1g5/G5/p3IKLGU1kpFhfXrgU6dAC2bgXCPesMG1fglvnRZKp9ut6Vb3trtutVdWe428/Q3r3ifWJ2NhAWBsOi7/HgET/mRydhMeXqtm8Hbr9dtGq9/jrwxhtqR+SxzGYzZFmGZDKJwtXPdS6RAxA/A+np1tP1rtWuV/WnTx/XbNez15kzwLhx4k2Sr68oqKZOBQCUGUwYq9uGEwVlqiQMP42MmJZBSEkegCA/NypOiTyBogCPPALMny/e/G7bBsTGqh2VR6rOj5IkhjEEBTlt8JBdFKX26Xrl5da3q2rXq5kjO3Z0vXa9uvj2W7HIrteLjpMlS4AbbmB+dCIWU67s0CFg4ECgqEi8eZw507VevDyRwSBWrlq2BCJVHN95Zbvejh3A/v227XpBQbVP1/MU27YBY8eKgqptW5Ek+va1ukmZwYRJc3cgI6/EqUMp/DUyukaEYP7kvh6fKIhc0osvAu+9J14Hf/lFvBaSY+XmigFGnTuLdnG11GzXq/pz5ozt7dq3t86P7tCuZy+jEXj+eeCTT8TnkyeLxUZ//+qbMD86B4spV3XmDNC/P3DypDhTaulS92rLcleKIgoZHydfjq5q16s5Xe/Kdj1ZvtyuV9WS4G7tevZSFGDGDOCZZ0TCuOUW4PvvrzopyWAyY/qKTKSk5zjlwEJ/rYyx8ZF4dVQXj25dIHJZn30GPP20eP376SfgrrvUjsg7GI3OH+xRs12v5nS9K9++Nm1qO13P3dr17HXunDgCYMsW8e/x6adi2nMtC+7Mj47HYsoVlZQAN98sBgf07Qts2MDNtJ6kql2vZmI4edL2dm3b2k7XCw52frzOVlEBPPEE8PXX4vO//hV4/327Eviu7CL8eWE6SvRGh6zC+WtkhARo8cXEeCR66FQiIpeXkiLeSCqKeJ145BG1I6LGUrNdr+Z0vdra9Xr1st7r5O7tevb67Tfg/vvF4IyICPH70L//de/G/Og4LKZcTWUlMGKEKKA6dhT7RFq2VDsqqi+LBTh82Hq6nj3ten37imLK25w6Bdx3n0ieAQHA7NliOlEd6CvNeGd1Jr7flQNZAvSNsBIXoJVhUYAJiZF46a4uCPD1jtU2IpezZQswdKhoyX77beDll9WOiBri0iXRiVEzR9bWrhcTY1049e5t1c7mNWbOBP7yF/FecdAg4Icf6nTeKPOjY7CYciUWCzBpErBwoWhn2r5d9PuS+zh3znoD7PXa9WpO13N2a6Gr2bgRmDABKCwUP/dLl4qNwvVUrDfih7QczEw9gVKDCXqj2aYr5FokCQjQ+iDYT4Npg2MwLsEzT24nchsHDog3kMXFwJNPAp9/zn3E7sRkEv+GNXPk9dr1qrozvH1R2WAAnnpKLDAC4uMPPxRDmeqB+bFxsZhyJc8/D3zwgWjl2rwZiI9XOyKvcuHCBWzduhVbt27FTTfdhDFjxlSf+F6r8nLb6XrXaterOV3PG9r17KUoIim88IJYUBg2TCwoNG+cNgGLRcHW44XYdLgAO7PO42h+KWRJgkaWoABQFAWSJEECYLIosCgKOrUKRmJ0CwyJC8eAmBaQZb5hI1JVTo44lDc3V4yA/uEHLkA5UZ3zo6KIf7Oa+bG2dj2t1na6XocO3tGuZ6+cHDGIaedOcTVOpwMefrhRHpr5sXGwmHIVH38M/N//iT7glSuBO+9UOyKvYjAYkJSUhIKCAgwePBgbNmzAxIkTMWXKlMs3KisTCbzmdD2z2fqBgoLEoZE1V9S8sV3PXmVlwJQpYrgEAPzjH8A//+nQN0kWi4JTReXIKixDhcmMSpMFvhoZ/hoftA8LQlSLQDH+l4hcw4ULwODBYgjBwIHAunWeM5HNDdiVHxUF2LMHWLPmco48e9b2wWJirAunXr28s13PXps3i6NBCgqAqCjgf/9z6EI782P9eOAYMDf0/feikAKAr75iIaUCSZLw8ssvIy4uDgDQsmVL7NmzB+Xl5QisGv9qMgGPPXb5TrIM9OhhO12Pq6X2OXZMrDAfOCDOwfrmG/G5g8myhOiwIESHcagLkcurqADuuUcUUl26iEPsWUg5lV35sbJSdBR8+OHlOzZrdnmqHtv16kZRxMjz554Ti7Z33AEsWgS0aOHQp2V+rB8WU2rbtOny5dr33gMeekjdeLyUr68v4uLiYLFYIMsyIiIi8M0331xOFOJGYvRo1coa2/Xq7+efgT/9Sex9iIsT+6P+SNRERADEm8hJk8TQiYgIYPXqRmv/JfvZlR/9/MSEuYoK6+l6vIpRd+Xl4hDehQvF5y+8IIatcKHWZbHNT02//y4205aUiOksn3zCFx5Hs1jEYcj5+eLF/iornA8++CBGjBiBSZMmOTlAD2exAG+9Bbzxhlh5u/deMdo4JETtyIjIlSiKOGfus8/E68OvvwLdu6sdlecrKRGDk3r3vmrhyvzoQCdOiLy4f7/YNvD112K/FLk0XplSy6lT4pDBkhLxi/Kf/7CQcoSzZ22n65WUiGlxBw7UepdVq1ahuLgYw4cPd3KwHq64WFyFXb5c/Ky//Tbw4ovcaExEtv79b1FI+foCy5axkHIEk0ks6tbMkZmZopCdMweYPNnmLsyPDrR6tTgK5MIFcVVv6VIx+ZdcHospNRQViUIqL08czjt/Pi/fNoaq6Xo1D/s7dcr2du3aiQ2cGusf/6oWhkWLFuGVV15BWFgYzGYzZFnmhsuGysgQq21Hjog++oULxe8AEdGV5s8XrU1VH996q6rheARFEfnwyul6er317bRaMRRCqwWMxurD0pkfHUhRgHfeAV55RXx8993i5z40VO3IyE4sppxNrwdGjxarPzfeCPz4IyfZ1EdVu17Nwun3322n6wUH207Xi4io9SFlWcYXX3yBNWvWQKvV4oUXXkDHjh3x0UcfoWnTpo7/njxVSgrw6KNicl/PnmIaUUyM2lERkStat+7yFZH//AcYP17deNxVVbtezRx57pzt7WJjrfPjVabrMT86SEmJyI9Ll4qOjX/+UxRV7NhwKyymrsJiUXCyqBxZhaWoMFpgNFug9ZHhr5XRPiwYUc0D6z5b32wWm+63bhVXR1avFqv0dH1V7XpVf3btEien1yTL4s16zcP+unSx+6qfoiiorKxEnz59cPPNN+Pxxx9HfHz8tc/SoKszm8Wo8/feE59PnAjMmgXU3LRMRG7HIfkREJ0F990n2s+eew74618bPXaPVLNdr+rPoUO2h+E2a2Y9ffamm4CwMLuegvnRAQ4dEh0bhw6Jq1DffguMHKl2VFQPHEDxh6qDyzYeyseu7KIrDi5ToChi0UCCVH1wWcfwYCRGN8eQuHAMjA27dvJQFHFi9X//K073Tk0FunVz2vfnVsrLRftBVVLYubP2dr3ISOvCqU8fsWGT1Hf+PPDAA8D69aKY/eADsZmc7SBEbsfh+REQG+8HDBBXTyZOFG1OfKNuq6pdr2Z+vFa73pWH4fI12DX8+KPYQ3zpkngvuHSp+Pcht+T1xVSx3ojFaTmYlXoCZQYTyivNqMv/EAlAoK8Pgvw0SBocg/EJkQgN0Nre8J13gJdfFuND164Ve6VItOtlZlpvgLWnXa9vX6BNG+fGWqN/nK6hanX55EkgPBxYvBi45Ra1oyKiOnJafiwsFIXU0aPA7beLg+t9fRvr23BvxcWX2/WqcuT12vWqDsP183NenCaTWDhjsXZtZjPw2mvAv/4lPh8/Xgz74DErbs1riyl9pRnvrMrE92k5kCSgwmhp8GMGaGVYFGBCQiReGt4FAb5/tJd9843oiZUk8cbSm8dcnjljO12vtna97t2tE0NcnHpDOsxmUSCkpgJ/+5s6MbiLefPEWVwVFeKq4ZIloqWViNyGU/NjWZkooHbsEG3aW7Z471EJRqNYTKw5JKK2dr3mza27Mm66yeGHuV6VooiCLyVF/PslJqoThzsoKhJXXdesEe9z3nsPePZZFqAewCuLqZ1ZRXjqu3SU6I2oMDU8SVzJXyMjJECLLybGI/HQTmDUKPGG/NNPxXlS3uLKdr0dO4CcHNvbRUZaF07x8a7VrpebK2IMCBDta1c5m8qrGY2i0Pz8c/H51KniY2eujBJRgzk1P7YLEXtGVqwAoqKA7dud33GgFkURV+9rFk7p6bbter6+1u16N93keu16//d/wMcfA88/D7z/vtrRuKZ9+8TPelaW2Kf2/ffAkCFqR0WNxKuKKYPJjOkrMpCSntsoK23X4+8DjN2zBq+u+RJ+zz0LvPuuw59TNWaz7XS9Awds2/WaNLncrle1suYOyTMhQRSGy5eLsaV0mV4PDB0qDtX09RVFVFKS2lERUR04PT9qZYwtOYZXP/8b/EJDgG3bgM6dHf68qqnZrlfVnVFbu16HDrbT9Vx9UeqXX4DbbgM6dQIOH1Y7GtezahVw//0iV/bpIyba3nCD2lFRI/KaYqrMYMJDc3Yg80yJQ1bbrsbfaEBXyyXM/9dEBPl70H6bqna9qj9pabbtej4+ol2vZjuCmu16DTF9uuhznjIFmD1b7WhUkZubi/DwcPheuZehrEysSC5fLlo9+vVTJ0AiqhdV82NBFuZP7Y+gwQOc9rwOV9Wud+V0vSs1b247XU+tdr2GMJnE/tgLF8Qe6Lg4tSNSRa050mIRewK7dhULsf/9L7tbPJBXFFNlBhPG6rbhREEZDE5MFFX8NBJiWgYjJXkAgvzccBp9Wdnldr2qlgR3bNdriP37RT94eLgoJL1sytTzzz+PjIwM6HQ6tG3b1vaQxooK0dbZvLk6ARJRvaieHyUFMa1D3Dc/VrXr1Syc0tPFa2JNvr5A797Wi4uxsa7VrtcQkyYBCxaIfUB//7va0TjdNXOkwSAKzVatPOffm6x4fDFlMJnxwMzfkHGmRJVEUcVPI+PGiBB8l9QPfhoXvjJjNttO17teu17Vipo7tOvVl6IA7duLpLltG9C/v9oROc0///lPbNu2DT/88ANCvHVjOJEHYn6sh4sXbafr5efb3q5mu17fvmIxztXb9RoiJQUYN05MZdy6Ve1onIo5ktxwGahupq/IQKbKiQIADCYLMvJKMH1FJt66x4XOl8rLs94Ae7V2vSvPq+jc2T3b9epLkoAxY8QQkWXLvKqY0mg0eO211xASEoLU1FQoioLWrVujU6dOaodGRA3A/HgdRqPoSrhyut6VWrSwvuKUmOie7XoNMWyYuPq2fbvYC9aqldoROQ1zJHl0MbUzq0hsplU5UVSpMFmQkp6DMb0ikBitQjtUzXa9qj+5uba3u+EG6ytOffoAgYHOj9fVVBVTy5d79jCRK2RmZqJp06a4ePEiXn/9dXTt2hV6vR7Dhg3D1KlT1Q6PiOqB+fEKigJkZ9tO17tau17NxcWYGLZvNWkiptOtXg38/DMwebLaETkNcyR5bJufvtKMWz7YhPxLBrVDsRHexA+bn7vt8jkbjlCzXa/mdD3LFYkzJMR2ul7r1o6Ly50ZjWLP1MWLwJEjQMeOakfkFLt378YTTzyByMhIzJ8/H76+vli3bh3mzZuHTz/9FC1btlQ7RCKqA6/Pj4B1u15Vy15t7XodO1rnR09v12uIGTOAJ54ARo8WHRxegjmSPPbK1L9WZaJEb1Q7jFqV6I14Z3Um3hzdiO0MeXm20/VKS61v4+NjuwE2Ls7rhinUm1YLjBgBLFwoEsVzz6kdkVP06tUL48ePx2uvvYaLFy8iIiICUVFR0Gq1aOFtrSxEHsDr8mNVu17NHFnbCO8WLWyn63Gojv3uvlsUU+vWiYFEXtLRwhxJHnllqlhvxE3/Wq96H/i1+Glk7Hz5DoQG1GNcemmpdbvezp3Xb9ermq7nJS9uDrN4MTBhAjB4MLBli9rROJbFUl1oGwwGPP300zh58iQ+/vhjvPLKK2jWrBlmzJgBH2/aO0fk5jw+P1a169XMj2zXc57ERLGYu2yZuELlqRRFjITXip9R5kjv5pHF1KzUE/hw3WGnHDxYXwFaGc/e2RlTB8dc+4ZmM5CRYd3Hfb12vaoVNbbrNb6SEnF6udksNtmGhakdkWOsWgV89x3w5ZdW4+3fffddlJWVwWQy4Z133lExQCKqD4/Kj4Bo16vKj1X/LSiwvV1Vu17N6XpXnplHDffWW8Crr4o9U3PmqB2NY5SXiytwTz8tztKs8XPEHOmdPK6YslgU9Ht3g0v2gl8pvIkffnvxdshyjZWw06dtp+vV1q7Xo4ftdD226znHsGHA2rXAV18Bjz6qdjSNy2IB3n4beP11sfK2dKkYvMHVWiK35/b5sbLSdrretdr1ak7XY7uec/z+u3h/0rKlOJPR067KZGUB990H7N0rjkvJzOQeOvK8PVNbjxeizGBSOwy7lFaYsG3pRgw6XqNl7/Rp2xtGRVlfcWK7nrrGjBHF1PLlnlVMFRcDjzwi2jMkSawwjh7NQorIQ7hVfjSYsG3rAQw6fdB6up7hikLQz8+6Xe+mm9iup6Zu3YDo6MutlgMGqB1R41m7FnjgAXEAb4cOYrGRhRTBA4upjYfyUV5pvv4NXYDeYMTG/y7BoI2zL38xJEQkg5pDIrzovAa3MHo08Oc/A2vWAHo9EBCgdkQNl5EB3HuvmFLYtKkYsjF8uNpREVEjcqv8WGHExjc+tc6PANCpk3XhxHY911J1JuMnn4iFOU8ophRFHIfyj3+Ij0eNAubPF7mSCB5YTO3KLoI9fYt+GhkvDe+CUT3aINhPgwOni/HWykzszblo93ON7hmBKYPao0vrEPhqZKTszsFzKfvtvr8iy9jVORHopGG7njtp105cHUxPBzZsEC+s7mzJEnGFrbRU9H8vXQrExqodFRE1MnvzI9A4OVKSgGeGdMSExEg0D/LF8fxSvL/2MH45XMuepisosoxd7XuKCaps13MvNYup995TO5qGuXRJdGwsXSo+f/114LXX+D6NrHjUT4PFouBofun1bwjgtVFd8eiAaBSWGrA24yzib2iG+ZNvQrNA+6cHxbVuArNFwcnzZfUNGUdaREL573/Fm9kuXfgL6i7GjBH/Xb5c3TgawmwGXnoJGDtWFFIPPihOr2chReRx6pIfgcbJkY/fHIu/3tEJJrOCFfvPILZlMGZPSkDH8GC77n+kTSyUFSvEm9dhw1hIuYtBg8RVm8OHa9/T5i4OHxZXP5cuBUJDgZ9+At54g+/TyIZH/UScLCqHbEefdIsgX4zrEwmzRcGfZu/A04v24sd9p9HEX4tH+kfb/XzvrzmM+77chtRjhfWOWZYknDxfXu/7k0qqiqmffrKdrOgOzp8XK77vvis2CH/0EfDtt1aT+4jIc9ibH4HGyZE+soSkP6bxPfHtbjz7wz7oUk9A4yMj+WY7pvSB+dFtabXAyJHiY3ddcFy2TFwJPXQIuPFGccCzu3ehkMN4VDGVVVgKjXz9ZNGpVRP4amTkXdTjfFklAOD33GIAQNc2IQ6N8UoaWUJWYf2vbJFKevQQg0HOnhWTpdzJnj1AQoLYTNuyJbB+PfB//8cN20QezN78CDROjmwT6o/mQb4wWxQcyCup12MwP7qxqgXHZcvUjaOuzGYx2v2ee0SL37hxwG+/idH6RFfhUcVUhdECxY6O8LBgsVm1rPLyVKOqTbktmzh3MosCoMLkHhuCqQZJunwgoTutvC1YIDYEZ2eLVbfdu4Fbb1U7KiJyMHvzI9A4ObJlsLid3ng5v5X/8Xj2PgbzoxsbNkxcodq2rfZzv1zRhQvi6tNbb4lWvvffB77/Hgi2ry2VvJdHFVNGswX2nJpVWCpW2oJ8L8/fCPITZyEUOPn8DUVRUOnCJ9HTNbjTypvRCDzzDDBpElBRAUyZAmzZAkRGqh0ZETmBvfkRaJwcWVAqbheg9am+6B3kp6nTYzA/urGQEGDIEDH9bsUKtaO5vv37RcfG6tXinLK1a4Hnn2fHBtnFo4oprY9s18/90fxLqDRZENE0oHoFrke7pgCAzLMlDozQliRJ8NV41D+D97j5ZrEpNSMDOHZM7Wiu7uxZ4PbbgU8/FSuFOh0wezbg7692ZETkJPbmR6BxcuSZ4gpcKK+Ejyyhe9vQKx7jkl2Pwfzo5txlwfG774D+/YETJ8Sk3t27Rc4kspNHvUr5a2VIuH62KCytREp6LnxkCd9O6YfPHuiN0T0iUGow4ZvtJwEAY+PbIfudkVj5l0FXfZyhXVvhg7E9MLhDGAAgIbo5PhjbAxMS7F/tlwD4azzshHBvodWKIQ6A67b6/fYb0KcPkJoKRESIq1HTpqkdFRE5mb35EWicHGm2KJiVegIA8N+J8fhwXE8kDWoPk9kC3ZbjdsXB/Ojm7r5b/HftWnEmo6sxmYC//Q2YOBEoLxcj0H/9VeyHJqoDjzpnqn1YMEwW+/oY/vnTQZjMFozs3gbRLVphT85FvL0yA0V/bLatWsG71uN1bROCsX0uF07RLYIQ3UJMQ/s+LceuOC6VleHLf/8TB3t3QUJCAnr27IkATzgE1luMGSNWtZYtEy/KrmTmTOCpp0SL3+DBwOLFQOvWakdFRCqoS34EGidHzth8HP5aH4zvE4m7e0TgeEEp/r32MI6cs29Ee0lpKV5/9gms6d4Rffr0QUJCAqKjoyGx9co9tGsnFvN27xaDjqqKK1eQnw9MmAD88gug0YhzsZ54gm19VC+SotjbRe36LBYFXV5fDUMj9Fi/OrILpgyKwZPf7sbKA2cbIbraWYwG5Hx4f/XnPj4+uPHGG5GQkFD9p0ePHvDzc+5gDLJTcbGYiGc2A+fOAWFhakck9kT95S+ilQ8Ann4a+OADcSWNiLxSY+ZHwDk58sr8CADNmze3yo99+vRBZGQkCyxXNX26OCdsypTLOUltu3YB990H5OaKBcaUFGDgQLWjIjfmUcUUAIz6LLV6DGtDrHp6MI7mX8LTi/Y2PKhriGmqwdgmx5GWloa0tDRkZGTAbLaeXqTVatG9e/fqlbmEhAR069YNvr6+Do2N7DR0KLBuHfDNN8DDD6sbS06OOIR3506xJ2rWLOChh9SNiYhcQmPlR8A5ObJzywD8uUMpdu/ejbS0NOzatQsFtUyGa9mypVWBlZCQgIiICIfFRXWwbx/QqxcQHg6cOaP+gbdz5gBPPglUVorJtj/8IFrgiRrA44qpf/50EF9vy7ZzAKy6JAl4bEB7vDaqa/XXysvLsW/fvuriKi0tDZmZmbjyn8nX1xc9e/a0KrC6du0KLa8+ON8XX4h2uvvuA5YsgcWi4GRRObIKS1FhtMBotkDrI8NfK6N9WDCimgdCtvO8lzr55Rdg/HgxhjY6Gvjf/4DevRv/eYjILbl7flQUBbm5udW5sarIOn/+vM39W7dubXMFqzXbnJ1PUYD27YGTJ8WY9P791cmRBoOYaKvTic+feAL4+GOAi9LUCDyumEo9WoDHF+xGWaXrn00R6OuDmZMSMKjDtVvDSktLsXfvXqsC6/Dhwza38/f3R69evaoTR0JCArp06QIfH27gdSTLqVPYessYbIwbgF13TcDRwjLIkgSNLEGBAkURbwwkSDBZFFgUBR3Dg5EY3RxD4sIxMDasYYlDUURSeP550W44dCiwcKEY70pE9AdPzI+KouDkyZNW+XH37t24ePGizW3btm1rU2C1bNnSQd8BVbE88wy2Lt+CjROewK62XXA0v9S5OfL0adGx8dtvgJ8f8OWXwGOPNd43SF7P44opi0VBv3c3IN/J50XVR6smftj+4u31epEoKSnBnj17rBLIsVrGcwcGBqJ3795WyaNTp04ssBpBsd6IxWk5mJV6AmUXSlAua6HUoYVBgnjDEOSnQdLgGIxPiERoQB2vLJaXA0lJongCgBdfFAcO8t+XiK7gLflRURScOHHCKj+mp6ejpMS2xTEqKsqqw6NPnz5o3rx5Y3wLXq86R67PRNmlcpT7+kORnJwjU1OBcePEnubISNGxkZBQt8cgug6PK6YAYFbqCXy47jAqjK572F+AVsazd3bG1MExjfaYFy5cQHp6enXrQ1paGrKysmxuFxwcjPj4eKsVutjYWMh2FgJ6vR4vvvgimjVrhgcffBCdO3dutO/BHegrzXhnVSa+T8uBJKFRfs4CtDIsCjAhIRIvDe+CAF87iqETJ4B77xWHDQYHA19/Ddx//3XvRkTey1vzo8ViwbFjx2wKrLKyMpvbxsTEWHV4xMfHo2nTpnY/F3OkC+RIRQE+/1xM2TWZxAHCixaJgVFEjcwji6livRE3/Wt9o00tcgQ/jYydL99R91WWOjp//nx1cVX131OnTtncLiQkxGp1LiEhAe3bt691QlJhYSHmzZuHzz77DBMmTMC7774LAMjIyMCGDRvQq1cv9OvXzyP3b+3MKsJT36WjRG9EhQN+vvw1MkICtPhiYjwSo6+xOrp6NfDgg8DFi0CnTsDSpUDXrle/PRERmB9rMpvNOHLkiFWBtWfPHuhrOROpY8eONgVWkyZNan1c5kiVc2R5OfD448D8+eLz554D3nlHjEAncgCPLKYA4LVlB7A4Lcchv8wN5a+RMT4xEm+O7qbK8+fn59sUWKdPn7a5XbNmzXD8+HE0a9bM6usWiwWyLONPf/oTRo4ciYkTJ2L9+vVYsmQJiouLcfjwYTz++ONISkqCoigeMbLWYDJj+ooMpKTnOmVF118rY2x8O7w6qiv8ah5aabGIpPDqq2LlbfRoYN48IDTU4TERkWdgfrw6k8mEzMxMqw6PvXv3wmCwbo2UJAlPPfUU3n33XQQGBlr9HXOkijkyO1t0bOzdCwQGAnPnivOkiBzIY4spfaUZt3ywySV7w1uF+OGXZ2+zr5XLSc6cOWOVPNLS0mA0GpGXl1frGVeXLl3Crbfeiu+++w6dOnXCsGHDMGHCBEyePBl79+7F559/jjfeeAPt2rVT4btpXGUGEx6aswOZZ0qc+ubDXyOja0QI5k/uiyA/DVBSIk5o//FHsVv3zTeBl19Wf9QsEbkV5se6MRqNOHjwoFWO3LdvH9566y08++yzte5BZo50PJscuW4d8MADQFEREBsrcmU3dYpy8i4eW0wBwK7sIkyau8OlesP9tTIWTO6LhGu1cLkARVFw/vx5hIaG1tqKkJGRgQcffBD79u0DALRo0QK5ubnVhVe3bt2wZcsWhLnCIbYNUGYwYaxuG04UlKnSFuOnkRHTMggpt7ZA0Pj7gcOHgaZNgW+/BUaMcHo8ROQZmB8bxmAwwGg0Ijg4uNa/Z450Dj+NjJiwIKSU/4agV14S3RsjRogcWYd9bkQN4dFL2onRzTE2vh38Na7xbfprZIyNj3SLRCFJEsLCwq7a07137160atUKALBr1y6EhIQgICAAsizj7NmzKCoqcvskYTCZ8dCcHaolCRGDBSfOlmDSR2tgOHYc6N5dnN7OQoqIGoD5sWH8/PyuWkgBdc+R7riu7TI5Mu8CJmVIMEgy8PrrwE8/sZAip3KNV1EHenVUV3SNCIGfygnD74/L0a+O6qJqHI0lNzcX/fv3BwCkp6cjPj6++u+2bt2K2NhYAKJ3HAAqKyvx/vvv47777sO//vUvrFmzBoWFhc4PvA6mr8hA5pkS1TdqGxQJGWHRmJ78HrB9O9Chg6rxEJFnYH50nLrmSJPJhEGDBuGJJ57AnDlzsG/fPhiNRucHXgcukyNlDTJaxWL6B0uBN95g6zs5ncePNvHT+GD+5L7qX4ZuGYT5k/tab5R0Q8uWLcMnn3yCPXv2YNy4cQCAoKAgq5PlN27ciKFDh1rdT6/XY/369Vi3bh2WLl1a/fXo6GirCYLx8fE2Ay/UsDOrSGykdZEN2hVaP6QEdsGYAgMSg4LUDoeIPADzY+Orb47Mzc3F1q1bsXXr1uqv+fv7o1evXlaTduPi4qBxgal0Lpkji2SMyS669iRcIgfw6D1TNZUZTJg0dwcy8lTeIOnm9Ho9fv31V+zcuRMbNmzAHXfcgSeeeAJPPvkkwsPDIcsyFEXBE088YXW2hqIoOHr0KHbt2mV1xkd5ebnNc8TGxtoUWCEhIc77Hl14c3Z4Ez9sfs61NmcTkXtjfmw89c2RlZWV2L59u9UQqGPHjtk8fmBgIHr37m01pr1Tp061DsFw2PfIHElkxWuKKaBqdGcmUtJznDi6MxKvjuriEStu15Keno5ly5ahqKgIb7zxBlq0aHHd+5jNZhw6dMhqRPuePXtQUVFhc9tOnTpZFVi9e/e+Zr96Q7y67AB+4NhgIvIizI+OVZ8cefHiRaSnp1sVWFlZWTa3Cw4ORnx8vFWB1aFDB8gOandjjiSy5lXFVJVd2UX480IXOHiVbJhMJmRkZFQnjt27d2Pv3r2orKy0up0kSYiLi7MqsHr16mVz3kdd8UBLIvJmzI+u7fz58zYF1qlTp2xuFxISYtUe2KdPH8TExDT4TCvmSCJbXllMAeIy9TurM/H9rhzIEqBvhJW4AK0MiwJMSIzES3d14WXmRlJZWYmDBw9aFVj79++32ZwryzJuvPFGqwTSs2dP+Pv72/1cs1JP4MN1h11qXPCVArQynr2zM6YOjlE7FCLyQMyP7iU/Px+7d++2Ogfr9OnTNrdr1qyZTYEVFRVVpwKLOZLIltcWU1WK9Ub8kJaDmaknUGowQW80oy7/RyQJCND6INhPg2mDYzAuIZKrIU5gMBjw+++/W63OHThwAGaz2ep2Go0G3bp1s0og3bt3r/UgYotFQb93N7hkH/iVwpv44bcXb4csN2yVkYjoapgf3deZM2esCqxdu3bh3LlzNrdr0aKFVYdHQkIC2rZtW2uBxRxJVDuvL6aqWCwKth4vxKbDBdiZdR5H80shSxI0sgQFYoCCJEmQAJgsCiyKgk6tgpEY3QJD4sIxIKYFf2lVptfrsX//fqsCKyMjo3r0bBWtVosePXpY9Zd369YNv2VfxOMLdqOs0nyVZ3Adgb4+mDkpAYM6uPdZXkTk+pgf3Z+iKMjLy7Pq8Ni1a1etR5SEh4fbFFht2rRB6tEC5kiiWrCYugqLRcGponJkFZahwmRGpckCX40Mf40P2ocFIapFYIN7j8nxysrKsG/fPqsC69ChQzYHJPr5+SHm/udRHtlXLKe6OEkCHhvQHq+N6qp2KETkZZgfPYOiKMjJybHKj7t370ZRUZHNbSMiItBmxFMoDOsOwPX/bZkjyZlYTJHXuXTpEvbu3WuVQI4cOYLWj34Mv9b2HYj74bieGBgbhmZBWpQZzPj99EW8v/owDp4psTuOvw/rjNE9I9Ay2A8VJgsOn72E/6w/gu0nztt1/+5tQ/DTU4Ptfj4iIqJrURQF2dnZNgVWcXGx3TmyMfLjs3d2wu1x4WjXXAyVyjxTgn+vOYy0kxfsfgzmSHIWFlNEAC5cvIib/r0V9u6pXZTUD+dKKnCpwoT+sS0Q2zIYuRfKMej9TXY/52cP9IYsSygqq0SvyKbo3jYU+koz4t9aB73x+m0UfhoZh968iyvARETkMBaLBceOH8eIrw7DpFw/3zRGfvz177fhUoUJ+3OL0TMyFHGtQ3CpwojbP9ps954t5khyFs84JY+ogS6atND4+MBosa8X/IFZv1V/fGNECH7+y2C0CQ2ARpZgsti3PvGXRXuqPw4N0GLfa0MR4OuDsGBf5FzQX/f+siTh5PlyRIcF2fV8REREdSXLMrTNIqDVHIfJjoW+xsiPTy/ai/RT4ipUoK8Pdr18B5r4a9H7hmZYc/CsfXEzR5KTsJgiApBVWApNHTdIP9w/Ch3Dm2BArDh8cVbqCbsTRZXRPSPQJ6oZ4m9oBgBYsT/PrkIKADSyhKzCMiYKIiJyqLrmyIbmx6pCChA7tDQ+4rnPFtuXHwHmSHIeFlNEACqMFiioWyE0olsb9IsRiSLvoh6769DLXeXmjmEY2ycSAHCxvBKpR20nK12NAqDC5PpTlYiIyL3VNUc2Rn4EAB9ZwgfjesJP44MV+/OwL7fY7vsyR5KzyGoHQOQKjGZLnc5PAUQrQ+dXVyFpXhpahfjjv3+KR7umAXV6jOdS9qPjKysxTrcNsizhvft7oE9UM7vuqygKKl34FHoiIvIMdc2RjZEf/bUyZk1KwPBubbDh0Dn8bfG+Ot2fOZKchcUUEQCtj2z3RHQ/jYyqbgeDyYLNRwpQVmmC1kdG5B+Th65HI0vw9RG/fkazgl3ZF5BfIjbVxtjZkiBJEnw1/BUmIiLHsjdHNkZ+BMQ+4m+n9MOQuHAsSc/FtPm7UWmuW2HEHEnOwjY/IogVMMnOszN6RzbFJw/0xs6sIhTrjUiMbo4Qfy0KSw04cFq0IIyNb4cPxvVERl4xRnz2q81jtA7xx4q/DMK24+dxvqwS3SJC0CE8GPpKM3Zm257xURsJgL/Gx+7vkYiIqD7szZGNkR8BYM7DCegT1QwXyytRojfiHyO6AAA2HynA5iMFdsXMHEnOwmKKCED7sGC7N8eeu2RAVmEZBnUMQ5CvBkVllVixPw+fbjyKSwYTgMvn/l7tMS8ZTNiXexGJ0c0RGqBFsb4SGw/l44tfjuHk+XK74jBZFLTnxloiInIwe3NkY+RHAGgd6g8AaBroi8cGtq/+eoneaHcxxRxJzsJiighAVPNAWOxsCM8qLLMa/VqbuNZNAAAzNh+v9e+L9UY88tWuugV5BYuiIKqF/W0TRERE9WFvjmyM/AigTmdSXQ1zJDkLm0mJAMiyhI7hwY32eANiw7B832msPGDfeRj10alVMA8jJCIih2vMHOmM/AgwR5Lz8MoU0R8So5vjYF5JHQek1274p6mN8ChXJ0lAYnQLhz4HERFRlcbKkY7OjwBzJDkXr0wR/WFIXDgCfd1js2qA1gdD4sLVDoOIiLwEcyRR7VhMEf1hYGwYgvzc42JtEz8NBsRw1Y2IiJyDOZKodiymiP4gyxKSBsfAX+vavxYBWhlJg2Mgy+wFJyIi52COJKqda/9GEDnZ+ITIOp3yrgaLAoxLiFQ7DCIi8jLMkUS2WEwR1RAaoMWEhEj4u+ip6f4aGRMSIxEaoFU7FCIi8jLMkUS2XPO3gUhFLw3vghAXfSEODdTipbu6qB0GERF5KeZIImsspoiuEODrgy8mxrtcX7i/VsYXD8YjwE2mKRERkedhjiSy5lq/CUQuIjG6OcbGt3OZVgZ/jYyx8ZFIiG6udihEROTlmCOJLnON3wIiF/TqqK7oGhECP5WThZ9GRteIELw6iq0LRETkGpgjiQQWU0RX4afxwfzJfRHTMki1ZOGnkRHTMgjzJ/eFn4atC0RE5BqYI4kEFlNE1xDkp0FK8gDcGBHi9HYGf42MGyNCkJI8wG0OSiQiIu/BHEkESIri6icGEKnPYDJj+opMpKTnoMJocfjz+WtF//ero7pwtY2IiFwacyR5MxZTRHWwK7sIf16YjhK9ERWmxk8Y/hoZIQFafDExHoncSEtERG6EOZK8EYspojrSV5rxzupMfL8rB7IE6BthFS5AK8OiABMSI/HSXV042pWIiNwScyR5GxZTRPVUrDfih7QczEw9gVKDCXqjGXX5bZIkIEDrg2A/DaYNjsG4BJ7aTkREnoE5krwFiymiBrJYFGw9XohNhwuwM+s8juaXQpYkaGQJCgBFUSBJEiQAJosCi6KgU6tgJEa3wJC4cAyIaQFZltT+NoiIiBodcyR5OhZTRI3MYlFwqqgcWYVlqDCZUWmywFcjw1/jg/ZhQYhqEQhJYmIgIiLvwxxJnobFFBERERERUT3wnCkiIiIiIqJ6YDFFRERERERUDyymiIiIiIiI6oHFFBERERERUT2wmCIiIiIiIqoHFlNERERERET1wGKKiIiIiIioHlhMERERERER1QOLKSIiIiIionpgMUVERERERFQPLKaIiIiIiIjqgcUUERERERFRPbCYIiIiIiIiqgcWU0RERERERPXAYoqIiIiIiKgeWEwRERERERHVA4spIiIiIiKiemAxRUREREREVA8spoiIiIiIiOqBxRQREREREVE9/D/T3EShZJpRhQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "label_dict = {i: str(i) + \", \" + str(t) for i, t in solution.items()}\n", + "edge_color = [\"red\" if solution[u] == (solution[v] + 1) % n\n", + " or solution[v] == (solution[u] + 1) % n else \"black\"\n", + " for (u, v) in G.edges]\n", + "label_dict_bf = {i: str(i) + \", \" + str(t) for i, t in solution_brute_force.items()}\n", + "edge_color_bf = [\"red\" if solution_brute_force[u] == (solution_brute_force[v] + 1) % n\n", + " or solution_brute_force[v] == (solution_brute_force[u] + 1) % n else \"black\"\n", + " for (u, v) in G.edges]\n", + "\n", + "# Draw the walk corresponding to the dictionary presented above 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(G, pos=pos, labels=label_dict, edge_color=edge_color, ax=ax[0], **options)\n", + "nx.drawing.nx_pylab.draw_networkx_edge_labels(G, pos=pos, ax=ax[0], edge_labels=nx.get_edge_attributes(G, 'weight'))\n", + "nx.draw(G, pos=pos, labels=label_dict_bf, edge_color=edge_color_bf, ax=ax[1], **options)\n", + "nx.drawing.nx_pylab.draw_networkx_edge_labels(G, pos=pos, ax=ax[1], edge_labels=nx.get_edge_attributes(G, 'weight'))\n", + "plt.axis(\"off\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The left graph given above shows a solution found by the parameterized quantum circuit, while the right graph given above shows a solution found by the brute-force algorithm. It can be seen that even if the order of the vertices are different, the routes are essentially the same, which verifies the correctness of using parameterized quantum circuit to solve the TSP." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Applications\n", + "\n", + "The TSP naturally applies in many transportation and logistics applications, for example, the problem of arranging school bus routes. The school bus application provides the motivation for Merrill Flood, a pioneer in the field of management science, to study TSP research in the 1940s. More recent applications involve food delivery route management [1] and power delivery for cable firms [2]. \n", + "\n", + "Other than those transportation applications, TSP also has wide usefulness in other management problems like scheduling of a machine to drill holes in a circuit board [3], reconstructing an unknown fragment of DNA [4] and scheduling optimal route in construction management [5]. Some consulting companies like [Nexus](https://nexustech.com.ph/company/newsletter/article/Finding-the-shortest-path-Optimizing-food-trips) have utilized this to provide management service.\n", + "\n", + "The TSP, as one of the most famous optimization problems, also provides a platform for the study of general methods in solving combinatorial problem. This is usually the first several problems that researchers give a try for experiments of new algorithms.\n", + "\n", + "More applications, formulations and solution approaches can be found in [6]." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## References\n", + "\n", + "[1] Bräysy, Olli, et al. \"An optimization approach for communal home meal delivery service: A case study.\" [Journal of Computational and Applied Mathematics 232.1 (2009): 46-53.](https://www.sciencedirect.com/science/article/pii/S0377042708005438)\n", + "\n", + "[2] Sloane, Thomas H., Frank Mann, and H. Kaveh. \"Powering the last mile: an alternative to powering FITL.\" [Proceedings of Power and Energy Systems in Converging Markets. IEEE, 1997.](https://ieeexplore.ieee.org/document/646046)\n", + "\n", + "[3] Onwubolu, Godfrey C. \"Optimizing CNC drilling machine operations: traveling salesman problem-differential evolution approach.\" [New optimization techniques in engineering. Springer, Berlin, Heidelberg, 2004. 537-565.](https://link.springer.com/chapter/10.1007/978-3-540-39930-8_22)\n", + "\n", + "[4] Caserta, Marco, and Stefan Voß. \"A hybrid algorithm for the DNA sequencing problem.\" [Discrete Applied Mathematics 163 (2014): 87-99.](https://www.sciencedirect.com/science/article/pii/S0166218X12003253)\n", + "\n", + "[5] Klanšek, Uroš. \"Using the TSP solution for optimal route scheduling in construction management.\" [Organization, technology & management in construction: an international journal 3.1 (2011): 243-249.](https://www.semanticscholar.org/paper/Using-the-TSP-Solution-for-Optimal-Route-Scheduling-Klansek/3d809f185c03a8e776ac07473c76e9d77654c389)\n", + "\n", + "[6] Matai, Rajesh, Surya Prakash Singh, and Murari Lal Mittal. \"Traveling salesman problem: an overview of applications, formulations, and solution approaches.\" [Traveling salesman problem, theory and applications 1 (2010).](https://www.sciencedirect.com/topics/computer-science/traveling-salesman-problem)" + ] + } + ], + "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.8.13" + }, + "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 +} diff --git a/tutorial/combinatorial_optimization/figures/dcqaoa-fig-applicability_example.png b/tutorials/combinatorial_optimization/figures/dcqaoa-fig-applicability_example.png similarity index 100% rename from tutorial/combinatorial_optimization/figures/dcqaoa-fig-applicability_example.png rename to tutorials/combinatorial_optimization/figures/dcqaoa-fig-applicability_example.png diff --git a/tutorial/combinatorial_optimization/figures/maxcut-fig-cir_ubud.png b/tutorials/combinatorial_optimization/figures/maxcut-fig-cir_ubud.png similarity index 100% rename from tutorial/combinatorial_optimization/figures/maxcut-fig-cir_ubud.png rename to tutorials/combinatorial_optimization/figures/maxcut-fig-cir_ubud.png diff --git a/tutorial/combinatorial_optimization/figures/maxcut-fig-cir_ud.png b/tutorials/combinatorial_optimization/figures/maxcut-fig-cir_ud.png similarity index 100% rename from tutorial/combinatorial_optimization/figures/maxcut-fig-cir_ud.png rename to tutorials/combinatorial_optimization/figures/maxcut-fig-cir_ud.png diff --git a/tutorial/combinatorial_optimization/figures/maxcut-fig-cut_graph.png b/tutorials/combinatorial_optimization/figures/maxcut-fig-cut_graph.png similarity index 100% rename from tutorial/combinatorial_optimization/figures/maxcut-fig-cut_graph.png rename to tutorials/combinatorial_optimization/figures/maxcut-fig-cut_graph.png diff --git a/tutorial/combinatorial_optimization/figures/maxcut-fig-gen_graph.png b/tutorials/combinatorial_optimization/figures/maxcut-fig-gen_graph.png similarity index 100% rename from tutorial/combinatorial_optimization/figures/maxcut-fig-gen_graph.png rename to tutorials/combinatorial_optimization/figures/maxcut-fig-gen_graph.png diff --git a/tutorial/combinatorial_optimization/figures/maxcut-fig-maxcut_cut.png b/tutorials/combinatorial_optimization/figures/maxcut-fig-maxcut_cut.png similarity index 100% rename from tutorial/combinatorial_optimization/figures/maxcut-fig-maxcut_cut.png rename to tutorials/combinatorial_optimization/figures/maxcut-fig-maxcut_cut.png diff --git a/tutorial/combinatorial_optimization/figures/maxcut-fig-maxcut_g.png b/tutorials/combinatorial_optimization/figures/maxcut-fig-maxcut_g.png similarity index 100% rename from tutorial/combinatorial_optimization/figures/maxcut-fig-maxcut_g.png rename to tutorials/combinatorial_optimization/figures/maxcut-fig-maxcut_g.png diff --git a/tutorial/combinatorial_optimization/figures/maxcut-fig-measure.png b/tutorials/combinatorial_optimization/figures/maxcut-fig-measure.png similarity index 100% rename from tutorial/combinatorial_optimization/figures/maxcut-fig-measure.png rename to tutorials/combinatorial_optimization/figures/maxcut-fig-measure.png diff --git a/tutorial/combinatorial_optimization/figures/tsp-fig-circuit.png b/tutorials/combinatorial_optimization/figures/tsp-fig-circuit.png similarity index 100% rename from tutorial/combinatorial_optimization/figures/tsp-fig-circuit.png rename to tutorials/combinatorial_optimization/figures/tsp-fig-circuit.png diff --git a/tutorial/combinatorial_optimization/realStockData_12.csv b/tutorials/combinatorial_optimization/realStockData_12.csv similarity index 100% rename from tutorial/combinatorial_optimization/realStockData_12.csv rename to tutorials/combinatorial_optimization/realStockData_12.csv diff --git a/tutorial/locc/EntanglementDistillation_BBPSSW_CN.ipynb b/tutorials/locc/EntanglementDistillation_BBPSSW_CN.ipynb similarity index 91% rename from tutorial/locc/EntanglementDistillation_BBPSSW_CN.ipynb rename to tutorials/locc/EntanglementDistillation_BBPSSW_CN.ipynb index 5a80727..d3e8e82 100644 --- a/tutorial/locc/EntanglementDistillation_BBPSSW_CN.ipynb +++ b/tutorials/locc/EntanglementDistillation_BBPSSW_CN.ipynb @@ -62,7 +62,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "bearing-millennium", "metadata": { "ExecuteTime": { @@ -84,8 +84,13 @@ } ], "source": [ + "import paddle_quantum\n", "from paddle_quantum.state import bell_state\n", - "N = 2 # 指定量子比特数量\n", + "\n", + "# 切换至密度矩阵模式\n", + "paddle_quantum.set_backend('density_matrix')\n", + "# 指定量子比特数量\n", + "N = 2\n", "rho = bell_state(N)\n", "print(\"生成的量子态 Phi = \\n\", rho)" ] @@ -111,15 +116,14 @@ "\\tag{4}\n", "$$\n", "\n", - "其中 $ T_B $ 代表相对于子系统 $ B $ 的部分转置 （partial transpose）操作，可以定义为 [7]，\n", + "其中 $||\\cdot ||_ 1$ 表示迹范数，$T_B$ 代表相对于子系统 $B$ 的部分转置 （partial transpose）操作，可以定义为 [7]\n", "\n", "$$\n", - "\\rho_{A B}^{T_{B}}:=(I \\otimes T)(\\rho_{A B})=\\sum_{i, j}(I_{A} \\otimes|i\\rangle\\langle j|_{B}) \\rho_{A B}(I_{A} \\otimes|i\\rangle\\langle j|_{B}).\n", + "\\rho_{A B}^{T_{B}}:=(I \\otimes T)(\\rho_{A B})=\\sum_{i, j}(I_{A} \\otimes|i\\rangle\\langle j|_{B}) \\rho_{A B}(I_{A} \\otimes|i\\rangle\\langle j|_{B}),\n", "\\tag{5}\n", "$$\n", "\n", - "\n", - "$||\\cdot ||_ 1$ 表示迹范数，$\\{|i\\rangle_B\\}$ 是 $B$ 系统上的一组基。上述两个指标间的联系为 $E_{N}(\\rho) = \\text{log}_2 (2\\mathcal{N}(\\rho)+1)$。 它们都与 PPT 的可分离性指标有关。\n", + "其中 $\\{|i\\rangle_B\\}$ 是 $B$ 系统上的一组基。上述两个指标间的联系为 $E_{N}(\\rho) = \\text{log}_2 (2\\mathcal{N}(\\rho)+1)$。它们都与 PPT 的可分离性指标有关。\n", "> *如果密度矩阵进行部分转置后没有负特征值（即半正定的），则称其具有 positive partial transpose, PPT。 否则，称为 negative partial transpose, NPT。*\n", "\n", "\n", @@ -149,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "unique-class", "metadata": { "ExecuteTime": { @@ -173,16 +177,15 @@ } ], "source": [ - "from paddle_quantum.state import bell_state\n", - "from paddle_quantum.utils import negativity, logarithmic_negativity, partial_transpose, is_ppt\n", + "from paddle_quantum.qinfo import negativity, logarithmic_negativity, partial_transpose, is_ppt\n", "\n", "input_state = bell_state(2)\n", "transposed_state = partial_transpose(input_state, 2) # 2 代表量子比特数量\n", - "print(\"部分转置后的量子态为\\n\", transposed_state)\n", + "print(\"部分转置后的量子态为\\n\", transposed_state.numpy())\n", "\n", "neg = negativity(input_state)\n", "log_neg = logarithmic_negativity(input_state)\n", - "print(\"With negativity =\", neg,\"and logarithmic_negativity =\", log_neg)\n", + "print(\"With negativity =\", neg.numpy()[0], \"and logarithmic_negativity =\", log_neg.numpy()[0])\n", "print(\"输入态满足 PPT 条件因此无法被蒸馏?\", is_ppt(input_state))" ] }, @@ -210,7 +213,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "assigned-laptop", "metadata": { "ExecuteTime": { @@ -224,16 +227,16 @@ "output_type": "stream", "text": [ "两个态的保真度是:\n", - "F= 0.7750000000000004\n" + "F= 0.77500015\n" ] } ], "source": [ - "from paddle_quantum.state import bell_state, isotropic_state\n", - "from paddle_quantum.utils import state_fidelity\n", + "from paddle_quantum.state import isotropic_state\n", + "from paddle_quantum.qinfo import state_fidelity\n", "\n", "F = state_fidelity(bell_state(2), isotropic_state(2, 0.7))\n", - "print(\"两个态的保真度是:\\nF=\", F**2)" + "print(\"两个态的保真度是:\\nF=\", (F**2).numpy()[0])" ] }, { @@ -296,7 +299,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "inside-vulnerability", "metadata": { "ExecuteTime": { @@ -308,10 +311,10 @@ "source": [ "import numpy as np\n", "from paddle_quantum.locc import LoccNet\n", - "from paddle import matmul, trace\n", "import paddle\n", + "from paddle import matmul, trace\n", "from paddle_quantum.state import bell_state, isotropic_state\n", - "from paddle_quantum.utils import logarithmic_negativity, is_ppt" + "from paddle_quantum.qinfo import logarithmic_negativity, is_ppt" ] }, { @@ -324,7 +327,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "considerable-premises", "metadata": { "ExecuteTime": { @@ -360,7 +363,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "sized-rover", "metadata": { "ExecuteTime": { @@ -399,7 +402,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "id": "motivated-association", "metadata": { "ExecuteTime": { @@ -412,65 +415,60 @@ "class LOCC(LoccNet):\n", " def __init__(self):\n", " super(LOCC, self).__init__()\n", - " \n", " # 添加第一个参与方 Alice\n", " # 第一个参数 2 代表着 Alice 手里有几个量子比特\n", " # 第二个参数代表着参与方的名字\n", " self.add_new_party(2, party_name='Alice')\n", - " \n", " # 添加第二个参与方 Bob\n", " # 第一个参数 2 代表着 Bob 手里有几个量子比特\n", " # 第二个参数代表着参与方的名字\n", " self.add_new_party(2, party_name='Bob')\n", - " \n", + "\n", " # 定义输入量子态 rho_in\n", - " _state = paddle.to_tensor(isotropic_state(2, p))\n", - " \n", + " _state = isotropic_state(2, p)\n", " # ('Alice', 0) 代表 Alice 的第一个量子比特 A0\n", " # ('Bob', 0) 代表 Bob 的第一个量子比特 B0\n", - " self.set_init_state(_state, [('Alice', 0), ('Bob', 0)]) \n", - " \n", + " self.set_init_state(_state, [('Alice', 0), ('Bob', 0)])\n", " # ('Alice', 1) 代表 Alice 的第二个量子比特 A1\n", " # ('Bob', 1) 代表 Bob 的第二个量子比特 B1\n", - " self.set_init_state(_state, [('Alice', 1), ('Bob', 1)]) \n", - " \n", - " def BBPSSW(self):\n", - " status = self.init_status\n", - " \n", - " # 创建 Alice 的局部操作\n", - " cir1 = self.create_ansatz('Alice')\n", - " cir1.cnot([0, 1])\n", + " self.set_init_state(_state, [('Alice', 1), ('Bob', 1)])\n", "\n", + " # 创建 Alice 的局部操作\n", + " self.cir1 = self.create_ansatz('Alice')\n", + " self.cir1.cnot([0, 1])\n", " # 创建 Bob 的局部操作\n", - " cir2 = self.create_ansatz('Bob')\n", - " cir2.cnot([0, 1])\n", - " \n", + " self.cir2 = self.create_ansatz('Bob')\n", + " self.cir2.cnot([0, 1])\n", + "\n", + " def BBPSSW(self):\n", + " status = self.init_status\n", " # 运行电路\n", - " status = cir1.run(status)\n", - " status_mid = cir2.run(status)\n", - " \n", + " status = self.cir1(status)\n", + " status_mid = self.cir2(status)\n", + "\n", " # ('Alice', 1) 代表测量 Alice 的第二个量子比特 A1\n", " # ('Bob', 1) 代表测量 Bob 的第二个量子比特 B1\n", " # ['00','11'] 代表着成功的蒸馏实验所需条件\n", " # Alice 和 Bob 同时测得 '00' or '11'\n", " status_mid = self.measure(status_mid, [('Alice', 1), ('Bob', 1)], [\"00\", \"11\"])\n", - " \n", + "\n", " # 取偏迹除去测量后的量子比特 A1&B1\n", " # 把 Alice 还有 Bob 的第一个量子比特 A0&B0 作为寄存器\n", " status_fin = self.partial_state(status_mid, [('Alice', 0), ('Bob', 0)])\n", - " \n", + "\n", " return status_fin" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "id": "enormous-workplace", "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:10:17.568446Z", "start_time": "2021-02-23T09:10:17.205178Z" - } + }, + "scrolled": true }, "outputs": [ { @@ -482,12 +480,12 @@ "蒸馏成功的概率是: 74.500%\n", "========================================================\n", "输出态是:\n", - " [[0.48489933+0.j 0. +0.j 0. +0.j 0.32885906+0.j]\n", + " [[0.48489934+0.j 0. +0.j 0. +0.j 0.32885906+0.j]\n", " [0. +0.j 0.01510067+0.j 0. +0.j 0. +0.j]\n", " [0. +0.j 0. +0.j 0.01510067+0.j 0. +0.j]\n", - " [0.32885906+0.j 0. +0.j 0. +0.j 0.48489933+0.j]]\n", - "初始 logarithmic negativity 是: 0.6322682154995127\n", - "蒸馏后 logarithmic negativity 是: 0.7026724166123284\n" + " [0.32885906+0.j 0. +0.j 0. +0.j 0.48489934+0.j]]\n", + "初始 logarithmic negativity 是: 0.6322681307792664\n", + "蒸馏后 logarithmic negativity 是: 0.7026724219322205\n" ] } ], @@ -496,15 +494,15 @@ "status_fin = LOCC().BBPSSW()\n", "\n", "# 计算保真度\n", - "target_state = paddle.to_tensor(bell_state(2))\n", + "target_state = bell_state(2)\n", "fidelity = 0\n", "for status in status_fin:\n", - " fidelity += paddle.real(trace(matmul(target_state, status.state)))\n", + " fidelity += paddle.real(trace(matmul(target_state.data, status.data)))\n", "fidelity /= len(status_fin)\n", "\n", "# 计算成功概率\n", "suc_rate = sum([status.prob for status in status_fin])\n", - "fidelity_in,_,_ = BBPSSW_metrics(p)\n", + "fidelity_in, _, _ = BBPSSW_metrics(p)\n", "\n", "# 输出模拟结果\n", "print(f\"输入态的保真度是: {fidelity_in:.5f}\")\n", @@ -512,11 +510,11 @@ "print(f\"蒸馏成功的概率是: {suc_rate.numpy()[0]:#.3%}\")\n", "\n", "# 打印输出态\n", - "rho_out = status_fin[0].state.numpy()\n", + "rho_out = status_fin[0]\n", "print(\"========================================================\")\n", - "print(f\"输出态是:\\n {rho_out}\")\n", - "print(f\"初始 logarithmic negativity 是: {logarithmic_negativity(isotropic_state(2,p))}\")\n", - "print(f\"蒸馏后 logarithmic negativity 是: {logarithmic_negativity(rho_out)}\")" + "print(f\"输出态是:\\n {rho_out.data.numpy()}\")\n", + "print(f\"初始 logarithmic negativity 是: {logarithmic_negativity(isotropic_state(2,p)).numpy()[0]}\")\n", + "print(f\"蒸馏后 logarithmic negativity 是: {logarithmic_negativity(rho_out).numpy()[0]}\")" ] }, { @@ -568,7 +566,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -582,7 +580,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/locc/EntanglementDistillation_BBPSSW_EN.ipynb b/tutorials/locc/EntanglementDistillation_BBPSSW_EN.ipynb similarity index 88% rename from tutorial/locc/EntanglementDistillation_BBPSSW_EN.ipynb rename to tutorials/locc/EntanglementDistillation_BBPSSW_EN.ipynb index a9917fc..804dbba 100644 --- a/tutorial/locc/EntanglementDistillation_BBPSSW_EN.ipynb +++ b/tutorials/locc/EntanglementDistillation_BBPSSW_EN.ipynb @@ -58,7 +58,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:10:37.924098Z", @@ -79,8 +79,13 @@ } ], "source": [ + "import paddle_quantum\n", "from paddle_quantum.state import bell_state\n", - "N = 2 # number of qubits\n", + "\n", + "# Change to density matrix mode\n", + "paddle_quantum.set_backend('density_matrix')\n", + "# Number of qubits\n", + "N = 2\n", "rho = bell_state(N)\n", "print(\"The generated state Phi = \\n\", rho)" ] @@ -91,7 +96,7 @@ "source": [ "### Entanglement quantification\n", "\n", - "After having a taste of quantum entanglement qualitatively, we want to promote our understanding to a quantitive level. One should realize the validity of aforementioned quantum communication protocols, including quantum teleportation and superdense coding, depends on **the quality of the entanglement quantification**. Following the convention in quantum information community, the **negativity** $\\mathcal{N}(\\rho)$ and the **logarithmic negativity** $E_{N}(\\rho)$ are widely recognized metrics to quantify the amount of entanglement presented in a bi-partite system [6]. Specifically,\n", + "After having a taste of quantum entanglement qualitatively, we want to promote our understanding to a quantitative level. One should realize the validity of aforementioned quantum communication protocols, including quantum teleportation and superdense coding, depends on **the quality of the entanglement quantification**. Following the convention in quantum information community, the **negativity** $\\mathcal{N}(\\rho)$ and the **logarithmic negativity** $E_{N}(\\rho)$ are widely recognized metrics to quantify the amount of entanglement presented in a bi-partite system [6]. Specifically,\n", "\n", "$$\n", "\\mathcal{N}(\\rho) \\equiv \\frac{||\\rho^{T_B}||_1-1}{2},\n", @@ -105,15 +110,14 @@ "\\tag{4}\n", "$$\n", "\n", - "where $T_B$ stands for the partial transpose operation with respect to subsystem $B$ and can be defined as [7],\n", + "where $||\\cdot||_1$ denotes the trace norm, and $T_B$ stands for the partial transpose operation with respect to subsystem $B$ and can be defined as [7]\n", "\n", "$$\n", - "\\rho_{A B}^{T_{B}}:=(I \\otimes T)(\\rho_{A B})=\\sum_{i, j}(I_{A} \\otimes|i\\rangle\\langle j|_{B}) \\rho_{A B}(I_{A} \\otimes|i\\rangle\\langle j|_{B}).\n", + "\\rho_{A B}^{T_{B}}:=(I \\otimes T)(\\rho_{A B})=\\sum_{i, j}(I_{A} \\otimes|i\\rangle\\langle j|_{B}) \\rho_{A B}(I_{A} \\otimes|i\\rangle\\langle j|_{B}),\n", "\\tag{5}\n", "$$\n", "\n", - "\n", - "$||\\cdot||_1$ denotes the trace norm and $\\{|i\\rangle_B\\}$ is a basis of subsystem $B$. It is easy to connect these two metrics as $E_{N}(\\rho) = \\text{log}_2 (2\\mathcal{N}(\\rho)+1)$. They are all related to the PPT criterion for separability. \n", + "where $\\{|i\\rangle_B\\}$ is a basis of subsystem $B$. It is easy to connect these two metrics as $E_{N}(\\rho) = \\text{log}_2 (2\\mathcal{N}(\\rho)+1)$. They are all related to the PPT criterion for separability. \n", "\n", "> *A density matrix has a positive partial transpose (PPT) if its partial transposition has no negative eigenvalues (i.e. positive semidefinite). Otherwise, it's called NPT.*\n", "\n", @@ -143,7 +147,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:10:43.024928Z", @@ -166,16 +170,15 @@ } ], "source": [ - "from paddle_quantum.state import bell_state\n", - "from paddle_quantum.utils import negativity, logarithmic_negativity, partial_transpose, is_ppt\n", + "from paddle_quantum.qinfo import negativity, logarithmic_negativity, partial_transpose, is_ppt\n", "\n", "input_state = bell_state(2)\n", "transposed_state = partial_transpose(input_state, 2) # 2 stands for qubit numbers\n", - "print(\"The transposed state is\\n\", transposed_state)\n", + "print(\"The transposed state is\\n\", transposed_state.numpy())\n", "\n", "neg = negativity(input_state)\n", "log_neg = logarithmic_negativity(input_state)\n", - "print(\"With negativity =\", neg,\"and logarithmic_negativity =\", log_neg)\n", + "print(\"With negativity =\", neg.numpy()[0], \"and logarithmic_negativity =\", log_neg.numpy()[0])\n", "print(\"The input state satisfies the PPT condition and hence not distillable?\", is_ppt(input_state))" ] }, @@ -202,7 +205,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:10:45.384306Z", @@ -215,16 +218,16 @@ "output_type": "stream", "text": [ "The state fidelity between these two states are:\n", - "F= 0.7750000000000004\n" + "F= 0.77500015\n" ] } ], "source": [ - "from paddle_quantum.state import bell_state, isotropic_state\n", - "from paddle_quantum.utils import state_fidelity\n", + "from paddle_quantum.state import isotropic_state\n", + "from paddle_quantum.qinfo import state_fidelity\n", "\n", "F = state_fidelity(bell_state(2), isotropic_state(2, 0.7))\n", - "print(\"The state fidelity between these two states are:\\nF=\", F**2)" + "print(\"The state fidelity between these two states are:\\nF=\", (F**2).numpy()[0])" ] }, { @@ -249,7 +252,7 @@ "\n", "This state is PPT and hence not distillable when $p \\leq 1/3$. \n", "\n", - "We have two remote parties, $A$ (Alice) and $B$ (Bob), involved in the BBPSSW distillation protocol. They share two qubit pairs $\\rho_{A_0B_0}$ and $\\rho_{A_1B_1}$. Each pair is initialized as $\\rho_{in} = \\rho_{\\text{iso}}(p)$. These states could come from last distillation process or previously distributed and stored in some memory registers of a quantum network. Alice holds two qubits $A_0, A_1$, and Bob also holds two qubits $B_0, B_1$. With these initial setups, Alice and Bob implements the following LOCC process:\n", + "We have two remote parties, $A$ (Alice) and $B$ (Bob), involved in the BBPSSW distillation protocol. They share two qubit pairs $\\rho_{A_0B_0}$ and $\\rho_{A_1B_1}$. Each pair is initialized as $\\rho_{in} = \\rho_{\\text{iso}}(p)$. These states could come from last distillation process or previously distributed and stored in some memory registers of a quantum network. Alice holds two qubits $A_0, A_1$, and Bob also holds two qubits $B_0, B_1$. With these initial setups, Alice and Bob implement the following LOCC process:\n", "\n", "1. Alice and Bob firstly choose the qubit pair **they want to keep as the memory qubit pair to store entanglement resource after distillation**. Here, they choose $A_0$ and $B_0$. \n", "2. Alice and Bob both apply a CNOT gate on their qubits. Here, they choose $A_0,B_0$ as the control qubits and $A_1,B_1$ as the target qubits.\n", @@ -291,7 +294,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:10:48.714566Z", @@ -302,10 +305,10 @@ "source": [ "import numpy as np\n", "from paddle_quantum.locc import LoccNet\n", - "from paddle import matmul, trace\n", "import paddle\n", + "from paddle import matmul, trace\n", "from paddle_quantum.state import bell_state, isotropic_state\n", - "from paddle_quantum.utils import logarithmic_negativity, is_ppt" + "from paddle_quantum.qinfo import logarithmic_negativity, is_ppt" ] }, { @@ -317,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:10:50.880991Z", @@ -351,7 +354,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:10:52.180240Z", @@ -388,7 +391,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:10:53.985975Z", @@ -401,59 +404,53 @@ "class LOCC(LoccNet):\n", " def __init__(self):\n", " super(LOCC, self).__init__()\n", - " \n", " # Add the first party Alice \n", " # The first parameter 2 stands for how many qubits A holds\n", - " # The second parameter records the name of this qubit holder\n", + " # The second parameter records the name of this party\n", " self.add_new_party(2, party_name='Alice')\n", - " \n", " # Add the second party Bob\n", " # The first parameter 2 stands for how many qubits B holds\n", - " # The second parameter records the name of this qubit holder\n", + " # The second parameter records the name of this party\n", " self.add_new_party(2, party_name='Bob')\n", - " \n", + "\n", " # Define the input quantum states rho_in\n", - " _state = paddle.to_tensor(isotropic_state(2, p))\n", - " \n", + " _state = isotropic_state(2, p)\n", " # ('Alice', 0) means Alice's first qubit A0\n", " # ('Bob', 0) means Bob's first qubit B0\n", - " self.set_init_state(_state, [('Alice', 0), ('Bob', 0)]) \n", - " \n", + " self.set_init_state(_state, [('Alice', 0), ('Bob', 0)])\n", " # ('Alice', 1) means Alice's second qubit A1\n", " # ('Bob', 1) means Bob's second qubit B1\n", - " self.set_init_state(_state, [('Alice', 1), ('Bob', 1)]) \n", - " \n", - " def BBPSSW(self):\n", - " status = self.init_status\n", - " \n", - " # Create Alice's local operations \n", - " cir1 = self.create_ansatz('Alice')\n", - " cir1.cnot([0, 1])\n", + " self.set_init_state(_state, [('Alice', 1), ('Bob', 1)])\n", "\n", + " # Create Alice's local operations \n", + " self.cir1 = self.create_ansatz('Alice')\n", + " self.cir1.cnot([0, 1])\n", " # Create Bob's local operations \n", - " cir2 = self.create_ansatz('Bob')\n", - " cir2.cnot([0, 1])\n", - " \n", + " self.cir2 = self.create_ansatz('Bob')\n", + " self.cir2.cnot([0, 1])\n", + "\n", + " def BBPSSW(self):\n", + " status = self.init_status\n", " # Run circuit\n", - " status = cir1.run(status)\n", - " status_mid = cir2.run(status)\n", - " \n", + " status = self.cir1(status)\n", + " status_mid = self.cir2(status)\n", + "\n", " # ('Alice', 1) means measuring Alice's second qubit A1\n", " # ('Bob', 1) means measuring Bob's second qubit B1\n", " # ['00','11'] specifies the success condition for distillation\n", " # Means Alice and Bob both measure '00' or '11'\n", " status_mid = self.measure(status_mid, [('Alice', 1), ('Bob', 1)], [\"00\", \"11\"])\n", - " \n", + "\n", " # Trace out the measured qubits A1&B1\n", " # Leaving only Alice’s first qubit and Bob’s first qubit A0&B0 as the memory register\n", " status_fin = self.partial_state(status_mid, [('Alice', 0), ('Bob', 0)])\n", - " \n", + "\n", " return status_fin" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:10:58.444882Z", @@ -470,12 +467,12 @@ "The probability of successful purification is: 74.500%\n", "========================================================\n", "The output state is:\n", - " [[0.48489933+0.j 0. +0.j 0. +0.j 0.32885906+0.j]\n", + " [[0.48489934+0.j 0. +0.j 0. +0.j 0.32885906+0.j]\n", " [0. +0.j 0.01510067+0.j 0. +0.j 0. +0.j]\n", " [0. +0.j 0. +0.j 0.01510067+0.j 0. +0.j]\n", - " [0.32885906+0.j 0. +0.j 0. +0.j 0.48489933+0.j]]\n", - "The initial logarithmic negativity is: 0.6322682154995127\n", - "The final logarithmic negativity is: 0.7026724166123284\n" + " [0.32885906+0.j 0. +0.j 0. +0.j 0.48489934+0.j]]\n", + "The initial logarithmic negativity is: 0.6322681307792664\n", + "The final logarithmic negativity is: 0.7026724219322205\n" ] } ], @@ -484,15 +481,15 @@ "status_fin = LOCC().BBPSSW()\n", "\n", "# Calculate fidelity\n", - "target_state = paddle.to_tensor(bell_state(2))\n", + "target_state = bell_state(2)\n", "fidelity = 0\n", "for status in status_fin:\n", - " fidelity += paddle.real(trace(matmul(target_state, status.state)))\n", + " fidelity += paddle.real(trace(matmul(target_state.data, status.data)))\n", "fidelity /= len(status_fin)\n", "\n", "# Calculate success rate\n", "suc_rate = sum([status.prob for status in status_fin])\n", - "fidelity_in,_,_ = BBPSSW_metrics(p)\n", + "fidelity_in, _, _ = BBPSSW_metrics(p)\n", "\n", "# Output simulation results\n", "print(f\"The fidelity of the input quantum state is: {fidelity_in:.5f}\")\n", @@ -500,11 +497,11 @@ "print(f\"The probability of successful purification is: {suc_rate.numpy()[0]:#.3%}\")\n", "\n", "# Print the output state\n", - "rho_out = status_fin[0].state.numpy()\n", + "rho_out = status_fin[0]\n", "print(\"========================================================\")\n", - "print(f\"The output state is:\\n {rho_out}\")\n", - "print(f\"The initial logarithmic negativity is: {logarithmic_negativity(isotropic_state(2,p))}\")\n", - "print(f\"The final logarithmic negativity is: {logarithmic_negativity(rho_out)}\")" + "print(f\"The output state is:\\n {rho_out.data.numpy()}\")\n", + "print(f\"The initial logarithmic negativity is: {logarithmic_negativity(isotropic_state(2,p)).numpy()[0]}\")\n", + "print(f\"The final logarithmic negativity is: {logarithmic_negativity(rho_out).numpy()[0]}\")" ] }, { @@ -513,7 +510,7 @@ "source": [ "## Conclusion\n", "\n", - "As we can see, the simulation results matches the theoretical prediction perfectly. Through the BBPSSW protocol, we can extract an entangled state with higher Fidelity from two entangled states with low Fidelity.\n", + "As we can see, the simulation results matches the theoretical prediction perfectly. Through the BBPSSW protocol, we can extract an entangled state with a higher fidelity from two entangled states with low fidelities.\n", "\n", "**Advantages**\n", "- Operations are simple. Only CNOT gates are required.\n", @@ -554,7 +551,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -568,7 +565,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/locc/EntanglementDistillation_DEJMPS_CN.ipynb b/tutorials/locc/EntanglementDistillation_DEJMPS_CN.ipynb similarity index 88% rename from tutorial/locc/EntanglementDistillation_DEJMPS_CN.ipynb rename to tutorials/locc/EntanglementDistillation_DEJMPS_CN.ipynb index 51d6ab6..657868e 100644 --- a/tutorial/locc/EntanglementDistillation_DEJMPS_CN.ipynb +++ b/tutorials/locc/EntanglementDistillation_DEJMPS_CN.ipynb @@ -23,7 +23,7 @@ "$$ \n", "\\begin{align*}\n", "|\\Phi^{\\pm}\\rangle_{AB} &= \\frac{1}{\\sqrt{2}}(|0\\rangle_A\\otimes|0\\rangle_B \\pm |1\\rangle_A\\otimes|1\\rangle_B), \\\\\n", - "|\\Psi^{\\pm}\\rangle_{AB} &= \\frac{1}{\\sqrt{2}}(|0\\rangle_A\\otimes|1\\rangle_B \\pm |1\\rangle_A\\otimes|0\\rangle_B). \n", + "|\\Psi^{\\pm}\\rangle_{AB} &= \\frac{1}{\\sqrt{2}}(|0\\rangle_A\\otimes|1\\rangle_B \\pm |1\\rangle_A\\otimes|0\\rangle_B),\n", "\\tag{1}\n", "\\end{align*}\n", "$$\n", @@ -87,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:13:09.766714Z", @@ -97,11 +97,14 @@ "outputs": [], "source": [ "import numpy as np\n", - "from paddle_quantum.locc import LoccNet\n", - "from paddle import matmul, trace\n", "import paddle\n", + "from paddle import matmul, trace\n", + "import paddle_quantum\n", + "from paddle_quantum.locc import LoccNet\n", "from paddle_quantum.state import bell_state, isotropic_state, bell_diagonal_state\n", - "from paddle_quantum.utils import negativity, logarithmic_negativity, is_ppt" + "from paddle_quantum.qinfo import negativity, logarithmic_negativity, is_ppt\n", + "# 切换至密度矩阵模式\n", + "paddle_quantum.set_backend('density_matrix')" ] }, { @@ -121,7 +124,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:13:09.792624Z", @@ -148,7 +151,7 @@ " F_in = p[0]\n", " p_succ = (p[0] + p[3]) ** 2 + (p[1] + p[2]) ** 2\n", " F_out = (p[0] ** 2 + p[3] ** 2)/p_succ\n", - " \n", + "\n", " return F_in, F_out, p_succ\n", "\n", "p = 0.7\n", @@ -157,7 +160,7 @@ "print(\"蒸馏后的保真度的理论值为:\", F_out)\n", "print(\"蒸馏成功率的理论值为:\", p_succ)\n", "print(\"输入态是否满足 PPT 条件并因而无法进行蒸馏？\", \n", - " is_ppt(bell_diagonal_state(p, (1-p)/2, (1-p)/3, (1-p)/6)))" + " is_ppt(bell_diagonal_state([p, (1-p)/2, (1-p)/3, (1-p)/6])))" ] }, { @@ -169,7 +172,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:13:11.302009Z", @@ -181,65 +184,58 @@ "class LOCC(LoccNet):\n", " def __init__(self):\n", " super(LOCC, self).__init__()\n", - " \n", " # 添加第一个持有者 Alice\n", " # 第一个参数 2 表明该持有者有多少个量子比特\n", " # 第二个参数用来标明该持有者的名字\n", " self.add_new_party(2, party_name='Alice')\n", - " \n", " # 添加第二个持有者 Bob\n", " self.add_new_party(2, party_name='Bob')\n", - " \n", + "\n", " # 定义一个贝尔对角态，四个系数对应 p1, p2, p3, p4\n", - " _state = paddle.to_tensor(bell_diagonal_state(p, (1-p)/2, (1-p)/3, (1-p)/6))\n", - " \n", + " _state = bell_diagonal_state([p, (1-p)/2, (1-p)/3, (1-p)/6])\n", " # ('Alice', 0) 表示 Alice 的第一个量子比特 A0\n", " # ('Bob', 0) 表示 Bob 的第一个量子比特 B0\n", - " self.set_init_state(_state, [('Alice', 0), ('Bob', 0)]) \n", - " \n", + " self.set_init_state(_state, [('Alice', 0), ('Bob', 0)])\n", " # ('Alice', 1) 表示 Alice 的第二个量子比特 A1\n", " # ('Bob', 1) 表示 Bob 的第二个量子比特 B1\n", - " self.set_init_state(_state, [('Alice', 1), ('Bob', 1)]) \n", - " \n", + " self.set_init_state(_state, [('Alice', 1), ('Bob', 1)])\n", + "\n", " # 创建两个参数 theta1 和 theta2 用来分别存储 Alice 和 Bob 的本地旋转门的角度\n", - " self.theta1 = paddle.to_tensor(np.array([np.pi/2, np.pi/2], dtype='float64'))\n", - " self.theta2 = paddle.to_tensor(np.array([-np.pi/2, -np.pi/2], dtype='float64'))\n", - " \n", - " def DEJMPS(self):\n", - " status = self.init_status\n", - " \n", + " self.theta1 = paddle.to_tensor(np.array([np.pi/2, np.pi/2]))\n", + " self.theta2 = paddle.to_tensor(np.array([-np.pi/2, -np.pi/2]))\n", " # 用电路模拟 Alice 的本地操作 \n", - " cir1 = self.create_ansatz('Alice')\n", - " cir1.rx(self.theta1[0], 0)\n", - " cir1.rx(self.theta1[1], 1)\n", - " cir1.cnot([0, 1])\n", - "\n", + " self.cir1 = self.create_ansatz('Alice')\n", + " self.cir1.rx(qubits_idx=0, param=self.theta1[0])\n", + " self.cir1.rx(qubits_idx=1, param=self.theta1[1])\n", + " self.cir1.cnot([0, 1])\n", " # 用电路模拟 Bob 的本地操作 \n", - " cir2 = self.create_ansatz('Bob')\n", - " cir2.rx(self.theta2[0], 0)\n", - " cir2.rx(self.theta2[1], 1)\n", - " cir2.cnot([0, 1])\n", - " \n", + " self.cir2 = self.create_ansatz('Bob')\n", + " self.cir2.rx(qubits_idx=0, param=self.theta2[0])\n", + " self.cir2.rx(qubits_idx=1, param=self.theta2[1])\n", + " self.cir2.cnot([0, 1])\n", + "\n", + " def DEJMPS(self):\n", + " status = self.init_status\n", " # 运行电路\n", - " status = cir1.run(status)\n", - " status_mid = cir2.run(status)\n", - " \n", + " status = self.cir1(status)\n", + " status_mid = self.cir2(status)\n", + "\n", " # 参数 ('Alice', 1) 表示测量 Alice 的第二个比特 A1\n", " # 参数 ('Bob', 1) 表示测量 Bob 的第二个比特 B1\n", " # 参数 ['00','11'] 表示我们希望的测量结果\n", " # status_mid 保留了测量得到 '00' 和 '11' 之后的四比特态\n", " status_mid = self.measure(status_mid, [('Alice', 1), ('Bob', 1)], [\"00\", \"11\"])\n", - " \n", + "\n", " # 对 A1&B1 求偏迹，用数组 [('Alice', 0), ('Bob', 0)] 表示想要保留的系统\n", " # status_fin 即为 A0 和 B0 的二比特态\n", " status_fin = self.partial_state(status_mid, [('Alice', 0), ('Bob', 0)])\n", - " \n", + "\n", " return status_fin" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:13:16.728882Z", @@ -256,12 +252,12 @@ "蒸馏的成功率为: 62.500%\n", "========================================================\n", "蒸馏后的态是:\n", - " [[ 0.45 +0.j 0. -0.j -0. +0.j 0.338-0.j]\n", - " [ 0. +0.j 0.05 +0.j 0.002-0.j 0. -0.j]\n", - " [ 0. +0.j 0.002+0.j 0.05 -0.j 0. -0.j]\n", - " [ 0.338+0.j -0. -0.j 0. +0.j 0.45 +0.j]]\n", - "初始态的 negativity: 0.19999999999999993\n", - "输出态的 negativity: 0.28800000000000003\n" + " [[0.45 +0.j 0. +0.j 0. +0.j 0.338+0.j]\n", + " [0. +0.j 0.05 +0.j 0.002+0.j 0. +0.j]\n", + " [0. +0.j 0.002+0.j 0.05 +0.j 0. +0.j]\n", + " [0.338+0.j 0. +0.j 0. +0.j 0.45 +0.j]]\n", + "初始态的 negativity: 0.19999995827674866\n", + "输出态的 negativity: 0.28800004720687866\n" ] } ], @@ -270,12 +266,12 @@ "status_fin = LOCC().DEJMPS()\n", "\n", "# 生成我们想要的目标态\n", - "target_state = paddle.to_tensor(bell_state(2))\n", + "target_state = bell_state(2)\n", "\n", "# 计算他们之间的保真度\n", "fidelity = 0\n", "for status in status_fin:\n", - " fidelity += paddle.real(trace(matmul(target_state, status.state)))\n", + " fidelity += paddle.real(trace(matmul(target_state.data, status.data)))\n", "fidelity /= len(status_fin)\n", "\n", "# 计算成功率\n", @@ -287,11 +283,11 @@ "print(f\"蒸馏的成功率为: {suc_rate.numpy()[0]:#.3%}\")\n", "\n", "# 输出终态\n", - "rho_out = status_fin[0].state.numpy()\n", + "rho_out = status_fin[0]\n", "print(\"========================================================\")\n", - "print(f\"蒸馏后的态是:\\n {np.around(rho_out, 4)}\")\n", - "print(f\"初始态的 negativity: {negativity(bell_diagonal_state(p, (1-p)/2, (1-p)/3, (1-p)/6))}\")\n", - "print(f\"输出态的 negativity: {negativity(rho_out)}\")" + "print(f\"蒸馏后的态是:\\n {np.around(rho_out.data.numpy(), 4)}\")\n", + "print(f\"初始态的 negativity: {negativity(bell_diagonal_state([p, (1-p)/2, (1-p)/3, (1-p)/6])).numpy()[0]}\")\n", + "print(f\"输出态的 negativity: {negativity(rho_out).numpy()[0]}\")" ] }, { @@ -328,7 +324,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -342,7 +338,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/locc/EntanglementDistillation_DEJMPS_EN.ipynb b/tutorials/locc/EntanglementDistillation_DEJMPS_EN.ipynb similarity index 81% rename from tutorial/locc/EntanglementDistillation_DEJMPS_EN.ipynb rename to tutorials/locc/EntanglementDistillation_DEJMPS_EN.ipynb index 9c5b3b1..056e340 100644 --- a/tutorial/locc/EntanglementDistillation_DEJMPS_EN.ipynb +++ b/tutorials/locc/EntanglementDistillation_DEJMPS_EN.ipynb @@ -21,7 +21,7 @@ "$$ \n", "\\begin{align*}\n", "|\\Phi^{\\pm}\\rangle_{AB} &= \\frac{1}{\\sqrt{2}}(|0\\rangle_A\\otimes|0\\rangle_B \\pm |1\\rangle_A\\otimes|1\\rangle_B), \\\\\n", - "|\\Psi^{\\pm}\\rangle_{AB} &= \\frac{1}{\\sqrt{2}}(|0\\rangle_A\\otimes|1\\rangle_B \\pm |1\\rangle_A\\otimes|0\\rangle_B). \n", + "|\\Psi^{\\pm}\\rangle_{AB} &= \\frac{1}{\\sqrt{2}}(|0\\rangle_A\\otimes|1\\rangle_B \\pm |1\\rangle_A\\otimes|0\\rangle_B),\n", "\\tag{1}\n", "\\end{align*}\n", "$$\n", @@ -48,7 +48,7 @@ "source": [ "## DEJMPS protocol\n", "\n", - "Suppose that two parties, namely Alice($A$) and Bob($B$), possess two copies of entangled qubit: $\\{ A_0, B_0 \\}, \\{ A_1, B_1 \\}$. If these two pairs are all in the same Bell-diagonal state $\\rho_{\\text{diag}}$, with $p_1 > 0.5$. We can apply the following workflow to purify the input states and leads to an output state has fidelity closer to $|\\Phi^+\\rangle$:\n", + "Suppose that two parties, namely Alice($A$) and Bob($B$), possess two copies of entangled qubit: $\\{ A_0, B_0 \\}, \\{ A_1, B_1 \\}$. If these two pairs are all in the same Bell-diagonal state $\\rho_{\\text{diag}}$, with $p_1 > 0.5$. We can apply the following workflow to purify the input states and obtain an output state that has a fidelity closer to $|\\Phi^+\\rangle$:\n", "1. Alice and Bob firstly choose the qubit pair **they want to keep as the memory qubit pair after distillation**. Here, they choose $A_0$ and $B_0$. \n", "2. Alice performs $R_x(\\pi/2)$ gates on both qubits, and Bob performs $R_x(-\\pi/2)$ gates on both qubits.\n", "3. Then, Alice and Bob both apply a CNOT gate on their qubits. Here, they choose $A_0,B_0$ as the control qubits and $A_1,B_1$ as the target qubits.\n", @@ -58,7 +58,7 @@ "
\n", "
Figure 1: Schematic diagram of the DEJMPS protocol
\n", "\n", - "After the distillation, the final state $\\rho_{out}$ of entangled pair $A_0, B_0$ will have higher fidelity than the initial state $\\rho$. The fidelity of the final state $F_{out}$ is\n", + "After the distillation, the final state $\\rho_{out}$ of entangled pair $A_0, B_0$ will have a higher fidelity than the initial state $\\rho$. The fidelity of the final state $F_{out}$ is\n", "\n", "$$\n", "F_{out} = \\frac{p_1^2 + p_4^2}{(p_1 + p_4)^2 + (p_2 + p_3)^2}.\n", @@ -83,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:13:33.570407Z", @@ -93,11 +93,14 @@ "outputs": [], "source": [ "import numpy as np\n", - "from paddle_quantum.locc import LoccNet\n", - "from paddle import matmul, trace\n", "import paddle\n", + "from paddle import matmul, trace\n", + "import paddle_quantum\n", + "from paddle_quantum.locc import LoccNet\n", "from paddle_quantum.state import bell_state, isotropic_state, bell_diagonal_state\n", - "from paddle_quantum.utils import negativity, logarithmic_negativity, is_ppt" + "from paddle_quantum.qinfo import negativity, logarithmic_negativity, is_ppt\n", + "# Change to density matrix mode\n", + "paddle_quantum.set_backend('density_matrix')" ] }, { @@ -117,7 +120,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:13:33.689788Z", @@ -144,7 +147,7 @@ " F_in = p[0]\n", " p_succ = (p[0] + p[3]) ** 2 + (p[1] + p[2]) ** 2\n", " F_out = (p[0] ** 2 + p[3] ** 2)/p_succ\n", - " \n", + "\n", " return F_in, F_out, p_succ\n", "\n", "p = 0.7\n", @@ -153,7 +156,7 @@ "print(\"The output fidelity is:\", F_out)\n", "print(\"With a probability of success:\", p_succ)\n", "print(\"The input state satisfies the PPT condition and hence not distillable?\", \n", - " is_ppt(bell_diagonal_state(p, (1-p)/2, (1-p)/3, (1-p)/6)))" + " is_ppt(bell_diagonal_state([p, (1-p)/2, (1-p)/3, (1-p)/6])))" ] }, { @@ -165,7 +168,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:13:35.397596Z", @@ -177,67 +180,61 @@ "class LOCC(LoccNet):\n", " def __init__(self):\n", " super(LOCC, self).__init__()\n", - " \n", " # Add the first party Alice \n", " # The first parameter 2 stands for how many qubits A holds\n", - " # The second parameter records the name of this qubit holder\n", + " # The second parameter records the name of this party\n", " self.add_new_party(2, party_name='Alice')\n", - " \n", " # Add the second party Bob\n", " # The first parameter 2 stands for how many qubits A holds\n", - " # The second parameter records the name of this qubit holder\n", + " # The second parameter records the name of this party\n", " self.add_new_party(2, party_name='Bob')\n", - " \n", + "\n", " # Define the input quantum states rho_in\n", - " _state = paddle.to_tensor(bell_diagonal_state(p, (1-p)/2, (1-p)/3, (1-p)/6))\n", - " \n", + " _state = bell_diagonal_state([p, (1-p)/2, (1-p)/3, (1-p)/6])\n", " # ('Alice', 0) means Alice's first qubit A0\n", " # ('Bob', 0) means Bob's first qubit B0\n", - " self.set_init_state(_state, [('Alice', 0), ('Bob', 0)]) \n", - " \n", + " self.set_init_state(_state, [('Alice', 0), ('Bob', 0)])\n", " # ('Alice', 1) means Alice's second qubit A1\n", " # ('Bob', 1) means Bob's second qubit B1\n", - " self.set_init_state(_state, [('Alice', 1), ('Bob', 1)]) \n", - " \n", + " self.set_init_state(_state, [('Alice', 1), ('Bob', 1)])\n", + "\n", " # Set the angles of the Rx gates\n", - " self.theta1 = paddle.to_tensor(np.array([np.pi/2, np.pi/2], dtype='float64'))\n", - " self.theta2 = paddle.to_tensor(np.array([-np.pi/2, -np.pi/2], dtype='float64'))\n", - " \n", - " def DEJMPS(self):\n", - " status = self.init_status\n", - " \n", - " # Create Alice's local operations \n", - " cir1 = self.create_ansatz('Alice')\n", - " cir1.rx(self.theta1[0], 0)\n", - " cir1.rx(self.theta1[1], 1)\n", - " cir1.cnot([0, 1])\n", + " self.theta1 = paddle.to_tensor([np.pi/2, np.pi/2])\n", + " self.theta2 = paddle.to_tensor([-np.pi/2, -np.pi/2])\n", "\n", + " # Create Alice's local operations \n", + " self.cir1 = self.create_ansatz('Alice')\n", + " self.cir1.rx(qubits_idx=0, param=self.theta1[0])\n", + " self.cir1.rx(qubits_idx=1, param=self.theta1[1])\n", + " self.cir1.cnot([0, 1])\n", " # Create Bob's local operations \n", - " cir2 = self.create_ansatz('Bob')\n", - " cir2.rx(self.theta2[0], 0)\n", - " cir2.rx(self.theta2[1], 1)\n", - " cir2.cnot([0, 1])\n", - " \n", + " self.cir2 = self.create_ansatz('Bob')\n", + " self.cir2.rx(qubits_idx=0, param=self.theta2[0])\n", + " self.cir2.rx(qubits_idx=1, param=self.theta2[1])\n", + " self.cir2.cnot([0, 1])\n", + "\n", + " def DEJMPS(self):\n", + " status = self.init_status\n", " # Run circuit\n", - " status = cir1.run(status)\n", - " status_mid = cir2.run(status)\n", - " \n", + " status = self.cir1(status)\n", + " status_mid = self.cir2(status)\n", + "\n", " # ('Alice', 1) means measuring Alice's second qubit A1\n", " # ('Bob', 1) means measuring Bob's second qubit B1\n", " # ['00','11'] specifies the success condition for distillation\n", " # Means Alice and Bob both measure '00' or '11'\n", " status_mid = self.measure(status_mid, [('Alice', 1), ('Bob', 1)], [\"00\", \"11\"])\n", - " \n", + "\n", " # Trace out the measured qubits A1&B1\n", " # Leaving only Alice’s first qubit and Bob’s first qubit A0&B0 as the memory register\n", " status_fin = self.partial_state(status_mid, [('Alice', 0), ('Bob', 0)])\n", - " \n", + "\n", " return status_fin" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:13:43.070659Z", @@ -254,12 +251,12 @@ "The probability of successful purification is: 62.500%\n", "========================================================\n", "The output state is:\n", - " [[ 0.45 +0.j 0. -0.j -0. +0.j 0.338-0.j]\n", - " [ 0. +0.j 0.05 +0.j 0.002-0.j 0. -0.j]\n", - " [ 0. +0.j 0.002+0.j 0.05 -0.j 0. -0.j]\n", - " [ 0.338+0.j -0. -0.j 0. +0.j 0.45 +0.j]]\n", - "The initial negativity is: 0.19999999999999993\n", - "The final negativity is: 0.28800000000000003\n" + " [[0.45 +0.j 0. +0.j 0. +0.j 0.338+0.j]\n", + " [0. +0.j 0.05 +0.j 0.002+0.j 0. +0.j]\n", + " [0. +0.j 0.002+0.j 0.05 +0.j 0. +0.j]\n", + " [0.338+0.j 0. +0.j 0. +0.j 0.45 +0.j]]\n", + "The initial negativity is: 0.19999995827674866\n", + "The final negativity is: 0.28800004720687866\n" ] } ], @@ -268,10 +265,10 @@ "status_fin = LOCC().DEJMPS()\n", "\n", "# Calculate fidelity\n", - "target_state = paddle.to_tensor(bell_state(2))\n", + "target_state = bell_state(2)\n", "fidelity = 0\n", "for status in status_fin:\n", - " fidelity += paddle.real(trace(matmul(target_state, status.state)))\n", + " fidelity += paddle.real(trace(matmul(target_state.data, status.data)))\n", "fidelity /= len(status_fin)\n", "\n", "# Calculate success rate\n", @@ -283,11 +280,11 @@ "print(f\"The probability of successful purification is: {suc_rate.numpy()[0]:#.3%}\")\n", "\n", "# Print the output state\n", - "rho_out = status_fin[0].state.numpy()\n", + "rho_out = status_fin[0]\n", "print(\"========================================================\")\n", - "print(f\"The output state is:\\n {np.around(rho_out,4)}\")\n", - "print(f\"The initial negativity is: {negativity(bell_diagonal_state(p, (1-p)/2, (1-p)/3, (1-p)/6))}\")\n", - "print(f\"The final negativity is: {negativity(rho_out)}\")" + "print(f\"The output state is:\\n {np.around(rho_out.data.numpy(), 4)}\")\n", + "print(f\"The initial negativity is: {negativity(bell_diagonal_state([p, (1-p)/2, (1-p)/3, (1-p)/6])).numpy()[0]}\")\n", + "print(f\"The final negativity is: {negativity(rho_out).numpy()[0]}\")" ] }, { @@ -303,7 +300,7 @@ "source": [ "## Conclusion\n", "\n", - "The DEJMPS protocol can effectively extract one entangled pair with higher fidelity from two noisy pairs. And compared to the BBPSSW protocol [2], it can be applied to Bell-diagonal states instead of isotropic states. Note that isotropic state is a special case of Bell-diagonal state. So in this sense, the DEJMPS protocol is more general than the BBPSSW protocol. However, it also shares the same disadvantages of the BBPSSW protocol including the limited type of input states and poor scalability. \n", + "The DEJMPS protocol can effectively extract one entangled pair with a higher fidelity from two noisy pairs. And compared to the BBPSSW protocol [2], it can be applied to Bell-diagonal states instead of isotropic states. Note that isotropic state is a special case of Bell-diagonal state. So in this sense, the DEJMPS protocol is more general than the BBPSSW protocol. However, it also shares the same disadvantages of the BBPSSW protocol including the limited type of input states and poor scalability. \n", "\n", "Next, We suggest interested readers to check the tutorial on [how to design a new distillation protocol with LOCCNet](./EntanglementDistillation_LOCCNet_EN.ipynb)." ] @@ -324,7 +321,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -338,7 +335,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.9" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/locc/EntanglementDistillation_LOCCNET_CN.ipynb b/tutorials/locc/EntanglementDistillation_LOCCNET_CN.ipynb similarity index 82% rename from tutorial/locc/EntanglementDistillation_LOCCNET_CN.ipynb rename to tutorials/locc/EntanglementDistillation_LOCCNET_CN.ipynb index eb7dafc..30ebd3d 100644 --- a/tutorial/locc/EntanglementDistillation_LOCCNET_CN.ipynb +++ b/tutorials/locc/EntanglementDistillation_LOCCNET_CN.ipynb @@ -84,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:14:25.259102Z", @@ -94,11 +94,14 @@ "outputs": [], "source": [ "import numpy as np\n", - "from paddle import matmul, trace\n", "import paddle\n", - "from paddle_quantum.locc import LoccAnsatz, LoccNet, LoccParty, LoccStatus\n", + "from paddle import matmul, trace\n", + "import paddle_quantum\n", + "from paddle_quantum.locc import LoccNet\n", "from paddle_quantum.state import isotropic_state, bell_state\n", - "from paddle_quantum.utils import logarithmic_negativity" + "from paddle_quantum.qinfo import logarithmic_negativity\n", + "# 切换至密度矩阵模式\n", + "paddle_quantum.set_backend('density_matrix')" ] }, { @@ -110,7 +113,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:14:25.296793Z", @@ -122,25 +125,16 @@ "class LOCC(LoccNet):\n", " def __init__(self):\n", " super(LOCC, self).__init__()\n", - " \n", + "\n", " # 添加第一个参与方 Alice\n", " # 第一个参数 4 代表着 Alice 手里有几个量子比特\n", " # 第二个参数代表着参与方的名字\n", " self.add_new_party(4, party_name=\"Alice\")\n", - " \n", " # 添加第二个参与方 Bob\n", " self.add_new_party(4, party_name=\"Bob\")\n", - " \n", - " # Alice 的参数\n", - " self.theta_1 = self.create_parameter(shape=[8, 3], default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi), dtype=\"float64\")\n", - " \n", - " # Bob 的参数\n", - " self.theta_2 = self.create_parameter(shape=[8, 3], default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi), dtype=\"float64\")\n", - " \n", + "\n", " # 生成输入态 isotropic state\n", - " _state = paddle.to_tensor(isotropic_state(2, 0.7))\n", - " \n", - " \n", + " _state = isotropic_state(2, 0.7)\n", " # 初始化量子态\n", " # ('Alice', 0) 代表 Alice 的第一个量子比特 A0\n", " # ('Bob', 0) 代表 Bob 的第一个量子比特 B0\n", @@ -149,53 +143,41 @@ " self.set_init_state(_state, [[\"Alice\", 2], [\"Bob\", 2]])\n", " self.set_init_state(_state, [[\"Alice\", 3], [\"Bob\", 3]])\n", "\n", - " def QNN(self, cir, theta):\n", + " # 创建 Alice 的局部操作\n", + " self.cir1 = self.create_ansatz(\"Alice\")\n", + " self.QNN(self.cir1)\n", + " # 创建 Bob 的局部操作\n", + " self.cir2 = self.create_ansatz(\"Bob\")\n", + " self.QNN(self.cir2)\n", + "\n", + " def QNN(self, cir):\n", " '''\n", " 定义图 1 中的 QNN\n", " '''\n", - " cir.u3(*theta[0], 0)\n", - " cir.u3(*theta[1], 1)\n", - " cir.u3(*theta[2], 2)\n", - " cir.u3(*theta[3], 3)\n", - " cir.cnot([0, 1])\n", - " cir.cnot([1, 2])\n", - " cir.cnot([2, 3])\n", - " cir.cnot([3, 0])\n", - " cir.u3(*theta[4], 0)\n", - " cir.u3(*theta[5], 1)\n", - " cir.u3(*theta[6], 2)\n", - " cir.u3(*theta[7], 3)\n", + " cir.u3('full')\n", + " cir.cnot('cycle')\n", + " cir.u3('full')\n", "\n", " def New_Protocol(self):\n", " status = self.init_status\n", - "\n", - " # 创建 Alice 的局部操作\n", - " cir1 = self.create_ansatz(\"Alice\")\n", - " self.QNN(cir1, self.theta_1)\n", - "\n", - " # 创建 Bob 的局部操作\n", - " cir2 = self.create_ansatz(\"Bob\")\n", - " self.QNN(cir2, self.theta_2)\n", - "\n", " # 运行 Alice 的电路\n", - " status = cir1.run(status)\n", - " \n", + " status = self.cir1(status)\n", " # 运行 Bob 的电路\n", - " status = cir2.run(status)\n", - " \n", + " status = self.cir2(status)\n", + "\n", " # 测量量子比特，[\"000000\", \"000011\",\"001100\",\"110000\",\"001111\",\"111100\",\"110011\",\"111111\"] 代表蒸馏成功的情况\n", " status1 = self.measure(status, [[\"Alice\", 1], [\"Bob\", 1],[\"Alice\", 2], [\"Bob\", 2], [\"Alice\", 3], [\"Bob\", 3]], \n", " [\"000000\", \"000011\", \"001100\", \"110000\", \"001111\", \"111100\", \"110011\", \"111111\"])\n", - " \n", " # 取偏迹除去测量后的量子比特，只留下 A0 & B0 \n", " status_fin = self.partial_state(status1, [[\"Alice\", 0], [\"Bob\", 0]])\n", - " target_state = paddle.to_tensor(bell_state(2))\n", - " \n", + " target_state = bell_state(2)\n", + "\n", " # 计算损失函数\n", " loss = 0\n", " for idx in range(0, len(status_fin)):\n", - " loss += 1 - paddle.real(trace(matmul(target_state, status_fin[idx].state)))[0]\n", - " return loss, status_fin\n" + " loss += 1 - paddle.real(trace(matmul(target_state.data, status_fin[idx].data)))\n", + "\n", + " return loss, status_fin" ] }, { @@ -207,7 +189,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:18:31.750336Z", @@ -219,31 +201,31 @@ "name": "stdout", "output_type": "stream", "text": [ - "itr 0: 5.7033257831039315\n", - "itr 10: 1.552207114278755\n", - "itr 20: 0.8980303153930879\n", - "itr 30: 0.7061224566044214\n", - "itr 40: 0.5713956826398692\n", - "itr 50: 0.5278055638406681\n", - "itr 60: 0.5121543497136843\n", - "itr 70: 0.5075981613869213\n", - "itr 80: 0.5052044047709767\n", - "itr 90: 0.5049323155027947\n", + "itr 0: 5.7033257\n", + "itr 10: 1.552211\n", + "itr 20: 0.8980296\n", + "itr 30: 0.7061223\n", + "itr 40: 0.57139534\n", + "itr 50: 0.5278059\n", + "itr 60: 0.5121539\n", + "itr 70: 0.50759834\n", + "itr 80: 0.5052042\n", + "itr 90: 0.50493234\n", "输入态的保真度为：0.77500\n", "输出态的保真度为：0.93690\n", "提纯成功率为：0.38654\n", "========================================================\n", "输出态为:\n", - " [[ 4.790e-01+0.j -1.000e-04-0.j 1.000e-04-0.j\n", - " 4.579e-01+0.0005j]\n", - " [-1.000e-04+0.j 2.100e-02+0.j 0.000e+00+0.j\n", - " -1.000e-04+0.j ]\n", - " [ 1.000e-04+0.j 0.000e+00-0.j 2.100e-02+0.j\n", - " 1.000e-04+0.0001j]\n", - " [ 4.579e-01-0.0005j -1.000e-04-0.j 1.000e-04-0.0001j\n", - " 4.790e-01+0.j ]]\n", - "初始态的 logarithmic negativity 为: 0.6322682154995127\n", - "输出态的 logarithmic negativity 为: 0.9059639124992761\n" + " [[ 4.790e-01-0.e+00j -1.000e-04-0.e+00j 1.000e-04-0.e+00j\n", + " 4.579e-01+5.e-04j]\n", + " [-1.000e-04+0.e+00j 2.100e-02+0.e+00j 0.000e+00+0.e+00j\n", + " -1.000e-04+0.e+00j]\n", + " [ 1.000e-04+0.e+00j 0.000e+00-0.e+00j 2.100e-02+0.e+00j\n", + " 1.000e-04+1.e-04j]\n", + " [ 4.579e-01-5.e-04j -1.000e-04-0.e+00j 1.000e-04-1.e-04j\n", + " 4.790e-01-0.e+00j]]\n", + "初始态的 logarithmic negativity 为: 0.6322681307792664\n", + "输出态的 logarithmic negativity 为: 0.9059638381004333\n" ] } ], @@ -254,19 +236,16 @@ "\n", "net = LOCC()\n", "# 选择 Adam 优化器\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", - "loss_list = [] \n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.cir1.parameters() + net.cir2.parameters())\n", "\n", "# 优化循环\n", "for itr in range(ITR):\n", " loss, status_fin = net.New_Protocol()\n", " # 反向传播\n", - " loss.backward() \n", + " loss.backward()\n", " opt.minimize(loss)\n", " # 清除梯度\n", - " opt.clear_grad() \n", - " loss_list.append(loss.numpy()[0])\n", - "\n", + " opt.clear_grad()\n", " # 打印训练结果\n", " if itr % 10 == 0:\n", " print(\"itr \" + str(itr) + \":\", loss.numpy()[0])\n", @@ -281,11 +260,11 @@ "print(\"输入态的保真度为：%.5f\" % fidelity_in)\n", "print(\"输出态的保真度为：%.5f\" % fidelity.numpy()[0])\n", "print(\"提纯成功率为：%.5f\" % suc_rate.numpy()[0])\n", - "rho_out = status_fin[0].state.numpy()\n", + "rho_out = status_fin[0]\n", "print(\"========================================================\")\n", - "print(f\"输出态为:\\n {np.around(rho_out, 4)}\")\n", - "print(f\"初始态的 logarithmic negativity 为: {logarithmic_negativity(isotropic_state(2, 0.7))}\")\n", - "print(f\"输出态的 logarithmic negativity 为: {logarithmic_negativity(rho_out)}\")" + "print(f\"输出态为:\\n {np.around(rho_out.data.numpy(), 4)}\")\n", + "print(f\"初始态的 logarithmic negativity 为: {logarithmic_negativity(isotropic_state(2, 0.7)).numpy()[0]}\")\n", + "print(f\"输出态的 logarithmic negativity 为: {logarithmic_negativity(rho_out).numpy()[0]}\")" ] }, { @@ -317,7 +296,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -331,7 +310,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/locc/EntanglementDistillation_LOCCNET_EN.ipynb b/tutorials/locc/EntanglementDistillation_LOCCNET_EN.ipynb similarity index 82% rename from tutorial/locc/EntanglementDistillation_LOCCNET_EN.ipynb rename to tutorials/locc/EntanglementDistillation_LOCCNET_EN.ipynb index eae4ed9..48c844f 100644 --- a/tutorial/locc/EntanglementDistillation_LOCCNET_EN.ipynb +++ b/tutorials/locc/EntanglementDistillation_LOCCNET_EN.ipynb @@ -87,7 +87,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:19:13.646334Z", @@ -97,23 +97,26 @@ "outputs": [], "source": [ "import numpy as np\n", - "from paddle import matmul, trace\n", "import paddle\n", - "from paddle_quantum.locc import LoccAnsatz, LoccNet, LoccParty, LoccStatus\n", + "from paddle import matmul, trace\n", + "import paddle_quantum\n", + "from paddle_quantum.locc import LoccNet\n", "from paddle_quantum.state import isotropic_state, bell_state\n", - "from paddle_quantum.utils import logarithmic_negativity" + "from paddle_quantum.qinfo import logarithmic_negativity\n", + "# Change to density matrix mode\n", + "paddle_quantum.set_backend('density_matrix')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Secondly, we define the QNN and loss function:" + "Secondly, we define the QNN and the loss function:" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:19:13.700268Z", @@ -125,78 +128,60 @@ "class LOCC(LoccNet):\n", " def __init__(self):\n", " super(LOCC, self).__init__()\n", - " \n", + "\n", " # Add the first party Alice \n", " # The first parameter 4 stands for how many qubits A holds\n", - " # The second parameter records the name of this qubit holder\n", + " # The second parameter records the name of this party\n", " self.add_new_party(4, party_name=\"Alice\")\n", - " \n", " # Add the second party Bob\n", " # The first parameter 4 stands for how many qubits B holds\n", - " # The second parameter records the name of this qubit holder\n", + " # The second parameter records the name of this party\n", " self.add_new_party(4, party_name=\"Bob\")\n", - " \n", - " # Alice‘s params\n", - " self.theta_1 = self.create_parameter(shape=[8, 3], default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi), dtype=\"float64\")\n", - " # Bob's params\n", - " self.theta_2 = self.create_parameter(shape=[8, 3], default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi), dtype=\"float64\")\n", - " \n", + "\n", " # Generate input isotropic states\n", - " _state = paddle.to_tensor(isotropic_state(2, 0.7))\n", - " \n", + " _state = isotropic_state(2, 0.7)\n", " # Distribute the pre-shared entangled states\n", " self.set_init_state(_state, [[\"Alice\", 0], [\"Bob\", 0]])\n", " self.set_init_state(_state, [[\"Alice\", 1], [\"Bob\", 1]])\n", " self.set_init_state(_state, [[\"Alice\", 2], [\"Bob\", 2]])\n", " self.set_init_state(_state, [[\"Alice\", 3], [\"Bob\", 3]])\n", "\n", - " def QNN(self, cir, theta):\n", + " # Create Alice's circuit\n", + " self.cir1 = self.create_ansatz(\"Alice\")\n", + " self.QNN(self.cir1)\n", + " # Create Bob's circuit\n", + " self.cir2 = self.create_ansatz(\"Bob\")\n", + " self.QNN(self.cir2)\n", + "\n", + " def QNN(self, cir):\n", " '''\n", " Define the QNN illustrated in Figure 1\n", " '''\n", - " cir.u3(*theta[0], 0)\n", - " cir.u3(*theta[1], 1)\n", - " cir.u3(*theta[2], 2)\n", - " cir.u3(*theta[3], 3)\n", - " cir.cnot([0, 1])\n", - " cir.cnot([1, 2])\n", - " cir.cnot([2, 3])\n", - " cir.cnot([3, 0])\n", - " cir.u3(*theta[4], 0)\n", - " cir.u3(*theta[5], 1)\n", - " cir.u3(*theta[6], 2)\n", - " cir.u3(*theta[7], 3)\n", + " cir.u3('full')\n", + " cir.cnot('cycle')\n", + " cir.u3('full')\n", "\n", " def New_Protocol(self):\n", " status = self.init_status\n", - "\n", - " # Create Alice's circuit\n", - " cir1 = self.create_ansatz(\"Alice\")\n", - " self.QNN(cir1, self.theta_1)\n", - "\n", - " # Create Bob's circuit\n", - " cir2 = self.create_ansatz(\"Bob\")\n", - " self.QNN(cir2, self.theta_2)\n", - "\n", " # Execute Alice's circuit\n", - " status = cir1.run(status)\n", - " \n", + " status = self.cir1(status)\n", " # Execute Bob's circuit\n", - " status = cir2.run(status)\n", - " \n", + " status = self.cir2(status)\n", + "\n", " # Measure qubits，[\"000000\", \"000011\",\"001100\",\"110000\",\"001111\",\"111100\",\"110011\",\"111111\"] represent successful cases\n", " status1 = self.measure(status, [[\"Alice\", 1], [\"Bob\", 1],[\"Alice\", 2], [\"Bob\", 2], [\"Alice\", 3], [\"Bob\", 3]], \n", " [\"000000\", \"000011\", \"001100\", \"110000\", \"001111\", \"111100\", \"110011\", \"111111\"])\n", - " \n", + "\n", " # Trace out all the qubits but A_0 and B_0\n", " status_fin = self.partial_state(status1, [[\"Alice\", 0], [\"Bob\", 0]])\n", - " target_state = paddle.to_tensor(bell_state(2))\n", - " \n", + " target_state = bell_state(2)\n", + "\n", " # Calculate loss function\n", " loss = 0\n", " for idx in range(0, len(status_fin)):\n", - " loss += 1 - paddle.real(trace(matmul(target_state, status_fin[idx].state)))[0]\n", - " return loss, status_fin\n" + " loss += 1 - paddle.real(trace(matmul(target_state.data, status_fin[idx].data)))\n", + "\n", + " return loss, status_fin" ] }, { @@ -208,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:22:27.071785Z", @@ -220,31 +205,31 @@ "name": "stdout", "output_type": "stream", "text": [ - "itr 0: 5.7033257831039315\n", - "itr 10: 1.552207114278755\n", - "itr 20: 0.8980303153930879\n", - "itr 30: 0.7061224566044214\n", - "itr 40: 0.5713956826398692\n", - "itr 50: 0.5278055638406681\n", - "itr 60: 0.5121543497136843\n", - "itr 70: 0.5075981613869213\n", - "itr 80: 0.5052044047709767\n", - "itr 90: 0.5049323155027947\n", + "itr 0: 5.7033257\n", + "itr 10: 1.552211\n", + "itr 20: 0.8980296\n", + "itr 30: 0.7061223\n", + "itr 40: 0.57139534\n", + "itr 50: 0.5278059\n", + "itr 60: 0.5121539\n", + "itr 70: 0.50759834\n", + "itr 80: 0.5052042\n", + "itr 90: 0.50493234\n", "The fidelity of the input quantum state is：0.77500\n", "The fidelity of the purified quantum state is： 0.93690\n", "The probability of successful purification is：0.38654\n", "========================================================\n", "The output state is:\n", - " [[ 4.790e-01+0.j -1.000e-04-0.j 1.000e-04-0.j\n", - " 4.579e-01+0.0005j]\n", - " [-1.000e-04+0.j 2.100e-02+0.j 0.000e+00+0.j\n", - " -1.000e-04+0.j ]\n", - " [ 1.000e-04+0.j 0.000e+00-0.j 2.100e-02+0.j\n", - " 1.000e-04+0.0001j]\n", - " [ 4.579e-01-0.0005j -1.000e-04-0.j 1.000e-04-0.0001j\n", - " 4.790e-01+0.j ]]\n", - "The initial logarithmic negativity is: 0.6322682154995127\n", - "The final logarithmic negativity is: 0.9059639124992761\n" + " [[ 4.790e-01-0.e+00j -1.000e-04-0.e+00j 1.000e-04-0.e+00j\n", + " 4.579e-01+5.e-04j]\n", + " [-1.000e-04+0.e+00j 2.100e-02+0.e+00j 0.000e+00+0.e+00j\n", + " -1.000e-04+0.e+00j]\n", + " [ 1.000e-04+0.e+00j 0.000e+00-0.e+00j 2.100e-02+0.e+00j\n", + " 1.000e-04+1.e-04j]\n", + " [ 4.579e-01-5.e-04j -1.000e-04-0.e+00j 1.000e-04-1.e-04j\n", + " 4.790e-01-0.e+00j]]\n", + "The initial logarithmic negativity is: 0.6322681307792664\n", + "The final logarithmic negativity is: 0.9059638381004333\n" ] } ], @@ -254,10 +239,8 @@ "paddle.seed(999)\n", "\n", "net = LOCC()\n", - "\n", "# Choose Adam optimizer\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", - "loss_list = [] \n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.cir1.parameters() + net.cir2.parameters())\n", "\n", "# Optimization loop\n", "for itr in range(ITR):\n", @@ -266,12 +249,11 @@ " loss.backward() \n", " opt.minimize(loss)\n", " # Clean gradients\n", - " opt.clear_grad() \n", - " loss_list.append(loss.numpy()[0])\n", - "\n", + " opt.clear_grad()\n", " # Print training result\n", " if itr % 10 == 0:\n", " print(\"itr \" + str(itr) + \":\", loss.numpy()[0])\n", + "\n", "# Calculate input state fidelity\n", "fidelity_in = (3 * 0.7 + 1) / 4\n", "# Calculate output state fidelity\n", @@ -282,11 +264,11 @@ "print(\"The fidelity of the input quantum state is：%.5f\" % fidelity_in)\n", "print(\"The fidelity of the purified quantum state is： %.5f\" % fidelity.numpy()[0])\n", "print(\"The probability of successful purification is：%.5f\" % suc_rate.numpy()[0])\n", - "rho_out = status_fin[0].state.numpy()\n", + "rho_out = status_fin[0]\n", "print(\"========================================================\")\n", - "print(f\"The output state is:\\n {np.around(rho_out, 4)}\")\n", - "print(f\"The initial logarithmic negativity is: {logarithmic_negativity(isotropic_state(2, 0.7))}\")\n", - "print(f\"The final logarithmic negativity is: {logarithmic_negativity(rho_out)}\")" + "print(f\"The output state is:\\n {np.around(rho_out.data.numpy(), 4)}\")\n", + "print(f\"The initial logarithmic negativity is: {logarithmic_negativity(isotropic_state(2, 0.7)).numpy()[0]}\")\n", + "print(f\"The final logarithmic negativity is: {logarithmic_negativity(rho_out).numpy()[0]}\")" ] }, { @@ -319,7 +301,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -333,7 +315,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/locc/LOCCNET_Tutorial_CN.ipynb b/tutorials/locc/LOCCNET_Tutorial_CN.ipynb similarity index 97% rename from tutorial/locc/LOCCNET_Tutorial_CN.ipynb rename to tutorials/locc/LOCCNET_Tutorial_CN.ipynb index 462d613..af65b39 100644 --- a/tutorial/locc/LOCCNET_Tutorial_CN.ipynb +++ b/tutorials/locc/LOCCNET_Tutorial_CN.ipynb @@ -65,7 +65,6 @@ "source": [ "这一部分，我们将解释 LOCCNet 的主要函数，让读者明白如何使用该框架。首先，我们展示一段伪代码：\n", "\n", - "\n", "```python\n", "from paddle_quantum.locc import LoccNet\n", "\n", @@ -73,15 +72,16 @@ " def __init__(self):\n", " super(Net, self).__init__()\n", " # Step 0: 初始化系统\n", - " # Step 1: 初始化 QNN 参数\n", - " # Step 2: 设置初始量子态\n", + " # Step 1: 设置初始量子态\n", + " # Step 2: 定义 QNNs\n", " \n", " def forward(self):\n", - " # Step 3: 定义并执行 QNNs\n", + " # Step 3: 执行 QNNs\n", " # Step 4: 定义 protocol 的具体过程\n", " # Step 5: 计算损失函数\n", " return loss, final_status\n", "```\n", + "\n", "首先，我们需要创建一个类 `class Net(LoccNet)` 来储存量子系统，与此同时，这个类也继承了 `LoccNet` 中的函数。LOCC 协议的主体部分都是在这个类 `Net()` 中实现的，它包含两个函数：`__init__()` and `forward()`。" ] }, @@ -89,11 +89,13 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "在 `__init__()` 函数中，我们需要初始化所有的参与方、量子态以及 QNN 的参数。\n", + "在 `__init__()` 函数中，我们需要初始化所有的参与方、量子态以及 QNN。\n", "\n", "- `self.add_new_party(qubits_number, party_name=None)` 是用于添加一个新的参与方的函数，第一个参数代表该参与方有几个量子比特；第二个参数是可选参数，代表着参与者的名字。在协议中，我们可以选择使用名字来指定参与方，也可以选择用编号来指定。如果我们希望使用名字，那么只需要在 `add_new_party` 函数中给 `party_name` 命名；如果希望使用编号，那么我们就不用给第二个参数赋值，第一个参与方会自动编号为 0，每增加一个参与方，其编号都会加一，同时该函数会将所添加的 party 的 ID 返回，其值根据定义会是 `int` 或者 `str`。\n", "\n", - "- `self.set_init_state(state, which_qubits)` 是用于设置协议的初始态的函数。第一个参数 `state` 是量子态，必须是密度矩阵的形式；第二个参数 `which_qubits` 是定位量子比特（哪一参与方的第几个量子比特，如 `(\"Alice\", 0)`）。需要说明的是，我们必须初始化所有的量子比特，否则程序将出现错误。" + "- `self.set_init_state(state, which_qubits)` 是用于设置协议的初始态的函数。第一个参数 `state` 是量子态，必须是密度矩阵的形式；第二个参数 `which_qubits` 是定位量子比特（哪一参与方的第几个量子比特，如 `(\"Alice\", 0)`）。需要说明的是，我们必须初始化所有的量子比特，否则程序将出现错误。\n", + "\n", + "- `self.create_ansatz(party_id)` 是为某一参与方创建本地量子电路的函数。所以参数 `party_id` 用来指定参与方。举个例子 `cir1 = self.create_ansatz(\"Alice\")` 为 Alice 创建了电路。之后，我们可以在电路中添加不同的操作比如 X 门、CNOT 门等." ] }, { @@ -102,7 +104,7 @@ "source": [ "在 `forward()` 函数中，我们需要定义协议的流程。如果我们想要训练一个模型，那么需要定义损失函数，并设置为 `forward()` 的返回值，这样才能不断更新参数使得损失函数最小化。如果我们仅仅是想要验证某个协议的结果，我们就做上述的事情，只需要把协议的流程定义清楚，就可以把我们感兴趣的值设为返回值。在 `forward()` 函数中，我们主要做两件事情--量子操作和测量，我们为他们提供了相应的函数：\n", "\n", - "- `self.create_ansatz(party_id)` 是为某一参与方创建本地量子电路的函数。所以参数 `party_id` 用来指定参与方。举个例子 `cir1 = self.create_ansatz(\"Alice\")` 为 Alice 创建了电路。之后，我们可以在电路中添加不同的操作比如 X 门， CNOT 门等，也可以在添加门之后通过 `run()` 函数来运行电路，得到运行后的结果，如 `status_out = cir1.run(status)`。\n", + "- 运行电路，得到运行后的结果，如 `status_out = cir1(status)`。\n", "\n", "- `self.measure(status, which_qubits, results_desired, theta=None)` 是用来进行测量的函数。第一个参数 `status` 是我们想要测量的态；第二个参数 `which_qubits` 代表着要测量的是哪一个量子比特。如果我们想测量的是 Alice 手中第 0 个量子比特，那么就需要给第二个参数赋值 `(\"Alice\", 0)`。如果我们想要同时测量两个量子比特，比如 Alice 手中的第 0 个量子比特和 Bob 手中的第 1 个量子比特，那么这个参数需要设为 `[(\"Alice\", 0), (\"Bob\", 1)]`。第三个参数 `results_desired` 是我们希望测量的结果，它只可以为 `\"0\"`，`\"1\"`，或者 `[\"0\", \"1\"]`。第四个参数 `theta` 是用于含参测量，如果我们不希望做含参测量操作，那么就不用给它赋值。\n", "\n", @@ -161,7 +163,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -175,7 +177,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/locc/LOCCNET_Tutorial_EN.ipynb b/tutorials/locc/LOCCNET_Tutorial_EN.ipynb similarity index 83% rename from tutorial/locc/LOCCNET_Tutorial_EN.ipynb rename to tutorials/locc/LOCCNET_Tutorial_EN.ipynb index b439701..c4028b4 100644 --- a/tutorial/locc/LOCCNET_Tutorial_EN.ipynb +++ b/tutorials/locc/LOCCNET_Tutorial_EN.ipynb @@ -15,7 +15,7 @@ "source": [ "## Overview\n", "\n", - "Quantum entanglement is an essential physical resource for quantum communication, quantum computation, and many other quantum technologies. Therefore, the ability to manipulate quantum entanglement reliably is an essential task if we want to build real applications in those fields. In the Noisy Intermediate-Scale Quantum (NISQ) era, directly transferring quantum information between the communication nodes inside a quantum network is an arduous task. Hence, the most natural set of operations to manipulate entanglement at this stage is the so-called Local Operations and Classical Communication (LOCC) [1] instead of global operations. Under this setup, several spatially separated parties can only implement local operations in their own labs and later communicates their measurement results (classical information) through a classical channel. Still, it is very challenging to design LOCC protocols for entanglement manipulation and further distributed quantum information processing tasks since the structure of LOCC is in general complicated and hard to characterize mathematically. To better explore the possibilities of near-term entanglement manipulation and long-term quantum information processing, we introduce **LOCCNet**, a machine learning framework for LOCC protocol design [2]." + "Quantum entanglement is an essential physical resource for quantum communication, quantum computation, and many other quantum technologies. Therefore, the ability to manipulate quantum entanglement reliably is an essential task if we want to build real applications in those fields. In the Noisy Intermediate-Scale Quantum (NISQ) era, directly transferring quantum information between the communication nodes inside a quantum network is an arduous task. Hence, the most natural set of operations to manipulate entanglement at this stage is the so-called Local Operations and Classical Communication (LOCC) [1] instead of global operations. Under this setup, several spatially separated parties can only implement local operations in their own labs and later communicate their measurement results (classical information) through a classical channel. Still, it is very challenging to design LOCC protocols for entanglement manipulation and further distributed quantum information processing tasks since the structure of LOCC is in general complicated and hard to characterize mathematically. To better explore the possibilities of near-term entanglement manipulation and long-term quantum information processing, we introduce **LOCCNet**, a machine learning framework for LOCC protocol design [2]." ] }, { @@ -47,7 +47,7 @@ "source": [ "## Philosophy of LOCCNet\n", "\n", - "Inspired by the success of Machine Learning (ML) in solving the quantum many-body problem [8] and protein folding structure prediction [9], we would like to adopt the learning capability of ML to help search optimal LOCC protocols among many possible combinations. The basic idea of LOCCNet is to utilize quantum neural networks (QNNs) to represent each local quantum operation $\\mathcal{E}^{(k)}_j$. That means each node represented in the tree graph of an LOCC protocol is now replaced by a QNN, which is essentially a parametrize quantum circuit (PQC) denoted by $U(\\boldsymbol \\theta)$. In Paddle Quantum, we already provide many QNN templates to reduce the learning cost for users. Once we set up the QNN, we can freely choose the measurement and communication plan. One last recipe we would need is a learning objective which is usually encoded as a loss function $L$. For example in quantum teleportation, the learning objective could be maximizing the state fidelity between Alice's state $|\\psi\\rangle$ and the state Bob receives $|\\phi\\rangle$ under four possible measurement results, meaning that $L \\equiv \\sum_{m_1m_2} \\big(1- F(|\\psi\\rangle, |\\phi\\rangle)\\big)$. The loss function should be designed according to the specific goal we want to accomplish. Finally, classical optimization methods (mainly gradient-based) will be applied to train the parameters in each QNN. Once the optimization has been done, we could obtain a near-optimal LOCC protocol. From our perspective, such a framework could sharply reduce the efforts to develop novel LOCC protocols, and the results should be easy to verify by experiments.\n", + "Inspired by the success of Machine Learning (ML) in solving the quantum many-body problem [8] and protein folding structure prediction [9], we would like to adopt the learning capability of ML to help search optimal LOCC protocols among many possible combinations. The basic idea of LOCCNet is to utilize quantum neural networks (QNNs) to represent each local quantum operation $\\mathcal{E}^{(k)}_j$. That means each node represented in the tree graph of an LOCC protocol is now replaced by a QNN, which is essentially a parameterized quantum circuit (PQC) denoted by $U(\\boldsymbol \\theta)$. In Paddle Quantum, we already provide many QNN templates to reduce the learning cost for users. Once we set up the QNN, we can freely choose the measurement and communication plan. One last recipe we would need is a learning objective which is usually encoded as a loss function $L$. For example in quantum teleportation, the learning objective could be maximizing the state fidelity between Alice's state $|\\psi\\rangle$ and the state Bob receives $|\\phi\\rangle$ under four possible measurement results, meaning that $L \\equiv \\sum_{m_1m_2} \\big(1- F(|\\psi\\rangle, |\\phi\\rangle)\\big)$. The loss function should be designed according to the specific goal we want to accomplish. Finally, classical optimization methods (mainly gradient-based) will be applied to train the parameters in each QNN. Once the optimization has been done, we could obtain a near-optimal LOCC protocol. From our perspective, such a framework could sharply reduce the efforts to develop novel LOCC protocols, and the results should be easy to verify by experiments.\n", "\n", "\n", "**Note:** LOCCNet only supports density matrix formulation at the current version." @@ -73,34 +73,36 @@ " def __init__(self):\n", " super(Net, self).__init__()\n", " # Step 0: System initialization \n", - " # Step 1: QNN parameter initialization \n", - " # Step 2: Set up the initial quantum states\n", + " # Step 1: Set up the initial quantum states\n", + " # Step 2: Define QNNs\n", "\n", " def forward(self):\n", - " # Step 3: Define and execute QNNs\n", + " # Step 3: Execute QNNs\n", " # Step 4: Measurement\n", " # Step 5: Calculate the loss function\n", " return loss, final_status\n", "```\n", "\n", - "Firstly, we need to create a python class through `class Net(LoccNet)` to reserve the complete quantum system and many helpful functions will be inherited from `LoccNet`. The main body of an LOCC protocol is realized in this customized class `Net()` which consists of two functions -- `__init__()` and `forward()`. In the `__init__()` function, you can initialize all the remote parties, quantum state in each subsystem, and the parameters of QNN.\n", + "Firstly, we need to create a python class through `class Net(LoccNet)` to reserve the complete quantum system and many helpful functions will be inherited from `LoccNet`. The main body of an LOCC protocol is realized in this customized class `Net()` which consists of two functions -- `__init__()` and `forward()`. In the `__init__()` function, you can initialize all the remote parties, quantum state in each subsystem, and the QNNs.\n", "\n", "- `self.add_new_party(qubits_number, party_name=None)` is used to add one party, the first parameter means the number of qubits held by this party; the second parameter is optional, which stands for the party's name. In a protocol, you can choose to identify each party either by their name character ID or a number ID. If you want to use the mode of character, you need to specify `party_name` when calling `add_new_party`; if you choose the latter mode, you don't need to set them, and the numbers will increase from 0 in the order you add them.\n", "\n", - "- `self.set_init_state(state, which_qubits)` is used to set the initial quantum state to be processed by your protocol. Here `state` is always in density matrix formulation, and `which_qubits` represents the identification of quantum states (belong to which qubits held by certain parties). It should be noted that you must give all the qubits to the initial quantum state through this function. Otherwise, the program will occur unexpected errors." + "- `self.set_init_state(state, which_qubits)` is used to set the initial quantum state to be processed by your protocol. Here `state` is always in density matrix formulation, and `which_qubits` represents the identification of quantum states (belong to which qubits held by certain parties). It should be noted that you must give all the qubits to the initial quantum state through this function. Otherwise, the program will occur unexpected errors.\n", + "\n", + "- `self.create_ansatz(party_id)` is to create the local quantum circuit of some party, hence you should specify the party through `party_id`. For example, `cir1 = self.create_ansatz(\"Alice\")`creates a circuit belonging to Alice, and we can manipulate Alice's qubits through this circuit, add X gates, add CNOT gates, and so on." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "In the `forward()` function, we can define the specific workflow of the protocol. If you want to train a model, you need to define the loss function as the return value of the function `forward()` which will be minimize by update the trainable parameters. If you just want to verify the result of a protocol, you don't need to define the loss function and can return the object of interests, such as the final quantum state, the probability to get reach that state, and so on. Generally, we mainly perform two operations in the function `forward()`, quantum operations and measurement. We also provide corresponding functions for these two operations:\n", + "In the `forward()` function, we can define the specific workflow of the protocol. If you want to train a model, you need to define the loss function as the return value of the function `forward()` which will be minimized by updating the trainable parameters. If you just want to verify the result of a protocol, you don't need to define the loss function and can return the object of interests, such as the final quantum state, the probability to get reach that state, and so on. Generally, we mainly perform two operations in the function `forward()`, quantum operations and measurement. We also provide corresponding functions for these two operations:\n", "\n", - "- `self.create_ansatz(party_id)` is to create the local quantum circuit of some party, hence you should specify the party through `party_id`. For example, `cir1 = self.create_ansatz(\"Alice\")`creates a circuit belonging to Alice, and we can manipulate Alice's qubits through this circuit, add X gates, add CNOT gates, and so on.\n", + "- Execute quantum circuits to obtain the output result, e.g., `status_out = cir1(status)`.\n", "\n", "- `self.measure(status, which_qubits, results_desired, theta=None)` is the measurement function we provided in `LoccNet`. The `status` is the `LoccStatus` you want to measure, which we will introduce below. `which_qubits` means the qubits you want to measure. If you want to measure Alice's 0th qubit, just assign `which_qubits` to `(\"Alice\", 0)`. If you want to measure Alice's 0th qubit and Bob's 1st qubit at the same time, you can assign `which_qubits` to `[(\"Alice\", 0), (\"Bob\", 1)]`. `results_desired` is the measurement result you want, it can only include `\"0\"`, `\"1\"`, or `[\"0\", \"1\"]`. `theta` means the parameter of parameterized measurement, which you don't need to provide if you want to measure without parameter.\n", "\n", - "- `LoccStatus`: In `LoccNet`, the smallest information processing unit we use is not a quantum state, but something we call the `LoccStatus`. It includes quantum state, the probability from the initial situation to this state, and the measurement results in this process. Sometimes, the state you want to get is not single, which means there are many situations in this protocol that are considered successful. We can also meet this demand. In the function `self.measure()`，if the parameter `results_desired` you given is a list, which means you want to get several `LoccStatus`, it would return a list of `LoccStatus`." + "- `LoccStatus`: In `LoccNet`, the smallest information processing unit we use is not a quantum state, but something we call the `LoccStatus`. It includes quantum state, the probability from the initial situation to this state, and the measurement results in this process. Sometimes, the state you want to get is not single, which means there are many situations in this protocol that are considered successful. We can also meet this demand. In the function `self.measure()`，if the parameter `results_desired` you give is a list, which means you want to get several `LoccStatus`, it would return a list of `LoccStatus`." ] }, { @@ -153,7 +155,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -167,7 +169,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/locc/QuantumTeleportation_CN.ipynb b/tutorials/locc/QuantumTeleportation_CN.ipynb similarity index 72% rename from tutorial/locc/QuantumTeleportation_CN.ipynb rename to tutorials/locc/QuantumTeleportation_CN.ipynb index f08eb11..77067fb 100644 --- a/tutorial/locc/QuantumTeleportation_CN.ipynb +++ b/tutorials/locc/QuantumTeleportation_CN.ipynb @@ -83,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:22:58.705389Z", @@ -93,11 +93,14 @@ "outputs": [], "source": [ "import numpy as np\n", - "from paddle_quantum.locc import LoccNet\n", - "from paddle import matmul, trace\n", "import paddle\n", - "from paddle_quantum.utils import state_fidelity\n", - "from paddle_quantum.state import bell_state, isotropic_state, density_op_random" + "from paddle import matmul, trace\n", + "import paddle_quantum\n", + "from paddle_quantum.locc import LoccNet\n", + "from paddle_quantum.qinfo import state_fidelity\n", + "from paddle_quantum.state import bell_state, isotropic_state, random_state\n", + "# 切换至密度矩阵模式\n", + "paddle_quantum.set_backend('density_matrix')" ] }, { @@ -109,7 +112,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:23:06.232030Z", @@ -121,27 +124,21 @@ "class LOCC(LoccNet):\n", " def __init__(self):\n", " super(LOCC, self).__init__()\n", - " \n", " # 添加第一个参与方 Alice\n", " # 第一个参数 2 代表着 Alice 手里有几个量子比特\n", " # 第二个参数代表着参与方的名字\n", " self.add_new_party(2, party_name=\"Alice\")\n", - " \n", " # 添加第二个参与方 Bob\n", " # 第一个参数 1 代表着 Bob 手里有几个量子比特\n", " # 第二个参数代表着参与方的名字\n", " self.add_new_party(1, party_name=\"Bob\")\n", - " \n", "\n", " # 准备一个贝尔态\n", - " _state = paddle.to_tensor(bell_state(2))\n", - " # _state = paddle.to_tensor(isotropic_state(2, 0.8))\n", + " _state = bell_state(2)\n", + " # _state = isotropic_state(2, 0.8) \n", + " # 随机制备传输用的纯态（rank=1）\n", + " self.state_C = random_state(num_qubits=1, rank=1)\n", "\n", - " \n", - " # 随机制备传输用的纯态 （rank =1）\n", - " random_state = density_op_random(n=1, real_or_complex=2, rank=1)\n", - " self.state_C = paddle.to_tensor(random_state)\n", - " \n", " # 通过分配上述制备好的量子态初始化整个量子系统\n", " # 这里 (\"Alice\", 0) 即表示量子比特 C\n", " # 这里 (\"Alice\", 1) 即表示量子比特 A\n", @@ -150,69 +147,40 @@ " self.set_init_state(self.state_C, [(\"Alice\", 0)])\n", " self.set_init_state(_state, [(\"Alice\", 1), (\"Bob\", 0)])\n", "\n", + " # 设置 Alice 的本地操作\n", + " self.cirA = self.create_ansatz(\"Alice\")\n", + " self.cirA.cnot([0, 1])\n", + " self.cirA.h(0)\n", + " # 创建 Bob 的本地操作\n", + " self.cirB = [self.create_ansatz(\"Bob\") for _ in range(4)]\n", + " self.cirB[1].x(0)\n", + " self.cirB[2].z(0)\n", + " self.cirB[3].x(0)\n", + " self.cirB[3].z(0)\n", "\n", " def teleportation(self):\n", " status = self.init_status\n", - " \n", - " # 设置 Alice 的本地操作\n", - " cirA = self.create_ansatz(\"Alice\")\n", - " cirA.cnot([0, 1])\n", - " cirA.h(0)\n", - " \n", " # 运行上述电路\n", - " status = cirA.run(status)\n", - " \n", + " status = self.cirA(status)\n", " # Alice 在计算基上测量她所持有的两个量子比特 C 还有 A\n", " # 得到并记录四种结果 00，01，10，11\n", " status_A = self.measure(status, [(\"Alice\", 0), (\"Alice\", 1)], [\"00\", \"01\", \"10\", \"11\"])\n", - " \n", + "\n", " # 用于记录平均保真度\n", " fid_list = []\n", - "\n", " # Bob 根据 Alice 的测量结果选择不同的门作用在自己的量子比特上\n", " for i, s in enumerate(status_A):\n", - " \n", - " # 判断语句根据 Alice 的测量结果，进行不同操作 \n", - " if status_A[i].measured_result == '00':\n", - " \n", - " # 创建 Bob 的本地操作\n", - " cirB = self.create_ansatz(\"Bob\")\n", - " \n", - " # 执行电路\n", - " status_B = cirB.run(s) \n", - " \n", - " # 仅保留 Bob 的量子比特 B\n", - " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", - "\n", - " # 计算初始态和传输后态之间的保真度\n", - " fid = state_fidelity(self.state_C.numpy(), status_fin.state.numpy())**2\n", - " fid_list.append(fid * status_fin.prob.numpy()[0])\n", - " \n", - " # 以下操作类似\n", - " elif status_A[i].measured_result == '01':\n", - " cirB = self.create_ansatz(\"Bob\")\n", - " cirB.x(0)\n", - " status_B = cirB.run(s)\n", - " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", - " fid = state_fidelity(self.state_C.numpy(), status_fin.state.numpy())**2\n", - " fid_list.append(fid * status_fin.prob.numpy()[0])\n", - " elif status_A[i].measured_result == '10':\n", - " cirB = self.create_ansatz(\"Bob\")\n", - " cirB.z(0)\n", - " status_B = cirB.run(s)\n", - " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", - " fid = state_fidelity(self.state_C.numpy(), status_fin.state.numpy())**2\n", - " fid_list.append(fid * status_fin.prob.numpy()[0])\n", - " elif status_A[i].measured_result == '11':\n", - " cirB = self.create_ansatz(\"Bob\")\n", - " cirB.x(0)\n", - " cirB.z(0)\n", - " status_B = cirB.run(s)\n", - " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", - " fid = state_fidelity(self.state_C.numpy(), status_fin.state.numpy())**2\n", - " fid_list.append(fid * status_fin.prob.numpy()[0])\n", + " # 根据 Alice 的测量结果，进行不同操作\n", + " cirB = self.cirB[int(status_A[i].measured_result, 2)]\n", + " # 执行电路\n", + " status_B = cirB(s)\n", + " # 仅保留 Bob 的量子比特 B\n", + " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", + " # 计算初始态和传输后态之间的保真度\n", + " fid = state_fidelity(self.state_C, status_fin) ** 2\n", + " fid_list.append(fid * status_fin.prob)\n", " fid_avg = sum(fid_list)\n", - " \n", + "\n", " return fid_avg" ] }, @@ -230,7 +198,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:23:14.626278Z", @@ -242,7 +210,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "平均保真度 = 1.0 , 标准差 = 6.429150606796583e-09\n" + "平均保真度 = 1.0 , 标准差 = 4.0480725e-07\n" ] } ], @@ -253,9 +221,9 @@ "np.random.seed(SEED)\n", "# 开始采样 \n", "for idx in range(num_state):\n", - " list_fid.append(LOCC().teleportation())\n", + " list_fid.append(LOCC().teleportation().numpy())\n", "\n", - "print('平均保真度 =', np.around(sum(list_fid)/len(list_fid), 4), ', 标准差 =', np.std(list_fid))" + "print('平均保真度 =', np.around(sum(list_fid)[0] / len(list_fid), 4), ', 标准差 =', np.std(list_fid))" ] }, { @@ -289,7 +257,7 @@ "\\tag{7}\n", "$$\n", "\n", - "这将为我们带来更强大的搜索能力，来寻找更多使用场景下的 LOCC 协议。类似地，我们将 Alice 的本地操作更改为更通用的参数化量子电路，这里具体使用的是一个内置的两量子比特通用门 `universal_2_qubit_gate(theta, which_qubit=[0,1])` [4]。基于以上条件，我们训练一个自定义的 LOCC 协议流程如下：\n", + "这将为我们带来更强大的搜索能力，来寻找更多使用场景下的 LOCC 协议。类似地，我们将 Alice 的本地操作更改为更通用的参数化量子电路，这里具体使用的是一个内置的两量子比特通用门 `universal_two_qubits()` [4]。基于以上条件，我们训练一个自定义的 LOCC 协议流程如下：\n", "\n", "1. Alice 对她所持有的两个量子比特作用两量子比特通用门。\n", "2. 然后 Alice 在计算基上测量她的两个量子比特，并通过经典信道与 Bob 交流。\n", @@ -341,93 +309,74 @@ "class LOCC_Train(LoccNet):\n", " def __init__(self):\n", " super(LOCC_Train, self).__init__()\n", - " \n", " # 初始化 LOCCNet\n", " self.parties = list()\n", - " \n", " # 添加第一个参与方 Alice\n", " # 第一个参数 2 代表着 Alice 手里有几个量子比特\n", " # 第二个参数代表着参与方的名字\n", " self.add_new_party(2, party_name=\"Alice\")\n", - " \n", " # 添加第二个参与方 Bob\n", " # 第一个参数 1 代表着 Bob 手里有几个量子比特\n", " # 第二个参数代表着参与方的名字\n", " self.add_new_party(1, party_name=\"Bob\")\n", - " \n", "\n", " # 准备一个贝尔态\n", - " _state = paddle.to_tensor(bell_state(2))\n", - " # _state = paddle.to_tensor(isotropic_state(2, 0.8))\n", - "\n", - "\n", - " # 设置 Alice 本地操作的参数\n", - " self.theta_A = self.create_parameter(shape=[15], default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi), dtype=\"float64\")\n", - " # 设置 Bob 本地操作的参数\n", - " self.theta_B = self.create_parameter(shape=[4, 3], default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi), dtype=\"float64\")\n", - "\n", + " _state = bell_state(2)\n", + " # _state = isotropic_state(2, 0.8)\n", " # 训练集: 4 个线性独立态\n", - " _state0 = paddle.to_tensor(np.array([[1, 0], [0, 0]], dtype=np.complex128))\n", - " _state1 = paddle.to_tensor(np.array([[0, 0], [0, 1]], dtype=np.complex128))\n", - " _state2 = paddle.to_tensor(np.array([[0.5, 0.5], [0.5, 0.5]], dtype=np.complex128))\n", - " _state3 = paddle.to_tensor(np.array([[0.5, -0.5j], [0.5j, 0.5]], dtype=np.complex128))\n", + " _state0 = paddle_quantum.State(np.array([[1, 0], [0, 0]], dtype=np.complex64))\n", + " _state1 = paddle_quantum.State(np.array([[0, 0], [0, 1]], dtype=np.complex64))\n", + " _state2 = paddle_quantum.State(np.array([[0.5, 0.5], [0.5, 0.5]], dtype=np.complex64))\n", + " _state3 = paddle_quantum.State(np.array([[0.5, -0.5j], [0.5j, 0.5]], dtype=np.complex64))\n", " self.init_states = [_state0, _state1, _state2, _state3]\n", - "\n", " # 通过分配上述制备好的量子态初始化整个量子系统\n", " self.set_init_state(_state, [(\"Alice\", 1), (\"Bob\", 0)])\n", " self.set_init_state(_state0, [(\"Alice\", 0)])\n", "\n", + " # 定义 Alice 的本地操作\n", + " self.cirA = self.create_ansatz(\"Alice\")\n", + " self.cirA.universal_two_qubits([0, 1])\n", + " # 定义 Bob 的本地操作\n", + " self.cirB = [self.create_ansatz(\"Bob\") for _ in range(4)]\n", + " for cir in self.cirB:\n", + " # 作用单量子比特通用门\n", + " cir.u3(0)\n", + "\n", " def LOCCNet(self):\n", - " \n", " # 定义训练过程\n", " loss = 0\n", " temp_state = self.init_status\n", - " \n", " # 开始训练\n", " for init_state in self.init_states:\n", - " \n", " # 重置 Alice 持有的量子比特 C 至训练集中的量子态\n", " status = self.reset_state(temp_state, init_state, [(\"Alice\", 0)])\n", - "\n", - " # 定义 Alice 的本地操作\n", - " cirA = self.create_ansatz(\"Alice\")\n", - " cirA.universal_2_qubit_gate(self.theta_A, [0, 1])\n", - "\n", " # 执行 Alice 的电路\n", - " status = cirA.run(status)\n", - " \n", + " status = self.cirA(status)\n", " # 测量得到四个可能的结果\n", " status_A = self.measure(status, [(\"Alice\", 0), (\"Alice\", 1)], [\"00\", \"01\", \"10\", \"11\"])\n", " \n", " # Bob 根据测量结果选择不同的门作用在自己的量子比特上\n", " for i, s in enumerate(status_A):\n", - " \n", - " # 定义 Bob 的本地操作\n", - " cirB = self.create_ansatz(\"Bob\")\n", - " \n", - " # 作用单量子比特通用门\n", - " cirB.u3(*self.theta_B[i], 0)\n", - " \n", " # 执行 Bob 的电路\n", - " status_B = cirB.run(s)\n", - " \n", + " status_B = self.cirB[i](s)\n", " # 仅留下 Bob 的量子比特 B\n", " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", - " \n", " # 将所有的测量结果的损失函数进行累加\n", - " loss += 1 - paddle.real(trace(matmul(init_state, status_fin.state)))[0]\n", + " loss += 1 - paddle.real(trace(matmul(init_state.data, status_fin.data)))\n", " \n", " return loss\n", "\n", " # 存储训练结束后的最优参数\n", " def save_module(self):\n", - " theta = np.array([self.theta_A.numpy(), self.theta_B.numpy()], dtype=\"object\")\n", - " np.save('parameters/QT_LOCCNet', theta)" + " theta_A = self.cirA.parameters()\n", + " theta_B = [self.cirB[i].parameters() for i in range(4)]\n", + " theta = theta_A + sum(theta_B, [])\n", + " paddle.save(theta, 'parameters/QT_LOCCNet')" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:27:21.094741Z", @@ -439,21 +388,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "itr 0: 7.721435597307273\n", - "itr 10: 0.5636061774837096\n", - "itr 20: 0.20642802374795632\n", - "itr 30: 0.07340371172539029\n", - "itr 40: 0.025112969166681598\n", - "itr 50: 0.008655519545057166\n", - "itr 60: 0.0035853096929094885\n", - "itr 70: 0.0014441032202451298\n", - "itr 80: 0.0004540960989092291\n", - "itr 90: 0.00018530025729923683\n", - "itr 100: 4.679932743989479e-05\n", - "itr 110: 1.5186530775368468e-05\n", - "itr 120: 4.8322085606233856e-06\n", - "itr 130: 3.08099659207528e-06\n", - "itr 140: 1.0481638913484304e-06\n" + "itr 0: 7.721435\n", + "itr 10: 0.5636051\n", + "itr 20: 0.20643002\n", + "itr 30: 0.073403895\n", + "itr 40: 0.025113285\n", + "itr 50: 0.008655369\n", + "itr 60: 0.0035846233\n", + "itr 70: 0.0014438629\n", + "itr 80: 0.00045502186\n", + "itr 90: 0.00018626451\n", + "itr 100: 4.7028065e-05\n", + "itr 110: 1.4960766e-05\n", + "itr 120: 4.4703484e-06\n", + "itr 130: 3.1590462e-06\n", + "itr 140: 1.66893e-06\n" ] } ], @@ -464,30 +413,19 @@ "np.random.seed(SEED)\n", "paddle.seed(SEED)\n", "\n", - "\n", "net = LOCC_Train()\n", - "\n", + "params = net.cirA.parameters() + sum([net.cirB[i].parameters() for i in range(4)], [])\n", "# 选择 Adam 优化器\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters= net.parameters())\n", - "\n", - "# 记录损失\n", - "loss_list = []\n", - "\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=params)\n", "# 开始优化循环\n", "for itr in range(ITR):\n", - "\n", " # 向前传播计算损失函数\n", " loss = net.LOCCNet()\n", - "\n", " # 反向传播优化损失函数\n", " loss.backward()\n", " opt.minimize(loss)\n", - "\n", " # 清除梯度\n", " opt.clear_grad()\n", - "\n", - " # 记录训练结果\n", - " loss_list.append(loss.numpy()[0])\n", " if itr % 10 == 0:\n", " print(\"itr \" + str(itr) + \":\", loss.numpy()[0])\n", "\n", @@ -501,12 +439,12 @@ "source": [ "### 基准测试\n", "\n", - "如果想要更快捷的感受效果，我们还提供**加载预先训练好的电路参数**并直接测试性能。" + "如果想要更快捷地感受效果，我们还提供**加载预先训练好的电路参数**并直接测试性能。" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:27:35.419952Z", @@ -516,39 +454,33 @@ "outputs": [], "source": [ "class LOCC_Test(LoccNet):\n", - " def __init__(self):\n", + " def __init__(self, theta_A, theta_B):\n", " super(LOCC_Test, self).__init__()\n", - " \n", " self.parties = list()\n", " self.add_new_party(2, party_name=\"Alice\")\n", " self.add_new_party(1, party_name=\"Bob\")\n", - " \n", - " self.theta_A = paddle.to_tensor(para[0])\n", - " self.theta_B = paddle.to_tensor(para[1])\n", - " \n", - " _state = paddle.to_tensor(bell_state(2))\n", - " random_state = density_op_random(n=1)\n", - " self._state0 = paddle.to_tensor(random_state)\n", + "\n", + " _state = bell_state(2)\n", + " self._state0 = random_state(1)\n", " self.set_init_state(_state, [(\"Alice\", 1), (\"Bob\", 0)])\n", " self.set_init_state(self._state0, [(\"Alice\", 0)])\n", - " \n", + "\n", + " self.cirA = self.create_ansatz(\"Alice\")\n", + " self.cirA.universal_two_qubits(qubits_idx=[0, 1], param=theta_A)\n", + " self.cirB = [self.create_ansatz(\"Bob\") for _ in range(4)]\n", + " for i, cir in enumerate(self.cirB):\n", + " cir.u3(qubits_idx=0, param=theta_B[i])\n", "\n", " def benchmark(self):\n", " input_state = self.init_status\n", - " cirA = self.create_ansatz(\"Alice\")\n", - " cirA.universal_2_qubit_gate(self.theta_A, [0, 1])\n", - "\n", - " status = cirA.run(input_state)\n", + " status = self.cirA(input_state)\n", " status_A = self.measure(status, [(\"Alice\", 0), (\"Alice\", 1)], [\"00\", \"01\", \"10\", \"11\"])\n", " fid_list = []\n", - "\n", " for i, s in enumerate(status_A):\n", - " cirB = self.create_ansatz(\"Bob\")\n", - " cirB.u3(*self.theta_B[i], 0)\n", - " status_B = cirB.run(s)\n", + " status_B = self.cirB[i](s)\n", " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", - " fid = state_fidelity(self._state0.numpy(), status_fin.state.numpy())**2\n", - " fid_list.append(fid*status_fin.prob.numpy()[0])\n", + " fid = state_fidelity(self._state0, status_fin) ** 2\n", + " fid_list.append(fid * status_fin.prob)\n", " fid_ave = sum(fid_list)\n", " \n", " return fid_ave" @@ -568,13 +500,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "平均保真度 = 1.0 , 标准差 = 5.695904176663085e-07\n" + "平均保真度 = 1.0 , 标准差 = 3.8644316e-07\n" ] } ], "source": [ "# 加载预先训练的电路参数\n", - "para = np.load('parameters/QT_LOCCNet_Trained.npy', allow_pickle=True)\n", + "para = paddle.load('parameters/QT_LOCCNet')\n", "SEED = 999 # 固定生成传输态的随机种子\n", "num_state = 200 # 设置随机态的生成数量\n", "list_fid = [] # 用于记录保真度\n", @@ -583,9 +515,9 @@ "\n", "# 采样\n", "for idx in range(num_state):\n", - " list_fid.append(LOCC_Test().benchmark())\n", + " list_fid.append(LOCC_Test(para[0], para[1:]).benchmark().numpy())\n", "\n", - "print('平均保真度 =', np.around(sum(list_fid)/len(list_fid), 4), ', 标准差 =', np.std(list_fid))" + "print('平均保真度 =', np.around(sum(list_fid)[0] / len(list_fid), 4), ', 标准差 =', np.std(list_fid))" ] }, { @@ -594,7 +526,7 @@ "source": [ "## 结论\n", "\n", - "从以上数值实验的结果可以看出，基于 LOCCNet 我们成功地学习出了量子隐形传态协议。 最初的隐形传态协议旨在传输单量子比特量子态，无法直接推广到多量子比特的情形。 相比之下，LOCCNet 为寻找多量子比特情形下的隐形传态协议提供了可能, 更是可以训练得到更一般的通过量子纠缠和 LOCC 实现不同节点间量子信道的模拟。 此外，感兴趣的读者可以尝试各类量子噪声会如何影响 LOCCNet 训练的效果。 " + "从以上数值实验的结果可以看出，基于 LOCCNet 我们成功地学习出了量子隐形传态协议。 最初的隐形传态协议旨在传输单量子比特量子态，无法直接推广到多量子比特的情形。 相比之下，LOCCNet 为寻找多量子比特情形下的隐形传态协议提供了可能，更是可以训练得到更一般的通过量子纠缠和 LOCC 实现不同节点间量子信道的模拟。 此外，感兴趣的读者可以尝试各类量子噪声会如何影响 LOCCNet 训练的效果。另一方面，隐形传态协议可以看作是在模拟一个单位信道 $\\mathcal{E}_I$，即 Alice 发送量子态 $\\psi$ 而 Bob 接收到量子态 $\\mathcal{E}_I(\\psi)$。这个想法可以扩展到模拟许多其他信道，例如去极化信道 $\\mathcal{E}_{D}$。" ] }, { @@ -617,7 +549,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -631,7 +563,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/locc/QuantumTeleportation_EN.ipynb b/tutorials/locc/QuantumTeleportation_EN.ipynb similarity index 73% rename from tutorial/locc/QuantumTeleportation_EN.ipynb rename to tutorials/locc/QuantumTeleportation_EN.ipynb index d50169a..9e1a206 100644 --- a/tutorial/locc/QuantumTeleportation_EN.ipynb +++ b/tutorials/locc/QuantumTeleportation_EN.ipynb @@ -100,7 +100,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:28:54.132971Z", @@ -110,11 +110,14 @@ "outputs": [], "source": [ "import numpy as np\n", - "from paddle_quantum.locc import LoccNet\n", - "from paddle import matmul, trace\n", "import paddle\n", - "from paddle_quantum.utils import state_fidelity\n", - "from paddle_quantum.state import bell_state, isotropic_state, density_op_random" + "from paddle import matmul, trace\n", + "import paddle_quantum\n", + "from paddle_quantum.locc import LoccNet\n", + "from paddle_quantum.qinfo import state_fidelity\n", + "from paddle_quantum.state import bell_state, isotropic_state, random_state\n", + "# Change to density matrix mode\n", + "paddle_quantum.set_backend('density_matrix')" ] }, { @@ -126,7 +129,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:28:54.197393Z", @@ -138,27 +141,21 @@ "class LOCC(LoccNet):\n", " def __init__(self):\n", " super(LOCC, self).__init__()\n", - " \n", " # Add the first party Alice \n", " # The first parameter 2 stands for how many qubits A holds\n", - " # The second parameter records the name of this qubit holder\n", + " # The second parameter records the name of this party\n", " self.add_new_party(2, party_name=\"Alice\")\n", - " \n", " # Add the second party Bob\n", " # The first parameter 1 stands for how many qubits B holds\n", - " # The second parameter records the name of this qubit holder\n", + " # The second parameter records the name of this party\n", " self.add_new_party(1, party_name=\"Bob\")\n", - " \n", "\n", " # Create a bell state\n", - " _state = paddle.to_tensor(bell_state(2))\n", - " # _state = paddle.to_tensor(isotropic_state(2, 0.8))\n", - "\n", - " \n", + " _state = bell_state(2)\n", + " # _state = isotropic_state(2, 0.8)\n", " # Generate random pure quantum states for teleportation\n", - " random_state = density_op_random(n=1, real_or_complex=2, rank=1)\n", - " self.state_C = paddle.to_tensor(random_state)\n", - " \n", + " self.state_C = random_state(num_qubits=1, rank=1)\n", + "\n", " # Initialize the system by distributing states between Alice and Bob\n", " # (\"Alice\", 0) refers to qubit C\n", " # (\"Alice\", 1) refers to qubit A\n", @@ -167,68 +164,40 @@ " self.set_init_state(self.state_C, [(\"Alice\", 0)])\n", " self.set_init_state(_state, [(\"Alice\", 1), (\"Bob\", 0)])\n", "\n", + " # Create Alice's local operations \n", + " self.cirA = self.create_ansatz(\"Alice\")\n", + " self.cirA.cnot([0, 1])\n", + " self.cirA.h(0)\n", + " # Create Bob's local operations\n", + " self.cirB = [self.create_ansatz(\"Bob\") for _ in range(4)]\n", + " self.cirB[1].x(0)\n", + " self.cirB[2].z(0)\n", + " self.cirB[3].x(0)\n", + " self.cirB[3].z(0)\n", "\n", " def teleportation(self):\n", " status = self.init_status\n", - " \n", - " # Create Alice's local operations \n", - " cirA = self.create_ansatz(\"Alice\")\n", - " cirA.cnot([0, 1])\n", - " cirA.h(0)\n", - " \n", " # Run circuit\n", - " status = cirA.run(status)\n", - " \n", + " status = self.cirA(status)\n", " # Alice measures both of her qubits C and A\n", " status_A = self.measure(status, [(\"Alice\", 0), (\"Alice\", 1)], [\"00\", \"01\", \"10\", \"11\"])\n", - " \n", + "\n", " # Record average fidelity \n", " fid_list = []\n", - "\n", " # Bob applies different gates on his qubits depending on the measurement result of Alice\n", " for i, s in enumerate(status_A):\n", - " \n", " # Bob's circuit\n", - " if status_A[i].measured_result == '00':\n", - " \n", - " # Create Bob's local operations \n", - " cirB = self.create_ansatz(\"Bob\")\n", - " \n", - " # Run circuit\n", - " status_B = cirB.run(s) \n", - " \n", - " # Trace out the measured qubits C and A\n", - " # Leaving out only Bob’s qubit B\n", - " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", - "\n", - " # Calculate the fidelity between the teleported state and the original state\n", - " fid = state_fidelity(self.state_C.numpy(), status_fin.state.numpy())**2\n", - " fid_list.append(fid * status_fin.prob.numpy()[0])\n", - " \n", - " elif status_A[i].measured_result == '01':\n", - " cirB = self.create_ansatz(\"Bob\")\n", - " cirB.x(0)\n", - " status_B = cirB.run(s)\n", - " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", - " fid = state_fidelity(self.state_C.numpy(), status_fin.state.numpy())**2\n", - " fid_list.append(fid * status_fin.prob.numpy()[0])\n", - " elif status_A[i].measured_result == '10':\n", - " cirB = self.create_ansatz(\"Bob\")\n", - " cirB.z(0)\n", - " status_B = cirB.run(s)\n", - " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", - " fid = state_fidelity(self.state_C.numpy(), status_fin.state.numpy())**2\n", - " fid_list.append(fid * status_fin.prob.numpy()[0])\n", - " elif status_A[i].measured_result == '11':\n", - " cirB = self.create_ansatz(\"Bob\")\n", - " cirB.x(0)\n", - " cirB.z(0)\n", - " status_B = cirB.run(s)\n", - " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", - " fid = state_fidelity(self.state_C.numpy(), status_fin.state.numpy())**2\n", - " fid_list.append(fid * status_fin.prob.numpy()[0])\n", + " cirB = self.cirB[int(status_A[i].measured_result, 2)]\n", + " # Run circuit\n", + " status_B = cirB(s) \n", + " # Trace out the measured qubits C and A\n", + " # Leaving out only Bob’s qubit B\n", + " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", + " # Calculate the fidelity between the teleported state and the original state\n", + " fid = state_fidelity(self.state_C, status_fin) ** 2\n", + " fid_list.append(fid * status_fin.prob)\n", " fid_avg = sum(fid_list)\n", - " \n", + "\n", " return fid_avg" ] }, @@ -246,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:29:03.318794Z", @@ -258,7 +227,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "Teleportation_Fidelity_Avg: 1.0 , std= 6.429150606796583e-09\n" + "Teleportation_Fidelity_Avg: 1.0 , std= 3.9433777e-07\n" ] } ], @@ -269,9 +238,9 @@ "np.random.seed(SEED)\n", "# Start sampling\n", "for idx in range(num_state):\n", - " list_fid.append(LOCC().teleportation())\n", + " list_fid.append(LOCC().teleportation().numpy())\n", "\n", - "print('Teleportation_Fidelity_Avg:', np.around(sum(list_fid)/len(list_fid), 4), ', std=', np.std(list_fid))" + "print('Teleportation_Fidelity_Avg:', np.around(sum(list_fid)[0] / len(list_fid), 4), ', std=', np.std(list_fid))" ] }, { @@ -311,7 +280,7 @@ "\\tag{7}\n", "$$\n", "\n", - "This would bring us a more powerful searching capability in finding practical LOCC protocols. Similarly, we change Alice's local operations to a more general PQC called the `universal_2_qubit_gate(theta, which_qubit=[0,1])` [4]. We summarize the workflow below: \n", + "This would bring us a more powerful searching capability in finding practical LOCC protocols. Similarly, we change Alice's local operations to a more general PQC called the `universal_two_qubits()` [4]. We summarize the workflow below: \n", "\n", "1. Alice applies a 2-qubit PQC on her qubits.\n", "2. Alice measures both of her qubits in the computational basis and communicates with Bob through a classical channel.\n", @@ -351,7 +320,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:29:08.878062Z", @@ -363,91 +332,73 @@ "class LOCC_Train(LoccNet):\n", " def __init__(self):\n", " super(LOCC_Train, self).__init__()\n", - "\n", " # Add the first party Alice \n", " # The first parameter 2 stands for how many qubits A holds\n", - " # The second parameter records the name of this qubit holder\n", + " # The second parameter records the name of this party\n", " self.add_new_party(2, party_name=\"Alice\")\n", - " \n", " # Add the second party Bob\n", " # The first parameter 1 stands for how many qubits B holds\n", - " # The second parameter records the name of this qubit holder\n", + " # The second parameter records the name of this party\n", " self.add_new_party(1, party_name=\"Bob\")\n", - " \n", "\n", " # Create a bell state\n", - " _state = paddle.to_tensor(bell_state(2))\n", - " # _state = paddle.to_tensor(isotropic_state(2, 0.8))\n", - "\n", - "\n", - " # Initialize Alice‘s parameters\n", - " self.theta_A = self.create_parameter(shape=[15], default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi), dtype=\"float64\")\n", - " # Initialize Bob's parameters\n", - " self.theta_B = self.create_parameter(shape=[4, 3], default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi), dtype=\"float64\")\n", - "\n", + " _state = bell_state(2)\n", + " # _state = isotropic_state(2, 0.8)\n", " # Training set: 4 linear independent states\n", - " _state0 = paddle.to_tensor(np.array([[1, 0], [0, 0]], dtype=np.complex128))\n", - " _state1 = paddle.to_tensor(np.array([[0, 0], [0, 1]], dtype=np.complex128))\n", - " _state2 = paddle.to_tensor(np.array([[0.5, 0.5], [0.5, 0.5]], dtype=np.complex128))\n", - " _state3 = paddle.to_tensor(np.array([[0.5, -0.5j], [0.5j, 0.5]], dtype=np.complex128))\n", + " _state0 = paddle_quantum.State(np.array([[1, 0], [0, 0]], dtype=np.complex64))\n", + " _state1 = paddle_quantum.State(np.array([[0, 0], [0, 1]], dtype=np.complex64))\n", + " _state2 = paddle_quantum.State(np.array([[0.5, 0.5], [0.5, 0.5]], dtype=np.complex64))\n", + " _state3 = paddle_quantum.State(np.array([[0.5, -0.5j], [0.5j, 0.5]], dtype=np.complex64))\n", " self.init_states = [_state0, _state1, _state2, _state3]\n", - "\n", " # Initialize the system by distributing states between Alice and Bob\n", " self.set_init_state(_state, [(\"Alice\", 1), (\"Bob\", 0)])\n", " self.set_init_state(_state0, [(\"Alice\", 0)])\n", "\n", + " # Define Alice's local operations\n", + " self.cirA = self.create_ansatz(\"Alice\")\n", + " self.cirA.universal_two_qubits([0, 1])\n", + " # Define Bob's local operations\n", + " self.cirB = [self.create_ansatz(\"Bob\") for _ in range(4)]\n", + " for cir in self.cirB:\n", + " # Apply a universal single qubit gate\n", + " cir.u3(0)\n", + "\n", " def LOCCNet(self):\n", - " \n", " # Define the training process\n", " loss = 0\n", " temp_state = self.init_status\n", - " \n", " # Training\n", " for init_state in self.init_states:\n", - " \n", " # Reset Alice's first qubit C to states in training set\n", " status = self.reset_state(temp_state, init_state, [(\"Alice\", 0)])\n", - "\n", - " # Define Alice's local operations\n", - " cirA = self.create_ansatz(\"Alice\")\n", - " cirA.universal_2_qubit_gate(self.theta_A, [0, 1])\n", - "\n", " # Run circuit\n", - " status = cirA.run(status)\n", - " \n", - " # Obtain 4 possible measurement results\n", + " status = self.cirA(status)\n", + " # Obtain 4 possible measurement results\n", " status_A = self.measure(status, [(\"Alice\", 0), (\"Alice\", 1)], [\"00\", \"01\", \"10\", \"11\"])\n", - " \n", + "\n", " # Bob needs to apply different operation on his qubits, depending on the measurement results\n", " for i, s in enumerate(status_A):\n", - " \n", - " # Define Bob's local operations\n", - " cirB = self.create_ansatz(\"Bob\")\n", - " \n", - " # Apply a universal single qubit gate\n", - " cirB.u3(*self.theta_B[i], 0)\n", - " \n", " # Run circuit\n", - " status_B = cirB.run(s)\n", - " \n", + " status_B = self.cirB[i](s)\n", " # Trace out the measured qubits C and A\n", " # Leaving out only Bob’s qubit B\n", " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", - " \n", " # Summing up the loss function for all possible measurement results\n", - " loss += 1 - paddle.real(trace(matmul(init_state, status_fin.state)))[0]\n", - " \n", + " loss += 1 - paddle.real(trace(matmul(init_state.data, status_fin.data)))\n", + "\n", " return loss\n", "\n", " # Save the optimized parameters\n", " def save_module(self):\n", - " theta = np.array([self.theta_A.numpy(), self.theta_B.numpy()], dtype=\"object\")\n", - " np.save('parameters/QT_LOCCNet', theta)" + " theta_A = self.cirA.parameters()\n", + " theta_B = [self.cirB[i].parameters() for i in range(4)]\n", + " theta = theta_A + sum(theta_B, [])\n", + " paddle.save(theta, 'parameters/QT_LOCCNet')" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2021-03-09T06:30:12.560553Z", @@ -459,21 +410,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "itr 0: 7.721435597307273\n", - "itr 10: 0.5636061774837096\n", - "itr 20: 0.20642802374795632\n", - "itr 30: 0.07340371172539029\n", - "itr 40: 0.025112969166681598\n", - "itr 50: 0.008655519545057166\n", - "itr 60: 0.0035853096929094885\n", - "itr 70: 0.0014441032202451298\n", - "itr 80: 0.0004540960989092291\n", - "itr 90: 0.00018530025729923683\n", - "itr 100: 4.679932743989479e-05\n", - "itr 110: 1.5186530775368468e-05\n", - "itr 120: 4.8322085606233856e-06\n", - "itr 130: 3.08099659207528e-06\n", - "itr 140: 1.0481638913484304e-06\n" + "itr 0: 7.721435\n", + "itr 10: 0.5636051\n", + "itr 20: 0.20643002\n", + "itr 30: 0.073403895\n", + "itr 40: 0.025113285\n", + "itr 50: 0.008655369\n", + "itr 60: 0.0035846233\n", + "itr 70: 0.0014438629\n", + "itr 80: 0.00045502186\n", + "itr 90: 0.00018626451\n", + "itr 100: 4.7028065e-05\n", + "itr 110: 1.4960766e-05\n", + "itr 120: 4.4703484e-06\n", + "itr 130: 3.1590462e-06\n", + "itr 140: 1.66893e-06\n" ] } ], @@ -485,28 +436,18 @@ "paddle.seed(SEED)\n", "\n", "net = LOCC_Train()\n", - "\n", + "params = net.cirA.parameters() + sum([net.cirB[i].parameters() for i in range(4)], [])\n", "# Choose the Adam optimizer\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters= net.parameters())\n", - "\n", - "# Record loss\n", - "loss_list = []\n", - "\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=params)\n", "# Optimization loop\n", "for itr in range(ITR):\n", - "\n", " # Forward propagation to calculate loss function\n", " loss = net.LOCCNet()\n", - "\n", " # Backpropagation\n", " loss.backward()\n", " opt.minimize(loss)\n", - "\n", " # Clean gradients\n", " opt.clear_grad()\n", - "\n", - " # Record the learning process\n", - " loss_list.append(loss.numpy()[0])\n", " if itr % 10 == 0:\n", " print(\"itr \" + str(itr) + \":\", loss.numpy()[0])\n", "\n", @@ -525,7 +466,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:20:18.582863Z", @@ -535,39 +476,34 @@ "outputs": [], "source": [ "class LOCC_Test(LoccNet):\n", - " def __init__(self):\n", + " def __init__(self, theta_A, theta_B):\n", " super(LOCC_Test, self).__init__()\n", - " \n", " self.parties = list()\n", " self.add_new_party(2, party_name=\"Alice\")\n", " self.add_new_party(1, party_name=\"Bob\")\n", - " \n", - " self.theta_A = paddle.to_tensor(para[0])\n", - " self.theta_B = paddle.to_tensor(para[1])\n", - " \n", - " _state = paddle.to_tensor(bell_state(2))\n", - " random_state = density_op_random(n=1)\n", - " self._state0 = paddle.to_tensor(random_state)\n", + "\n", + " _state = bell_state(2)\n", + " self._state0 = random_state(1)\n", " self.set_init_state(_state, [(\"Alice\", 1), (\"Bob\", 0)])\n", " self.set_init_state(self._state0, [(\"Alice\", 0)])\n", + "\n", + " self.cirA = self.create_ansatz(\"Alice\")\n", + " self.cirA.universal_two_qubits(qubits_idx=[0, 1], param=theta_A)\n", + " self.cirB = [self.create_ansatz(\"Bob\") for _ in range(4)]\n", + " for i, cir in enumerate(self.cirB):\n", + " cir.u3(qubits_idx=0, param=theta_B[i])\n", " \n", "\n", " def benchmark(self):\n", " input_state = self.init_status\n", - " cirA = self.create_ansatz(\"Alice\")\n", - " cirA.universal_2_qubit_gate(self.theta_A, [0, 1])\n", - "\n", - " status = cirA.run(input_state)\n", + " status = self.cirA(input_state)\n", " status_A = self.measure(status, [(\"Alice\", 0), (\"Alice\", 1)], [\"00\", \"01\", \"10\", \"11\"])\n", " fid_list = []\n", - "\n", " for i, s in enumerate(status_A):\n", - " cirB = self.create_ansatz(\"Bob\")\n", - " cirB.u3(*self.theta_B[i], 0)\n", - " status_B = cirB.run(s)\n", + " status_B = self.cirB[i](s)\n", " status_fin = self.partial_state(status_B, [(\"Bob\", 0)])\n", - " fid = state_fidelity(self._state0.numpy(), status_fin.state.numpy())**2\n", - " fid_list.append(fid*status_fin.prob.numpy()[0])\n", + " fid = state_fidelity(self._state0, status_fin) ** 2\n", + " fid_list.append(fid * status_fin.prob)\n", " fid_ave = sum(fid_list)\n", " \n", " return fid_ave" @@ -575,7 +511,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2021-02-23T09:20:33.607232Z", @@ -587,13 +523,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "LOCCNet_Fidelity_avg: 1.0 , std= 5.695904182530426e-07\n" + "LOCCNet_Fidelity_avg: 1.0 , std= 3.8644316e-07\n" ] } ], "source": [ "# Load pre-trained circuit parameters\n", - "para = np.load('parameters/QT_LOCCNet_Trained.npy', allow_pickle=True)\n", + "para = paddle.load('parameters/QT_LOCCNet')\n", "np.random.seed(999) # Fix random seed\n", "num_state = 200 # Number of random states generated\n", "list_fid = [] # Record the fidelity\n", @@ -602,9 +538,9 @@ "\n", "# Start sampling\n", "for idx in range(num_state):\n", - " list_fid.append(LOCC_Test().benchmark())\n", + " list_fid.append(LOCC_Test(para[0], para[1:]).benchmark().numpy())\n", "\n", - "print('LOCCNet_Fidelity_avg:', np.around(sum(list_fid)/len(list_fid), 4), ', std=', np.std(list_fid))" + "print('LOCCNet_Fidelity_avg:', np.around(sum(list_fid)[0] / len(list_fid), 4), ', std=', np.std(list_fid))" ] }, { @@ -613,7 +549,7 @@ "source": [ "## Conclusion\n", "\n", - "Based on LOCCNet we successfully learned a teleportation protocol with a noiseless pre-shared Bell state. The original teleportation protocol was designed to transfer a single-qubit quantum state. It is not clear how it can be generalize to the multi-qubit case. By comparison, LOCCNet provides the possibility of training a teleportation protocol for multi-qubit quantum states. Also, it will be an interesting question to ask how robust LOCCNet will be against various noises. On the other hand, the teleportation protocol could be viewed as a special case of simulation the identity channel $\\mathcal{E}_I$ where Alice sends $\\psi$ and Bob receives $\\mathcal{E}_I(\\psi)$. This idea can be extended to simulate many other channels including the depolarizing channel $\\mathcal{E}_{D}$." + "Based on LOCCNet we successfully learned a teleportation protocol with a noiseless pre-shared Bell state. The original teleportation protocol was designed to transfer a single-qubit quantum state. It is not clear how it can be generalize to the multi-qubit case. By comparison, LOCCNet provides the possibility of training a teleportation protocol for multi-qubit quantum states. Also, it will be an interesting question to ask how robust LOCCNet will be against various noises. On the other hand, the teleportation protocol could be viewed as a special case of simulating the identity channel $\\mathcal{E}_I$ where Alice sends $\\psi$ and Bob receives $\\mathcal{E}_I(\\psi)$. This idea can be extended to simulate many other channels including the depolarizing channel $\\mathcal{E}_{D}$." ] }, { @@ -636,7 +572,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -650,7 +586,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/locc/StateDiscrimination_CN.ipynb b/tutorials/locc/StateDiscrimination_CN.ipynb similarity index 75% rename from tutorial/locc/StateDiscrimination_CN.ipynb rename to tutorials/locc/StateDiscrimination_CN.ipynb index 97cf628..24fbf24 100644 --- a/tutorial/locc/StateDiscrimination_CN.ipynb +++ b/tutorials/locc/StateDiscrimination_CN.ipynb @@ -33,7 +33,7 @@ "在我们提供的 LOCCNet 框架下解决这样一个任务是很轻松的。方便起见，我们还是先采用单轮通讯协议 $r=1$ 的设计。 也就是说 Alice 和 Bob 之间只会进行一次经典通讯。具体的量子神经网络（QNN）见图 1。该任务中的关键步骤是确定损失函数 $ L $。这里我们设置 Alice 和 Bob 都需要对手中量子比特做一次测量，因此有 4 种可能的测量结果 $m_Am_B\\in\\{00, 01, 10, 11\\}$。为了能清晰地区分 $\\lvert\\psi\\rangle$ 和 $\\lvert\\phi\\rangle$， 我们不妨定义当测量结果为 $m_Am_B\\in\\{00, 10\\}$ 时将其分类为 $\\lvert\\psi\\rangle$。 类似地，如果参与方的测量结果为 $m_Am_B\\in\\{01, 11\\}$ 时将其分类为 $\\lvert\\phi\\rangle$。此步骤可以理解为在监督学习中为数据添加标签。通过以上标签，我们可以通过分辨协议出错的概率来定义损失函数，\n", "\n", "$$\n", - "L = p_{\\lvert\\psi\\rangle\\_01}+p_{\\lvert\\psi\\rangle\\_11}+p_{\\lvert\\phi\\rangle\\_10}+p_{\\lvert\\phi\\rangle\\_00}. \n", + "L = p_{\\lvert\\psi\\rangle\\_01}+p_{\\lvert\\psi\\rangle\\_11}+p_{\\lvert\\phi\\rangle\\_10}+p_{\\lvert\\phi\\rangle\\_00},\n", "\\tag{1}\n", "$$\n", "\n", @@ -67,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "5fc7fce4", "metadata": { "ExecuteTime": { @@ -80,7 +80,10 @@ "import numpy as np\n", "from scipy.stats import unitary_group\n", "import paddle\n", - "from paddle_quantum.locc import LoccNet" + "import paddle_quantum\n", + "from paddle_quantum.locc import LoccNet\n", + "# 切换至密度矩阵模式\n", + "paddle_quantum.set_backend('density_matrix')" ] }, { @@ -93,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "9abe8856", "metadata": { "ExecuteTime": { @@ -104,13 +107,11 @@ "outputs": [], "source": [ "def states_orthogonal_random(n, num=2):\n", - " \n", " # 随机生成两个正交态\n", " assert num <= 2 ** n, \"return too many orthognal states\"\n", " U = unitary_group.rvs(2 ** n)\n", - " return_list = []\n", - " for i in range(num):\n", - " return_list.append(U[i])\n", + " return_list = [np.array(U[i], dtype=np.complex64) for i in range(num)]\n", + "\n", " return return_list" ] }, @@ -124,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "9cca865a", "metadata": { "ExecuteTime": { @@ -137,85 +138,63 @@ "class Net(LoccNet):\n", " def __init__(self):\n", " super(Net, self).__init__()\n", - " \n", " # 添加第一个参与方 Alice\n", " # 第一个参数 1 代表着 Alice 手里有几个量子比特\n", " # 第二个参数代表着参与方的名字\n", " self.add_new_party(1, party_name='Alice')\n", - " \n", " # 添加第二个参与方 Bob\n", " # 第一个参数 1 代表着 Bob 手里有几个量子比特\n", " # 第二个参数代表着参与方的名字\n", " self.add_new_party(1, party_name='Bob')\n", - " \n", - " # 初始化 Alice 的参数\n", - " self.theta1 = self.create_parameter(shape=[3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype=\"float64\")\n", - " # 初始化 Bob 的参数\n", - " # Bob 要准备两个电路来应对两个不同的测量结果\n", - " self.theta2 = self.create_parameter(shape=[3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype=\"float64\")\n", - " self.theta3 = self.create_parameter(shape=[3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype=\"float64\")\n", - " \n", + "\n", " # 将输入态写成密度矩阵形式\n", " _states = states_orthogonal_random(2)\n", - " _states = [paddle.to_tensor(np.outer(init_state, init_state.conjugate())) for init_state in _states]\n", - " \n", + " _states = [paddle_quantum.State(np.outer(init_state, init_state.conjugate())) for init_state in _states]\n", " # 初始化整个量子系统并分配量子态\n", " self.set_init_state(_states[0], [('Alice', 0), ('Bob', 0)])\n", " self.psi = self.init_status\n", " self.phi = self.reset_state(self.init_status, _states[1], [('Alice', 0), ('Bob', 0)])\n", "\n", - " def A_circuit(self, theta, state, res):\n", " # Alice 的电路\n", - " cir = self.create_ansatz('Alice')\n", + " self.cirA = self.create_ansatz('Alice')\n", " # 添加单量子比特通用门\n", - " cir.u3(*theta, 0)\n", - " # 运行电路\n", - " after_state = cir.run(state)\n", - " # 测量电路，记录结果 \n", - " after_state = self.measure(status=after_state, which_qubits=('Alice', 0), results_desired=res)\n", - " return after_state\n", - "\n", - " def B_circuit(self, theta, state, res):\n", - " # Bob 的电路\n", - " cir = self.create_ansatz('Bob')\n", + " self.cirA.u3(0)\n", + " # Bob 要准备两个电路来应对两个不同的测量结果\n", + " self.cirB = [self.create_ansatz('Bob'), self.create_ansatz('Bob')]\n", " # 添加单量子比特通用门\n", - " cir.u3(*theta, 0)\n", + " self.cirB[0].u3(0)\n", + " self.cirB[1].u3(0)\n", + "\n", + " def run_circuit(self, party, cir, state, res):\n", " # 运行电路\n", - " after_state = cir.run(state)\n", + " after_state = cir(state)\n", " # 测量电路，记录结果 \n", - " after_state = self.measure(status=after_state, which_qubits=('Bob', 0), results_desired=res)\n", + " after_state = self.measure(status=after_state, which_qubits=(party, 0), results_desired=res)\n", + "\n", " return after_state\n", - " \n", + "\n", " def forward(self):\n", " # 训练过程\n", " # Alice 操作过后的量子态\n", - " phi = self.A_circuit(theta=self.theta1, state=self.phi, res=['0', '1'])\n", - " psi = self.A_circuit(theta=self.theta1, state=self.psi, res=['0', '1'])\n", + " psi = self.run_circuit('Alice', self.cirA, self.psi, ['0', '1'])\n", + " phi = self.run_circuit('Alice', self.cirA, self.phi, ['0', '1'])\n", "\n", " # 定义损失函数\n", " loss = 0\n", - " for each_phi in phi:\n", - " if each_phi.measured_result == '0':\n", - " # 我们要称之为 phi_1 ，代表着把 phi 预测为 psi\n", - " phi_1 = self.B_circuit(self.theta2, state=each_phi, res='1')\n", - " loss += phi_1.prob\n", - " elif each_phi.measured_result == '1':\n", - " psi_1 = self.B_circuit(self.theta3, state=each_phi, res='1')\n", - " loss += psi_1.prob\n", - "\n", " for each_psi in psi:\n", " if each_psi.measured_result == '0':\n", - " phi_0 = self.B_circuit(self.theta2, state=each_psi, res='0')\n", - " loss += phi_0.prob\n", + " psi_01 = self.run_circuit('Bob', self.cirB[0], each_psi, '1')\n", + " loss += psi_01.prob\n", " elif each_psi.measured_result == '1':\n", - " psi_0 = self.B_circuit(self.theta3, state=each_psi, res='0')\n", - " loss += psi_0.prob\n", + " psi_11 = self.run_circuit('Bob', self.cirB[1], each_psi, '1')\n", + " loss += psi_11.prob\n", + " for each_phi in phi:\n", + " if each_phi.measured_result == '0':\n", + " phi_00 = self.run_circuit('Bob', self.cirB[0], each_phi, '0')\n", + " loss += phi_00.prob\n", + " elif each_phi.measured_result == '1':\n", + " phi_10 = self.run_circuit('Bob', self.cirB[1], each_phi, '0')\n", + " loss += phi_10.prob\n", "\n", " return loss\n", "\n", @@ -229,23 +208,22 @@ " print('Charlie 选择的态是', choice)\n", "\n", " # Alice 的操作\n", - " status = self.A_circuit(theta=self.theta1, state=self.status, res=['0', '1'])\n", + " status = self.run_circuit('Alice', self.cirA, self.status, ['0', '1'])\n", " # Bob 的操作 \n", " result_0 = list()\n", " result_1 = list()\n", " for each_status in status:\n", " if each_status.measured_result == '0':\n", - " phi = self.B_circuit(theta=self.theta2, state=each_status, res=['0', '1'])\n", - " result_0.append(phi[0].prob.numpy())\n", - " result_0.append(phi[1].prob.numpy())\n", - "\n", + " status = self.run_circuit('Bob', self.cirB[0], each_status, ['0', '1'])\n", + " result_0.append(status[0].prob.numpy()[0])\n", + " result_0.append(status[1].prob.numpy()[0])\n", " elif each_status.measured_result == '1':\n", - " psi = self.B_circuit(theta=self.theta3, state=each_status, res=['0', '1'])\n", - " result_1.append(psi[0].prob.numpy())\n", - " result_1.append(psi[1].prob.numpy())\n", - " print(\"Alice 和 Bob 将这个态分辨为 phi 的概率为:\", result_0[0][0] + result_1[0][0])\n", - " print(\"Alice 和 Bob 将这个态分辨为 psi 的概率为:\", result_0[1][0] + result_1[1][0])\n", - " " + " status = self.run_circuit('Bob', self.cirB[1], each_status, ['0', '1'])\n", + " result_1.append(status[0].prob.numpy()[0])\n", + " result_1.append(status[1].prob.numpy()[0])\n", + "\n", + " print(\"Alice 和 Bob 将这个态分辨为 psi 的概率为:\", result_0[0] + result_1[0])\n", + " print(\"Alice 和 Bob 将这个态分辨为 phi 的概率为:\", result_0[1] + result_1[1])" ] }, { @@ -258,7 +236,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "3c722a55", "metadata": { "ExecuteTime": { @@ -271,24 +249,24 @@ "name": "stdout", "output_type": "stream", "text": [ - "itr 0: 0.8761168230331675\n", - "itr 10: 0.20833627335270305\n", - "itr 20: 0.09979993875586758\n", - "itr 30: 0.05990778041973435\n", - "itr 40: 0.02806489116318598\n", - "itr 50: 0.026191291836946892\n", - "itr 60: 0.02245618597383097\n", - "itr 70: 0.01903560177140634\n", - "itr 80: 0.016262801555360196\n", - "itr 90: 0.011920717566034985\n", - "最小损失: 0.0077142257760679424\n", + "itr 0: 1.1238832\n", + "itr 10: 0.32665575\n", + "itr 20: 0.085007355\n", + "itr 30: 0.085270524\n", + "itr 40: 0.026622297\n", + "itr 50: 0.015240545\n", + "itr 60: 0.007836903\n", + "itr 70: 0.004827206\n", + "itr 80: 0.0035075857\n", + "itr 90: 0.002215183\n", + "最小损失: 0.0016813411\n", "======================== 测试阶段 ===============================\n", "Charlie 选择的态是 psi\n", - "Alice 和 Bob 将这个态分辨为 phi 的概率为: 0.003188464207077198\n", - "Alice 和 Bob 将这个态分辨为 psi 的概率为: 0.9968115357929229\n", + "Alice 和 Bob 将这个态分辨为 psi 的概率为: 0.9990063\n", + "Alice 和 Bob 将这个态分辨为 phi 的概率为: 0.0009937042\n", "Charlie 选择的态是 phi\n", - "Alice 和 Bob 将这个态分辨为 phi 的概率为: 0.99590992116251\n", - "Alice 和 Bob 将这个态分辨为 psi 的概率为: 0.004090078837489469\n" + "Alice 和 Bob 将这个态分辨为 psi 的概率为: 0.0006236615\n", + "Alice 和 Bob 将这个态分辨为 phi 的概率为: 0.9993763\n" ] } ], @@ -300,18 +278,17 @@ "paddle.seed(SEED)\n", "\n", "net = Net()\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", - "loss_list = list()\n", + "params = net.cirA.parameters() + net.cirB[0].parameters() + net.cirB[1].parameters()\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=params)\n", "# 通过梯度下降训练 LOCC 网络以进行 ITR 次迭代\n", "for itr in range(ITR):\n", " loss = net()\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", - " loss_list.append(loss.numpy()[0])\n", " if itr % 10 == 0:\n", " print(\"itr \" + str(itr) + \":\", loss.numpy()[0])\n", - "print(\"最小损失:\", loss_list[-1])\n", + "print(\"最小损失:\", loss.numpy()[0])\n", "\n", "print(\"======================== 测试阶段 ===============================\")\n", "np.random.seed(10)\n", @@ -348,7 +325,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -362,7 +339,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/locc/StateDiscrimination_EN.ipynb b/tutorials/locc/StateDiscrimination_EN.ipynb similarity index 65% rename from tutorial/locc/StateDiscrimination_EN.ipynb rename to tutorials/locc/StateDiscrimination_EN.ipynb index a60cbe6..10322f5 100644 --- a/tutorial/locc/StateDiscrimination_EN.ipynb +++ b/tutorials/locc/StateDiscrimination_EN.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "id": "2dfbb4cb", "metadata": {}, "source": [ "# Quantum State Discrimination\n", @@ -12,6 +13,7 @@ }, { "cell_type": "markdown", + "id": "0aa43109", "metadata": {}, "source": [ "## Overview\n", @@ -21,17 +23,17 @@ }, { "cell_type": "markdown", + "id": "f04bce42", "metadata": {}, "source": [ "## QSD Protocol\n", "\n", - "Firstly, we want to make the problem definition clear. Consider two spatially separated parties $A$ (Alice) and $B$ (Bob) share a given two-qubit system, the system state is $\\lvert\\varphi\\rangle$ previously distributed by another party $C$ (Charlie). Alice and Bob were only notified that $\\lvert\\varphi\\rangle$ is either $\\lvert\\psi\\rangle$ or $\\lvert\\phi\\rangle$ (both are pure states), satisfying $\\langle\\psi\\lvert\\phi\\rangle=0$. Then, Charlie provides many copies of $\\lvert\\psi\\rangle$ and $\\lvert\\phi\\rangle$ to them, and he asks Alice and Bob to cooperate with each other to figure out which state they are actually sharing.\n", + "Firstly, we want to make the problem definition clear. Consider two spatially separated parties $A$ (Alice) and $B$ (Bob) sharing a given two-qubit system. The system state is $\\lvert\\varphi\\rangle$ previously distributed by another party $C$ (Charlie). Alice and Bob were only notified that $\\lvert\\varphi\\rangle$ is either $\\lvert\\psi\\rangle$ or $\\lvert\\phi\\rangle$ (both are pure states), satisfying $\\langle\\psi\\lvert\\phi\\rangle=0$. Then, Charlie provides many copies of $\\lvert\\psi\\rangle$ and $\\lvert\\phi\\rangle$ to them, and he asks Alice and Bob to cooperate with each other to figure out which state they are actually sharing.\n", "\n", - "\n", - "Solving this problem under our LOCCNet framework is trivial. As always, let's start with the simplest one-round LOCC protocol with a QNN architecture shown in Figure 1. Then, the difficult lies in the design of an appropriate loss function $L$. Since we choose to let both parties to measure their subsystem, there will be four possible measurement results $m_Am_B\\in\\{00, 01, 10, 11\\}$. To distinguish $\\lvert\\psi\\rangle$ and $\\lvert\\phi\\rangle$, we will label the former state with measurement results $m_Am_B\\in\\{00, 10\\}$ and the latter with $m_Am_B\\in\\{01, 11\\}$. This step can be understood as adding labels to the data in supervised learning. With these labels, we can define the loss function as the probability of guessing wrong label,\n", + "Solving this problem under our LOCCNet framework is trivial. As always, let's start with the simplest one-round LOCC protocol with a QNN architecture shown in Figure 1. Then, the difficulty lies in the design of an appropriate loss function $L$. Since we choose to let both parties measure their subsystem, there will be four possible measurement results $m_Am_B\\in\\{00, 01, 10, 11\\}$. To distinguish $\\lvert\\psi\\rangle$ and $\\lvert\\phi\\rangle$, we will label the former state with measurement results $m_Am_B\\in\\{00, 10\\}$ and the latter with $m_Am_B\\in\\{01, 11\\}$. This step can be understood as adding labels to the data in supervised learning. With these labels, we can define the loss function as the probability of guessing wrong label,\n", "\n", "$$\n", - "L = p_{\\lvert\\psi\\rangle\\_01}+p_{\\lvert\\psi\\rangle\\_11}+p_{\\lvert\\phi\\rangle\\_10}+p_{\\lvert\\phi\\rangle\\_00}.\n", + "L = p_{\\lvert\\psi\\rangle\\_01}+p_{\\lvert\\psi\\rangle\\_11}+p_{\\lvert\\phi\\rangle\\_10}+p_{\\lvert\\phi\\rangle\\_00},\n", "\\tag{1}\n", "$$\n", "\n", @@ -56,6 +58,7 @@ }, { "cell_type": "markdown", + "id": "0a114f6a", "metadata": {}, "source": [ "## Simulation with Paddle Quantum \n", @@ -65,7 +68,8 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, + "id": "3c5adbc4", "metadata": { "ExecuteTime": { "end_time": "2021-03-09T04:11:04.474304Z", @@ -77,11 +81,15 @@ "import numpy as np\n", "from scipy.stats import unitary_group\n", "import paddle\n", - "from paddle_quantum.locc import LoccNet" + "import paddle_quantum\n", + "from paddle_quantum.locc import LoccNet\n", + "# Change to density matrix mode\n", + "paddle_quantum.set_backend('density_matrix')" ] }, { "cell_type": "markdown", + "id": "96931b91", "metadata": {}, "source": [ "Randomly generate two orthogonal pure states $\\lvert\\psi\\rangle$ and $\\lvert\\phi\\rangle$ by Charlie." @@ -89,7 +97,8 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, + "id": "32fab324", "metadata": { "ExecuteTime": { "end_time": "2021-03-09T04:11:04.498238Z", @@ -99,18 +108,17 @@ "outputs": [], "source": [ "def states_orthogonal_random(n, num=2):\n", - " \n", " # Randomly generate two orthogonal states\n", " assert num <= 2 ** n, \"return too many orthognal states\"\n", " U = unitary_group.rvs(2 ** n)\n", - " return_list = []\n", - " for i in range(num):\n", - " return_list.append(U[i])\n", + " return_list = [np.array(U[i], dtype=np.complex64) for i in range(num)]\n", + "\n", " return return_list" ] }, { "cell_type": "markdown", + "id": "fe517847", "metadata": {}, "source": [ "Below is the main part of our LOCC protocol:" @@ -118,7 +126,8 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, + "id": "5b281baf", "metadata": { "ExecuteTime": { "end_time": "2021-03-09T04:11:04.551149Z", @@ -130,85 +139,63 @@ "class Net(LoccNet):\n", " def __init__(self):\n", " super(Net, self).__init__()\n", - " \n", " # Add the first party Alice \n", " # The first parameter 1 stands for how many qubits A holds\n", - " # The second parameter records the name of this qubit holder\n", + " # The second parameter records the name of this party\n", " self.add_new_party(1, party_name='Alice')\n", - " \n", " # Add the first party Bob \n", " # The first parameter 1 stands for how many qubits B holds\n", - " # The second parameter records the name of this qubit holder\n", + " # The second parameter records the name of this party\n", " self.add_new_party(1, party_name='Bob')\n", - " \n", - " # Initialize Alice's parameter\n", - " self.theta1 = self.create_parameter(shape=[3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype=\"float64\")\n", - " # Initialize Bob's parameter\n", - " # Bob has to prepare two circuits according Alice's measurement result \n", - " self.theta2 = self.create_parameter(shape=[3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype=\"float64\")\n", - " self.theta3 = self.create_parameter(shape=[3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype=\"float64\")\n", - " \n", - " # Rewrite the input states into density martices\n", + "\n", + " # Rewrite the input states into density matrices\n", " _states = states_orthogonal_random(2)\n", - " _states = [paddle.to_tensor(np.outer(init_state, init_state.conjugate())) for init_state in _states]\n", - " \n", + " _states = [paddle_quantum.State(np.outer(init_state, init_state.conjugate())) for init_state in _states]\n", " # Initialize the system by distributing states\n", " self.set_init_state(_states[0], [('Alice', 0), ('Bob', 0)])\n", " self.psi = self.init_status\n", " self.phi = self.reset_state(self.init_status, _states[1], [('Alice', 0), ('Bob', 0)])\n", "\n", - " def A_circuit(self, theta, state, res):\n", " # Alice's local operations\n", - " cir = self.create_ansatz('Alice')\n", + " self.cirA = self.create_ansatz('Alice')\n", " # Add single-qubit universal gate\n", - " cir.u3(*theta, 0)\n", - " # Run circuit\n", - " after_state = cir.run(state)\n", - " # Measure the circuit and record the measurement results \n", - " after_state = self.measure(status=after_state, which_qubits=('Alice', 0), results_desired=res)\n", - " return after_state\n", - "\n", - " def B_circuit(self, theta, state, res):\n", - " # Bob's local operations\n", - " cir = self.create_ansatz('Bob')\n", + " self.cirA.u3(0)\n", + " # Bob has to prepare two circuits according Alice's measurement result\n", + " self.cirB = [self.create_ansatz('Bob'), self.create_ansatz('Bob')]\n", " # Add single-qubit universal gate\n", - " cir.u3(*theta, 0)\n", + " self.cirB[0].u3(0)\n", + " self.cirB[1].u3(0)\n", + "\n", + " def run_circuit(self, party, cir, state, res):\n", " # Run circuit\n", - " after_state = cir.run(state)\n", + " after_state = cir(state)\n", " # Measure the circuit and record the measurement results \n", - " after_state = self.measure(status=after_state, which_qubits=('Bob', 0), results_desired=res)\n", + " after_state = self.measure(status=after_state, which_qubits=(party, 0), results_desired=res)\n", + "\n", " return after_state\n", - " \n", + "\n", " def forward(self):\n", " # Training steps\n", " # Quantum state after Alice's operation\n", - " phi = self.A_circuit(theta=self.theta1, state=self.phi, res=['0', '1'])\n", - " psi = self.A_circuit(theta=self.theta1, state=self.psi, res=['0', '1'])\n", + " psi = self.run_circuit('Alice', self.cirA, self.psi, ['0', '1'])\n", + " phi = self.run_circuit('Alice', self.cirA, self.phi, ['0', '1'])\n", "\n", " # Calculate the loss function\n", " loss = 0\n", - " for each_phi in phi:\n", - " if each_phi.measured_result == '0':\n", - " # maybe we should call it phi_1 which means predicting the phi to psi\n", - " phi_1 = self.B_circuit(self.theta2, state=each_phi, res='1')\n", - " loss += phi_1.prob\n", - " elif each_phi.measured_result == '1':\n", - " psi_1 = self.B_circuit(self.theta3, state=each_phi, res='1')\n", - " loss += psi_1.prob\n", - "\n", " for each_psi in psi:\n", " if each_psi.measured_result == '0':\n", - " phi_0 = self.B_circuit(self.theta2, state=each_psi, res='0')\n", - " loss += phi_0.prob\n", + " psi_01 = self.run_circuit('Bob', self.cirB[0], each_psi, '1')\n", + " loss += psi_01.prob\n", " elif each_psi.measured_result == '1':\n", - " psi_0 = self.B_circuit(self.theta3, state=each_psi, res='0')\n", - " loss += psi_0.prob\n", + " psi_11 = self.run_circuit('Bob', self.cirB[1], each_psi, '1')\n", + " loss += psi_11.prob\n", + " for each_phi in phi:\n", + " if each_phi.measured_result == '0':\n", + " phi_00 = self.run_circuit('Bob', self.cirB[0], each_phi, '0')\n", + " loss += phi_00.prob\n", + " elif each_phi.measured_result == '1':\n", + " phi_10 = self.run_circuit('Bob', self.cirB[1], each_phi, '0')\n", + " loss += phi_10.prob\n", "\n", " return loss\n", "\n", @@ -222,27 +209,27 @@ " print('Charlie chooses the state', choice)\n", "\n", " # Alice's operations\n", - " status = self.A_circuit(theta=self.theta1, state=self.status, res=['0', '1'])\n", + " status = self.run_circuit('Alice', self.cirA, self.status, ['0', '1'])\n", " # Bob's operations \n", " result_0 = list()\n", " result_1 = list()\n", " for each_status in status:\n", " if each_status.measured_result == '0':\n", - " phi = self.B_circuit(theta=self.theta2, state=each_status, res=['0', '1'])\n", - " result_0.append(phi[0].prob.numpy())\n", - " result_0.append(phi[1].prob.numpy())\n", - "\n", + " status = self.run_circuit('Bob', self.cirB[0], each_status, ['0', '1'])\n", + " result_0.append(status[0].prob.numpy()[0])\n", + " result_0.append(status[1].prob.numpy()[0])\n", " elif each_status.measured_result == '1':\n", - " psi = self.B_circuit(theta=self.theta3, state=each_status, res=['0', '1'])\n", - " result_1.append(psi[0].prob.numpy())\n", - " result_1.append(psi[1].prob.numpy())\n", - " print(\"The probability that Alice and Bob recognize it as phi:\", result_0[0][0] + result_1[0][0])\n", - " print(\"The probability that Alice and Bob recognize it as psi:\", result_0[1][0] + result_1[1][0])\n", - " " + " status = self.run_circuit('Bob', self.cirB[1], each_status, ['0', '1'])\n", + " result_1.append(status[0].prob.numpy()[0])\n", + " result_1.append(status[1].prob.numpy()[0])\n", + "\n", + " print(\"The probability that Alice and Bob recognize it as psi:\", result_0[0] + result_1[0])\n", + " print(\"The probability that Alice and Bob recognize it as phi:\", result_0[1] + result_1[1])" ] }, { "cell_type": "markdown", + "id": "f3c844c1", "metadata": {}, "source": [ "Train the QNN parameters, and Charlie randomly select one of the two orthogonal states $\\lvert\\psi\\rangle$ and $\\lvert\\phi\\rangle$ and see whether Alice and Bob can distinguish it correctly." @@ -250,7 +237,8 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, + "id": "24722ab6", "metadata": { "ExecuteTime": { "end_time": "2021-03-09T04:11:19.312821Z", @@ -262,24 +250,24 @@ "name": "stdout", "output_type": "stream", "text": [ - "itr 0: 0.8761168230331675\n", - "itr 10: 0.20833627335270305\n", - "itr 20: 0.09979993875586758\n", - "itr 30: 0.05990778041973435\n", - "itr 40: 0.02806489116318598\n", - "itr 50: 0.026191291836946892\n", - "itr 60: 0.02245618597383097\n", - "itr 70: 0.01903560177140634\n", - "itr 80: 0.016262801555360196\n", - "itr 90: 0.011920717566034985\n", - "Minimum loss: 0.0077142257760679424\n", + "itr 0: 1.1238832\n", + "itr 10: 0.32665575\n", + "itr 20: 0.085007355\n", + "itr 30: 0.085270524\n", + "itr 40: 0.026622297\n", + "itr 50: 0.015240545\n", + "itr 60: 0.007836903\n", + "itr 70: 0.004827206\n", + "itr 80: 0.0035075857\n", + "itr 90: 0.002215183\n", + "Minimum loss: 0.0016813411\n", "======================== test stage ===============================\n", "Charlie chooses the state psi\n", - "The probability that Alice and Bob recognize it as phi: 0.003188464207077198\n", - "The probability that Alice and Bob recognize it as psi: 0.9968115357929229\n", + "The probability that Alice and Bob recognize it as psi: 0.9990063\n", + "The probability that Alice and Bob recognize it as phi: 0.0009937042\n", "Charlie chooses the state phi\n", - "The probability that Alice and Bob recognize it as phi: 0.99590992116251\n", - "The probability that Alice and Bob recognize it as psi: 0.004090078837489469\n" + "The probability that Alice and Bob recognize it as psi: 0.0006236615\n", + "The probability that Alice and Bob recognize it as phi: 0.9993763\n" ] } ], @@ -291,18 +279,17 @@ "paddle.seed(SEED)\n", "\n", "net = Net()\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", - "loss_list = list()\n", + "params = net.cirA.parameters() + net.cirB[0].parameters() + net.cirB[1].parameters()\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=params)\n", "# Train the LOCC net for ITR iterations by gradient descent\n", "for itr in range(ITR):\n", " loss = net()\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", - " loss_list.append(loss.numpy()[0])\n", " if itr % 10 == 0:\n", " print(\"itr \" + str(itr) + \":\", loss.numpy()[0])\n", - "print(\"Minimum loss:\", loss_list[-1])\n", + "print(\"Minimum loss:\", loss.numpy()[0])\n", "\n", "print(\"======================== test stage ===============================\")\n", "np.random.seed(10)\n", @@ -313,6 +300,7 @@ }, { "cell_type": "markdown", + "id": "46b30cd0", "metadata": {}, "source": [ "## Conclusion\n", @@ -322,6 +310,7 @@ }, { "cell_type": "markdown", + "id": "e1aea01e", "metadata": {}, "source": [ "---\n", @@ -337,7 +326,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -351,7 +340,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/locc/figures/LOCC-fig-BBPSSW.png b/tutorials/locc/figures/LOCC-fig-BBPSSW.png similarity index 100% rename from tutorial/locc/figures/LOCC-fig-BBPSSW.png rename to tutorials/locc/figures/LOCC-fig-BBPSSW.png diff --git a/tutorial/locc/figures/LOCC-fig-controltree.png b/tutorials/locc/figures/LOCC-fig-controltree.png similarity index 100% rename from tutorial/locc/figures/LOCC-fig-controltree.png rename to tutorials/locc/figures/LOCC-fig-controltree.png diff --git a/tutorial/locc/figures/LOCC-fig-cooptree.png b/tutorials/locc/figures/LOCC-fig-cooptree.png similarity index 100% rename from tutorial/locc/figures/LOCC-fig-cooptree.png rename to tutorials/locc/figures/LOCC-fig-cooptree.png diff --git a/tutorial/locc/figures/discrimination-fig-circuit.png b/tutorials/locc/figures/discrimination-fig-circuit.png similarity index 100% rename from tutorial/locc/figures/discrimination-fig-circuit.png rename to tutorials/locc/figures/discrimination-fig-circuit.png diff --git a/tutorial/locc/figures/distillation-fig-BBPSSW.png b/tutorials/locc/figures/distillation-fig-BBPSSW.png similarity index 100% rename from tutorial/locc/figures/distillation-fig-BBPSSW.png rename to tutorials/locc/figures/distillation-fig-BBPSSW.png diff --git a/tutorial/locc/figures/distillation-fig-DEJMPS.jpg b/tutorials/locc/figures/distillation-fig-DEJMPS.jpg similarity index 100% rename from tutorial/locc/figures/distillation-fig-DEJMPS.jpg rename to tutorials/locc/figures/distillation-fig-DEJMPS.jpg diff --git a/tutorial/locc/figures/distillation-fig-LOCCNet4.png b/tutorials/locc/figures/distillation-fig-LOCCNet4.png similarity index 100% rename from tutorial/locc/figures/distillation-fig-LOCCNet4.png rename to tutorials/locc/figures/distillation-fig-LOCCNet4.png diff --git a/tutorial/locc/figures/statetransformation-fig.png b/tutorials/locc/figures/statetransformation-fig.png similarity index 100% rename from tutorial/locc/figures/statetransformation-fig.png rename to tutorials/locc/figures/statetransformation-fig.png diff --git a/tutorial/locc/figures/teleportation-fig-LOCCNet.png b/tutorials/locc/figures/teleportation-fig-LOCCNet.png similarity index 100% rename from tutorial/locc/figures/teleportation-fig-LOCCNet.png rename to tutorials/locc/figures/teleportation-fig-LOCCNet.png diff --git a/tutorial/locc/figures/teleportation-fig-circuit.jpg b/tutorials/locc/figures/teleportation-fig-circuit.jpg similarity index 100% rename from tutorial/locc/figures/teleportation-fig-circuit.jpg rename to tutorials/locc/figures/teleportation-fig-circuit.jpg diff --git a/tutorials/locc/parameters/QT_LOCCNet b/tutorials/locc/parameters/QT_LOCCNet new file mode 100644 index 0000000..2063be7 Binary files /dev/null and b/tutorials/locc/parameters/QT_LOCCNet differ diff --git a/tutorial/machine_learning/DataEncoding_CN.ipynb b/tutorials/machine_learning/DataEncoding_CN.ipynb similarity index 84% rename from tutorial/machine_learning/DataEncoding_CN.ipynb rename to tutorials/machine_learning/DataEncoding_CN.ipynb index 56d49a1..d6913e8 100644 --- a/tutorial/machine_learning/DataEncoding_CN.ipynb +++ b/tutorials/machine_learning/DataEncoding_CN.ipynb @@ -52,14 +52,16 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "44bd5d8e", "metadata": {}, "outputs": [], "source": [ "# 导入所需要的包\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.gate import BasisEncoding, AmplitudeEncoding, AngleEncoding, IQPEncoding\n", + "import paddle_quantum as pq\n", "import numpy as np" ] }, @@ -73,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "eee7f90d", "metadata": {}, "outputs": [ @@ -96,14 +98,14 @@ "# 量子比特的数量等于经典信息的长度\n", "n = 4\n", "# 初始化电路\n", - "basis_enc = UAnsatz(n)\n", + "basis_enc = Circuit(n)\n", "# x 是经典信息\n", "x = '1011'\n", "# 如果第 i 维经典信息是1，那么我们在对应的量子比特上作用一个 X 门\n", "for i in range(len(x)):\n", " if x[i] == '1':\n", " basis_enc.x(i)\n", - " \n", + "\n", "print(basis_enc)" ] }, @@ -117,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "6293b67b", "metadata": {}, "outputs": [ @@ -131,8 +133,10 @@ } ], "source": [ - "basis_quan_state = basis_enc.run_state_vector()\n", - "print(basis_quan_state.numpy())" + "init_state = pq.state.zero_state(n)\n", + "basis_quantum_state = basis_enc(init_state)\n", + "\n", + "print(basis_quantum_state)" ] }, { @@ -147,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "id": "3f58d5a3", "metadata": {}, "outputs": [ @@ -162,12 +166,12 @@ ], "source": [ "# 内置的基态编码函数\n", - "built_in_basis_enc = UAnsatz(n)\n", + "built_in_basis_enc = BasisEncoding(num_qubits=n)\n", "# 经典信息 x 需要是 Tensor 的形式\n", "x = paddle.to_tensor([1, 0, 1, 1])\n", - "built_in_basis_enc.basis_encoding(x)\n", - "built_in_basis_enc_state = built_in_basis_enc.run_state_vector()\n", - "print(built_in_basis_enc_state.numpy())" + "built_in_basis_enc_state = built_in_basis_enc(feature=x)\n", + "\n", + "print(built_in_basis_enc_state)" ] }, { @@ -192,7 +196,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "2436b99f", "metadata": {}, "outputs": [ @@ -209,11 +213,12 @@ "# 量子比特的数目为2\n", "n = 2\n", "# 初始化电路\n", - "built_in_amplitude_enc = UAnsatz(n)\n", + "built_in_amplitude_enc = AmplitudeEncoding(num_qubits=n)\n", "# 经典信息 x 需要是 Tensor 的形式\n", "x = paddle.to_tensor([0.5, 0.5, 0.5])\n", - "state = built_in_amplitude_enc.amplitude_encoding(x, 'state_vector')\n", - "print(state.numpy())" + "state = built_in_amplitude_enc(x)\n", + "\n", + "print(state)" ] }, { @@ -239,7 +244,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "bbfd0d21", "metadata": {}, "outputs": [ @@ -260,12 +265,12 @@ "# 量子比特的数量等于经典信息的维度\n", "n = 3\n", "# 初始化电路\n", - "angle_enc = UAnsatz(n)\n", + "angle_enc = Circuit(n)\n", "# x 是需要编码的经典信息\n", "x = paddle.to_tensor([np.pi, np.pi, np.pi], 'float64')\n", "# 加一层 Ry 旋转门\n", "for i in range(len(x)):\n", - " angle_enc.ry(x[i], i)\n", + " angle_enc.ry(qubits_idx=i, param=x[i])\n", " \n", "print(angle_enc)" ] @@ -280,7 +285,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "id": "5905b719", "metadata": {}, "outputs": [ @@ -288,13 +293,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "[0j, 0j, 0j, 0j, 0j, 0j, 0j, (1+0j)]\n" + "[(-0+0j), 0j, 0j, (-0+0j), 0j, (-0+0j), (-0+0j), (1+0j)]\n" ] } ], "source": [ - "angle_quan_state = angle_enc.run_state_vector()\n", - "print([np.round(i, 2) for i in angle_quan_state.numpy()])" + "init_state = pq.state.zero_state(n)\n", + "angle_quan_state = angle_enc(init_state)\n", + "\n", + "print([np.round(i, 2) for i in angle_quan_state.data.numpy()])" ] }, { @@ -309,7 +316,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "id": "7462102b", "metadata": {}, "outputs": [ @@ -317,21 +324,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "[0j, 0j, 0j, 0j, 0j, 0j, 0j, (1+0j)]\n" + "[(-0+0j), 0j, 0j, (-0+0j), 0j, (-0+0j), (-0+0j), (1+0j)]\n" ] } ], "source": [ "# 内置角度编码函数\n", - "# 量子比特的数目是3\n", + "# 量子比特的数\n", "n = 3\n", "# 初始化电路\n", - "built_in_angle_enc = UAnsatz(n)\n", + "built_in_angle_enc = AngleEncoding(num_qubits=n, encoding_gate=\"ry\", feature=x)\n", "# x是需要编码的经典信息\n", "x = paddle.to_tensor([np.pi, np.pi, np.pi], 'float64')\n", - "built_in_angle_enc.angle_encoding(x, \"ry\")\n", - "state = built_in_angle_enc.run_state_vector()\n", - "print([np.round(i, 2) for i in state.numpy()])" + "init_state = pq.state.zero_state(n)\n", + "state = built_in_angle_enc(state=init_state)\n", + "\n", + "print([np.round(i, 2) for i in state.data.numpy()])" ] }, { @@ -360,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "id": "4ed6549a", "metadata": {}, "outputs": [ @@ -370,7 +378,7 @@ "text": [ "--*-----------------*--\n", " | | \n", - "--X----Rz(6.000)----X--\n", + "--x----Rz(6.000)----x--\n", " \n" ] } @@ -379,13 +387,13 @@ "# 量子比特的数量\n", "n = 2\n", "# 初始化电路\n", - "Rzz = UAnsatz(n)\n", + "Rzz = Circuit(n)\n", "# x 是经典信息\n", "x = paddle.to_tensor([2, 3], 'float64')\n", "# 实现 RZZ 门\n", - "Rzz.cnot([0, 1])\n", - "Rzz.rz(x[0]*x[1], 1)\n", - "Rzz.cnot([0, 1])\n", + "Rzz.cnot(qubits_idx=[0, 1])\n", + "Rzz.rz(qubits_idx=1, param=x[0]*x[1])\n", + "Rzz.cnot(qubits_idx=[0, 1])\n", " \n", "print(Rzz)" ] @@ -402,7 +410,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "id": "05abe637", "metadata": {}, "outputs": [ @@ -412,11 +420,11 @@ "text": [ "--H----Rz(-1.45)----*-----------------*------------------------------------------------\n", " | | \n", - "--H----Rz(3.000)----X----Rz(-4.35)----X----*-----------------*-------------------------\n", + "--H----Rz(3.000)----x----Rz(-4.35)----x----*-----------------*-------------------------\n", " | | \n", - "--H----Rz(2.000)---------------------------X----Rz(6.000)----X----*-----------------*--\n", + "--H----Rz(2.000)---------------------------x----Rz(6.000)----x----*-----------------*--\n", " | | \n", - "--H----Rz(-0.05)--------------------------------------------------X----Rz(-0.10)----X--\n", + "--H----Rz(-0.05)--------------------------------------------------x----Rz(-0.10)----x--\n", " \n" ] } @@ -425,23 +433,23 @@ "# 量子比特的数量\n", "n = 4\n", "# 初始化电路\n", - "iqp_enc = UAnsatz(n)\n", + "iqp_enc = Circuit(n)\n", "# x 是经典信息\n", "x = paddle.to_tensor([-1.45, 3, 2, -0.05], 'float64')\n", "# S 集合中的每一对量子比特对都要加上 RZZ 门\n", "S = [[0, 1], [1, 2], [2, 3]]\n", + "# r 是 U 重复的次数\n", "r = 1\n", "\n", "for i in range(r):\n", " # 加上一层 Hadamard 门\n", - " iqp_enc.superposition_layer()\n", + " iqp_enc.h(\"full\")\n", " # 加上一层旋转门 Rz\n", - " for j in range(n):\n", - " iqp_enc.rz(x[j] ,j)\n", + " iqp_enc.rz(qubits_idx=\"full\",param=x)\n", " # 加上 RZZ 门\n", " for k in S:\n", " iqp_enc.cnot(k)\n", - " iqp_enc.rz(x[k[0]]*x[k[1]], k[1])\n", + " iqp_enc.rz(qubits_idx=k[1], param=x[k[0]]*x[k[1]])\n", " iqp_enc.cnot(k)\n", " \n", "print(iqp_enc)" @@ -457,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "id": "0c84ae1f", "metadata": {}, "outputs": [ @@ -465,13 +473,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "[(0.25+0j), (0.24719-0.03736j), (-0.0115+0.24974j), (-0.02397+0.24885j), (-0.01559-0.24951j), (-0.0527-0.24438j), (0.21313+0.13067j), (0.20633+0.14116j), (0.22138+0.11615j), (0.23625+0.08176j), (-0.12621+0.2158j), (-0.13684+0.20922j), (0.07483+0.23854j), (0.10964+0.22468j), (-0.2382-0.07589j), (-0.23411-0.0877j)]\n" + "[(-0.20396-0.14456j), (-0.22328-0.11246j), (0.15379-0.1971j), (0.16345-0.18916j), (-0.13157+0.21258j), (-0.09832+0.22985j), (-0.09832-0.22985j), (-0.08671-0.23448j), (-0.11345-0.22278j), (-0.14547-0.20332j), (0.22776-0.10308j), (0.23263-0.09157j), (0.07689-0.23788j), (0.04047-0.2467j), (0.15046+0.19966j), (0.14029+0.20693j)]\n" ] } ], "source": [ - "iqp_quan_state = iqp_enc.run_state_vector()\n", - "print([np.round(i, 5) for i in iqp_quan_state.numpy()])" + "init_state = pq.state.zero_state(n)\n", + "iqp_quantum_state = iqp_enc(init_state)\n", + "\n", + "print([np.round(i, 5) for i in iqp_quantum_state.data.numpy()])" ] }, { @@ -484,7 +494,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "b941cb2e", "metadata": {}, "outputs": [ @@ -492,25 +502,26 @@ "name": "stdout", "output_type": "stream", "text": [ - "[(0.25+0j), (0.24719-0.03736j), (-0.0115+0.24974j), (-0.02397+0.24885j), (-0.01559-0.24951j), (-0.0527-0.24438j), (0.21313+0.13067j), (0.20633+0.14116j), (0.22138+0.11615j), (0.23625+0.08176j), (-0.12621+0.2158j), (-0.13684+0.20922j), (0.07483+0.23854j), (0.10964+0.22468j), (-0.2382-0.07589j), (-0.23411-0.0877j)]\n" + "[(-0.20396-0.14456j), (-0.22328-0.11246j), (0.15379-0.1971j), (0.16345-0.18916j), (-0.13157+0.21258j), (-0.09832+0.22985j), (-0.09832-0.22985j), (-0.08671-0.23448j), (-0.11345-0.22278j), (-0.14547-0.20332j), (0.22776-0.10308j), (0.23263-0.09157j), (0.07689-0.23788j), (0.04047-0.2467j), (0.15046+0.19966j), (0.14029+0.20693j)]\n" ] } ], "source": [ "# 内置 IQP 编码\n", - "# 量子比特的数量是 6\n", + "# 量子比特的数量\n", "n = 4\n", "# 初始化电路\n", - "built_in_iqp_enc = UAnsatz(n)\n", - "# x 是经典信息\n", - "x = paddle.to_tensor([-1.45, 3, 2, -0.05], 'float64')\n", - "# S 集合中的每一对量子比特对都要加上 RZZ 门\n", - "S = [[0, 1], [1, 2], [2, 3]]\n", "# r 是 U 重复的次数\n", "r = 1\n", - "built_in_iqp_enc.iqp_encoding(x, r, S)\n", - "built_in_iqp_enc_state = built_in_iqp_enc.run_state_vector()\n", - "print([np.round(i, 5) for i in built_in_iqp_enc_state.numpy()])" + "# S 集合中的每一对量子比特对都要加上 RZZ 门\n", + "S = [[0, 1], [1, 2], [2, 3]]\n", + "built_in_iqp_enc = IQPEncoding(qubits_idx=S, num_qubits = n, num_repeat=r, feature=x)\n", + "# x 是经典信息\n", + "x = paddle.to_tensor([-1.45, 3, 2, -0.05], 'float64')\n", + "init_state = pq.state.zero_state(n)\n", + "built_in_iqp_enc_state = built_in_iqp_enc(state=init_state)\n", + "\n", + "print([np.round(i, 5) for i in built_in_iqp_enc_state.data.numpy()])" ] }, { @@ -551,7 +562,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -565,7 +576,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.8.13" } }, "nbformat": 4, diff --git a/tutorial/machine_learning/DataEncoding_EN.ipynb b/tutorials/machine_learning/DataEncoding_EN.ipynb similarity index 84% rename from tutorial/machine_learning/DataEncoding_EN.ipynb rename to tutorials/machine_learning/DataEncoding_EN.ipynb index 14abf52..9716b61 100644 --- a/tutorial/machine_learning/DataEncoding_EN.ipynb +++ b/tutorials/machine_learning/DataEncoding_EN.ipynb @@ -55,14 +55,16 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "3b220934", "metadata": {}, "outputs": [], "source": [ "# Import necessary library\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.gate import BasisEncoding, AmplitudeEncoding, AngleEncoding, IQPEncoding\n", + "import paddle_quantum as pq\n", "import numpy as np" ] }, @@ -76,7 +78,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "ff86f454", "metadata": {}, "outputs": [ @@ -99,14 +101,14 @@ "# Number of qubits = length of the classical binary string\n", "n = 4\n", "# Initialize the circuit\n", - "basis_enc = UAnsatz(n)\n", + "basis_enc = Circuit(n)\n", "# X is the classical information\n", "x = '1011'\n", "# Add a Pauli X gate to the ith qubit if the ith classical bit is 1\n", "for i in range(len(x)):\n", " if x[i] == '1':\n", " basis_enc.x(i)\n", - " \n", + " \n", "print(basis_enc)" ] }, @@ -120,7 +122,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "9a5909db", "metadata": {}, "outputs": [ @@ -134,8 +136,10 @@ } ], "source": [ - "basis_quan_state = basis_enc.run_state_vector()\n", - "print(basis_quan_state.numpy())" + "init_state = pq.state.zero_state(n)\n", + "basis_quantum_state = basis_enc(init_state)\n", + "\n", + "print(basis_quantum_state)" ] }, { @@ -150,7 +154,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 7, "id": "a7594453", "metadata": {}, "outputs": [ @@ -165,12 +169,12 @@ ], "source": [ "# Built-in basis encoding\n", - "built_in_basis_enc = UAnsatz(n)\n", + "built_in_basis_enc = BasisEncoding(num_qubits=n)\n", "# Classical information x should be of type Tensor\n", "x = paddle.to_tensor([1, 0, 1, 1])\n", - "built_in_basis_enc.basis_encoding(x)\n", - "built_in_basis_enc_state = built_in_basis_enc.run_state_vector()\n", - "print(built_in_basis_enc_state.numpy())" + "built_in_basis_enc_state = built_in_basis_enc(feature=x)\n", + "\n", + "print(built_in_basis_enc_state)" ] }, { @@ -196,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "adb251b5", "metadata": {}, "outputs": [ @@ -210,14 +214,15 @@ ], "source": [ "# Built-in amplitude encoding\n", - "# Number of qubits = 2\n", + "# Number of qubits\n", "n = 2\n", "# Initialize the circuit\n", - "built_in_amplitude_enc = UAnsatz(n)\n", + "built_in_amplitude_enc = AmplitudeEncoding(num_qubits=n)\n", "# Classical information x should be of type Tensor\n", "x = paddle.to_tensor([0.5, 0.5, 0.5])\n", - "state = built_in_amplitude_enc.amplitude_encoding(x, 'state_vector')\n", - "print(state.numpy())" + "state = built_in_amplitude_enc(x)\n", + "\n", + "print(state)" ] }, { @@ -244,7 +249,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "5f9c513e", "metadata": {}, "outputs": [ @@ -265,12 +270,12 @@ "# Number of qubits = length of the classical information\n", "n = 3\n", "# Initialize the circuit\n", - "angle_enc = UAnsatz(n)\n", + "angle_enc = Circuit(n)\n", "# X is the classical information\n", "x = paddle.to_tensor([np.pi, np.pi, np.pi], 'float64')\n", "# Add a layer of rotation y gates\n", "for i in range(len(x)):\n", - " angle_enc.ry(x[i], i)\n", + " angle_enc.ry(qubits_idx=i, param=x[i])\n", " \n", "print(angle_enc)" ] @@ -285,7 +290,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "id": "295e7c3d", "metadata": {}, "outputs": [ @@ -293,13 +298,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "[0j, 0j, 0j, 0j, 0j, 0j, 0j, (1+0j)]\n" + "[(-0+0j), 0j, 0j, (-0+0j), 0j, (-0+0j), (-0+0j), (1+0j)]\n" ] } ], "source": [ - "angle_quan_state = angle_enc.run_state_vector()\n", - "print([np.round(i, 2) for i in angle_quan_state.numpy()])" + "init_state = pq.state.zero_state(n)\n", + "angle_quan_state = angle_enc(init_state)\n", + "\n", + "print([np.round(i, 2) for i in angle_quan_state.data.numpy()])" ] }, { @@ -314,7 +321,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "id": "af779e74", "metadata": {}, "outputs": [ @@ -322,7 +329,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[0j, 0j, 0j, 0j, 0j, 0j, 0j, (1+0j)]\n" + "[(-0+0j), 0j, 0j, (-0+0j), 0j, (-0+0j), (-0+0j), (1+0j)]\n" ] } ], @@ -331,12 +338,13 @@ "# Number of qubits\n", "n = 3\n", "# Initialize the circuit\n", - "built_in_angle_enc = UAnsatz(n)\n", + "built_in_angle_enc = AngleEncoding(num_qubits=n, encoding_gate=\"ry\", feature=x)\n", "# Classical information x should be of type Tensor\n", "x = paddle.to_tensor([np.pi, np.pi, np.pi], 'float64')\n", - "built_in_angle_enc.angle_encoding(x, \"ry\")\n", - "state = built_in_angle_enc.run_state_vector()\n", - "print([np.round(i, 2) for i in state.numpy()])" + "init_state = pq.state.zero_state(n)\n", + "state = built_in_angle_enc(state=init_state)\n", + "\n", + "print([np.round(i, 2) for i in state.data.numpy()])" ] }, { @@ -366,7 +374,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "id": "bcde1189", "metadata": {}, "outputs": [ @@ -376,7 +384,7 @@ "text": [ "--*-----------------*--\n", " | | \n", - "--X----Rz(2.000)----X--\n", + "--x----Rz(6.000)----x--\n", " \n" ] } @@ -385,13 +393,13 @@ "# Number of qubits\n", "n = 2\n", "# Initialize the circuit\n", - "Rzz = UAnsatz(n)\n", + "Rzz = Circuit(n)\n", "# Theta is the angle of Rzz gate\n", - "theta = paddle.to_tensor([2], 'float64')\n", + "x = paddle.to_tensor([2, 3], 'float64')\n", "# Implement Rzz gate\n", - "Rzz.cnot([0, 1])\n", - "Rzz.rz(theta, 1)\n", - "Rzz.cnot([0, 1])\n", + "Rzz.cnot(qubits_idx=[0, 1])\n", + "Rzz.rz(qubits_idx=1, param=x[0]*x[1])\n", + "Rzz.cnot(qubits_idx=[0, 1])\n", " \n", "print(Rzz)" ] @@ -408,7 +416,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "id": "38f5afac", "metadata": {}, "outputs": [ @@ -418,11 +426,11 @@ "text": [ "--H----Rz(-1.45)----*-----------------*------------------------------------------------\n", " | | \n", - "--H----Rz(3.000)----X----Rz(-4.35)----X----*-----------------*-------------------------\n", + "--H----Rz(3.000)----x----Rz(-4.35)----x----*-----------------*-------------------------\n", " | | \n", - "--H----Rz(2.000)---------------------------X----Rz(6.000)----X----*-----------------*--\n", + "--H----Rz(2.000)---------------------------x----Rz(6.000)----x----*-----------------*--\n", " | | \n", - "--H----Rz(-0.05)--------------------------------------------------X----Rz(-0.10)----X--\n", + "--H----Rz(-0.05)--------------------------------------------------x----Rz(-0.10)----x--\n", " \n" ] } @@ -431,7 +439,7 @@ "# Number of qubits\n", "n = 4\n", "# Initialize the circuit\n", - "iqp_enc = UAnsatz(n)\n", + "iqp_enc = Circuit(n)\n", "# X is the classical information\n", "x = paddle.to_tensor([-1.45, 3, 2, -0.05], 'float64')\n", "# S is a list containing all the pairs to be entagled\n", @@ -441,14 +449,13 @@ "\n", "for i in range(r):\n", " # Add a layer of hadamard gates\n", - " iqp_enc.superposition_layer()\n", + " iqp_enc.h(\"full\")\n", " # Add a layer of rotation z gates\n", - " for j in range(n):\n", - " iqp_enc.rz(x[j] ,j)\n", + " iqp_enc.rz(qubits_idx=\"full\",param=x)\n", " # Add a layer of ZZ gates\n", " for k in S:\n", " iqp_enc.cnot(k)\n", - " iqp_enc.rz(x[k[0]] * x[k[1]], k[1])\n", + " iqp_enc.rz(qubits_idx=k[1], param=x[k[0]]*x[k[1]])\n", " iqp_enc.cnot(k)\n", " \n", "print(iqp_enc)" @@ -464,7 +471,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "id": "187b7ec4", "metadata": {}, "outputs": [ @@ -472,13 +479,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "[(0.25+0j), (0.24719-0.03736j), (-0.0115+0.24974j), (-0.02397+0.24885j), (-0.01559-0.24951j), (-0.0527-0.24438j), (0.21313+0.13067j), (0.20633+0.14116j), (0.22138+0.11615j), (0.23625+0.08176j), (-0.12621+0.2158j), (-0.13684+0.20922j), (0.07483+0.23854j), (0.10964+0.22468j), (-0.2382-0.07589j), (-0.23411-0.0877j)]\n" + "[(-0.20396-0.14456j), (-0.22328-0.11246j), (0.15379-0.1971j), (0.16345-0.18916j), (-0.13157+0.21258j), (-0.09832+0.22985j), (-0.09832-0.22985j), (-0.08671-0.23448j), (-0.11345-0.22278j), (-0.14547-0.20332j), (0.22776-0.10308j), (0.23263-0.09157j), (0.07689-0.23788j), (0.04047-0.2467j), (0.15046+0.19966j), (0.14029+0.20693j)]\n" ] } ], "source": [ - "iqp_quan_state = iqp_enc.run_state_vector()\n", - "print([np.round(i, 5) for i in iqp_quan_state.numpy()])" + "init_state = pq.state.zero_state(n)\n", + "iqp_quantum_state = iqp_enc(init_state)\n", + "\n", + "print([np.round(i, 5) for i in iqp_quantum_state.data.numpy()])" ] }, { @@ -492,7 +501,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "a81b03cb", "metadata": {}, "outputs": [ @@ -500,7 +509,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[(0.25+0j), (0.24719-0.03736j), (-0.0115+0.24974j), (-0.02397+0.24885j), (-0.01559-0.24951j), (-0.0527-0.24438j), (0.21313+0.13067j), (0.20633+0.14116j), (0.22138+0.11615j), (0.23625+0.08176j), (-0.12621+0.2158j), (-0.13684+0.20922j), (0.07483+0.23854j), (0.10964+0.22468j), (-0.2382-0.07589j), (-0.23411-0.0877j)]\n" + "[(-0.20396-0.14456j), (-0.22328-0.11246j), (0.15379-0.1971j), (0.16345-0.18916j), (-0.13157+0.21258j), (-0.09832+0.22985j), (-0.09832-0.22985j), (-0.08671-0.23448j), (-0.11345-0.22278j), (-0.14547-0.20332j), (0.22776-0.10308j), (0.23263-0.09157j), (0.07689-0.23788j), (0.04047-0.2467j), (0.15046+0.19966j), (0.14029+0.20693j)]\n" ] } ], @@ -509,16 +518,17 @@ "# Number of qubits\n", "n = 4\n", "# Initialize the circuit\n", - "built_in_iqp_enc = UAnsatz(n)\n", - "# Classical information x should be of type Tensor\n", - "x = paddle.to_tensor([-1.45, 3, 2, -0.05], 'float64')\n", - "# S is a list containing all the pairs to be entagled\n", - "S = [[0, 1], [1, 2], [2, 3]]\n", "# r is the repeating times of U\n", "r = 1\n", - "built_in_iqp_enc.iqp_encoding(x, r, S)\n", - "built_in_iqp_enc_state = built_in_iqp_enc.run_state_vector()\n", - "print([np.round(i, 5) for i in built_in_iqp_enc_state.numpy()])" + "# S is a list containing all the pairs to be entagled\n", + "S = [[0, 1], [1, 2], [2, 3]]\n", + "built_in_iqp_enc = IQPEncoding(qubits_idx=S, num_qubits = n, num_repeat=r, feature=x)\n", + "# Classical information x should be of type Tensor\n", + "x = paddle.to_tensor([-1.45, 3, 2, -0.05], 'float64')\n", + "init_state = pq.state.zero_state(n)\n", + "built_in_iqp_enc_state = built_in_iqp_enc(state=init_state)\n", + "\n", + "print([np.round(i, 5) for i in built_in_iqp_enc_state.data.numpy()])" ] }, { @@ -559,7 +569,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -573,7 +583,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.8.13" } }, "nbformat": 4, diff --git a/tutorial/machine_learning/QAutoencoder_CN.ipynb b/tutorials/machine_learning/QAutoencoder_CN.ipynb similarity index 66% rename from tutorial/machine_learning/QAutoencoder_CN.ipynb rename to tutorials/machine_learning/QAutoencoder_CN.ipynb index bdf72de..79b77a3 100644 --- a/tutorial/machine_learning/QAutoencoder_CN.ipynb +++ b/tutorials/machine_learning/QAutoencoder_CN.ipynb @@ -74,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:58:08.278605Z", @@ -84,13 +84,13 @@ "outputs": [], "source": [ "import numpy as np\n", - "from numpy import diag\n", - "import scipy\n", - "import scipy.stats\n", "import paddle\n", "from paddle import matmul, trace, kron, real\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import dagger, state_fidelity, partial_trace" + "import paddle_quantum as pq\n", + "from paddle_quantum.ansatz.circuit import Circuit\n", + "from paddle_quantum.qinfo import state_fidelity, partial_trace\n", + "from paddle_quantum.linalg import dagger, haar_unitary\n", + "from paddle_quantum.state.common import to_state" ] }, { @@ -104,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:58:08.292440Z", @@ -113,18 +113,18 @@ }, "outputs": [], "source": [ - "N_A = 2 # 系统 A 的量子比特数\n", - "N_B = 1 # 系统 B 的量子比特数\n", - "N = N_A + N_B # 总的量子比特数\n", - "\n", - "scipy.random.seed(1) # 固定随机种子\n", - "V = scipy.stats.unitary_group.rvs(2**N) # 随机生成一个酉矩阵\n", - "D = diag([0.4, 0.2, 0.2, 0.1, 0.1, 0, 0, 0]) # 输入目标态rho的谱\n", - "V_H = V.conj().T # 进行厄尔米特转置\n", - "rho_in = (V @ D @ V_H).astype('complex128') # 生成 rho_in\n", + "N_A = 2 # 系统 A 的量子比特数\n", + "N_B = 1 # 系统 B 的量子比特数\n", + "N = N_A + N_B # 总的量子比特数\n", + "SEED = 15 # 设置随机数种子\n", + "paddle.seed(SEED)\n", + "pq.set_dtype('complex64') # 设置数据类型\n", "\n", - "# 初始化量子系统 C\n", - "rho_C = np.diag([1,0]).astype('complex128')" + "V = haar_unitary(N).numpy() # 随机生成一个酉矩阵\n", + "D = np.diag([0.4, 0.2, 0.2, 0.1, 0.1, 0, 0, 0]) # 输入目标态 rho 的谱\n", + "V_H = V.conj().T # 进行厄尔米特转置\n", + "rho_in = to_state((V @ D @ V_H).astype('complex64')) # 生成输入量子态 rho_in\n", + "rho_C = to_state(np.diag([1,0]).astype('complex64')) # 生成辅助量子系统 C" ] }, { @@ -139,38 +139,40 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:58:08.310082Z", "start_time": "2021-04-30T08:58:08.303101Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "初始化的电路：\n", + "--Ry(2.974)----Rz(3.296)----*---------x----Ry(4.201)----Rz(4.559)----*---------x----Ry(5.254)----Rz(4.834)----*---------x----Ry(3.263)----Rz(1.664)----*---------x----Ry(5.240)----Rz(1.166)----*---------x----Ry(5.038)----Rz(0.564)----*---------x--\n", + " | | | | | | | | | | | | \n", + "--Ry(2.407)----Rz(3.514)----x----*----|----Ry(6.279)----Rz(4.675)----x----*----|----Ry(4.986)----Rz(5.080)----x----*----|----Ry(2.845)----Rz(2.662)----x----*----|----Ry(0.015)----Rz(0.052)----x----*----|----Ry(4.341)----Rz(5.329)----x----*----|--\n", + " | | | | | | | | | | | | \n", + "--Ry(3.866)----Rz(3.272)---------x----*----Ry(2.219)----Rz(2.298)---------x----*----Ry(6.060)----Rz(0.431)---------x----*----Ry(3.197)----Rz(1.673)---------x----*----Ry(2.324)----Rz(0.037)---------x----*----Ry(4.892)----Rz(1.856)---------x----*--\n", + " \n" + ] + } + ], "source": [ - "# 设置电路参数\n", - "cir_depth = 6 # 电路深度\n", - "block_len = 2 # 每个模组的长度\n", - "theta_size = N*block_len*cir_depth # 网络参数 theta 的大小\n", - "\n", - "# 搭建编码器 Encoder E\n", - "def Encoder(theta):\n", - "\n", - " # 用 UAnsatz 初始化网络\n", - " cir = UAnsatz(N)\n", - " \n", - " # 搭建层级结构：\n", - " for layer_num in range(cir_depth):\n", - " \n", - " for which_qubit in range(N):\n", - " cir.ry(theta[block_len*layer_num*N + which_qubit], which_qubit)\n", - " cir.rz(theta[(block_len*layer_num + 1)*N + which_qubit], which_qubit)\n", - "\n", - " for which_qubit in range(N-1):\n", - " cir.cnot([which_qubit, which_qubit + 1])\n", - " cir.cnot([N-1, 0])\n", - "\n", - " return cir" + "# 设置电路深度\n", + "cir_depth = 6\n", + "\n", + "# 用 Circuit 类搭建编码器 Encoder E\n", + "cir_Encoder = Circuit(N)\n", + "for _ in range(cir_depth):\n", + " cir_Encoder.ry('full')\n", + " cir_Encoder.rz('full')\n", + " cir_Encoder.cnot('cycle')\n", + "print(\"初始化的电路：\") \n", + "print(cir_Encoder)" ] }, { @@ -191,110 +193,103 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:58:31.111139Z", "start_time": "2021-04-30T08:58:20.555305Z" - } + }, + "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iter: 10 loss: 0.1683 fid: 0.8211\n", - "iter: 20 loss: 0.1231 fid: 0.8720\n", - "iter: 30 loss: 0.1122 fid: 0.8810\n", - "iter: 40 loss: 0.1058 fid: 0.8864\n", - "iter: 50 loss: 0.1025 fid: 0.8901\n", - "iter: 60 loss: 0.1019 fid: 0.8907\n", - "iter: 70 loss: 0.1013 fid: 0.8914\n", - "iter: 80 loss: 0.1012 fid: 0.8917\n", - "iter: 90 loss: 0.1010 fid: 0.8921\n", - "iter: 100 loss: 0.1008 fid: 0.8924\n", + "iter: 10 loss: 0.1594 fid: 0.8286\n", + "iter: 20 loss: 0.1214 fid: 0.8741\n", + "iter: 30 loss: 0.1078 fid: 0.8861\n", + "iter: 40 loss: 0.1026 fid: 0.8906\n", + "iter: 50 loss: 0.1017 fid: 0.8905\n", + "iter: 60 loss: 0.1009 fid: 0.8925\n", + "iter: 70 loss: 0.1005 fid: 0.8935\n", + "iter: 80 loss: 0.1004 fid: 0.8935\n", + "iter: 90 loss: 0.1002 fid: 0.8942\n", + "iter: 100 loss: 0.1001 fid: 0.8949\n", "\n", "训练后的电路：\n", - "--Ry(3.935)----Rz(2.876)----*---------X----Ry(2.678)----Rz(6.372)----*---------X----Ry(5.516)----Rz(4.082)----*---------X----Ry(1.199)----Rz(1.584)----*---------X----Ry(4.512)----Rz(0.847)----*---------X----Ry(5.038)----Rz(0.564)----*---------X--\n", + "--Ry(3.020)----Rz(4.904)----*---------x----Ry(3.350)----Rz(4.894)----*---------x----Ry(6.877)----Rz(4.309)----*---------x----Ry(3.806)----Rz(1.201)----*---------x----Ry(4.422)----Rz(1.580)----*---------x----Ry(3.051)----Rz(-0.90)----*---------x--\n", " | | | | | | | | | | | | \n", - "--Ry(2.045)----Rz(4.282)----X----*----|----Ry(6.116)----Rz(6.203)----X----*----|----Ry(5.135)----Rz(4.828)----X----*----|----Ry(3.532)----Rz(3.827)----X----*----|----Ry(0.497)----Rz(1.693)----X----*----|----Ry(5.243)----Rz(5.329)----X----*----|--\n", + "--Ry(2.135)----Rz(3.829)----x----*----|----Ry(5.740)----Rz(3.472)----x----*----|----Ry(5.583)----Rz(4.673)----x----*----|----Ry(2.273)----Rz(2.103)----x----*----|----Ry(2.121)----Rz(0.393)----x----*----|----Ry(4.825)----Rz(5.194)----x----*----|--\n", " | | | | | | | | | | | | \n", - "--Ry(2.706)----Rz(4.168)---------X----*----Ry(2.141)----Rz(2.014)---------X----*----Ry(5.364)----Rz(-0.34)---------X----*----Ry(4.014)----Rz(2.668)---------X----*----Ry(3.419)----Rz(1.952)---------X----*----Ry(4.255)----Rz(1.856)---------X----*--\n", + "--Ry(2.911)----Rz(2.564)---------x----*----Ry(2.335)----Rz(1.657)---------x----*----Ry(6.486)----Rz(0.392)---------x----*----Ry(2.889)----Rz(1.981)---------x----*----Ry(0.753)----Rz(1.536)---------x----*----Ry(5.659)----Rz(3.284)---------x----*--\n", " \n" ] } ], "source": [ "# 超参数设置\n", - "N_A = 2 # 系统 A 的量子比特数\n", - "N_B = 1 # 系统 B 的量子比特数\n", - "N = N_A + N_B # 总的量子比特数\n", "LR = 0.2 # 设置学习速率\n", "ITR = 100 # 设置迭代次数\n", - "SEED = 15 # 固定初始化参数用的随机数种子\n", "\n", "class NET(paddle.nn.Layer):\n", - "\n", - " def __init__(self, shape, dtype='float64'):\n", + " def __init__(self, cir, rho_in, rho_C, dtype='float32'):\n", " super(NET, self).__init__()\n", - " \n", - " # 将 Numpy array 转换成 Paddle 中支持的 Tensor\n", - " self.rho_in = paddle.to_tensor(rho_in)\n", - " self.rho_C = paddle.to_tensor(rho_C)\n", - " self.theta = self.create_parameter(shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype=dtype, is_bias=False)\n", + " # 载入编码器 E\n", + " self.cir = cir\n", + " # 载入输入态 rho_in 和辅助态 rho_C\n", + " self.rho_in = rho_in\n", + " self.rho_C = rho_C\n", + " # 设置可训练参数\n", + " self.theta = cir.parameters()\n", " \n", " # 定义损失函数和前向传播机制\n", " def forward(self):\n", - " \n", - " # 生成初始的编码器 E 和解码器 D\n", - " cir = Encoder(self.theta)\n", - " E = cir.U\n", + " \n", + " # 生成编码器 E 和解码器 D 的矩阵形式\n", + " E = self.cir.unitary_matrix()\n", " E_dagger = dagger(E)\n", " D = E_dagger\n", " D_dagger = E\n", "\n", " # 编码量子态 rho_in\n", - " rho_BA = matmul(matmul(E, self.rho_in), E_dagger)\n", + " rho_BA = to_state(matmul(matmul(E, self.rho_in.data), E_dagger))\n", " \n", " # 取 partial_trace() 获得 rho_encode 与 rho_trash\n", - " rho_encode = partial_trace(rho_BA, 2 ** N_B, 2 ** N_A, 1)\n", - " rho_trash = partial_trace(rho_BA, 2 ** N_B, 2 ** N_A, 2)\n", + " rho_encode = to_state(partial_trace(rho_BA, 2 ** N_B, 2 ** N_A, 1))\n", + " rho_trash = to_state(partial_trace(rho_BA, 2 ** N_B, 2 ** N_A, 2))\n", "\n", " # 解码得到量子态 rho_out\n", - " rho_CA = kron(self.rho_C, rho_encode)\n", - " rho_out = matmul(matmul(D, rho_CA), D_dagger)\n", + " rho_CA = to_state(kron(self.rho_C.data, rho_encode.data))\n", + " rho_out = to_state(matmul(matmul(D, rho_CA.data), D_dagger))\n", " \n", " # 通过 rho_trash 计算损失函数\n", - " zero_Hamiltonian = paddle.to_tensor(np.diag([1,0]).astype('complex128'))\n", - " loss = 1 - real(trace(matmul(zero_Hamiltonian, rho_trash)))\n", - "\n", - " return loss, self.rho_in, rho_out, cir\n", + " zero_Hamiltonian = paddle.to_tensor(np.diag([1,0]).astype('complex64'))\n", + " loss = 1 - real(trace(matmul(zero_Hamiltonian, rho_trash.data)))\n", "\n", + " return loss, rho_out\n", "\n", - "paddle.seed(SEED)\n", "# 生成网络\n", - "net = NET([theta_size])\n", + "net = NET(cir_Encoder, rho_in, rho_C)\n", "# 一般来说，我们利用 Adam 优化器来获得相对好的收敛\n", - "# 当然你可以改成 SGD 或者是 RMS prop.\n", + "# 当然你可以改成 SGD 或者是 RMS prop\n", "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", "\n", "# 优化循环\n", "for itr in range(1, ITR + 1):\n", - " # 前向传播计算损失函数\n", - " loss, rho_in, rho_out, cir = net()\n", + " # 前向传播计算损失函数\n", + " loss, rho_out = net()\n", " # 反向传播极小化损失函数\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", " # 计算并打印保真度\n", - " fid = state_fidelity(rho_in.numpy(), rho_out.numpy())\n", + " fid = state_fidelity(rho_in, rho_out)\n", " if itr % 10 == 0:\n", - " print('iter:', itr, 'loss:', '%.4f' % loss, 'fid:', '%.4f' % np.square(fid))\n", + " print('iter:', itr, 'loss:', '%.4f' % loss, 'fid:', '%.4f' % np.square(fid.item()))\n", " if itr == ITR:\n", " print(\"\\n训练后的电路：\") \n", - " print(cir)" + " print(cir_Encoder)" ] }, { @@ -327,7 +322,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -341,7 +336,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/machine_learning/QAutoencoder_EN.ipynb b/tutorials/machine_learning/QAutoencoder_EN.ipynb similarity index 65% rename from tutorial/machine_learning/QAutoencoder_EN.ipynb rename to tutorials/machine_learning/QAutoencoder_EN.ipynb index 18b3513..af7a49a 100644 --- a/tutorial/machine_learning/QAutoencoder_EN.ipynb +++ b/tutorials/machine_learning/QAutoencoder_EN.ipynb @@ -74,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:57:29.266507Z", @@ -84,13 +84,13 @@ "outputs": [], "source": [ "import numpy as np\n", - "from numpy import diag\n", - "import scipy\n", - "import scipy.stats\n", "import paddle\n", "from paddle import matmul, trace, kron, real\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import dagger, state_fidelity, partial_trace" + "import paddle_quantum as pq\n", + "from paddle_quantum.ansatz.circuit import Circuit\n", + "from paddle_quantum.qinfo import state_fidelity, partial_trace\n", + "from paddle_quantum.linalg import dagger, haar_unitary\n", + "from paddle_quantum.state.common import to_state" ] }, { @@ -105,7 +105,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:57:29.283394Z", @@ -114,18 +114,18 @@ }, "outputs": [], "source": [ - "N_A = 2 # Number of qubits in system A\n", - "N_B = 1 # Number of qubits in system B\n", - "N = N_A + N_B # Total number of qubits\n", - "\n", - "scipy.random.seed(1) # Fixed random seed\n", - "V = scipy.stats.unitary_group.rvs(2**N) # Generate a random unitary matrix\n", - "D = diag([0.4, 0.2, 0.2, 0.1, 0.1, 0, 0, 0]) # Enter the spectrum of the target state rho\n", - "V_H = V.conj().T # Apply Hermitian transpose\n", - "rho_in = (V @ D @ V_H).astype('complex128') # Generate rho_in\n", + "N_A = 2 # Number of qubits in system A\n", + "N_B = 1 # Number of qubits in system B\n", + "N = N_A + N_B # Total number of qubits\n", + "SEED = 15 # Set random seed\n", + "paddle.seed(SEED)\n", + "pq.set_dtype('complex64') # set data type\n", "\n", - "# Initialize the quantum system C\n", - "rho_C = np.diag([1,0]).astype('complex128')" + "V = haar_unitary(N).numpy() # Generate a random unitary matrix\n", + "D = np.diag([0.4, 0.2, 0.2, 0.1, 0.1, 0, 0, 0]) # Set the spectrum of the target state rho\n", + "V_H = V.conj().T # Apply Hermitian transpose\n", + "rho_in = to_state((V @ D @ V_H).astype('complex64')) # Generate input state rho_in\n", + "rho_C = to_state(np.diag([1,0]).astype('complex64')) # Generate ancilla state rho_C" ] }, { @@ -139,39 +139,40 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:57:29.301622Z", "start_time": "2021-04-30T08:57:29.288113Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The initialized circuit:\n", + "--Ry(2.974)----Rz(3.296)----*---------x----Ry(4.201)----Rz(4.559)----*---------x----Ry(5.254)----Rz(4.834)----*---------x----Ry(3.263)----Rz(1.664)----*---------x----Ry(5.240)----Rz(1.166)----*---------x----Ry(5.038)----Rz(0.564)----*---------x--\n", + " | | | | | | | | | | | | \n", + "--Ry(2.407)----Rz(3.514)----x----*----|----Ry(6.279)----Rz(4.675)----x----*----|----Ry(4.986)----Rz(5.080)----x----*----|----Ry(2.845)----Rz(2.662)----x----*----|----Ry(0.015)----Rz(0.052)----x----*----|----Ry(4.341)----Rz(5.329)----x----*----|--\n", + " | | | | | | | | | | | | \n", + "--Ry(3.866)----Rz(3.272)---------x----*----Ry(2.219)----Rz(2.298)---------x----*----Ry(6.060)----Rz(0.431)---------x----*----Ry(3.197)----Rz(1.673)---------x----*----Ry(2.324)----Rz(0.037)---------x----*----Ry(4.892)----Rz(1.856)---------x----*--\n", + " \n" + ] + } + ], "source": [ - "# Set circuit parameters\n", - "cir_depth = 6 # Circuit depth\n", - "block_len = 2 # The length of each block\n", - "theta_size = N*block_len*cir_depth # The size of the circuit parameter theta\n", - "\n", - "\n", - "# Build the encoder E\n", - "def Encoder(theta):\n", - "\n", - " # Initialize the network with UAnsatz\n", - " cir = UAnsatz(N)\n", - " \n", - " # Build the network by layers\n", - " for layer_num in range(cir_depth):\n", - " \n", - " for which_qubit in range(N):\n", - " cir.ry(theta[block_len*layer_num*N + which_qubit], which_qubit)\n", - " cir.rz(theta[(block_len*layer_num + 1)*N+ which_qubit], which_qubit)\n", - "\n", - " for which_qubit in range(N-1):\n", - " cir.cnot([which_qubit, which_qubit + 1])\n", - " cir.cnot([N-1, 0])\n", - "\n", - " return cir" + "# Set circuit depth\n", + "cir_depth = 6\n", + "\n", + "# Use Circuit class to build the encoder E\n", + "cir_Encoder = Circuit(N)\n", + "for _ in range(cir_depth):\n", + " cir_Encoder.ry('full')\n", + " cir_Encoder.rz('full')\n", + " cir_Encoder.cnot('cycle')\n", + "print(\"The initialized circuit:\") \n", + "print(cir_Encoder)" ] }, { @@ -192,7 +193,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:57:52.962725Z", @@ -204,97 +205,90 @@ "name": "stdout", "output_type": "stream", "text": [ - "iter: 10 loss: 0.1683 fid: 0.8211\n", - "iter: 20 loss: 0.1231 fid: 0.8720\n", - "iter: 30 loss: 0.1122 fid: 0.8810\n", - "iter: 40 loss: 0.1058 fid: 0.8864\n", - "iter: 50 loss: 0.1025 fid: 0.8901\n", - "iter: 60 loss: 0.1019 fid: 0.8907\n", - "iter: 70 loss: 0.1013 fid: 0.8914\n", - "iter: 80 loss: 0.1012 fid: 0.8917\n", - "iter: 90 loss: 0.1010 fid: 0.8921\n", - "iter: 100 loss: 0.1008 fid: 0.8924\n", + "iter: 10 loss: 0.1700 fid: 0.8226\n", + "iter: 20 loss: 0.1329 fid: 0.8605\n", + "iter: 30 loss: 0.1138 fid: 0.8793\n", + "iter: 40 loss: 0.1075 fid: 0.8856\n", + "iter: 50 loss: 0.1024 fid: 0.8891\n", + "iter: 60 loss: 0.1010 fid: 0.8917\n", + "iter: 70 loss: 0.1003 fid: 0.8927\n", + "iter: 80 loss: 0.1001 fid: 0.8932\n", + "iter: 90 loss: 0.1000 fid: 0.8936\n", + "iter: 100 loss: 0.1000 fid: 0.8939\n", "\n", "The trained circuit:\n", - "--Ry(3.935)----Rz(2.876)----*---------X----Ry(2.678)----Rz(6.372)----*---------X----Ry(5.516)----Rz(4.082)----*---------X----Ry(1.199)----Rz(1.584)----*---------X----Ry(4.512)----Rz(0.847)----*---------X----Ry(5.038)----Rz(0.564)----*---------X--\n", + "--Ry(3.715)----Rz(3.480)----*---------x----Ry(5.783)----Rz(3.863)----*---------x----Ry(4.643)----Rz(5.174)----*---------x----Ry(3.187)----Rz(1.627)----*---------x----Ry(5.195)----Rz(1.282)----*---------x----Ry(5.990)----Rz(0.919)----*---------x--\n", " | | | | | | | | | | | | \n", - "--Ry(2.045)----Rz(4.282)----X----*----|----Ry(6.116)----Rz(6.203)----X----*----|----Ry(5.135)----Rz(4.828)----X----*----|----Ry(3.532)----Rz(3.827)----X----*----|----Ry(0.497)----Rz(1.693)----X----*----|----Ry(5.243)----Rz(5.329)----X----*----|--\n", + "--Ry(2.889)----Rz(3.898)----x----*----|----Ry(7.024)----Rz(5.530)----x----*----|----Ry(4.595)----Rz(4.244)----x----*----|----Ry(3.576)----Rz(2.981)----x----*----|----Ry(-1.39)----Rz(0.356)----x----*----|----Ry(3.557)----Rz(4.126)----x----*----|--\n", " | | | | | | | | | | | | \n", - "--Ry(2.706)----Rz(4.168)---------X----*----Ry(2.141)----Rz(2.014)---------X----*----Ry(5.364)----Rz(-0.34)---------X----*----Ry(4.014)----Rz(2.668)---------X----*----Ry(3.419)----Rz(1.952)---------X----*----Ry(4.255)----Rz(1.856)---------X----*--\n", + "--Ry(3.593)----Rz(3.298)---------x----*----Ry(0.958)----Rz(2.486)---------x----*----Ry(6.317)----Rz(0.314)---------x----*----Ry(3.837)----Rz(2.775)---------x----*----Ry(3.415)----Rz(-0.07)---------x----*----Ry(4.543)----Rz(3.359)---------x----*--\n", " \n" ] } ], "source": [ "# Set hyper-parameters\n", - "N_A = 2 # Number of qubits in system A\n", - "N_B = 1 # Number of qubits in system B\n", - "N = N_A + N_B # Total number of qubits\n", "LR = 0.2 # Set the learning rate\n", "ITR = 100 # Set the number of iterations\n", - "SEED = 15 # Fixed random number seed for initializing parameters\n", "\n", "class NET(paddle.nn.Layer):\n", - " def __init__(self, shape, dtype='float64'):\n", + " def __init__(self, cir, rho_in, rho_C, dtype='float32'):\n", " super(NET, self).__init__()\n", - " \n", - " # Convert Numpy array to Tensor supported in PaddlePaddle\n", - " self.rho_in = paddle.to_tensor(rho_in)\n", - " self.rho_C = paddle.to_tensor(rho_C)\n", - " self.theta = self.create_parameter(shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype=dtype, is_bias=False)\n", + " # load the circuit of the encoder E\n", + " self.cir = cir\n", + " # load the input state rho_in and the ancilla state rho_C\n", + " self.rho_in = rho_in\n", + " self.rho_C = rho_C\n", + " # set trainable parameters\n", + " self.theta = cir.parameters()\n", " \n", " # Define loss function and forward propagation mechanism\n", " def forward(self):\n", - " \n", - " # Generate initial encoder E and decoder D\n", - " cir = Encoder(self.theta)\n", - " E = cir.U\n", + " \n", + " # Generate the matrices of the encoder E and decoder D\n", + " E = self.cir.unitary_matrix()\n", " E_dagger = dagger(E)\n", " D = E_dagger\n", " D_dagger = E\n", "\n", " # Encode the quantum state rho_in\n", - " rho_BA = matmul(matmul(E, self.rho_in), E_dagger)\n", + " rho_BA = to_state(matmul(matmul(E, self.rho_in.data), E_dagger))\n", " \n", " # Take partial_trace() to get rho_encode and rho_trash\n", - " rho_encode = partial_trace(rho_BA, 2 ** N_B, 2 ** N_A, 1)\n", - " rho_trash = partial_trace(rho_BA, 2 ** N_B, 2 ** N_A, 2)\n", + " rho_encode = to_state(partial_trace(rho_BA, 2 ** N_B, 2 ** N_A, 1))\n", + " rho_trash = to_state(partial_trace(rho_BA, 2 ** N_B, 2 ** N_A, 2))\n", "\n", - " # Decode the quantum state rho_out\n", - " rho_CA = kron(self.rho_C, rho_encode)\n", - " rho_out = matmul(matmul(D, rho_CA), D_dagger)\n", + " # Decode and get the quantum state rho_out\n", + " rho_CA = to_state(kron(self.rho_C.data, rho_encode.data))\n", + " rho_out = to_state(matmul(matmul(D, rho_CA.data), D_dagger))\n", " \n", " # Calculate the loss function with rho_trash\n", - " zero_Hamiltonian = paddle.to_tensor(np.diag([1,0]).astype('complex128'))\n", - " loss = 1 - real(trace(matmul(zero_Hamiltonian, rho_trash)))\n", - "\n", - " return loss, self.rho_in, rho_out, cir\n", + " zero_Hamiltonian = paddle.to_tensor(np.diag([1,0]).astype('complex64'))\n", + " loss = 1 - real(trace(matmul(zero_Hamiltonian, rho_trash.data)))\n", "\n", + " return loss, rho_out\n", "\n", - "paddle.seed(SEED)\n", "# Generate network\n", - "net = NET([theta_size])\n", + "net = NET(cir_Encoder, rho_in, rho_C)\n", "# Generally speaking, we use Adam optimizer to get relatively good convergence\n", - "# Of course, it can be changed to SGD or RMS prop.\n", + "# Of course, it can be changed to SGD or RMS prop\n", "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", "\n", "# Optimization loops\n", "for itr in range(1, ITR + 1):\n", " # Forward propagation for calculating loss function\n", - " loss, rho_in, rho_out, cir = net()\n", + " loss, rho_out = net()\n", " # Use back propagation to minimize the loss function\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", " # Calculate and print fidelity\n", - " fid = state_fidelity(rho_in.numpy(), rho_out.numpy())\n", - " if itr% 10 == 0:\n", - " print('iter:', itr,'loss:','%.4f'% loss,'fid:','%.4f'% np.square(fid))\n", + " fid = state_fidelity(rho_in, rho_out)\n", + " if itr % 10 == 0:\n", + " print('iter:', itr, 'loss:', '%.4f' % loss, 'fid:', '%.4f' % np.square(fid.item()))\n", " if itr == ITR:\n", - " print(\"\\nThe trained circuit:\")\n", - " print(cir)" + " print(\"\\nThe trained circuit:\") \n", + " print(cir_Encoder)" ] }, { @@ -326,7 +320,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -340,7 +334,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorials/machine_learning/QClassifier_CN.ipynb b/tutorials/machine_learning/QClassifier_CN.ipynb new file mode 100644 index 0000000..ff61cb6 --- /dev/null +++ b/tutorials/machine_learning/QClassifier_CN.ipynb @@ -0,0 +1,1392 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 量子分类器\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 概览\n", + "\n", + "本教程我们将讨论量子分类器（quantum classifier）的原理，以及如何利用量子神经网络（quantum neural network, QNN）来完成**二分类**任务。这类方法早期工作的主要代表是 Mitarai et al.(2018) 的量子电路学习 [(Quantum Circuit Learning, QCL)](https://arxiv.org/abs/1803.00745) [1], Farhi & Neven (2018) [2] 和 Schuld et al.(2018) 的中心电路量子分类器 [Circuit-Centric Quantum Classifiers](https://arxiv.org/abs/1804.00633) [3]。这里我们以第一类的 QCL 框架应用于监督学习（Supervised learning）为例进行介绍，通常我们需要先将经典数据编码成量子数据，然后通过训练量子神经网络的参数，最终得到一个最优的分类器。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 背景\n", + "\n", + "在监督学习的情况下，我们需要输入 $N$ 个带标签的数据点构成的数据集 $D = \\{(x^k,y^k)\\}_{k=1}^{K}$，其中 $x^k\\in \\mathbb{R}^{m}$ 是数据点，$y^k \\in\\{0,1\\}$ 是对应数据点 $x^k$ 的分类标签。**分类过程实质上是一个决策过程，决策给定数据点的标签归属问题**。 对于量子分类器框架，分类器 $\\mathcal{F}$ 的实现方式为一个含参 $\\theta$ 的量子神经网络/参数化量子电路, 测量量子系统以及数据后处理的组合。一个优秀的分类器 $\\mathcal{F}_\\theta$ 应该尽可能的将每个数据集内的数据点正确地映射到相对应的标签上 $\\mathcal{F}_\\theta(x^k) \\rightarrow y^k$。因此，我们将预测标签 $\\tilde{y}^{k} = \\mathcal{F}_\\theta(x^k)$ 和实际标签 $y^k$ 之间的累计距离作为损失函数 $\\mathcal{L}(\\theta)$ 进行优化。对于两分类任务，可以选择二次损失函数\n", + "\n", + "$$\n", + "\\mathcal{L}(\\theta) = \\sum_{k=1}^N 1/N \\cdot |\\tilde{y}^{k}-y^k|^2. \\tag{1}\n", + "$$\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 方案流程\n", + "\n", + "这里我们给出实现量子电路学习 (QCL) 框架下量子分类器的一个流程。\n", + "\n", + "1. 将经典数据编码$x^k$为量子数据$\\lvert \\psi_{\\rm in}\\rangle^k$。本教程采用角度编码。关于编码方式的具体操作，见[量子态编码经典数据](./DataEncoding_CN.ipynb)。用户也可以尝试其他编码，如振幅编码，体验不同编码方式对分类器学习效率的影响。\n", + "2. 构建可调参数量子电路，对应幺正变换(unitary gate)$U(\\theta)$。\n", + "3. 对每一个量子数据$\\lvert\\psi_{\\rm in}\\rangle^k$，通过参数化量子电路$U(\\theta)$，得到输出态$\\lvert \\psi_{\\rm out}\\rangle^k = U(\\theta)\\lvert \\psi_{\\rm in} \\rangle^k$。\n", + "4. 对每一个量子数据得到的输出量子态$\\lvert \\psi_{\\rm out}\\rangle^k$，通过测量与数据后处理，得到标签 $\\tilde{y}^{k}$。\n", + "5. 重复以上步骤，得到数据集内所有点的标签，并计算损失函数 $\\mathcal{L}(\\theta)$。\n", + "6. 通过梯度下降等优化方法不断调整参数 $\\theta$ 的值，从而最小化损失函数。记录优化完成后的最优参数 $\\theta^*$, 这时我们就学习到了最优的分类器 $\\mathcal{F}_{\\theta^*}$。\n", + "\n", + " \n", + "
图 1：量子分类器训练的流程图
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Paddle Quantum 实现\n", + "\n", + "这里，我们先导入所需要的语言包：" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T09:15:03.419838Z", + "start_time": "2021-03-02T09:15:03.413324Z" + } + }, + "outputs": [], + "source": [ + "# 导入 numpy、paddle 和 paddle_quantum\n", + "import numpy as np\n", + "import paddle\n", + "import paddle_quantum\n", + "\n", + "# 构建量子电路\n", + "from paddle_quantum.ansatz import Circuit\n", + "\n", + "# 一些用到的函数\n", + "from numpy import pi as PI\n", + "from paddle import matmul, transpose, reshape # paddle 矩阵乘法与转置\n", + "from paddle_quantum.qinfo import pauli_str_to_matrix # 得到 N 量子比特泡利矩阵,\n", + "from paddle_quantum.linalg import dagger # 复共轭\n", + "\n", + "# 作图与计算时间\n", + "from matplotlib import pyplot as plt\n", + "import time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "分类器问题用到的参数" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# 数据集参数设置\n", + "Ntrain = 200 # 规定训练集大小\n", + "Ntest = 100 # 规定测试集大小\n", + "boundary_gap = 0.5 # 设置决策边界的宽度\n", + "seed_data = 2 # 固定随机种子\n", + "# 训练参数设置\n", + "N = 4 # 所需的量子比特数量\n", + "DEPTH = 1 # 采用的电路深度\n", + "BATCH = 20 # 训练时 batch 的大小\n", + "EPOCH = int(200 * BATCH / Ntrain)\n", + " # 训练 epoch 轮数，使得总迭代次数 EPOCH * (Ntrain / BATCH) 在200左右\n", + "LR = 0.01 # 设置学习速率\n", + "seed_paras = 19 # 设置随机种子用以初始化各种参数" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数据集的生成\n", + "\n", + "对于监督学习来说，我们绕不开的一个问题就是——采用什么样的数据集呢？在这个教程中我们按照论文 [1] 里所提及方法生成简单的圆形决策边界二分数据集 $\\{(x^{k}, y^{k})\\}$。其中数据点 $x^{k}\\in \\mathbb{R}^{2}$，标签 $y^{k} \\in \\{0,1\\}$。\n", + "\n", + " \n", + "
图 2：生成的数据集和对应的决策边界
\n", + "\n", + "具体的生成方式和可视化请见如下代码：" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "数据集生成函数 " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T09:15:04.631031Z", + "start_time": "2021-03-02T09:15:04.617301Z" + } + }, + "outputs": [], + "source": [ + "# 圆形决策边界两分类数据集生成器\n", + "def circle_data_point_generator(Ntrain, Ntest, boundary_gap, seed_data):\n", + " \"\"\"\n", + " :param Ntrain: 训练集大小\n", + " :param Ntest: 测试集大小\n", + " :param boundary_gap: 取值于 (0, 0.5), 两类别之间的差距\n", + " :param seed_data: 随机种子\n", + " :return: 四个列表：训练集x，训练集y，测试集x，测试集y\n", + " \"\"\"\n", + " # 生成共Ntrain + Ntest组数据，x对应二维数据点，y对应编号\n", + " # 取前Ntrain个为训练集，后Ntest个为测试集\n", + " train_x, train_y = [], []\n", + " num_samples, seed_para = 0, 0\n", + " while num_samples < Ntrain + Ntest:\n", + " np.random.seed((seed_data + 10) * 1000 + seed_para + num_samples)\n", + " data_point = np.random.rand(2) * 2 - 1 # 生成[-1, 1]范围内二维向量\n", + "\n", + " # 如果数据点的模小于(0.7 - gap)，标为0\n", + " if np.linalg.norm(data_point) < 0.7 - boundary_gap / 2:\n", + " train_x.append(data_point)\n", + " train_y.append(0.)\n", + " num_samples += 1\n", + "\n", + " # 如果数据点的模大于(0.7 + gap)，标为1\n", + " elif np.linalg.norm(data_point) > 0.7 + boundary_gap / 2:\n", + " train_x.append(data_point)\n", + " train_y.append(1.)\n", + " num_samples += 1\n", + " else:\n", + " seed_para += 1\n", + "\n", + " train_x = np.array(train_x).astype(\"float64\")\n", + " train_y = np.array([train_y]).astype(\"float64\").T\n", + "\n", + " print(\"训练集的维度大小 x {} 和 y {}\".format(np.shape(train_x[0:Ntrain]), np.shape(train_y[0:Ntrain])))\n", + " print(\"测试集的维度大小 x {} 和 y {}\".format(np.shape(train_x[Ntrain:]), np.shape(train_y[Ntrain:])), \"\\n\")\n", + "\n", + " return train_x[0:Ntrain], train_y[0:Ntrain], train_x[Ntrain:], train_y[Ntrain:]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "数据集可视化函数" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# 用以可视化生成的数据集\n", + "def data_point_plot(data, label):\n", + " \"\"\"\n", + " :param data: 形状为 [M, 2], 代表M个 2-D 数据点\n", + " :param label: 取值 0 或者 1\n", + " :return: 画这些数据点\n", + " \"\"\"\n", + " dim_samples, dim_useless = np.shape(data)\n", + " plt.figure(1)\n", + " for i in range(dim_samples):\n", + " if label[i] == 0:\n", + " plt.plot(data[i][0], data[i][1], color=\"r\", marker=\"o\")\n", + " elif label[i] == 1:\n", + " plt.plot(data[i][0], data[i][1], color=\"b\", marker=\"o\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "此教程采用大小分别为 200, 100 的训练集，测试集，决策边界宽度为 0.5 的数据，用以训练与测试量子神经网络训练效果：" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T09:15:06.422981Z", + "start_time": "2021-03-02T09:15:05.043595Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "训练集的维度大小 x (200, 2) 和 y (200, 1)\n", + "测试集的维度大小 x (100, 2) 和 y (100, 1) \n", + "\n", + "训练集 200 个数据点的可视化：\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "测试集 100 个数据点的可视化：\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " 读者不妨自己调节数据集的参数设置来生成属于自己的数据集吧！\n" + ] + } + ], + "source": [ + "# 生成自己的数据集\n", + "train_x, train_y, test_x, test_y = circle_data_point_generator(Ntrain, Ntest, boundary_gap, seed_data)\n", + "\n", + "# 打印数据集的维度信息\n", + "print(\"训练集 {} 个数据点的可视化：\".format(Ntrain))\n", + "data_point_plot(train_x, train_y)\n", + "print(\"测试集 {} 个数据点的可视化：\".format(Ntest))\n", + "data_point_plot(test_x, test_y)\n", + "print(\"\\n 读者不妨自己调节数据集的参数设置来生成属于自己的数据集吧！\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 数据的预处理\n", + "\n", + "与经典机器学习不同的是，量子分类器在实际工作的时候需要考虑数据的预处理。我们需要多加一个步骤将经典的数据转化成量子信息才能放在量子计算机上运行。此处我们采用角度编码方式得到量子数据。\n", + "\n", + "首先我们确定需要使用的量子比特数量。因为我们的数据 $\\{x^{k} = (x^{k}_0, x^{k}_1)\\}$ 是二维的, 按照 Mitarai (2018) 论文[1]中的编码方式我们至少需要2个量子比特。接着准备一系列的初始量子态 $|00\\rangle$。然后将经典信息 $\\{x^{k}\\}$ 编码成一系列量子门 $U(x^{k})$ 并作用在初始量子态上。最终得到一系列的量子态 $|\\psi_{\\rm in}\\rangle^k = U(x^{k})|00\\rangle$。这样我们就完成从经典信息到量子信息的编码了！\n", + "\n", + "给定 $m$ 个量子比特去编码二维的经典数据点，采用角度编码，量子门的构造为：\n", + "\n", + "$$\n", + "U(x^{k}) = \\otimes_{j=0}^{m-1} R_j^z\\big[\\arccos(x^{k}_{j \\, \\text{mod} \\, 2}\\cdot x^{k}_{j \\, \\text{mod} \\, 2})\\big] R_j^y\\big[\\arcsin(x^{k}_{j \\, \\text{mod} \\, 2}) \\big],\\tag{2}\n", + "$$\n", + "\n", + "**注意** ：这种表示下，我们将第一个量子比特编号为 $j = 0$。更多编码方式见 [Robust data encodings for quantum classifiers](https://arxiv.org/pdf/2003.01695.pdf)。读者也可以直接使用量桨中提供的[编码方式](./DataEncoding_CN.ipynb)。这里我们也欢迎读者自己创新尝试全新的编码方式。\n", + "\n", + "由于这种编码的方式看着比较复杂，我们不妨来举一个简单的例子。假设我们给定一个数据点 $x = (x_0, x_1)= (1,0)$, 显然这个数据点的标签应该为 1，对应上图**蓝色**的点。同时数据点对应的2比特量子门 $U(x)$ 是\n", + "\n", + "$$\n", + "U(x) = \n", + "\\bigg( R_0^z\\big[\\arccos(x_{0}\\cdot x_{0})\\big] R_0^y\\big[\\arcsin(x_{0}) \\big] \\bigg)\n", + "\\otimes \n", + "\\bigg( R_1^z\\big[\\arccos(x_{1}\\cdot x_{1})\\big] R_1^y\\big[\\arcsin(x_{1}) \\big] \\bigg),\\tag{3}\n", + "$$\n", + "\n", + "\n", + "把具体的数值带入我们就能得到：\n", + "$$\n", + "U(x) = \n", + "\\bigg( R_0^z\\big[0\\big] R_0^y\\big[\\pi/2 \\big] \\bigg)\n", + "\\otimes \n", + "\\bigg( R_1^z\\big[\\pi/2\\big] R_1^y\\big[0 \\big] \\bigg),\n", + "\\tag{4}\n", + "$$\n", + "\n", + "以下是常用的旋转门的矩阵形式：\n", + "\n", + "\n", + "$$\n", + "R_x(\\theta) :=\n", + "\\begin{bmatrix}\n", + "\\cos \\frac{\\theta}{2} &-i\\sin \\frac{\\theta}{2} \\\\\n", + "-i\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2}\n", + "\\end{bmatrix}\n", + ",\\quad\n", + "R_y(\\theta) :=\n", + "\\begin{bmatrix}\n", + "\\cos \\frac{\\theta}{2} &-\\sin \\frac{\\theta}{2} \\\\\n", + "\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2}\n", + "\\end{bmatrix}\n", + ",\\quad\n", + "R_z(\\theta) :=\n", + "\\begin{bmatrix}\n", + "e^{-i\\frac{\\theta}{2}} & 0 \\\\\n", + "0 & e^{i\\frac{\\theta}{2}}\n", + "\\end{bmatrix}.\n", + "\\tag{5}\n", + "$$\n", + "\n", + "那么这个两比特量子门 $U(x)$ 的矩阵形式可以写为：\n", + "\n", + "$$\n", + "U(x) = \n", + "\\bigg(\n", + "\\begin{bmatrix}\n", + "1 & 0 \\\\ \n", + "0 & 1\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + "\\cos \\frac{\\pi}{4} &-\\sin \\frac{\\pi}{4} \\\\ \n", + "\\sin \\frac{\\pi}{4} &\\cos \\frac{\\pi}{4} \n", + "\\end{bmatrix}\n", + "\\bigg)\n", + "\\otimes \n", + "\\bigg(\n", + "\\begin{bmatrix}\n", + "e^{-i\\frac{\\pi}{4}} & 0 \\\\ \n", + "0 & e^{i\\frac{\\pi}{4}}\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + "1 &0 \\\\ \n", + "0 &1\n", + "\\end{bmatrix}\n", + "\\bigg)\\, .\\tag{6}\n", + "$$\n", + "\n", + "化简后我们作用在零初始化的 $|00\\rangle$ 量子态上可以得到编码后的量子态 $|\\psi_{\\rm in}\\rangle$，\n", + "\n", + "$$\n", + "|\\psi_{\\rm in}\\rangle =\n", + "U(x)|00\\rangle = \\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "1-i &0 &-1+i &0 \\\\ \n", + "0 &1+i &0 &-1-i \\\\\n", + "1-i &0 &1-i &0 \\\\\n", + "0 &1+i &0 &1+i \n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + "1 \\\\\n", + "0 \\\\\n", + "0 \\\\\n", + "0\n", + "\\end{bmatrix}\n", + "= \\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "1-i \\\\\n", + "0 \\\\\n", + "1-i \\\\\n", + "0\n", + "\\end{bmatrix}.\\tag{7}\n", + "$$\n", + "\n", + "接着我们来看看代码上怎么实现这种编码方式。需要注意的是：代码中使用了一个张量积来表述\n", + "\n", + "$$\n", + "(U_1 |0\\rangle)\\otimes (U_2 |0\\rangle) = (U_1 \\otimes U_2) |0\\rangle\\otimes|0\\rangle\n", + "= (U_1 \\otimes U_2) |00\\rangle.\\tag{8}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T09:15:06.589265Z", + "start_time": "2021-03-02T09:15:06.452691Z" + } + }, + "outputs": [], + "source": [ + "# 构建绕 Y 轴，绕 Z 轴旋转 theta 角度矩阵\n", + "def Ry(theta):\n", + " \"\"\"\n", + " :param theta: 参数\n", + " :return: Y 旋转矩阵\n", + " \"\"\"\n", + " return np.array([[np.cos(theta / 2), -np.sin(theta / 2)],\n", + " [np.sin(theta / 2), np.cos(theta / 2)]])\n", + "\n", + "def Rz(theta):\n", + " \"\"\"\n", + " :param theta: 参数\n", + " :return: Z 旋转矩阵\n", + " \"\"\"\n", + " return np.array([[np.cos(theta / 2) - np.sin(theta / 2) * 1j, 0],\n", + " [0, np.cos(theta / 2) + np.sin(theta / 2) * 1j]])\n", + "\n", + "# 经典 -> 量子数据编码器\n", + "def datapoints_transform_to_state(data, n_qubits):\n", + " \"\"\"\n", + " :param data: 形状为 [-1, 2]，numpy向量形式\n", + " :param n_qubits: 数据转化后的量子比特数量\n", + " :return: 形状为 [-1, 1, 2 ^ n_qubits]\n", + " 形状中-1表示第一个参数为任意大小。在此教程实例分析中，对应于BATCH，用以得到Eq.(1)中平方误差的平均值\n", + " \"\"\"\n", + " dim1, dim2 = data.shape\n", + " res = []\n", + " for sam in range(dim1):\n", + " res_state = 1.\n", + " zero_state = np.array([[1, 0]])\n", + " # 角度编码\n", + " for i in range(n_qubits):\n", + " # 对偶数编号量子态作用 Rz(arccos(x0^2)) Ry(arcsin(x0))\n", + " if i % 2 == 0:\n", + " state_tmp=np.dot(zero_state, Ry(np.arcsin(data[sam][0])).T)\n", + " state_tmp=np.dot(state_tmp, Rz(np.arccos(data[sam][0] ** 2)).T)\n", + " res_state=np.kron(res_state, state_tmp)\n", + " # 对奇数编号量子态作用 Rz(arccos(x1^2)) Ry(arcsin(x1))\n", + " elif i % 2 == 1:\n", + " state_tmp=np.dot(zero_state, Ry(np.arcsin(data[sam][1])).T)\n", + " state_tmp=np.dot(state_tmp, Rz(np.arccos(data[sam][1] ** 2)).T)\n", + " res_state=np.kron(res_state, state_tmp)\n", + " res.append(res_state)\n", + " res = np.array(res, dtype=paddle_quantum.get_dtype())\n", + "\n", + " return res" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "测试角度编码下得到的量子数据" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "作为测试我们输入以上的经典信息:\n", + "(x_0, x_1) = (1, 0)\n", + "编码后输出的2比特量子态为:\n", + "[[[0.5-0.5j 0. +0.j 0.5-0.5j 0. +0.j ]]]\n" + ] + } + ], + "source": [ + "print(\"作为测试我们输入以上的经典信息:\")\n", + "print(\"(x_0, x_1) = (1, 0)\")\n", + "print(\"编码后输出的2比特量子态为:\")\n", + "print(datapoints_transform_to_state(np.array([[1, 0]]), n_qubits=2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 构造量子神经网络\n", + "\n", + "那么在完成上述从经典数据到量子数据的编码后，我们现在可以把这些量子态输入到量子计算机里面了。在那之前，我们还需要设计下我们所采用的量子神经网络结构。\n", + "\n", + " \n", + "
图 3：参数化量子神经网络的电路结构
\n", + "\n", + "为了方便，我们统一将上述参数化的量子神经网络称为 $U(\\boldsymbol{\\theta})$。这个 $U(\\boldsymbol{\\theta})$ 是我们分类器的关键组成部分，需要一定的复杂结构来拟合我们的决策边界。与经典神经网络类似，量子神经网络的的设计并不是唯一的，这里展示的仅仅是一个例子，读者不妨自己设计出自己的量子神经网络。我们还是拿原来提过的这个数据点 $x = (x_0, x_1)= (1,0)$ 来举例子，编码过后我们已经得到了一个量子态 $|\\psi_{\\rm in}\\rangle$，\n", + "\n", + "$$\n", + "|\\psi_{\\rm in}\\rangle =\n", + "\\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "1-i \\\\\n", + "0 \\\\\n", + "1-i \\\\\n", + "0\n", + "\\end{bmatrix},\\tag{9}\n", + "$$\n", + "\n", + "接着我们把这个量子态输入进我们的量子神经网络，也就是把一个酉矩阵乘以一个向量。得到处理过后的量子态 $|\\psi_{\\rm out}\\rangle$\n", + "\n", + "$$\n", + "|\\psi_{\\rm out}\\rangle = U(\\boldsymbol{\\theta})|\\psi_{\\rm in}\\rangle,\\tag{10}\n", + "$$\n", + "\n", + "如果我们把所有的参数 $\\theta$ 都设置为 $\\theta = \\pi$, 那么我们就可以写出具体的矩阵了：\n", + "\n", + "$$\n", + "|\\psi_{\\rm out}\\rangle = \n", + "U(\\boldsymbol{\\theta} =\\pi)|\\psi_{\\rm in}\\rangle =\n", + "\\begin{bmatrix}\n", + "0 &0 &-1 &0 \\\\ \n", + "-1 &0 &0 &0 \\\\\n", + "0 &1 &0 &0 \\\\\n", + "0 &0 &0 &1 \n", + "\\end{bmatrix}\n", + "\\cdot\n", + "\\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "1-i \\\\\n", + "0 \\\\\n", + "1-i \\\\\n", + "0\n", + "\\end{bmatrix}\n", + "= \\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "-1+i \\\\\n", + "-1+i \\\\\n", + "0 \\\\\n", + "0\n", + "\\end{bmatrix}.\\tag{11}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 测量\n", + "\n", + "经过量子神经网络$U(\\theta)$后，得到是量子态$\\lvert \\psi_{\\rm out}\\rangle^k = U(\\theta)\\lvert \\psi_{\\rm in} \\rangle^k$。要想得到该量子态的标签，我们需要通过测量来得到经典信息。然后再通过这些处理后的经典信息计算损失函数 $\\mathcal{L}(\\boldsymbol{\\theta})$。最后再通过梯度下降算法来不断更新 QNN 参数 $\\boldsymbol{\\theta}$，并优化损失函数。\n", + "\n", + "\n", + "这里我们采用的测量方式是测量泡利 $Z$ 算符在第一个量子比特上的期望值。 具体来说，\n", + "\n", + "$$\n", + "\\langle Z \\rangle = \n", + "\\langle \\psi_{\\rm out} |Z\\otimes I\\cdots \\otimes I| \\psi_{\\rm out}\\rangle,\\tag{12}\n", + "$$\n", + "\n", + "复习一下，泡利 $Z$ 算符的矩阵形式为：\n", + "\n", + "$$\n", + "Z := \\begin{bmatrix} 1 &0 \\\\ 0 &-1 \\end{bmatrix},\\tag{13}\n", + "$$\n", + "\n", + "继续我们前面的 2 量子比特的例子，测量过后我们得到的期望值就是：\n", + "$$\n", + "\\langle Z \\rangle = \n", + "\\langle \\psi_{\\rm out} |Z\\otimes I| \\psi_{\\rm out}\\rangle = \n", + "\\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "-1-i \\quad\n", + "-1-i \\quad\n", + "0 \\quad\n", + "0\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + "1 &0 &0 &0 \\\\ \n", + "0 &1 &0 &0 \\\\\n", + "0 &0 &-1 &0 \\\\\n", + "0 &0 &0 &-1 \n", + "\\end{bmatrix}\n", + "\\cdot\n", + "\\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "-1+i \\\\\n", + "-1+i \\\\\n", + "0 \\\\\n", + "0\n", + "\\end{bmatrix}\n", + "= 1,\\tag{14}\n", + "$$\n", + "\n", + "好奇的读者或许会问，这个测量结果好像就是我们原来的标签 1 ，这是不是意味着我们已经成功的分类这个数据点了？其实并不然，因为 $\\langle Z \\rangle$ 的取值范围通常在 $[-1,1]$之间。 为了对应我们的标签范围 $y^{k} \\in \\{0,1\\}$, 我们还需要将区间上下限映射上。这个映射最简单的做法就是让\n", + "\n", + "$$\n", + "\\tilde{y}^{k} = \\frac{\\langle Z \\rangle}{2} + \\frac{1}{2} + bias \\quad \\in [0, 1].\\tag{15}\n", + "$$\n", + "\n", + "其中加入偏置（bias）是机器学习中的一个小技巧，目的就是为了让决策边界不受制于原点或者一些超平面。一般我们默认偏置初始化为0，并且优化器在迭代过程中会类似于参数 $\\theta$ 一样不断更新偏置确保 $\\tilde{y}^{k} \\in [0, 1]$。当然读者也可以选择其他复杂的映射（激活函数）比如说 sigmoid 函数。映射过后我们就可以把 $\\tilde{y}^{k}$ 看作是我们估计出的标签（label）了。如果 $\\tilde{y}^{k}< 0.5$ 就对应标签 0，如果 $\\tilde{y}^{k}> 0.5$ 就对应标签 1。 我们稍微复习一下整个流程，\n", + "\n", + "\n", + "$$\n", + "x^{k} \\rightarrow |\\psi_{\\rm in}\\rangle^{k} \\rightarrow U(\\boldsymbol{\\theta})|\\psi_{\\rm in}\\rangle^{k} \\rightarrow\n", + "|\\psi_{\\rm out}\\rangle^{k} \\rightarrow ^{k}\\langle \\psi_{\\rm out} |Z\\otimes I\\cdots \\otimes I| \\psi_{\\rm out} \\rangle^{k}\n", + "\\rightarrow \\langle Z \\rangle \\rightarrow \\tilde{y}^{k}.\\tag{16}\n", + "$$\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 损失函数\n", + "\n", + "相比于公式(1)中损失函数，需要在每次迭代中对所有 Ntrain 个数据点进行测量计算，在实际应用中，我们将训练集中的数据拆分为 \"Ntrain/BATCH\" 组，其中每组包含BATCH个数据。\n", + "\n", + "对第 i 组数据，训练对应损失函数：\n", + "$$\n", + "\\mathcal{L}_{i} = \\sum_{k=1}^{BATCH} \\frac{1}{BATCH} |y^{i,k} - \\tilde{y}^{i,k}|^2,\\tag{17}\n", + "$$\n", + "并对每一组训练 EPOCH 次。\n", + "\n", + "当取 \"BATCH = Ntrain\"，此时仅有一组数据点，Eq. (17)重新变为Eq. (1)。\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T09:15:07.667491Z", + "start_time": "2021-03-02T09:15:07.661325Z" + } + }, + "outputs": [], + "source": [ + "# 生成只作用在第一个量子比特上的泡利 Z 算符\n", + "# 其余量子比特上都作用单位矩阵\n", + "def Observable(n):\n", + " r\"\"\"\n", + " :param n: 量子比特数量\n", + " :return: 局部可观测量: Z \\otimes I \\otimes ...\\otimes I\n", + " \"\"\"\n", + " Ob = pauli_str_to_matrix([[1.0, 'z0']], n)\n", + "\n", + " return Ob" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# 搭建整个优化流程图\n", + "class Opt_Classifier(paddle_quantum.gate.Gate):\n", + " \"\"\"\n", + " 创建模型训练网络\n", + " \"\"\"\n", + " def __init__(self, n, depth, seed_paras=1):\n", + " # 初始化部分，通过n, depth给出初始电路\n", + " super(Opt_Classifier, self).__init__()\n", + " self.n = n\n", + " self.depth = depth\n", + " # 初始化偏置 (bias)\n", + " self.bias = self.create_parameter(\n", + " shape=[1],\n", + " default_initializer=paddle.nn.initializer.Normal(std=0.01),\n", + " dtype='float32',\n", + " is_bias=False)\n", + " \n", + " self.circuit = Circuit(n)\n", + " # 先搭建广义的旋转层\n", + " for i in range(n):\n", + " self.circuit.rz(qubits_idx=i)\n", + " self.circuit.ry(qubits_idx=i)\n", + " self.circuit.rz(qubits_idx=i)\n", + "\n", + " # 默认深度为 depth = 1\n", + " # 对每一层搭建电路\n", + " for d in range(3, depth + 3):\n", + " # 搭建纠缠层\n", + " for i in range(n-1):\n", + " self.circuit.cnot(qubits_idx=[i, i + 1])\n", + " self.circuit.cnot(qubits_idx=[n-1, 0])\n", + " # 对每一个量子比特搭建Ry\n", + " for i in range(n):\n", + " self.circuit.ry(qubits_idx=i)\n", + "\n", + " # 定义前向传播机制、计算损失函数 和交叉验证正确率\n", + " def forward(self, state_in, label):\n", + " \"\"\"\n", + " 输入： state_in：输入量子态，shape: [-1, 1, 2^n] -- 此教程中为[BATCH, 1, 2^n]\n", + " label：输入量子态对应标签，shape: [-1, 1]\n", + " 计算损失函数:\n", + " L = 1/BATCH * (( + 1)/2 + bias - label)^2\n", + " \"\"\"\n", + " # 将 Numpy array 转换成 tensor\n", + " Ob = paddle.to_tensor(Observable(self.n))\n", + " label_pp = reshape(paddle.to_tensor(label), [-1, 1])\n", + "\n", + " # 按照随机初始化的参数 theta \n", + " Utheta = self.circuit.unitary_matrix()\n", + "\n", + " # 因为 Utheta是学习到的，我们这里用行向量运算来提速而不会影响训练效果\n", + " state_out = matmul(state_in, Utheta) # [-1, 1, 2 ** n]形式，第一个参数在此教程中为BATCH\n", + "\n", + " # 测量得到泡利 Z 算符的期望值 -- shape [-1,1,1]\n", + " E_Z = matmul(matmul(state_out, Ob), transpose(paddle.conj(state_out), perm=[0, 2, 1]))\n", + "\n", + " # 映射 处理成标签的估计值 \n", + " state_predict = paddle.real(E_Z)[:, 0] * 0.5 + 0.5 + self.bias # 计算每一个y^{i,k}与真实值得平方差\n", + " loss = paddle.mean((state_predict - label_pp) ** 2) # 对BATCH个得到的平方差取平均，得到L_i：shape:[1,1]\n", + "\n", + " # 计算交叉验证正确率\n", + " is_correct = (paddle.abs(state_predict - label_pp) < 0.5).nonzero().shape[0]\n", + " acc = is_correct / label.shape[0]\n", + "\n", + " return loss, acc, state_predict.numpy(), self.circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 训练过程\n", + "\n", + "好了， 那么定义完以上所有的概念之后我们不妨来看看实际的训练过程！" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# 用于绘制最终训练得到分类器的平面分类图\n", + "def heatmap_plot(Opt_Classifier, N):\n", + " # 生成数据点 x_y_\n", + " Num_points = 30\n", + " x_y_ = []\n", + " for row_y in np.linspace(0.9, -0.9, Num_points):\n", + " row = []\n", + " for row_x in np.linspace(-0.9, 0.9, Num_points):\n", + " row.append([row_x, row_y])\n", + " x_y_.append(row)\n", + " x_y_ = np.array(x_y_).reshape(-1, 2).astype(\"float64\")\n", + "\n", + " # 计算预测: heat_data\n", + " input_state_test = paddle.to_tensor(\n", + " datapoints_transform_to_state(x_y_, N))\n", + " loss_useless, acc_useless, state_predict, cir = Opt_Classifier(state_in=input_state_test, label=x_y_[:, 0])\n", + " heat_data = state_predict.reshape(Num_points, Num_points)\n", + "\n", + " # 画图\n", + " fig = plt.figure(1)\n", + " ax = fig.add_subplot(111)\n", + " x_label = np.linspace(-0.9, 0.9, 3)\n", + " y_label = np.linspace(0.9, -0.9, 3)\n", + " ax.set_xticks([0, Num_points // 2, Num_points - 1])\n", + " ax.set_xticklabels(x_label)\n", + " ax.set_yticks([0, Num_points // 2, Num_points - 1])\n", + " ax.set_yticklabels(y_label)\n", + " im = ax.imshow(heat_data, cmap=plt.cm.RdBu)\n", + " plt.colorbar(im)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "通过 Adam 优化器不断学习训练" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def QClassifier(Ntrain, Ntest, gap, N, DEPTH, EPOCH, LR, BATCH, seed_paras, seed_data):\n", + " \"\"\"\n", + " 量子二分类器\n", + " 输入参数：\n", + " Ntrain, # 规定训练集大小\n", + " Ntest, # 规定测试集大小\n", + " gap, # 设定决策边界的宽度\n", + " N, # 所需的量子比特数量\n", + " DEPTH, # 采用的电路深度\n", + " BATCH, # 训练时 batch 的大小\n", + " EPOCH, # 训练 epoch 轮数\n", + " LR, # 设置学习速率\n", + " seed_paras, # 设置随机种子用以初始化各种参数\n", + " seed_data, # 固定生成数据集所需要的随机种子\n", + " \"\"\"\n", + " # 生成训练集测试集\n", + " train_x, train_y, test_x, test_y = circle_data_point_generator(Ntrain=Ntrain, Ntest=Ntest, boundary_gap=gap, seed_data=seed_data)\n", + " # 读取训练集的维度\n", + " N_train = train_x.shape[0]\n", + "\n", + " paddle.seed(seed_paras)\n", + " # 初始化寄存器存储正确率 acc 等信息\n", + " summary_iter, summary_test_acc = [], []\n", + "\n", + " # 一般来说，我们利用Adam优化器来获得相对好的收敛\n", + " # 当然你可以改成SGD或者是RMSprop\n", + " myLayer = Opt_Classifier(n=N, depth=DEPTH) # 得到初始化量子电路\n", + " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=myLayer.parameters())\n", + "\n", + " # 优化循环\n", + " # 此处将训练集分为Ntrain/BATCH组数据，对每一组训练后得到的量子线路作为下一组数据训练的初始量子电路\n", + " # 故通过cir记录每组数据得到的最终量子线路\n", + " i = 0 # 记录总迭代次数\n", + " for ep in range(EPOCH):\n", + " # 将训练集分组，对每一组训练\n", + " for itr in range(N_train // BATCH):\n", + " i += 1 # 记录总迭代次数\n", + " # 将经典数据编码成量子态 |psi>, 维度 [BATCH, 2 ** N]\n", + " input_state = paddle.to_tensor(datapoints_transform_to_state(train_x[itr * BATCH:(itr + 1) * BATCH], N))\n", + "\n", + " # 前向传播计算损失函数\n", + " loss, train_acc, state_predict_useless, cir \\\n", + " = myLayer(state_in=input_state, label=train_y[itr * BATCH:(itr + 1) * BATCH]) # 对此时量子电路优化\n", + " # 显示迭代过程中performance变化\n", + " if i % 30 == 5:\n", + " # 计算测试集上的正确率 test_acc\n", + " input_state_test = paddle.to_tensor(datapoints_transform_to_state(test_x, N))\n", + " loss_useless, test_acc, state_predict_useless, t_cir \\\n", + " = myLayer(state_in=input_state_test,label=test_y)\n", + " print(\"epoch:\", ep, \"iter:\", itr,\n", + " \"loss: %.4f\" % loss.numpy(),\n", + " \"train acc: %.4f\" % train_acc,\n", + " \"test acc: %.4f\" % test_acc)\n", + " # 存储正确率 acc 等信息\n", + " summary_iter.append(itr + ep * N_train)\n", + " summary_test_acc.append(test_acc) \n", + "\n", + " # 反向传播极小化损失函数\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + "\n", + " # 得到训练后电路\n", + " print(\"训练后的电路：\")\n", + " print(cir)\n", + " # 画出 heatmap 表示的决策边界\n", + " heatmap_plot(myLayer, N=N)\n", + "\n", + " return summary_test_acc" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "训练集的维度大小 x (200, 2) 和 y (200, 1)\n", + "测试集的维度大小 x (100, 2) 和 y (100, 1) \n", + "\n", + "epoch: 0 iter: 4 loss: 0.2750 train acc: 0.7000 test acc: 0.6700\n", + "epoch: 3 iter: 4 loss: 0.2471 train acc: 0.2500 test acc: 0.5500\n", + "epoch: 6 iter: 4 loss: 0.1976 train acc: 0.8000 test acc: 0.9200\n", + "epoch: 9 iter: 4 loss: 0.1639 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 12 iter: 4 loss: 0.1441 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 15 iter: 4 loss: 0.1337 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 18 iter: 4 loss: 0.1287 train acc: 1.0000 test acc: 1.0000\n", + "训练后的电路：\n", + "--Rz(3.490)----Ry(5.436)----Rz(3.281)----*--------------x----Ry(0.098)--\n", + " | | \n", + "--Rz(1.499)----Ry(2.579)----Rz(3.496)----x----*---------|----Ry(1.282)--\n", + " | | \n", + "--Rz(5.956)----Ry(3.158)----Rz(3.949)---------x----*----|----Ry(1.418)--\n", + " | | \n", + "--Rz(1.604)----Ry(0.722)----Rz(5.037)--------------x----*----Ry(2.437)--\n", + " \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "主程序段总共运行了 7.0908989906311035 秒\n" + ] + } + ], + "source": [ + "def main():\n", + " \"\"\"\n", + " 主函数\n", + " \"\"\"\n", + " time_start = time.time()\n", + " acc = QClassifier(\n", + " Ntrain = 200, # 规定训练集大小\n", + " Ntest = 100, # 规定测试集大小\n", + " gap = 0.5, # 设定决策边界的宽度\n", + " N = 4, # 所需的量子比特数量\n", + " DEPTH = 1, # 采用的电路深度\n", + " BATCH = 20, # 训练时 batch 的大小\n", + " EPOCH = int(200 * BATCH / Ntrain), \n", + " # 训练 epoch 轮数，使得总迭代次数 EPOCH * (Ntrain / BATCH) 在200左右\n", + " LR = 0.01, # 设置学习速率\n", + " seed_paras = 19, # 设置随机种子用以初始化各种参数\n", + " seed_data = 2, # 固定生成数据集所需要的随机种子\n", + " )\n", + " \n", + " time_span = time.time() - time_start\n", + " print('主程序段总共运行了', time_span, '秒')\n", + "\n", + "if __name__ == '__main__':\n", + " main()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "通过打印训练结果可以看到不断优化后分类器在测试集和训练集的正确率都达到了 $100\\%$。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 研究不同的编码方式\n", + "\n", + "监督学习的编码方式对分类结果有很大影响 [4]。在量桨中，我们集成了常用的编码方式，包括振幅编码、角度编码、IQP编码等。 用户可以用内置的 ``SimpleDataset`` 类实例对简单分类数据（不需要降维的数据）进行编码；也可以用内置的 ``VisionDataset`` 类实例对图片数据进行编码。编码的方法都是调用类对象的 ``encode`` 方法。" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(100, 4)\n" + ] + } + ], + "source": [ + "# 使用前面构建的圆形数据集研究编码\n", + "from paddle_quantum.dataset import *\n", + "\n", + "# 用两个量子比特编码二维数据\n", + "quantum_train_x = SimpleDataset(2).encode(train_x, 'angle_encoding', 2)\n", + "quantum_test_x = SimpleDataset(2).encode(test_x, 'angle_encoding', 2)\n", + "\n", + "print(type(quantum_test_x)) # ndarray\n", + "print(quantum_test_x.shape) # (100, 4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "这里我们对上面的分类器进行化简，之后的所有分类都采用这个分类器。" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# 简化的分类器\n", + "def QClassifier2(quantum_train_x, train_y,quantum_test_x,test_y, N, DEPTH, EPOCH, LR, BATCH):\n", + " \"\"\"\n", + " 量子二分类分类器\n", + " 输入：\n", + " quantum_train_x # 训练特征\n", + " train_y # 训练标签\n", + " quantum_test_x # 测试特征\n", + " test_y # 测试标签\n", + " N # 使用的量子比特数目\n", + " DEPTH # 分类器电路的深度\n", + " EPOCH # 迭代次数\n", + " LR # 学习率\n", + " BATCH # 一个批量的大小\n", + " \"\"\"\n", + " Ntrain = len(quantum_train_x)\n", + " \n", + " paddle.seed(1)\n", + "\n", + " net = Opt_Classifier(n=N, depth=DEPTH)\n", + "\n", + " # 测试准确率列表\n", + " summary_iter, summary_test_acc = [], []\n", + "\n", + " # 这里用 Adam，但是也可以是 SGD 或者 RMSprop\n", + " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + " # 进行优化\n", + " for ep in range(EPOCH):\n", + " for itr in range(Ntrain // BATCH):\n", + " # 导入数据\n", + " input_state = quantum_train_x[itr * BATCH:(itr + 1) * BATCH] # paddle.tensor类型\n", + " input_state = reshape(input_state, [-1, 1, 2 ** N])\n", + " label = train_y[itr * BATCH:(itr + 1) * BATCH]\n", + " test_input_state = reshape(quantum_test_x, [-1, 1, 2 ** N])\n", + "\n", + " loss, train_acc, state_predict_useless, cir = net(state_in=input_state, label=label)\n", + "\n", + " if itr % 5 == 0:\n", + " # 获取测试准确率\n", + " loss_useless, test_acc, state_predict_useless, t_cir = net(state_in=test_input_state, label=test_y)\n", + " print(\"epoch:\", ep, \"iter:\", itr,\n", + " \"loss: %.4f\" % loss.numpy(),\n", + " \"train acc: %.4f\" % train_acc,\n", + " \"test acc: %.4f\" % test_acc)\n", + " summary_test_acc.append(test_acc)\n", + "\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + "\n", + " return summary_test_acc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "现在可以开始用不同编码方式对上面产生的圆形数据进行编码。这里我们采用五种编码方法：振幅编码、角度编码、泡利旋转编码、IQP编码、复杂纠缠编码。然后我们绘制出测试精度曲线以便分析。" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Encoding method: amplitude_encoding\n", + "epoch: 0 iter: 0 loss: 0.3005 train acc: 0.6000 test acc: 0.4600\n", + "epoch: 0 iter: 5 loss: 0.2908 train acc: 0.3000 test acc: 0.5000\n", + "epoch: 0 iter: 10 loss: 0.2313 train acc: 0.8000 test acc: 0.6200\n", + "epoch: 0 iter: 15 loss: 0.2181 train acc: 0.7000 test acc: 0.7000\n", + "Encoding method: angle_encoding\n", + "epoch: 0 iter: 0 loss: 0.4141 train acc: 0.4000 test acc: 0.3700\n", + "epoch: 0 iter: 5 loss: 0.2942 train acc: 0.6000 test acc: 0.6700\n", + "epoch: 0 iter: 10 loss: 0.1952 train acc: 0.6000 test acc: 0.6700\n", + "epoch: 0 iter: 15 loss: 0.2389 train acc: 0.6000 test acc: 0.6000\n", + "Encoding method: pauli_rotation_encoding\n", + "epoch: 0 iter: 0 loss: 0.1985 train acc: 0.7000 test acc: 0.7400\n", + "epoch: 0 iter: 5 loss: 0.2303 train acc: 0.6000 test acc: 0.6900\n", + "epoch: 0 iter: 10 loss: 0.1970 train acc: 0.6000 test acc: 0.7200\n", + "epoch: 0 iter: 15 loss: 0.2120 train acc: 0.7000 test acc: 0.7000\n", + "Encoding method: IQP_encoding\n", + "epoch: 0 iter: 0 loss: 0.2962 train acc: 0.5000 test acc: 0.4500\n", + "epoch: 0 iter: 5 loss: 0.2074 train acc: 0.7000 test acc: 0.7000\n", + "epoch: 0 iter: 10 loss: 0.2463 train acc: 0.6000 test acc: 0.6500\n", + "epoch: 0 iter: 15 loss: 0.2090 train acc: 0.9000 test acc: 0.5800\n", + "Encoding method: complex_entangled_encoding\n", + "epoch: 0 iter: 0 loss: 0.2500 train acc: 0.6000 test acc: 0.6800\n", + "epoch: 0 iter: 5 loss: 0.2571 train acc: 0.5000 test acc: 0.6800\n", + "epoch: 0 iter: 10 loss: 0.2661 train acc: 0.7000 test acc: 0.6700\n", + "epoch: 0 iter: 15 loss: 0.1916 train acc: 0.8000 test acc: 0.7200\n" + ] + } + ], + "source": [ + "# 测试不同编码方式\n", + "encoding_list = ['amplitude_encoding', 'angle_encoding', 'pauli_rotation_encoding', 'IQP_encoding', 'complex_entangled_encoding']\n", + "num_qubit = 2 # 这里需要小心，如果量子比特数目取 1，可能会报错，因为有 CNOT 门\n", + "dimension = 2\n", + "acc_list = []\n", + "\n", + "for i in range(len(encoding_list)):\n", + " encoding = encoding_list[i]\n", + " print(\"Encoding method:\", encoding)\n", + " # 用 SimpleDataset 类来编码数据，这里数据维度为 2，编码量子比特数目也是 2\n", + " quantum_train_x= SimpleDataset(dimension).encode(train_x, encoding, num_qubit)\n", + " quantum_test_x= SimpleDataset(dimension).encode(test_x, encoding, num_qubit)\n", + " quantum_train_x = paddle.to_tensor(quantum_train_x)\n", + " quantum_test_x = paddle.to_tensor(quantum_test_x)\n", + "\n", + " acc = QClassifier2(\n", + " quantum_train_x, # 训练特征\n", + " train_y, # 训练标签\n", + " quantum_test_x, # 测试特征\n", + " test_y, # 测试标签\n", + " N = num_qubit, # 使用的量子比特数目\n", + " DEPTH = 1, # 分类器电路的深度\n", + " EPOCH = 1, # 迭代次数\n", + " LR = 0.1, # 学习率\n", + " BATCH = 10, # 一个批量的大小\n", + " )\n", + " acc_list.append(acc)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 绘制五种编码方法的训练曲线\n", + "x=[2*i for i in range(len(acc_list[0]))]\n", + "for i in range(len(encoding_list)):\n", + " plt.plot(x,acc_list[i])\n", + "plt.legend(encoding_list)\n", + "plt.title(\"Benchmarking different encoding methods\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Test accuracy\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 用内置的 MNIST 和 Iris 数据集实现量子分类\n", + "\n", + "量桨将常用的分类数据集进行了编码，用户可以使用 `paddle_quantum.dataset` 模块获取编码的量子电路或者量子态。目前集成了4个数据集，包括 MNIST, FashionMNIST, Iris 和 BreastCancer。下面展示如何用这些内置数据集快速实现量子监督学习。\n", + "\n", + "我们从 Iris 数据集开始。Iris 数据集包括三种类别，每种类别有50个样本。数据集中只有四个特征，是比较简单且容易编码的数据集。" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch: 0 iter: 0 loss: 0.3372 train acc: 0.5000 test acc: 0.5000\n", + "epoch: 0 iter: 5 loss: 0.2687 train acc: 0.2500 test acc: 0.5500\n", + "epoch: 0 iter: 10 loss: 0.0781 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 0 iter: 15 loss: 0.0786 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 1 iter: 0 loss: 0.0903 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 1 iter: 5 loss: 0.1020 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 1 iter: 10 loss: 0.0553 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 1 iter: 15 loss: 0.0559 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 2 iter: 0 loss: 0.0770 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 2 iter: 5 loss: 0.0879 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 2 iter: 10 loss: 0.0438 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 2 iter: 15 loss: 0.0538 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 3 iter: 0 loss: 0.0768 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 3 iter: 5 loss: 0.0887 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 3 iter: 10 loss: 0.0417 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 3 iter: 15 loss: 0.0511 train acc: 1.0000 test acc: 1.0000\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Iris 数据集二分类\n", + "\n", + "test_rate=0.2\n", + "num_qubit=4\n", + "\n", + "# 获取 Iris 数据集的量子态\n", + "iris = Iris (encoding='angle_encoding', num_qubits=num_qubit, test_rate=test_rate,classes=[0, 1], return_state=True)\n", + "\n", + "quantum_train_x, train_y = iris.train_x, iris.train_y\n", + "quantum_test_x, test_y = iris.test_x, iris.test_y\n", + "testing_data_num = len(test_y)\n", + "training_data_num = len(train_y)\n", + "\n", + "acc = QClassifier2(\n", + " quantum_train_x, # 训练特征\n", + " train_y, # 训练标签\n", + " quantum_test_x, # 测试特征\n", + " test_y, # 测试标签\n", + " N = num_qubit, # 使用的量子比特数目\n", + " DEPTH = 1, # 分类器电路的深度\n", + " EPOCH = 4, # 迭代次数\n", + " LR = 0.1, # 学习率\n", + " BATCH = 4, # 一个批量的大小\n", + " )\n", + "plt.plot(acc)\n", + "plt.title(\"Classify Iris 0&1 using angle encoding\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Testing accuracy\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "第二个例子为 MNIST 数据集。 MNIST 是手写数字数据集，有 0-9 十个类别（每一类训练集中有 6000 个样本，测试集中有 1000 个样本）。所有的图片都是 $28\\times28$ 的灰度图，所以需要使用 ``resize`` 或 ``PCA`` 降维到目标维度 ``target_dimension`` 。" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch: 0 iter: 0 loss: 0.2345 train acc: 0.5750 test acc: 0.5350\n", + "epoch: 0 iter: 5 loss: 0.2322 train acc: 0.6500 test acc: 0.5800\n", + "epoch: 0 iter: 10 loss: 0.2423 train acc: 0.6250 test acc: 0.5550\n", + "epoch: 1 iter: 0 loss: 0.1909 train acc: 0.8000 test acc: 0.6900\n", + "epoch: 1 iter: 5 loss: 0.1938 train acc: 0.7250 test acc: 0.6450\n", + "epoch: 1 iter: 10 loss: 0.2055 train acc: 0.6750 test acc: 0.7250\n", + "epoch: 2 iter: 0 loss: 0.1855 train acc: 0.8000 test acc: 0.7400\n", + "epoch: 2 iter: 5 loss: 0.1627 train acc: 0.8000 test acc: 0.7650\n", + "epoch: 2 iter: 10 loss: 0.1684 train acc: 0.8250 test acc: 0.7900\n", + "epoch: 3 iter: 0 loss: 0.1676 train acc: 0.8250 test acc: 0.7750\n", + "epoch: 3 iter: 5 loss: 0.1387 train acc: 0.8500 test acc: 0.7500\n", + "epoch: 3 iter: 10 loss: 0.1679 train acc: 0.8500 test acc: 0.7950\n", + "epoch: 4 iter: 0 loss: 0.1584 train acc: 0.7250 test acc: 0.8050\n", + "epoch: 4 iter: 5 loss: 0.1408 train acc: 0.8500 test acc: 0.8150\n", + "epoch: 4 iter: 10 loss: 0.1603 train acc: 0.8500 test acc: 0.8100\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 使用 MNIST 进行分类\n", + "\n", + "# 主要参数\n", + "training_data_num = 500\n", + "testing_data_num = 200\n", + "num_qubit = 4\n", + "\n", + "# 选择3和6两个类，将 MNIST 从 28*28 重采样为 4*4，再用振幅编码方式进行编码 \n", + "train_dataset = MNIST(mode='train', encoding='amplitude_encoding', num_qubits=num_qubit, classes=[3,6],\n", + " data_num=training_data_num,need_cropping=True,\n", + " downscaling_method='resize', target_dimension=16, return_state=True)\n", + "\n", + "val_dataset = MNIST(mode='test', encoding='amplitude_encoding', num_qubits=num_qubit, classes=[3,6],\n", + " data_num=testing_data_num,need_cropping=True,\n", + " downscaling_method='resize', target_dimension=16,return_state=True)\n", + "\n", + "quantum_train_x, train_y = train_dataset.quantum_image_states, train_dataset.labels\n", + "quantum_test_x, test_y = val_dataset.quantum_image_states, val_dataset.labels\n", + "\n", + "acc = QClassifier2(\n", + " quantum_train_x, # 训练特征\n", + " train_y, # 训练标签\n", + " quantum_test_x, # 测试特征\n", + " test_y, # 测试标签\n", + " N = num_qubit, # 使用的量子比特数目\n", + " DEPTH = 3, # 分类器电路的深度\n", + " EPOCH = 5, # 迭代次数\n", + " LR = 0.1, # 学习率\n", + " BATCH = 40, # 一个批量的大小\n", + " )\n", + "plt.plot(acc)\n", + "plt.title(\"Classify MNIST 3&6 using amplitude encoding\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Testing accuracy\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Mitarai, Kosuke, et al. Quantum circuit learning. [Physical Review A 98.3 (2018): 032309.](https://arxiv.org/abs/1803.00745)\n", + "\n", + "[2] Farhi, Edward, and Hartmut Neven. Classification with quantum neural networks on near term processors. [arXiv preprint arXiv:1802.06002 (2018).](https://arxiv.org/abs/1802.06002)\n", + "\n", + "[3] Schuld, Maria, et al. Circuit-centric quantum classifiers. [Physical Review A 101.3 (2020): 032308.](https://arxiv.org/abs/1804.00633)\n", + "\n", + "[4] Schuld, Maria. Supervised quantum machine learning models are kernel methods. [arXiv preprint arXiv:2101.11020 (2021).](https://arxiv.org/pdf/2101.11020)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.8.13" + }, + "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": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorials/machine_learning/QClassifier_EN.ipynb b/tutorials/machine_learning/QClassifier_EN.ipynb new file mode 100644 index 0000000..dd7f032 --- /dev/null +++ b/tutorials/machine_learning/QClassifier_EN.ipynb @@ -0,0 +1,1406 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Quantum Classifier\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "In this tutorial, we will discuss the workflow of Variational Quantum Classifiers (VQC) and how to use quantum neural networks (QNN) to accomplish a **binary classification** task. The main representatives of this approach include the [Quantum Circuit Learning (QCL)](https://arxiv.org/abs/1803.00745) [1] by Mitarai et al. (2018), Farhi & Neven (2018) [2] and [Circuit-Centric Quantum Classifiers](https://arxiv.org/abs/1804.00633) [3] by Schuld et al. (2018). Here, we mainly talk about classification in the language of supervised learning. Unlike classical methods, quantum classifiers require pre-processing to encode classical data into quantum data, and then train the parameters in the quantum neural network. Using different encoding methods, we can benchmark the optimal classification performance through test data. Finally, we demonstrate how to use built-in quantum datasets to accomplish quantum classification.\n", + "\n", + "### Background\n", + "\n", + "In the language of supervised learning, we need to enter a data set composed of $N$ pairs of labeled data points $D = \\{(x^k,y^k)\\}_{k=1}^{N}$ , Where $x^k\\in \\mathbb{R}^{m}$ is the data point, and $y^k \\in\\{0,1\\}$ is the label associated with the data point $x^k$. **The classification process is essentially a decision-making process, which determines the label attribution of a given data point**. For the quantum classifier framework, the realization of the classifier $\\mathcal{F}$ is a combination of a quantum neural network (or parameterized quantum circuit) with parameters $\\theta$, measurement, and data processing. An excellent classifier $\\mathcal{F}_\\theta$ should correctly map the data points in each data set to the corresponding labels as accurate as possible $\\mathcal{F}_\\theta(x^k ) \\rightarrow y^k$. Therefore, we use the cumulative distance between the predicted label $\\tilde{y}^{k} = \\mathcal{F}_\\theta(x^k)$ and the actual label $y^k$ as the loss function $\\mathcal {L}(\\theta)$ to be optimized. For binary classification tasks, we can choose the following loss function,\n", + "\n", + "$$\n", + "\\mathcal{L}(\\theta) = \\sum_{k=1}^N 1/N \\cdot |\\tilde{y}^{k}-y^k|^2. \\tag{1}\n", + "$$\n", + "\n", + "### Pipeline\n", + "\n", + "Here we give the whole pipeline to implement a quantum classifier under the framework of quantum circuit learning (QCL).\n", + "\n", + "1. Encode the classical data $x^k$ to quantum data $\\lvert \\psi_{\\rm in}\\rangle^k$. In this tutorial, we use Angle Encoding, see [encoding methods](./DataEncoding_EN.ipynb) for details. Readers can also try other encoding methods, e.g., Amplitude Encoding, and see the performance.\n", + "2. Construct the parameterized quantum circuit (PQC), corresponds to the unitary gate $U(\\theta)$.\n", + "3. Apply the parameterized circuit $U(\\theta)$ with the parameter $\\theta$ on input states $\\lvert \\psi_{\\rm in} \\rangle^k$, thereby obtaining the output state $\\lvert \\psi_{\\rm out} \\rangle^k = U(\\theta)\\lvert \\psi_{\\rm in} \\rangle^k$.\n", + "4. Measure the quantum state $\\lvert \\psi_{\\rm out}\\rangle^k$ processed by the quantum neural network to get the estimated label $\\tilde{y}^{k}$.\n", + "5. Repeat steps 3-4 until all data points in the data set have been processed. Then calculate the loss function $\\mathcal{L}(\\theta)$.\n", + "6. Continuously adjust the parameter $\\theta$ through optimization methods such as gradient descent to minimize the loss function. Record the optimal parameters after optimization $\\theta^* $, and then we obtain the optimal classifier $\\mathcal{F}_{\\theta^*}$.\n", + "\n", + " \n", + "
Figure 1: Flow chart of quantum classifier training
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Paddle Quantum Implementation\n", + "\n", + "Here, we first import the required packages:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Import numpy,paddle and paddle_quantum\n", + "import numpy as np\n", + "import paddle\n", + "import paddle_quantum\n", + "\n", + "# To construct quantum circuit\n", + "from paddle_quantum.ansatz import Circuit\n", + "\n", + "# Some functions\n", + "from numpy import pi as PI\n", + "from paddle import matmul, transpose, reshape # paddle matrix multiplication and transpose\n", + "from paddle_quantum.qinfo import pauli_str_to_matrix # N qubits Pauli matrix\n", + "from paddle_quantum.linalg import dagger # complex conjugate\n", + "\n", + "# Plot figures, calculate the run time\n", + "from matplotlib import pyplot as plt\n", + "import time" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Parameters used for classification" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Parameters for generating the data set\n", + "Ntrain = 200 # Specify the training set size\n", + "Ntest = 100 # Specify the test set size\n", + "boundary_gap = 0.5 # Set the width of the decision boundary\n", + "seed_data = 2 # Fixed random seed required to generate the data set\n", + "# Parameters for training\n", + "N = 4 # Number of qubits required\n", + "DEPTH = 1 # Circuit depth\n", + "BATCH = 20 # Batch size during training\n", + "EPOCH = int(200 * BATCH / Ntrain)\n", + " # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n", + "LR = 0.01 # Set the learning rate\n", + "seed_paras = 19 # Set random seed to initialize various parameters" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data set generation\n", + "\n", + "One of the key parts in supervised learning is what data set to use? In this tutorial, we follow the exact approach introduced in QCL paper to generate a simple binary data set $\\{(x^{k}, y^{k})\\}$ with circular decision boundary, where the data point $x^{k}\\in \\mathbb{R}^{2}$, and the label $y^{k} \\in \\{0,1\\}$. The figure below provides us a concrete example.\n", + "\n", + " \n", + "
Figure 2: Generated data set and the corresponding decision boundary
\n", + "\n", + "For the generation method and visualization, please see the following code:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Generate a binary classification data set" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T04:03:35.707224Z", + "start_time": "2021-03-09T04:03:35.691351Z" + } + }, + "outputs": [], + "source": [ + "# Generate a binary classification data set with circular decision boundary\n", + "def circle_data_point_generator(Ntrain, Ntest, boundary_gap, seed_data):\n", + " \"\"\"\n", + " :param Ntrain: number of training samples\n", + " :param Ntest: number of test samples\n", + " :param boundary_gap: value in (0, 0.5), means the gap between two labels\n", + " :param seed_data: random seed\n", + " :return: 'Ntrain' samples for training and\n", + " 'Ntest' samples for testing\n", + " \"\"\"\n", + " # Generate \"Ntrain + Ntest\" pairs of data, x for 2-dim data points, y for labels.\n", + " # The first \"Ntrain\" pairs are used as training set, the last \"Ntest\" pairs are used as testing set\n", + " train_x, train_y = [], []\n", + " num_samples, seed_para = 0, 0\n", + " while num_samples < Ntrain + Ntest:\n", + " np.random.seed((seed_data + 10) * 1000 + seed_para + num_samples)\n", + " data_point = np.random.rand(2) * 2 - 1 # 2-dim vector in range [-1, 1]\n", + "\n", + " # If the modulus of the data point is less than (0.7 - gap), mark it as 0\n", + " if np.linalg.norm(data_point) < 0.7-boundary_gap / 2:\n", + " train_x.append(data_point)\n", + " train_y.append(0.)\n", + " num_samples += 1\n", + "\n", + " # If the modulus of the data point is greater than (0.7 + gap), mark it as 1\n", + " elif np.linalg.norm(data_point) > 0.7 + boundary_gap / 2:\n", + " train_x.append(data_point)\n", + " train_y.append(1.)\n", + " num_samples += 1\n", + " else:\n", + " seed_para += 1\n", + "\n", + " train_x = np.array(train_x).astype(\"float64\")\n", + " train_y = np.array([train_y]).astype(\"float64\").T\n", + "\n", + " print(\"The dimensions of the training set x {} and y {}\".format(np.shape(train_x[0:Ntrain]), np.shape(train_y[0:Ntrain])))\n", + " print(\"The dimensions of the test set x {} and y {}\".format(np.shape(train_x[Ntrain:]), np.shape(train_y[Ntrain:])), \"\\n\")\n", + "\n", + " return train_x[0:Ntrain], train_y[0:Ntrain], train_x[Ntrain:], train_y[Ntrain:]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the generated data set" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def data_point_plot(data, label):\n", + " \"\"\"\n", + " :param data: shape [M, 2], means M 2-D data points\n", + " :param label: value 0 or 1\n", + " :return: plot these data points\n", + " \"\"\"\n", + " dim_samples, dim_useless = np.shape(data)\n", + " plt.figure(1)\n", + " for i in range(dim_samples):\n", + " if label[i] == 0:\n", + " plt.plot(data[i][0], data[i][1], color=\"r\", marker=\"o\")\n", + " elif label[i] == 1:\n", + " plt.plot(data[i][0], data[i][1], color=\"b\", marker=\"o\")\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In this tutorial, we use a training set with 200 elements, a testing set with 100 elements. The boundary gap is 0.5." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T04:03:37.244233Z", + "start_time": "2021-03-09T04:03:35.719425Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The dimensions of the training set x (200, 2) and y (200, 1)\n", + "The dimensions of the test set x (100, 2) and y (100, 1) \n", + "\n", + "Visualization of 200 data points in the training set: \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Visualization of 100 data points in the test set: \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " You may wish to adjust the parameter settings to generate your own data set!\n" + ] + } + ], + "source": [ + "# Generate data set\n", + "train_x, train_y, test_x, test_y = circle_data_point_generator(\n", + " Ntrain, Ntest, boundary_gap, seed_data)\n", + "\n", + "# Visualization\n", + "print(\"Visualization of {} data points in the training set: \".format(Ntrain))\n", + "data_point_plot(train_x, train_y)\n", + "print(\"Visualization of {} data points in the test set: \".format(Ntest))\n", + "data_point_plot(test_x, test_y)\n", + "print(\"\\n You may wish to adjust the parameter settings to generate your own data set!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data preprocessing\n", + "Different from classical machine learning, quantum classifiers need to consider data preprocessing heavily. We need one more step to convert classical data into quantum information before running on a quantum computer. In this tutorial we use \"Angle Encoding\" to get quantum data.\n", + "\n", + "First, we determine the number of qubits that need to be used. Because our data $\\{x^{k} = (x^{k}_0, x^{k}_1)\\}$ is two-dimensional, according to the paper by Mitarai (2018) we need at least 2 qubits for encoding. Then prepare a group of initial quantum states $|00\\rangle$. Encode the classical information $\\{x^{k}\\}$ into a group of quantum gates $U(x^{k})$ and act them on the initial quantum states. Finally we get a group of quantum states $|\\psi_{\\rm in}\\rangle^k = U(x^{k})|00\\rangle$. In this way, we have completed the encoding from classical information into quantum information! Given $m$ qubits to encode a two-dimensional classical data point, the quantum gate is:\n", + "\n", + "$$\n", + "U(x^{k}) = \\otimes_{j=0}^{m-1} R_j^z\\big[\\arccos(x^{k}_{j \\, \\text{mod} \\, 2}\\cdot x^{k}_{j \\, \\text{mod} \\, 2})\\big] R_j^y\\big[\\arcsin(x^{k}_{j \\, \\text{mod} \\, 2}) \\big],\n", + "\\tag{2}\n", + "$$\n", + "\n", + "**Note:** In this representation, we count the first qubit as $j = 0$. For more encoding methods, see [Robust data encodings for quantum classifiers](https://arxiv.org/pdf/2003.01695.pdf). We also provide several built-in [encoding methods](./DataEncoding_EN.ipynb) in Paddle Quantum. Here we also encourage readers to try new encoding methods by themselves!\n", + "\n", + "Since this encoding method looks quite complicated, we might as well give a simple example. Suppose we are given a data point $x = (x_0, x_1)= (1,0)$. The label of this data point should be 1, corresponding to the **blue** point in the figure above. At the same time, the 2-qubit quantum gate $U(x)$ corresponding to the data point is,\n", + "\n", + "$$\n", + "U(x) =\n", + "\\bigg( R_0^z\\big[\\arccos(x_{0}\\cdot x_{0})\\big] R_0^y\\big[\\arcsin(x_{0}) \\big] \\bigg)\n", + "\\otimes\n", + "\\bigg( R_1^z\\big[\\arccos(x_{1}\\cdot x_{1})\\big] R_1^y\\big[\\arcsin(x_{1}) \\big] \\bigg),\n", + "\\tag{3}\n", + "$$\n", + "\n", + "Substituting in specific values, we get:\n", + "\n", + "$$\n", + "U(x) =\n", + "\\bigg( R_0^z\\big[0\\big] R_0^y\\big[\\pi/2 \\big] \\bigg)\n", + "\\otimes\n", + "\\bigg( R_1^z\\big[\\pi/2\\big] R_1^y\\big[0 \\big] \\bigg),\n", + "\\tag{4}\n", + "$$\n", + "\n", + "Recall the matrix form of rotation gates:\n", + "\n", + "$$\n", + "R_x(\\theta) :=\n", + "\\begin{bmatrix}\n", + "\\cos \\frac{\\theta}{2} &-i\\sin \\frac{\\theta}{2} \\\\\n", + "-i\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2}\n", + "\\end{bmatrix}\n", + ",\\quad\n", + "R_y(\\theta) :=\n", + "\\begin{bmatrix}\n", + "\\cos \\frac{\\theta}{2} &-\\sin \\frac{\\theta}{2} \\\\\n", + "\\sin \\frac{\\theta}{2} &\\cos \\frac{\\theta}{2}\n", + "\\end{bmatrix}\n", + ",\\quad\n", + "R_z(\\theta) :=\n", + "\\begin{bmatrix}\n", + "e^{-i\\frac{\\theta}{2}} & 0 \\\\\n", + "0 & e^{i\\frac{\\theta}{2}}\n", + "\\end{bmatrix}.\n", + "\\tag{5}\n", + "$$\n", + "\n", + "Then the matrix form of the two-qubit quantum gate $U(x)$ can be written as\n", + "\n", + "$$\n", + "U(x) = \n", + "\\bigg(\n", + "\\begin{bmatrix}\n", + "1 & 0 \\\\ \n", + "0 & 1\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + "\\cos \\frac{\\pi}{4} &-\\sin \\frac{\\pi}{4} \\\\ \n", + "\\sin \\frac{\\pi}{4} &\\cos \\frac{\\pi}{4} \n", + "\\end{bmatrix}\n", + "\\bigg)\n", + "\\otimes \n", + "\\bigg(\n", + "\\begin{bmatrix}\n", + "e^{-i\\frac{\\pi}{4}} & 0 \\\\ \n", + "0 & e^{i\\frac{\\pi}{4}}\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + "1 &0 \\\\ \n", + "0 &1\n", + "\\end{bmatrix}\n", + "\\bigg) \\, .\n", + "\\tag{6}\n", + "$$\n", + "\n", + "After simplification, we can get the encoded quantum state $|\\psi_{\\rm in}\\rangle$ by acting the quantum gate on the initialized quantum state $|00\\rangle$,\n", + "\n", + "$$\n", + "|\\psi_{\\rm in}\\rangle =\n", + "U(x)|00\\rangle = \\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "1-i &0 &-1+i &0 \\\\\n", + "0 &1+i &0 &-1-i \\\\\n", + "1-i &0 &1-i &0 \\\\\n", + "0 &1+i &0 &1+i\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + "1 \\\\\n", + "0 \\\\\n", + "0 \\\\\n", + "0\n", + "\\end{bmatrix}\n", + "= \\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "1-i \\\\\n", + "0 \\\\\n", + "1-i \\\\\n", + "0\n", + "\\end{bmatrix}.\n", + "\\tag{7}\n", + "$$\n", + "\n", + "Then let us take a look at how to implement this encoding method in Paddle Quantum. Note that in the code, we use the following trick: \n", + "\n", + "$$\n", + "(U_1 |0\\rangle)\\otimes (U_2 |0\\rangle) = (U_1 \\otimes U_2) |0\\rangle\\otimes|0\\rangle\n", + "= (U_1 \\otimes U_2) |00\\rangle.\n", + "\\tag{8}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T04:03:37.354267Z", + "start_time": "2021-03-09T04:03:37.258314Z" + } + }, + "outputs": [], + "source": [ + "# Gate: rotate around Y-axis, Z-axis with angle theta\n", + "def Ry(theta):\n", + " \"\"\"\n", + " :param theta: parameter\n", + " :return: Y rotation matrix\n", + " \"\"\"\n", + " return np.array([[np.cos(theta / 2), -np.sin(theta / 2)],\n", + " [np.sin(theta / 2), np.cos(theta / 2)]])\n", + "\n", + "def Rz(theta):\n", + " \"\"\"\n", + " :param theta: parameter\n", + " :return: Z rotation matrix\n", + " \"\"\"\n", + " return np.array([[np.cos(theta / 2) - np.sin(theta / 2) * 1j, 0],\n", + " [0, np.cos(theta / 2) + np.sin(theta / 2) * 1j]])\n", + "\n", + "# Classical -> Quantum Data Encoder\n", + "def datapoints_transform_to_state(data, n_qubits):\n", + " \"\"\"\n", + " :param data: shape [-1, 2]\n", + " :param n_qubits: the number of qubits to which\n", + " the data transformed\n", + " :return: shape [-1, 1, 2 ^ n_qubits]\n", + " the first parameter -1 in this shape means can be arbitrary. In this tutorial, it equals to BATCH.\n", + " \"\"\"\n", + " dim1, dim2 = data.shape\n", + " res = []\n", + " for sam in range(dim1):\n", + " res_state = 1.\n", + " zero_state = np.array([[1, 0]])\n", + " # Angle Encoding\n", + " for i in range(n_qubits):\n", + " # For even number qubits, perform Rz(arccos(x0^2)) Ry(arcsin(x0))\n", + " if i % 2 == 0:\n", + " state_tmp=np.dot(zero_state, Ry(np.arcsin(data[sam][0])).T)\n", + " state_tmp=np.dot(state_tmp, Rz(np.arccos(data[sam][0] ** 2)).T)\n", + " res_state=np.kron(res_state, state_tmp)\n", + " # For odd number qubits, perform Rz(arccos(x1^2)) Ry(arcsin(x1))\n", + " elif i% 2 == 1:\n", + " state_tmp=np.dot(zero_state, Ry(np.arcsin(data[sam][1])).T)\n", + " state_tmp=np.dot(state_tmp, Rz(np.arccos(data[sam][1] ** 2)).T)\n", + " res_state=np.kron(res_state, state_tmp)\n", + " res.append(res_state)\n", + " res = np.array(res, dtype=paddle_quantum.get_dtype())\n", + " \n", + " return res" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "quantum data after angle encoding" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "As a test, we enter the classical information:\n", + "(x_0, x_1) = (1, 0)\n", + "The 2-qubit quantum state output after encoding is:\n", + "[[[0.5-0.5j 0. +0.j 0.5-0.5j 0. +0.j ]]]\n" + ] + } + ], + "source": [ + "print(\"As a test, we enter the classical information:\")\n", + "print(\"(x_0, x_1) = (1, 0)\")\n", + "print(\"The 2-qubit quantum state output after encoding is:\")\n", + "print(datapoints_transform_to_state(np.array([[1, 0]]), n_qubits=2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Building Quantum Neural Network \n", + "After completing the encoding from classical data to quantum data, we can now input these quantum states into the quantum computer. Before that, we also need to design the quantum neural network.\n", + "\n", + " \n", + "
Figure 3: Parameterized Quantum Circuit
\n", + "\n", + "\n", + "For convenience, we call the parameterized quantum neural network as $U(\\boldsymbol{\\theta})$. $U(\\boldsymbol{\\theta})$ is a key component of our classifier, and it needs a certain complex structure to fit our decision boundary. Similar to traditional neural networks, the structure of a quantum neural network is not unique. The structure shown above is just one case. You could design your own structure. Let's take the previously mentioned data point $x = (x_0, x_1)= (1,0)$ as an example. After encoding, we have obtained a quantum state $|\\psi_{\\rm in}\\rangle$,\n", + "\n", + "$$\n", + "|\\psi_{\\rm in}\\rangle =\n", + "\\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "1-i \\\\\n", + "0 \\\\\n", + "1-i \\\\\n", + "0\n", + "\\end{bmatrix}.\n", + "\\tag{9}\n", + "$$\n", + "\n", + "Then we input this quantum state into our quantum neural network (QNN). That is, multiply a unitary matrix by a vector to get the processed quantum state $|\\varphi\\rangle$\n", + "\n", + "$$\n", + "|\\psi_{\\rm out}\\rangle = U(\\boldsymbol{\\theta})|\\psi_{\\rm in}\\rangle.\n", + "\\tag{10}\n", + "$$\n", + "\n", + "If we set all the QNN parameters to be $\\theta = \\pi$, then we can write down the resulting state:\n", + "\n", + "$$\n", + "|\\psi_{\\rm out}\\rangle =\n", + "U(\\boldsymbol{\\theta} =\\pi)|\\psi_{\\rm in}\\rangle =\n", + "\\begin{bmatrix}\n", + "0 &0 &-1 &0 \\\\\n", + "-1 &0 &0 &0 \\\\\n", + "0 &1 &0 &0 \\\\\n", + "0 &0 &0 &1\n", + "\\end{bmatrix}\n", + "\\cdot\n", + "\\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "1-i \\\\\n", + "0 \\\\\n", + "1-i \\\\\n", + "0\n", + "\\end{bmatrix}\n", + "= \\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "-1+i \\\\\n", + "-1+i \\\\\n", + "0 \\\\\n", + "0\n", + "\\end{bmatrix}.\n", + "\\tag{11}\n", + "$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Measurement\n", + "After passing through the PQC $U(\\theta)$, the quantum data becomes $\\lvert \\psi_{\\rm out}\\rangle^k = U(\\theta)\\lvert \\psi_{\\rm in} \\rangle^k$. To get its label, we need to measure this new quantum state to obtain the classical information. These processed classical information will then be used to calculate the loss function $\\mathcal{L}(\\boldsymbol{\\theta})$. Finally, based on the gradient descent algorithm, we continuously update the PQC parameters $\\boldsymbol{\\theta}$ and optimize the loss function. \n", + "\n", + "Here we measure the expected value of the Pauli $Z$ operator on the first qubit. Specifically,\n", + "\n", + "$$\n", + "\\langle Z \\rangle =\n", + "\\langle \\psi_{\\rm out} |Z\\otimes I\\cdots \\otimes I| \\psi_{\\rm out}\\rangle.\n", + "\\tag{12}\n", + "$$\n", + "\n", + "Recall that the matrix of the Pauli $Z$ operator is defined as:\n", + "\n", + "$$\n", + "Z := \\begin{bmatrix} 1 &0 \\\\ 0 &-1 \\end{bmatrix}.\n", + "\\tag{13}\n", + "$$\n", + "\n", + "Continuing our previous 2-qubit example, the expected value we get after the measurement is\n", + "\n", + "$$\n", + "\\langle Z \\rangle =\n", + "\\langle \\psi_{\\rm out} |Z\\otimes I| \\psi_{\\rm out}\\rangle =\n", + "\\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "-1-i \\quad\n", + "-1-i \\quad\n", + "0 \\quad\n", + "0\n", + "\\end{bmatrix}\n", + "\\begin{bmatrix}\n", + "1 &0 &0 &0 \\\\\n", + "0 &1 &0 &0 \\\\\n", + "0 &0 &-1 &0 \\\\\n", + "0 &0 &0 &-1\n", + "\\end{bmatrix}\n", + "\\cdot\n", + "\\frac{1}{2}\n", + "\\begin{bmatrix}\n", + "-1+i \\\\\n", + "-1+i \\\\\n", + "0 \\\\\n", + "0\n", + "\\end{bmatrix}\n", + "= 1. \\tag{14}\n", + "$$\n", + "\n", + "This measurement result seems to be our original label 1. Does this mean that we have successfully classified this data point? This is not the case because the range of $\\langle Z \\rangle$ is usually between $[-1,1]$. \n", + "To match it to our label range $y^{k} \\in \\{0,1\\}$, we need to map the upper and lower limits. The simplest mapping is \n", + "\n", + "$$\n", + "\\tilde{y}^{k} = \\frac{\\langle Z \\rangle}{2} + \\frac{1}{2} + bias \\quad \\in [0, 1].\n", + "\\tag{15}\n", + "$$\n", + "\n", + "Using bias is a trick in machine learning. The purpose is to make the decision boundary not restricted by the origin or some hyperplane. Generally, the default bias is initialized to be 0, and the optimizer will continuously update it like all the other parameters $\\theta$ in the iterative process to ensure $\\tilde{y}^{k} \\in [0, 1]$. Of course, you can also choose other complex mappings (activation functions), such as the sigmoid function. After mapping, we can regard $\\tilde{y}^{k}$ as the label we estimated. $\\tilde{y}^{k}< 0.5$ corresponds to label 0, and $\\tilde{y}^{k}> 0.5$ corresponds to label 1. It's time to quickly review the whole process before we finish discussion,\n", + "\n", + "$$\n", + "x^{k} \\rightarrow |\\psi_{\\rm in}\\rangle^{k} \\rightarrow U(\\boldsymbol{\\theta})|\\psi_{\\rm in}\\rangle^{k} \\rightarrow\n", + "|\\psi_{\\rm out}\\rangle^{k} \\rightarrow ^{k}\\langle \\psi_{\\rm out} |Z\\otimes I\\cdots \\otimes I| \\psi_{\\rm out} \\rangle^{k}\n", + "\\rightarrow \\langle Z \\rangle \\rightarrow \\tilde{y}^{k}.\\tag{16}\n", + "$$\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Loss function\n", + "\n", + "To calculate the loss function in Eq. (1), we need to measure all training data in each iteration. In real practice, we devide the training data into \"Ntrain/BATCH\" groups, where each group contains \"BATCH\" data pairs.\n", + "\n", + "The loss function for the i-th group is \n", + "$$\n", + "\\mathcal{L}_{i} = \\sum_{k=1}^{BATCH} \\frac{1}{BATCH} |y^{i,k} - \\tilde{y}^{i,k}|^2,\\tag{17}\n", + "$$\n", + "and we train the PQC with $\\mathcal{L}_{i}$ for \"EPOCH\" times. \n", + "\n", + "If you set \"BATCH = Ntrain\", there will be only one group, and Eq. (17) becomes Eq. (1)." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T04:03:37.439183Z", + "start_time": "2021-03-09T04:03:37.432202Z" + } + }, + "outputs": [], + "source": [ + "# 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", + " r\"\"\"\n", + " :param n: number of qubits\n", + " :return: local observable: Z \\otimes I \\otimes ...\\otimes I\n", + " \"\"\"\n", + " Ob = pauli_str_to_matrix([[1.0, 'z0']], n)\n", + "\n", + " return Ob" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T04:03:37.503213Z", + "start_time": "2021-03-09T04:03:37.473028Z" + } + }, + "outputs": [], + "source": [ + "# Build the computational graph\n", + "class Opt_Classifier(paddle_quantum.gate.Gate):\n", + " \"\"\"\n", + " Construct the model net\n", + " \"\"\"\n", + " def __init__(self, n, depth, seed_paras=1):\n", + " # Initialization, use n, depth give the initial PQC\n", + " super(Opt_Classifier, self).__init__()\n", + " self.n = n\n", + " self.depth = depth\n", + " # Initialize bias\n", + " self.bias = self.create_parameter(\n", + " shape=[1],\n", + " default_initializer=paddle.nn.initializer.Normal(std=0.01),\n", + " dtype='float32',\n", + " is_bias=False)\n", + " \n", + " self.circuit = Circuit(n)\n", + " # Build a generalized rotation layer\n", + " for i in range(n):\n", + " self.circuit.rz(qubits_idx=i)\n", + " self.circuit.ry(qubits_idx=i)\n", + " self.circuit.rz(qubits_idx=i)\n", + "\n", + " # The default depth is depth = 1\n", + " # Build the entangleed layer and Ry rotation layer\n", + " for d in range(3, depth + 3):\n", + " # The entanglement layer\n", + " for i in range(n-1):\n", + " self.circuit.cnot(qubits_idx=[i, i + 1])\n", + " self.circuit.cnot(qubits_idx=[n-1, 0])\n", + " # Add Ry to each qubit\n", + " for i in range(n):\n", + " self.circuit.ry(qubits_idx=i)\n", + "\n", + " # Define forward propagation mechanism, and then calculate loss function and cross-validation accuracy\n", + " def forward(self, state_in, label):\n", + " \"\"\"\n", + " Args:\n", + " state_in: The input quantum state, shape [-1, 1, 2^n] -- in this tutorial: [BATCH, 1, 2^n]\n", + " label: label for the input state, shape [-1, 1]\n", + " Returns:\n", + " The loss:\n", + " L = 1/BATCH * (( + 1)/2 + bias - label)^2\n", + " \"\"\"\n", + " # Convert Numpy array to tensor\n", + " Ob = paddle.to_tensor(Observable(self.n))\n", + " label_pp = reshape(paddle.to_tensor(label), [-1, 1])\n", + "\n", + " # Build the quantum circuit\n", + " Utheta = self.circuit.unitary_matrix()\n", + "\n", + " # Because Utheta is achieved by learning, we compute with row vectors to speed up without affecting the training effect\n", + " state_out = matmul(state_in, Utheta) # shape:[-1, 1, 2 ** n], the first parameter is BATCH in this tutorial\n", + "\n", + " # Measure the expectation value of Pauli Z operator -- shape [-1,1,1]\n", + " E_Z = matmul(matmul(state_out, Ob), transpose(paddle.conj(state_out), perm=[0, 2, 1]))\n", + "\n", + " # Mapping to the estimated value of the label\n", + " state_predict = paddle.real(E_Z)[:, 0] * 0.5 + 0.5 + self.bias # |y^{i,k} - \\tilde{y}^{i,k}|^2\n", + " loss = paddle.mean((state_predict - label_pp) ** 2) # Get average for \"BATCH\" |y^{i,k} - \\tilde{y}^{i,k}|^2: L_i：shape:[1,1]\n", + "\n", + " # Calculate the accuracy of cross-validation\n", + " is_correct = (paddle.abs(state_predict - label_pp) < 0.5).nonzero().shape[0]\n", + " acc = is_correct / label.shape[0]\n", + "\n", + " return loss, acc, state_predict.numpy(), self.circuit" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training process\n", + "\n", + "After defining all the concepts above, we might take a look at the actual training process." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Draw the figure of the final training classifier\n", + "def heatmap_plot(Opt_Classifier, N):\n", + " # generate data points x_y_\n", + " Num_points = 30\n", + " x_y_ = []\n", + " for row_y in np.linspace(0.9, -0.9, Num_points):\n", + " row = []\n", + " for row_x in np.linspace(-0.9, 0.9, Num_points):\n", + " row.append([row_x, row_y])\n", + " x_y_.append(row)\n", + " x_y_ = np.array(x_y_).reshape(-1, 2).astype(\"float64\")\n", + "\n", + " # make prediction: heat_data\n", + " input_state_test = paddle.to_tensor(\n", + " datapoints_transform_to_state(x_y_, N))\n", + " loss_useless, acc_useless, state_predict, cir = Opt_Classifier(state_in=input_state_test, label=x_y_[:, 0])\n", + " heat_data = state_predict.reshape(Num_points, Num_points)\n", + "\n", + " # plot\n", + " fig = plt.figure(1)\n", + " ax = fig.add_subplot(111)\n", + " x_label = np.linspace(-0.9, 0.9, 3)\n", + " y_label = np.linspace(0.9, -0.9, 3)\n", + " ax.set_xticks([0, Num_points // 2, Num_points - 1])\n", + " ax.set_xticklabels(x_label)\n", + " ax.set_yticks([0, Num_points // 2, Num_points - 1])\n", + " ax.set_yticklabels(y_label)\n", + " im = ax.imshow(heat_data, cmap=plt.cm.RdBu)\n", + " plt.colorbar(im)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Learn the PQC via Adam" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T04:03:38.325454Z", + "start_time": "2021-03-09T04:03:38.299975Z" + } + }, + "outputs": [], + "source": [ + "def QClassifier(Ntrain, Ntest, gap, N, DEPTH, EPOCH, LR, BATCH, seed_paras, seed_data):\n", + " \"\"\"\n", + " Quantum Binary Classifier\n", + " Input:\n", + " Ntrain # Specify the training set size\n", + " Ntest # Specify the test set size\n", + " gap # Set the width of the decision boundary\n", + " N # Number of qubits required\n", + " DEPTH # Circuit depth\n", + " BATCH # Batch size during training\n", + " EPOCH # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n", + " LR # Set the learning rate\n", + " seed_paras # Set random seed to initialize various parameters\n", + " seed_data # Fixed random seed required to generate the data set\n", + " plot_heat_map # Whether to plot heat map, default True\n", + " \"\"\"\n", + " # Generate data set\n", + " train_x, train_y, test_x, test_y = circle_data_point_generator(Ntrain=Ntrain, Ntest=Ntest, boundary_gap=gap, seed_data=seed_data)\n", + " # Read the dimension of the training set\n", + " N_train = train_x.shape[0]\n", + " \n", + " paddle.seed(seed_paras)\n", + " # Initialize the registers to store the accuracy rate and other information\n", + " summary_iter, summary_test_acc = [], []\n", + "\n", + " # Generally, we use Adam optimizer to get relatively good convergence\n", + " # Of course, it can be changed to SGD or RMSprop\n", + " myLayer = Opt_Classifier(n=N, depth=DEPTH) # Initial PQC\n", + " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=myLayer.parameters())\n", + "\n", + "\n", + " # Optimize iteration\n", + " # We divide the training set into \"Ntrain/BATCH\" groups\n", + " # For each group the final circuit will be used as the initial circuit for the next group\n", + " # Use cir to record the final circuit after learning.\n", + " i = 0 # Record the iteration number\n", + " for ep in range(EPOCH):\n", + " # Learn for each group\n", + " for itr in range(N_train // BATCH):\n", + " i += 1 # Record the iteration number\n", + " # Encode classical data into a quantum state |psi>, dimension [BATCH, 2 ** N]\n", + " input_state = paddle.to_tensor(datapoints_transform_to_state(train_x[itr * BATCH:(itr + 1) * BATCH], N))\n", + "\n", + " # Run forward propagation to calculate loss function\n", + " loss, train_acc, state_predict_useless, cir \\\n", + " = myLayer(state_in=input_state, label=train_y[itr * BATCH:(itr + 1) * BATCH]) # optimize the given PQC\n", + " # Print the performance in iteration\n", + " if i % 30 == 5:\n", + " # Calculate the correct rate on the test set test_acc\n", + " input_state_test = paddle.to_tensor(datapoints_transform_to_state(test_x, N))\n", + " loss_useless, test_acc, state_predict_useless, t_cir \\\n", + " = myLayer(state_in=input_state_test,label=test_y)\n", + " print(\"epoch:\", ep, \"iter:\", itr,\n", + " \"loss: %.4f\" % loss.numpy(),\n", + " \"train acc: %.4f\" % train_acc,\n", + " \"test acc: %.4f\" % test_acc)\n", + " # Store accuracy rate and other information\n", + " summary_iter.append(itr + ep * N_train)\n", + " summary_test_acc.append(test_acc) \n", + "\n", + " # Run back propagation to minimize the loss function\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + " \n", + " # Print the final circuit\n", + " print(\"The trained circuit:\")\n", + " print(cir)\n", + " # Draw the decision boundary represented by heatmap\n", + " heatmap_plot(myLayer, N=N)\n", + "\n", + " return summary_test_acc" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T04:04:19.852356Z", + "start_time": "2021-03-09T04:03:38.709491Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The dimensions of the training set x (200, 2) and y (200, 1)\n", + "The dimensions of the test set x (100, 2) and y (100, 1) \n", + "\n", + "epoch: 0 iter: 4 loss: 0.2750 train acc: 0.7000 test acc: 0.6700\n", + "epoch: 3 iter: 4 loss: 0.2471 train acc: 0.2500 test acc: 0.5500\n", + "epoch: 6 iter: 4 loss: 0.1976 train acc: 0.8000 test acc: 0.9200\n", + "epoch: 9 iter: 4 loss: 0.1639 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 12 iter: 4 loss: 0.1441 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 15 iter: 4 loss: 0.1337 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 18 iter: 4 loss: 0.1287 train acc: 1.0000 test acc: 1.0000\n", + "The trained circuit:\n", + "--Rz(3.490)----Ry(5.436)----Rz(3.281)----*--------------x----Ry(0.098)--\n", + " | | \n", + "--Rz(1.499)----Ry(2.579)----Rz(3.496)----x----*---------|----Ry(1.282)--\n", + " | | \n", + "--Rz(5.956)----Ry(3.158)----Rz(3.949)---------x----*----|----Ry(1.418)--\n", + " | | \n", + "--Rz(1.604)----Ry(0.722)----Rz(5.037)--------------x----*----Ry(2.437)--\n", + " \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The main program finished running in 7.628719806671143 seconds.\n" + ] + } + ], + "source": [ + "def main():\n", + " \"\"\"\n", + " main\n", + " \"\"\"\n", + " time_start = time.time()\n", + " acc = QClassifier(\n", + " Ntrain = 200, # Specify the training set size\n", + " Ntest = 100, # Specify the test set size\n", + " gap = 0.5, # Set the width of the decision boundary\n", + " N = 4, # Number of qubits required\n", + " DEPTH = 1, # Circuit depth\n", + " BATCH = 20, # Batch size during training\n", + " EPOCH = int(200 * BATCH / Ntrain),\n", + " # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n", + " LR = 0.01, # Set the learning rate\n", + " seed_paras = 19, # Set random seed to initialize various parameters\n", + " seed_data = 2, # Fixed random seed required to generate the data set\n", + " )\n", + " \n", + " time_span = time.time()-time_start\n", + " print('The main program finished running in ', time_span, 'seconds.')\n", + "\n", + "if __name__ == '__main__':\n", + " main()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By printing out the training results, you can see that the classification accuracy in both the test set and the training set after continuous optimization has reached $100\\%$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Benchmarking Different Encoding Methods\n", + "\n", + "Encoding methods are fundemental in supervised quantum machine learning [4]. In paddle quantum, commonly used encoding methods such as amplitude encoding, angle encoding, IQP encoding, etc., are integrated. Simple classification data of users (without reducing dimensions) can be encoded by an instance of the ``SimpleDataset`` class and image data can be encoded by an instance of the ``VisionDataset`` class both using the method ``encode``." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "(100, 4)\n" + ] + } + ], + "source": [ + "# Use circle data above to accomplish classification\n", + "from paddle_quantum.dataset import *\n", + "\n", + "# The data are two-dimensional and are encoded by two qubits\n", + "quantum_train_x = SimpleDataset(2).encode(train_x, 'angle_encoding', 2)\n", + "quantum_test_x = SimpleDataset(2).encode(test_x, 'angle_encoding', 2)\n", + "\n", + "print(type(quantum_test_x)) # ndarray\n", + "print(quantum_test_x.shape) # (100, 4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we define an ordinary classifier, and it will be used by different data afterwards." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# A simpler classifier\n", + "def QClassifier2(quantum_train_x, train_y,quantum_test_x,test_y, N, DEPTH, EPOCH, LR, BATCH):\n", + " \"\"\"\n", + " Quantum Binary Classifier\n", + " Input：\n", + " quantum_train_x # training x\n", + " train_y # training y\n", + " quantum_test_x # testing x\n", + " test_y # testing y\n", + " N # Number of qubits required\n", + " DEPTH # Circuit depth\n", + " EPOCH # Number of training epochs\n", + " LR # Set the learning rate\n", + " BATCH # Batch size during training\n", + " \"\"\"\n", + " Ntrain = len(quantum_train_x)\n", + " \n", + " paddle.seed(1)\n", + "\n", + " net = Opt_Classifier(n=N, depth=DEPTH)\n", + "\n", + " # Test accuracy list\n", + " summary_iter, summary_test_acc = [], []\n", + "\n", + " # Adam can also be replaced by SGD or RMSprop\n", + " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + " # Optimize\n", + " for ep in range(EPOCH):\n", + " for itr in range(Ntrain // BATCH):\n", + " # Import data\n", + " input_state = quantum_train_x[itr * BATCH:(itr + 1) * BATCH] # paddle.tensor\n", + " input_state = reshape(input_state, [-1, 1, 2 ** N])\n", + " label = train_y[itr * BATCH:(itr + 1) * BATCH]\n", + " test_input_state = reshape(quantum_test_x, [-1, 1, 2 ** N])\n", + "\n", + " loss, train_acc, state_predict_useless, cir = net(state_in=input_state, label=label)\n", + "\n", + " if itr % 5 == 0:\n", + " # get accuracy on test dataset (test_acc)\n", + " loss_useless, test_acc, state_predict_useless, t_cir = net(state_in=test_input_state, label=test_y)\n", + " print(\"epoch:\", ep, \"iter:\", itr,\n", + " \"loss: %.4f\" % loss.numpy(),\n", + " \"train acc: %.4f\" % train_acc,\n", + " \"test acc: %.4f\" % test_acc)\n", + " summary_test_acc.append(test_acc)\n", + "\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + "\n", + " return summary_test_acc" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we can test different encoding methods on the circle data generated above. Here we choose five encoding methods: amplitude encoding, angle encoding, pauli rotation encoding, IQP encoding, and complex entangled encoding. Then the curves of the testing accuracy are shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Encoding method: amplitude_encoding\n", + "epoch: 0 iter: 0 loss: 0.3005 train acc: 0.6000 test acc: 0.4600\n", + "epoch: 0 iter: 5 loss: 0.2908 train acc: 0.3000 test acc: 0.5000\n", + "epoch: 0 iter: 10 loss: 0.2313 train acc: 0.8000 test acc: 0.6200\n", + "epoch: 0 iter: 15 loss: 0.2181 train acc: 0.7000 test acc: 0.7000\n", + "Encoding method: angle_encoding\n", + "epoch: 0 iter: 0 loss: 0.4141 train acc: 0.4000 test acc: 0.3700\n", + "epoch: 0 iter: 5 loss: 0.2942 train acc: 0.6000 test acc: 0.6700\n", + "epoch: 0 iter: 10 loss: 0.1952 train acc: 0.6000 test acc: 0.6700\n", + "epoch: 0 iter: 15 loss: 0.2389 train acc: 0.6000 test acc: 0.6000\n", + "Encoding method: pauli_rotation_encoding\n", + "epoch: 0 iter: 0 loss: 0.1985 train acc: 0.7000 test acc: 0.7400\n", + "epoch: 0 iter: 5 loss: 0.2303 train acc: 0.6000 test acc: 0.6900\n", + "epoch: 0 iter: 10 loss: 0.1970 train acc: 0.6000 test acc: 0.7200\n", + "epoch: 0 iter: 15 loss: 0.2120 train acc: 0.7000 test acc: 0.7000\n", + "Encoding method: IQP_encoding\n", + "epoch: 0 iter: 0 loss: 0.2962 train acc: 0.5000 test acc: 0.4500\n", + "epoch: 0 iter: 5 loss: 0.2074 train acc: 0.7000 test acc: 0.7000\n", + "epoch: 0 iter: 10 loss: 0.2463 train acc: 0.6000 test acc: 0.6500\n", + "epoch: 0 iter: 15 loss: 0.2090 train acc: 0.9000 test acc: 0.5800\n", + "Encoding method: complex_entangled_encoding\n", + "epoch: 0 iter: 0 loss: 0.2500 train acc: 0.6000 test acc: 0.6800\n", + "epoch: 0 iter: 5 loss: 0.2571 train acc: 0.5000 test acc: 0.6800\n", + "epoch: 0 iter: 10 loss: 0.2661 train acc: 0.7000 test acc: 0.6700\n", + "epoch: 0 iter: 15 loss: 0.1916 train acc: 0.8000 test acc: 0.7200\n" + ] + } + ], + "source": [ + "# Testing different encoding methods\n", + "encoding_list = ['amplitude_encoding', 'angle_encoding', 'pauli_rotation_encoding', 'IQP_encoding', 'complex_entangled_encoding']\n", + "num_qubit = 2 # If qubit number is 1, CNOT gate in cir_classifier can not be used\n", + "dimension = 2\n", + "acc_list = []\n", + "\n", + "for i in range(len(encoding_list)):\n", + " encoding = encoding_list[i]\n", + " print(\"Encoding method:\", encoding)\n", + " # Use SimpleDataset to encode the data\n", + " quantum_train_x= SimpleDataset(dimension).encode(train_x, encoding, num_qubit)\n", + " quantum_test_x= SimpleDataset(dimension).encode(test_x, encoding, num_qubit)\n", + " quantum_train_x = paddle.to_tensor(quantum_train_x)\n", + " quantum_test_x = paddle.to_tensor(quantum_test_x)\n", + " \n", + " acc = QClassifier2(\n", + " quantum_train_x, # Training x\n", + " train_y, # Training y\n", + " quantum_test_x, # Testing x\n", + " test_y, # Testing y\n", + " N = num_qubit, # Number of qubits required\n", + " DEPTH = 1, # Circuit depth\n", + " EPOCH = 1, # Number of training epochs\n", + " LR = 0.1, # Set the learning rate\n", + " BATCH = 10, # Batch size during training\n", + " )\n", + " acc_list.append(acc)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Benchmarking different encoding methods\n", + "x=[2*i for i in range(len(acc_list[0]))]\n", + "for i in range(len(encoding_list)):\n", + " plt.plot(x,acc_list[i])\n", + "plt.legend(encoding_list)\n", + "plt.title(\"Benchmarking different encoding methods\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Test accuracy\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quantum Classification on Built-In MNIST and Iris Datasets\n", + "\n", + "Paddle Quantum provides datasets commonly used in quantum classification tasks, and users can use the `paddle_quantum.dataset` module to get the encoding circuits or encoded states. There are four built-in datasets in Paddle Quantum at present, including MNIST, FashionMNIST, Iris and BreastCancer. We can easily accomplishing quantum classification using these quantum datasets.\n", + "\n", + "The first case is Iris. It has three types of labels and 50 samples of each type. There are only four features in Iris data, and it is very easy to fulfill its classification." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch: 0 iter: 0 loss: 0.3372 train acc: 0.5000 test acc: 0.5000\n", + "epoch: 0 iter: 5 loss: 0.2687 train acc: 0.2500 test acc: 0.5500\n", + "epoch: 0 iter: 10 loss: 0.0781 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 0 iter: 15 loss: 0.0786 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 1 iter: 0 loss: 0.0903 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 1 iter: 5 loss: 0.1020 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 1 iter: 10 loss: 0.0553 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 1 iter: 15 loss: 0.0559 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 2 iter: 0 loss: 0.0770 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 2 iter: 5 loss: 0.0879 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 2 iter: 10 loss: 0.0438 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 2 iter: 15 loss: 0.0538 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 3 iter: 0 loss: 0.0768 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 3 iter: 5 loss: 0.0887 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 3 iter: 10 loss: 0.0417 train acc: 1.0000 test acc: 1.0000\n", + "epoch: 3 iter: 15 loss: 0.0511 train acc: 1.0000 test acc: 1.0000\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Using Iris\n", + "test_rate = 0.2\n", + "num_qubit = 4\n", + "\n", + "# acquire Iris data as quantum states\n", + "iris =Iris (encoding='angle_encoding', num_qubits=num_qubit, test_rate=test_rate,classes=[0, 1], return_state=True)\n", + "\n", + "quantum_train_x, train_y = iris.train_x, iris.train_y\n", + "quantum_test_x, test_y = iris.test_x, iris.test_y\n", + "testing_data_num = len(test_y)\n", + "training_data_num = len(train_y)\n", + "\n", + "acc = QClassifier2(\n", + " quantum_train_x, # training x\n", + " train_y, # training y\n", + " quantum_test_x, # testing x\n", + " test_y, # testing y\n", + " N = num_qubit, # Number of qubits required\n", + " DEPTH = 1, # Circuit depth\n", + " EPOCH = 4, # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n", + " LR = 0.1, # Set the learning rate\n", + " BATCH = 4, # Batch size during training\n", + " )\n", + "plt.plot(acc)\n", + "plt.title(\"Classify Iris 0&1 using angle encoding\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Testing accuracy\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The second case is MNIST. It is a handwritten digit dataset and has 10 classes. Each figure has $28\\times28$ pixels, and downscaling methods such as ``resize`` and ``PCA`` should be used to transform it into the target dimension." + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "epoch: 0 iter: 0 loss: 0.2345 train acc: 0.5750 test acc: 0.5350\n", + "epoch: 0 iter: 5 loss: 0.2322 train acc: 0.6500 test acc: 0.5800\n", + "epoch: 0 iter: 10 loss: 0.2423 train acc: 0.6250 test acc: 0.5550\n", + "epoch: 1 iter: 0 loss: 0.1909 train acc: 0.8000 test acc: 0.6900\n", + "epoch: 1 iter: 5 loss: 0.1938 train acc: 0.7250 test acc: 0.6450\n", + "epoch: 1 iter: 10 loss: 0.2055 train acc: 0.6750 test acc: 0.7250\n", + "epoch: 2 iter: 0 loss: 0.1855 train acc: 0.8000 test acc: 0.7400\n", + "epoch: 2 iter: 5 loss: 0.1627 train acc: 0.8000 test acc: 0.7650\n", + "epoch: 2 iter: 10 loss: 0.1684 train acc: 0.8250 test acc: 0.7900\n", + "epoch: 3 iter: 0 loss: 0.1676 train acc: 0.8250 test acc: 0.7750\n", + "epoch: 3 iter: 5 loss: 0.1387 train acc: 0.8500 test acc: 0.7500\n", + "epoch: 3 iter: 10 loss: 0.1679 train acc: 0.8500 test acc: 0.7950\n", + "epoch: 4 iter: 0 loss: 0.1584 train acc: 0.7250 test acc: 0.8050\n", + "epoch: 4 iter: 5 loss: 0.1408 train acc: 0.8500 test acc: 0.8150\n", + "epoch: 4 iter: 10 loss: 0.1603 train acc: 0.8500 test acc: 0.8100\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# using MNIST\n", + "\n", + "# main parameters\n", + "training_data_num = 500\n", + "testing_data_num = 200\n", + "num_qubit = 4\n", + "\n", + "# MNIST data with amplitude encoding, resized to 4*4\n", + "train_dataset = MNIST(mode='train', encoding='amplitude_encoding', num_qubits=num_qubit, classes=[3, 6],\n", + " data_num=training_data_num, need_cropping=True,\n", + " downscaling_method='resize', target_dimension=16, return_state=True)\n", + "\n", + "val_dataset = MNIST(mode='test', encoding='amplitude_encoding', num_qubits=num_qubit, classes=[3, 6],\n", + " data_num=testing_data_num, need_cropping=True,\n", + " downscaling_method='resize', target_dimension=16,return_state=True)\n", + "\n", + "quantum_train_x, train_y = train_dataset.quantum_image_states, train_dataset.labels\n", + "quantum_test_x, test_y = val_dataset.quantum_image_states, val_dataset.labels\n", + "\n", + "acc = QClassifier2(\n", + " quantum_train_x, # Training x\n", + " train_y, # Training y\n", + " quantum_test_x, # Testing x\n", + " test_y, # Testing y\n", + " N = num_qubit, # Number of qubits required\n", + " DEPTH = 3, # Circuit depth\n", + " EPOCH = 5, # Number of training epochs, the total iteration number \"EPOCH * (Ntrain / BATCH)\" is chosen to be about 200\n", + " LR = 0.1, # Set the learning rate\n", + " BATCH = 40, # Batch size during training\n", + " )\n", + "\n", + "plt.plot(acc)\n", + "plt.title(\"Classify MNIST 3&6 using amplitude encoding\")\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Testing accuracy\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## References\n", + "\n", + "\n", + "[1] Mitarai, Kosuke, et al. Quantum circuit learning. [Physical Review A 98.3 (2018): 032309.](https://arxiv.org/abs/1803.00745)\n", + "\n", + "[2] Farhi, Edward, and Hartmut Neven. Classification with quantum neural networks on near term processors. [arXiv preprint arXiv:1802.06002 (2018).](https://arxiv.org/abs/1802.06002)\n", + "\n", + "[3] Schuld, Maria, et al. Circuit-centric quantum classifiers. [Physical Review A 101.3 (2020): 032308.](https://arxiv.org/abs/1804.00633)\n", + "\n", + "[4] Schuld, Maria. Supervised quantum machine learning models are kernel methods. [arXiv preprint arXiv:2101.11020 (2021).](https://arxiv.org/pdf/2101.11020)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.8.13" + }, + "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": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/machine_learning/QGAN_CN.ipynb b/tutorials/machine_learning/QGAN_CN.ipynb similarity index 53% rename from tutorial/machine_learning/QGAN_CN.ipynb rename to tutorials/machine_learning/QGAN_CN.ipynb index 80ec8d9..c6a4bf8 100644 --- a/tutorial/machine_learning/QGAN_CN.ipynb +++ b/tutorials/machine_learning/QGAN_CN.ipynb @@ -192,7 +192,7 @@ "\n", "对于判别器得到的量子态，我们还需要采用泡利 Z 门对第3个量子比特进行测量，从而得到判别器对输入量子态的判断结果（即判别器认为输入是目标态的概率）。首先有 $M_{z}=I\\otimes I\\otimes\\sigma_{z}$，而测量结果为 $\\text{disc_output}=\\langle\\phi|M_{z}|\\phi\\rangle$，所以测量结果为目标态的概率是 $P=(\\text{disc_output}+1)/2$。\n", "\n", - "我们定义判别器的损失函数为 $\\mathcal{L}_D=P_{G}(\\text{gen_theta}, \\text{disc_phi})-P_{T}(\\text{disc_phi})$，生成器的损失函数为 $\\mathcal{L}_{G}=-P_{G}(\\text{gen_theta}, \\text{disc_phi})$。这里的 $P_{G}$ 和 $P_{T}$ 分别是输入量子态为生成态和目标态时，$P=(\\text{disc_output}+1)/2$ 的表达式，gen_theta 和 disc_phi 分别是生成器和判别器线路的参数。\n", + "我们定义判别器的损失函数为 $\\mathcal{L}_D=P_{G}(\\text{gen_theta}, \\text{disc_phi})-P_{T}(\\text{disc_phi})$，生成器的损失函数为 $\\mathcal{L}_{G}=-P_{G}(\\text{gen_theta}, \\text{disc_phi})$。这里的 $P_{G}$ 和 $P_{T}$ 分别是输入量子态为生成态和目标态时，$P=(\\text{disc_output}+1)/2$ 的表达式，gen\\_theta 和 disc\\_phi 分别是生成器和判别器线路的参数。\n", "\n", "因此我们只需要分别优化目标函数 $\\min_{\\text{disc_phi}}\\mathcal{L}_{D}$ 和 $\\min_{\\text{gen_theta}}\\mathcal{L}_{G}$ 即可交替训练判别器和生成器。" ] @@ -213,15 +213,23 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", + "import scipy\n", + "import warnings\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import partial_trace, dagger, state_fidelity\n", - "from tqdm import tqdm" + "import paddle_quantum\n", + "from paddle_quantum.state import zero_state\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum import Hamiltonian\n", + "from paddle_quantum.loss import ExpecVal\n", + "from paddle_quantum.qinfo import partial_trace\n", + "from tqdm import tqdm\n", + "\n", + "warnings.filterwarnings(\"ignore\")" ] }, { @@ -233,68 +241,40 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "class QGAN(paddle.nn.Layer):\n", - " def __init__(self):\n", - " super(QGAN, self).__init__()\n", - " \n", - " # 用以制备目标量子态的角度\n", - " target_omega_0 = 0.9 * np.pi\n", - " target_omega_1 = 0.2 * np.pi\n", - " self.target_omega = paddle.to_tensor(\n", - " np.array([target_omega_0, target_omega_1], np.float64))\n", - " \n", - " # 生成器和判别器电路的参数\n", - " self.gen_theta = self.create_parameter([9], \n", - " dtype=\"float64\", default_initializer=paddle.nn.initializer.Uniform(\n", - " low=0.0, high=np.pi))\n", - " self.disc_phi = self.create_parameter([9], \n", - " dtype=\"float64\", default_initializer=paddle.nn.initializer.Uniform(\n", - " low=0.0, high=np.pi))\n", - " \n", - " # 制备目标量子态\n", - " cir = UAnsatz(3)\n", - " cir.ry(self.target_omega[0], 0)\n", - " cir.rz(self.target_omega[1], 0)\n", - " self.target_state = cir.run_state_vector()\n", + "# 设置模拟方式为密度矩阵\n", + "paddle_quantum.set_backend('density_matrix')\n", "\n", - " def generator(self, theta):\n", - " \"\"\"\n", - " 生成器的量子线路\n", - " \"\"\"\n", - " cir = UAnsatz(3)\n", - " cir.u3(*theta[:3], 0)\n", - " cir.u3(*theta[3:6], 1)\n", - " cir.cnot([0, 1])\n", - " cir.u3(*theta[6:], 0)\n", "\n", - " return cir\n", + "class QGAN(paddle_quantum.gate.Gate):\n", + " def __init__(self, target_state):\n", + " super().__init__()\n", + " self.target_state = target_state.clone()\n", "\n", - " def discriminator(self, phi):\n", - " \"\"\"\n", - " 判别器的量子线路\n", - " \"\"\"\n", - " cir = UAnsatz(3)\n", - " cir.u3(*phi[:3], 0)\n", - " cir.u3(*phi[3:6], 2)\n", - " cir.cnot([0, 2])\n", - " cir.u3(*phi[6:], 0)\n", + " # 生成器的量子电路\n", + " self.generator = Circuit(3)\n", + " self.generator.u3([0, 1])\n", + " self.generator.cnot([0, 1])\n", + " self.generator.u3(0)\n", "\n", - " return cir\n", + " # 判别器的量子电路\n", + " self.discriminator = Circuit(3)\n", + " self.discriminator.u3([0, 2])\n", + " self.discriminator.cnot([0, 2])\n", + " self.discriminator.u3(0)\n", "\n", " def disc_target_as_target(self):\n", " \"\"\"\n", " 判别器将目标态判断为目标态的概率\n", " \"\"\"\n", - " # 判别器电路\n", - " cir = self.discriminator(self.disc_phi)\n", - " cir.run_state_vector(self.target_state)\n", + " state = self.discriminator(self.target_state)\n", + " expec_val_func = ExpecVal(Hamiltonian([[1.0, 'z2']]))\n", " \n", " # 判别器对目标态的判断结果\n", - " target_disc_output = cir.expecval([[1.0, 'z2']])\n", + " target_disc_output = expec_val_func(state)\n", " prob_as_target = (target_disc_output + 1) / 2\n", "\n", " return prob_as_target\n", @@ -304,13 +284,13 @@ " 判别器将生成态判断为目标态的概率\n", " \"\"\"\n", " # 得到生成器生成的量子态\n", - " gen_state = self.generator(\n", - " self.gen_theta).run_state_vector()\n", + " gen_state = self.generator()\n", + "\n", " # 判别器电路\n", - " cir = self.discriminator(self.disc_phi)\n", - " cir.run_state_vector(gen_state)\n", + " state = self.discriminator(gen_state)\n", " # 判别器对生成态的判断结果\n", - " gen_disc_output = cir.expecval([[1.0, 'z2']])\n", + " expec_val_func = ExpecVal(Hamiltonian([[1.0, 'z2']]))\n", + " gen_disc_output = expec_val_func(state)\n", " prob_as_target = (gen_disc_output + 1) / 2\n", " \n", " return prob_as_target\n", @@ -331,10 +311,7 @@ " \"\"\"\n", " 得到目标态的密度矩阵表示\n", " \"\"\"\n", - " state = self.target_state\n", - " state = paddle.reshape(state, [1] + state.shape)\n", - " density_matrix = paddle.matmul(dagger(state), state)\n", - " state = partial_trace(density_matrix, 2, 4, 2)\n", + " state = partial_trace(self.target_state, 2, 4, 2)\n", "\n", " return state.numpy()\n", "\n", @@ -342,10 +319,8 @@ " \"\"\"\n", " 得到生成态的密度矩阵表示\n", " \"\"\"\n", - " state = self.generator(self.gen_theta).run_state_vector()\n", - " state = paddle.reshape(state, [1] + state.shape)\n", - " density_matrix = paddle.matmul(dagger(state), state)\n", - " state = partial_trace(density_matrix, 2, 4, 2)\n", + " state = self.generator()\n", + " state = partial_trace(state, 2, 4, 2)\n", "\n", " return state.numpy()" ] @@ -359,14 +334,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Training: 100%|#################################################| 1050/1050 [01:27<00:00, 12.01it/s]\n" + "Training: 100%|#################################################| 2250/2250 [00:39<00:00, 57.65it/s]\n" ] }, { @@ -374,16 +349,16 @@ "output_type": "stream", "text": [ "the density matrix of the target state:\n", - "[[0.02447174+0.00000000e+00j 0.125 +9.08178160e-02j]\n", - " [0.125 -9.08178160e-02j 0.97552826+5.16498656e-18j]] \n", + "[[0.02447175+0.j 0.12500004-0.09081785j]\n", + " [0.12500004+0.09081785j 0.97552836+0.j ]] \n", "\n", "the density matrix of the generated state:\n", - "[[0.0244643 -5.29696618e-19j 0.12657544+8.85689120e-02j]\n", - " [0.12657544-8.85689120e-02j 0.9755357 -2.82739625e-19j]] \n", + "[[0.02444258+3.7252903e-09j 0.12302095-9.3332648e-02j]\n", + " [0.12302095+9.3332678e-02j 0.97555757-7.4505806e-09j]] \n", "\n", - "the distance between these two quantum states is 1.5079277656078345e-05 \n", + "the distance between these two quantum states is 2.0483967e-05 \n", "\n", - "the fidelity between these two quantum states is 0.9999962306522913\n" + "the fidelity between these two quantum states is 0.9999947358758301\n" ] } ], @@ -391,20 +366,26 @@ "# 学习率\n", "LR = 0.1\n", "# 总的迭代次数\n", - "ITR = 15\n", + "ITR = 25\n", "# 每次迭代时，判别器的迭代次数\n", - "ITR1 = 20\n", + "ITR1 = 40\n", "# 每次迭代时，生成器的迭代次数\n", "ITR2 = 50\n", "\n", + "# 制备目标量子态\n", + "target_state = zero_state(num_qubits=3)\n", + "target_state = paddle_quantum.gate.RY(0, param=0.9 * np.pi)(target_state)\n", + "target_state = paddle_quantum.gate.RZ(0, param=0.2 * np.pi)(target_state)\n", + "target_state.data = paddle.to_tensor(target_state.data.numpy())\n", + "\n", "# 用来记录loss值的变化\n", "loss_history = list()\n", "paddle.seed(18)\n", - "gan_demo = QGAN()\n", + "gan_demo = QGAN(target_state)\n", "optimizer = paddle.optimizer.SGD(learning_rate=LR, parameters=gan_demo.parameters())\n", "pbar = tqdm(desc=\"Training: \", total=ITR * (ITR1 + ITR2), ncols=100, ascii=True)\n", "for itr0 in range(ITR):\n", - "\n", + " \n", " # 记录判别器loss值的变化\n", " loss_disc_history = list()\n", "\n", @@ -413,8 +394,10 @@ " pbar.update(1)\n", " loss_disc = gan_demo('disc')\n", " loss_disc.backward()\n", - " optimizer.minimize(loss_disc, parameters=[gan_demo.disc_phi],\n", - " no_grad_set=[gan_demo.gen_theta])\n", + " optimizer.minimize(\n", + " loss_disc, parameters=gan_demo.discriminator.parameters(),\n", + " no_grad_set=gan_demo.generator.parameters()\n", + " )\n", " gan_demo.clear_gradients()\n", " loss_disc_history.append(loss_disc.numpy()[0])\n", "\n", @@ -426,8 +409,10 @@ " pbar.update(1)\n", " loss_gen = gan_demo('gen')\n", " loss_gen.backward()\n", - " optimizer.minimize(loss_gen, parameters=[gan_demo.gen_theta],\n", - " no_grad_set=[gan_demo.disc_phi])\n", + " optimizer.minimize(\n", + " loss_gen, parameters=gan_demo.generator.parameters(),\n", + " no_grad_set=gan_demo.discriminator.parameters()\n", + " )\n", " optimizer.clear_grad()\n", " loss_gen_history.append(loss_gen.numpy()[0])\n", "\n", @@ -446,10 +431,12 @@ "\n", "# 计算两个量子态之间的距离，\n", "# 这里的距离定义为 tr[(target_state-gen_state)^2]\n", - "distance = np.trace(np.matmul(target_state-gen_state, \n", - " target_state-gen_state)).real\n", + "distance = np.trace(np.matmul(target_state-gen_state, target_state-gen_state)).real\n", "# 计算两个量子态的保真度\n", - "fidelity = state_fidelity(target_state, gen_state)\n", + "# fidelity = state_fidelity(target_state, gen_state)\n", + "fidelity = np.trace(\n", + " scipy.linalg.sqrtm(scipy.linalg.sqrtm(target_state) @ gen_state @ scipy.linalg.sqrtm(gen_state))\n", + ").real\n", "print(\"the distance between these two quantum states is\", distance, \"\\n\")\n", "print(\"the fidelity between these two quantum states is\", fidelity)" ] @@ -479,7 +466,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -497,12 +484,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -594,7 +581,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.8.0" }, "toc": { "base_numbering": 1, diff --git a/tutorial/machine_learning/QGAN_EN.ipynb b/tutorials/machine_learning/QGAN_EN.ipynb similarity index 55% rename from tutorial/machine_learning/QGAN_EN.ipynb rename to tutorials/machine_learning/QGAN_EN.ipynb index 937f65f..5956eee 100644 --- a/tutorial/machine_learning/QGAN_EN.ipynb +++ b/tutorials/machine_learning/QGAN_EN.ipynb @@ -199,7 +199,7 @@ "\n", "For the quantum state obtained by the discriminator, we also need to use the Pauli Z gate to measure the third qubit so as to obtain the judgment result of the input quantum state by the discriminator (that is, the probability that the discriminator thinks the input is the target state). First there is $M_{z}=I\\otimes I\\otimes\\sigma_{z}$, and the measurement result is $\\text{disc_output}=\\langle\\phi|M_{z}|\\phi\\rangle$, so the probability of the measurement that the result is the target state is $P=(\\text{disc_output}+1)/2$.\n", "\n", - "We define the loss function of the discriminator as $\\mathcal{L}_{D}=P_{G}(\\text{gen_theta}, \\text{disc_phi})-P_{T}(\\text{disc_phi})$, The loss function of the generator is $\\mathcal{L}_{G}=-P_{G}(\\text{gen_theta}, \\text{disc_phi})$. Here, $P_{G}$ and $P_{T}$ are the expressions of $P=(\\text{disc_output}+1)/2$, when the input quantum state is the generated state and the target state, respectively. gen_theta and disc_phi are the parameters of the generator and discriminator circuits.\n", + "We define the loss function of the discriminator as $\\mathcal{L}_{D}=P_{G}(\\text{gen_theta}, \\text{disc_phi})-P_{T}(\\text{disc_phi})$, The loss function of the generator is $\\mathcal{L}_{G}=-P_{G}(\\text{gen_theta}, \\text{disc_phi})$. Here, $P_{G}$ and $P_{T}$ are the expressions of $P=(\\text{disc_output}+1)/2$, when the input quantum state is the generated state and the target state, respectively. gen\\_theta and disc\\_phi are the parameters of the generator and discriminator circuits.\n", "\n", "So we only need to optimize the objective function $\\min_{\\text{disc_phi}}\\mathcal{L}_{D}$ and $\\min_{\\text{gen_theta}}\\mathcal{L}_{G}$ respectively. The discriminator and generator can be alternately trained." ] @@ -220,7 +220,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-01-09T10:49:41.308412Z", @@ -230,10 +230,18 @@ "outputs": [], "source": [ "import numpy as np\n", + "import scipy\n", + "import warnings\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import partial_trace, dagger, state_fidelity\n", - "from tqdm import tqdm" + "import paddle_quantum\n", + "from paddle_quantum.state import zero_state\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum import Hamiltonian\n", + "from paddle_quantum.loss import ExpecVal\n", + "from paddle_quantum.qinfo import partial_trace\n", + "from tqdm import tqdm\n", + "\n", + "warnings.filterwarnings(\"ignore\")" ] }, { @@ -245,7 +253,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-01-09T10:49:43.091496Z", @@ -254,64 +262,36 @@ }, "outputs": [], "source": [ - "class QGAN(paddle.nn.Layer):\n", - " def __init__(self):\n", - " super(QGAN, self).__init__()\n", - " \n", - " # The angle used to prepare the target quantum state\n", - " target_omega_0 = 0.9 * np.pi\n", - " target_omega_1 = 0.2 * np.pi\n", - " self.target_omega = paddle.to_tensor(\n", - " np.array([target_omega_0, target_omega_1], np.float64))\n", - " \n", - " # Generator and discriminator circuit parameters\n", - " self.gen_theta = self.create_parameter([9], \n", - " dtype=\"float64\", default_initializer=paddle.nn.initializer.Uniform(\n", - " low=0.0, high=np.pi))\n", - " self.disc_phi = self.create_parameter([9], \n", - " dtype=\"float64\", default_initializer=paddle.nn.initializer.Uniform(\n", - " low=0.0, high=np.pi))\n", - " \n", - " # Prepare target quantum state\n", - " cir = UAnsatz(3)\n", - " cir.ry(self.target_omega[0], 0)\n", - " cir.rz(self.target_omega[1], 0)\n", - " self.target_state = cir.run_state_vector()\n", + "# set the backend to density_matrix\n", + "paddle_quantum.set_backend('density_matrix')\n", "\n", - " def generator(self, theta):\n", - " \"\"\"\n", - " Generator quantum circuit\n", - " \"\"\"\n", - " cir = UAnsatz(3)\n", - " cir.u3(*theta[:3], 0)\n", - " cir.u3(*theta[3:6], 1)\n", - " cir.cnot([0, 1])\n", - " cir.u3(*theta[6:], 0)\n", "\n", - " return cir\n", + "class QGAN(paddle_quantum.gate.Gate):\n", + " def __init__(self, target_state):\n", + " super().__init__()\n", + " self.target_state = target_state.clone()\n", "\n", - " def discriminator(self, phi):\n", - " \"\"\"\n", - " Quantum circuit of the discriminator\n", - " \"\"\"\n", - " cir = UAnsatz(3)\n", - " cir.u3(*phi[:3], 0)\n", - " cir.u3(*phi[3:6], 2)\n", - " cir.cnot([0, 2])\n", - " cir.u3(*phi[6:], 0)\n", + " # Quantum circuit of generator\n", + " self.generator = Circuit(3)\n", + " self.generator.u3([0, 1])\n", + " self.generator.cnot([0, 1])\n", + " self.generator.u3(0)\n", "\n", - " return cir\n", + " # Quantum circuit of the discriminator\n", + " self.discriminator = Circuit(3)\n", + " self.discriminator.u3([0, 2])\n", + " self.discriminator.cnot([0, 2])\n", + " self.discriminator.u3(0)\n", "\n", " def disc_target_as_target(self):\n", " \"\"\"\n", " The probability that the discriminator judges the target state as the target state\n", " \"\"\"\n", - " # Discriminator circuit\n", - " cir = self.discriminator(self.disc_phi)\n", - " cir.run_state_vector(self.target_state)\n", - "\n", + " state = self.discriminator(self.target_state)\n", + " expec_val_func = ExpecVal(Hamiltonian([[1.0, 'z2']]))\n", + " \n", " # The judgment result of the discriminator on the target state\n", - " target_disc_output = cir.expecval([[1.0,'z2']])\n", + " target_disc_output = expec_val_func(state)\n", " prob_as_target = (target_disc_output + 1) / 2\n", "\n", " return prob_as_target\n", @@ -321,25 +301,25 @@ " The probability that the discriminator judges the generated state as the target state\n", " \"\"\"\n", " # Get the quantum state generated by the generator\n", - " gen_state = self.generator(\n", - " self.gen_theta).run_state_vector()\n", - " # Discriminator circuit\n", - " cir = self.discriminator(self.disc_phi)\n", - " cir.run_state_vector(gen_state)\n", + " gen_state = self.generator()\n", + "\n", + " state = self.discriminator(gen_state)\n", " # The judgment result of the discriminator on the generated state\n", - " gen_disc_output = cir.expecval([[1.0,'z2']])\n", + " expec_val_func = ExpecVal(Hamiltonian([[1.0, 'z2']]))\n", + " gen_disc_output = expec_val_func(state)\n", " prob_as_target = (gen_disc_output + 1) / 2\n", "\n", " return prob_as_target\n", "\n", " def forward(self, model_name):\n", - " if model_name =='gen':\n", - " # Calculate the loss function of the generator, the interval of the loss value is [-1, 0],\n", - " # 0 means extremely poor generation effect, -1 means excellent generation effect\n", + " if model_name == 'gen':\n", + " # Calculate the loss function of the generator, the interval of the loss value is [-1, 0],\n", + " # 0 means extremely poor generation effect, -1 means excellent generation effect\n", " loss = -1 * self.disc_gen_as_target()\n", " else:\n", - " # Calculate the loss function of the discriminator, the loss value range is [-1, 1],\n", - " # -1 means perfect distinction, 0 means indistinguishable, 1 means inverted distinction\n", + " # Calculate the loss function of the discriminator, the loss value range is [-1, 1],\n", + " # -1 means perfect distinction, 0 means indistinguishable, 1 means inverted distinction\n", + " loss = self.disc_gen_as_target() - self.disc_target_as_target()\n", " loss = self.disc_gen_as_target() - self.disc_target_as_target()\n", "\n", " return loss\n", @@ -348,10 +328,7 @@ " \"\"\"\n", " Get the density matrix representation of the target state\n", " \"\"\"\n", - " state = self.target_state\n", - " state = paddle.reshape(state, [1] + state.shape)\n", - " density_matrix = paddle.matmul(dagger(state), state)\n", - " state = partial_trace(density_matrix, 2, 4, 2)\n", + " state = partial_trace(self.target_state, 2, 4, 2)\n", "\n", " return state.numpy()\n", "\n", @@ -359,11 +336,8 @@ " \"\"\"\n", " Get the density matrix representation of the generated state\n", " \"\"\"\n", - " state = self.generator(\n", - " self.gen_theta).run_state_vector()\n", - " state = paddle.reshape(state, [1] + state.shape)\n", - " density_matrix = paddle.matmul(dagger(state), state)\n", - " state = partial_trace(density_matrix, 2, 4, 2)\n", + " state = self.generator()\n", + " state = partial_trace(state, 2, 4, 2)\n", "\n", " return state.numpy()" ] @@ -377,7 +351,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2021-01-09T10:52:15.221809Z", @@ -389,7 +363,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "Training: 100%|#################################################| 1050/1050 [01:31<00:00, 11.51it/s]\n" + "Training: 100%|#################################################| 2250/2250 [00:57<00:00, 39.44it/s]\n" ] }, { @@ -397,16 +371,16 @@ "output_type": "stream", "text": [ "the density matrix of the target state:\n", - "[[0.02447174+0.00000000e+00j 0.125 +9.08178160e-02j]\n", - " [0.125 -9.08178160e-02j 0.97552826+5.16498656e-18j]] \n", + "[[0.02447175+0.j 0.12500004-0.09081785j]\n", + " [0.12500004+0.09081785j 0.97552836+0.j ]] \n", "\n", "the density matrix of the generated state:\n", - "[[0.0244643 -5.29696618e-19j 0.12657544+8.85689120e-02j]\n", - " [0.12657544-8.85689120e-02j 0.9755357 -2.82739625e-19j]] \n", + "[[0.02444258+3.7252903e-09j 0.12302095-9.3332648e-02j]\n", + " [0.12302095+9.3332678e-02j 0.97555757-7.4505806e-09j]] \n", "\n", - "the distance between these two quantum states is 1.5079277656078345e-05 \n", + "the distance between these two quantum states is 2.0483967e-05 \n", "\n", - "the fidelity between these two quantum states is 0.9999962306522913\n" + "the fidelity between these two quantum states is 0.9999947358758301\n" ] } ], @@ -414,16 +388,22 @@ "# Learning rate\n", "LR = 0.1\n", "# Total number of iterations\n", - "ITR = 15\n", + "ITR = 25\n", "# In each iteration, the number of iterations of the discriminator\n", - "ITR1 = 20\n", + "ITR1 = 40\n", "# In each iteration, the number of generator iterations\n", "ITR2 = 50\n", "\n", + "# prepare the target quantum state\n", + "target_state = zero_state(num_qubits=3)\n", + "target_state = paddle_quantum.gate.RY(0, param=0.9 * np.pi)(target_state)\n", + "target_state = paddle_quantum.gate.RZ(0, param=0.2 * np.pi)(target_state)\n", + "target_state.data = paddle.to_tensor(target_state.data.numpy())\n", + "\n", "# Used to record the change of loss value\n", "loss_history = list()\n", "paddle.seed(18)\n", - "gan_demo = QGAN()\n", + "gan_demo = QGAN(target_state)\n", "optimizer = paddle.optimizer.SGD(learning_rate=LR, parameters=gan_demo.parameters())\n", "pbar = tqdm(desc=\"Training: \", total=ITR * (ITR1 + ITR2), ncols=100, ascii=True)\n", "for itr0 in range(ITR):\n", @@ -436,9 +416,10 @@ " pbar.update(1)\n", " loss_disc = gan_demo('disc')\n", " loss_disc.backward()\n", - " optimizer.minimize(loss_disc, parameters\n", - " =[gan_demo.disc_phi],\n", - " no_grad_set=[gan_demo.gen_theta])\n", + " optimizer.minimize(\n", + " loss_disc, parameters=gan_demo.discriminator.parameters(),\n", + " no_grad_set=gan_demo.generator.parameters()\n", + " )\n", " gan_demo.clear_gradients()\n", " loss_disc_history.append(loss_disc.numpy()[0])\n", "\n", @@ -450,12 +431,14 @@ " pbar.update(1)\n", " loss_gen = gan_demo('gen')\n", " loss_gen.backward()\n", - " optimizer.minimize(loss_gen, parameters\n", - " =[gan_demo.gen_theta],\n", - " no_grad_set=[gan_demo.disc_phi])\n", + " optimizer.minimize(\n", + " loss_gen, parameters=gan_demo.generator.parameters(),\n", + " no_grad_set=gan_demo.discriminator.parameters()\n", + " )\n", " optimizer.clear_grad()\n", " loss_gen_history.append(loss_gen.numpy()[0])\n", "\n", + "\n", " loss_history.append((loss_disc_history, loss_gen_history))\n", "pbar.close()\n", "\n", @@ -471,10 +454,11 @@ "\n", "# Calculate the distance between two quantum states,\n", "# The distance here is defined as tr[(target_state-gen_state)^2]\n", - "distance = np.trace(np.matmul(target_state-gen_state,\n", - " target_state-gen_state)).real\n", + "distance = np.trace(np.matmul(target_state-gen_state, target_state-gen_state)).real\n", "# Calculate the fidelity of two quantum states\n", - "fidelity = state_fidelity(target_state, gen_state)\n", + "fidelity = np.trace(\n", + " scipy.linalg.sqrtm(scipy.linalg.sqrtm(target_state) @ gen_state @ scipy.linalg.sqrtm(gen_state))\n", + ").real\n", "print(\"the distance between these two quantum states is\", distance, \"\\n\")\n", "print(\"the fidelity between these two quantum states is\", fidelity)" ] @@ -504,7 +488,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -522,12 +506,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -619,7 +603,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.0" }, "toc": { "base_numbering": 1, diff --git a/tutorials/machine_learning/QKernel_CN.ipynb b/tutorials/machine_learning/QKernel_CN.ipynb new file mode 100644 index 0000000..7d16710 --- /dev/null +++ b/tutorials/machine_learning/QKernel_CN.ipynb @@ -0,0 +1,754 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "instructional-length", + "metadata": {}, + "source": [ + "# 量子核方法\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "id": "desirable-compatibility", + "metadata": {}, + "source": [ + "## 概览\n", + "\n", + "在量子机器学习中，参数化量子电路（parameterized quantum circuit）扮演着重要的角色。在很多场景中，为了类比经典机器学习领域中的神经网络方法，我们也经常会把参数化量子电路称为量子神经网络。但是实际上，在量子机器学习的相关应用中，人们发现参数化量子电路的数学原理更类似于经典机器学习中的核方法（kernel methods）[1]。这种通过将量子计算和经典核方法相结合的思路以及研究方法，就被称为量子核方法（quantum kernel methods）。这两种方法的结合对于量子计算如何更好的解决一系列机器学习问题提供了全新的视角，因此在近年来收到了极大的关注 [2-7]。在本教程中，我们将探究如何用量子核方法结合支持向量机来实现数据分类。\n", + "\n", + "### 理论背景\n", + "\n", + "在经典机器学习中，核方法一般指的是将低维的数据向量通过特征映射（feature map）映射到高维的特征空间（feature space）中，来识别低维数据中难以分辨的模式的方法。如图1的例子所示，通过将一维的线性不可分数据映射到二维，映射后的数据在二维空间中是线性可分的。\n", + "\n", + "![feature map](./figures/Qkernel-fig-featuremap.png \"图1：核方法中的特征映射\")\n", + "
图1：核方法中的特征映射
\n", + "\n", + "不过，在实际应用中，由于特征空间的维数可能会十分巨大，我们往往并不希望直接对映射后的特征向量进行分析。相反，通过核方法中的另一个核心概念-核函数（kernel function），我们可以隐式地引入特征映射在模式识别上的优势。核函数的定义为数据向量在特征空间里的内积，其具体形式为\n", + "\n", + "$$\n", + "K(\\mathbf{x}_i, \\mathbf{x}_j) = \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i),\n", + "\\tag{1}\n", + "$$\n", + "\n", + "其中 $\\phi()$ 就代表着特征映射。需要注意的是，在核方法中我们并不需要显式地写出特征映射，而只需要定义核函数的形式即可。\n", + "\n", + "在经典机器学习中，核方法最具代表性的应用就是支持向量机（support vector machine, SVM）。简单的来说，支持向量机解决的是线性分类问题：以一个二分类的问题举例，我们的数据集为 $T = \\{ (\\mathbf{x}_1, y_1), ..., (\\mathbf{x}_m, y_m) \\} \\subset \\mathcal{X}\\times\\mathbb{Z}_2$，通过一个超平面 $(\\mathbf{w}, b)$，支持向量机可以通过如下决策函数的正负来预测每个数据点 $\\mathbf{x}$ 的标签：\n", + "\n", + "$$\n", + "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}, \\mathbf{x} \\rangle + b).\n", + "\\tag{2}\n", + "$$\n", + "\n", + "但是对于在原始数据空间中线性不可分的数据而言，这样的做法往往并不可行。所以如图1所示，通过引入我们上文中提到的特征映射，我们可以将原始数据空间中的数据向量映射到特征空间中来进行分类，从而得到更好的分类效果。此时，我们标记特征空间中的超平面为 $(\\mathbf{w}', b')$, 我们的决策函数就变成了：\n", + "\n", + "$$\n", + "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}', \\phi(\\mathbf{x}) \\rangle + b').\n", + "\\tag{3}\n", + "$$\n", + "\n", + "更进一步的是，我们可以通过对偶化的方法，引入拉格朗日乘子 $\\alpha_i$ 来表示此时的分割超平面 $\\mathbf{w}' = \\sum_i \\alpha_i \\phi(\\mathbf{x_i})$ [8]。此时，我们可以在 $\\alpha_i \\geq 0$，$\\sum_i y_i \\alpha_i=0$ 的约束下，通过最大化\n", + "\n", + "$$\n", + "\\sum_i \\alpha_i - \\frac{1}{2} \\sum_{i, j} \\alpha_i \\alpha_j y_i y_j \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i)\n", + "\\tag{4}\n", + "$$\n", + "\n", + "来计算最优参数 $\\alpha_i^*$。不难发现，此时我们只需要计算数据向量在特征空间里的内积 $\\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i) = K(x_i, x_j)$，正是我们上文中提到的核函数。换言之，在支持向量机中，我们不需要显式地知道特征映射的形式，而只需要计算原始数据在特征空间里的内积，就可以实现在特征空间中对数据进行分类。并且，对于任何新的数据向量 $\\mathbf{x}'$，我们只需要通过核函数 $K(,)$ 计算\n", + "\n", + "$$\n", + "y_{\\rm pred} = {\\rm sign}(\\sum_i \\alpha^*_i \\langle \\phi(\\mathbf{x_i}), \\phi(\\mathbf{x}' \\rangle + b') = \n", + "{\\rm sign}(\\sum_i \\alpha^*_i K(\\mathbf{x}_i, \\mathbf{x}') + b'),\n", + "\\tag{5}\n", + "$$\n", + "\n", + "就可以对数据的标签进行预测。\n", + "\n", + "借助这种思想，我们就可以很简单的理解量子核方法的内涵。首先，我们引入量子特征空间的概念，即我们认为我们通过一个编码电路 $U(\\mathbf{x}) $ 将经典数据向量 $\\mathbf{x} $ 编码到某个量子态 $| \\phi(\\mathbf{x}) \\rangle$ 上：\n", + "\n", + "$$\n", + "U(\\mathbf{x}) | 0^{\\otimes N} \\rangle = | \\phi(\\mathbf{x}) \\rangle.\n", + "\\tag{6}\n", + "$$ \n", + "\n", + "关于编码电路的具体形式我们这里不做展开，感兴趣的读者可以阅读我们的[编码教程](./DataEncoding_CN.ipynb)来了解不同的量子编码电路形式。此时我们的量子特征映射就是从经典数据空间到量子态所处的希尔伯特空间的一种特殊特征映射。在这个基础上，我们将量子核函数（quantum kernel function）定义为经典数据向量在量子特征空间的内积，其具体形式就为\n", + "\n", + "$$\n", + "K^Q_{ij} = |\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2,\n", + "\\tag{7}\n", + "$$\n", + "\n", + "上式可以进一步写为\n", + "\n", + "$$\n", + "|\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2 = |\\langle 0^{\\otimes N} | U^\\dagger(\\mathbf{x}_j) U(\\mathbf{x}_i) | 0^{\\otimes N} \\rangle |^2.\n", + "\\tag{8}\n", + "$$\n", + "\n", + "不难发现，通过运行如图2中所示的量子电路，并在统计其测量结果为 $| 0^{\\otimes N} \\rangle $ 的概率，我们就可以估计式（8）中的量子核函数。这种方法也被称为量子核估计（quantum kernel estimation, QKE）方法。也就是说，如果我们通过量子核估计方法来计算式（4-5) 中的核函数的话，我们就可以利用支持向量机的方法在量子特征空间来完成数据分类。借助量子特征映射的量子性，人们希望这种量子核方法可以更好地分类具有复杂模式的数据。人们已经证明，通过精心设计量子特征映射，量子核方法就可以用来分辨任何经典方法都无法识别的数据模式 [3]。\n", + "\n", + "![QKE](./figures/Qkernel-fig-QKE.png \"图2：量子核估计电路\")\n", + "
图2：量子核估计电路
\n", + "\n", + "![illustration](./figures/Qkernel-fig-illustrationCN.png \"图3：经典核方法和量子核方法的对比示意图\")\n", + "
图3：经典核方法和量子核方法的对比示意图
" + ] + }, + { + "cell_type": "markdown", + "id": "willing-shopping", + "metadata": {}, + "source": [ + "### 拓展：量子机器学习和核方法的联系\n", + "\n", + "在量子机器学习中，往往我们量子电路中的一部分需要将经典的数据编码到其对应的量子态上，其数学形式为：\n", + "\n", + "$$\n", + "| \\phi(x) \\rangle = U (x) | 0^{\\otimes N} \\rangle,\n", + "\\tag{9}\n", + "$$\n", + "\n", + "其中 $U(x)$ 是一个取决于经典数据 $x$ 的参数化电路。正如我们上文中提到的，这种编码的过程可以被考虑成是一种从经典数据空间到量子特征空间的特殊特征映射。同时，考虑一个作用在编码量子态上的量子神经网络电路，其数学形式为：\n", + "\n", + "$$\n", + "| \\psi \\rangle = U_{\\rm QNN}(\\theta)U (\\mathbf{x}) | 0^{\\otimes N} \\rangle,\n", + "\\tag{10}\n", + "$$\n", + "\n", + "其中 $U_{\\rm QNN}(\\theta)$ 为代表量子神经网络的参数化量子电路，$\\theta$ 为其中的参数。我们在电路的最后进行测量，该测量用 $\\mathcal{M}$ 表示。这时，我们测得的期望值为\n", + "\n", + "$$\n", + "\\langle \\mathcal{M} \\rangle = \\langle \\psi | \\mathcal{M} | \\psi \\rangle = \\langle \\phi(\\mathbf{x}) | U^\\dagger_{\\rm QNN}(\\theta) \\mathcal{M} U_{\\rm QNN}(\\theta)| \\phi(\\mathbf{x}) \\rangle.\n", + "\\tag{11}\n", + "$$\n", + "\n", + "我们不妨将测量写成算符的形式 $| \\sigma \\rangle \\langle \\sigma |$ ，那么式（11）就可以进一步被写为\n", + "\n", + "$$\n", + "\\langle \\phi(\\mathbf{x}) | \\sigma'(\\theta) \\rangle \\langle \\sigma' (\\theta) | \\phi(x) \\rangle = \n", + "|\\langle \\sigma' (\\theta) | \\phi(\\mathbf{x}) \\rangle|^2,\n", + "\\tag{12}\n", + "$$\n", + "\n", + "其中 $| \\sigma'(\\theta) \\rangle = U^\\dagger_{\\rm QNN}(\\theta) | \\sigma \\rangle$。这样的话，我们发现我们这种基于量子神经网络的测量结果也可以被认为是量子特征空间中两个量子特征向量的内积：$|\\langle \\sigma' (\\theta) | \\phi(\\mathbf{x}) \\rangle|^2$。\n", + "而该内积，正是我们前文中提到的量子核函数，只不过其中一个特征向量是由一个参数化的测量所描述的。这也就是我们在本教程的一开始提到，量子神经网络模型的数学形式实际上更接近于经典机器学习中的核方法的原因。" + ] + }, + { + "cell_type": "markdown", + "id": "tutorial-vocabulary", + "metadata": {}, + "source": [ + "## 示例：利用量子核方法来解决分类问题\n", + "\n", + "> 本教程需要使用 [`sklearn`](https://scikit-learn.org/stable/install.html) 中的相关函数来实现支持向量机的功能。需要的读者可以运行下面的代码块来安装相关模块：" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "informative-miami", + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import clear_output\n", + "\n", + "!pip install scikit-learn\n", + "clear_output()" + ] + }, + { + "cell_type": "markdown", + "id": "emerging-anxiety", + "metadata": {}, + "source": [ + "下面，我们用一个简单的例子来展示如何在 Paddle Quantum 中模拟量子核估计电路，并将其应用在一个实际的分类任务上。" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "acting-nursery", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import matplotlib\n", + "import numpy as np\n", + "import paddle\n", + "from numpy import pi as PI\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from paddle import matmul, transpose\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.gate import IQPEncoding\n", + "import paddle_quantum\n", + "\n", + "import sklearn\n", + "from sklearn import svm\n", + "from sklearn.datasets import fetch_openml, make_moons, make_circles\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "from IPython.display import clear_output\n", + "from tqdm import tqdm" + ] + }, + { + "cell_type": "markdown", + "id": "fluid-rating", + "metadata": {}, + "source": [ + "首先，我们生成两类线性不可分的二维圆形数据点作为我们的训练集和测试集。" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "turkish-energy", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "先来看一下我们的训练集和测试集:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAEICAYAAAD80ZhHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAoJElEQVR4nO3deZxcVZ338c+3qrfsC9khGyEEAgrGlrCJMBhMUCco6MC4IC4RgXEdhjzqI+qMTtRxF4WgaBxHkBmNRAn7ozKoCAmyhD3EQEIChBAgW6fT3b/nj75NKp3qTndXdd+uqu/79apX3XvOudW/S4XTvz733HMVEZiZmZlZ38ukHYCZmZlZpXIiZmZmZpYSJ2JmZmZmKXEiZmZmZpYSJ2JmZmZmKXEiZmZmZpYSJ2JW0iTdIOnctOMwMzPrCSdi1uckbct5tUjambP/ru58VkTMi4glvRWrmVlHitmXJZ/3e0kf7I1Yrf+qSjsAqzwRMbhtW9Ja4IMRcWv7dpKqIqKpL2MzM+uqrvZlZp3xiJj1G5JOlrRe0iWSngF+LGmEpN9K2iRpS7J9UM4xr/wFKel9ku6Q9B9J279JmpfaCZlZRZKUkbRQ0hOSNku6VtLIpK5O0s+S8hcl3S1prKQvAa8HvpeMqH0v3bOwvuJEzPqbccBIYDKwgNZ/oz9O9icBO4HOOqjZwKPAKOCrwI8kqTcDNjNr56PAGcAbgAnAFuCypO5cYBgwETgAOB/YGRGfAf4XuCgiBkfERX0dtKXDiZj1Ny3ApRGxKyJ2RsTmiPhlROyIiK3Al2jt3DryZERcGRHNwBJgPDC2D+I2M2vzYeAzEbE+InYBnwfOklQF7KY1ATskIpojYmVEvJxirJYyzxGz/mZTRDS07UgaCHwTmAuMSIqHSMomyVZ7z7RtRMSOZDBscJ52Zma9ZTKwVFJLTlkzrX8U/ieto2HXSBoO/IzWpG13n0dp/YJHxKy/iXb7nwJmALMjYihwUlLuy41m1l+tA+ZFxPCcV11EPB0RuyPiCxExEzgeeAvw3uS49v2fVQAnYtbfDaF1XtiLyWTXS1OOx8xsfy4HviRpMoCk0ZLmJ9unSHqVpCzwMq2XKttG958FDk4jYEuPEzHr774FDACeB+4Ebkw1GjOz/fs2sAy4WdJWWvuu2UndOOB/aE3CHgb+QOvlybbjzkru+v5O34ZsaVGER0LNzMzM0uARMTMzM7OUOBEzMzMzS4kTMTMzM7OUOBEzMzMzS0lJLug6atSomDJlStphmFkfWrly5fMRMTrtOArl/sus8nTWf5VkIjZlyhRWrFiRdhhm1ockPZl2DMXg/sus8nTWf/nSpJmZmVlKnIiZmZmZpaQoiZikqyQ9J2lVB/WS9B1JqyXdL2lWTt1cSY8mdQuLEY+ZmZlZKSjWiNhPgLmd1M8DpievBcAPAJJnbV2W1M8EzpE0s0gxmZmZmfVrRZmsHxG3S5rSSZP5wE+j9XlKd0oaLmk8MAVYHRFrACRdk7R9qBhxmRVLRLB67XYaGpqZccgQaqp9Vd/M0tPQ0MyDj76ct+7gyYMYMbymjyOynuqruyYPBNbl7K9PyvKVzyYPSQtoHU1j0qRJvROlWR5PrtvBxV98gBdebCSTEQQs/Oih/N2JY9IOzcwq1P0PvcQnL32AQQOzSHvKdza08IF/nMx73zk5veCsW/rqz3rlKYtOyvctjFgcEfURUT96dMkvJWQlork5+Ohn72Pjsw00NLSwY0czO3Y286VvPcraddvTDs/MKlT90SMYN6aW7Tua2bZ9z6sqK976pvFph2fd0FeJ2HpgYs7+QcCGTsrN+oV7HniRnTubiXZ/HjTtbuG6GzemE5SZVbxMRlxw3jQG1O35NV5TLc6YN4ERw3xZspT0VSK2DHhvcvfkscBLEbERuBuYLmmqpBrg7KStWb/w0su785Y3t8DmFxr7OBozsz1OPn4Uw4ZWv7IviXe/Y2InR1h/VKzlK64G/gzMkLRe0gcknS/p/KTJcmANsBq4ErgAICKagIuAm4CHgWsj4sFixGRWDK+eOYymppZ9yuvqMhz/ugNSiMjMrFXuqJhHw0pXse6aPGc/9QFc2EHdcloTNbN+Z8yoWs58y4EsXb6Bhl2tCVltTYZJEwbyd6/3XEUzS9fJx4/i+z+uZvOWRo+GlaiSfNakWV+64LyDOeqIYfzq+g3s2NnMqa8fzd+/abyXsDCz1GUy4v98dAZPrt/h0bAS5UTMbD8kceLsUZw4e1TaoZiZ7eO1R43gtUeNSDsM6yH/SW9mZmaWEidiZmZmZilxImZmZmaWEidiZmZmZilxImZmZmaWEidiZlbxJM2V9Kik1ZIW5qm/WNK9yWuVpGZJI5O6tZIeSOpW9H30ZlbKvHyFmVU0SVngMmAOrc+/vVvSsoh4qK1NRHwN+FrS/q3AJyLihZyPOSUinu/DsM2sTHhEzMwq3THA6ohYExGNwDXA/E7anwNc3SeRmVnZcyJmZpXuQGBdzv76pGwfkgYCc4Ff5hQHcLOklZIW9FqUZlaWfGnSzCqd8pRFB23fCvyx3WXJEyJig6QxwC2SHomI2/f6Aa0J2gKASZMmFSNmMysTHhEzs0q3Hsh9WvJBwIYO2p5Nu8uSEbEheX8OWErrpU7atVkcEfURUT96tB8Wb2Z7OBEzs0p3NzBd0lRJNbQmW8vaN5I0DHgDcF1O2SBJQ9q2gdOAVX0StZmVBV+aNLOKFhFNki4CbgKywFUR8aCk85P6y5OmbwNujojtOYePBZZKgtb+9OcRcWPfRW9mpc6JmJlVvIhYDixvV3Z5u/2fAD9pV7YGOKqXwzOzMuZLk2ZmZmYpKUoi5lWpzczMzLqv4EuTXpXazMzMrGeKMSLmVanNzMzMeqAYiZhXpTYzMzPrgWLcNdnrq1KDV6Y2MzOz8lOMRKxoq1JLaluVep9ELCIWA4sB6uvrO0r0zMxK2q7GFra82LhPuQRjRtWSrFlmZmWiGInYK6tSA0/Tmmz9Y/tGOatSvzunbBCQiYitOatSf7EIMZmZlaQrlqzhf377NDXVe88cadjVwmWLjuaoI4alFJmZ9YaC54hFRBPQtir1w8C1batSt61MnehoVeo7JN0H3AVc71WpzaySveW08VRVZWjY1bLXa8yoWo48bGja4ZlZkRVlZX2vSm1mVhwHTx5E/VHDuXPlC7S0tJYNqMtwwXkHk836sqRZufHK+mZm/cz55x5MVdWe7nnI4GpOOWF0ihGZWW9xImZm1s+0jYplMh4NMyt3TsTMzPqh8889GEkeDTMrc0WZI2ZmZsV18ORBvPW0cRxXf4BHw8zKmBMxM7N+6p8vODTtEMysl/nSpJmZmVlKnIiZmZmZpcSJmJmZmVlKnIiZmZmZpcSJWBc1NDRz9dJ1fPATK/mnT9/H7/64iQg/e9ysHEiaK+lRSaslLcxTf7KklyTdm7w+19Vjzcw647smu6BxdwsfueSvPLV+J7saW5858vDjL3PvqnF84sPTU47OzAohKQtcBswB1gN3S1oWEQ+1a/q/EfGWHh5rZpaXR8S64Hd3bGLdhj1JGEBDQwu/uekZNj7bkGJkZlYExwCrI2JNRDQC1wDz++BYMzMnYl1x58oXaGho2ac8mxX3P/RSChGZWREdCKzL2V+flLV3nKT7JN0g6YjuHCtpgaQVklZs2rSpWHGbWRlwItYFo0bWUJXdt1yCEcOq+z4gMyumfMvWt58Aeg8wOSKOAr4L/LobxxIRiyOiPiLqR4/244rMbA8nYl3w93PHk63a+z+VBAPqssw6akRKUZlZkawHJubsHwRsyG0QES9HxLZkezlQLWlUV441M+uME7EumDhhIF+4+HCGDKpi4IAsdbUZDho/gO9++Siq/Aw4s1J3NzBd0lRJNcDZwLLcBpLGSVKyfQytfefmrhxrZtYZ3zXZRSfOHsVvfjaSx9Zso642y9RJA0n6ZTMrYRHRJOki4CYgC1wVEQ9KOj+pvxw4C/iIpCZgJ3B2tK5fk/fYVE7EzEqSE7FuqKrKMPPQoWmHYWZFllxuXN6u7PKc7e8B3+vqsWZmXVWUS5NeDNHMzMys+woeEfNiiGZmZmY9U4wRMS+GaGZmZtYDxUjEen0xRPCCiGZmZlZ+ipGI9fpiiOAFEc3MzKz8FCMR82KIZmZmZj1QjETMiyGamZmZ9UDBd016MUQzMzOzninKgq5eDNHMzMys+/ysSTMzM7OUOBEzMzMzS4kTMTMzM7OUOBEzMzMzS4kTMTMzM7OUOBEzMzMzS4kTMTMzM7OUOBEzMzMzS4kTMTMzM7OUOBEzMzMzS4kTMTOreJLmSnpU0mpJC/PUv0vS/cnrT5KOyqlbK+kBSfdKWtG3kZtZqSvKsybNzEqVpCxwGTAHWA/cLWlZRDyU0+xvwBsiYoukecBiYHZO/SkR8XyfBW1mZcMjYmZW6Y4BVkfEmohoBK4B5uc2iIg/RcSWZPdO4KA+jtHMypQTMTOrdAcC63L21ydlHfkAcEPOfgA3S1opaUG+AyQtkLRC0opNmzYVHLCZlQ9fmjSzSqc8ZZG3oXQKrYnYiTnFJ0TEBkljgFskPRIRt+/1YRGLab2cSX19fd7PNrPK5BExM6t064GJOfsHARvaN5L0auCHwPyI2NxWHhEbkvfngKW0Xuo0M+sSJ2JmVunuBqZLmiqpBjgbWJbbQNIk4FfAeyLisZzyQZKGtG0DpwGr+ixyMyt5vjRpZhUtIpokXQTcBGSBqyLiQUnnJ/WXA58DDgC+LwmgKSLqgbHA0qSsCvh5RNyYwmlYiVj9lSt47Avf2bdC4pjrf8iok4/t+6AsVUVJxCTNBb5Nayf2w4hY1K7+XcAlye424CMRcV9StxbYCjSzp3MzM+szEbEcWN6u7PKc7Q8CH8xz3BrgqPblZh0ZPedEHv+3y2hp2LVXeXbwQIa/9siUorI0FZyIeQ0eMzPrj+4552M8f9uf9ynPDhrISX9dRvXwoX0e07BZRzDiuNew+fd/gWi9byM7cADTLv4QVUMG93k8lr5izBHzGjxmZtbvDD16Js07G9i95aW9XtXDh1A1bEhqcR2+6F/I1NXuKciIqf/03tTisXQVIxHr9TV4wOvwmJlZ90y58N1kqve+8JMdNJDDv3oJyby+VAybdQQjjj0aJI+GWVESsZ6swXNJTvEJETELmAdcKOmkfMdGxOKIqI+I+tGjRxcas5mZlbmqwYOYdsmHyQ4c8ErZwKkHMeqNJ6QYVavDF/0LmZpqj4ZZURIxr8FjZmb90pQL342yrb/q+sNoWJths45g1KnHM/2zF3o0rMIVIxHzGjxmZtYvtY2KKZvtN6Nhbep/fTnTPrXPzbhWYQpOxCKiCWhbg+dh4Nq2NXja1uFh7zV47pW0IikfC9wh6T7gLuB6r8FjPfXcjX/gjtlv5+bRr+NPbziHzf97d9ohmVk/MOXCd1M9chiHf21hvxgNa9OfYrH0KKL0HntWX18fK1as2H9Dqxgbfnkj9513CS07G14pywyo43XXXc6oU45LMTIrFkkry2GdQfdf6WhpbCRTU5N2GFahOuu//IgjK3kRwcMXL9orCQNo2dnAw5d8NaWozKw/cRJm/ZUTMSt5LY27aXj62bx12x5a3cfRmJmZdZ0TMSt5mZpqqobmv+uodvyYPo7GzMys65yIWcmTxLSLP7TXWkHQ+tiQ6Z+9MKWozMzM9q8oD/02S9u0iz9ENO7mia//iGhqIlNXy6GX/hMTz3172qGZmZl1yImYlQVJTP/shUy7ZAG7t7xM9chhZKr8z9vMzPo3/6ayspKprqZ2zAFph2FmZtYlniNmZmZmlhInYmZmZmYp8aVJK4rG51/gqR/9Ny/edT9DXnUokxecTd2EsWmHZWZm1q85EbOC7fjbOu449iyad+ykpWEXm266nbXf/SnH/e6/GPrqw9IOz8zMrN9yImYFe+if/53dL74MLS0AtOxqpGVXIw9ccCkn3PGLlKMz2z9Jc4FvA1nghxGxqF29kvrTgR3A+yLinq4ca2alLyL4yS+eYsfOpn3qDhw3gDPmTejxZzsRs4JtuuWPryRhuV68+34/aNf6PUlZ4DJgDrAeuFvSsoh4KKfZPGB68poN/ACY3cVjzazERcDS5Rt4YUvjPnVHHTGsoETMk/WtYNkBdXnLVZVF2WwfR2PWbccAqyNiTUQ0AtcA89u1mQ/8NFrdCQyXNL6Lx5pZictkxIffO4UBdXv/TqurzfCR9x1c2GcXdLQZMPH9Z5Gpq92rTLU1THjH6U7ErBQcCKzL2V+flHWlTVeORdICSSskrdi0aVNRgrby17R9B9seXbPv67G/EXmuQljvetMp4xgwYM/vNAkOnTaYIw8bWtDn+tKkFezQSz/K1lWPsfkPd6GqLDS3MOTVh3HEdz6XdmhmXaE8ZdHFNl05lohYDCwGqK+v36feLJ/VX/4Ba77xIzK5Vx0CmrdtZ/bNP2HUKcelF1wFqsq2jop964on2NnQTG1NhgvOm1b45xYhNqtw2bpajvnNlWx9aDVbVz3GoOlTGPaamWmHZdZV64GJOfsHARu62KamC8ea9cikD7yTv31nCc1bt+9VXnfgWA446ZiUoqpsbzplHFf8dC07G5qLMhoGvjRpRTRk5iFMeOfpTsKs1NwNTJc0VVINcDawrF2bZcB71epY4KWI2NjFY816ZODBExk3fw5U7bkclh08kMP+/WJP+0hJ26gYUJTRMChSIiZprqRHJa2WtDBPvSR9J6m/X9Ksrh5rZtabIqIJuAi4CXgYuDYiHpR0vqTzk2bLgTXAauBK4ILOju3jU7AyNuOLHydTtefiVfWwIUx45+kpRmRvOmUciz57RFFGw6AIlyZ967eZlbqIWE5rspVbdnnOdgAXdvVYs2JpGxXb8MsbyNbVejSsH6jKihNnjyra5xVjRMy3fpuZmfWSGV/8OEIeDStTxZisn+/27dldaNPRrd/tjwVab/8GFgBMmjSpsIjNLBURwT33v8j1tzzD7qYWTjt5LCcccwCZTL6bD80MWkfFpn7iPEaeWO/RsDJUjESs12/9Bt/+bVYOvv/jNSxdvoGGXa1rIP155Qsc99qRfPGSmbQ+RcjM8jn8y/+cdgjWS4pxabKQW7+7cqyZlYF1G3bwy+v3JGEADQ0t/HnlC/x11UspRmZmlp5iJGK+9dvM9uuuv25BeQa8d+1q4U93bU4hIjOz9BV8aTIimiS13b6dBa5qu/U7qb+c1juKTqf11u8dwHmdHVtoTGbF0LJ7N2u/95889cNraWnczYSz38wh/7KAqiGD0w6tJA0aUEUmkwGa9yrPZsXgQV5b2swqU1F6P9/6beVoxZkXsvn3f6FlZwMAf/vmj3l22W28/u6lZGpqUo6u9Lz+2AP4+g8e26c8mxGnnTwmhYis0jz4yS+xfsmv9ilXdTXH3341gw+d2q3P+8OrTmfnuo37lA+YPIE33Hd9j+O0yuKV9a0gEcHLDzzKlr/cR0tjY9rhFM1LK1fxwh/ueiUJA2jZ1cjOpzbwzNJbUoysdA0aWMVX/u+RDBqYfeVVV5vh0x+fwYRxA9IOzyrAiONeQ8vuJppe3rbXS9kMA6ce1O3PGzprJi27dtG8fccrr5ZdjQx77ZG9EL2VK18PsB7b9sgT3H3G+ex6ZhPKZCCT4egff4Wxbz017dAK9uLd99M6kLu35m07eOGPK5nwD29OIarSN+vVI/jNz45n5X1baG4OZr16BAMH+HZ86xvjz5zLIwu/xs6n9twTlh00kBn/9kky1dXd/rwZn/8Yz/zqZqJpz+V2VWU59NKPFiVeqwweEbMeaWlq4s4572XHmnU0b99J09btNL20lXve9Um2r34y7fAKVnfgWDJV+yYImQF1DJjS/b+cbY+a6gzH1R/AibNHOQmzPqVMhsMWXUx28MBXyrKDBnDQu3u2jvjAqRMZ9/bTUPIIIlVXMf4d8xg4+cCixGuVwYmY9cjzt/2Jpu07od2oUTQ18dSPrk0pquIZPfckskMGQWbv/0VUleWg95yRTlBmVrDxZ86lZuRwoLDRsDYzPv8xlPzRpqxHw6z7nIhZjzRuemGfJAwgdjexa8NzKURUXJnqao7/3c8Z9pqZZGpryNTVMnDaJI698SfUjh6Zdnhm1kNto2KqqS5oNKxN26gYGXk0zHrEc8SsR0aeWL/XvIg22UEDGT33pBQiKr6BB0/kxDt/ScPG54jdTdRNHO/V383KwPgz5/LYF77LtIs/VNBoWJsZn/8Ym2643aNh1iNOxKxHBk45iIkfeAfrf/JLmrfvBFrnTw06dArjz3xTytEVV914L61gVk6UyXDSX5cVJQmD1lGxORv/7OdAWo84EbMeO+Kbn+WA17+OJ6+4muZtOxj/D29m8oKzvcaWmfV7xUrC2jgJs55yImY9JonxZ85l/Jlz0w7FzMysJHmyvpmZmVlKnIhZSWppauKJ/7iS26a+gZtG1XPPOR9jx9/WpR2WmZlZtzgRs5J0/wc/zeP/+j0a1j9D00tb2firm7nj2DPZ9dzmtEOzEiJppKRbJD2evI/I02aipN9JeljSg5I+llP3eUlPS7o3eZ3et2dgZqXOiZiVnJ1PbWDj/9xA8449z4GkpYXm7TtZ+4P/Si8wK0ULgdsiYjpwW7LfXhPwqYg4HDgWuFDSzJz6b0bE0clree+HbGblxImYlZyXVz1GpnbfOzNbdjXy4p/uSSEiK2HzgSXJ9hLgjPYNImJjRNyTbG8FHga8aqeZFYUTMSs5A6ccRMvupn3KVV3FoJmHpBCRlbCxEbERWhMuoNNF4yRNAV4D/CWn+CJJ90u6Kt+lzeS4BZJWSFqxadOmIoVuZuXAiZiVnCEzD2F4/ZGo3XplmZpqpl74npSisv5K0q2SVuV5devZNpIGA78EPh4RLyfFPwCmAUcDG4Gv5zs2IhZHRH1E1I8ePbrnJ2NmZceJmJWk+l9fwbi3zUE11ai6isGHTeOY63/EoEMmpx2a9TMR8caIODLP6zrgWUnjAZL3vA9KlVRNaxL2XxHxq5zPfjYimiOiBbgSOKb3z8jMyklBC7pKGgn8ApgCrAXeGRFb2rWZCPwUGAe0AIsj4ttJ3eeBDwFtY/Wf9mRX64rqoYOZ9bNv0Nywi5ZdjVQPG5J2SFaalgHnAouS9+vaN1DrA0Z/BDwcEd9oVze+7dIm8DZgVe+Ga2blptARMd9xZKnK1tU6CbNCLALmSHocmJPsI2mCpLb+6ATgPcDf5Vmm4quSHpB0P3AK8Ik+jt/MSlyhjziaD5ycbC8Bfg9cktsg+WuxbTLsVkltdxw9VODPNjMrSERsBk7NU74BOD3ZvgNQB8d7UqKZFaTQEbE+uePIzMzMrBztNxHrD3ccJcf79m8zMzMrK/u9NBkRb+yoTtKzbZNVe3rHUU6bK4HfdhLHYmAxQH19fewvbjMzM7P+rtBLk213HEEP7zjK2fUdR2ZmZlZRCk3EfMeRmZmZWQ8VdNek7zgyMzMz6zmvrG9mZmaWEidiZmZmZilxImZmZmaWEidiZmZmZilxImZmZmaWEidiZmZmZilxImZmZmaWEidiZmZmZilxImZmZmaWEidiZmZmZilxImZmZmaWEidiZmZmZilxImZmZmaWkqq0AzAzS4ukkcAvgCnAWuCdEbElT7u1wFagGWiKiPruHF9Ma57czpe+9QjNzbFP3RnzJnDGvAm9+ePNrMg8ImZmlWwhcFtETAduS/Y7ckpEHN2WhPXg+KIYMbyaJ9ZuZ/Xf9n49uW4HQwb7b2uzUuNEzMwq2XxgSbK9BDijj4/vthHDajjzzQdSU629ykeOqOHk40f39o83syJzImZmlWxsRGwESN7HdNAugJslrZS0oLvHS1ogaYWkFZs2bSo46He/YyLSnkRsQF2WC847mGxWnRxlZv2REzEzK2uSbpW0Ks9rfjc+5oSImAXMAy6UdFJ3YoiIxRFRHxH1o0cXPmo1YlgNZ8yb8Mqo2NAhVR4NMytRBSVikkZKukXS48n7iA7arZX0gKR7Ja3o7vFmZj0VEW+MiCPzvK4DnpU0HiB5f66Dz9iQvD8HLAWOSaq6dHxvaBsVq63JeDTMrIQVOiJWchNdzcxyLAPOTbbPBa5r30DSIElD2raB04BVXT2+t7SNio0c7rlhZqWs0ESs5Ca6mpnlWATMkfQ4MCfZR9IEScuTNmOBOyTdB9wFXB8RN3Z2fF85/9ypLP76azwaZlbCCr3Xea+JqpL2N9E1gCsiYnE3jyeZILsAYNKkSQWGbWYGEbEZODVP+Qbg9GR7DXBUd47vK9XVGUYMr0nrx5tZEew3EZN0KzAuT9VnuvFzToiIDUmidYukRyLi9m4cT5K8LQaor6/fdyVDMzMzsxKz30QsIt7YUZ2kZyWNT0azujTRVVLbRNfbSSa67u/4ntq6rYlnNjUwfkwdgwd5oUMzMzPrXwrNTtomqi6ik4muQCYituZMdP1iV4/viabm4FtXPM7yW5+hqipDU3NwxrzxXPT+aWQynkthZmZm/UOhk/X75UTXH/98LTf8v2dp3B3s2NlMY2MLy27cyNW/WleMjzczMzMrioJGxPrjRNeI4L9/8zS7drXsVd6wq4VrrlvPu87yRH8zMzPrH8puZf0I2LGzOW/d1q1NfRyNmZmZWcfKLhHLZMTUSQPz1h06bXAfR2NmZmbWsbJLxAA+cf50amsztD0TV4K62gwf/dAh6QZmZmZmlqMs13SY9arhfH/R0Sy59knWPLmD6VMH8b6zJzNtikfEzMzMrP8oy0QMYMYhQ/jyp49MOwwzMzOzDpXlpUkzMzOzUuBEzMzMzCwlTsTMzMzMUuJEzMzMzCwlTsTMzMzMUuJEzMzMzCwlTsTMzMzMUuJEzMzMzCwlTsTMzMzMUuJEzMwqlqSRkm6R9HjyPiJPmxmS7s15vSzp40nd5yU9nVN3ep+fhJmVNCdiZlbJFgK3RcR04LZkfy8R8WhEHB0RRwOvBXYAS3OafLOtPiKW90XQZlY+nIiZWSWbDyxJtpcAZ+yn/anAExHxZG8GZWaVw4mYmVWysRGxESB5H7Of9mcDV7cru0jS/ZKuyndpE0DSAkkrJK3YtGlT4VGbWdkoKBHz/Aoz6+8k3SppVZ7X/G5+Tg3w98B/5xT/AJgGHA1sBL6e79iIWBwR9RFRP3r06J6diJmVpaoCj2+bX7FI0sJk/5LcBhHxKK2dFJKywNPsO7/iPwqMw8wsr4h4Y0d1kp6VND4iNkoaDzzXyUfNA+6JiGdzPvuVbUlXAr8tRsxmVjkKvTTp+RVmVsqWAecm2+cC13XS9hzaXZZMkrc2bwNWFTU6Myt7hSZifTK/AjzHwsx6xSJgjqTHgTnJPpImSHrlDkhJA5P6X7U7/quSHpB0P3AK8Im+CdvMyoUiovMG0q3AuDxVnwGWRMTwnLZbIqKjyao1wAbgiLbhfEljgeeBAP4VGB8R799f0PX19bFixYr9NTOzMiJpZUTUpx1Hodx/mVWezvqv/c4R8/wKMzMzs95R6KVJz68wMzMz66FCEzHPrzAzMzProYKWr4iIzbTeCdm+fANwes7+DuCAPO3eU8jPNzMzMytlXlnfzMzMLCVOxMzMzMxS4kTMzMzMLCVOxMzMzMxSUuizJs3K2paXGrnhtmdZv2EnRx42lFNfP5ra2mzaYZmZ7dcTa7dx7XVPE+y7cPtb5ozn1TOHpRCVtedEzKwDj6/ZxkX/516amoJdjS3c8odn+ckvnuTKr89i2NDqtMMzM+tUw64Wlt/2DO0foJPJwInHjEonKNuHL02adeBfv/EI23c0s6uxBYCdDS089/wufvTztekGZmbWBUfMGMqRhw1F2rt8/Jg6Tpy9z4pSlhInYmZ5vPjSbp56esc+5U1Nwe/+6IfOm1lpuPD9B1NTs+dX/YC6DBe8fxqZjDo5yvqSEzGzPKqqOu6kaqr9v42ZlYYjDxvGoQcPfmVUbOTwGl7v0bB+xb9RzPIYPKiKVx0+lEy7/0NqazK8Zc64dIIyM+uBtlExj4b1T07EzDrwuU8dztjRdQwckKW2NkNdbYZXzxzGu86alHZoZmZd1jYqNnKER8P6I981adaB0QfUcs0Vx7Divi0881wDM6YN4bDpQ9IOy8ys277wLzNpaGj2aFg/5ETMrBPZrJg9a2TaYZiZFWTMqNq0Q7AO+NKkmZmZWUqciJlZxZL0DkkPSmqRVN9Ju7mSHpW0WtLCnPKRkm6R9HjyPqJvIjezcuFEzMwq2Srg7cDtHTWQlAUuA+YBM4FzJM1MqhcCt0XEdOC2ZN/MrMuciJlZxYqIhyPi0f00OwZYHRFrIqIRuAaYn9TNB5Yk20uAM3olUDMrW07EzMw6dyCwLmd/fVIGMDYiNgIk72P6ODYzK3EledfkypUrn5f0ZE7RKOD5tOLpQ5VynlA55+rz7LrJPTlI0q1AvlV4PxMR13XlI/KURZ6yzmJYACxIdrdJ2t8oXCmqlH/LuSrxnMHn3RMd9l8lmYhFxOjcfUkrIqLDibblolLOEyrnXH2evS8i3ljgR6wHJubsHwRsSLaflTQ+IjZKGg8810EMi4HFBcbRr1XKv+VclXjO4PMu9uf60qSZWefuBqZLmiqpBjgbWJbULQPOTbbPBboywmZm9gonYmZWsSS9TdJ64Djgekk3JeUTJC0HiIgm4CLgJuBh4NqIeDD5iEXAHEmPA3OSfTOzLivJS5N5lPWQf45KOU+onHP1eaYoIpYCS/OUbwBOz9lfDizP024zcGpvxlhC+uV33Msq8ZzB511UiujWnFMzMzMzKxJfmjQzMzNLiRMxMzMzs5SUZCJW6PPhSkVXn2Mnaa2kByTdK2lFX8fZU/v7ftTqO0n9/ZJmpRFnobpwnidLein5/u6V9Lk04iyUpKskPSdpVQf1ZfF9Wqty759yVUpf1V6l9F25UunHIqLkXsDhwAzg90B9B22ywBPAwUANcB8wM+3Yu3meXwUWJtsLga900G4tMCrteLt5bvv9fmidLH0DrQtqHgv8Je24e+k8TwZ+m3asRTjXk4BZwKoO6kv++/Rrr++zbPundvFXRF/Vw/Mui76r3Tn1eT9WkiNiUfjz4UpFOT/Hrivfz3zgp9HqTmB4smhmKSmHf4ddEhG3Ay900qQcvk/bo5z7p1yV0le1VzF9V640+rGSTMS6qLPnw5WKrj7HLoCbJa1MHqVSCrry/ZTDd9jVczhO0n2SbpB0RN+E1ufK4fu0Pcq5f8pVKX1Ve+678iv6d91v1xFTP3g+XF/o7Dy78TEnRMQGSWOAWyQ9kmT1/VlXvp+S+A73oyvncA8wOSK2STod+DUwvbcDS0E5fJ8VpYL7p1yV0le1574rv6J/1/02EYvefT5cv9HZeUrq6nPsNiTvz0laSuuQcn/v6Lry/ZTEd7gf+z2HiHg5Z3u5pO9LGhUR5fZQ3XL4PitKBfdPuSqlr2rPfVd+Rf+uy/nSZGfPhysV+32OnaRBkoa0bQOnAXnv9uhnuvL9LAPem9ylcizwUtulkBKy3/OUNE6Sku1jaP3/cnOfR9r7yuH7tD3KuX/KVSl9VXvuu/Ir+nfdb0fEOiPpbcB3gdG0Ph/u3oh4k6QJwA8j4vSIaJLU9ny4LHBV7Hk+XKlYBFwr6QPAU8A7oPU5eCTnCYwFlib/L1QBP4+IG1OKt8s6+n4knZ/UX07rI2VOB1YDO4Dz0oq3p7p4nmcBH5HUBOwEzo7k9pxSIulqWu+iGqXW5zdeClRD+Xyftpey7Z9yVUpf1V4l9V250ujH/IgjMzMzs5SU86VJMzMzs37NiZiZmZlZSpyImZmZmaXEiZiZmZlZSpyImZmZmaXEiZiZmZlZSpyImZmZmaXk/wM1fhQOO5B5vQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 生成训练集和测试集\n", + "X_train, y_train = make_circles(10, noise=0.05, factor=0.2, random_state=0)\n", + "X_test, y_test = make_circles(10, noise=0.05, factor=0.2, random_state=1024)\n", + "\n", + "# 将生成的数据集进行可视化\n", + "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n", + "ax[0].scatter(X_train[:,0], X_train[:,1], \n", + " marker='o', c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)))\n", + "ax[0].set_title('Train')\n", + "ax[1].set_title('Test')\n", + "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)))\n", + "\n", + "print(\"先来看一下我们的训练集和测试集:\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "federal-representation", + "metadata": {}, + "outputs": [], + "source": [ + "# 初始化进度条\n", + "bar_format_string = '{l_bar}{bar}|[{elapsed}<{remaining}, ' '{rate_fmt}{postfix}]'\n", + "pbar = tqdm(total=100, bar_format=bar_format_string)\n", + "pbar.close()\n", + "clear_output()" + ] + }, + { + "cell_type": "markdown", + "id": "educated-permission", + "metadata": {}, + "source": [ + "下面，我们来用 PaddleQuantum 来搭建量子核函数的计算电路：" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "every-competition", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "检查是否满足 K(x, x) = 1？ True\n" + ] + } + ], + "source": [ + "# 初始化一个用来更新进度条的全局变量\n", + "N = 1\n", + "\n", + "# 通过 paddle quantum 模拟的 QKE 电路\n", + "def q_kernel_estimator(x1, x2):\n", + " \n", + " # 将数据类型转换为 tensor\n", + " x1 = paddle.to_tensor(x1)\n", + " x2 = paddle.to_tensor(x2)\n", + " \n", + " # 创建电路\n", + " cir = paddle_quantum.ansatz.Sequential()\n", + " \n", + " # 添加对应第一个数据的编码电路\n", + " cir.append(IQPEncoding(qubits_idx=[[0,1]], feature=x1))\n", + " init_state = paddle_quantum.state.zero_state(2)\n", + " state = cir[0](state=init_state)\n", + " \n", + " # 添加对应第二个数据的编码电路的逆电路\n", + " cir.append(IQPEncoding(qubits_idx=[[0,1]], feature=x2))\n", + " fin_state = cir[1](state=state,invert=True).data\n", + " \n", + " # 更新进度条\n", + " global pbar\n", + " global N\n", + " pbar.update(100/N)\n", + "\n", + " # 返回测量结果为 0...0 的概率\n", + " return (fin_state[0].conj() * fin_state[0]).real().numpy()[0]\n", + "\n", + "# 按照规范定义需要传入的 Kernel 矩阵函数\n", + "# 按照规范，输入应为两个数据列表\n", + "def q_kernel_matrix(X1, X2):\n", + " return np.array([[q_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])\n", + "\n", + "# 可视化决策函数（预测值），以及决策边界\n", + "def visualize_decision_bound(clf):\n", + " \n", + " # 创建一个 10x10 的网格\n", + " x_min, x_max = X_train[:,0].min(), X_train[:,0].max()\n", + " y_min, y_max = X_train[:,1].min(), X_train[:,1].max()\n", + " XX, YY = np.meshgrid(np.linspace(-1.2, 1.2, 10), \n", + " np.linspace(-1.2, 1.2, 10))\n", + " \n", + " # 计算分类器该网格上的预测值\n", + " Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()])\n", + " Z_qke = Z.reshape(XX.shape)\n", + " \n", + " # 可视化决策函数，以及决策边界\n", + " clear_output()\n", + " plt.contourf(XX, YY, Z_qke ,vmin=-1., vmax=1., levels=20,\n", + " cmap=matplotlib.cm.coolwarm, alpha=1)\n", + " plt.scatter(X_train[:,0], X_train[:,1], \n", + " c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)),\n", + " edgecolor='black')\n", + " plt.scatter(X_test[:,0], X_test[:,1], marker='v', \n", + " c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)),\n", + " edgecolor='black')\n", + " plt.contour(XX, YY, Z_qke, colors=['k', 'k', 'k'], linestyles=['--', '-', '--'],\n", + " levels=[-.2, 0, .2])\n", + "\n", + "# 作为检查量子核函数是否运行正常，我们可以检查 K(x, x) 是否等于 1\n", + "# 提示：根据内积的定义 = 1\n", + "print('检查是否满足 K(x, x) = 1？',\n", + " bool(abs(q_kernel_estimator(np.array([1. ,1.]), np.array([1., 1.])) - 1) < 1e-6))" + ] + }, + { + "cell_type": "markdown", + "id": "requested-cameroon", + "metadata": {}, + "source": [ + "接下来，让我们尝试用量子核支持向量机（QKE-SVM）来进行数据分类：" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "caring-daily", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "让我们看一下量子核支持向量机的分类效果如何:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 创建进度条，并设置所需要的量子核函数计算数量 N\n", + "pbar = tqdm(total=100, \n", + " desc='训练 QKE-SVM 并分类中', \n", + " bar_format=bar_format_string)\n", + "N = len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test)\n", + "\n", + "# 创建一个具有量子核函数的支持向量机\n", + "svm_qke = svm.SVC(kernel=q_kernel_matrix)\n", + "\n", + "# 根据训练数据计算支持向量机的决策平面\n", + "svm_qke.fit(X_train, y_train)\n", + "\n", + "# 计算支持向量机分别对于训练数据和测试数据的分类预测值\n", + "predict_svm_qke_train = svm_qke.predict(X_train)\n", + "predict_svm_qke_test = svm_qke.predict(X_test)\n", + "\n", + "# 计算准确率\n", + "accuracy_train = np.array(predict_svm_qke_train == y_train, dtype=int).sum()/len(y_train)\n", + "accuracy_test = np.array(predict_svm_qke_test == y_test, dtype=int).sum()/len(y_test)\n", + "\n", + "# 可视化分类预测结果\n", + "pbar.close()\n", + "clear_output()\n", + "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n", + "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n", + " c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_train, dtype=np.float32)))\n", + "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n", + "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n", + " c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_test, dtype=np.float32)))\n", + "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n", + "print(\"让我们看一下量子核支持向量机的分类效果如何:\")" + ] + }, + { + "cell_type": "markdown", + "id": "distinguished-dependence", + "metadata": {}, + "source": [ + "更进一步的，我们还可以检查此时的决策函数平面以及决策边界：" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "universal-genome", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "计算 QKE-SVM 的决策函数中: 100%|█████████████████████████████████████████████████▉|[00:09<00:00, 10.09it/s]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 创建进度条，并设置所需要的量子核函数计算数量 N\n", + "pbar = tqdm(total=100, \n", + " desc='计算 QKE-SVM 的决策函数中', \n", + " bar_format=bar_format_string)\n", + "N = 10 ** 2 * len(X_train)\n", + " \n", + "# 可视化决策函数平面\n", + "visualize_decision_bound(svm_qke)\n", + "pbar.close()" + ] + }, + { + "cell_type": "markdown", + "id": "transsexual-swift", + "metadata": {}, + "source": [ + "可以看到，量子核函数可以很好的学习到数据中的非线性特征。实际上，量子核方法的表现取决于量子特征映射的设计。并且，对于如何设计更好的量子核函数的探究才刚刚开始：一方面，我们可以尝试不同的数据编码方式；另一方面，我们可以尝试通过训练量子特征映射的方式提升分类效果 [5-6]；最后，我们还可以尝试一些不同的量子核函数形式 [7]。\n", + "\n", + "下面，作为拓展，我们也将展示一种特殊的量子核函数:投影量子核函数（projected quantum kernel）。" + ] + }, + { + "cell_type": "markdown", + "id": "scenic-circuit", + "metadata": {}, + "source": [ + "### 拓展：投影量子核函数\n", + "\n", + "上文中已经提到，量子核方法通过将经典信息映射到潜在的高维量子特征空间来分辨在经典空间不可分的信息。但是，当我们的量子特征空间-希尔伯特空间的维度太大的时候，所有映射到希尔伯特空间的量子态都会接近于相互垂直的状态，此时的核矩阵将会近似的变成一个单位矩阵 $K_{ij} = K(\\mathbf{x}_j, \\mathbf{x}_i) \\sim {I}$。为了避免这种维度问题的出现，我们需要首先从高维希尔伯特空间提取出足够的低维信息。投影量子核方法就是遵循了这个思路，即将量子态投影到新的经典空间，再在这个新的经典空间使用核方法。我们可以认为每一个投影是从不同的角度去观测希尔伯特空间的量子态，从足够多的角度测量这个量子态可以使我们获得足够重构这个态的经典信息。但在实际应用中，通常只需要从几个角度测量就能得到比较好的结果 [5]。 由于这个经典空间保留了部分希尔伯特空间中的重要特征，所以信息在这个经典空间的可分性优于原来的经典空间。\n", + "\n", + "投影量子核函数有很多不同的形式，这里我们举一个最为代表性的作为例子：\n", + "\n", + "$$\n", + "K^{PQ}(x_i,x_j) = \\exp\\left(-\\gamma\\sum\\limits_{k}\\sum\\limits_{P\\in \\mathcal{M}}( {\\rm Tr} (P\\rho(x_i)_k)-{\\rm Tr}(P\\rho(x_j)_k))^{2}\\right),\n", + "\\tag{13}\n", + "$$\n", + "\n", + "其中 $k$ 是用来标记多量子比特约化密度矩阵的下标，$\\mathcal{M}$ 是一个作用在多量子比特约化密度矩阵上的测量的集合。在这里，我们取 $k = 0, 1$，即两个单量子比特的约化密度矩阵，$M = \\{X, Y, Z \\}$，即一组 Pauli 测量。\n", + "\n", + "我们先尝试用 Paddle Quantum 来实现对应的投影量子核电路：" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "artificial-hierarchy", + "metadata": {}, + "outputs": [], + "source": [ + "# 因为这次我们的特征映射的特征空间也是经典的，我们不妨先把该映射写出来\n", + "def projected_q_feature_map(x):\n", + " # 将经典数据转换为 Tensor\n", + " x = paddle.to_tensor(x)\n", + " \n", + " # 更新进度条\n", + " global N\n", + " pbar.update(100/N)\n", + " \n", + " init_state = paddle_quantum.state.zero_state(2)\n", + "\n", + " # 进行投影测量，返回其期望值作为经典特征向量\n", + " res = []\n", + " for op_pauli in ['z0', 'z1', 'x0', 'x1', 'y0', 'y1']:\n", + " cir = paddle_quantum.ansatz.Sequential()\n", + " cir.append(IQPEncoding(qubits_idx=[[0, 1]], feature=x))\n", + " state = cir[0](init_state)\n", + " hamiltonian = paddle_quantum.Hamiltonian([[1.0, op_pauli]])\n", + " cir.append(paddle_quantum.loss.ExpecVal(hamiltonian))\n", + " res.append(cir[1](state).numpy()[0])\n", + " return res\n", + "\n", + "# 按照上文公式计算投影量子核函数\n", + "def p_quantum_kernel_estimator(x1, x2):\n", + " \n", + " # 分别得到特征向量，并计算核函数\n", + " p_feature_vector_1 = np.array(projected_q_feature_map(x1))\n", + " p_feature_vector_2 = np.array(projected_q_feature_map(x2))\n", + " \n", + " return np.exp(-((p_feature_vector_1 - p_feature_vector_2) ** 2).sum())\n", + "\n", + "# 类似地，按照规范定义传入支持向量机的核函数\n", + "def p_quantum_kernel_matrix(X1, X2):\n", + " return np.array([[p_quantum_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])" + ] + }, + { + "cell_type": "markdown", + "id": "baking-bridges", + "metadata": {}, + "source": [ + "接下来，让我们看一下如何用投影量子核支持向量机（PQK-SVM）来进行数据分类：" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "chronic-terrorist", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "让我们看一下投影量子核支持向量机的分类效果如何:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 创建进度条，并设置所需要的量子核函数计算数量 N\n", + "pbar = tqdm(total=100, \n", + " desc='训练 PQK-SVM 并分类中', \n", + " bar_format=bar_format_string)\n", + "N = 2 * (len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test))\n", + "\n", + "# 创建一个具有投影量子核函数的支持向量机\n", + "svm_pqk = svm.SVC(kernel=p_quantum_kernel_matrix)\n", + "\n", + "# 根据训练数据计算支持向量机的决策平面\n", + "svm_pqk.fit(X_train, y_train)\n", + "\n", + "# 计算支持向量机分别对于训练数据和测试数据的分类预测值\n", + "predict_svm_pqk_train = svm_pqk.predict(X_train)\n", + "predict_svm_pqk_test = svm_pqk.predict(X_test)\n", + "\n", + "# 计算准确率\n", + "accuracy_train = np.array(predict_svm_pqk_train == y_train, dtype=int).sum()/len(y_train)\n", + "accuracy_test = np.array(predict_svm_pqk_test == y_test, dtype=int).sum()/len(y_test)\n", + "\n", + "# 可视化分类结果\n", + "pbar.close()\n", + "clear_output()\n", + "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n", + "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n", + " c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_train, dtype=np.float32)))\n", + "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n", + "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n", + " c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_test, dtype=np.float32)))\n", + "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n", + "print(\"让我们看一下投影量子核支持向量机的分类效果如何:\")" + ] + }, + { + "cell_type": "markdown", + "id": "irish-embassy", + "metadata": {}, + "source": [ + "同样的，我们检查一下此时的决策函数平面以及决策边界：" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "chief-beach", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "计算 PQK-SVM 决策函数中: 100%|███████████████████████████████████████████████████▉|[01:28<00:00, 1.13it/s]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 创建进度条，并设置所需要的量子核函数计算数量 N\n", + "pbar = tqdm(total=100, \n", + " desc='计算 PQK-SVM 决策函数中', \n", + " bar_format=bar_format_string)\n", + "N = 2 * 10 ** 2 * len(X_train)\n", + " \n", + "# 可视化决策函数平面\n", + "visualize_decision_bound(svm_pqk)\n", + "pbar.close()" + ] + }, + { + "cell_type": "markdown", + "id": "continuous-chance", + "metadata": {}, + "source": [ + "## 总结\n", + "\n", + "在量子机器学习的研究中，研究者们希望借助量子力学的特点设计出可以超越经典机器学习方法的模型。随着该领域的研究越发深入，人们发现量子机器学习和传统机器学习可以通过核方法建立起深入的联系。相比“传统”的量子神经网络，量子核方法把研究的重点放在了从经典数据空间到量子希尔伯特空间的特征映射，而不是变分量子电路。这为量子机器学习带来了新的研究思路，并为设计出实用的量子算法带来了新的可能性。因此，我们鼓励读者一起来思考如何设计出更好的量子核函数，并将其应用在更多样的数据集上。" + ] + }, + { + "cell_type": "markdown", + "id": "intimate-bible", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 参考资料\n", + "\n", + "[1] Schuld, Maria. \"Supervised quantum machine learning models are kernel methods.\" arXiv preprint [arXiv:2101.11020 (2021)](https://arxiv.org/abs/2101.11020).\n", + "\n", + "[2] Havlíček, Vojtěch, et al. \"Supervised learning with quantum-enhanced feature spaces.\" [Nature 567.7747 (2019): 209-212](https://arxiv.org/abs/1804.11326).\n", + "\n", + "[3] Liu, Yunchao, Srinivasan Arunachalam, and Kristan Temme. \"A rigorous and robust quantum speed-up in supervised machine learning.\" arXiv preprint [arXiv:2010.02174 (2020)](https://arxiv.org/abs/2010.02174).\n", + "\n", + "[4] Schuld, Maria, and Nathan Killoran. \"Quantum machine learning in feature Hilbert spaces.\" [Phys. Rev. Lett. 122.4 (2019): 040504](https://arxiv.org/abs/1803.07128).\n", + "\n", + "[5] Hubregtsen, Thomas, et al. \"Training Quantum Embedding Kernels on Near-Term Quantum Computers.\" arXiv preprint [arXiv:2105.02276(2021)](https://arxiv.org/abs/2105.02276).\n", + "\n", + "[6] Glick, Jennifer R., et al. \"Covariant quantum kernels for data with group structure.\" arXiv preprint [arXiv:2105.03406(2021)](https://arxiv.org/abs/2105.03406).\n", + "\n", + "[7] Huang, Hsin-Yuan, et al. \"Power of data in quantum machine learning.\" arXiv preprint [arXiv:2011.01938 (2020)](https://arxiv.org/abs/2011.01938).\n", + "\n", + "[8] Schölkopf, Bernhard, and Alexander J. Smola\"Learning with kernels: support vector machines, regularization, optimization, and beyond.\" [MIT Press(2002)](https://mitpress.mit.edu/books/learning-kernels)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.8.13" + }, + "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 + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/machine_learning/QKernel_EN.ipynb b/tutorials/machine_learning/QKernel_EN.ipynb new file mode 100644 index 0000000..2cedc0b --- /dev/null +++ b/tutorials/machine_learning/QKernel_EN.ipynb @@ -0,0 +1,751 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "white-energy", + "metadata": {}, + "source": [ + "# Quantum Kernel Methods\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "id": "perfect-marker", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "One of the most important learning models for quantum machine learning applications in the noisy intermediate-scale quantum (NISQ) era is the parameterized quantum circuit. Although given its obvious analogy to classical neural networks, many refer to such quantum models as \"quantum neural networks\", it was shown that the mathematical form of such quantum machine learning models is actually much closer to kernel methods, a different kind of classical learning approach [1]. By combining classical kernel methods and the power of quantum models, quantum kernel methods can shed new light on how to approach a variety of machine learning problems, thus raising great interest in the field of quantum machine learning [2-7]. In this tutorial, we will introduce the basic ideas of quantum kernel methods and demonstrate how to classify data with two different quantum kernels.\n", + "\n", + "### Background\n", + "\n", + "In classical machine learning, kernel methods' basic idea is to map a low-dimensional data vector into a potentially high-dimensional feature space via a feature map, thus giving us the possibility to use linear methods to analyze non-linear features in the original data. As shown in Fig. 1, by mapping linearly inseparable 1D data into a 2D feature space, the feature vectors of the original data become linearly separable.\n", + "\n", + "![feature map](./figures/Qkernel-fig-featuremap.png \"Figure 1. feature map in kernel methods\")\n", + "
Figure 1. feature map in kernel methods
\n", + "\n", + "In practice, the feature space's dimensionality sometimes can be extremely large (even goes to infinity). So we do not wish to tackle these feature vectors directly. Another key idea in kernel methods is that we can implicitly analyze these feature vectors by only accessing their inner products in the feature space, which is noted as kernel functions $K(,)$:\n", + "\n", + "$$\n", + "K(\\mathbf{x}_i, \\mathbf{x}_j) = \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i),\n", + "\\tag{1}\n", + "$$\n", + "\n", + "with $\\phi()$ being the feature map. We note that in kernel methods, we do not need to express the feature map explicitly. Instead, we only need to compute the kernel function. This approach can introduce non-linearity into our models, giving us the ability to recognize intractable patterns in the original data space. \n", + "\n", + "The arguably most famous application of kernel methods is the support vector machine (SVM), which solves linear classification problems. Take a 2-classification problem as an example: Given data set $T = \\{ (\\mathbf{x}_1, y_1), ..., (\\mathbf{x}_m, y_m) \\} \\subset \\mathcal{X}\\times\\mathbb{Z}_2$, with a hyperplane $( \\mathbf{w}, b)$, a support vector machine can assign labels via the signs of the decision function, as:\n", + "\n", + "$$\n", + "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}, \\mathbf{x} \\rangle + b).\n", + "\\tag{2}\n", + "$$\n", + "\n", + "But for linearly inseparable data, such linear classification schemes do not work. So again, as shown in Fig. 1, we can potentially find a better separation by mapping them into a feature space. For example, if we note the separating hyperplane in the feature space as $(\\mathbf{w}', b')$, then the decision function becomes:\n", + "\n", + "$$\n", + "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}', \\phi(\\mathbf{x}) \\rangle + b').\n", + "\\tag{3}\n", + "$$\n", + "\n", + "Furthermore, by duality, we can write the hyperplane as $\\mathbf{w}' = \\sum_i \\alpha_i \\phi(\\mathbf{x_i})$ with Lagrangian multipliers $\\alpha_i$ [8]. Then, under the constraints $\\alpha_i \\geq 0$ and $\\sum_i y_i \\alpha_i=0$, we can compute the optimal $\\alpha_i^*$, thus the optimal hyperplane by maximizing \n", + "\n", + "$$\n", + "\\sum_i \\alpha_i - \\frac{1}{2} \\sum_{i, j} \\alpha_i \\alpha_j y_i y_j \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i).\n", + "\\tag{4}\n", + "$$\n", + "\n", + "Notice that in Eq. (4), we only need the inner products of feature vectors $\\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i) = K(x_i, x_j)$, which is the above mentioned kernel function. As a result, we are able to find the optimal separating hyperplane in the feature space with SVM by only accessing the feature space through the kernel function. Furthermore, we can compute the predicted label as follows:\n", + "\n", + "$$\n", + "y_{\\rm pred} = {\\rm sign}(\\sum_i \\alpha^*_i \\langle \\phi(\\mathbf{x_i}), \\phi(\\mathbf{x}' \\rangle + b') = \n", + "{\\rm sign}(\\sum_i \\alpha^*_i K(\\mathbf{x}_i, \\mathbf{x}') + b').\n", + "\\tag{5}\n", + "$$\n", + "\n", + "Again, only kernel function is needed. \n", + "\n", + "Given the idea of classical kernel methods, we can easily understand the essential idea of quantum kernel methods. First, consider a quantum feature space, where we map a classical data vector $\\mathbf{x}$ into a quantum state $| \\phi(\\mathbf{x})\\rangle$ by a encoding circuit $U(\\mathbf{x})$ as follows:\n", + "\n", + "$$\n", + "U(\\mathbf{x}) | 0^{\\otimes N} \\rangle = | \\phi(\\mathbf{x}) \\rangle.\n", + "\\tag{6}\n", + "$$\n", + "\n", + "There are many discussions about how to best design an encoding circuit. We refer to our [data encoding tutorial](./DataEncoding_EN.ipynb) for a more detailed explanation. The encoding can also be regarded as a quantum feature map from classical data space to the Hilbert space. Based on this idea, we define a quantum kernel function as the inner products of two quantum feature vectors in the Hilbert space, which is\n", + "\n", + "$$\n", + "K^Q_{ij} = |\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2,\n", + "\\tag{7}\n", + "$$\n", + "\n", + "which can be further formulated as\n", + "\n", + "$$\n", + "|\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2 = |\\langle 0^{\\otimes N} | U^\\dagger(\\mathbf{x}_j) U(\\mathbf{x}_i) | 0^{\\otimes N} \\rangle |^2.\n", + "\\tag{8}\n", + "$$\n", + "\n", + "By running the quantum circuit as shown in Fig. 2, and measure the probability of observing $| 0^{\\otimes N} \\rangle $ at the output, we can estimate the quantum kernel function in Eq. (8). This way of constructing quantum kernels is also known as quantum kernel estimation (QKE). By replacing the classical kernel function in Eq. (4-5) with QKE, we can classify data in the quantum feature space with SVM. Given the potentially non-simulatable nature of such quantum kernels, there might exist a quantum advantage in recognizing classically intractable patterns. Such an advantage has been rigorously shown, with a constructed classically hard classification problem and a carefully designed quantum feature map [3].\n", + "\n", + "![QKE](./figures/Qkernel-fig-QKE.png \"Figure 2. Quantum kernel estimation circuit\")\n", + "
Figure 2. Quantum kernel estimation circuit
\n", + "\n", + "![illustration](./figures/Qkernel-fig-illustrationEN.png \"Figure 3. Classical kernel methods and quantum kernel methods\")\n", + "
Figure 3. Classical kernel methods and quantum kernel methods
" + ] + }, + { + "cell_type": "markdown", + "id": "parental-tampa", + "metadata": {}, + "source": [ + "### Connections between quantum machine learning and kernel methods\n", + "\n", + "In quantum machine learning models, a quantum encoding circuit is often used to encode classical data into a quantum state\n", + "\n", + "$$\n", + "| \\phi(x) \\rangle = U (x) | 0^{\\otimes N} \\rangle,\n", + "\\tag{9}\n", + "$$\n", + "\n", + "where $U(x)$ is a parameterized quantum circuit depending on the data vector $x$. Like we mentioned above, such quantum encoding circuit can be considered as a quantum feature map. Then, consider a \"quantum neural network\" is applied to the encoding state, in which the quantum circuit is composed of a set of parameterized gates with variational parameters. We have the final state as\n", + "\n", + "$$\n", + "| \\psi \\rangle = U_{\\rm QNN}(\\theta)U (\\mathbf{x}) | 0^{\\otimes N} \\rangle,\n", + "\\tag{10}\n", + "$$\n", + "\n", + "where $U_{\\rm QNN}(\\theta)$ is the quantum neural network with parameters $\\theta$. Finally we perform a measurement $\\mathcal{M}$ on the final state as the output of our model, its expectation value can be computed as\n", + "\n", + "$$\n", + "\\langle \\mathcal{M} \\rangle = \\langle \\psi | \\mathcal{M} | \\psi \\rangle = \\langle \\phi(\\mathbf{x}) | U^\\dagger_{\\rm QNN}(\\theta) \\mathcal{M} U_{\\rm QNN}(\\theta)| \\phi(\\mathbf{x}) \\rangle.\n", + "\\tag{11}\n", + "$$\n", + "\n", + "Suppose we write the measurement in its operator form $| \\sigma \\rangle \\langle \\sigma |$, then Eq. (11) can be further reformulated as \n", + "\n", + "$$\n", + "\\langle \\phi(\\mathbf{x}) | \\sigma'(\\theta) \\rangle \\langle \\sigma' (\\theta) | \\phi(x) \\rangle = \n", + "|\\langle \\sigma' (\\theta) | \\phi(\\mathbf{x}) \\rangle|^2,\n", + "\\tag{12}\n", + "$$\n", + "\n", + "where $| \\sigma'(\\theta) \\rangle = U^\\dagger_{\\rm QNN}(\\theta) | \\sigma \\rangle$. From Eq. (12), QNN together with a measurement can also be seen as a parameterized measurement operator, which is used to compute the inner product with the data encoding state in the Hilbert space, which is, the kernel function. This is why we mentioned in the introduction that the mathematical form of parameterized quantum circuits is closely related to kernel methods." + ] + }, + { + "cell_type": "markdown", + "id": "adequate-association", + "metadata": {}, + "source": [ + "## Kernel-based Classification with Paddle Quantum\n", + "\n", + "> It is required to have [`sklearn`](https://scikit-learn.org/stable/install.html) packages installed for the support vector machine. Readers may run the following block to install the relevant packages:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "automatic-timeline", + "metadata": {}, + "outputs": [], + "source": [ + "from IPython.display import clear_output\n", + "\n", + "!pip install scikit-learn\n", + "clear_output()" + ] + }, + { + "cell_type": "markdown", + "id": "existing-devon", + "metadata": {}, + "source": [ + "In this tutorial, we will demonstrate how to classify data using a support vector machine with a kernel computed by Paddle Quantum." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "literary-feature", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import matplotlib\n", + "import numpy as np\n", + "import paddle\n", + "from numpy import pi as PI\n", + "from matplotlib import pyplot as plt\n", + "\n", + "from paddle import matmul, transpose\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.gate import IQPEncoding\n", + "import paddle_quantum\n", + "\n", + "import sklearn\n", + "from sklearn import svm\n", + "from sklearn.datasets import fetch_openml, make_moons, make_circles\n", + "from sklearn.model_selection import train_test_split\n", + "\n", + "from IPython.display import clear_output\n", + "from tqdm import tqdm" + ] + }, + { + "cell_type": "markdown", + "id": "imperial-license", + "metadata": {}, + "source": [ + "For the training and testing set, we generate some 2D circle data that has 2 classes." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "literary-district", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Let's first see our training and testing set:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Generate data set\n", + "X_train, y_train = make_circles(10, noise=0.05, factor=0.2, random_state=0)\n", + "X_test, y_test = make_circles(10, noise=0.05, factor=0.2, random_state=1024)\n", + "\n", + "# Visualize respectively the training and testing set\n", + "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n", + "ax[0].scatter(X_train[:,0], X_train[:,1], \n", + " marker='o', c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)))\n", + "ax[0].set_title('Train')\n", + "ax[1].set_title('Test')\n", + "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)))\n", + "\n", + "print(\"Let's first see our training and testing set:\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "explicit-wayne", + "metadata": {}, + "outputs": [], + "source": [ + "# Initialize the progress bar\n", + "bar_format_string = '{l_bar}{bar}|[{elapsed}<{remaining}, ' '{rate_fmt}{postfix}]'\n", + "pbar = tqdm(total=100, bar_format=bar_format_string)\n", + "pbar.close()\n", + "clear_output()" + ] + }, + { + "cell_type": "markdown", + "id": "asian-preliminary", + "metadata": {}, + "source": [ + "Now, let's see how to implement a quantum kernel with Paddle Quantum:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "ideal-jaguar", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Check if K(x, x) = 1? True\n" + ] + } + ], + "source": [ + "# Global variable for manual updates of the progress bar\n", + "N = 1\n", + "\n", + "# The QKE circuit simulated by paddle quantm\n", + "def q_kernel_estimator(x1, x2):\n", + " \n", + " # Transform data vectors into tensors\n", + " x1 = paddle.to_tensor(x1)\n", + " x2 = paddle.to_tensor(x2)\n", + " \n", + " # Create the circuit\n", + " cir = paddle_quantum.ansatz.Sequential()\n", + " \n", + " # Add the encoding circuit for the first data vector\n", + " cir.append(IQPEncoding(qubits_idx=[[0,1]], feature=x1))\n", + " init_state = paddle_quantum.state.zero_state(2)\n", + " state = cir[0](state=init_state) \n", + " \n", + " # Add inverse of the encoding circuit for the second data vector\n", + " cir.append(IQPEncoding(qubits_idx=[[0,1]], feature=x2))\n", + " fin_state = cir[1](state=state,invert=True).data\n", + " \n", + " # Update the progress bar\n", + " global N\n", + " pbar.update(100/N)\n", + " \n", + " # Return the probability of measuring 0...0 \n", + " return (fin_state[0].conj() * fin_state[0]).real().numpy()[0]\n", + "\n", + "# Define a kernel matrix function, for which the input should be two list of vectors\n", + "# This is needed to customize the SVM kernel\n", + "def q_kernel_matrix(X1, X2):\n", + " return np.array([[q_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])\n", + "\n", + "# Visualize the decision function, boundary, and margins of +- 0.2\n", + "def visualize_decision_bound(clf):\n", + " \n", + " # Create a 10x10 mesh in the data plan \n", + " x_min, x_max = X_train[:,0].min(), X_train[:,0].max()\n", + " y_min, y_max = X_train[:,1].min(), X_train[:,1].max()\n", + " XX, YY = np.meshgrid(np.linspace(-1.2, 1.2, 10), \n", + " np.linspace(-1.2, 1.2, 10))\n", + " \n", + " # Calculate the decision function value on the 10x10 mesh\n", + " Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()])\n", + " Z_qke = Z.reshape(XX.shape)\n", + " \n", + " # visualize the decision function and boundary\n", + " clear_output()\n", + " plt.contourf(XX, YY, Z_qke ,vmin=-1., vmax=1., levels=20,\n", + " cmap=matplotlib.cm.coolwarm, alpha=1)\n", + " plt.scatter(X_train[:,0], X_train[:,1], \n", + " c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)),\n", + " edgecolor='black')\n", + " plt.scatter(X_test[:,0], X_test[:,1], marker='v', \n", + " c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)),\n", + " edgecolor='black')\n", + " plt.contour(XX, YY, Z_qke, colors=['k', 'k', 'k'], linestyles=['--', '-', '--'],\n", + " levels=[-.2, 0, .2])\n", + "\n", + "# To make sure we didn't make any mistake, check if the kernel function satisfies K(x, x)=1\n", + "print('Check if K(x, x) = 1?',\n", + " bool(abs(q_kernel_estimator(np.array([1. ,1.]), np.array([1., 1.])) - 1) < 1e-6))" + ] + }, + { + "cell_type": "markdown", + "id": "close-description", + "metadata": {}, + "source": [ + "Then, let's try to use a support vector machine with a quantum kernel (QKE-SVM) to classify our data:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "driving-belize", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Let's see how the QKE-SVM performs on the training on both the training and testing data:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create the progress bar and the total kernel evaluation number N needed for training and prediction\n", + "pbar = tqdm(total=100, \n", + " desc='Training and predicting with QKE-SVM', \n", + " bar_format=bar_format_string)\n", + "N = len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test)\n", + "\n", + "# Create a support vector machine with a quantum kernel\n", + "svm_qke = svm.SVC(kernel=q_kernel_matrix)\n", + "\n", + "# Train the svm with training data\n", + "svm_qke.fit(X_train, y_train)\n", + "\n", + "# See how the svm classifies the training and testing data\n", + "predict_svm_qke_train = svm_qke.predict(X_train)\n", + "predict_svm_qke_test = svm_qke.predict(X_test)\n", + "\n", + "# Calculate the accuracy\n", + "accuracy_train = np.array(predict_svm_qke_train == y_train, dtype=int).sum()/len(y_train)\n", + "accuracy_test = np.array(predict_svm_qke_test == y_test, dtype=int).sum()/len(y_test)\n", + "\n", + "# Visualize the result\n", + "pbar.close()\n", + "clear_output()\n", + "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n", + "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n", + " c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_train, dtype=np.float32)))\n", + "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n", + "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n", + " c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_test, dtype=np.float32)))\n", + "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n", + "print(\"Let's see how the QKE-SVM performs on the training on both the training and testing data:\")" + ] + }, + { + "cell_type": "markdown", + "id": "radio-freeze", + "metadata": {}, + "source": [ + "We can also visualize the decision function, also the decision boundary with margins of $\\pm 0.2$:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "dynamic-colonial", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Calculating the decision function of QKE-SVM: 100%|██████████████████████████████▉|[00:09<00:00, 10.96it/s]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Create the progress bar and the total kernel evaluation number N needed for visualizing the decision function\n", + "pbar = tqdm(total=100, \n", + " desc='Calculating the decision function of QKE-SVM', \n", + " bar_format=bar_format_string)\n", + "N = 10 ** 2 * len(X_train)\n", + " \n", + "# Visualize the decision function\n", + "visualize_decision_bound(svm_qke)\n", + "pbar.close()" + ] + }, + { + "cell_type": "markdown", + "id": "quantitative-reliance", + "metadata": {}, + "source": [ + "We can see that the quantum kernel has the ability to learn non-linearity correctly. As a matter of fact, the performance of quantum kernel methods in classification depends on whether the quantum feature map can distinguish non-trivial patterns hidden in the data. Currently, people are still exploring how to design a good quantum kernel: First, we may try different designs of encoding circuits; Second, we can train the quantum feature map to improve its classification accuracy [5-6]; Finally, we can also try variants of the quantum kernels [7]. \n", + "\n", + "In the following part, we will introduce another special kind of quantum kernel - projected quantum kernel. " + ] + }, + { + "cell_type": "markdown", + "id": "residential-williams", + "metadata": {}, + "source": [ + "### Projected quantum kernel\n", + "\n", + "It was mentioned above that quantum kernel methods can potentially distinguish intractable patterns by mapping classical data vectors into a quantum feature space via a quantum feature map. However, as the quantum feature space - the Hilbert space's dimensionality grows exponentially with the number of qubits, nearly all quantum states will be perpendicular to each other when we have a large number of qubits. Then the kernel matrix will just become an identity matrix $K_{ij} = K(\\mathbf{x}_j, \\mathbf{x}_i) \\sim {I}$, and the kernel methods would fail. To avoid this problem caused by extra dimensionality, we first need to extract features from the Hilbert space and then construct the kernel function with these extracted features. Following this idea, a variant of quantum kernel - projected quantum kernel is proposed : By projecting the quantum feature vectors back into the classical space with a set of measurements, the dimensionality problem is mitigated [7]. Also, as the projection can preserve important features of the quantum feature space, the projected kernel can still gain a quantum advantage. \n", + "\n", + "There are several kinds of projected quantum kernels, here we choose the most rudimentary one:\n", + "\n", + "$$\n", + "K^{P}(x_i,x_j) = \\exp\\left(-\\gamma\\sum\\limits_{k}\\sum\\limits_{P\\in \\mathcal{M}}( {\\rm Tr} (P\\rho(x_i)_k)-{\\rm Tr}(P\\rho(x_j)_k))^{2}\\right),\n", + "\\tag{13}\n", + "$$\n", + "\n", + "where $\\rho(x_i)_k$ is the reduce density matrix of qubits $k$, $\\mathcal{M}$ a set of measurements on the reduce density matrix. Here we take $k = 0, 1$ and $M = \\{X, Y, Z \\}$, which means using Pauli measurements to measure every single qubit at the output.\n", + "\n", + "Let's first try to implement a projected quantum kernel circuit with Paddle Quantum:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "acute-environment", + "metadata": {}, + "outputs": [], + "source": [ + "# First we can create a circuit to calculate the feature map \n", + "def projected_q_feature_map(x):\n", + " # turn data into tensor\n", + " x = paddle.to_tensor(x)\n", + " \n", + " # Update the progress bar\n", + " global N\n", + " pbar.update(100/N)\n", + " \n", + " init_state = paddle_quantum.state.zero_state(2)\n", + "\n", + " res = []\n", + " #　Take a projected measurement, returning its expected value as a classical feature\n", + " for op_pauli in ['z0', 'z1', 'x0', 'x1', 'y0', 'y1']:\n", + " cir = paddle_quantum.ansatz.Sequential()\n", + " cir.append(IQPEncoding(qubits_idx=[[0, 1]], feature=x))\n", + " state = cir[0](init_state)\n", + " hamiltonian = paddle_quantum.Hamiltonian([[1.0, op_pauli]])\n", + " cir.append(paddle_quantum.loss.ExpecVal(hamiltonian))\n", + " res.append(cir[1](state).numpy()[0])\n", + " return res\n", + "\n", + "# to compute the projected quantum kernel based on the feature vectors\n", + "def p_quantum_kernel_estimator(x1, x2):\n", + " \n", + " # compute the feature vector of each data and return the kernel function value\n", + " p_feature_vector_1 = np.array(projected_q_feature_map(x1))\n", + " p_feature_vector_2 = np.array(projected_q_feature_map(x2))\n", + " \n", + " return np.exp(-((p_feature_vector_1 - p_feature_vector_2) ** 2).sum())\n", + "\n", + "# similarly, define the kernel matrix as required \n", + "def p_quantum_kernel_matrix(X1, X2):\n", + " return np.array([[p_quantum_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])" + ] + }, + { + "cell_type": "markdown", + "id": "round-bandwidth", + "metadata": {}, + "source": [ + "Then, we replace the quantum kernel in the support vector machine with a projected quantum kernel, and see how the projected kernel performs on this classification task:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "alert-royal", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Let's see how the PQK-SVM performs on the training on both the training and testing data:\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Set the progress bar and the total kernel evaluation number N needed for training and prediction\n", + "pbar = tqdm(total=100, \n", + " desc='Training and predicting with PQK-SVM', \n", + " bar_format=bar_format_string)\n", + "N = 2 * (len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test))\n", + "\n", + "# Create a support vector machine with a quantum kernel\n", + "svm_pqk = svm.SVC(kernel=p_quantum_kernel_matrix)\n", + "\n", + "# Train the svm with training data\n", + "svm_pqk.fit(X_train, y_train)\n", + "\n", + "# See how the svm classifies the training and testing data\n", + "predict_svm_pqk_train = svm_pqk.predict(X_train)\n", + "predict_svm_pqk_test = svm_pqk.predict(X_test)\n", + "\n", + "# Calculate the accuracy\n", + "accuracy_train = np.array(predict_svm_pqk_train == y_train, dtype=int).sum()/len(y_train)\n", + "accuracy_test = np.array(predict_svm_pqk_test == y_test, dtype=int).sum()/len(y_test)\n", + "\n", + "# Visualize the result\n", + "pbar.close()\n", + "clear_output()\n", + "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n", + "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n", + " c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_train, dtype=np.float32)))\n", + "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n", + "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n", + " c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_test, dtype=np.float32)))\n", + "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n", + "print(\"Let's see how the PQK-SVM performs on the training on both the training and testing data:\")" + ] + }, + { + "cell_type": "markdown", + "id": "unavailable-stretch", + "metadata": {}, + "source": [ + "Let's also check the decision function given by the PQK-SVM:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "connected-final", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Calculating the decision function for PQK-SVM: 100%|█████████████████████████████▉|[01:17<00:00, 1.29it/s]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Set the progress bar and the total kernel evaluation number N needed for visualizing the decision function\n", + "pbar = tqdm(total=100, \n", + " desc='Calculating the decision function for PQK-SVM', \n", + " bar_format=bar_format_string)\n", + "N = 2 * 10 ** 2 * len(X_train)\n", + " \n", + "# Clear the progress bar and visualize the decision function\n", + "visualize_decision_bound(svm_pqk)\n", + "pbar.close()" + ] + }, + { + "cell_type": "markdown", + "id": "italic-failing", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "In quantum machine learning, people hope the design learning models which can gain quantum advantage by exploring the nature of quantum mechanics' laws. Recently, many connections are made between these quantum models and kernel methods, one of the most important classical machine learning approaches. In comparison to considering a parameterized quantum circuit as a \"quantum neural network\", where we focus on the variational ansatz $U(\\theta)$, the quantum kernel methods emphasize the importance of quantum feature map $U(x)$, which describes how the classical data vectors is mapped to the quantum states. This brings new perspectives to how we can design novel quantum machine learning algorithms. Therefore, we encourage readers to together explore the performance of various quantum kernel designs on different data sets.\n" + ] + }, + { + "cell_type": "markdown", + "id": "external-sterling", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## References\n", + "\n", + "[1] Schuld, Maria. \"Supervised quantum machine learning models are kernel methods.\" arXiv preprint [arXiv:2101.11020 (2021)](https://arxiv.org/abs/2101.11020).\n", + "\n", + "[2] Havlíček, Vojtěch, et al. \"Supervised learning with quantum-enhanced feature spaces.\" [Nature 567.7747 (2019): 209-212](https://arxiv.org/abs/1804.11326).\n", + "\n", + "[3] Liu, Yunchao, Srinivasan Arunachalam, and Kristan Temme. \"A rigorous and robust quantum speed-up in supervised machine learning.\" arXiv preprint [arXiv:2010.02174 (2020)](https://arxiv.org/abs/2010.02174).\n", + "\n", + "[4] Schuld, Maria, and Nathan Killoran. \"Quantum machine learning in feature Hilbert spaces.\" [Phys. Rev. Lett. 122.4 (2019): 040504](https://arxiv.org/abs/1803.07128).\n", + "\n", + "[5] Hubregtsen, Thomas, et al. \"Training Quantum Embedding Kernels on Near-Term Quantum Computers.\" arXiv preprint [arXiv:2105.02276(2021)](https://arxiv.org/abs/2105.02276).\n", + "\n", + "[6] Glick, Jennifer R., et al. \"Covariant quantum kernels for data with group structure.\" arXiv preprint [arXiv:2105.03406(2021)](https://arxiv.org/abs/2105.03406).\n", + "\n", + "[7] Huang, Hsin-Yuan, et al. \"Power of data in quantum machine learning.\" arXiv preprint [arXiv:2011.01938 (2020)](https://arxiv.org/abs/2011.01938).\n", + "\n", + "[8] Schölkopf, Bernhard, and Alexander J. Smola\"Learning with kernels: support vector machines, regularization, optimization, and beyond.\" [MIT Press(2002)](https://mitpress.mit.edu/books/learning-kernels)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.8.13" + }, + "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 + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/machine_learning/VQSVD_CN.ipynb b/tutorials/machine_learning/VQSVD_CN.ipynb new file mode 100644 index 0000000..421d134 --- /dev/null +++ b/tutorials/machine_learning/VQSVD_CN.ipynb @@ -0,0 +1,897 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# 变分量子奇异值分解\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 概览\n", + "\n", + "在本教程中，我们一起学习下经典奇异值分解（singular value decomposition, SVD）的概念以及我们自主研发的量子神经网络版本的量子奇异值分解（variational quantum SVD, VQSVD）[1] 是如何运作的。主体部分包括两个具体案例：\n", + "- 分解随机生成的 $8\\times8$ 复数矩阵；\n", + "- 应用在图像压缩上的效果。\n", + "\n", + "## 背景\n", + "\n", + "奇异值分解有非常多的应用，包括主成分分析（principal component analysis, PCA）、求解线性方程组和推荐系统。其主要任务是给定一个复数矩阵 $M \\in \\mathbb{C}^{m \\times n}$, 找到如下的分解形式：$M = UDV^\\dagger$。其中 $U_{m\\times m}$ 和 $V^\\dagger_{n\\times n}$ 是酉矩阵（Unitary matrix）, 满足性质 $UU^\\dagger = VV^\\dagger = I$。 \n", + "\n", + "- 矩阵 $U$ 的列向量 $|u_j\\rangle$ 被称为左奇异向量（left singular vectors）, $\\{|u_j\\rangle\\}_{j=1}^{m}$ 组成一组正交向量基。这些列向量本质上是矩阵 $MM^\\dagger$ 的本征向量。\n", + "- 类似的，矩阵 $V$ 的列向量 $\\{|v_j\\rangle\\}_{j=1}^{n}$ 是 $M^\\dagger M$ 的本征向量也组成一组正交向量基。\n", + "- 中间矩阵 $D_{m\\times n}$ 的对角元素上存储着由大到小排列的奇异值 $d_j$。 \n", + "\n", + "我们不妨先来看个简单的例子（为了方便讨论，我们假设以下出现的 $M$ 都是方阵）：\n", + "\n", + "$$\n", + "M = 2*X\\otimes Z + 6*Z\\otimes X + 3*I\\otimes I = \n", + "\\begin{bmatrix} \n", + "3 &6 &2 &0 \\\\\n", + "6 &3 &0 &-2 \\\\\n", + "2 &0 &3 &-6 \\\\\n", + "0 &-2 &-6 &3 \n", + "\\end{bmatrix}, \\tag{1}\n", + "$$\n", + "\n", + "那么该矩阵的奇异值分解可表示为:\n", + "\n", + "$$\n", + "M = UDV^\\dagger = \n", + "\\frac{1}{2}\n", + "\\begin{bmatrix} \n", + "-1 &-1 &1 &1 \\\\\n", + "-1 &-1 &-1 &-1 \\\\\n", + "-1 &1 &-1 &1 \\\\\n", + "1 &-1 &-1 &1 \n", + "\\end{bmatrix}\n", + "\\begin{bmatrix} \n", + "11 &0 &0 &0 \\\\\n", + "0 &7 &0 &0 \\\\\n", + "0 &0 &5 &0 \\\\\n", + "0 &0 &0 &1 \n", + "\\end{bmatrix}\n", + "\\frac{1}{2}\n", + "\\begin{bmatrix} \n", + "-1 &-1 &-1 &-1 \\\\\n", + "-1 &-1 &1 &1 \\\\\n", + "-1 &1 &1 &-1 \\\\\n", + "1 &-1 &1 &-1 \n", + "\\end{bmatrix}. \\tag{2}\n", + "$$\n", + "\n", + "我们通过下面几行代码引入必要的 library和 package。\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:47:34.433321Z", + "start_time": "2021-03-09T03:47:28.730090Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from numpy import pi as PI\n", + "from matplotlib import pyplot as plt\n", + "from scipy.stats import unitary_group\n", + "from scipy.linalg import norm\n", + "\n", + "import paddle\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.linalg import dagger" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# 画出优化过程中的学习曲线\n", + "def loss_plot(loss):\n", + " '''\n", + " loss is a list, this function plots loss over iteration\n", + " '''\n", + " plt.plot(list(range(1, len(loss)+1)), loss)\n", + " plt.xlabel('iteration')\n", + " plt.ylabel('loss')\n", + " plt.title('Loss Over Iteration')\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 经典奇异值分解\n", + "\n", + "那么在了解一些简单的数学背景之后， 我们来学习下如何用 Numpy 完成矩阵的奇异值分解。" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:47:34.469286Z", + "start_time": "2021-03-09T03:47:34.440399Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "我们想要分解的矩阵 M 是：\n", + "[[ 3.+0.j 6.+0.j 2.+0.j 0.+0.j]\n", + " [ 6.+0.j 3.+0.j 0.+0.j -2.+0.j]\n", + " [ 2.+0.j 0.+0.j 3.+0.j -6.+0.j]\n", + " [ 0.+0.j -2.+0.j -6.+0.j 3.+0.j]]\n" + ] + } + ], + "source": [ + "# 生成矩阵 M\n", + "def M_generator():\n", + " I = np.array([[1, 0], [0, 1]])\n", + " Z = np.array([[1, 0], [0, -1]])\n", + " X = np.array([[0, 1], [1, 0]])\n", + " Y = np.array([[0, -1j], [1j, 0]])\n", + " M = 2 *np.kron(X, Z) + 6 * np.kron(Z, X) + 3 * np.kron(I, I)\n", + " return M.astype('complex64')\n", + "\n", + "print('我们想要分解的矩阵 M 是：')\n", + "print(M_generator())" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:47:34.541244Z", + "start_time": "2021-03-09T03:47:34.489833Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "矩阵的奇异值从大到小分别是:\n", + "[11. 7. 5. 1.]\n", + "分解出的酉矩阵 U 是:\n", + "[[-0.5+0.j -0.5+0.j 0.5+0.j 0.5+0.j]\n", + " [-0.5+0.j -0.5+0.j -0.5+0.j -0.5+0.j]\n", + " [-0.5+0.j 0.5+0.j -0.5+0.j 0.5+0.j]\n", + " [ 0.5+0.j -0.5+0.j -0.5+0.j 0.5+0.j]]\n", + "分解出的酉矩阵 V_dagger 是:\n", + "[[-0.5+0.j -0.5+0.j -0.5+0.j 0.5+0.j]\n", + " [-0.5+0.j -0.5+0.j 0.5+0.j -0.5+0.j]\n", + " [-0.5+0.j 0.5+0.j 0.5+0.j 0.5+0.j]\n", + " [-0.5+0.j 0.5+0.j -0.5+0.j -0.5+0.j]]\n" + ] + } + ], + "source": [ + "# 我们只需要以下一行代码就可以完成 SVD \n", + "U, D, V_dagger = np.linalg.svd(M_generator(), full_matrices=True)\n", + "\n", + "# 打印分解结果\n", + "print(\"矩阵的奇异值从大到小分别是:\")\n", + "print(D)\n", + "print(\"分解出的酉矩阵 U 是:\")\n", + "print(U)\n", + "print(\"分解出的酉矩阵 V_dagger 是:\")\n", + "print(V_dagger)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:47:34.600873Z", + "start_time": "2021-03-09T03:47:34.565570Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 3.+0.j 6.+0.j 2.+0.j 0.+0.j]\n", + " [ 6.+0.j 3.+0.j 0.+0.j -2.+0.j]\n", + " [ 2.+0.j 0.+0.j 3.+0.j -6.+0.j]\n", + " [ 0.+0.j -2.+0.j -6.+0.j 3.+0.j]]\n" + ] + } + ], + "source": [ + "# 再组装回去，能不能复原矩阵？\n", + "M_reconst = np.matmul(U, np.matmul(np.diag(D), V_dagger))\n", + "print(M_reconst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "那当然是可以复原成原来的矩阵 $M$ 的！读者也可以自行修改矩阵，试试看不是方阵的情况。\n", + "\n", + "---\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 量子奇异值分解\n", + "\n", + "接下来我们来看看量子版本的奇异值分解是怎么一回事。简单的说，我们把矩阵分解这一问题巧妙的转换成了优化问题。通过以下四个步骤：\n", + "\n", + "- 准备一组正交向量基 $\\{|\\psi_j\\rangle\\}$, 不妨直接取计算基 $\\{ |000\\rangle, |001\\rangle,\\cdots |111\\rangle\\}$ （这是3量子比特的情形）\n", + "- 准备两个参数化的量子神经网络 $U(\\theta)$ 和 $V(\\phi)$ 分别用来学习左/右奇异向量\n", + "- 利用量子神经网络估算奇异值 $m_j = \\text{Re}\\langle\\psi_j|U(\\theta)^{\\dagger} M V(\\phi)|\\psi_j\\rangle$\n", + "- 设计损失函数并且利用飞桨来优化\n", + "\n", + "$$\n", + "L(\\theta,\\phi) = \\sum_{j=1}^T q_j\\times \\text{Re} \\langle\\psi_j|U(\\theta)^{\\dagger} M V(\\phi)|\\psi_j\\rangle, \\tag{3}\n", + "$$\n", + "\n", + "其中 $q_1>\\cdots>q_T>0$ 是可以调节的权重（超参数）, $T$ 表示我们想要学习到的阶数（rank）或者可以解释为总共要学习得到的奇异值个数。\n", + "\n", + "\n", + "\n", + "### 案例1：分解随机生成的 $8\\times8$ 复数矩阵\n", + "\n", + "接着我们来看一个具体的例子，这可以更好的解释整体流程。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:47:34.656799Z", + "start_time": "2021-03-09T03:47:34.620380Z" + }, + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "我们想要分解的矩阵 M 是：\n", + "[[6.+1.j 3.+9.j 7.+3.j 4.+7.j 6.+6.j 9.+8.j 2.+7.j 6.+4.j]\n", + " [7.+1.j 4.+4.j 3.+7.j 7.+9.j 7.+8.j 2.+8.j 5.+0.j 4.+8.j]\n", + " [1.+6.j 7.+8.j 5.+7.j 1.+0.j 4.+7.j 0.+7.j 9.+2.j 5.+0.j]\n", + " [8.+7.j 0.+2.j 9.+2.j 2.+0.j 6.+4.j 3.+9.j 8.+6.j 2.+9.j]\n", + " [4.+8.j 2.+6.j 6.+8.j 4.+7.j 8.+1.j 6.+0.j 1.+6.j 3.+6.j]\n", + " [8.+7.j 1.+4.j 9.+2.j 8.+7.j 9.+5.j 4.+2.j 1.+0.j 3.+2.j]\n", + " [6.+4.j 7.+2.j 2.+0.j 0.+4.j 3.+9.j 1.+6.j 7.+6.j 3.+8.j]\n", + " [1.+9.j 5.+9.j 5.+2.j 9.+6.j 3.+0.j 5.+3.j 1.+3.j 9.+4.j]]\n", + "矩阵的奇异值从大到小分别是:\n", + "[54.83484985 19.18141073 14.98866247 11.61419557 10.15927045 7.60223249\n", + " 5.81040539 3.30116001]\n" + ] + } + ], + "source": [ + "# 先固定随机种子， 为了能够复现结果\n", + "np.random.seed(42)\n", + "\n", + "# 设置量子比特数量，确定希尔伯特空间的维度\n", + "N = 3\n", + "\n", + "# 制作随机矩阵生成器\n", + "def random_M_generator():\n", + " M = np.random.randint(10, size = (2**N, 2**N)) + 1j*np.random.randint(10, size = (2**N, 2**N))\n", + " M1 = np.random.randint(10, size = (2**N, 2**N)) \n", + " return M\n", + "\n", + "M = random_M_generator()\n", + "M_err = np.copy(M)\n", + "\n", + "# 打印结果\n", + "print('我们想要分解的矩阵 M 是：')\n", + "print(M)\n", + "\n", + "U, D, V_dagger = np.linalg.svd(M, full_matrices=True)\n", + "print(\"矩阵的奇异值从大到小分别是:\")\n", + "print(D)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:47:34.692350Z", + "start_time": "2021-03-09T03:47:34.671114Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "选取的等差权重为：\n", + "[24.+0.j 21.+0.j 18.+0.j 15.+0.j 12.+0.j 9.+0.j 6.+0.j 3.+0.j]\n" + ] + } + ], + "source": [ + "# 超参数设置\n", + "N = 3 # 量子比特数量\n", + "T = 8 # 设置想要学习的阶数\n", + "ITR = 100 # 迭代次数\n", + "LR = 0.02 # 学习速率\n", + "SEED = 14 # 随机数种子\n", + "\n", + "# 设置等差的学习权重\n", + "weight = np.arange(3 * T, 0, -3).astype('complex128')\n", + "print('选取的等差权重为：')\n", + "print(weight)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们搭建如下的量子神经网络结构：" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:47:34.725007Z", + "start_time": "2021-03-09T03:47:34.702861Z" + } + }, + "outputs": [], + "source": [ + "# 设置电路参数\n", + "cir_depth = 20 # 电路深度\n", + "block_len = 2 # 每个模组的长度" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# 定义量子神经网络\n", + "def U_theta() -> Circuit:\n", + "\n", + " # 用 UAnsatz 初始化网络\n", + " cir = Circuit(N)\n", + " \n", + " # 搭建层级结构：\n", + " for _ in range(cir_depth):\n", + " cir.ry()\n", + " cir.rz()\n", + " cir.cnot()\n", + "\n", + " return cir" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "接着我们来完成算法的主体部分：\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:49:24.011232Z", + "start_time": "2021-03-09T03:47:40.712257Z" + } + }, + "outputs": [], + "source": [ + "class NET(paddle.nn.Layer):\n", + " def __init__(self, matrix: np.ndarray, weights: np.ndarray) -> None:\n", + " super(NET, self).__init__()\n", + " \n", + " # 创建用来学习 U_dagger 的量子神经网络\n", + " self.cir_U = U_theta()\n", + " \n", + " # 创建用来学习 V_dagger 的量子神经网络\n", + " self.cir_V = U_theta()\n", + " \n", + " # 将 Numpy array 转换成 Paddle 支持的 Tensor\n", + " self.M = paddle.to_tensor(matrix)\n", + " self.weight = paddle.to_tensor(weights)\n", + "\n", + " # 定义损失函数和前向传播机制\n", + " def forward(self):\n", + " \n", + " # 获取量子神经网络的酉矩阵表示\n", + " U = self.cir_U.unitary_matrix()\n", + " U_dagger = dagger(U)\n", + " \n", + " V = self.cir_V.unitary_matrix()\n", + " V_dagger = dagger(V)\n", + " \n", + " # 初始化损失函数和奇异值存储器\n", + " loss = 0 \n", + " singular_values = np.zeros(T)\n", + " \n", + " # 定义损失函数\n", + " for i in range(T):\n", + " loss -= paddle.real(self.weight)[i] * paddle.real(U_dagger @ self.M @ V)[i][i]\n", + " singular_values[i] = paddle.real(U_dagger @ self.M @ V)[i][i].numpy()\n", + " \n", + " # 函数返回两个矩阵 U 和 V_dagger 学习的奇异值以及损失函数 \n", + " return U, V_dagger, loss, singular_values\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 0 loss: -262.8009\n", + "iter: 10 loss: -1886.9825\n", + "iter: 20 loss: -2182.6929\n", + "iter: 30 loss: -2280.7289\n", + "iter: 40 loss: -2315.2391\n", + "iter: 50 loss: -2333.0160\n", + "iter: 60 loss: -2342.7280\n", + "iter: 70 loss: -2348.7263\n", + "iter: 80 loss: -2353.2796\n", + "iter: 90 loss: -2356.9237\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 记录优化中间过程\n", + "loss_list, singular_value_list = [], []\n", + "U_learned, V_dagger_learned = [], []\n", + " \n", + "# 确定网络的参数维度\n", + "net = NET(M, weight)\n", + "\n", + "# 一般来说，我们利用 Adam 优化器来获得相对好的收敛\n", + "# 当然你可以改成 SGD 或者是 RMS prop.\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + "# 优化循环\n", + "for itr in range(ITR):\n", + "\n", + " # 前向传播计算损失函数\n", + " U, V_dagger, loss, singular_values = net()\n", + "\n", + " # 反向传播极小化损失函数\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + "\n", + " # 记录优化中间结果\n", + " loss_list.append(loss[0][0].numpy())\n", + " singular_value_list.append(singular_values)\n", + " \n", + " if itr% 10 == 0:\n", + " print('iter:', itr,'loss:','%.4f'% loss.numpy()[0])\n", + " \n", + "# 绘制学习曲线\n", + "loss_plot(loss_list)\n", + "\n", + "# 记录最后学出的两个酉矩阵 \n", + "U_learned = U.numpy()\n", + "V_dagger_learned = V_dagger.numpy()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "接着我们来探究下量子版本的奇异值分解的精度问题。在上述部分，我们提到过可以用分解得到的更少的信息来表达原矩阵。具体来说，就是用前 $T$ 个奇异值和前 $T$ 列左右奇异向量重构一个矩阵：\n", + "\n", + "$$\n", + "M_{re}^{(T)} = UDV^{\\dagger}, \\tag{4}\n", + "$$\n", + "\n", + "并且对于一个本身秩 (rank) 为 $r$ 的矩阵 $M$, 误差随着使用奇异值的数量变多会越来越小。经典的奇异值算法可以保证：\n", + "\n", + "$$\n", + "\\lim_{T\\rightarrow r} ||M - M_{re}^{(T)}||^2_2 = 0, \\tag{5}\n", + "$$\n", + "\n", + "其中矩阵间的距离测量由 Frobenius-norm 来计算,\n", + "\n", + "$$\n", + "||M||_2 = \\sqrt{\\sum_{i,j} |M_{ij}|^2}. \\tag{6}\n", + "$$\n", + "\n", + "目前量子版本的奇异值分解还需要很长时间的优化，理论上只能保证上述误差不断减小。" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:49:24.407257Z", + "start_time": "2021-03-09T03:49:24.027591Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "singular_value = singular_value_list[-1]\n", + "err_subfull, err_local, err_SVD = [], [], []\n", + "U, D, V_dagger = np.linalg.svd(M, full_matrices=True)\n", + "\n", + "# 计算 Frobenius-norm 误差\n", + "for i in range(T):\n", + " lowrank_mat = np.matrix(U[:, :i]) * np.diag(D[:i])* np.matrix(V_dagger[:i, :])\n", + " recons_mat = np.matrix(U_learned[:, :i]) * np.diag(singular_value[:i])* np.matrix(V_dagger_learned[:i, :])\n", + " err_local.append(norm(lowrank_mat - recons_mat)) \n", + " err_subfull.append(norm(M_err - recons_mat))\n", + " err_SVD.append(norm(M_err- lowrank_mat))\n", + "\n", + "\n", + "# 画图 \n", + "fig, ax = plt.subplots()\n", + "ax.plot(list(range(1, T+1)), err_subfull, \"o-.\", \n", + " label = 'Reconstruction via VQSVD')\n", + "ax.plot(list(range(1, T+1)), err_SVD, \"^--\", \n", + " label='Reconstruction via SVD')\n", + "plt.xlabel('Singular Value Used (Rank)', fontsize = 14)\n", + "plt.ylabel('Norm Distance', fontsize = 14)\n", + "leg = plt.legend(frameon=True)\n", + "leg.get_frame().set_edgecolor('k')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "### 案例2：图像压缩\n", + "\n", + "为了做图像处理，我们先引入必要的 package。" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:50:17.225100Z", + "start_time": "2021-03-09T03:50:17.151352Z" + } + }, + "outputs": [], + "source": [ + "# 图像处理包 PIL\n", + "from PIL import Image\n", + "\n", + "# 打开提前准备好的图片\n", + "img = Image.open('./figures/MNIST_32.png')\n", + "imgmat = np.array(list(img.getdata(band=0)), float)\n", + "imgmat.shape = (img.size[1], img.size[0])\n", + "imgmat = np.matrix(imgmat)/255" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:50:18.337792Z", + "start_time": "2021-03-09T03:50:17.231211Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 然后我们看看经典奇异值的分解效果\n", + "U, sigma, V = np.linalg.svd(imgmat)\n", + "\n", + "for i in range(5, 16, 5):\n", + " reconstimg = np.matrix(U[:, :i]) * np.diag(sigma[:i]) * np.matrix(V[:i, :])\n", + " plt.imshow(reconstimg, cmap='gray')\n", + " title = \"n = %s\" % i\n", + " plt.title(title)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:50:18.966739Z", + "start_time": "2021-03-09T03:50:18.950606Z" + } + }, + "outputs": [], + "source": [ + "# 然后我们再来看看量子版本的分解效果：\n", + "\n", + "# 超参数设置\n", + "N = 5 # 量子比特数量\n", + "T = 8 # 设置想要学习的阶数\n", + "ITR = 200 # 迭代次数\n", + "LR = 0.02 # 学习速率\n", + "SEED = 14 # 随机数种子\n", + "\n", + "# 设置等差的学习权重\n", + "weight = np.arange(2 * T, 0, -2).astype('complex128')\n", + "\n", + "\n", + "def Mat_generator():\n", + " imgmat = np.array(list(img.getdata(band=0)), float)\n", + " imgmat.shape = (img.size[1], img.size[0])\n", + " lenna = np.matrix(imgmat)\n", + " return lenna.astype('complex128')\n", + "\n", + "M_err = Mat_generator()\n", + "U, D, V_dagger = np.linalg.svd(Mat_generator(), full_matrices=True)\n", + "\n", + "# 设置电路参数\n", + "cir_depth = 40 # 电路深度\n", + "block_len = 1 # 每个模组的长度" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:50:19.553293Z", + "start_time": "2021-03-09T03:50:19.531180Z" + } + }, + "outputs": [], + "source": [ + "# 重新定义量子神经网络\n", + "def U_theta():\n", + "\n", + " # 用 Circuit 初始化网络\n", + " cir = Circuit(N)\n", + " \n", + " # 搭建层级结构：\n", + " for _ in range(cir_depth):\n", + " cir.ry()\n", + " cir.cnot()\n", + "\n", + " return cir" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:59:58.649381Z", + "start_time": "2021-03-09T03:54:30.126561Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 0 loss: -4291.2284\n", + "iter: 10 loss: -103444.3877\n", + "iter: 20 loss: -126821.2327\n", + "iter: 30 loss: -135986.5470\n", + "iter: 40 loss: -141457.8124\n", + "iter: 50 loss: -145045.8896\n", + "iter: 60 loss: -147249.5471\n", + "iter: 70 loss: -149020.3769\n", + "iter: 80 loss: -150570.5096\n", + "iter: 90 loss: -151898.1960\n", + "iter: 100 loss: -152989.3110\n", + "iter: 110 loss: -153869.6654\n", + "iter: 120 loss: -154547.8973\n", + "iter: 130 loss: -155069.0768\n", + "iter: 140 loss: -155459.7348\n", + "iter: 150 loss: -155744.3048\n", + "iter: 160 loss: -155957.9127\n", + "iter: 170 loss: -156124.0155\n", + "iter: 180 loss: -156257.4063\n", + "iter: 190 loss: -156367.2717\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 记录优化中间过程\n", + "loss_list, singular_value_list = [], []\n", + "U_learned, V_dagger_learned = [], []\n", + " \n", + "net = NET(Mat_generator(), weight)\n", + "\n", + "# 一般来说，我们利用 Adam 优化器来获得相对好的收敛\n", + "# 当然你可以改成 SGD 或者是 RMS prop.\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + "# 优化循环\n", + "for itr in range(ITR):\n", + "\n", + " # 前向传播计算损失函数\n", + " U, V_dagger, loss, singular_values = net()\n", + "\n", + " # 反向传播极小化损失函数\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + "\n", + " # 记录优化中间结果\n", + " loss_list.append(loss[0][0].numpy())\n", + " singular_value_list.append(singular_values)\n", + " \n", + " if itr% 10 == 0:\n", + " print('iter:', itr,'loss:','%.4f'% loss.numpy()[0])\n", + "\n", + "# 记录最后学出的两个酉矩阵 \n", + "U_learned = U.numpy()\n", + "V_dagger_learned = V_dagger.numpy()\n", + "\n", + "singular_value = singular_value_list[-1]\n", + "mat = np.matrix(U_learned.real[:, :T]) * np.diag(singular_value[:T])* np.matrix(V_dagger_learned.real[:T, :])\n", + "\n", + "reconstimg = mat\n", + "plt.imshow(reconstimg, cmap='gray')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Wang, X., Song, Z., & Wang, Y. Variational Quantum Singular Value Decomposition. [Quantum, 5, 483 (2021).](https://quantum-journal.org/papers/q-2021-06-29-483/)" + ] + } + ], + "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.8.13" + }, + "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": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorials/machine_learning/VQSVD_EN.ipynb b/tutorials/machine_learning/VQSVD_EN.ipynb new file mode 100644 index 0000000..c243bad --- /dev/null +++ b/tutorials/machine_learning/VQSVD_EN.ipynb @@ -0,0 +1,904 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Variational Quantum Singular Value Decomposition\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "In this tutorial, we will go through the concept of classical singular value decomposition (SVD) and the quantum neural network (QNN) version of variational quantum singular value decomposition (VQSVD) [1]. The tutorial consists of the following two parts: \n", + "- Decompose a randomly generated $8\\times8$ complex matrix; \n", + "- Apply SVD on image compression." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Background\n", + "\n", + "Singular value decomposition (SVD) has many applications, including principal component analysis (PCA), solving linear equations and recommender systems. The main task is formulated as following:\n", + "> Given a complex matrix $M \\in \\mathbb{C}^{m \\times n}$, find the decomposition in form $M = UDV^\\dagger$, where $U_{m\\times m}$ and $V^\\dagger_{n\\times n}$ are unitary matrices, which satisfy the property $UU^\\dagger = VV^\\dagger = I$.\n", + "\n", + "- The column vectors $|u_j\\rangle$ of the unitary matrix $U$ are called left singular vectors $\\{|u_j\\rangle\\}_{j=1}^{m}$ form an orthonormal basis. These column vectors are the eigenvectors of the matrix $MM^\\dagger$.\n", + "- Similarly, the column vectors $\\{|v_j\\rangle\\}_{j=1}^{n}$ of the unitary matrix $V$ are the eigenvectors of $M^\\dagger M$ and form an orthonormal basis.\n", + "- The diagonal elements of the matrix $D_{m\\times n}$ are singular values $d_j$ arranged in a descending order.\n", + "\n", + "For the convenience, we assume that the $M$ appearing below are all square matrices. Let's first look at an example: \n", + "\n", + "$$\n", + "M = 2*X\\otimes Z + 6*Z\\otimes X + 3*I\\otimes I = \n", + "\\begin{bmatrix} \n", + "3 &6 &2 &0 \\\\\n", + "6 &3 &0 &-2 \\\\\n", + "2 &0 &3 &-6 \\\\\n", + "0 &-2 &-6 &3 \n", + "\\end{bmatrix}, \\tag{1}\n", + "$$\n", + "\n", + "Then the singular value decomposition of the matrix can be expressed as:\n", + "\n", + "$$\n", + "M = UDV^\\dagger = \n", + "\\frac{1}{2}\n", + "\\begin{bmatrix} \n", + "-1 &-1 &1 &1 \\\\\n", + "-1 &-1 &-1 &-1 \\\\\n", + "-1 &1 &-1 &1 \\\\\n", + "1 &-1 &-1 &1 \n", + "\\end{bmatrix}\n", + "\\begin{bmatrix} \n", + "11 &0 &0 &0 \\\\\n", + "0 &7 &0 &0 \\\\\n", + "0 &0 &5 &0 \\\\\n", + "0 &0 &0 &1 \n", + "\\end{bmatrix}\n", + "\\frac{1}{2}\n", + "\\begin{bmatrix} \n", + "-1 &-1 &-1 &-1 \\\\\n", + "-1 &-1 &1 &1 \\\\\n", + "-1 &1 &1 &-1 \\\\\n", + "1 &-1 &1 &-1 \n", + "\\end{bmatrix}. \\tag{2}\n", + "$$\n", + "\n", + "Import packages." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:44:34.008567Z", + "start_time": "2021-03-09T03:44:29.796997Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "from numpy import pi as PI\n", + "from matplotlib import pyplot as plt\n", + "from scipy.stats import unitary_group\n", + "from scipy.linalg import norm\n", + "\n", + "import paddle\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.linalg import dagger" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Draw the learning curve in the optimization process\n", + "def loss_plot(loss):\n", + " '''\n", + " loss is a list, this function plots loss over iteration\n", + " '''\n", + " plt.plot(list(range(1, len(loss)+1)), loss)\n", + " plt.xlabel('iteration')\n", + " plt.ylabel('loss')\n", + " plt.title('Loss Over Iteration')\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Classical Singular Value Decomposition\n", + "\n", + "With the above mathematical definition, one can realize SVD numerically through NumPy." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:44:34.056721Z", + "start_time": "2021-03-09T03:44:34.012222Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The matrix M we want to decompose is: \n", + "[[ 3.+0.j 6.+0.j 2.+0.j 0.+0.j]\n", + " [ 6.+0.j 3.+0.j 0.+0.j -2.+0.j]\n", + " [ 2.+0.j 0.+0.j 3.+0.j -6.+0.j]\n", + " [ 0.+0.j -2.+0.j -6.+0.j 3.+0.j]]\n" + ] + } + ], + "source": [ + "# Generate matrix M\n", + "def M_generator():\n", + " I = np.array([[1, 0], [0, 1]])\n", + " Z = np.array([[1, 0], [0, -1]])\n", + " X = np.array([[0, 1], [1, 0]])\n", + " Y = np.array([[0, -1j], [1j, 0]])\n", + " M = 2 *np.kron(X, Z) + 6 * np.kron(Z, X) + 3 * np.kron(I, I)\n", + " return M.astype('complex64')\n", + "\n", + "print('The matrix M we want to decompose is: ')\n", + "print(M_generator())" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:44:34.093725Z", + "start_time": "2021-03-09T03:44:34.063353Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The singular values of the matrix from large to small are:\n", + "[11. 7. 5. 1.]\n", + "The decomposed unitary matrix U is:\n", + "[[-0.5+0.j -0.5+0.j 0.5+0.j 0.5+0.j]\n", + " [-0.5+0.j -0.5+0.j -0.5+0.j -0.5+0.j]\n", + " [-0.5+0.j 0.5+0.j -0.5+0.j 0.5+0.j]\n", + " [ 0.5+0.j -0.5+0.j -0.5+0.j 0.5+0.j]]\n", + "The decomposed unitary matrix V_dagger is:\n", + "[[-0.5+0.j -0.5+0.j -0.5+0.j 0.5+0.j]\n", + " [-0.5+0.j -0.5+0.j 0.5+0.j -0.5+0.j]\n", + " [-0.5+0.j 0.5+0.j 0.5+0.j 0.5+0.j]\n", + " [-0.5+0.j 0.5+0.j -0.5+0.j -0.5+0.j]]\n" + ] + } + ], + "source": [ + "# We only need the following line of code to complete SVD\n", + "U, D, V_dagger = np.linalg.svd(M_generator(), full_matrices=True)\n", + "\n", + "\n", + "# Print decomposition results\n", + "print(\"The singular values of the matrix from large to small are:\")\n", + "print(D)\n", + "print(\"The decomposed unitary matrix U is:\")\n", + "print(U)\n", + "print(\"The decomposed unitary matrix V_dagger is:\")\n", + "print(V_dagger)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:44:34.112670Z", + "start_time": "2021-03-09T03:44:34.098847Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[ 3.+0.j 6.+0.j 2.+0.j 0.+0.j]\n", + " [ 6.+0.j 3.+0.j 0.+0.j -2.+0.j]\n", + " [ 2.+0.j 0.+0.j 3.+0.j -6.+0.j]\n", + " [ 0.+0.j -2.+0.j -6.+0.j 3.+0.j]]\n" + ] + } + ], + "source": [ + "# Then assemble it back, can we restore the original matrix?\n", + "M_reconst = np.matmul(U, np.matmul(np.diag(D), V_dagger))\n", + "print(M_reconst)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Surely, we can be restored the original matrix $M$! One can further modify the matrix, see what happens if it is not a square matrix.\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Quantum Singular Value Decomposition\n", + "\n", + "Next, let's take a look at what the quantum version of singular value decomposition is all about. In summary, we transform the problem of matrix factorization into an optimization problem with the variational principle of singular values. Specifically, this is achieved through the following four steps:\n", + "\n", + "- Prepare an orthonormal basis $\\{|\\psi_j\\rangle\\}$, one can take the computational basis $\\{ |000\\rangle, |001\\rangle,\\cdots |111\\rangle\\}$ (this is in the case of 3 qubits)\n", + "- Prepare two parameterized quantum neural networks $U(\\theta)$ and $V(\\phi)$ to learn left/right singular vectors respectively\n", + "- Use quantum neural network to estimate singular values $m_j = \\text{Re}\\langle\\psi_j|U(\\theta)^{\\dagger} M V(\\phi)|\\psi_j\\rangle$\n", + "- Design the loss function $\\mathcal{L}(\\theta)$ and use PaddlePaddle Deep Learning framework to maximize the following quantity, \n", + "\n", + "$$\n", + "L(\\theta,\\phi) = \\sum_{j=1}^T q_j\\times \\text{Re} \\langle\\psi_j|U(\\theta)^{\\dagger} MV(\\phi)|\\psi_j\\rangle. \\tag{3}\n", + "$$\n", + "\n", + "Where $q_1>\\cdots>q_T>0$ is the adjustable weights (hyperparameter), and $T$ represents the rank we want to learn or the total number of singular values to be learned.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Case 1: Decompose a randomly generated $8\\times8$ complex matrix\n", + "\n", + "Then we look at a specific example, which can better explain the overall process." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:44:34.132465Z", + "start_time": "2021-03-09T03:44:34.116446Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The matrix M we want to decompose is:\n", + "[[6.+1.j 3.+9.j 7.+3.j 4.+7.j 6.+6.j 9.+8.j 2.+7.j 6.+4.j]\n", + " [7.+1.j 4.+4.j 3.+7.j 7.+9.j 7.+8.j 2.+8.j 5.+0.j 4.+8.j]\n", + " [1.+6.j 7.+8.j 5.+7.j 1.+0.j 4.+7.j 0.+7.j 9.+2.j 5.+0.j]\n", + " [8.+7.j 0.+2.j 9.+2.j 2.+0.j 6.+4.j 3.+9.j 8.+6.j 2.+9.j]\n", + " [4.+8.j 2.+6.j 6.+8.j 4.+7.j 8.+1.j 6.+0.j 1.+6.j 3.+6.j]\n", + " [8.+7.j 1.+4.j 9.+2.j 8.+7.j 9.+5.j 4.+2.j 1.+0.j 3.+2.j]\n", + " [6.+4.j 7.+2.j 2.+0.j 0.+4.j 3.+9.j 1.+6.j 7.+6.j 3.+8.j]\n", + " [1.+9.j 5.+9.j 5.+2.j 9.+6.j 3.+0.j 5.+3.j 1.+3.j 9.+4.j]]\n", + "The singular values of the matrix M are:\n", + "[54.83484985 19.18141073 14.98866247 11.61419557 10.15927045 7.60223249\n", + " 5.81040539 3.30116001]\n" + ] + } + ], + "source": [ + "# First fix the random seed, in order to reproduce the results at any time\n", + "np.random.seed(42)\n", + "\n", + "# Set the number of qubits, which determines the dimension of the Hilbert space\n", + "N = 3\n", + "\n", + "# Make a random matrix generator\n", + "def random_M_generator():\n", + " M = np.random.randint(10, size = (2**N, 2**N)) + 1j*np.random.randint(10, size = (2**N, 2**N))\n", + " return M\n", + "\n", + "M = random_M_generator()\n", + "M_err = np.copy(M)\n", + "\n", + "\n", + "# Output the matrix M\n", + "print('The matrix M we want to decompose is:')\n", + "print(M)\n", + "\n", + "# Apply SVD and record the exact singular values\n", + "U, D, V_dagger = np.linalg.svd(M, full_matrices=True)\n", + "print(\"The singular values of the matrix M are:\")\n", + "print(D)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:44:34.147570Z", + "start_time": "2021-03-09T03:44:34.138265Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The selected weight is:\n", + "[24.+0.j 21.+0.j 18.+0.j 15.+0.j 12.+0.j 9.+0.j 6.+0.j 3.+0.j]\n" + ] + } + ], + "source": [ + "# Hyperparameter settings\n", + "N = 3 # Number of qubits\n", + "T = 8 # Set the number of rank you want to learn\n", + "ITR = 100 # Number of iterations\n", + "LR = 0.02 # Learning rate\n", + "SEED = 14 # Random seed\n", + "\n", + "# Set the learning weight \n", + "weight = np.arange(3 * T, 0, -3).astype('complex128')\n", + "print('The selected weight is:')\n", + "print(weight)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We design QNN with the following structure:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:44:34.245692Z", + "start_time": "2021-03-09T03:44:34.226859Z" + } + }, + "outputs": [], + "source": [ + "# Set circuit parameters\n", + "cir_depth = 20 # circuit depth\n", + "block_len = 2 # length of each block" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Define quantum neural network\n", + "def U_theta() -> Circuit:\n", + "\n", + " # Initialize the network with Circuit\n", + " cir = Circuit(N)\n", + " \n", + " # Build a hierarchy：\n", + " for _ in range(cir_depth):\n", + " cir.ry()\n", + " cir.rz()\n", + " cir.cnot()\n", + "\n", + " return cir" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we complete the main part of the algorithm:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:46:12.944634Z", + "start_time": "2021-03-09T03:44:50.626213Z" + } + }, + "outputs": [], + "source": [ + "class NET(paddle.nn.Layer):\n", + " def __init__(self, matrix: np.ndarray, weights: np.ndarray) -> None:\n", + " super(NET, self).__init__()\n", + " \n", + " # Create the parameter theta for learning U\n", + " self.cir_U = U_theta()\n", + " \n", + " # Create a parameter phi to learn V_dagger\n", + " self.cir_V = U_theta()\n", + " \n", + " # Convert Numpy array to Tensor supported in Paddle\n", + " self.M = paddle.to_tensor(matrix)\n", + " self.weight = paddle.to_tensor(weights)\n", + "\n", + " # Define loss function and forward propagation mechanism\n", + " def forward(self):\n", + " \n", + " # Get the unitary matrix representation of the quantum neural network\n", + " U = self.cir_U.unitary_matrix()\n", + " U_dagger = dagger(U)\n", + " \n", + " \n", + " V = self.cir_V.unitary_matrix()\n", + " V_dagger = dagger(V)\n", + " \n", + " # Initialize the loss function and singular value memory\n", + " loss = 0\n", + " singular_values = np.zeros(T)\n", + " \n", + " # Define loss function\n", + " for i in range(T):\n", + " loss -= paddle.real(self.weight)[i] * paddle.real(U_dagger @ self.M @ V)[i][i]\n", + " singular_values[i] = paddle.real(U_dagger @ self.M @ V)[i][i].numpy()\n", + " \n", + " # Function returns two matrices U and V_dagger, learned singular values and loss function\n", + " return U, V_dagger, loss, singular_values" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 0 loss: -43.6754\n", + "iter: 10 loss: -1533.6699\n", + "iter: 20 loss: -2002.1223\n", + "iter: 30 loss: -2137.2044\n", + "iter: 40 loss: -2200.9439\n", + "iter: 50 loss: -2267.5643\n", + "iter: 60 loss: -2329.0521\n", + "iter: 70 loss: -2359.0386\n", + "iter: 80 loss: -2367.3676\n", + "iter: 90 loss: -2372.0702\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Record the optimization process\n", + "loss_list, singular_value_list = [], []\n", + "U_learned, V_dagger_learned = [], []\n", + "\n", + " \n", + "# Determine the parameter dimension of the network\n", + "net = NET(M, weight)\n", + "\n", + "# We use Adam optimizer for better performance\n", + "# One can change it to SGD or RMSprop.\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + "# Optimization cycle\n", + "for itr in range(ITR):\n", + "\n", + " # Forward propagation to calculate loss function\n", + " U, V_dagger, loss, singular_values = net()\n", + "\n", + " # Back propagation minimizes the loss function\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + "\n", + " # Record optimization intermediate results\n", + " loss_list.append(loss[0][0].numpy())\n", + " singular_value_list.append(singular_values)\n", + " \n", + " if itr% 10 == 0:\n", + " print('iter:', itr,'loss:','%.4f'% loss.numpy()[0])\n", + "\n", + "# Draw a learning curve\n", + "loss_plot(loss_list)\n", + "\n", + "# Record the last two learned unitary matrices\n", + "U_learned = U.numpy()\n", + "V_dagger_learned = V_dagger.numpy()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now explore the accuracy of the quantum version of singular value decomposition. In the above section, we mentioned that the original matrix can be expressed with less information obtained by decomposition. Specifically, it uses the first $T$ singular values and the first $T$ left and right singular vectors to reconstruct a matrix:\n", + "\n", + "$$\n", + "M_{re}^{(T)} = UDV^{\\dagger}, \\tag{4}\n", + "$$\n", + "\n", + "For matrix $M$ with rank $r$, the error will decreasing dramatically as more and more singular values are used to reconstruct it. The classic singular value algorithm can guarantee:\n", + "\n", + "$$\n", + "\\lim_{T\\rightarrow r} ||M-M_{re}^{(T)}||^2_2 = 0, \\tag{5}\n", + "$$\n", + "\n", + "The distance measurement between the matrices is calculated by the Frobenius-norm,\n", + "\n", + "$$\n", + "||M||_2 = \\sqrt{\\sum_{i,j} |M_{ij}|^2}. \\tag{6}\n", + "$$\n", + "\n", + "The current quantum version of singular value decomposition still needs a lot of efforts to be optimized. In theory, it can only guarantee the reduction of accumulated errors." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:46:13.453107Z", + "start_time": "2021-03-09T03:46:12.949847Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "singular_value = singular_value_list[-1]\n", + "err_subfull, err_local, err_SVD = [], [], []\n", + "U, D, V_dagger = np.linalg.svd(M, full_matrices=True)\n", + "\n", + "\n", + "# Calculate the Frobenius-norm error\n", + "for i in range(T):\n", + " lowrank_mat = np.matrix(U[:, :i]) * np.diag(D[:i])* np.matrix(V_dagger[:i, :])\n", + " recons_mat = np.matrix(U_learned[:, :i]) * np.diag(singular_value[:i])* np.matrix(V_dagger_learned[:i, :])\n", + " err_local.append(norm(lowrank_mat - recons_mat)) \n", + " err_subfull.append(norm(M_err - recons_mat))\n", + " err_SVD.append(norm(M_err- lowrank_mat))\n", + "\n", + "\n", + "# Plot\n", + "fig, ax = plt.subplots()\n", + "ax.plot(list(range(1, T+1)), err_subfull, \"o-.\", \n", + " label = 'Reconstruction via VQSVD')\n", + "ax.plot(list(range(1, T+1)), err_SVD, \"^--\", \n", + " label='Reconstruction via SVD')\n", + "plt.xlabel('Singular Value Used (Rank)', fontsize = 14)\n", + "plt.ylabel('Norm Distance', fontsize = 14)\n", + "leg = plt.legend(frameon=True)\n", + "leg.get_frame().set_edgecolor('k')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "---\n", + "### Case 2: Image compression\n", + "\n", + "In order to fulfill image processing tasks, we first import the necessary package.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:47:14.486390Z", + "start_time": "2021-03-09T03:47:14.466171Z" + } + }, + "outputs": [], + "source": [ + "# Image processing package PIL\n", + "from PIL import Image\n", + "\n", + "# Open the picture prepared in advance\n", + "img = Image.open('./figures/MNIST_32.png')\n", + "imgmat = np.array(list(img.getdata(band=0)), float)\n", + "imgmat.shape = (img.size[1], img.size[0])\n", + "imgmat = np.matrix(imgmat)/255" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:47:15.837676Z", + "start_time": "2021-03-09T03:47:14.960968Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Then we look at the effect of the classic singular value decomposition\n", + "U, sigma, V = np.linalg.svd(imgmat)\n", + "\n", + "for i in range(5, 16, 5):\n", + " reconstimg = np.matrix(U[:, :i]) * np.diag(sigma[:i]) * np.matrix(V[:i, :])\n", + " plt.imshow(reconstimg, cmap='gray')\n", + " title = \"n = %s\" % i\n", + " plt.title(title)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:47:15.858695Z", + "start_time": "2021-03-09T03:47:15.847413Z" + } + }, + "outputs": [], + "source": [ + "# Hyper-parameters\n", + "N = 5 # Number of qubits\n", + "T = 8 # Set the number of rank you want to learn\n", + "ITR = 200 # Number of iterations\n", + "LR = 0.02 # Learning rate\n", + "SEED = 14 # Random number seed\n", + "\n", + "# Set the learning weight\n", + "weight = np.arange(2 * T, 0, -2).astype('complex128')\n", + "\n", + "# Convert the image into numpy array\n", + "def Mat_generator():\n", + " imgmat = np.array(list(img.getdata(band=0)), float)\n", + " imgmat.shape = (img.size[1], img.size[0])\n", + " lenna = np.matrix(imgmat)\n", + " return lenna.astype('complex128')\n", + "\n", + "M_err = Mat_generator()\n", + "U, D, V_dagger = np.linalg.svd(Mat_generator(), full_matrices=True)\n", + "\n", + "# Set circuit parameters\n", + "cir_depth = 40 # Circuit depth\n", + "block_len = 1 # The length of each module" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:47:16.002083Z", + "start_time": "2021-03-09T03:47:15.993385Z" + } + }, + "outputs": [], + "source": [ + "# Define quantum neural network\n", + "def U_theta():\n", + "\n", + " # Initialize the network with Circuit\n", + " cir = Circuit(N)\n", + " \n", + " # Build a hierarchy：\n", + " for _ in range(cir_depth):\n", + " cir.ry()\n", + " cir.cnot()\n", + "\n", + " return cir" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-09T03:53:07.440520Z", + "start_time": "2021-03-09T03:47:21.094099Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 0 loss: -5052.6035\n", + "iter: 10 loss: -108312.2634\n", + "iter: 20 loss: -127067.9950\n", + "iter: 30 loss: -138785.3241\n", + "iter: 40 loss: -144992.7031\n", + "iter: 50 loss: -148297.3650\n", + "iter: 60 loss: -150532.9232\n", + "iter: 70 loss: -152235.0095\n", + "iter: 80 loss: -153425.8656\n", + "iter: 90 loss: -154247.9781\n", + "iter: 100 loss: -154813.1122\n", + "iter: 110 loss: -155224.0510\n", + "iter: 120 loss: -155530.3507\n", + "iter: 130 loss: -155773.2695\n", + "iter: 140 loss: -155976.5740\n", + "iter: 150 loss: -156153.5143\n", + "iter: 160 loss: -156310.1349\n", + "iter: 170 loss: -156450.4223\n", + "iter: 180 loss: -156576.0634\n", + "iter: 190 loss: -156689.3533\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAPsAAAD5CAYAAADhukOtAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAYRklEQVR4nO2da2xdVXbH/ysmbzt2TF5OHEiAQASEycNECYkQHTQjQCMBUoXgA+IDmoyqQSrS9AOiUqFSPzBVAfGhogolmkxFeXQCIlSonRQNgpGAwYG8UzKQB8Fx4rwTQxJIsvrhnqhOdNbf1+fa5xr2/ydFud7L++x19tnL13f/vdY2d4cQ4ofPiHo7IIQoBwW7EImgYBciERTsQiSCgl2IRFCwC5EIl9XS2czuAPAcgAYA/+ruT7Hvb21t9fb29gGP09DQkNvOZMNz584NeBwAGDEi/vkXjXfZZfE0Mh/NLLSdPXs2tJ0/f37A14zmsL/rMT+Y/9F4bH7ZM2NjsTlm913EjyLroz9bBLvnyLZ3714cOXIk11g42M2sAcA/A/gJgK8AfGxma919W9Snvb0db731Vq6NTWJjY2Nu+3fffRf2+frrr0MbY+zYsaEtGq+lpSXswwJp5MiRoe3QoUOh7ZtvvhnwNSdMmBD2OXPmTGjr6ekJbaNGjQpt0TMbN25c2Ke3t7fQWKdPnw5tzc3Noa2IH0XWB8B9jN4s2PqI4uXOO++M+4SW/lkM4HN33+nu3wJ4BcDdNVxPCDGE1BLsMwDs7fP1V1mbEGIYMuQbdGa2wsw6zazzyJEjQz2cECKglmDvAjCzz9ftWdtFuPtKd+9w947W1tYahhNC1EItwf4xgDlmNtvMRgG4H8DawXFLCDHYFN6Nd/ezZvYIgP9GRXpb5e5bq+iX287kjmhnnckqTA4rKnlF47FdWLYbX7Qf8z+65tGjR8M+TAlhu+dF5CT2nNmO+4kTJwr1Y/MYweb31KlToY3tno8ePTq0RXNSRH5l91uTzu7ubwN4u5ZrCCHKQX9BJ0QiKNiFSAQFuxCJoGAXIhEU7EIkQk278QPl/PnzNOlioDAZh43DpCYmu0TSCpNcmDxYJKsJ4FJT1I9JkYyi2YORHywhhNnYPI4ZMya0Rc+GJRMxeY35waQyNo+RhFkkw47JoXpnFyIRFOxCJIKCXYhEULALkQgKdiESodTdeDMLd0eL1EFjyQXMVnRHNdrRZgkt7HpFa+ixa3777be57WyHme3uF0ngAIDx48fntrOdc/Zc9u/fH9qY0hCtN7bTzeaDPWuWNMTWdzSPRXbwGXpnFyIRFOxCJIKCXYhEULALkQgKdiESQcEuRCKUngjDEhAioqq0LHGCSRORPAVw2SWSa4oeacROHmGJMEziicZj12N+sJNkLr/88tAW1Yw7duxY2IfBxiqSCFP0qKmi9emamppCW3T6D1uLUaKXEmGEEAp2IVJBwS5EIijYhUgEBbsQiaBgFyIRapLezGw3gJMAzgE46+4d/Xx/KIWwjKcoY4hJE0xeY2MxGS3KeGKZYUwKYbIW85/ZovltaWkJ+7Asuujorf76NTY25rZPmzYt7MOOeGInADMfI8mOSWhMlmMZdmztMMk5Wj9F1im7r8HQ2f/C3fOFQiHEsEG/xguRCLUGuwP4vZmtN7MVg+GQEGJoqPXX+OXu3mVmUwCsM7P/dff3+n5D9kNgBQBMnz69xuGEEEWp6Z3d3buy/3sAvAFgcc73rHT3DnfvmDhxYi3DCSFqoHCwm9l4M2u68BrATwFsGSzHhBCDSy2/xk8F8Ea21X8ZgH939/9iHUaMGBFmbLGCfJGNHbtUVCJhUll0TTYWy8hiY7EMKiZDRddkMg6TDtlzYZJXBJOGGGweWUZZdG9F5EuAPzPWr8hxXmzuo+uxtV042N19J4AfFe0vhCgXSW9CJIKCXYhEULALkQgKdiESQcEuRCKUXnAykpSYfBXZmHzCMpcYTD45fPhwbvvu3bvDPsePHw9tLBNtypQpoY1ljkXz293dHfbZs2dPaIvuGeCZXGweIzZs2BDa9u3bF9ra29tD27Jly3Lb586dG/ZhBT2ZhMaksqhAJFBsriJUcFIIoWAXIhUU7EIkgoJdiERQsAuRCKXuxgPxjmVU3w0ATp48mdvOatAVTWZgfvT09OS2b9y4MezDdrpZDbrx48eHNnZv0ZFYBw8eDPsw5YIpDezeIqWBKQnbtm0LbVu2xAmVs2bNCm3Rs46OFAOAK6+8MrSx9cESitgcjx07Nred7eCzxKYIvbMLkQgKdiESQcEuRCIo2IVIBAW7EImgYBciEUqX3iIphCXCRDJJb29v2IfJIKx2GkuCiOSTvXv3hn3Wr18f2pj/7JpMeoukTZZ0E0k/AHDoULHDfqIkGVZhmM19dIwTwH2M5FIGk0TZkVeR7Alw/6OELia/FqlBp3d2IRJBwS5EIijYhUgEBbsQiaBgFyIRFOxCJEK/0puZrQLwMwA97n5j1tYK4FUAswDsBnCfux+txRGWwRbJSUwyYrXCGhsbBzwWENeFW758edhn0qRJoY1Jb7t27Qpt7GioSKZcsGBB2IfZmGTHJMBIAmIy2Zo1a0IbO/KKZdLdcsstue2sxh/LNit6/BPLlovWHFuLkR+11qD7DYA7Lml7DMA77j4HwDvZ10KIYUy/wZ6dt37pj9W7AazOXq8GcM/guiWEGGyKfmaf6u4XahPvR+VEVyHEMKbmDTqvfEgIPyiY2Qoz6zSzTva5SwgxtBQN9gNm1gYA2f/hHyC7+0p373D3DlYKSAgxtBQN9rUAHspePwTgzcFxRwgxVFQjvb0M4DYAk8zsKwBPAHgKwGtm9jCAPQDuq2awESNGhJk8TLaI5Boma7HsJCa9HTt2LLRFPrIChc3NzaGNZUIxWfHEiROhbcyYMbntTJKZPXt2aGMSJitiGd0bkxvZUVldXV2h7cYbbwxt0RphWZZFpTeW0ceO35o8eXJuO5urIkdG9Rvs7v5AYLp9wKMJIeqG/oJOiERQsAuRCAp2IRJBwS5EIijYhUiEUgtOuntYtLGIpMHkNZZlxApOsoJ9URFL1odJPKwfKzbIJJ7oXDxWePGLL74Ibe3t7YX8iM6IW7duXdhn8+bNoW3evHmhbdGiRaGNZbdFFJG1AL6umJQaFedksIy4CL2zC5EICnYhEkHBLkQiKNiFSAQFuxCJoGAXIhFKld7MDA0NDbk2JkNFUgiT15iUx2wsyyuyMamGXY/dM/Mxki+BWOpjtQSiTDmA31t0RhkQF4hkEiDL8poxY0ZoY5mFUSFT9lwYg11UEoifGfORSboRemcXIhEU7EIkgoJdiERQsAuRCAp2IRKh1N14IN5hZDu70c50kWQAgO9ms+SaIrumUfIMwO+ZHfEUKRpAPFesD1MFWD02lkDz7rvv5rZ/+OGHYR82V8uWLQttS5YsCW0TJkzIbS+q1rBnxtYO28Uvsr7ZWBF6ZxciERTsQiSCgl2IRFCwC5EICnYhEkHBLkQiVHP80yoAPwPQ4+43Zm1PAvg5gAvn/zzu7m9Xca1QAmIyQ3SEz+HDh+lYEUy2YLXfIomKJUAwyYvVHmPyDzv2Kromk/Ki47UAPh+nT58Obbt27cptZ3IdS2i59tprQ1tbW1toi+aRPTN2z2xdsaPDIgkQiI/zYglKETTxqor+vwFwR077s+4+P/vXb6ALIepLv8Hu7u8B0MHqQnzPqeUz+yNmtsnMVplZXFNYCDEsKBrszwO4GsB8AN0Ano6+0cxWmFmnmXWyz9hCiKGlULC7+wF3P+fu5wG8AGAx+d6V7t7h7h3sPHIhxNBSKNjNrO/2570AtgyOO0KIoaIa6e1lALcBmGRmXwF4AsBtZjYfgAPYDeAX1Q5YpPYXO1anCEzmYxlxUcYTuycmoTU1NYU29pGH2RobG3PbWQ23qF4cAGzcuDG0ffDBB6Ftx44due2zZs0K+yxdujS03XzzzaEtumcgPg6LPTMmKbLstaIya5FsyiJx1G+wu/sDOc0vDngkIURd0V/QCZEICnYhEkHBLkQiKNiFSAQFuxCJUHrByUiKYpJXJL2xQonMxiQSJstFcgfLoisqn7CMpyK2osULmWTU1dUV2qIsO5ahds0114S26BgngMubRYqSsj4se7DoeozGY88l6sPmQu/sQiSCgl2IRFCwC5EICnYhEkHBLkQiKNiFSIRSpbeGhgZaeC8iylxqaWkJ+zBZK8oyAvhZXpHcwWQVJpOxwoasIGJPT09oa21tzW0fN25c2Iexd+/e0Pbpp5+Gtt7e3tx2VjiSZcRNnBgXQ2L3FkllReVS9qzHjh0b2piEGT2zIplyVP4LLUKIHxQKdiESQcEuRCIo2IVIBAW7EIlQ6m78+fPncebMmVwbS4Rhu+cRLCGA7cSyGmNFdnbZfY0ePTq0MaWB7fBHigHbwd+5c2do2759e2hjysVVV12V237rrbeGfW666abQxnaZ9+3bF9qiHW22g8/WzlAQrR/mB1tXEXpnFyIRFOxCJIKCXYhEULALkQgKdiESQcEuRCJUc/zTTAC/BTAVleOeVrr7c2bWCuBVALNQOQLqPnc/yq7l7oVkBlZ/jI0VwaQyNlYkdzAJikkkLHGiqJwX2VhizbFjx0Lb/v37Qxs7liuq8zdt2rSwz+TJk0Mbkym//PLL0BY9m6LSW5Facv1dM3rWRY54YlTzzn4WwK/c/XoASwD80syuB/AYgHfcfQ6Ad7KvhRDDlH6D3d273f2T7PVJANsBzABwN4DV2betBnDPEPkohBgEBvSZ3cxmAVgA4CMAU929OzPtR+XXfCHEMKXqYDezRgBrADzq7if62rzygST3Q4mZrTCzTjPrZEcDCyGGlqqC3cxGohLoL7n761nzATNry+xtAHL/+NrdV7p7h7t3RBU5hBBDT7/BbpUtwRcBbHf3Z/qY1gJ4KHv9EIA3B989IcRgUU062TIADwLYbGYbsrbHATwF4DUzexjAHgD31eIIk5MiGYf1YTJIUfkkyr5jfVidOZbNx2quManvs88+y21///33wz6bNm0KbawO2nXXXRfaFi5cmNvO5DUmTzE/2BxH8hUbq2iNQrau2DWjdczk12gsel+h5f87/xFAJPjd3l9/IcTwQH9BJ0QiKNiFSAQFuxCJoGAXIhEU7EIkQqkFJ4FYpmLyVSS9sT7MxrKJivRjkgsrYMlkEpYRxyTH6K8Ut27dGvZhBSeZrDV//vzQdvvt+UINO/7p9OnToY0dQxWtDyB+ZkUk1v76DXbWG5PeIh9pxl5oEUL8oFCwC5EICnYhEkHBLkQiKNiFSAQFuxCJUKr05u6Fznpra2vLbT98+HDYh8kgTNJobm4ObUUyqJjtwIEDoY1lVzE5Lzr3jBWOZLLWokWLQtvSpUtD29Sp+YWLWPYau+cZM2aENlZMM1pvTC5lxS2LZuaxbL/oHD7mB1vfEXpnFyIRFOxCJIKCXYhEULALkQgKdiESofREmCKJCadOncptZ7vqRY/wYckY0S44S8RgCS3RLizAd+p7e3tD265du3Lb2RFPrN7dDTfcENrmzp0b2iZMmJDbfvDgwbAPey7sWC620x3dN9s5Z2uH7fwX2SFnsPVdRBnSO7sQiaBgFyIRFOxCJIKCXYhEULALkQgKdiESoV/pzcxmAvgtKkcyO4CV7v6cmT0J4OcALmgpj7v72/1cC2PGjMm1MZkhkqjGjRsX9ila3+3EiROhbbBr0EXyFAB0d3eHtm3btoW2o0eP5ra3tLSEfebNmxfa5syZE9pYLb9p06bltjc2NoZ9WCJMlOADAE1NTaGtCMwPJs1GaxsodnwV6xOtK/ZMqtHZzwL4lbt/YmZNANab2brM9qy7/1MV1xBC1JlqznrrBtCdvT5pZtsBxPmGQohhyYA+s5vZLAALAHyUNT1iZpvMbJWZxX+GJYSoO1UHu5k1AlgD4FF3PwHgeQBXA5iPyjv/00G/FWbWaWadUU1zIcTQU1Wwm9lIVAL9JXd/HQDc/YC7n3P38wBeALA4r6+7r3T3DnfvaG1tHSy/hRADpN9gt8r23osAtrv7M33a+9aKuhfAlsF3TwgxWFSzG78MwIMANpvZhqztcQAPmNl8VOS43QB+Uc2AUWYQk6iiPizbrGhdOCajRXXyWLYT++hy6NCh0LZ+/frQtnHjxtAW+cjktQULFoS29vb20MZknui+WdYYlY3IkUwnT54MbdGzLvKcAZ59x9YjI7pvNhbzP6Ka3fg/AsjzhmrqQojhhf6CTohEULALkQgKdiESQcEuRCIo2IVIhGFTcJJJCdERPix7rYgPAJddilyPSU1MAmRHMm3fvj20XXHFFbntrDjk8uXLQxvLRmSSV5QdFmV4ATyLMSo6ChR7Zgx2zwy2hlkmXbSOmR+RzMfWot7ZhUgEBbsQiaBgFyIRFOxCJIKCXYhEULALkQjDRnorctYbKzTIrseyiSKZD4gLCrKMPVaEkGVJMamGZctF0hYrpMlgchiTFaM5YffFxmJZb6yYZiQBsmKOTMpjchjzkV0zkmB11psQohAKdiESQcEuRCIo2IVIBAW7EImgYBciEUqV3s6dO4fjx4/n2pgMNWNG/gE0TCZjMBmKZdJFcgfLyDp8+HBo27FjR2jbvHlzaGOyUTQnLNuMXY/JSdOnTw9tBw8ezG1nch3LGpsyZUpoY3McSbBsLHbPo0ePDm1sHpubm0NbFBNsLRbJzNM7uxCJoGAXIhEU7EIkgoJdiERQsAuRCP3uxpvZGADvARidff/v3P0JM5sN4BUAlwNYD+BBd4+zHCrXokkjEdFuN9tRZbW4mA9shz/apWVKAkuEYTaWyMN2fSPYbnxbW1toY0lDvb29A7ax+WWJTSyRhO1aR+MVrQ3I/Ch6HFm0Hlkftr4jqnlnPwPgx+7+I1SOZ77DzJYA+DWAZ939GgBHATw84NGFEKXRb7B7hQs/pkdm/xzAjwH8LmtfDeCeoXBQCDE4VHs+e0N2gmsPgHUAvgBwzN0vKPtfAcj/yxchxLCgqmB393PuPh9AO4DFAOIi5JdgZivMrNPMOtnxxUKIoWVAu/HufgzAHwAsBdBiZhd2rNoBdAV9Vrp7h7t3tLa21uKrEKIG+g12M5tsZi3Z67EAfgJgOypB/5fZtz0E4M0h8lEIMQhUkwjTBmC1mTWg8sPhNXf/TzPbBuAVM/sHAJ8CeLGaASNJickWUY0xloDCpCuWRMDqoBWp+8Vqrk2YMCG0zZs3L7RNnTo1tM2cOTO3fdq0aWEfNo/s3thcRZIdmw8m5TFZjl0zkmeZ/MpkraJ15li/aK0yH9n6Dn3o7xvcfROABTntO1H5/C6E+B6gv6ATIhEU7EIkgoJdiERQsAuRCAp2IRLBmLQy6IOZHQSwJ/tyEoD4HKPykB8XIz8u5vvmx5XuPjnPUGqwXzSwWae7d9RlcPkhPxL0Q7/GC5EICnYhEqGewb6yjmP3RX5cjPy4mB+MH3X7zC6EKBf9Gi9EItQl2M3sDjP7zMw+N7PH6uFD5sduM9tsZhvMrLPEcVeZWY+ZbenT1mpm68zsz9n/E+vkx5Nm1pXNyQYzu6sEP2aa2R/MbJuZbTWzv87aS50T4kepc2JmY8zsT2a2MfPj77P22Wb2URY3r5pZXA00D3cv9R+ABlTKWl0FYBSAjQCuL9uPzJfdACbVYdxbASwEsKVP2z8CeCx7/RiAX9fJjycB/E3J89EGYGH2ugnADgDXlz0nxI9S5wSAAWjMXo8E8BGAJQBeA3B/1v4vAP5qINetxzv7YgCfu/tOr5SefgXA3XXwo264+3sALq3RdTcqhTuBkgp4Bn6Ujrt3u/sn2euTqBRHmYGS54T4USpeYdCLvNYj2GcA2Nvn63oWq3QAvzez9Wa2ok4+XGCqu3dnr/cDiCtUDD2PmNmm7Nf8If840Rczm4VK/YSPUMc5ucQPoOQ5GYoir6lv0C1394UA7gTwSzO7td4OAZWf7Kj8IKoHzwO4GpUzAroBPF3WwGbWCGANgEfd/aJztcuckxw/Sp8Tr6HIa0Q9gr0LQN/aSWGxyqHG3buy/3sAvIH6Vt45YGZtAJD931MPJ9z9QLbQzgN4ASXNiZmNRCXAXnL317Pm0uckz496zUk29jEMsMhrRD2C/WMAc7KdxVEA7gewtmwnzGy8mTVdeA3gpwC28F5DylpUCncCdSzgeSG4Mu5FCXNilaJvLwLY7u7P9DGVOieRH2XPyZAVeS1rh/GS3ca7UNnp/ALA39bJh6tQUQI2Athaph8AXkbl18HvUPns9TAqZ+a9A+DPAP4HQGud/Pg3AJsBbEIl2NpK8GM5Kr+ibwKwIft3V9lzQvwodU4A3IRKEddNqPxg+bs+a/ZPAD4H8B8ARg/kuvoLOiESIfUNOiGSQcEuRCIo2IVIBAW7EImgYBciERTsQiSCgl2IRFCwC5EI/wfi5DoyocN8sQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Record the optimization process\n", + "loss_list, singular_value_list = [], []\n", + "U_learned, V_dagger_learned = [], []\n", + " \n", + "net = NET(Mat_generator(), weight)\n", + "\n", + "# We use Adam optimizer for better performance\n", + "# One can change it to SGD or RMSprop.\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + "# Optimization loop\n", + "for itr in range(ITR):\n", + "\n", + " # Forward propagation to calculate loss function\n", + " U, V_dagger, loss, singular_values = net()\n", + "\n", + " # Back propagation minimizes the loss function\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + "\n", + " # Record optimization intermediate results\n", + " loss_list.append(loss[0][0].numpy())\n", + " singular_value_list.append(singular_values)\n", + " \n", + " if itr% 10 == 0:\n", + " print('iter:', itr,'loss:','%.4f'% loss.numpy()[0])\n", + "\n", + "# Record the last two unitary matrices learned\n", + "U_learned = U.numpy()\n", + "V_dagger_learned = V_dagger.numpy()\n", + "\n", + "singular_value = singular_value_list[-1]\n", + "mat = np.matrix(U_learned.real[:, :T]) * np.diag(singular_value[:T])* np.matrix(V_dagger_learned.real[:T, :])\n", + "\n", + "reconstimg = mat\n", + "plt.imshow(reconstimg, cmap='gray')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## References\n", + "\n", + "[1] Wang, X., Song, Z., & Wang, Y. Variational Quantum Singular Value Decomposition. [Quantum, 5, 483 (2021).](https://quantum-journal.org/papers/q-2021-06-29-483/)" + ] + } + ], + "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.8.13" + }, + "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": true + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/machine_learning/VSQL_CN.ipynb b/tutorials/machine_learning/VSQL_CN.ipynb similarity index 83% rename from tutorial/machine_learning/VSQL_CN.ipynb rename to tutorials/machine_learning/VSQL_CN.ipynb index 2fe4622..6b26d43 100644 --- a/tutorial/machine_learning/VSQL_CN.ipynb +++ b/tutorials/machine_learning/VSQL_CN.ipynb @@ -63,7 +63,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "senior-blues", "metadata": {}, "outputs": [], @@ -71,11 +71,10 @@ "import time\n", "import numpy as np\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle.vision.datasets import MNIST\n", "import paddle.nn.functional as F\n", - "\n", - "paddle.set_default_dtype(\"float64\")" + "from paddle.vision.datasets import MNIST\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit" ] }, { @@ -90,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "surgical-breast", "metadata": {}, "outputs": [], @@ -98,14 +97,14 @@ "# 归一化处理向量并在尾部补零\n", "def norm_img(images):\n", " new_images = [np.pad(np.array(i).flatten(), (0, 240), constant_values=(0, 0)) for i in images]\n", - " new_images = [paddle.to_tensor(i / np.linalg.norm(i), dtype='complex128') for i in new_images]\n", - " \n", + " new_images = [paddle.to_tensor(i / np.linalg.norm(i), dtype='complex64') for i in new_images]\n", + "\n", " return new_images" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "synthetic-holly", "metadata": {}, "outputs": [], @@ -132,7 +131,7 @@ " y_train = paddle.to_tensor(np.eye(2)[train_targets])\n", " test_targets = np.array(test_labels).reshape(-1)\n", " y_test = paddle.to_tensor(np.eye(2)[test_targets])\n", - " \n", + "\n", " return x_train, y_train, x_test, y_test" ] }, @@ -177,29 +176,36 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "orange-american", "metadata": {}, "outputs": [], "source": [ "# 搭建 U(theta)\n", - "def U_theta(theta, n, n_start, n_qsc=2, depth=1):\n", + "def U_theta(n, n_qsc=2, depth=1):\n", " # 初始化电路\n", - " cir = UAnsatz(n)\n", + " cir = Circuit(n)\n", " # 先搭建广义的旋转层\n", " for i in range(n_qsc):\n", - " cir.rx(theta[0][0][i], n_start + i)\n", - " cir.ry(theta[0][1][i], n_start + i)\n", - " cir.rx(theta[0][2][i], n_start + i)\n", + " cir.rx(qubits_idx=i)\n", + " cir.ry(qubits_idx=i)\n", + " cir.rx(qubits_idx=i)\n", " # 搭建纠缠层和 Ry 旋转层，重复 D 次\n", " for repeat in range(1, depth + 1):\n", " for i in range(n_qsc - 1):\n", - " cir.cnot([n_start + i, n_start + i + 1])\n", - " cir.cnot([n_start + n_qsc - 1, n_start])\n", + " cir.cnot([i, i + 1])\n", + " cir.cnot([n_qsc - 1, 0])\n", " for i in range(n_qsc):\n", - " cir.ry(theta[repeat][1][i], n_start + i)\n", + " cir.ry(qubits_idx=i)\n", "\n", - " return cir" + " return cir\n", + "\n", + "# 滑动电路\n", + "def slide_circuit(cir, distance):\n", + " for sublayer in cir.sublayers():\n", + " qubits_idx = np.array(sublayer.qubits_idx)\n", + " qubits_idx = qubits_idx + distance\n", + " sublayer.qubits_idx = qubits_idx.tolist()" ] }, { @@ -212,7 +218,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "shaped-location", "metadata": {}, "outputs": [ @@ -220,13 +226,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "--Rx(1.591)----Ry(1.112)----Rx(1.673)----*--------------X----Ry(2.861)----*--------------X----Ry(3.252)--\n", + "--Rx(1.162)----Ry(3.081)----Rx(2.008)----*--------------x----Ry(0.401)----*--------------x----Ry(2.556)--\n", " | | | | \n", - "--Rx(1.569)----Ry(0.516)----Rx(3.077)----X----*---------|----Ry(4.816)----X----*---------|----Ry(3.264)--\n", + "--Rx(4.303)----Ry(4.531)----Rx(5.933)----x----*---------|----Ry(3.765)----x----*---------|----Ry(4.912)--\n", " | | | | \n", - "--Rx(0.560)----Ry(6.122)----Rx(1.436)---------X----*----|----Ry(6.038)---------X----*----|----Ry(2.531)--\n", + "--Rx(5.490)----Ry(5.024)----Rx(0.269)---------x----*----|----Ry(4.286)---------x----*----|----Ry(6.192)--\n", " | | | | \n", - "--Rx(1.425)----Ry(1.378)----Rx(5.048)--------------X----*----Ry(5.986)--------------X----*----Ry(1.309)--\n", + "--Rx(6.190)----Ry(3.108)----Rx(6.206)--------------x----*----Ry(1.648)--------------x----*----Ry(2.013)--\n", " \n", "---------------------------------------------------------------------------------------------------------\n", " \n", @@ -237,11 +243,9 @@ ], "source": [ "N = 6\n", - "NSTART = 0\n", "NQSC = 4\n", "D = 2\n", - "theta = paddle.uniform([D + 1, 3, NQSC], min=0.0, max=2 * np.pi)\n", - "cir = U_theta(theta, N, NSTART, n_qsc=NQSC, depth=D)\n", + "cir = U_theta(N, n_qsc=NQSC, depth=D)\n", "print(cir)" ] }, @@ -257,7 +261,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "advanced-clinic", "metadata": {}, "outputs": [], @@ -265,8 +269,9 @@ "# 构造用来获取影子特征的可观测量\n", "def observable(n_start, n_qsc=2):\n", " pauli_str = ','.join('x' + str(i) for i in range(n_start, n_start + n_qsc))\n", - " \n", - " return [[1.0, pauli_str]]" + " hamiltonian = paddle_quantum.Hamiltonian([[1.0, pauli_str]])\n", + "\n", + " return hamiltonian" ] }, { @@ -285,45 +290,46 @@ }, { "cell_type": "code", - "execution_count": 7, - "id": "certified-details", + "execution_count": 8, + "id": "0df2cd90", "metadata": {}, "outputs": [], "source": [ "class Net(paddle.nn.Layer):\n", " def __init__(self,\n", - " n, # 全局量子比特的数量: n \n", + " n, # 全局量子比特的数量: n\n", " n_qsc, # 影子电路的宽度\n", - " depth=1, # 电路深度\n", - " seed=3, # 随机数种子\n", + " depth=1 # 电路深度\n", " ):\n", " super(Net, self).__init__()\n", - "\n", " self.n = n\n", " self.n_qsc = n_qsc\n", " self.depth = depth\n", - " # 初始化参数列表 theta，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " self.theta = self.create_parameter(shape=[depth + 1, 3, n_qsc],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi))\n", + " self.cir = U_theta(self.n, n_qsc=self.n_qsc, depth=self.depth)\n", " # FCNN, 采用高斯分布来初始化权重和偏置\n", " self.fc = paddle.nn.Linear(n - n_qsc + 1, 2,\n", " weight_attr=paddle.ParamAttr(initializer=paddle.nn.initializer.Normal()),\n", " bias_attr=paddle.ParamAttr(initializer=paddle.nn.initializer.Normal()))\n", - " \n", + "\n", " # 定义前向传播机制、计算损失函数 和交叉验证正确率\n", " def forward(self, batch_in, label):\n", " # 量子部分\n", " dim = len(batch_in)\n", " features = []\n", " for state in batch_in:\n", + " _state = paddle_quantum.State(state)\n", " f_i = []\n", " for st in range(self.n - self.n_qsc + 1):\n", " ob = observable(st, n_qsc=self.n_qsc)\n", - " cir = U_theta(self.theta, self.n, st, n_qsc=self.n_qsc)\n", - " cir.run_state_vector(state)\n", + " # 滑动电路使其依次作用在各量子比特上\n", + " slide_circuit(self.cir, 1 if st != 0 else 0)\n", + " expecval = paddle_quantum.loss.ExpecVal(ob)\n", + " out_state = self.cir(_state)\n", " # 计算期望值\n", - " f_ij = cir.expecval(ob)\n", + " f_ij = expecval(out_state)\n", " f_i.append(f_ij)\n", + " # 滑动电路至初始位置\n", + " slide_circuit(self.cir, -st)\n", " f_i = paddle.concat(f_i)\n", " features.append(f_i)\n", " features = paddle.stack(features)\n", @@ -337,22 +343,22 @@ " if paddle.argmax(label[i], axis=-1) == paddle.argmax(outputs[i], axis=-1):\n", " is_correct = is_correct + 1\n", " acc = is_correct / dim\n", - " \n", + "\n", " return loss, acc" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "classified-saying", "metadata": {}, "outputs": [], "source": [ - "def ShadowClassifier(N=4, n_qsc=2, D=1, EPOCH=4, LR=0.1, BATCH=1, seed=1, N_train=1000, N_test=100):\n", + "def ShadowClassifier(N=4, n_qsc=2, D=1, EPOCH=4, LR=0.1, BATCH=1, N_train=1000, N_test=100):\n", " # 加载数据\n", " x_train, y_train, x_test, y_test = data_loading(n_train=N_train, n_test=N_test)\n", " # 初始化神经网络\n", - " net = Net(N, n_qsc, depth=D, seed=seed)\n", + " net = Net(N, n_qsc, depth=D)\n", " # 一般来说，我们利用 Adam 优化器来获得相对好的收敛\n", " # 当然你可以改成 SGD 或者是 RMSprop\n", " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", @@ -389,24 +395,34 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "id": "chicken-trash", "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/8_/kmzpk4lx35x7t6zp95sm5j100000gn/T/ipykernel_56443/103109265.py:6: FutureWarning: The input object of type 'Image' is an array-like implementing one of the corresponding protocols (`__array__`, `__array_interface__` or `__array_struct__`); but not a sequence (or 0-D). In the future, this object will be coerced as if it was first converted using `np.array(obj)`. To retain the old behaviour, you have to either modify the type 'Image', or assign to an empty array created with `np.empty(correct_shape, dtype=object)`.\n", + " train_dataset = np.array([i for i in train_dataset if i[1][0] == 0 or i[1][0] == 1], dtype=object)\n", + "/var/folders/8_/kmzpk4lx35x7t6zp95sm5j100000gn/T/ipykernel_56443/103109265.py:7: FutureWarning: The input object of type 'Image' is an array-like implementing one of the corresponding protocols (`__array__`, `__array_interface__` or `__array_struct__`); but not a sequence (or 0-D). In the future, this object will be coerced as if it was first converted using `np.array(obj)`. To retain the old behaviour, you have to either modify the type 'Image', or assign to an empty array created with `np.empty(correct_shape, dtype=object)`.\n", + " test_dataset = np.array([i for i in test_dataset if i[1][0] == 0 or i[1][0] == 1], dtype=object)\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "epoch: 0 iter: 0 loss: 13.1132 batch acc: 0.6000 test acc: 0.5900\n", - "epoch: 0 iter: 10 loss: 11.3892 batch acc: 0.9000 test acc: 0.9600\n", - "epoch: 0 iter: 20 loss: 8.4291 batch acc: 0.9500 test acc: 0.9700\n", - "epoch: 1 iter: 0 loss: 8.3585 batch acc: 0.9000 test acc: 0.9700\n", - "epoch: 1 iter: 10 loss: 6.9244 batch acc: 0.9500 test acc: 0.9800\n", - "epoch: 1 iter: 20 loss: 6.0455 batch acc: 0.9500 test acc: 0.9800\n", - "epoch: 2 iter: 0 loss: 5.4859 batch acc: 0.9500 test acc: 0.9800\n", - "epoch: 2 iter: 10 loss: 5.1867 batch acc: 0.9500 test acc: 0.9800\n", - "epoch: 2 iter: 20 loss: 5.3668 batch acc: 0.9500 test acc: 0.9700\n", - "time used: 551.4094610214233\n" + "epoch: 0 iter: 0 loss: 20.8973 batch acc: 0.4500 test acc: 0.5700\n", + "epoch: 0 iter: 10 loss: 10.2715 batch acc: 0.8500 test acc: 0.7600\n", + "epoch: 0 iter: 20 loss: 8.8303 batch acc: 0.9000 test acc: 0.9300\n", + "epoch: 1 iter: 0 loss: 7.1990 batch acc: 1.0000 test acc: 0.9300\n", + "epoch: 1 iter: 10 loss: 6.4360 batch acc: 1.0000 test acc: 0.9500\n", + "epoch: 1 iter: 20 loss: 6.7546 batch acc: 1.0000 test acc: 0.9700\n", + "epoch: 2 iter: 0 loss: 5.5871 batch acc: 1.0000 test acc: 0.9700\n", + "epoch: 2 iter: 10 loss: 4.2780 batch acc: 1.0000 test acc: 0.9800\n", + "epoch: 2 iter: 20 loss: 4.7867 batch acc: 1.0000 test acc: 0.9800\n", + "time used: 335.4554250240326\n" ] } ], @@ -419,7 +435,6 @@ " EPOCH=3, # 训练 epoch 轮数\n", " LR=0.02, # 设置学习速率\n", " BATCH=20, # 训练时 batch 的大小\n", - " seed=1024, # 随机数种子\n", " N_train=500, # 规定训练集大小\n", " N_test=100 # 规定测试集大小\n", ")\n", @@ -454,8 +469,11 @@ } ], "metadata": { + "interpreter": { + "hash": "f7cfecff1ef1940b21a48efa1b88278bb096bd916f13c2df11af4810c38b47e1" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.0 ('pq')", "language": "python", "name": "python3" }, @@ -469,7 +487,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.0" }, "toc": { "base_numbering": 1, diff --git a/tutorial/machine_learning/VSQL_EN.ipynb b/tutorials/machine_learning/VSQL_EN.ipynb similarity index 84% rename from tutorial/machine_learning/VSQL_EN.ipynb rename to tutorials/machine_learning/VSQL_EN.ipynb index 147cbb9..67df097 100644 --- a/tutorial/machine_learning/VSQL_EN.ipynb +++ b/tutorials/machine_learning/VSQL_EN.ipynb @@ -65,7 +65,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "auburn-compound", "metadata": {}, "outputs": [], @@ -73,11 +73,10 @@ "import time\n", "import numpy as np\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle.vision.datasets import MNIST\n", "import paddle.nn.functional as F\n", - "\n", - "paddle.set_default_dtype(\"float64\")" + "from paddle.vision.datasets import MNIST\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit" ] }, { @@ -92,7 +91,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "valuable-criterion", "metadata": {}, "outputs": [], @@ -100,14 +99,14 @@ "# Normalize the vector and do zero-padding\n", "def norm_img(images):\n", " new_images = [np.pad(np.array(i).flatten(), (0, 240), constant_values=(0, 0)) for i in images]\n", - " new_images = [paddle.to_tensor(i / np.linalg.norm(i), dtype='complex128') for i in new_images]\n", - " \n", + " new_images = [paddle.to_tensor(i / np.linalg.norm(i), dtype='complex64') for i in new_images]\n", + "\n", " return new_images" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "ancient-philosophy", "metadata": {}, "outputs": [], @@ -134,7 +133,7 @@ " y_train = paddle.to_tensor(np.eye(2)[train_targets])\n", " test_targets = np.array(test_labels).reshape(-1)\n", " y_test = paddle.to_tensor(np.eye(2)[test_targets])\n", - " \n", + "\n", " return x_train, y_train, x_test, y_test" ] }, @@ -179,29 +178,36 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "derived-workstation", "metadata": {}, "outputs": [], "source": [ "# Construct the shadow circuit U(theta)\n", - "def U_theta(theta, n, n_start, n_qsc=2, depth=1):\n", + "def U_theta(n, n_qsc=2, depth=1):\n", " # Initialize the circuit\n", - " cir = UAnsatz(n)\n", + " cir = Circuit(n)\n", " # Add layers of rotation gates\n", " for i in range(n_qsc):\n", - " cir.rx(theta[0][0][i], n_start + i)\n", - " cir.ry(theta[0][1][i], n_start + i)\n", - " cir.rx(theta[0][2][i], n_start + i)\n", + " cir.rx(qubits_idx=i)\n", + " cir.ry(qubits_idx=i)\n", + " cir.rx(qubits_idx=i)\n", " # Add D layers of the dashed box\n", " for repeat in range(1, depth + 1):\n", " for i in range(n_qsc - 1):\n", - " cir.cnot([n_start + i, n_start + i + 1])\n", - " cir.cnot([n_start + n_qsc - 1, n_start])\n", + " cir.cnot([i, i + 1])\n", + " cir.cnot([n_qsc - 1, 0])\n", " for i in range(n_qsc):\n", - " cir.ry(theta[repeat][1][i], n_start + i)\n", + " cir.ry(qubits_idx=i)\n", "\n", - " return cir" + " return cir\n", + "\n", + "# Slide the circuit\n", + "def slide_circuit(cir, distance):\n", + " for sublayer in cir.sublayers():\n", + " qubits_idx = np.array(sublayer.qubits_idx)\n", + " qubits_idx = qubits_idx + distance\n", + " sublayer.qubits_idx = qubits_idx.tolist()" ] }, { @@ -214,7 +220,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "roman-radical", "metadata": {}, "outputs": [ @@ -222,13 +228,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "--Rx(2.435)----Ry(5.433)----Rx(5.893)----*--------------X----Ry(0.430)----*--------------X----Ry(3.016)--\n", + "--Rx(2.461)----Ry(5.857)----Rx(1.809)----*--------------x----Ry(4.381)----*--------------x----Ry(1.523)--\n", " | | | | \n", - "--Rx(4.804)----Ry(2.413)----Rx(4.271)----X----*---------|----Ry(3.770)----X----*---------|----Ry(4.303)--\n", + "--Rx(3.861)----Ry(5.536)----Rx(3.228)----x----*---------|----Ry(1.633)----x----*---------|----Ry(2.853)--\n", " | | | | \n", - "--Rx(1.397)----Ry(0.021)----Rx(2.358)---------X----*----|----Ry(5.194)---------X----*----|----Ry(0.938)--\n", + "--Rx(3.690)----Ry(5.288)----Rx(2.211)---------x----*----|----Ry(0.397)---------x----*----|----Ry(6.159)--\n", " | | | | \n", - "--Rx(2.457)----Ry(0.133)----Rx(0.743)--------------X----*----Ry(2.042)--------------X----*----Ry(3.704)--\n", + "--Rx(3.030)----Ry(5.486)----Rx(3.769)--------------x----*----Ry(1.769)--------------x----*----Ry(2.564)--\n", " \n", "---------------------------------------------------------------------------------------------------------\n", " \n", @@ -239,11 +245,9 @@ ], "source": [ "N = 6\n", - "NSTART = 0\n", "NQSC = 4\n", "D = 2\n", - "theta = paddle.uniform([D + 1, 3, NQSC], min=0.0, max=2 * np.pi)\n", - "cir = U_theta(theta, N, NSTART, n_qsc=NQSC, depth=D)\n", + "cir = U_theta(N, n_qsc=NQSC, depth=D)\n", "print(cir)" ] }, @@ -259,7 +263,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "equipped-begin", "metadata": {}, "outputs": [], @@ -267,8 +271,9 @@ "# Construct the observable for extracting shadow features\n", "def observable(n_start, n_qsc=2):\n", " pauli_str = ','.join('x' + str(i) for i in range(n_start, n_start + n_qsc))\n", - " \n", - " return [[1.0, pauli_str]]" + " hamiltonian = paddle_quantum.Hamiltonian([[1.0, pauli_str]])\n", + "\n", + " return hamiltonian" ] }, { @@ -287,7 +292,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "upper-petite", "metadata": {}, "outputs": [], @@ -296,36 +301,37 @@ " def __init__(self,\n", " n, # Number of qubits: n \n", " n_qsc, # Number of local qubits in a shadow\n", - " depth=1, # Circuit depth\n", - " seed=3, # Random seed\n", + " depth=1 # Circuit depth\n", " ):\n", " super(Net, self).__init__()\n", - "\n", " self.n = n\n", " self.n_qsc = n_qsc\n", " self.depth = depth\n", - " # Initialize the parameters theta with a uniform distribution of [0, 2 * pi]\n", - " self.theta = self.create_parameter(shape=[depth + 1, 3, n_qsc],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi))\n", + " self.cir = U_theta(self.n, n_qsc=self.n_qsc, depth=self.depth)\n", " # FCNN, initialize the weights and the bias with a Gaussian distribution\n", " self.fc = paddle.nn.Linear(n - n_qsc + 1, 2,\n", " weight_attr=paddle.ParamAttr(initializer=paddle.nn.initializer.Normal()),\n", " bias_attr=paddle.ParamAttr(initializer=paddle.nn.initializer.Normal()))\n", - " \n", + "\n", " # Define forward propagation mechanism, and then calculate loss function and cross-validation accuracy\n", " def forward(self, batch_in, label):\n", " # Quantum part\n", " dim = len(batch_in)\n", " features = []\n", " for state in batch_in:\n", + " _state = paddle_quantum.State(state)\n", " f_i = []\n", " for st in range(self.n - self.n_qsc + 1):\n", " ob = observable(st, n_qsc=self.n_qsc)\n", - " cir = U_theta(self.theta, self.n, st, n_qsc=self.n_qsc)\n", - " cir.run_state_vector(state)\n", + " # Slide the circuit to act on different qubits\n", + " slide_circuit(self.cir, 1 if st != 0 else 0)\n", + " expecval = paddle_quantum.loss.ExpecVal(ob)\n", + " out_state = self.cir(_state)\n", " # Calculate the expectation value\n", - " f_ij = cir.expecval(ob)\n", + " f_ij = expecval(out_state)\n", " f_i.append(f_ij)\n", + " # Slide the circuit back to the initial position\n", + " slide_circuit(self.cir, -st)\n", " f_i = paddle.concat(f_i)\n", " features.append(f_i)\n", " features = paddle.stack(features)\n", @@ -339,22 +345,22 @@ " if paddle.argmax(label[i], axis=-1) == paddle.argmax(outputs[i], axis=-1):\n", " is_correct = is_correct + 1\n", " acc = is_correct / dim\n", - " \n", + "\n", " return loss, acc" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "handed-study", "metadata": {}, "outputs": [], "source": [ - "def ShadowClassifier(N=4, n_qsc=2, D=1, EPOCH=4, LR=0.1, BATCH=1, seed=1, N_train=1000, N_test=100):\n", + "def ShadowClassifier(N=4, n_qsc=2, D=1, EPOCH=4, LR=0.1, BATCH=1, N_train=1000, N_test=100):\n", " # Load data\n", " x_train, y_train, x_test, y_test = data_loading(n_train=N_train, n_test=N_test)\n", " # Initialize the neural network\n", - " net = Net(N, n_qsc, depth=D, seed=seed)\n", + " net = Net(N, n_qsc, depth=D)\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", @@ -391,26 +397,36 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "id": "unique-indie", "metadata": { "scrolled": true }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\v_zhaoxuanqiang\\AppData\\Local\\Temp\\ipykernel_9684\\2285585707.py:6: FutureWarning: The input object of type 'Image' is an array-like implementing one of the corresponding protocols (`__array__`, `__array_interface__` or `__array_struct__`); but not a sequence (or 0-D). In the future, this object will be coerced as if it was first converted using `np.array(obj)`. To retain the old behaviour, you have to either modify the type 'Image', or assign to an empty array created with `np.empty(correct_shape, dtype=object)`.\n", + " train_dataset = np.array([i for i in train_dataset if i[1][0] == 0 or i[1][0] == 1], dtype=object)\n", + "C:\\Users\\v_zhaoxuanqiang\\AppData\\Local\\Temp\\ipykernel_9684\\2285585707.py:7: FutureWarning: The input object of type 'Image' is an array-like implementing one of the corresponding protocols (`__array__`, `__array_interface__` or `__array_struct__`); but not a sequence (or 0-D). In the future, this object will be coerced as if it was first converted using `np.array(obj)`. To retain the old behaviour, you have to either modify the type 'Image', or assign to an empty array created with `np.empty(correct_shape, dtype=object)`.\n", + " test_dataset = np.array([i for i in test_dataset if i[1][0] == 0 or i[1][0] == 1], dtype=object)\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "epoch: 0 iter: 0 loss: 18.4158 batch acc: 0.2500 test acc: 0.4800\n", - "epoch: 0 iter: 10 loss: 10.6799 batch acc: 0.8000 test acc: 0.9500\n", - "epoch: 0 iter: 20 loss: 10.1750 batch acc: 0.8500 test acc: 0.9400\n", - "epoch: 1 iter: 0 loss: 8.5254 batch acc: 0.9000 test acc: 0.9600\n", - "epoch: 1 iter: 10 loss: 7.0151 batch acc: 0.9000 test acc: 0.9700\n", - "epoch: 1 iter: 20 loss: 7.5365 batch acc: 0.9000 test acc: 0.9700\n", - "epoch: 2 iter: 0 loss: 6.5155 batch acc: 0.8500 test acc: 0.9700\n", - "epoch: 2 iter: 10 loss: 5.5648 batch acc: 0.9500 test acc: 0.9800\n", - "epoch: 2 iter: 20 loss: 6.3797 batch acc: 0.9500 test acc: 0.9700\n", - "time used: 548.4337043762207\n" + "epoch: 0 iter: 0 loss: 15.8133 batch acc: 0.4500 test acc: 0.4700\n", + "epoch: 0 iter: 10 loss: 12.3796 batch acc: 0.7500 test acc: 0.8800\n", + "epoch: 0 iter: 20 loss: 11.3694 batch acc: 0.8500 test acc: 0.9600\n", + "epoch: 1 iter: 0 loss: 9.0114 batch acc: 0.9000 test acc: 0.9700\n", + "epoch: 1 iter: 10 loss: 8.0621 batch acc: 0.9500 test acc: 0.9700\n", + "epoch: 1 iter: 20 loss: 8.1941 batch acc: 0.9000 test acc: 0.9800\n", + "epoch: 2 iter: 0 loss: 6.5335 batch acc: 0.9000 test acc: 0.9900\n", + "epoch: 2 iter: 10 loss: 6.2066 batch acc: 0.9000 test acc: 0.9900\n", + "epoch: 2 iter: 20 loss: 6.6691 batch acc: 0.9000 test acc: 0.9900\n", + "time used: 499.0781090259552\n" ] } ], @@ -423,7 +439,6 @@ " EPOCH=3, # Number of training epochs\n", " LR=0.02, # Learning rate\n", " BATCH=20, # Batch size\n", - " seed=1024, # Random seed\n", " N_train=500, # Number of training data\n", " N_test=100 # Number of test data\n", ")\n", @@ -460,7 +475,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -474,7 +489,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/machine_learning/figures/MNIST_32.png b/tutorials/machine_learning/figures/MNIST_32.png similarity index 100% rename from tutorial/machine_learning/figures/MNIST_32.png rename to tutorials/machine_learning/figures/MNIST_32.png diff --git a/tutorial/machine_learning/figures/QA-fig-encoder_pipeline-cn.png b/tutorials/machine_learning/figures/QA-fig-encoder_pipeline-cn.png similarity index 100% rename from tutorial/machine_learning/figures/QA-fig-encoder_pipeline-cn.png rename to tutorials/machine_learning/figures/QA-fig-encoder_pipeline-cn.png diff --git a/tutorial/machine_learning/figures/QA-fig-encoder_pipeline.png b/tutorials/machine_learning/figures/QA-fig-encoder_pipeline.png similarity index 100% rename from tutorial/machine_learning/figures/QA-fig-encoder_pipeline.png rename to tutorials/machine_learning/figures/QA-fig-encoder_pipeline.png diff --git a/tutorial/machine_learning/figures/QGAN-fig-discriminator.png b/tutorials/machine_learning/figures/QGAN-fig-discriminator.png similarity index 100% rename from tutorial/machine_learning/figures/QGAN-fig-discriminator.png rename to tutorials/machine_learning/figures/QGAN-fig-discriminator.png diff --git a/tutorial/machine_learning/figures/QGAN-fig-generator.png b/tutorials/machine_learning/figures/QGAN-fig-generator.png similarity index 100% rename from tutorial/machine_learning/figures/QGAN-fig-generator.png rename to tutorials/machine_learning/figures/QGAN-fig-generator.png diff --git a/tutorials/machine_learning/figures/QGAN-fig-loss.gif b/tutorials/machine_learning/figures/QGAN-fig-loss.gif new file mode 100644 index 0000000..4f66f30 Binary files /dev/null and b/tutorials/machine_learning/figures/QGAN-fig-loss.gif differ diff --git a/tutorial/machine_learning/figures/QGAN-fig-output_16_1.png b/tutorials/machine_learning/figures/QGAN-fig-output_16_1.png similarity index 100% rename from tutorial/machine_learning/figures/QGAN-fig-output_16_1.png rename to tutorials/machine_learning/figures/QGAN-fig-output_16_1.png diff --git a/tutorial/machine_learning/figures/QGAN-fig-target_state.png b/tutorials/machine_learning/figures/QGAN-fig-target_state.png similarity index 100% rename from tutorial/machine_learning/figures/QGAN-fig-target_state.png rename to tutorials/machine_learning/figures/QGAN-fig-target_state.png diff --git a/tutorial/machine_learning/figures/Qkernel-fig-QKE.png b/tutorials/machine_learning/figures/Qkernel-fig-QKE.png similarity index 100% rename from tutorial/machine_learning/figures/Qkernel-fig-QKE.png rename to tutorials/machine_learning/figures/Qkernel-fig-QKE.png diff --git a/tutorial/machine_learning/figures/Qkernel-fig-featuremap.png b/tutorials/machine_learning/figures/Qkernel-fig-featuremap.png similarity index 100% rename from tutorial/machine_learning/figures/Qkernel-fig-featuremap.png rename to tutorials/machine_learning/figures/Qkernel-fig-featuremap.png diff --git a/tutorial/machine_learning/figures/Qkernel-fig-illustrationCN.png b/tutorials/machine_learning/figures/Qkernel-fig-illustrationCN.png similarity index 100% rename from tutorial/machine_learning/figures/Qkernel-fig-illustrationCN.png rename to tutorials/machine_learning/figures/Qkernel-fig-illustrationCN.png diff --git a/tutorial/machine_learning/figures/Qkernel-fig-illustrationEN.png b/tutorials/machine_learning/figures/Qkernel-fig-illustrationEN.png similarity index 100% rename from tutorial/machine_learning/figures/Qkernel-fig-illustrationEN.png rename to tutorials/machine_learning/figures/Qkernel-fig-illustrationEN.png diff --git a/tutorial/machine_learning/figures/qclassifier-fig-circuit.png b/tutorials/machine_learning/figures/qclassifier-fig-circuit.png similarity index 100% rename from tutorial/machine_learning/figures/qclassifier-fig-circuit.png rename to tutorials/machine_learning/figures/qclassifier-fig-circuit.png diff --git a/tutorial/machine_learning/figures/qclassifier-fig-data-cn.png b/tutorials/machine_learning/figures/qclassifier-fig-data-cn.png similarity index 100% rename from tutorial/machine_learning/figures/qclassifier-fig-data-cn.png rename to tutorials/machine_learning/figures/qclassifier-fig-data-cn.png diff --git a/tutorial/machine_learning/figures/qclassifier-fig-data.png b/tutorials/machine_learning/figures/qclassifier-fig-data.png similarity index 100% rename from tutorial/machine_learning/figures/qclassifier-fig-data.png rename to tutorials/machine_learning/figures/qclassifier-fig-data.png diff --git a/tutorial/machine_learning/figures/qclassifier-fig-decisionboundary.png b/tutorials/machine_learning/figures/qclassifier-fig-decisionboundary.png similarity index 100% rename from tutorial/machine_learning/figures/qclassifier-fig-decisionboundary.png rename to tutorials/machine_learning/figures/qclassifier-fig-decisionboundary.png diff --git a/tutorial/machine_learning/figures/qclassifier-fig-pipeline-cn.png b/tutorials/machine_learning/figures/qclassifier-fig-pipeline-cn.png similarity index 100% rename from tutorial/machine_learning/figures/qclassifier-fig-pipeline-cn.png rename to tutorials/machine_learning/figures/qclassifier-fig-pipeline-cn.png diff --git a/tutorial/machine_learning/figures/qclassifier-fig-pipeline.png b/tutorials/machine_learning/figures/qclassifier-fig-pipeline.png similarity index 100% rename from tutorial/machine_learning/figures/qclassifier-fig-pipeline.png rename to tutorials/machine_learning/figures/qclassifier-fig-pipeline.png diff --git a/tutorial/machine_learning/figures/qclassifier-fig-test.png b/tutorials/machine_learning/figures/qclassifier-fig-test.png similarity index 100% rename from tutorial/machine_learning/figures/qclassifier-fig-test.png rename to tutorials/machine_learning/figures/qclassifier-fig-test.png diff --git a/tutorial/machine_learning/figures/qclassifier-fig-training.png b/tutorials/machine_learning/figures/qclassifier-fig-training.png similarity index 100% rename from tutorial/machine_learning/figures/qclassifier-fig-training.png rename to tutorials/machine_learning/figures/qclassifier-fig-training.png diff --git a/tutorial/machine_learning/figures/vsql-fig-2-local.png b/tutorials/machine_learning/figures/vsql-fig-2-local.png similarity index 100% rename from tutorial/machine_learning/figures/vsql-fig-2-local.png rename to tutorials/machine_learning/figures/vsql-fig-2-local.png diff --git a/tutorial/machine_learning/figures/vsql-fig-pipeline-cn.png b/tutorials/machine_learning/figures/vsql-fig-pipeline-cn.png similarity index 100% rename from tutorial/machine_learning/figures/vsql-fig-pipeline-cn.png rename to tutorials/machine_learning/figures/vsql-fig-pipeline-cn.png diff --git a/tutorial/machine_learning/figures/vsql-fig-pipeline.png b/tutorials/machine_learning/figures/vsql-fig-pipeline.png similarity index 100% rename from tutorial/machine_learning/figures/vsql-fig-pipeline.png rename to tutorials/machine_learning/figures/vsql-fig-pipeline.png diff --git a/tutorial/machine_learning/figures/vsql-fig-qubit0-cn.png b/tutorials/machine_learning/figures/vsql-fig-qubit0-cn.png similarity index 100% rename from tutorial/machine_learning/figures/vsql-fig-qubit0-cn.png rename to tutorials/machine_learning/figures/vsql-fig-qubit0-cn.png diff --git a/tutorial/machine_learning/figures/vsql-fig-qubit0.png b/tutorials/machine_learning/figures/vsql-fig-qubit0.png similarity index 100% rename from tutorial/machine_learning/figures/vsql-fig-qubit0.png rename to tutorials/machine_learning/figures/vsql-fig-qubit0.png diff --git a/tutorial/machine_learning/figures/vsql-fig-qubit1-cn.png b/tutorials/machine_learning/figures/vsql-fig-qubit1-cn.png similarity index 100% rename from tutorial/machine_learning/figures/vsql-fig-qubit1-cn.png rename to tutorials/machine_learning/figures/vsql-fig-qubit1-cn.png diff --git a/tutorial/machine_learning/figures/vsql-fig-qubit1.png b/tutorials/machine_learning/figures/vsql-fig-qubit1.png similarity index 100% rename from tutorial/machine_learning/figures/vsql-fig-qubit1.png rename to tutorials/machine_learning/figures/vsql-fig-qubit1.png diff --git a/tutorial/machine_learning/figures/vsql-fig-qubit2-cn.png b/tutorials/machine_learning/figures/vsql-fig-qubit2-cn.png similarity index 100% rename from tutorial/machine_learning/figures/vsql-fig-qubit2-cn.png rename to tutorials/machine_learning/figures/vsql-fig-qubit2-cn.png diff --git a/tutorial/machine_learning/figures/vsql-fig-qubit2.png b/tutorials/machine_learning/figures/vsql-fig-qubit2.png similarity index 100% rename from tutorial/machine_learning/figures/vsql-fig-qubit2.png rename to tutorials/machine_learning/figures/vsql-fig-qubit2.png diff --git a/tutorial/mbqc/Introduction_CN.md b/tutorials/mbqc/Introduction_CN.md similarity index 98% rename from tutorial/mbqc/Introduction_CN.md rename to tutorials/mbqc/Introduction_CN.md index ec77e2a..49b0140 100644 --- a/tutorial/mbqc/Introduction_CN.md +++ b/tutorials/mbqc/Introduction_CN.md @@ -89,11 +89,12 @@ state_out = mbqc.get_quantum_output() ### 示例教程 -在这里，我们提供了三个示例教程，其中每个教程都包含了关于 MBQC 的基础理论讲解和详细的代码演示。用户可以通过教程学习和代码练习，熟练掌握 MBQC 的运算逻辑和模块的调用方式，为后续进一步探索 MBQC 打下基础。 +在这里，我们提供了四个示例教程，其中每个教程都包含了关于 MBQC 的基础理论讲解和详细的代码演示。用户可以通过教程学习和代码练习，熟练掌握 MBQC 的运算逻辑和模块的调用方式，为后续进一步探索 MBQC 打下基础。 - [MBQC 入门介绍](MBQC_CN.ipynb) - [基于测量的量子近似优化算法](QAOA_CN.ipynb) - [MBQC 模型下求解多项式组合优化问题](PUBO_CN.ipynb) +- [MBQC 模型加速量子电路模拟](Pattern_CN.ipynb) ## 常见问题 diff --git a/tutorial/mbqc/Introduction_EN.md b/tutorials/mbqc/Introduction_EN.md similarity index 97% rename from tutorial/mbqc/Introduction_EN.md rename to tutorials/mbqc/Introduction_EN.md index bf8818c..fa1c3bb 100644 --- a/tutorial/mbqc/Introduction_EN.md +++ b/tutorials/mbqc/Introduction_EN.md @@ -88,12 +88,13 @@ of more functionalities of each module, please refer to the tutorials and the AP ### Tutorials -Here, we provide three tutorials, each of which contains basic theory explanations and detailed code demonstrations. By following the tutorials and code practice, you will get familiar with the MBQC model as well as our module +Here, we provide four tutorials, each of which contains basic theory explanations and detailed code demonstrations. By following the tutorials and code practice, you will get familiar with the MBQC model as well as our module shortly. - [MBQC Quick Start Guide](MBQC_EN.ipynb) - [Measurement-based Quantum Approximate Optimization Algorithm](QAOA_EN.ipynb) - [Polynomial Unconstrained Boolean Optimization Problem in MBQC](PUBO_EN.ipynb) +- [Speeding Up Quantum Circuit Simulation by MBQC](Pattern_EN.ipynb) ## Frequently Asked Questions diff --git a/tutorial/mbqc/MBQC_CN.ipynb b/tutorials/mbqc/MBQC_CN.ipynb similarity index 97% rename from tutorial/mbqc/MBQC_CN.ipynb rename to tutorials/mbqc/MBQC_CN.ipynb index 3de7ac3..9abfc4e 100644 --- a/tutorial/mbqc/MBQC_CN.ipynb +++ b/tutorials/mbqc/MBQC_CN.ipynb @@ -2,17 +2,20 @@ "cells": [ { "cell_type": "markdown", + "metadata": { + "tags": [] + }, "source": [ "# MBQC 入门介绍 \n", "\n", " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ], - "metadata": { - "tags": [] - } + ] }, { "cell_type": "markdown", + "metadata": { + "tags": [] + }, "source": [ "## 概述\n", "\n", @@ -43,13 +46,13 @@ "
表 1：基于测量的量子计算模型与量子电路模型的优势和限制比较
\n", "\n", "MBQC 模型因为没有经典对应，初学者可能有些难以用直觉去理解，但也正是这种超乎直觉的计算方式，给该模型带来了更多探索的空间和无穷的乐趣。接下来，就让我们共同走进 MBQC 模型的世界，一起来探索其中的奥秘吧！" - ], - "metadata": { - "tags": [] - } + ] }, { "cell_type": "markdown", + "metadata": { + "tags": [] + }, "source": [ "## 预备知识\n", "\n", @@ -84,13 +87,13 @@ "- XZ 平面测量：$M^{XZ}(\\theta) = \\{R_y(\\theta)|0\\rangle, R_y(\\theta)|1\\rangle\\}$，其中，当 $\\theta = 0$ 时为 $Z$ 测量；\n", "\n", "以上 $|+\\rangle = (|0\\rangle + |1\\rangle)/ \\sqrt{2},|-\\rangle = (|0\\rangle - |1\\rangle)/ \\sqrt{2}$, 且 $R_x, R_y, R_z$ 分别为绕 $x,y,z$ 轴旋转的单比特旋转门。" - ], - "metadata": { - "tags": [] - } + ] }, { "cell_type": "markdown", + "metadata": { + "tags": [] + }, "source": [ "## 框架介绍\n", "\n", @@ -111,7 +114,7 @@ "\n", "#### 测量模式与 \"EMC\" 语言\n", "\n", - "除了常用的“三步走”流程之外，一个 MBQC 模型还可以用 \"EMC\" 语言 [18] 来描述。如前所述，MBQC 模型与电路模型具有一一对应关系。我们可以把由电路模型对应的 MBQC 模型称为该电路模型的测量**模式 (pattern)** ，把电路中的单个量子门或对输出态的单个测量对应的 MBQC 模型称为该量子门或测量对应的**子模式 (subpattern)** [18]。在描述 MBQC 的 \"EMC\" 语言中，我们将纠缠操作对应 “纠缠命令”，用符号 \"E\" 来表示；将测量操作对应 “测量命令”，用符号 \"M\" 来表示；将副产品纠正操作对应 “副产品纠正命令”，用符号 \"C\" 来表示。于是，对应于上述“三步走”流程，一个完整的 MBQC 运算过程还可以用“命令列表” \\[EMC\\] 来表示。运算过程则是按照命令列表从左至右的顺序执行各个命令。为了让大家快速地熟悉 MBQC 模型，在本教程中，我们采用经典的“三步走”流程来描述 MBQC 模型的运算过程。\n", + "除了常用的“三步走”流程之外，一个 MBQC 模型还可以用 \"EMC\" 语言 [18] 来描述。如前所述，MBQC 模型与电路模型具有一一对应关系。我们可以把由电路模型对应的 MBQC 模型称为该电路模型的测量**模式 (pattern)** ，把电路中的单个量子门或对输出态的单个测量对应的 MBQC 模型称为该量子门或测量对应的**子模式 (subpattern)** [18]。在描述 MBQC 的 \"EMC\" 语言中，我们将纠缠操作对应 “纠缠命令”，用符号 \"E\" 来表示；将测量操作对应 “测量命令”，用符号 \"M\" 来表示；将副产品纠正操作对应 “副产品纠正命令”，用符号 \"C\" 来表示。于是，对应于上述“三步走”流程，一个完整的 MBQC 运算过程还可以用“命令列表” \\[EMC\\] 来表示。运算过程则是按照命令列表从左至右的顺序执行各个命令。为了让大家快速地熟悉 MBQC 模型，在本教程中，我们采用经典的“三步走”流程来描述 MBQC 模型的运算过程；但是在后续教程 [MBQC 模型加速量子电路模拟](Pattern_CN.ipynb)中，我们将会采用运算起来更为方便的 \"EMC\" 语言来描述 MBQC 模型的运算过程。需要注意的是，“三步走”流程和 \"EMC\" 语言只是 MBQC 模型运算过程的不同表示方式，两者本质是一样的。\n", "\n", "#### 代码实现\n", "\n", @@ -198,20 +201,18 @@ "classical_output = mbqc.get_classical_output()\n", "quantum_output = mbqc.get_quantum_output()\n", "```" - ], - "metadata": { - "tags": [] - } + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "跟据前面的介绍，相信大家对 MBQC 模型以及我们设计的 MBQC 模拟模块有了大致的了解。下面我们用两个示例带领大家进行一些实战。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 2. 使用示例：用 MBQC 实现任意单比特量子门\n", "\n", @@ -223,21 +224,22 @@ "**注意**：测量完前四个比特后，第五个量子比特的状态为 $X^{s_2 + s_4}Z^{s_1 + s_3} U|\\psi\\rangle$，其中 $X^{s_2 + s_4}Z^{s_1 + s_3}$ 就是所谓的副产品，我们需要跟据测量结果，对此进行修正，才能得到想要的 $U|\\psi\\rangle$。\n", "\n", "以下是代码展示：" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### 引入计算所需要的模块\n", "\n", "一方面，我们需要引入 `numpy` 和 `paddle` 两个常用的计算模块；另一方面，我们需要引入 MBQC 模拟的相关模块，其中 `simulator` 为模拟的核心模块，主要包含 `MBQC` 类，我们可以实例化这个类，搭建属于自己的 MBQC 模型；`qobject` 包含量子信息处理常用的量子对象（如：`State`,`Circuit`,`Pattern`等）；`utils` 包含计算所需要的常用函数（如：`plus_state` 加态，`basis` 常用测量基等）。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# 引入常用的计算模块\n", "from numpy import pi\n", @@ -246,22 +248,22 @@ "from paddle_quantum.mbqc.simulator import MBQC\n", "from paddle_quantum.mbqc.qobject import State\n", "from paddle_quantum.mbqc.utils import rotation_gate, basis, random_state_vector, compare_by_vector" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### 输入图和量子态\n", "\n", "接下来，我们可以自定义要输入的图，在此例中，如图 $3$ 所示，我们需要输入的是五个带标签的节点（记作 `['1', '2', '3', '4', '5']` ）和图中的四条边（记作 `[('1', '2'), ('2', '3'), ('3', '4'), ('4', '5')]` ），并在最左侧的比特 `'1'` 上输入量子态，同时初始化测量的角度。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# 构造用于 MBQC 计算的图\n", "V = ['1', '2', '3', '4', '5']\n", @@ -275,22 +277,22 @@ "alpha = to_tensor([pi / 6], dtype='float64')\n", "beta = to_tensor([pi / 4], dtype='float64')\n", "gamma = to_tensor([pi / 3], dtype='float64')" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### 初始化 MBQC 模型\n", "\n", "实例化 `MBQC` 类并设置图和输入量子态的信息，就可以搭建属于自己的 MBQC 模型了。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# 实例化 MBQC 类\n", "mbqc = MBQC()\n", @@ -298,47 +300,46 @@ "mbqc.set_graph(G)\n", "# 输入初始量子态的信息\n", "mbqc.set_input_state(input_state)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "之后，我们依次对四个节点进行测量。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### 测量第一个节点\n", "\n", "根据图 3，第一个比特的测量方式为 $X$ 测量，也就是 $XY$ 平面测量角度为 $0$ 的情形，即 $\\theta_1 = 0$。 " - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# 计算第一个比特的测量角度\n", "theta1 = to_tensor([0], dtype='float64')\n", "# 对第一个比特进行测量\n", "mbqc.measure('1', basis('XY', theta1))" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "第一个比特的测量不涉及适应性的问题，所以比较简单，但对于第二、三和四个比特而言，其测量角度就需要考虑前面的测量结果了。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### 测量第二个节点\n", "\n", @@ -351,23 +352,23 @@ "也就是 $XY$ 平面测量角度为 $(-1)^{s_1 + 1} \\alpha$ 的测量，其中 $s_1$ 为第一个节点的测量结果。 \n", "\n", "在 `MBQC` 类中，我们定义了类方法 `sum_outcomes` ，可以对指定输入标签的量子比特的测量结果进行求和运算，如果想要对求和结果额外加上一个数字 $x$，则可在第二个参数处赋值 $x$，否则为 $0$。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# 计算第二个比特的测量角度\n", "theta2 = to_tensor((-1) ** mbqc.sum_outcomes(['1'], 1), dtype='float64') * alpha\n", "# 对第二个比特进行测量\n", "mbqc.measure('2', basis('XY', theta2))" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### 测量第三个节点\n", "\n", @@ -378,23 +379,23 @@ "$$\n", "\n", "也就是 $XY$ 平面测量角度为 $(-1)^{s_2 + 1} \\beta$ 的测量，其中 $s_2$ 为第二个节点的测量结果。 " - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# 计算第三个比特的测量角度\n", "theta3 = to_tensor((-1) ** mbqc.sum_outcomes(['2'], 1), dtype='float64') * beta\n", "# 对第三个比特进行测量\n", "mbqc.measure('3', basis('XY', theta3))" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### 测量第四个节点\n", "\n", @@ -405,53 +406,54 @@ "$$\n", "\n", "也就是 $XY$ 平面测量角度为 $(-1)^{s_1 + s_3 + 1} \\gamma$ 的测量，其中 $s_1$ 为第一个节点的测量结果，其中 $s_3$ 为第三个节点的测量结果。 " - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# 计算第四个比特的测量角度\n", "theta4 = to_tensor((-1) ** mbqc.sum_outcomes(['1', '3'], 1), dtype='float64') * gamma\n", "# 对第四个比特进行测量\n", "mbqc.measure('4', basis('XY', theta4))" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### 对第五个节点输出的量子态进行修正\n", "\n", "前四个节点测量结束之后，第五个节点上的输出量子态并不是 $U|\\psi\\rangle$，而是附带有副产品的量子态 $X^{s_2 + s_4}Z^{s_1 + s_3} U|\\psi\\rangle$， 如果希望输出量子态为 $U|\\psi\\rangle$，需要在测量结束之后对副产品进行修正。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# 对量子态的副产品进行修正\n", "mbqc.correct_byproduct('X','5', mbqc.sum_outcomes(['2','4']))\n", "mbqc.correct_byproduct('Z','5', mbqc.sum_outcomes(['1','3']))" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### 读取修正后的量子态并与预期的量子态进行比较\n", "\n", "调用 `get_classical_output` 和 `get_quantum_output` 分别获取经典和量子输出结果。为了方便检验修正之后的量子态是否为我们预期的单比特量子门演化后的量子态 $U|\\psi\\rangle$，我们在 `utils` 模块中定义了两种比较两个量子态是否相同的函数 `compare_by_vector` 和 `compare_by_density`，前者是通过量子态列向量进行比较，后者是将量子态转化为密度矩阵进行比较。实际使用的时候，我们可以根据自己的需求调用这两个函数。若两个量子态相同，则该函数输出误差范数，并打印 \"They are exactly the same states.\" 字样。（注意：我们默认误差范数在 1e-14 到 1e-16 之间的两个量子态为同一量子态。）" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# 读取经典输出结果\n", "classical_output = mbqc.get_classical_output()\n", @@ -467,12 +469,11 @@ "\n", "# 与预期的输出态进行比较\n", "compare_by_vector(quantum_output, state_std)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 3. 使用示例： 用 MBQC 实现 CNOT 门\n", "\n", @@ -484,12 +485,13 @@ "**注意**：与前面的单比特量子门类似，我们需要在测量完之后对副产品进行修正才能得到预期的 $\\text{CNOT}|\\psi\\rangle$。\n", "\n", "以下是完整的代码展示：" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# 引入常用的计算模块\n", "from paddle import to_tensor, matmul\n", @@ -562,12 +564,11 @@ "\n", "# 与预期的量子态作比较\n", "compare_by_vector(quantum_output, state_std)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## 欢迎使用 MBQC 模块！\n", "\n", @@ -575,13 +576,14 @@ "\n", "- [基于测量的量子近似优化算法](QAOA_CN.ipynb)\n", "- [MBQC 模型下求解多项式组合优化问题](PUBO_CN.ipynb)\n", + "- [MBQC 模型加速量子电路模拟](Pattern_CN.ipynb)\n", "\n", "我们开发的 MBQC 模块作为量桨平台的新功能，它所能做的远不止上述这几个例子，我们真诚希望您可以使用 MBQC 模型和我们开发的模块去探索更多有趣的实例！关于 MBQC 计算模型本身更为详细的学习，有兴趣的读者可以参考 [15,16]。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "---\n", "\n", @@ -622,8 +624,7 @@ "[17] Nielsen, Michael A., and Isaac Chuang. \"Quantum computation and quantum information.\"[Cambridge university press (2010).](https://www.cambridge.org/core/books/quantum-computation-and-quantum-information/01E10196D0A682A6AEFFEA52D53BE9AE)\n", "\n", "[18] Danos, Vincent, et al. \"The measurement calculus.\" [Journal of the ACM (JACM) 54.2 (2007): 8-es.](https://dl.acm.org/doi/abs/10.1145/1219092.1219096)" - ], - "metadata": {} + ] } ], "metadata": { @@ -701,4 +702,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/tutorial/mbqc/MBQC_EN.ipynb b/tutorials/mbqc/MBQC_EN.ipynb similarity index 96% rename from tutorial/mbqc/MBQC_EN.ipynb rename to tutorials/mbqc/MBQC_EN.ipynb index 0f16af8..0d99ca6 100644 --- a/tutorial/mbqc/MBQC_EN.ipynb +++ b/tutorials/mbqc/MBQC_EN.ipynb @@ -2,17 +2,20 @@ "cells": [ { "cell_type": "markdown", + "metadata": { + "tags": [] + }, "source": [ "# MBQC Quick Start Guide\n", "\n", " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ], - "metadata": { - "tags": [] - } + ] }, { "cell_type": "markdown", + "metadata": { + "tags": [] + }, "source": [ "## Introduction\n", "\n", @@ -37,13 +40,13 @@ "
Table 1: Advantages and limitations of MBQC and quantum circuit models
\n", "\n", "Since MBQC does not have a classical analog, it may be difficult for beginners to understand it intuitively. However, it is this super-intuitive approach that brings a wide range of opportunities to explore the unknowns. So, let's dive into the world of MBQC and explore the mysteries together!" - ], - "metadata": { - "tags": [] - } + ] }, { "cell_type": "markdown", + "metadata": { + "tags": [] + }, "source": [ "## Prerequisites\n", "\n", @@ -75,13 +78,13 @@ "- XZ-plane measurement: $M^{XZ}(\\theta) = \\{R_y(\\theta)|0\\rangle, R_y(\\theta)|1\\rangle\\}$, reducing to $Z$ measurement if $\\theta = 0$.\n", "\n", "In the above definitions, we use $|+\\rangle = (|0\\rangle + |1\\rangle)/ \\sqrt{2},|-\\rangle = (|0\\rangle - |1\\rangle)/ \\sqrt{2}$, and $R_x, R_y, R_z$ are rotation gates around $x,y,z$ axes respectively." - ], - "metadata": { - "tags": [] - } + ] }, { "cell_type": "markdown", + "metadata": { + "tags": [] + }, "source": [ "## MBQC Module Framework\n", "\n", @@ -102,7 +105,7 @@ "\n", "#### Measurement pattern and \"EMC\" language\n", "\n", - "Besides the \"three-step\" process, an MBQC model can also be described by the **EMC** language from the measurement calculus [18]. As is mentioned above, MBQC admits a one-to-one correspondence to the circuit model. We can usually call the MBQC equivalent of a quantum circuit as a measurement **pattern** while the equivalent of a specific gate/measurement is called **subpattern** [18]. In the \"EMC\" language, we usually call an entanglement operation \"an entanglement command\", denoted by \"E\"; call a measurement operation \"a measurement command\", denoted by \"M\"; call a byproduct correction operation \"a byproduct correction command\", denoted by \"C\". Therefore, in parallel with the\"three-step\" process, MBQC is also characterized by an \"EMC\" command list. The process of computation is to execute commands in the command list in order. However, to familiarize ourselves with MBQC quickly, we will adopt the conventional \"three-step\" process to describe MBQC in this tutorial.\n", + "Besides the \"three-step\" process, an MBQC model can also be described by the **EMC** language from the measurement calculus [18]. As is mentioned above, MBQC admits a one-to-one correspondence to the circuit model. We can usually call the MBQC equivalent of a quantum circuit as a measurement **pattern** while the equivalent of a specific gate/measurement is called **subpattern** [18]. In the \"EMC\" language, we usually call an entanglement operation \"an entanglement command\", denoted by \"E\"; call a measurement operation \"a measurement command\", denoted by \"M\"; call a byproduct correction operation \"a byproduct correction command\", denoted by \"C\". Therefore, in parallel with the\"three-step\" process, MBQC is also characterized by an \"EMC\" command list. The process of computation is to execute commands in the command list in order. However, to familiarize ourselves with MBQC quickly, we will adopt the conventional \"three-step\" process to describe MBQC in this tutorial. In a later tutorial [Speeding up quantum circuit simulation by MBQC](/tutorials/measurement-based-quantum-computation/speeding-up-quantum-circuit-simulation-by-mbqc.html), we will use the \"EMC\" language instead as it is more friendly for specific calculations. It should be noted that the \"three-step\" process and the \"EMC\" language are essentially the same things with different denotations.\n", "\n", "#### Code implementation\n", "\n", @@ -190,20 +193,18 @@ "classical_output = mbqc.get_classical_output()\n", "quantum_output = mbqc.get_quantum_output()\n", "```" - ], - "metadata": { - "tags": [] - } + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "After going through the above introduction, I am sure you already have a basic understanding of MBQC and our simulation module. Now, let's do some combat exercises with the following two examples!" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 2. Example: general single-qubit unitary gate in MBQC\n", "\n", @@ -216,21 +217,22 @@ "**Note**: after measuring the first four qubits, state on qubit $5$ has the form of $X^{s_2 + s_4}Z^{s_1 + s_3} U|\\psi\\rangle$, where $X^{s_2 + s_4}$ and $Z^{s_1 + s_3}$ are the so-called byproducts. We need to correct them according to the measurement outcomes to get the desired state of $U|\\psi\\rangle$.\n", "\n", "Here is the code implementation:" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### Import relevant modules\n", "\n", "We first import two common modules `numpy` and `paddle`. Then we need to import the MBQC simulation module ``simulator`` which mainly contains the class ``MBQC``. We can instantiate this class and create an MBQC model. We also need to import the ``qobject`` module which contains quantum objects that are frequently used in quantum information processing (e.g. ``State``, ``Circuit``, ``Pattern``). Finally, we import the ``utils`` module that provides commonly used functions (e.g. ``plus_state``, ``basis`` etc.). " - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Import common calculation modules\n", "from numpy import pi\n", @@ -239,22 +241,22 @@ "from paddle_quantum.mbqc.simulator import MBQC\n", "from paddle_quantum.mbqc.qobject import State\n", "from paddle_quantum.mbqc.utils import rotation_gate, basis, random_state_vector, compare_by_vector" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### Set graph and state\n", "\n", "Then, we can set the graph on our own. For this instance in Figure 3, we need five vertices (recorded as `['1', '2', '3', '4', '5']`) and four edges (recorded as (`[('1', '2'), ('2', '3'), ('3', '4'), ('4', '5')]`)). We need to set an input the state on vertex `'1'` and initialize measurement angles." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Construct the underlying graph\n", "V = ['1', '2', '3', '4', '5']\n", @@ -268,22 +270,22 @@ "alpha = to_tensor([pi / 6], dtype='float64')\n", "beta = to_tensor([pi / 4], dtype='float64')\n", "gamma = to_tensor([pi / 3], dtype='float64')" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### Instantiate an MBQC model\n", "\n", "Then we can construct our own MBQC model by instantiating the class `MBQC` and setting the graph and input state." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Instantiate MBQC\n", "mbqc = MBQC()\n", @@ -291,47 +293,46 @@ "mbqc.set_graph(G)\n", "# Set the input state\n", "mbqc.set_input_state(input_state)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Then, we perform measurements on the first four vertices." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### Measure the first vertex\n", "\n", "As shown in Figure 3, we perform $X$-measurement on the first vertex, that is, the measurement in $XY$-plane with an angle of $\\theta_1 = 0$。 " - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Calculate the angle for the first measurement\n", "theta1 = to_tensor([0], dtype='float64')\n", "# Measure the first vertex\n", "mbqc.measure('1', basis('XY', theta1))" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Measurement on the first vertex is straightforward because it is not adaptive. However, things will be tougher to the second, third, and fourth vertices, as the measurement angles are set adaptively according to the previous measurement outcomes." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### Measure the second vertex\n", "\n", @@ -344,23 +345,23 @@ "This is a measurement in the $XY$-plane with an adaptive angle $(-1)^{s_1 + 1} \\alpha$, where $s_1$ is the outcome of the first vertex. \n", "\n", "There is a method `sum_outcomes` in the class `MBQC` to calculate the summation of outcomes for vertices in the first argument. If we want to add an extra value \"$x$\" on top of the summation, we can set the second argument to be $x$.Otherwise, the default value of the second argument is $0$." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Calculate the angle for the second measurement\n", "theta2 = to_tensor((-1) ** mbqc.sum_outcomes(['1'], 1), dtype='float64') * alpha\n", "# Measure the second vertex\n", "mbqc.measure('2', basis('XY', theta2))" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### Measure the third vertex\n", "\n", @@ -371,23 +372,23 @@ "$$\n", "\n", "This is a measurement in the $XY$-plane with an adaptive angle $(-1)^{s_2 + 1} \\beta$, where $s_2$ is the outcome of the second vertex." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Calculate the angle for the third measurement\n", "theta3 = to_tensor((-1) ** mbqc.sum_outcomes(['2'], 1), dtype='float64') * beta\n", "# Measure the third vertex\n", "mbqc.measure('3', basis('XY', theta3))" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### Measure the fourth vertex\n", "\n", @@ -398,53 +399,54 @@ "$$\n", "\n", "This is a measurement in the $XY$-plane with an adaptive angle $(-1)^{s_1 + s_3 + 1} \\gamma$, where $s_1$ and $s_3$ are respectively the outcomes of the first and the third vertices." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Calculate the angle for the fourth measurement\n", "theta4 = to_tensor((-1) ** mbqc.sum_outcomes(['1', '3'], 1), dtype='float64') * gamma\n", "# Measure the fourth vertex\n", "mbqc.measure('4', basis('XY', theta4))" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### Correct byproducts on the fifth vertex\n", "\n", "After measurements on the first four vertices, the state on the fifth vertex is not exactly $U|\\psi\\rangle$, but a state with byproducts $X^{s_2 + s_4}Z^{s_1 + s_3} U|\\psi\\rangle$. To obtain the desired $U|\\psi\\rangle$, we must correct byproducts on the fifth vertex." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Correct byproducts on the fifth vertex\n", "mbqc.correct_byproduct('X','5', mbqc.sum_outcomes(['2','4']))\n", "mbqc.correct_byproduct('Z','5', mbqc.sum_outcomes(['1','3']))" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "#### Obtain the final output state and compare it with the expected one\n", "\n", "We can call `get_classical_output` and `get_quantum_output` to obtain the classical and quantum outputs after simulation. We also provide in the module ``utils`` two functions `compare_by_vector` and `compare_by_density` to check if two given quantum states are identical. The former function compares two states by their state vectors, while the second function compares their density matrices. If two states are identical, both functions will return the norm difference of these two states, and print a statement: \"They are exactly the same states.\" (Note: we regard two states as the same if their norm difference is within the range of 1e-14 and 1e-16.)" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Obtain the classcial result\n", "classical_output = mbqc.get_classical_output()\n", @@ -460,12 +462,11 @@ "\n", "# Compare with the expected state\n", "compare_by_vector(quantum_output, state_std)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 3. Example: CNOT gate in MBQC\n", "\n", @@ -477,12 +478,13 @@ "**Note**: Similar to the first example, byproduct corrections are necessary to get the desired $\\text{CNOT}|\\psi\\rangle$.\n", "\n", "Here is a complete code implementation:" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "# Import common calculation modules\n", "from paddle import to_tensor, matmul\n", @@ -556,12 +558,11 @@ "\n", "# Compare with the expected result\n", "compare_by_vector(quantum_output, state_std)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Welcome Aboard!\n", "\n", @@ -569,13 +570,14 @@ "\n", "- [Measurement-based Quantum Approximate Optimization Algorithm](QAOA_EN.ipynb)\n", "- [Polynomial Unconstrained Boolean Optimization Problem in MBQC](PUBO_EN.ipynb)\n", + "- [Speeding Up Quantum Circuit Simulation by MBQC](Pattern_EN.ipynb)\n", "\n", "Our MBQC module provides all the essential building blocks for the implementation of a general MBQC algorithm. It can do much beyond than what we have listed above. We sincerely encourage you to explore more potential applications with MBQC and our module! If you are interested in a more detailed study of MBQC itself, please refer to [15,16]." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "---\n", "\n", @@ -616,8 +618,7 @@ "[17] Nielsen, Michael A., and Isaac Chuang. \"Quantum computation and quantum information.\"[Cambridge university press (2010).](https://www.cambridge.org/core/books/quantum-computation-and-quantum-information/01E10196D0A682A6AEFFEA52D53BE9AE)\n", "\n", "[18] Danos, Vincent, et al. \"The measurement calculus.\" [Journal of the ACM (JACM) 54.2 (2007): 8-es.](https://dl.acm.org/doi/abs/10.1145/1219092.1219096)" - ], - "metadata": {} + ] } ], "metadata": { @@ -690,4 +691,4 @@ }, "nbformat": 4, "nbformat_minor": 4 -} \ No newline at end of file +} diff --git a/tutorial/mbqc/PUBO_CN.ipynb b/tutorials/mbqc/PUBO_CN.ipynb similarity index 98% rename from tutorial/mbqc/PUBO_CN.ipynb rename to tutorials/mbqc/PUBO_CN.ipynb index b3d8d70..00212c5 100644 --- a/tutorial/mbqc/PUBO_CN.ipynb +++ b/tutorials/mbqc/PUBO_CN.ipynb @@ -455,7 +455,11 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "至此，我们完成了本教程的两个完整示例。MB-QAOA 算法实现预示着 MBQC 模型在量子机器学习领域强大的潜力。很显然，MBQC 模型所能够处理的算法不仅有 QAOA，我们非常期待 MBQC 这种非同寻常的计算方式能在某些特殊情境下展现出无与伦比的优势！" + "至此，我们完成了本教程的两个完整示例。MB-QAOA 算法实现预示着 MBQC 模型在量子机器学习领域强大的潜力。很显然，MBQC 模型所能够处理的算法不仅有 QAOA，我们非常期待 MBQC 这种非同寻常的计算方式能在某些特殊情境下展现出无与伦比的优势！\n", + "\n", + "接下来的一个教程将会给出我们在 MBQC 模型优势上的一个探索，一起去学习吧！\n", + "\n", + "[MBQC 模型加速量子电路模拟](Pattern_EN.ipynb)" ] }, { diff --git a/tutorial/mbqc/PUBO_EN.ipynb b/tutorials/mbqc/PUBO_EN.ipynb similarity index 98% rename from tutorial/mbqc/PUBO_EN.ipynb rename to tutorials/mbqc/PUBO_EN.ipynb index 27324ef..213b0a2 100644 --- a/tutorial/mbqc/PUBO_EN.ipynb +++ b/tutorials/mbqc/PUBO_EN.ipynb @@ -458,7 +458,11 @@ "metadata": {}, "source": [ "Now, we have completed the demonstration of two examples. The implementation of MB-QAOA indicates a great potential of MBQC in the field of quantum machine learning. Apparently, MBQC model can realize quantities of algorithms far beyond QAOA. We therefore are \n", - "looking forward to exploring more on this and to show some unparalleled advantages in practice." + "looking forward to exploring more on this and to show some unparalleled advantages in practice.\n", + "\n", + "As a matter of fact, we have found an interesting application of MBQC in simulating a special class of quantum circuits! So, let's continue our exploration to the next tutorial together:\n", + "\n", + "[Speeding up Quantum Circuit Simulation by MBQC](Pattern_EN.ipynb)" ] }, { diff --git a/tutorials/mbqc/Pattern_CN.ipynb b/tutorials/mbqc/Pattern_CN.ipynb new file mode 100644 index 0000000..b5b932e --- /dev/null +++ b/tutorials/mbqc/Pattern_CN.ipynb @@ -0,0 +1,558 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# MBQC 模型加速量子电路模拟\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ], + "metadata": { + "tags": [] + } + }, + { + "cell_type": "markdown", + "source": [ + "## 概述\n", + "\n", + "量子计算利用量子世界中特有的运行规律，为我们提供了一条全新的并且非常有前景的信息处理方式。在当下，量子计算机仍处于研发中的初级阶段，其制造、运行和维护的成本极其昂贵。幸运的是，使用经典计算机模拟量子算法的方式足以满足大部分的科研和教学等需求。2012 年 John Preskill 提出 “量子计算优越性”（又称 “量子霸权”）这一概念，揭起了量子算法与经典算法性能大比拼的序幕 [1,2]。在各界科研团队竞相宣告“量子优越性”实现的同时，也有越来越多的人关注如何使用经典计算机和特殊的优化算法完成对量子计算机的模拟，进而挑战这些量子计算设备的“霸权地位”。不论是科学研究还是教学应用，如何提高经典计算机对量子计算机的模拟能力是一个备受关注的问题。\n", + "\n", + "我们在使用经典计算机模拟量子算法时，通常使用列向量来描述和存储量子态。单比特的量子态需要长度为 $2 \\times 1$ 大小的列向量来存储，$n$ 比特的量子态则需要长度为 $2^n \\times 1$ 大小的列向量来存储。由于列向量的长度会随着比特数的增加呈指数增长，当比特数较大时，经典计算机很难去存储和模拟计算。当下现有的量子电路模拟方式最多能支持模拟几十个量子比特的算法。解决这个瓶颈问题的思路之一是通过改变数据结构来改变量子态的存储方式，目前主流的可以用于替换量子态列向量的数据结构有决策图，张量网络（包括矩阵乘积态）等，每一种存储结构对应一种量子电路的模拟方式。然而，这些模拟方式始终都停留在**量子电路模型 (quantum circuit model)** 的讨论框架中。\n", + "\n", + "解决上述内存和计算资源消耗问题的另一个思路便是跳出量子电路模型的框架，尝试使用另一种等价模型来完成计算。**基于测量的量子计算模型 (measurement based quantum computation, MBQC)** [3-6]自提出后，以其独特的运算过程备受关注。如[MBQC 入门介绍](MBQC_CN.ipynb)中所讲，对于无依赖关系的测量，物理实现上可以同时进行，经典模拟上则可以通过优化执行顺序来降低实际参与运算的比特数量，从而减少内存消耗和计算量。\n", + "\n", + "本教程将会介绍如何利用 MBQC 模型，并依据其测量执行顺序的多样性对其进行优化，最终提高对应量子电路的模拟效率。同时，我们也将会介绍基于该模拟思路所开发的 MBQC 电路模块和翻译模块的使用方法。" + ], + "metadata": { + "tags": [] + } + }, + { + "cell_type": "markdown", + "source": [ + "## 量子电路模拟\n", + "\n", + "本教程提出的量子电路模拟的思路主要分为以下三个步骤，每个步骤有其需要调用的模块。每个模块对应的核心类及对应实现的功能，如表 1 所示：\n", + "\n", + "|步骤|调用的模块|实例化类|实现的功能|\n", + "|:---:|:---:|:---:|:---:|\n", + "|构造量子电路|``qobject`` 模块| `Circuit` 类|输入量子电路信息（包含量子门和测量信息）|\n", + "|翻译和优化|``mcalculus`` 模块| `MCalculus` 类|将量子电路翻译成 MBQC 模型并进行优化处理|\n", + "|模拟执行|``simulator`` 模块| `MBQC`类|模拟执行翻译后得到的模型并获得其运算结果|\n", + "\n", + "
表 1：本教程提出的量子电路模拟思路
\n", + "\n", + "以下我们对这三个步骤分别做出详细的说明和对应的代码演示。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 构造量子电路\n", + "\n", + "在 MBQC 工具包的``qobject``中，我们设置了 ``Circuit`` 类，用于记录和存储用户输入的量子门和测量信息。为了让模型更加直观，便于大家接受和使用，我们在实例化该类之后，通过调用类方法来搭建属于自己的量子电路。在搭建量子门时，调用类方法的格式类似于量桨中我们熟悉的 [UAnsatz](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html) 电路，大家可以参考[量桨上的教程及示例](https://qml.baidu.com/quick-start/quantum-neural-network.html)类比学习。如图 1 所示，我们使用一个简单的例子，来向大家展示 ``Circuit`` 类的使用方法。\n", + "\n", + "![Circuit example](./figures/mbqc-fig-pat-cir-intro.png)\n", + "
图 1: 一个简单的量子电路图示例
\n", + "\n", + "其中，$Ry$ 代表一个绕 y 轴的单比特旋转门，双比特量子门为 $CNOT$ 门，初始态为 $|0\\rangle$ 态。用 ``Circuit`` 类搭建该量子电路的代码实现如下：" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# 引入需要的计算模块\n", + "from numpy import pi, random\n", + "from paddle import to_tensor\n", + "\n", + "# 引入需要的 Circuit 模块\n", + "from paddle_quantum.mbqc.qobject import Circuit\n", + "\n", + "# 设置角度参数 theta \n", + "theta = random.rand(4) * 2 * pi \n", + " \n", + "# 将 Numpy array 转换成 Paddle 中的 Tensor\n", + "theta = to_tensor(theta, dtype='float64')\n", + "\n", + "# 初始化量子电路\n", + "qubit_number = 2\n", + "cir = Circuit(qubit_number)\n", + "\n", + "# 添加 Ry 旋转门\n", + "cir.ry(theta[0], 0)\n", + "cir.ry(theta[1], 1)\n", + "\n", + "# 添加 CNOT 门\n", + "cir.cnot([0, 1])\n", + "\n", + "# 添加 Ry 旋转门\n", + "cir.ry(theta[2], 0)\n", + "cir.ry(theta[3], 1)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "然后，我们输入量子电路中的测量信息。\n", + "\n", + "**注意**：用``Circuit`` 输入测量的方式与 ``UAnsatz`` 电路不同！ ``Circuit`` 类需要在执行运算之前就需要调用 ``.measure`` 方法输入测量比特信息，而 ``UAnsatz`` 是在运行完量子电路之后调用 ``.measure`` 方法，对输出的量子态进行测量。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# 输入测量比特的信息\n", + "# 默认对电路中的所有比特进行测量\n", + "cir.measure()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "接下来，我们需要将该电路传递给 MBQC 翻译模块进行翻译和优化。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 翻译和优化\n", + "\n", + "翻译过程的主要逻辑参考文献 [7,8]，感兴趣的朋友可以自行学习文献中的细节，在此我们仅简要阐述翻译的思路及其代码实现。\n", + "\n", + "我们在 [MBQC 入门介绍](MBQC_CN.ipynb)中提及了 MBQC 模型的 \"EMC\" 语言，这里我们简单回顾一下。我们把由电路模型翻译得到的 MBQC 模型称为该电路模型对应的**模式 (pattern)** ，把由电路中的单个量子门或对输出态的单个测量翻译得到的 MBQC 模型称为该量子门或测量对应的**子模式 (subpattern)** [7]。量子电路的翻译过程实际上就是对所有量子门和所有电路测量进行逐一翻译、标准化、化简和优化的过程，具体来讲分为以下三步：\n", + "\n", + "- 逐一翻译：将电路中的每一个量子门和测量逐一翻译为对应的子模式\n", + "- 标准化：将所有翻译后得到的子模式整合为一个标准化的模式，构成电路模型对应的模式\n", + "- 化简和优化：对模式中的测量命令进行化简和优化\n" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "代码实现上，我们提供了 ``MCalculus`` 类来完成由电路模型到 MBQC 模型的具体翻译和优化任务。通过调用 ``set_circuit`` 方法可以将我们构造好的量子电路 ``cir`` 传递到 ``MCalculus`` 类中。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# 引入需要的翻译和优化模块\n", + "from paddle_quantum.mbqc.mcalculus import MCalculus\n", + "\n", + "# 实例化 MCalculus 类\n", + "mc = MCalculus()\n", + "\n", + "# 将电路信息传递到 MCalculus 中\n", + "mc.set_circuit(cir)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "#### 逐一翻译\n", + "我们先将每个量子门翻译为对应的 MBQC 子模式。根据 [MBQC 入门介绍](MBQC_CN.ipynb)，MBQC 的标准“三步走”流程和 \"EMC\" 语言等价。对于 MBQC 模型下实现 $R_y$ 门，我们可以将“三步走”流程的每个步骤与 “EMC” 命令对应起来，如表 2 所示：\n", + "\n", + "|“三步走”流程的步骤| 对应的 \"EMC\" 命令|\n", + "|:---|:---|\n", + "|**量子图态准备**
在节点 $1$ 处输入初始量子态，
在节点 $2,3,4,5$ 处初始化量子态为 $\\lvert+\\rangle$,
对相邻比特作用控制 Z 门。| **纠缠命令**
$E_{12}E_{23}E_{34}E_{45}$|\n", + "|**单比特测量**
对节点 $1$ 执行 $XY$ 平面测量 $M_1$，测量角度为 $\\frac{\\pi}{2}$，测量结果为 $s_1$；
对节点 $2$ 执行 $XY$ 平面测量 $M_2$，测量角度为 $(-1)^{s_1 + 1}\\alpha$，测量结果为 $s_2$；
对节点 $3$ 执行 $XY$ 平面测量 $M_3$，测量角度为 $-\\frac{\\pi}{2} + (s_1+s_2)\\pi$，测量结果为 $s_3$；
对节点 $4$ 执行 $XY$ 平面测量 $M_4$，测量角度为 $s_2\\pi$，测量结果为 $s_4$。|**测量命令**
$M_1M_2M_3M_4$|\n", + "|**副产品纠正**
分别对节点 $5$ 执行 $X$ 副产品纠正，纠正算符 $X^{s_4}$ 和 $Z$ 副产品纠正命令，纠正算符 $Z^{s_3}$。| **副产品纠正命令**
$X_5Z_5$|\n", + "\n", + "
表 2：MBQC 实现 Ry 的“三步走”流程与 “EMC” 命令的对应关系
\n", + "\n", + "我们将上述所有命令按照先后顺序从左到右排列起来，拼接成一个命令列表 \\[$E_{12}E_{23}E_{34}E_{45}M_1M_2M_3M_4X_5Z_5$\\]，其中各命令里包含了详细的参数信息，本教程为了表述简洁未明确写出。我们只需要从左至右执行对应的命令就完成了 MBQC 模型的运算过程。\n", + "\n", + "\n", + "类似地，$CNOT$ 门对应子模式的命令列表为 \\[$E_{12}E_{23}E_{24}M_1 M_2 X_4 Z_3 Z_4$\\]。电路模型中，对输出量子态的单个比特进行测量的过程，也就是 MBQC 模型中对应输出节点进行 $Z$ 测量的过程。因此，电路模型中的单个测量步骤对应的子模式，就是对输出比特执行 $Z$ 测量的命令，用命令列表 \\[$M_1$\\] 来表示。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "我们设置了内部方法 ``__to_subpattern`` 来实现量子门和测量的翻译（该类方法中记录了所有逻辑门和测量的子模式信息；对于熟悉 MBQC 模型的朋友来说，如果希望自定义设计每个子模式，也可以直接加入其中）。当所有的量子门和测量的子模式翻译完成后，所有信息会存储在一个叫**原始模式（wild pattern）** 的变量中，便于后续的整合和处理。\n", + "\n", + "![Wild pattern](./figures/mbqc-fig-wild_pat.jpg)\n", + "
图 2: 对量子门和测量进行逐一翻译生成原始模式
" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "#### 标准化\n", + "我们有了原始模式之后，下一步就是通过**标准化（standardization）** 操作获取整个电路对应的**标准模式（standard pattern）**。所谓标准化就是把原始模式中的所有命令按纠缠命令、测量命令和副产品纠正命令的先后顺序重新排列。\n", + "\n", + "**注意**：标准化中的顺序交换的过程是不平凡的，每相邻两个命令的顺序交换需要满足特定的规则 [7]。\n", + "\n", + "![Standard pattern](./figures/mbqc-fig-pat_std.jpg)\n", + "
图 3: 原始模式标准化为标准模式
" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "代码实现上，我们提供了 ``standardize`` 类方法用于实现对命令列表的标准化处理和对子模式的整合。调用方式如下：" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# 标准化\n", + "mc.standardize()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "#### 化简和优化\n", + "在获得电路模型对应的标准模式之后，我们便可以直接将该模式返回并接入 MBQC 模拟模块中运行了。但是，考虑到翻译得到的模式并不唯一，我们可以通过一些化简和优化技巧找到更优的模式（类似于寻找更简化的等价电路图），再使用 MBQC 模拟模块运行，以此减少内存消耗和计算时间，提高运算效率。一方面，测量命令对其他节点测量结果的依赖性越强，实际参与运算的比特数就越多，因此我们可以通过尽可能简化测量命令对其他测量结果的依赖关系，减少实际运算所需的比特数；另一方面，无依赖关系的测量命令在模拟上可以交换顺序而不影响测量结果，因此我们也可以通过优化测量命令的顺序来减少模拟过程的计算量。\n", + "\n", + "基于上述两点考虑，我们将使用**信号转移**操作来简化测量命令对其他测量结果的依赖关系，另用**基于行序优先原则的优化算法**来优化测量命令的顺序。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "**信号转移**\n", + "\n", + "信号转移是针对测量命令的依赖关系进行化简的过程。简单来说，对于测量命令中的某类依赖关系，我们可以将其从测量命令中拆分出来，从而对命令进行简化 [7]。代码实现上，我们提供了 ``shift_signals`` 类方法来实现信号转移操作。调用方式如下：" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# 信号转移\n", + "mc.shift_signals()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "**基于行序优先原则的优化算法**\n", + "\n", + "基于行序优先原则的优化算法是我们自研的一类算法，该算法的初衷是希望按照行序优先的原则逐行对节点进行测量。按照这种测量方式，当该行节点都被测量之后，我们可以完全删除该行的信息，从而减小后续参与运算的比特数。在原先的电路模型中，该算法对应于按行执行量子门及测量。实验观察到，行序优先原则的优化算法可以有效优化浅层量子电路对应测量模式中的测量命令的顺序（其优势见下文）。\n", + "\n", + "代码实现上，我们提供了 ``optimize_by_row`` 类方法来实现基于行序优先原则的优化算法。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# 测量顺序优化\n", + "mc.optimize_by_row()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "对测量命令进行化简和优化之后，便结束了我们全部的翻译过程。我们可以调用 ``get_pattern`` 类方法返回翻译得到的 MBQC 测量模式。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# 返回处理后的 MBQC 模式\n", + "pattern = mc.get_pattern()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 模拟执行\n", + "\n", + "在获得翻译、化简和优化的模式之后，我们就可以使用 MBQC 模拟模块来执行该模式了。实例化 `MBQC` 类后，我们可以通过调用类方法 `set_pattern` 将模式信息传入模拟模块中，并通过调用类方法 `run_pattern` 执行运算过程，最后获得相应的运算结果。代码示例如下：" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# 引入模拟模块和常用函数\n", + "from paddle_quantum.mbqc.simulator import MBQC\n", + "from paddle_quantum.mbqc.qobject import State\n", + "from paddle_quantum.mbqc.utils import zero_state, kron, div_str_to_float\n", + "\n", + "# 实例化 MBQC 模型\n", + "mbqc = MBQC()\n", + "\n", + "# 输入模式信息\n", + "mbqc.set_pattern(pattern)\n", + "\n", + "# 输入初始量子态信息，此处选取为 |0> 态，与电路模型的输入保持一致\n", + "input_vector = kron([zero_state() for _ in range(qubit_number)])\n", + "input_system = [0,1]\n", + "input_state = State(input_vector, input_system)\n", + "\n", + "mbqc.set_input_state(input_state)\n", + "\n", + "# 按照测量模式进行运算\n", + "mbqc.run_pattern()\n", + "\n", + "# 获得运算后的量子输出\n", + "quantum_output = mbqc.get_quantum_output()\n", + "print(\"运算后的量子态为：\", quantum_output)\n", + "\n", + "# 获得运算后的经典输出\n", + "classical_output = mbqc.get_classical_output()\n", + "print(\"运算后的经典输出结果为：\", classical_output)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "至此，我们便实现了电路模拟的全部过程。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### 函数 “simulate_by_mbqc”\n", + "\n", + "为了方便使用，除了 `MBQC` 类之外，我们在 MBQC 模拟模块中单独提供了一个函数 ``simulate_by_mbqc``。我们通过调用 ``Circuit`` 类构造量子电路，之后直接调用 ``simulate_by_mbqc`` 来模拟运行。该函数可以将量子电路自动翻译为 MBQC 模型并执行运行，最后输出等价于量子电路模型的经典采样结果或量子态向量。下面我们对图 1 中的电路图，给出完整的使用示例。" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# 引入需要的通用计算模块\n", + "from numpy import random, pi\n", + "from paddle import to_tensor\n", + "\n", + "# 引入需要的 utils 模块\n", + "from paddle_quantum.mbqc.utils import random_state_vector\n", + "# 引入需要的 Circuit 模块\n", + "from paddle_quantum.mbqc.qobject import Circuit\n", + "# 引入模拟模块\n", + "from paddle_quantum.mbqc.simulator import simulate_by_mbqc\n", + "\n", + "# 设置角度参数 theta \n", + "theta = random.rand(4) * 2 * pi \n", + " \n", + "# 我们需要将 Numpy array 转换成 Paddle 中的 Tensor\n", + "theta = to_tensor(theta)\n", + "\n", + "# 初始化量子电路\n", + "qubit_number = 2\n", + "cir = Circuit(qubit_number)\n", + "\n", + "# 添加单比特旋转门\n", + "cir.ry(theta[0], 0)\n", + "cir.ry(theta[1], 1)\n", + "\n", + "# 添加两比特门\n", + "cir.cnot([0, 1])\n", + "\n", + "# 添加单比特旋转门\n", + "cir.ry(theta[2], 0)\n", + "cir.ry(theta[3], 1)\n", + "\n", + "# 输入量子测量的信息\n", + "# 默认对电路中的所有比特进行测量\n", + "cir.measure()\n", + "\n", + "# 构造初始量子态\n", + "input_vector = random_state_vector(qubit_number)\n", + "input_system = list(range(qubit_number))\n", + "input_state = State(input_vector, input_system)\n", + "\n", + "# 调用该函数运行量子电路，输入电路、初始量子态\n", + "classical_output, quantum_output = simulate_by_mbqc(cir, input_state)\n", + "\n", + "# 打印运行结果\n", + "print(\"经典输出为：\", classical_output)\n", + "print(\"量子输出为：\", quantum_output)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## 示例\n", + "\n", + "由于近期小型量子计算机缺乏纠错能力，所以在量子算法设计中，可并行性和电路深度成为很重要的考虑因素。我们希望设计的量子算法具有高度的并行性和较浅的电路深度，以使得量子计算机能尽快地完成算法的执行，从而降低退相干性对计算结果保真度的影响。基于浅层量子电路而设计的量子算法对近期量子计算的发展和落地至关重要。以下我们通过两个示例，展示本教程中电路模拟思路在浅层量子电路模拟上的提升效果。\n", + "\n", + "### 谷歌随机量子电路\n", + "\n", + "2017年，谷歌设计了一系列[随机量子电路 (GRCS)](https://github.com/sboixo/GRCS)。鉴于该类量子电路的模拟难度，其往往被作为模拟器性能的基准测试案例 [9]。\n", + "\n", + "为了展示本教程中模拟思路对量子电路模拟上的实际效果，我们选取了一部分 GRCS 中的浅层电路（特别地，我们选取了一部分**电路深度为 10** 的含 CZ 门的电路），分别使用本教程中的模拟算法和业界最领先的 Qiskit 模拟器中的两种算法（ `statevector` 和 `matrix_product_state`）进行比较。我们选取的具体示例为：\n", + "\n", + "|索引|文件名|比特数|\\||索引|文件名|比特数|\\||索引|文件名|比特数|\\||索引|文件名|比特数|\\||索引|文件名|比特数|\n", + "| :---: | :---: | :---: | :---:| :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: |:---: |:---: |:---: |\n", + "|1|inst_5x5_10_0.txt|25|**\\|** | 11|inst_5x6_10_0.txt|30|**\\|**|21|inst_6x6_10_0.txt|36|**\\|**|31|inst_6x7_10_0.txt|42|**\\|**|41|inst_7x7_10_0.txt|49|\n", + "|2|inst_5x5_10_1.txt|25|**\\|**| 12|inst_5x6_10_1.txt|30|**\\|**|22|inst_6x6_10_1.txt|36|**\\|**|32|inst_6x7_10_1.txt|42|**\\|**|42|inst_7x7_10_1.txt|49|\n", + "|3|inst_5x5_10_2.txt|25|**\\|**| 13|inst_5x6_10_2.txt|30|**\\|**|23|inst_6x6_10_2.txt|36|**\\|**|33|inst_6x7_10_2.txt|42|**\\|**|43|inst_7x7_10_2.txt|49|\n", + "|4|inst_5x5_10_3.txt|25|**\\|**| 14|inst_5x6_10_3.txt|30|**\\|**|24|inst_6x6_10_3.txt|36|**\\|**|34|inst_6x7_10_3.txt|42|**\\|**|44|inst_7x7_10_3.txt|49|\n", + "|5|inst_5x5_10_4.txt|25|**\\|**| 15|inst_5x6_10_4.txt|30|**\\|**|25|inst_6x6_10_4.txt|36|**\\|**|35|inst_6x7_10_4.txt|42|**\\|**|45|inst_7x7_10_4.txt|49|\n", + "|6|inst_5x5_10_5.txt|25|**\\|**| 16|inst_5x6_10_5.txt|30|**\\|**|26|inst_6x6_10_5.txt|36|**\\|**|36|inst_6x7_10_5.txt|42|**\\|**|46|inst_7x7_10_5.txt|49|\n", + "|7|inst_5x5_10_6.txt|25|**\\|**| 17|inst_5x6_10_6.txt|30|**\\|**|27|inst_6x6_10_6.txt|36|**\\|**|37|inst_6x7_10_6.txt|42|**\\|**|47|inst_7x7_10_6.txt|49|\n", + "|8|inst_5x5_10_7.txt|25|**\\|**| 18|inst_5x6_10_7.txt|30|**\\|**|28|inst_6x6_10_7.txt|36|**\\|**|38|inst_6x7_10_7.txt|42|**\\|**|48|inst_7x7_10_7.txt|49|\n", + "|9|inst_5x5_10_8.txt|25|**\\|**| 19|inst_5x6_10_8.txt|30|**\\|**|29|inst_6x6_10_8.txt|36|**\\|**|39|inst_6x7_10_8.txt|42|**\\|**|49|inst_7x7_10_8.txt|49|\n", + "|10|inst_5x5_10_9.txt|25|**\\|**| 20|inst_5x6_10_9.txt|30|**\\|**|30|inst_6x6_10_9.txt|36|**\\|**|40|inst_6x7_10_9.txt|42|**\\|**|50|inst_7x7_10_9.txt|49|" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "我们选取 `statevector` 和 `matrix_product_state` 两种算法中时间较短的结果作为 Qiskit 模拟器的运行时间。所有示例均使用具有 16 G 内存和 Intel Core i7 10TH GEN 处理器的普通笔记本运行，结果如图 4 所示。\n", + "\n", + "![GRCS plot](./figures/mbqc-fig-GRCS_plot.jpg)\n", + "
图 4: 不同示例下 Qiskit 与 MBQC 模拟算法运行时间比较
\n", + "\n", + "从图中可知，本教程的思路在模拟谷歌随机量子电路时具有运算效率上的显著优势。" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## 总结\n", + "\n", + "通过跳出量子电路模型的框架，本教程给出了一种使用 等价的 MBQC 模型来进行电路模拟的新思路。特别地，对于多比特浅层量子电路的模拟，该思路具有运算效率上的显著优势。我们期待该模拟思路将进一步在量子机器学习和量子神经网络的应用中带来突破。\n", + "\n", + "尽管当前我们 MBQC 模拟模块的底层采用量子态向量的数据结构，但是本教程的模拟思路并不依赖于具体计算时的数据存储方式，换句话说，该模拟思路可以与不同的数据结构配合实现。\n", + "\n", + "关于量子电路的模拟和 MBQC 模型中的算法开发均有待进一步探索，也欢迎广大量子计算开发者及爱好者加入我们，共同挖掘 MBQC 模型的无限可能！" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "---\n", + "## 参考文献\n", + "\n", + "[1] Preskill, John. \"Quantum computing and the entanglement frontier.\" [arXiv preprint arXiv:1203.5813 (2012).](https://arxiv.org/abs/1203.5813)\n", + "\n", + "[2] Preskill, John. \"Quantum computing in the NISQ era and beyond.\" [Quantum 2 (2018): 79.](https://quantum-journal.org/papers/q-2018-08-06-79/)\n", + "\n", + "[3] Robert Raussendorf, et al. \"A one-way quantum computer.\" [Physical Review Letters 86.22 (2001): 5188.](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.86.5188)\n", + "\n", + "[4] Raussendorf, Robert, and Hans J. Briegel. \"Computational model underlying the one-way quantum computer.\" [Quantum Information & Computation 2.6 (2002): 443-486.](https://dl.acm.org/doi/abs/10.5555/2011492.2011495)\n", + "\n", + "[5] Robert Raussendorf, et al. \"Measurement-based quantum computation on cluster states.\" [Physical Review A 68.2 (2003): 022312.](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.68.022312)\n", + "\n", + "[6] Briegel, Hans J., et al. \"Measurement-based quantum computation.\" [Nature Physics 5.1 (2009): 19-26.](https://www.nature.com/articles/nphys1157)\n", + "\n", + "[7] Danos, Vincent, et al. \"The measurement calculus.\" [Journal of the ACM (JACM) 54.2 (2007): 8-es.](https://dl.acm.org/doi/abs/10.1145/1219092.1219096)\n", + "\n", + "[8] Broadbent, Anne, and Elham Kashefi. \"Parallelizing quantum circuits.\" [Theoretical computer science 410.26 (2009): 2489-2510.](https://arxiv.org/abs/0704.1736)\n", + "\n", + "[9] Boixo, Sergio, et al. \"Characterizing quantum supremacy in near-term devices.\" [Nature Physics 14.6 (2018): 595-600.](https://www.nature.com/articles/s41567-018-0124-x)" + ], + "metadata": {} + } + ], + "metadata": { + "interpreter": { + "hash": "73e152e9b81fe728e387c249fa9090f02d423820fe8ab6018c11ce80df71d553" + }, + "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.11" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "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 + }, + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/tutorials/mbqc/Pattern_EN.ipynb b/tutorials/mbqc/Pattern_EN.ipynb new file mode 100644 index 0000000..26f04c7 --- /dev/null +++ b/tutorials/mbqc/Pattern_EN.ipynb @@ -0,0 +1,562 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Speeding Up Quantum Circuit Simulation by MBQC\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ], + "metadata": { + "tags": [] + } + }, + { + "cell_type": "markdown", + "source": [ + "## Introduction\n", + "\n", + "Quantum computation utilizes the peculiar laws in the quantum world and provides us with a novel and promising way of information processing. Nowadays, quantum computer is still in its early stage of development, with prohibitive manufacture, operating and maintenance costs. Fortunately, simulating quantum algorithms with classical computers is satisfactory to most scientific research and education. In 2012, John Preskill proposed the concept of \"quantum advantages\" (also known as \"quantum supremacy\"), starting a big competition between the performance of quantum and classical computers [1,2]. As different research teams announcing the achievements of quantum supremacy of their devices, there is also an increasing amount of people focusing on how to challenge the 'quantum supremacy' of those quantum computing devices, by designing efficient simulation algorithms in classical computers. How to improve the capability of simulating quantum algorithms classically is one of the most important topics in the field.\n", + "\n", + "When simulating quantum algorithms on classical computers, we usually use column vectors to represent and store a quantum state. However, to store the information of a single qubit quantum state, we need a column vector of size $2 \\times 1$, while for an $n$-qubit quantum state, we need a column vector with the size as large as $2^{n} \\times 1$. Therefore, using column vectors to store a quantum state rapidly consumes memory and computational resources, as its size increases exponentially to the number of qubits. To break through this bottleneck, one approach is to replace the data structure of qubit's information storage. The commonly used data structures to replace column vectors include decision diagrams, tensor networks (including matrix product states), etc. Each data structure has its distinctive way of quantum circuit simulation. However, all these stay in the framework of **Quantum Circuit Model**.\n", + "\n", + "Another idea to solve the bottleneck of computation resources is to jump out of the framework of the quantum circuit model and simulate a circuit by its equivalents. **Measurement-Based Quantum Computation (MBQC)** [3-6] is another universal quantum computation model, that receives wide attention by its unique way of performing computation since its proposal. As is mentioned in [MBQC Quick Start Guide](MBQC_EN.ipynb), for non-adaptive measurements, not only can they be carried out simultaneously in physical implementation, but in classical simulation, they can also help to reduce the effective number of qubits in the computation, thus reducing the consumption of memory and computational resources. \n", + "\n", + "In this tutorial, we will introduce a new scheme of quantum circuit simulation by firstly translating it into its MBQC equivalent and then optimizing the order of measurements to finally improve the simulation efficiency. In the meanwhile, we will also demonstrate applications of the ``circuit`` and ``mcalculus`` modules in our MBQC package by two concrete examples. " + ], + "metadata": { + "tags": [] + } + }, + { + "cell_type": "markdown", + "source": [ + "## Quantum Circuit Simulation\n", + "\n", + "Our new scheme of quantum circuit simulation contains three steps, and each step corresponds to a module in the MBQC package. The main class in each module and their functionalities are shown in Table 1.\n", + "\n", + "|Step|Module|Class|Functionality|\n", + "|:---:|:---:|:---:|:---:|\n", + "|Quantum circuit construction|``qobject`` module|``Circuit`` class|Construct quantum circuit (with quantum gates and measurements)|\n", + "|Translation and optimization|``mcalculus`` module|``MCalculus`` class|Translate quantum circuit into MBQC equivalent and optimize it|\n", + "|Simulation |``simulator`` module|``MBQC`` class|Run measurement pattern and obtain the computation results|\n", + "\n", + "
Table 1: Quantum circuit simulation scheme by MBQC proposed in this tutorial
\n", + "\n", + "Next, we will introduce the above three steps in more details and with code implementations." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Quantum circuit construction\n", + "\n", + "In the module ``qobject``, we provide a class `Circuit` to store the information of quantum gates and measurements in the circuit model. We can call the methods in `Circuit` to build our own quantum circuit after instantiation. The syntax to add quantum gates is almost the same as in [UAnsatz](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html) which you might be quite familiar with. Please refer to the tutorial [Quantum Neural Network](https://qml.baidu.com/quick-start/quantum-neural-network.html) for more details. Let's take the circuit in Figure 1 as an example to show the usage of ``Circuit``.\n", + "\n", + "![Circuit example](./figures/mbqc-fig-pat-cir-intro.png)\n", + "
Figure 1: A simple example of quantum circuit
\n", + "\n", + "In the figure $Ry$ stands for a rotation-y gate, the 2-qubits gate is $CNOT$ gate, $|0\\rangle$ is the initial quantum state. The code implementation using ``Circuit`` to construct such a circuit is as follows:" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# Import common modules\n", + "from numpy import pi, random\n", + "from paddle import to_tensor\n", + "\n", + "# Import circuit module\n", + "from paddle_quantum.mbqc.qobject import Circuit\n", + "\n", + "# Initialize ratation angle theta \n", + "theta = random.rand(4) * 2 * pi \n", + " \n", + "# Transform 'Numpy array' to 'Tensor' in Paddle\n", + "theta = to_tensor(theta)\n", + "\n", + "# Instantiate a quantum circuit\n", + "qubit_number = 2\n", + "cir = Circuit(qubit_number)\n", + "\n", + "# Add Ry gate\n", + "cir.ry(theta[0], 0)\n", + "cir.ry(theta[1], 1)\n", + "\n", + "# Add CNOT gate\n", + "cir.cnot([0, 1])\n", + "\n", + "# Add Ry gate\n", + "cir.ry(theta[2], 0)\n", + "cir.ry(theta[3], 1)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Then, we add measurements to the circuit.\n", + "\n", + "**Note**: The way to add measurements in `Circuit` is different from `UAnsatz`! The former is to call `.measure` method before running the circuit, while the latter is to call `.measure` method after running the circuit." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# Input measurement information\n", + "# Measure all qubits by default\n", + "cir.measure()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Then, we need to pass the constructed circuit to the translation module ``mcalculus`` for further process." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Translation and optimization\n", + "\n", + "The basic notions of translation can be referred to [7,8]. Here we just give a brief introduction on translation, optimization, and their code implementations.\n", + "\n", + "We have mentioned the \"EMC\" language of MBQC models in [Introduction to the MBQC framework](MBQC_CN.ipynb). So let's briefly review it here. We refer to the MBQC model translated from a circuit model as the **pattern**, and to the MBQC model translated from a single quantum gate or measurement of an output state as the **subpattern** [7]. The translation process of a quantum circuit is actually the following three steps:`\n", + "\n", + "- one-by-one translation: translate each quantum gate and measurement into a subpattern;\n", + "\n", + "- standardization: integrate all subpatterns into a standard pattern;\n", + "\n", + "- simplification and optimization: simplify and optimize all measurement commands in the standard pattern." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "In terms of code implementation, we provide `MCalculus` class for this task. We can call the method `set_circuit` to pass the constructed circuit ``cir`` to `MCalculus`." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# Import mcalculus module\n", + "from paddle_quantum.mbqc.mcalculus import MCalculus\n", + "\n", + "# Instantiate MCalculus class\n", + "mc = MCalculus()\n", + "\n", + "# Pass the circuit to MCalculus\n", + "mc.set_circuit(cir)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "#### One-by-one translation\n", + "\n", + "We first translate each quantum gate into an MBQC subpattern. As introduced in [MBQC Quick Start Guide](MBQC_EN.ipynb), the standard \"three-step\" process of MBQC is equivalent to the \"EMC\" language. As for the implementation of the $R_y$ gate, we can map every step of the \"three-step\" process to the \"EMC\" commands, as shown in Table 2:\n", + "\n", + "|\"Three-step\" process|\"EMC\" commands|\n", + "|:---|:---|\n", + "|**Graph state preparation**
Prepare the input state on vertex $1$,
and plus states on vertices $2,3,4,5$,
perform CZ operation on adjacent vertices. |**Entanglement commands**
$E_{12}E_{23}E_{34}E_{45}$||\n", + "|**Single-qubit measurement**
Measure vertex $1$ in the $XY$ plane with angle $\\frac{\\pi}{2}$ and record the outcome $s_1$;
Measure vertex $2$ in the $XY$ plane with angle $(-1)^{s_1 + 1}\\alpha$ and record the outcome $s_2$.
Measure vertex $3$ in the $XY$ plane with angle $-\\frac{\\pi}{2} + (s_1+s_2)\\pi$ and record the outcome $s_3$.
Measure vertex $4$ in the $XY$ plane with angle $s_2\\pi$ and record the outcome $s_4$. |**Measurement commands**
$M_1M_2M_3M_4$|\n", + "|**Byproduct correction**
Correct byproducts $X^{s_4}$ and $Z^{s_3}$ on vertex $5$ |**Byproduct correction command**
$X_5Z_5$|\n", + "\n", + "
Table 2: Correspondence between the \"Three-step\" process and the \"EMC\" commands for implementing Ry in MBQC
\n", + "\n", + "We arrange the above commands from left to right and get a command list $[E_{12}E_{23}E_{34}E_{45}M_1M_2M_3M_4X_5Z_5]$. The detailed parameters in the commands are omitted here for simplicity. \n", + "\n", + "Similarly, the command list of $CNOT$ gate can be given by \\[$E_{12}E_{23}E_{24}M_1 M_2 X_4 Z_3 Z_4$\\]. A measurement in the circuit model can be simply given by a command list \\[$M_1$\\] as measurements in the circuit model play the same role as $Z$ measurements on the output qubits in MBQC." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "As for the code implementation, we provide a private method `__to_subpattern` to translate quantum gates and measurements one by one. (This method records all the one-to-one correspondence between gates and subpatterns. You can also customize this function if needed.) Once all the gates and measurements are translated, the information of all the subpatterns is stored in a list named **wild pattern** which will be used for further processes.\n", + "\n", + "![Wild pattern](./figures/mbqc-fig-wild_pat.jpg)\n", + "
Figure 2: Translate quantum gates and measurements one by one to obtain a wild pattern
" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "#### Standardization\n", + "\n", + "Once we have a wild pattern, the next step is to do **standardization**, that is, to reorder commands in the wild pattern such that all entanglement commands move to the left, and all the byproduct correction commands move to the right. The resulting pattern is called a **standard pattern**.\n", + "\n", + "**Note**: The command list reordering is non-trivial and follows a specific set of rules in [7].\n", + "\n", + "![Standard pattern](./figures/mbqc-fig-pat_std.jpg)\n", + "
Figure 3: Transform a wild pattern to a standard pattern
" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "In terms of code implementation, we can directly call the method `standardize` to complete the standarization process. " + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# Standarization\n", + "mc.standardize()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "#### Simplification and optimization\n", + "\n", + "Once a standard pattern is obtained, one option is to directly pass it to the MBQC simulation module and run the simulation. However, a better job can be done before the simulation. Just like the quantum circuit optimization which aims to find a simpler but equivalent representation of the circuit, we can also find a refined pattern based on the standard one. Such refinement can be done in two approaches: removing the measurement dependency as much as possible and reordering the measurement commands. Both approaches aim to reduce the number of effective qubits involved in the actual simulation.\n", + "\n", + "Due to the above two considerations, we use a **signal shifting** operation to simplify the measurement dependencies and use a **row-major order optimization algorithm** to optimize the order of measurement commands." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "**Signal shifting**\n", + "\n", + "The operation of signal shifting aims to simplify dependency by pulling out a particular type of dependency from the measurement command and compensating it with a \"signal\" command [7]. In terms of code implementation, we can directly call the method `shift_signals` to realize this." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# Signal shifting\n", + "mc.shift_signals()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "**Row-major order optimization algorithm**\n", + "\n", + "The row-major order optimization algorithm is a new algorithm we propose. The intention is to measure vertices with row-major order. Once all vertices in a row are measured, we can completely remove this row, thereby reducing the number of effective vertices involved in subsequent operations. Intuitively speaking, this method makes quantum gates and measurements executed by rows in some sense. Numerical experiments show that this optimization technique provides a significant improvement for the simulation of quantum shallow circuits (see below).\n", + "\n", + "In terms of code implementation, we can directly call `optimize_by_row` to implement the row-major optimization algorithm." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# Optimize the measurement order\n", + "mc.optimize_by_row()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "Now, we can call the method `get_pattern` to get the optimized pattern." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# Get the Pattern\n", + "pattern = mc.get_pattern()" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Simulation\n", + "\n", + "Once we have the optimized pattern, we can call the method `set_pattern` in `MBQC` to pass it to the simulation module and call `run_pattern` to start the simulation process." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# Import required modules\n", + "from paddle_quantum.mbqc.simulator import MBQC\n", + "from paddle_quantum.mbqc.qobject import State\n", + "from paddle_quantum.mbqc.utils import zero_state, kron, div_str_to_float\n", + "\n", + "# Instantiate MBQC\n", + "mbqc = MBQC()\n", + "\n", + "# Input the pattern\n", + "mbqc.set_pattern(pattern)\n", + "\n", + "# Input the initial quantum state. Here we choose |0> state to consist with the circuit model\n", + "input_vector = kron([zero_state() for _ in range(qubit_number)])\n", + "input_system = [0,1]\n", + "input_state = State(input_vector, input_system)\n", + "\n", + "mbqc.set_input_state(input_state)\n", + "\n", + "# Run pattern\n", + "mbqc.run_pattern()\n", + "\n", + "# Obtain quantum output\n", + "quantum_output = mbqc.get_quantum_output()\n", + "print(\"The qunatum output state is：\", quantum_output)\n", + "\n", + "# Obtain classcial output\n", + "classical_output = mbqc.get_classical_output()\n", + "print(\"The classical output is：\", classical_output)" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "At this point, we have achieved the entire process of circuit simulation." + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "### Function \"simulate_by_mbqc\"\n", + "\n", + "For convenience, we provide a function `simulate_by_mbqc` to pack the whole process of quantum circuit simulation. We can construct a circuit from ``Circuit`` first and then call `simulate_by_mbqc` to run the simulation process. This function translates the constructed circuit to its MBQC equivalent, runs the simulation, and finally returns the classical outcomes or quantum state vector equivalent to the quantum circuit model. An example is given as follows." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "source": [ + "# Import required modules\n", + "from numpy import random, pi\n", + "from paddle import to_tensor\n", + "\n", + "# Import utils modules\n", + "from paddle_quantum.mbqc.utils import random_state_vector\n", + "# Import Circuit modules\n", + "from paddle_quantum.mbqc.qobject import Circuit\n", + "# Import simulation module\n", + "from paddle_quantum.mbqc.simulator import simulate_by_mbqc\n", + "\n", + "# Set rotation angle theta \n", + "theta = random.rand(4) * 2 * pi \n", + " \n", + "# Transform 'Numpy array' to 'Tensor' in Paddle\n", + "theta = to_tensor(theta)\n", + "\n", + "# Instaniate a quantum circuit\n", + "qubit_number = 2\n", + "cir = Circuit(qubit_number)\n", + "\n", + "# Add Ry gate\n", + "cir.ry(theta[0], 0)\n", + "cir.ry(theta[1], 1)\n", + "\n", + "# Add CNOT gate\n", + "cir.cnot([0, 1])\n", + "\n", + "# Add Ry gate\n", + "cir.ry(theta[2], 0)\n", + "cir.ry(theta[3], 1)\n", + "\n", + "# Input the measurement information\n", + "# Measure all qubits by default\n", + "cir.measure()\n", + "\n", + "# Construct the input state\n", + "input_vector = random_state_vector(qubit_number)\n", + "input_system = list(range(qubit_number))\n", + "input_state = State(input_vector, input_system)\n", + "\n", + "\n", + "# Call the function to simulate quantum circuit by MBQC\n", + "classical_output, quantum_output = simulate_by_mbqc(cir, input_state)\n", + "\n", + "# Print the returned classical and quantum outputs\n", + "print(\"Classical output is：\", classical_output)\n", + "print(\"Quantum output is：\", quantum_output)\n" + ], + "outputs": [], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Examples\n", + "\n", + "Due to the incapability of error correction in near-term quantum computers, parallelism and circuit depth become crucial factors in designing quantum algorithms. We hope to design algorithms with high-performance parallelism and low circuit depth, such that quantum computers can accomplish the algorithm execution as soon as possible, to reduce the influence of decoherence to the result's accuracy. Thereby, quantum algorithms using shallow circuits will play an important role in the near-term. \n", + "\n", + "In the following, we use two classes of quantum shallow circuits to demonstrate the superiority of our simulation scheme.\n", + "\n", + "### Google Random Circuit\n", + "In 2017, Google proposed a series of random quantum circuits (GRCS). Due to the hardness of simulation, GRCS is frequently used as benchmark to test the performance of classical simulators [9].\n", + "\n", + "To demonstrate the efficiency of our simulation scheme, we select part of the shallow circuits (in particular, circuits with CZ gates of **depth 10** ) from the [GRCS library](https://github.com/sboixo/GRCS). The specific circuits selected are as follows:\n", + "\n", + "|Index|File Name|Qubit Number|\\||Index|File Name|Qubit Number|\\||Index|File Name|Qubit Number|\\||Index|File Name|Qubit Number|\\||Index|File Name|Qubit Number|\n", + "| :---: | :---: | :---: | :---:| :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: | :---: |:---: |:---: |:---: |\n", + "|1|inst_5x5_10_0.txt|25|**\\|** | 11|inst_5x6_10_0.txt|30|**\\|**|21|inst_6x6_10_0.txt|36|**\\|**|31|inst_6x7_10_0.txt|42|**\\|**|41|inst_7x7_10_0.txt|49|\n", + "|2|inst_5x5_10_1.txt|25|**\\|**| 12|inst_5x6_10_1.txt|30|**\\|**|22|inst_6x6_10_1.txt|36|**\\|**|32|inst_6x7_10_1.txt|42|**\\|**|42|inst_7x7_10_1.txt|49|\n", + "|3|inst_5x5_10_2.txt|25|**\\|**| 13|inst_5x6_10_2.txt|30|**\\|**|23|inst_6x6_10_2.txt|36|**\\|**|33|inst_6x7_10_2.txt|42|**\\|**|43|inst_7x7_10_2.txt|49|\n", + "|4|inst_5x5_10_3.txt|25|**\\|**| 14|inst_5x6_10_3.txt|30|**\\|**|24|inst_6x6_10_3.txt|36|**\\|**|34|inst_6x7_10_3.txt|42|**\\|**|44|inst_7x7_10_3.txt|49|\n", + "|5|inst_5x5_10_4.txt|25|**\\|**| 15|inst_5x6_10_4.txt|30|**\\|**|25|inst_6x6_10_4.txt|36|**\\|**|35|inst_6x7_10_4.txt|42|**\\|**|45|inst_7x7_10_4.txt|49|\n", + "|6|inst_5x5_10_5.txt|25|**\\|**| 16|inst_5x6_10_5.txt|30|**\\|**|26|inst_6x6_10_5.txt|36|**\\|**|36|inst_6x7_10_5.txt|42|**\\|**|46|inst_7x7_10_5.txt|49|\n", + "|7|inst_5x5_10_6.txt|25|**\\|**| 17|inst_5x6_10_6.txt|30|**\\|**|27|inst_6x6_10_6.txt|36|**\\|**|37|inst_6x7_10_6.txt|42|**\\|**|47|inst_7x7_10_6.txt|49|\n", + "|8|inst_5x5_10_7.txt|25|**\\|**| 18|inst_5x6_10_7.txt|30|**\\|**|28|inst_6x6_10_7.txt|36|**\\|**|38|inst_6x7_10_7.txt|42|**\\|**|48|inst_7x7_10_7.txt|49|\n", + "|9|inst_5x5_10_8.txt|25|**\\|**| 19|inst_5x6_10_8.txt|30|**\\|**|29|inst_6x6_10_8.txt|36|**\\|**|39|inst_6x7_10_8.txt|42|**\\|**|49|inst_7x7_10_8.txt|49|\n", + "|10|inst_5x5_10_9.txt|25|**\\|**| 20|inst_5x6_10_9.txt|30|**\\|**|30|inst_6x6_10_9.txt|36|**\\|**|40|inst_6x7_10_9.txt|42|**\\|**|50|inst_7x7_10_9.txt|49|" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "We compare the running time between our simulation scheme and two other simulators (`statevector` and `matrix_product_state`) in Qiskit. We choose a shorter time from `statevector` and `matrix_product_state` as the running time of the Qiskit simulator. All the numerical experiments are conducted on a standard laptop with 16G RAM and Intel Core i7 10TH GEN CPU. The time comparison is shown in Figure 4. It is clear that our new simulation scheme provides a significant improvement over the Qiskit simulators for simulating shallow circuits.\n", + "\n", + "![GRCS plot](./figures/mbqc-fig-GRCS_plot.jpg)\n", + "
Figure 4: Time comparison between Qiskit and our MBQC simulation scheme for different instances
" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "## Conclusion\n", + "\n", + "MBQC model provides a different technical route to realize universal quantum computation, in parallel with the quantum circuit model. By going from circuits to their MBQC equivalents, this tutorial provides a new scheme to speed up quantum circuit simulation. The improvement of our simulation scheme is evident for shallow circuits. We expect that this new idea will bring further advantages in applications of quantum machine learning and quantum neural networks.\n", + "\n", + "Although we adopt the state vector for underlying simulation in the current MBQC package, the idea of quantum circuit simulation by MBQC is not limited to any data structure. \n", + "\n", + "In terms of quantum circuit simulation and MBQC based algorithms, there are still lots of unknowns to explore. Welcome to join us and discover the infinite possibilities of MBQC together!" + ], + "metadata": {} + }, + { + "cell_type": "markdown", + "source": [ + "---\n", + "## References\n", + "\n", + "[1] Preskill, John. \"Quantum computing and the entanglement frontier.\" [arXiv preprint arXiv:1203.5813 (2012).](https://arxiv.org/abs/1203.5813)\n", + "\n", + "[2] Preskill, John. \"Quantum computing in the NISQ era and beyond.\" [Quantum 2 (2018): 79.](https://quantum-journal.org/papers/q-2018-08-06-79/)\n", + "\n", + "[3] Robert Raussendorf, et al. \"A one-way quantum computer.\" [Physical Review Letters 86.22 (2001): 5188.](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.86.5188)\n", + "\n", + "[4] Raussendorf, Robert, and Hans J. Briegel. \"Computational model underlying the one-way quantum computer.\" [Quantum Information & Computation 2.6 (2002): 443-486.](https://dl.acm.org/doi/abs/10.5555/2011492.2011495)\n", + "\n", + "[5] Robert Raussendorf, et al. \"Measurement-based quantum computation on cluster states.\" [Physical Review A 68.2 (2003): 022312.](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.68.022312)\n", + "\n", + "[6] Briegel, Hans J., et al. \"Measurement-based quantum computation.\" [Nature Physics 5.1 (2009): 19-26.](https://www.nature.com/articles/nphys1157)\n", + "\n", + "[7] Danos, Vincent, et al. \"The measurement calculus.\" [Journal of the ACM (JACM) 54.2 (2007): 8-es.](https://dl.acm.org/doi/abs/10.1145/1219092.1219096)\n", + "\n", + "[8] Broadbent, Anne, and Elham Kashefi. \"Parallelizing quantum circuits.\" [Theoretical computer science 410.26 (2009): 2489-2510.](https://arxiv.org/abs/0704.1736)\n", + "\n", + "[9] Boixo, Sergio, et al. \"Characterizing quantum supremacy in near-term devices.\" [Nature Physics 14.6 (2018): 595-600.](https://www.nature.com/articles/s41567-018-0124-x)" + ], + "metadata": {} + } + ], + "metadata": { + "interpreter": { + "hash": "73e152e9b81fe728e387c249fa9090f02d423820fe8ab6018c11ce80df71d553" + }, + "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.11" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": false, + "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 + }, + "toc-autonumbering": false, + "toc-showcode": false, + "toc-showmarkdowntxt": false, + "toc-showtags": false, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/tutorial/mbqc/QAOA_CN.ipynb b/tutorials/mbqc/QAOA_CN.ipynb similarity index 100% rename from tutorial/mbqc/QAOA_CN.ipynb rename to tutorials/mbqc/QAOA_CN.ipynb diff --git a/tutorial/mbqc/QAOA_EN.ipynb b/tutorials/mbqc/QAOA_EN.ipynb similarity index 100% rename from tutorial/mbqc/QAOA_EN.ipynb rename to tutorials/mbqc/QAOA_EN.ipynb diff --git a/tutorial/mbqc/figures/mbqc-fig-GRCS_plot.jpg b/tutorials/mbqc/figures/mbqc-fig-GRCS_plot.jpg similarity index 100% rename from tutorial/mbqc/figures/mbqc-fig-GRCS_plot.jpg rename to tutorials/mbqc/figures/mbqc-fig-GRCS_plot.jpg diff --git a/tutorial/mbqc/figures/mbqc-fig-cnot_pattern.jpg b/tutorials/mbqc/figures/mbqc-fig-cnot_pattern.jpg similarity index 100% rename from tutorial/mbqc/figures/mbqc-fig-cnot_pattern.jpg rename to tutorials/mbqc/figures/mbqc-fig-cnot_pattern.jpg diff --git a/tutorial/mbqc/figures/mbqc-fig-general_pattern.jpg b/tutorials/mbqc/figures/mbqc-fig-general_pattern.jpg similarity index 100% rename from tutorial/mbqc/figures/mbqc-fig-general_pattern.jpg rename to tutorials/mbqc/figures/mbqc-fig-general_pattern.jpg diff --git a/tutorial/mbqc/figures/mbqc-fig-graph_states.jpg b/tutorials/mbqc/figures/mbqc-fig-graph_states.jpg similarity index 100% rename from tutorial/mbqc/figures/mbqc-fig-graph_states.jpg rename to tutorials/mbqc/figures/mbqc-fig-graph_states.jpg diff --git a/tutorials/mbqc/figures/mbqc-fig-pat-cir-intro.png b/tutorials/mbqc/figures/mbqc-fig-pat-cir-intro.png new file mode 100644 index 0000000..79faad4 Binary files /dev/null and b/tutorials/mbqc/figures/mbqc-fig-pat-cir-intro.png differ diff --git a/tutorials/mbqc/figures/mbqc-fig-pat_std.jpg b/tutorials/mbqc/figures/mbqc-fig-pat_std.jpg new file mode 100644 index 0000000..23d3343 Binary files /dev/null and b/tutorials/mbqc/figures/mbqc-fig-pat_std.jpg differ diff --git a/tutorial/mbqc/figures/mbqc-fig-qaoa_graph_1.jpg b/tutorials/mbqc/figures/mbqc-fig-qaoa_graph_1.jpg similarity index 100% rename from tutorial/mbqc/figures/mbqc-fig-qaoa_graph_1.jpg rename to tutorials/mbqc/figures/mbqc-fig-qaoa_graph_1.jpg diff --git a/tutorial/mbqc/figures/mbqc-fig-qaoa_graph_p.jpg b/tutorials/mbqc/figures/mbqc-fig-qaoa_graph_p.jpg similarity index 100% rename from tutorial/mbqc/figures/mbqc-fig-qaoa_graph_p.jpg rename to tutorials/mbqc/figures/mbqc-fig-qaoa_graph_p.jpg diff --git a/tutorial/mbqc/figures/mbqc-fig-single_qubit_pattern_CN.jpg b/tutorials/mbqc/figures/mbqc-fig-single_qubit_pattern_CN.jpg similarity index 100% rename from tutorial/mbqc/figures/mbqc-fig-single_qubit_pattern_CN.jpg rename to tutorials/mbqc/figures/mbqc-fig-single_qubit_pattern_CN.jpg diff --git a/tutorial/mbqc/figures/mbqc-fig-single_qubit_pattern_EN.jpg b/tutorials/mbqc/figures/mbqc-fig-single_qubit_pattern_EN.jpg similarity index 100% rename from tutorial/mbqc/figures/mbqc-fig-single_qubit_pattern_EN.jpg rename to tutorials/mbqc/figures/mbqc-fig-single_qubit_pattern_EN.jpg diff --git a/tutorials/mbqc/figures/mbqc-fig-wild_pat.jpg b/tutorials/mbqc/figures/mbqc-fig-wild_pat.jpg new file mode 100644 index 0000000..13cf6a5 Binary files /dev/null and b/tutorials/mbqc/figures/mbqc-fig-wild_pat.jpg differ diff --git a/tutorials/qnn_research/BarrenPlateaus_CN.ipynb b/tutorials/qnn_research/BarrenPlateaus_CN.ipynb new file mode 100644 index 0000000..d20d572 --- /dev/null +++ b/tutorials/qnn_research/BarrenPlateaus_CN.ipynb @@ -0,0 +1,1344 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 量子神经网络的贫瘠高原效应\n", + "\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 概览\n", + "\n", + "在经典神经网络的训练中，基于梯度的优化方法不仅仅会遇到局部最小值的问题，同时还要面对鞍点等附近梯度近似于零的几何结构。相对应的，在量子神经网络中也存在着一种**贫瘠高原效应**（barren plateaus）。这个奇特的现象首先是由 McClean et al. 在 2018 年发现 [[1]](https://arxiv.org/abs/1803.11173)。简单来说，就是当你选取的随机电路结构满足一定复杂程度时优化曲面（optimization landscape）会变得很平坦，从而导致基于梯度下降的优化方法很难找到全局最小值。对于大多数的变分量子算法（VQE等），这个现象意味着当量子比特数量越来越多时，选取随机结构的电路有可能效果并不好。这会让你设计的损失函数所对应的优化曲面变成一个巨大的高原，让从而导致量子神经网络的训练愈加困难。你随机找到的初始值很难逃离这个高原，梯度下降收敛速度会很缓慢。\n", + "\n", + "![BP-fig-barren](./figures/BP-fig-barren-cn.png)\n", + "\n", + "图片由 [Gradient Descent Viz](https://github.com/lilipads/gradient_descent_viz) 生成\n", + "\n", + "\n", + "基于梯度变化对这类变分量子算法训练的影响，我们在量桨（Paddle Quantum）平台提供了梯度分析工具模块，辅助用户对 QML 模型进行诊断，便于贫瘠高原等问题的研究。\n", + "\n", + "本教程主要讨论如何在量桨（Paddle Quantum）平台上展示贫瘠高原现象，以及如何使用梯度分析工具对用户自定义量子神经网络中的参数梯度进行分析。其中并不涉及任何算法创新，但能提升读者对于量子神经网络训练中梯度问题的认识。\n", + "\n", + "首先我们先引入必要的 library 和 package：\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T12:20:39.463025Z", + "start_time": "2021-03-02T12:20:36.336398Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\openfermion\\hamiltonians\\hartree_fock.py:11: DeprecationWarning: Please use `OptimizeResult` from the `scipy.optimize` namespace, the `scipy.optimize.optimize` namespace is deprecated.\n", + " from scipy.optimize.optimize import OptimizeResult\n" + ] + } + ], + "source": [ + "# 忽略 waring 输出\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# 需要用的包\n", + "import time\n", + "import numpy as np\n", + "from math import pi\n", + "import paddle\n", + "from paddle_quantum.state import zero_state\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.linalg import dagger\n", + "# 画图工具\n", + "from matplotlib import pyplot as plt \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 随机的网络结构\n", + "\n", + "这里我们按照原作者 McClean (2018) [[1]](https://arxiv.org/abs/1803.11173) 论文中提及的类似方法搭建如下随机电路：\n", + "\n", + "![BP-fig-Barren_circuit](./figures/BP-fig-Barren_circuit.png)\n", + "\n", + "首先作用在所有量子比特上绕布洛赫球的 Y-轴旋转 $\\pi/4$。\n", + "\n", + "其余的结构加起来构成一个模块（Block）, 每个模块共分为两层：\n", + "\n", + "- 第一层搭建随机的旋转门, 其中 $R_{\\ell,n} \\in \\{R_x, R_y, R_z\\}$。下标 $\\ell$ 表示处于第 $\\ell$ 个重复的模块， 上图中 $\\ell =1$。第二个下标 $n$ 表示作用在第几个量子比特上。\n", + "- 第二层由 CZ 门组成，作用在每两个相邻的量子比特上。\n", + "\n", + "在量桨中, 我们可以这么搭建。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T12:20:39.972053Z", + "start_time": "2021-03-02T12:20:39.962259Z" + } + }, + "outputs": [], + "source": [ + "def rand_circuit(theta, target, num_qubits):\n", + " # 初始化量子电路\n", + " cir = Circuit(num_qubits)\n", + " \n", + " # 固定角度的 Ry 旋转门\n", + " cir.ry(param=pi / 4)\n", + "\n", + " # ============== 第一层 ==============\n", + " # target是一个随机的数组,用来帮助我们抽取随机的单比特门 \n", + " for i in range(num_qubits):\n", + " if target[i] == 0:\n", + " cir.rz(i, param=theta[i])\n", + " elif target[i] == 1:\n", + " cir.ry(i, param=theta[i])\n", + " else:\n", + " cir.rx(i, param=theta[i])\n", + " \n", + " # ============== 第二层 ==============\n", + " # 搭建两两相邻的 CZ 门\n", + " for i in range(num_qubits - 1):\n", + " cir.cz([i, i + 1])\n", + " \n", + " return cir" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 损失函数与优化曲面 \n", + "\n", + "当我们确定了电路的结构之后，我们还需要定义一个损失函数（loss function）来确定优化曲面。按照原作者 McClean (2018) [[1]](https://arxiv.org/abs/1803.11173) 论文中提及的，我们采用 VQE算法中常用的损失函数：\n", + "\n", + "$$\n", + "\\mathcal{L}(\\boldsymbol{\\theta})= \\langle0| U^{\\dagger}(\\boldsymbol{\\theta})H U(\\boldsymbol{\\theta}) |0\\rangle,\n", + "\\tag{1}\n", + "$$\n", + "\n", + "其中的酉矩阵 $U(\\boldsymbol{\\theta})$ 就是我们上一部分搭建的带有随机结构的量子神经网络。对于其中的哈密顿量 $H$ 我们不妨先取最简单的形式 $H = |00\\cdots 0\\rangle\\langle00\\cdots 0|$。设定好这些后，我们就可以从最简单的两个量子比特的情形开始采样了 -- 生成300组随机网络结构和不同的随机初始参数 $\\{\\theta_{\\ell,n}^{(i)}\\}_{i=1}^{300}$。每次计算梯度都是按照 VQE 的解析梯度公式计算关于 **第一个参数 $\\theta_{1,1}$** 的偏导数。然后统计得到的这300个梯度的平均值和方差。其中解析梯度的公式为：\n", + "\n", + "$$\n", + "\\partial \\theta_{j} \n", + "\\equiv \\frac{\\partial \\mathcal{L}}{\\partial \\theta_j}\n", + "= \\frac{1}{2} \\big[\\mathcal{L}(\\theta_j + \\frac{\\pi}{2}) - \\mathcal{L}(\\theta_j - \\frac{\\pi}{2})\\big].\n", + "\\tag{2}\n", + "$$\n", + "\n", + "具体推导请参见：[arXiv:1803.00745](https://arxiv.org/abs/1803.00745)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T12:20:52.236108Z", + "start_time": "2021-03-02T12:20:40.850822Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\fluid\\framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " elif dtype == np.bool:\n", + "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " if data.dtype == np.object:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "主程序段总共运行了 2.7961888313293457 秒\n", + "采样 300 个随机网络关于第一个参数梯度的均值是： -0.025778826\n", + "采样 300 个随机网络关于第一个参数梯度的方差是： 0.11283756\n" + ] + } + ], + "source": [ + "# 超参数设置\n", + "# np.random.seed(42) # 固定 Numpy 的随机种子\n", + "N = 2 # 设置量子比特数量 \n", + "samples = 300 # 设定采样随机网络结构的数量\n", + "THETA_SIZE = N # 设置参数 theta 的大小\n", + "ITR = 1 # 设置迭代次数\n", + "LR = 0.2 # 设定学习速率\n", + "SEED = 1 # 固定优化器中随机初始化的种子\n", + "\n", + "# 初始化梯度数值的寄存器\n", + "grad_info = []\n", + "\n", + "# paddle.seed(SEED)\n", + "\n", + "class manual_gradient(paddle.nn.Layer):\n", + " \n", + " # 初始化一个可学习参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", + " def __init__(self, shape, param_attr=paddle.nn.initializer.Uniform(low=0.0, high=2 * pi), dtype='float32'):\n", + " super(manual_gradient, self).__init__()\n", + " \n", + " # 将 Numpy array 转换成 Paddle 中的 Tensor\n", + " self.H = zero_state(N).data\n", + " \n", + " # 定义损失函数和前向传播机制 \n", + " def forward(self):\n", + " \n", + " # 初始化三个 theta 参数列表\n", + " theta_np = np.random.uniform(low=0., high= 2 * pi, size=(THETA_SIZE))\n", + " theta_plus_np = np.copy(theta_np) \n", + " theta_minus_np = np.copy(theta_np) \n", + " \n", + " # 修改用以计算解析梯度\n", + " theta_plus_np[0] += pi/2\n", + " theta_minus_np[0] -= pi/2\n", + " \n", + " # 将 Numpy array 转换成 Paddle 中的 Tensor\n", + " theta_plus = paddle.to_tensor(theta_plus_np)\n", + " theta_minus = paddle.to_tensor(theta_minus_np)\n", + " \n", + " # 生成随机目标，在 rand_circuit 中随机选取电路门\n", + " target = np.random.choice(3, N) \n", + " \n", + " U_plus = rand_circuit(theta_plus, target, N).unitary_matrix()\n", + " U_minus = rand_circuit(theta_minus, target, N).unitary_matrix()\n", + "\n", + " # 计算解析梯度\n", + " grad = paddle.real((dagger(U_plus) @ self.H @ U_plus)[0][0] - (dagger(U_minus) @ self.H @ U_minus)[0][0])/2 \n", + " \n", + " return grad\n", + "\n", + "# 定义主程序段\n", + "def main():\n", + " \n", + " # 设置QNN的维度\n", + " sampling = manual_gradient(shape=[THETA_SIZE])\n", + "\n", + " # 采样获得梯度信息\n", + " grad = sampling().numpy() \n", + " \n", + " return grad\n", + "\n", + "\n", + "# 记录运行时间\n", + "time_start = time.time()\n", + "\n", + "# 开始采样\n", + "for i in range(samples):\n", + " if __name__ == '__main__':\n", + " grad = main()\n", + " grad_info.append(grad)\n", + "\n", + "time_span = time.time() - time_start \n", + "print('主程序段总共运行了', time_span, '秒')\n", + "print(\"采样\", samples, \"个随机网络关于第一个参数梯度的均值是：\", np.mean(grad_info))\n", + "print(\"采样\", samples, \"个随机网络关于第一个参数梯度的方差是：\", np.var(grad_info))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 优化曲面的可视化\n", + "\n", + "接下来我们试着利用 Matplotlib来可视化这个优化曲面（optimization landscape）。在**两个量子比特**的情况下，我们只有两个参数 $\\theta_1$ 和 $\\theta_2$, 并且第二层的随机电路电路总共有9种情况。这个很容易画出来：\n", + "\n", + "![BP-fig-landscape2](./figures/BP-fig-landscape2.png)\n", + "\n", + "可以看到的是最后一张图中 $R_z$-$R_z$ 结构所展示出的平原结构是我们非常不想见到的。在这种情况下，我们不能收敛到理论最小值。如果你想自己试着画一些优化曲面，不妨参见以下代码：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T12:21:49.972769Z", + "start_time": "2021-03-02T12:21:45.792119Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "主程序段总共运行了 1.4345674514770508 秒\n" + ] + } + ], + "source": [ + "time_start = time.time()\n", + "N = 2\n", + "\n", + "# 设置图像比例 竖：横 = 0.3 \n", + "fig = plt.figure(figsize=plt.figaspect(0.3))\n", + "\n", + "# 生成 x, y 轴上的点\n", + "X = np.linspace(0, 2 * pi, 80)\n", + "Y = np.linspace(0, 2 * pi, 80)\n", + "\n", + "# 生成 2D 网格 (mesh)\n", + "xx, yy = np.meshgrid(X, Y)\n", + "\n", + "\n", + "# 定义必要的逻辑门\n", + "def rx(theta):\n", + " mat = np.array([[np.cos(theta/2), -1j * np.sin(theta/2)],\n", + " [-1j * np.sin(theta/2), np.cos(theta/2)]])\n", + " return mat\n", + "\n", + "def ry(theta):\n", + " mat = np.array([[np.cos(theta/2), -1 * np.sin(theta/2)],\n", + " [np.sin(theta/2), np.cos(theta/2)]])\n", + " return mat\n", + "\n", + "def rz(theta):\n", + " mat = np.array([[np.exp(-1j * theta/2), 0],\n", + " [0, np.exp(1j * theta/2)]])\n", + " return mat\n", + "\n", + "def CZ():\n", + " mat = np.array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, -1]])\n", + " return mat\n", + "\n", + "# ============= 第一张图 =============\n", + "# 我们可视化第二层是 kron(Ry, Ry) 的情况\n", + "ax = fig.add_subplot(1, 2, 1, projection='3d')\n", + "\n", + "# 向前传播计算损失函数：\n", + "def cost_yy(para):\n", + " L1 = np.kron(ry(pi/4), ry(pi/4))\n", + " L2 = np.kron(ry(para[0]), ry(para[1]))\n", + " U = np.matmul(np.matmul(L1, L2), CZ())\n", + " H = np.zeros((2 ** N, 2 ** N))\n", + " H[0, 0] = 1\n", + " val = (U.conj().T @ H @ U).real[0][0]\n", + " return val\n", + "\n", + "# 画出图像\n", + "Z = np.array([[cost_yy([x, y]) for x in X] for y in Y]).reshape(len(Y), len(X))\n", + "surf = ax.plot_surface(xx, yy, Z, cmap='plasma')\n", + "ax.set_xlabel(r\"$\\theta_1$\")\n", + "ax.set_ylabel(r\"$\\theta_2$\")\n", + "ax.set_title(\"Optimization Landscape for Ry-Ry Layer\")\n", + "\n", + "# ============= 第二张图 =============\n", + "# 我们可视化第二层是 kron(Rx, Rz) 的情况\n", + "ax = fig.add_subplot(1, 2, 2, projection='3d')\n", + "\n", + "\n", + "def cost_xz(para):\n", + " L1 = np.kron(ry(pi/4), ry(pi/4))\n", + " L2 = np.kron(rx(para[0]), rz(para[1]))\n", + " U = np.matmul(np.matmul(L1, L2), CZ())\n", + " H = np.zeros((2 ** N, 2 ** N))\n", + " H[0, 0] = 1\n", + " val = (U.conj().T @ H @ U).real[0][0]\n", + " return val\n", + "\n", + "Z = np.array([[cost_xz([x, y]) for x in X] for y in Y]).reshape(len(Y), len(X))\n", + "surf = ax.plot_surface(xx, yy, Z, cmap='viridis')\n", + "ax.set_xlabel(r\"$\\theta_1$\")\n", + "ax.set_ylabel(r\"$\\theta_2$\")\n", + "ax.set_title(\"Optimization Landscape for Rx-Rz Layer\")\n", + "\n", + "\n", + "plt.show()\n", + "\n", + "time_span = time.time() - time_start \n", + "print('主程序段总共运行了', time_span, '秒')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 梯度分析工具\n", + "\n", + "基于梯度在贫瘠高原等现象中的表现出的重要作用，我们在量桨平台开发了一个简单的梯度分析工具，辅助用户查看电路中各参数的梯度情况，方便对量子神经网络做后续研究。\n", + "\n", + "需要注意的是，我们使用梯度分析工具时仅需用户**单独定义传入的电路和损失函数，不需要用户自己写网络训练**，减少使用负担" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 应用 一：无监督学习\n", + "\n", + "对于该类情况，主要关注类似变分量子本征求解器（VQE）的变分量子算法。该类变分算法要优化的目标函数通常是量子电路关于哈密顿量 $H$ 的期望值，即 $O(\\theta) = \\left\\langle0\\dots 0\\right\\lvert U^{\\dagger}(\\theta)HU(\\theta) \\left\\lvert0\\dots 0\\right\\rangle$，这里的 $U(\\theta)$ 表示的就是参数化量子电路，其中 $\\theta = [\\theta_1, \\theta_2, \\dots, \\theta_n]$ 是电路中的可训练参数，$H$ 是哈密顿量。 \n", + "\n", + "这里我们就以 VQE 做代表，演示该梯度分析工具的用法。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Paddle Quantum 实现\n", + "\n", + "首先导入该问题需要的包：" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# 需要用的包\n", + "from paddle_quantum.qinfo import pauli_str_to_matrix, random_pauli_str_generator\n", + "from paddle_quantum.hamiltonian import Hamiltonian\n", + "# 导入梯度工具包\n", + "from paddle_quantum.gradtool import random_sample, show_gradient, plot_loss_grad, show_gradient" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 定义量子电路\n", + "\n", + "接着，构造目标函数 $O(\\theta) = \\left\\langle00\\right\\lvert U^{\\dagger}(\\theta)HU(\\theta) \\left\\lvert00\\right\\rangle$ 中的参数化量子电路 $U(\\theta)$。这里我们还是采用上文中定义的随机电路。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 定义目标函数\n", + "\n", + "之后给出要优化的目标函数（这里需要注意的是，在梯度分析模块中我们是以 ``loss_func(circuit, *args)`` 的形式调用函数计算目标函数值的。这也就是说，第二个参数是可变参数，用户可以根据需要灵活的构造自己模型的目标函数形式）：" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# 要优化的目标函数，其中参数分别是电路和哈密顿量\n", + "def loss_func(circuit: Circuit, H: Hamiltonian) -> paddle.Tensor:\n", + " return circuit().expec_val(H, shots = 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "接着设置一些应用所需的参数" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# 超参数设置\n", + "# np.random.seed(1) # 固定 Numpy 的随机种子\n", + "N = 2 # 设置量子比特数量 \n", + "samples = 300 # 设定采样随机网络结构的数量\n", + "THETA_SIZE = N # 设置参数 theta 的大小 \n", + "ITR = 120 # 设置迭代次数\n", + "LR = 0.1 # 设定学习速率\n", + "SEED = 2 # 固定优化器中随机初始化的种子" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "随机生成参数化量子电路，以及哈密顿量信息列表。" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--Ry(0.785)----Rx(0.557)----*--\n", + " | \n", + "--Ry(0.785)----Rz(1.090)----z--\n", + " \n", + "Hamiltonian info: -0.5460435438880067 X0\n", + "-0.06715081059031625 Z1, Z0\n", + "-0.7710366768893184 Z1, X0\n", + "-0.7873104687630661 Z1, Y0\n", + "0.9563406325371104 Y0\n", + "0.8230280338420977 Y1\n", + "-0.7909293184638813 Y0, Y1\n" + ] + } + ], + "source": [ + "# paddle.seed(SEED)\n", + "target = np.random.choice(3, N)\n", + "# 在 0 - 2*Pi 间随机生成各参数值\n", + "theta = paddle.rand([THETA_SIZE]).astype('float32') * 2 * pi\n", + "theta.stop_gradient = False\n", + "cir = rand_circuit(theta, target, N)\n", + "print(cir)\n", + "# 随机生成哈密顿量\n", + "H_l = Hamiltonian(random_pauli_str_generator(N, terms=7))\n", + "print('Hamiltonian info: ', H_l)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "``cir`` 和 ``H_l`` 就是要优化的目标函数 ``loss_func`` 所需的参数。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "用户可以通过我们提供的梯度分析工具，查看电路中各参数梯度采样的结果。同时，可以根据需求在 ``single``, ``max``, 以及 ``random`` 三种模式间选择，其中 ``single`` 会返回电路多次采样后每个参数的平均值和方差， ``max`` 模式返回每轮采样中所有参数梯度最大值的均值和方差，``random`` 则是在每轮采样得到的各参数梯度中随机选择一个后计算均值和方差。\n", + "\n", + "我们首先对该电路采样 300 次，这里我们选择 ``single`` 模式，看看电路中每个可变参数梯度的平均值和方差，同时默认 ``param=0`` 表示我们查看第一个参数的梯度分布情况。" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: 100%|###################################################| 300/300 [00:03<00:00, 83.25it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of gradient for all parameters: \n", + "theta 1 : 0.010323498\n", + "theta 2 : -0.023893388\n", + "Variance of gradient for all parameters: \n", + "theta 1 : 0.04497918\n", + "theta 2 : 0.1173012\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "grad_mean_list, grad_variance_list = random_sample(cir, loss_func, samples, H_l, mode='single', param=0) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "用户如果想要查看该量子电路在训练过程中梯度和损失值的变化情况，还可以使用 ``plot_loss_grad`` 函数，辅助查看电路的训练效果。" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 0%| | 0/120 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_loss_grad(cir, loss_func, ITR, LR, H_l)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "如上图所示，可以看出 iteration 在几十次后损失函数的值就基本不发生变化了，而梯度也非常的接近 0。为了更直观的看到训练得到的最优解和理论值的差距，我们计算哈密顿量 ``H_l`` 的特征值。" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 100%|###################################################| 120/120 [00:01<00:00, 93.13it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "最终的优化结果： -1.431776\n", + "实际的基态能量： -2.935288\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "loss, grad = show_gradient(cir, loss_func, ITR, LR, H_l)\n", + "H_matrix = H_l.construct_h_matrix()\n", + "\n", + "print(\"最终的优化结果： \", loss[-1])\n", + "print(\"实际的基态能量：\", np.linalg.eigh(H_matrix)[0][0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "通过对比可以看出，该电路训练得到的最优解和我们要得到的实际值之间还存在一定的差距。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 更多的量子比特\n", + "\n", + "由于在贫瘠高原效应中，梯度会随着量子比特数的增加呈指数级消失。所以我们可以进一步对比增加电路中量子比特的数量，看看会对我们的梯度带来什么影响 (这里我们采样时选择 ``max`` 模式，对参数列表中的最大值做计算)。" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: 100%|###################################################| 300/300 [00:03<00:00, 89.26it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of max gradient\n", + "0.7397743\n", + "Variance of max gradient\n", + "0.16580562\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: 0%| | 0/300 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: 0%| | 0/300 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: 0%| | 0/300 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 超参数设置\n", + "selected_qubit = [2, 4, 6, 8]\n", + "means, variances = [], []\n", + "\n", + "# 不断增加量子比特数量\n", + "for N in selected_qubit:\n", + " grad_info = []\n", + " THETA_SIZE = N \n", + " target = np.random.choice(3, N)\n", + " # 在 0 - 2*Pi 间随机生成各参数值\n", + " theta = paddle.rand([THETA_SIZE]).astype('float32') * 2 * pi\n", + " theta.stop_gradient = False\n", + " cir = rand_circuit(theta, target, N)\n", + " \n", + " H_l = Hamiltonian(random_pauli_str_generator(N, terms=10))\n", + " \n", + " grad_mean_list, grad_variance_list = random_sample(cir, loss_func, samples, H_l, mode='max') \n", + " # 记录采样信息\n", + " means.append(grad_mean_list)\n", + " variances.append(grad_variance_list)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "接着对采样不同量子比特数量电路得到的各参数最大梯度的平均值和方差作图，方便比较。" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "我们接着画出这个采样出来的梯度的统计结果：\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "means = np.array(means)\n", + "variances = np.array(variances)\n", + "\n", + "n = np.array(selected_qubit)\n", + "print(\"我们接着画出这个采样出来的梯度的统计结果：\")\n", + "fig = plt.figure(figsize=plt.figaspect(0.3))\n", + "\n", + "# ============= 第一张图 =============\n", + "# 统计出随机采样的梯度平均值和量子比特数量的关系\n", + "plt.subplot(1, 2, 1)\n", + "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 gradient\".format(samples))\n", + "plt.xlim([1,9])\n", + "plt.grid()\n", + "\n", + "# ============= 第二张图 =============\n", + "# 统计出随机采样的梯度的方差和量子比特数量的关系\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(n, np.log(variances), \"v-\")\n", + "plt.xlabel(r\"Qubit #\")\n", + "plt.ylabel(r\"$ \\partial \\theta_{i} \\langle 0|H |0\\rangle$ Variance\")\n", + "plt.title(\"Variance of {} sampled gradient\".format(samples))\n", + "plt.xlim([1,9])\n", + "plt.grid()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "可以看出，随着量子比特数量的增加，多次采样获得所有参数梯度的最大值不断接近于 0，且方差也是呈下降趋势。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "为了进一步看看梯度随量子比特数量增加发生的变化，我们不妨可视化一下不同量子比特数量对的优化曲面的影响：\n", + "\n", + "![BP-fig-qubit_landscape_compare](./figures/BP-fig-qubit_landscape_compare.png \"(a)不固定 z 轴尺度时，采样出的优化曲面分别从左至右对应2、4和6量子比特的情形。（b）同样的优化曲面但是固定 z 轴尺度作为对比。\")\n", + " \n", + "\n", + "画图时 $\\theta_1$ 和 $\\theta_2$ 是前两个电路参数, 剩余参数全部固定为 $\\pi$。不然我们画不出这个高维度的流形。\n", + "结果不出所料，陡峭程度随着 $n$ 的增大越来越小了，**注意到 Z 轴尺度的极速减小**。相对于 2 量子比特的情况，6 量子比特的优化曲面已经非常扁平了。\n", + "\n", + "在理论上，只有当我们选取的网络结构还有损失函数满足一定条件时 (2-design)[[1]](https://arxiv.org/abs/1803.11173), 才会出现这种梯度随量子比特数增加而急剧消失的现象。\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 应用 二：基于经典数据量子编码的监督学习\n", + "\n", + "监督学习是量子神经网络的重要应用之一，然而贫瘠高原现象同样制约着量子变分算法在此类问题上的表现。因此，如何设计更有效的电路和损失函数来避免贫瘠高原现象的出现，是当前量子神经网络的重要研究方向之一。实际上，已有学者证明，在生成模型 (generative model) 的训练之中使用瑞丽熵 (Renyi divergence) 作为损失函数，可以有效避免贫瘠高原现象 [[3]](https://arxiv.org/abs/2106.09567)。 基于量桨的梯度分析模块，我们可以快速分析一个监督学习模型中梯度的相关信息，从而便于研究者尝试探索不同的量子电路和损失函数。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "这里，我们利用量桨的[量子态编码经典数据](./tutorial/machine_learning/DataEncoding_CN.ipynb)提供的数据集为例进行介绍。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Paddle Quantum 实现\n", + "\n", + "首先，导入需要的包" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from paddle_quantum.dataset import Iris\n", + "from paddle_quantum.gradtool import random_sample_supervised, plot_supervised_loss_grad" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 定义参数化量子电路\n", + "\n", + "接着，构建参数化量子电路 $U(\\theta)$ " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def U_theta(n: int, depth: int):\n", + " # 初始化网络\n", + " cir = Circuit(n)\n", + "\n", + " # 先搭建广义的旋转层\n", + " cir.rz()\n", + " cir.ry()\n", + " cir.rz()\n", + "\n", + " # 默认深度为 depth = 1\n", + " # 搭建纠缠层和 Ry旋转层\n", + " for _ in range(3, depth + 3):\n", + " cir.cnot()\n", + " cir.ry()\n", + " \n", + " return cir" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 定义目标函数\n", + "\n", + "这里定义要优化的目标函数，第二个参数仍然是可变参数 ``*args``。" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def loss_func(cir: Circuit, *args):\n", + " #传入量子态和训练标签\n", + " state_in = args[0]\n", + " label = args[1]\n", + " # 将 Numpy array 转换成 tensor\n", + " label_pp = paddle.to_tensor(label).reshape([-1, 1])\n", + " \n", + " Utheta = cir.unitary_matrix()\n", + " \n", + " # 因为 Utheta是学习到的，我们这里用行向量运算来提速而不会影响训练效果\n", + " state_out = state_in @ Utheta\n", + " \n", + " # 测量得到泡利 Z 算符的期望值 \n", + " Ob = paddle.to_tensor(pauli_str_to_matrix([[1.0, 'z0']], qubit_num))\n", + " E_Z = state_out @ Ob @ paddle.transpose(paddle.conj(state_out), perm=[0, 2, 1])\n", + "\n", + " # 映射 处理成标签的估计值\n", + " state_predict = paddle.real(E_Z)[:, 0] * 0.5 + 0.5\n", + " loss = paddle.mean((state_predict - label_pp) ** 2) #均方误差\n", + " \n", + " return loss\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### 定义数据集\n", + "\n", + "接着导入量子编码后的 Iris 数据集。" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--Rz(0.812)----Ry(1.897)----Rz(4.609)----*----x----Ry(1.629)--\n", + " | | \n", + "--Rz(0.351)----Ry(2.939)----Rz(5.847)----x----*----Ry(0.576)--\n", + " \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\fluid\\framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " elif dtype == np.bool:\n" + ] + } + ], + "source": [ + "time_start = time.time()\n", + "\n", + "#超参数设置,这里不需要太多qubit，不然严重过拟合\n", + "test_rate = 0.2\n", + "qubit_num = 2\n", + "depth = 1\n", + "lr = 0.1\n", + "BATCH = 4\n", + "EPOCH = 4\n", + "SAMPLE = 300\n", + "# 验证数据集\n", + "iris = Iris(encoding='amplitude_encoding', num_qubits=qubit_num, test_rate=test_rate, classes=[0,1], return_state=True)\n", + "\n", + "# 获取数据集的输入和标签\n", + "train_x, train_y = iris.train_x, iris.train_y #这里的 train_x, train_y，test_x, test_y 都是 paddle.tensor\n", + "test_x, test_y = iris.test_x, iris.test_y\n", + "testing_data_num = len(test_y)\n", + "training_data_num = len(train_y)\n", + "\n", + "\n", + "# 为量子电路创建可训练的参数\n", + "# 创建电路\n", + "circuit = U_theta(qubit_num, depth)\n", + "\n", + "print(circuit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们先看看在 EPOCH=4，BATCH=4 的情况下，训练过程中的损失函数值及梯度的变化情况" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " if data.dtype == np.object:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "loss,grad = plot_supervised_loss_grad(circuit, loss_func, N=qubit_num, EPOCH = EPOCH, LR = lr,BATCH = BATCH, TRAIN_X=train_x, TRAIN_Y=train_y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们可以看到在几十个 iteration 之后，损失函数的值只在一个较小的范围内波动，说明训练过程已经达到了稳定。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "接着我们再对该模型的初始参数进行随机采样 300 次，这里我们首先选择 ``max`` 模式，看看 300 次采样中每次采样中最大梯度的平均值和方差" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: 100%|###################################################| 300/300 [00:03<00:00, 76.54it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of max gradient\n", + "0.15144292\n", + "Variance of max gradient\n", + "0.0035474023\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mean, variance = random_sample_supervised(circuit,loss_func, N=qubit_num, sample_num=SAMPLE, BATCH=BATCH, TRAIN_X=train_x, TRAIN_Y=train_y, mode='max')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 总结\n", + "\n", + "可训练性问题是目前量子神经网络的研究的一个核心方向，量桨提供的梯度分析工具支持用户对模型进行可训练性的诊断，便于贫瘠高原等问题的研究。\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## 参考文献\n", + "\n", + "[1] McClean, J. R., Boixo, S., Smelyanskiy, V. N., Babbush, R. & Neven, H. Barren plateaus in quantum neural network training landscapes. [Nat. Commun. 9, 4812 (2018).](https://www.nature.com/articles/s41467-018-07090-4)\n", + "\n", + "[2] Cerezo, M., Sone, A., Volkoff, T., Cincio, L. & Coles, P. J. Cost-Function-Dependent Barren Plateaus in Shallow Quantum Neural Networks. [arXiv:2001.00550 (2020).](https://arxiv.org/abs/2001.00550)\n", + "\n", + "[3] Kieferova, Maria, Ortiz Marrero Carlos, and Nathan Wiebe. \"Quantum Generative Training Using R\\'enyi Divergences.\" arXiv preprint [arXiv:2106.09567 (2021).](https://arxiv.org/abs/2106.09567)" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "2c4627ff4a417355d61049564f513ba5a6282bdfd3c46a5a6bb293c3faa304ed" + }, + "kernelspec": { + "display_name": "Python 3.8.13 ('pd_dep')", + "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.8.13" + }, + "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": true + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorials/qnn_research/BarrenPlateaus_EN.ipynb b/tutorials/qnn_research/BarrenPlateaus_EN.ipynb new file mode 100644 index 0000000..9632ebe --- /dev/null +++ b/tutorials/qnn_research/BarrenPlateaus_EN.ipynb @@ -0,0 +1,1315 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Barren Plateaus\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "In the training of classical neural networks, gradient-based optimization methods encounter the problem of local minimum and saddle points. Correspondingly, the Barren plateau phenomenon could potentially block us from efficiently training quantum neural networks. This peculiar phenomenon was first discovered by McClean et al. in 2018 [[1]](https://arxiv.org/abs/1803.11173). In a few words, when we randomly initialize the parameters in random circuit structure meets a certain degree of complexity, the optimization landscape will become very flat, which makes it difficult for the optimization method based on gradient descent to find the global minimum. For most variational quantum algorithms (VQE, etc.), this phenomenon means that when the number of qubits increases, randomly choosing a circuit ansatz and randomly initializing the parameters of it may not be a good idea. This will make the optimization landscape corresponding to the loss function into a huge plateau, which makes the training of QNN much more difficult. The initial random value for the optimization process is very likely to stay inside this plateau, and the convergence time of gradient descent will be prolonged.\n", + "\n", + "![BP-fig-barren](./figures/BP-fig-barren.png)\n", + "\n", + "The figure is generated through [Gradient Descent Viz](https://github.com/lilipads/gradient_descent_viz)\n", + "\n", + "Based on the impact of gradient variation on the training of such variational quantum algorithms, we provide a gradient analysis tool module in the Paddle Quantum to assist users in diagnosing models and facilitate the study of problems such as barren plateaus.\n", + "\n", + "This tutorial mainly discusses how to demonstrate the barren plateau phenomenon with Paddle Quantum and use the gradient analysis tool to analyze the parameter gradients in user-defined quantum neural networks. Although it does not involve any algorithmic innovation, it can help readers to understand the gradient-based training for QNN.\n", + "\n", + "We first import the necessary libraries and packages:\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T12:20:39.463025Z", + "start_time": "2021-03-02T12:20:36.336398Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\openfermion\\hamiltonians\\hartree_fock.py:11: DeprecationWarning: Please use `OptimizeResult` from the `scipy.optimize` namespace, the `scipy.optimize.optimize` namespace is deprecated.\n", + " from scipy.optimize.optimize import OptimizeResult\n" + ] + } + ], + "source": [ + "# ignore waring \n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "\n", + "# Import packages needed\n", + "import time\n", + "import numpy as np\n", + "from math import pi\n", + "import paddle\n", + "from paddle_quantum.state import zero_state\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.linalg import dagger\n", + "\n", + "# Drawing tools\n", + "from matplotlib import pyplot as plt " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Random network structure\n", + "\n", + "Here we follow the original method mentioned in the paper by McClean (2018) [[1]](https://arxiv.org/abs/1803.11173) and build the following random circuit:\n", + "\n", + "![BP-fig-Barren_circuit](./figures/BP-fig-Barren_circuit.png)\n", + "\n", + "First, we rotate all the qubits around the $y$-axis of the Bloch sphere with rotation gates $R_y(\\pi/4)$.\n", + "\n", + "The remaining structure is in form of blocks, each block can be further divided into two layers:\n", + "\n", + "- The first layer is a set of random rotation gates on all the qubits, where $R_{\\ell,n} \\in \\{R_x, R_y, R_z\\}$. The subscript $\\ell$ means the gate is in the $\\ell$-th repeated block. In the figure above, $\\ell =1$. The second subscript $n$ indicates which qubit it acts on.\n", + "- The second layer is composed of CZ gates, which act on adjacent qubits.\n", + "\n", + "In Paddle Quantum, we can build this circuit with the following code:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T12:20:39.972053Z", + "start_time": "2021-03-02T12:20:39.962259Z" + } + }, + "outputs": [], + "source": [ + "def rand_circuit(theta, target, num_qubits):\n", + " # Initialize the quantum circuit\n", + " cir = Circuit(num_qubits)\n", + " \n", + " # Fixed-angle Ry rotation gates \n", + " cir.ry(param=pi / 4)\n", + "\n", + " # ============== First layer ==============\n", + " # Fixed-angle Ry rotation gates \n", + " for i in range(num_qubits):\n", + " if target[i] == 0:\n", + " cir.rz(i, param=theta[i])\n", + " elif target[i] == 1:\n", + " cir.ry(i, param=theta[i])\n", + " else:\n", + " cir.rx(i, param=theta[i])\n", + " \n", + " # ============== Second layer ==============\n", + " # Build adjacent CZ gates\n", + " for i in range(num_qubits - 1):\n", + " cir.cz([i, i + 1])\n", + " \n", + " return cir" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loss function and optimization landscape\n", + "\n", + "After determining the circuit structure, we also need to define a loss function to determine the optimization landscape. Following the same set up with McClean (2018)[[1]](https://arxiv.org/abs/1803.11173), we take the loss function from VQE:\n", + "\n", + "$$\n", + "\\mathcal{L}(\\boldsymbol{\\theta})= \\langle0| U^{\\dagger}(\\boldsymbol{\\theta})H U(\\boldsymbol{\\theta}) |0\\rangle,\n", + "\\tag{1}\n", + "$$\n", + "\n", + "The unitary matrix $U(\\boldsymbol{\\theta})$ is the quantum neural network with the random structure that we build from the last section. For the Hamiltonian $H$, we also take the simplest form $H = |00\\cdots 0\\rangle\\langle00\\cdots 0|$. After that, we can start sampling gradients with the two-qubit case - generate 300 sets of random network structures and different random initial parameters $\\{\\theta_{\\ell,n}^{( i)}\\}_{i=1}^{300}$. Each time the partial derivative with respect to the **first parameter $\\theta_{1,1}$** is calculated according to the analytical gradient formula from VQE. Then we analyze the mean and variance of these 300 sampled partial gradients. The formula for the analytical gradient is:\n", + "\n", + "$$\n", + "\\partial \\theta_{j} \n", + "\\equiv \\frac{\\partial \\mathcal{L}}{\\partial \\theta_j}\n", + "= \\frac{1}{2} \\big[\\mathcal{L}(\\theta_j + \\frac{\\pi}{2}) - \\mathcal{L}(\\theta_j - \\frac{\\pi}{2})\\big].\n", + "\\tag{2}\n", + "$$\n", + "\n", + "For a detailed derivation, see [arXiv:1803.00745](https://arxiv.org/abs/1803.00745).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T12:20:52.236108Z", + "start_time": "2021-03-02T12:20:40.850822Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\fluid\\framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " elif dtype == np.bool:\n", + "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " if data.dtype == np.object:\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The main program segment has run in total 3.090050458908081 seconds\n", + "Use 300 samples to get the mean value of the gradient of the random network's first parameter, and we have： 0.016533764\n", + "Use 300 samples to get the variance of the gradient of the random network's first parameter, and we have： 0.09683221\n" + ] + } + ], + "source": [ + "# Hyper parameter settings\n", + "# np.random.seed(42) # Fixed Numpy random seed\n", + "N = 2 # Set the number of qubits\n", + "samples = 300 # Set the number of sampled random network structures\n", + "THETA_SIZE = N # Set the size of the parameter theta\n", + "ITR = 1 # Set the number of iterations\n", + "LR = 0.2 # Set the learning rate\n", + "SEED = 1 # Fixed the randomly initialized seed in the optimizer\n", + "\n", + "# Initialize the register for the gradient value\n", + "grad_info = []\n", + "\n", + "# paddle.seed(SEED)\n", + "class manual_gradient(paddle.nn.Layer):\n", + " \n", + " # Initialize a list of learnable parameters and fill the initial value with a uniform distribution of [0, 2*pi]\n", + " def __init__(self, shape, param_attr=paddle.nn.initializer.Uniform(low=0.0, high=2 * pi), dtype='float32'):\n", + " super(manual_gradient, self).__init__()\n", + " \n", + " # Convert Numpy array to Tensor in PaddlePaddle\n", + " self.H = zero_state(N).data\n", + " \n", + " # Define loss function and forward propagation mechanism \n", + " def forward(self):\n", + " \n", + " # Initialize three theta parameter lists\n", + " theta_np = np.random.uniform(low=0., high= 2 * pi, size=(THETA_SIZE))\n", + " theta_plus_np = np.copy(theta_np) \n", + " theta_minus_np = np.copy(theta_np) \n", + " \n", + " # Modified to calculate analytical gradient\n", + " theta_plus_np[0] += np.pi/2\n", + " theta_minus_np[0] -= np.pi/2\n", + " \n", + " # Convert Numpy array to Tensor in PaddlePaddle\n", + " theta_plus = paddle.to_tensor(theta_plus_np)\n", + " theta_minus = paddle.to_tensor(theta_minus_np)\n", + " \n", + " # Generate random targets, randomly select circuit gates in rand_circuit\n", + " target = np.random.choice(3, N) \n", + " \n", + " U_plus = rand_circuit(theta_plus, target, N).unitary_matrix()\n", + " U_minus = rand_circuit(theta_minus, target, N).unitary_matrix()\n", + "\n", + " # Calculate the analytical gradient\n", + " grad = paddle.real((dagger(U_plus) @ self.H @ U_plus)[0][0] - (dagger(U_minus) @ self.H @ U_minus)[0][0])/2 \n", + "\n", + " return grad\n", + "\n", + "# Define the main block\n", + "def main():\n", + "\n", + " # Set the dimension of QNN\n", + " sampling = manual_gradient(shape=[THETA_SIZE])\n", + " \n", + " # Sampling to obtain gradient information\n", + " grad = sampling().numpy()\n", + " \n", + " return grad\n", + "\n", + "# Record running time\n", + "time_start = time.time()\n", + "\n", + "# Start sampling\n", + "for i in range(samples):\n", + " if __name__ == '__main__':\n", + " grad = main()\n", + " grad_info.append(grad)\n", + "\n", + "time_span = time.time() - time_start\n", + "\n", + "print('The main program segment has run in total ', time_span, ' seconds')\n", + "print(\"Use \", samples, \" samples to get the mean value of the gradient of the random network's first parameter, and we have：\", np.mean(grad_info))\n", + "print(\"Use \", samples, \"samples to get the variance of the gradient of the random network's first parameter, and we have：\", np.var(grad_info))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualization of the Optimization landscape\n", + "\n", + "Next, we use Matplotlib to visualize the optimization landscape. In the case of **two qubits**, we only have two parameters $\\theta_1$ and $\\theta_2$, and there are 9 possibilities for the random circuit structure in the second layer. \n", + "\n", + "![BP-fig-landscape2](./figures/BP-fig-landscape2.png)\n", + "\n", + "The plain structure shown in the $R_z$-$R_z$ layer from the last figure is something we should avoid. In this case, it's nearly impossible to converge to the theoretical minimum. If you want to try to draw some optimization landscapes yourself, please refer to the following code:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-03-02T12:21:49.972769Z", + "start_time": "2021-03-02T12:21:45.792119Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The main program segment has run in total 1.7086431980133057 seconds\n" + ] + } + ], + "source": [ + "time_start = time.time()\n", + "N = 2\n", + "\n", + "# Set the image ratio Vertical: Horizontal = 0.3\n", + "fig = plt.figure(figsize=plt.figaspect(0.3))\n", + "\n", + "# Generate points on the x, y axis\n", + "X = np.linspace(0, 2 * np.pi, 80)\n", + "Y = np.linspace(0, 2 * np.pi, 80)\n", + "\n", + "# Generate 2D mesh\n", + "xx, yy = np.meshgrid(X, Y)\n", + "\n", + "\n", + "# Define the necessary logic gates\n", + "def rx(theta):\n", + " mat = np.array([[np.cos(theta/2), -1j * np.sin(theta/2)],\n", + " [-1j * np.sin(theta/2), np.cos(theta/2)]])\n", + " return mat\n", + "\n", + "def ry(theta):\n", + " mat = np.array([[np.cos(theta/2), -1 * np.sin(theta/2)],\n", + " [np.sin(theta/2), np.cos(theta/2)]])\n", + " return mat\n", + "\n", + "def rz(theta):\n", + " mat = np.array([[np.exp(-1j * theta/2), 0],\n", + " [0, np.exp(1j * theta/2)]])\n", + " return mat\n", + "\n", + "def CZ():\n", + " mat = np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,-1]])\n", + " return mat\n", + "\n", + "# ============= The first figure =============\n", + "# We visualize the case where the second layer is kron(Ry, Ry)\n", + "ax = fig.add_subplot(1, 2, 1, projection='3d')\n", + "\n", + "# Forward propagation to calculate loss function:\n", + "def cost_yy(para):\n", + " L1 = np.kron(ry(np.pi/4), ry(np.pi/4))\n", + " L2 = np.kron(ry(para[0]), ry(para[1]))\n", + " U = np.matmul(np.matmul(L1, L2), CZ())\n", + " H = np.zeros((2 ** N, 2 ** N))\n", + " H[0, 0] = 1\n", + " val = (U.conj().T @ H@ U).real[0][0]\n", + " return val\n", + "\n", + "# Draw an image\n", + "Z = np.array([[cost_yy([x, y]) for x in X] for y in Y]).reshape(len(Y), len(X))\n", + "surf = ax.plot_surface(xx, yy, Z, cmap='plasma')\n", + "ax.set_xlabel(r\"$\\theta_1$\")\n", + "ax.set_ylabel(r\"$\\theta_2$\")\n", + "ax.set_title(\"Optimization Landscape for Ry-Ry Layer\")\n", + "\n", + "# ============= The second figure =============\n", + "# We visualize the case where the second layer is kron(Rx, Rz)\n", + "ax = fig.add_subplot(1, 2, 2, projection='3d')\n", + "\n", + "\n", + "def cost_xz(para):\n", + " L1 = np.kron(ry(np.pi/4), ry(np.pi/4))\n", + " L2 = np.kron(rx(para[0]), rz(para[1]))\n", + " U = np.matmul(np.matmul(L1, L2), CZ())\n", + " H = np.zeros((2 ** N, 2 ** N))\n", + " H[0, 0] = 1\n", + " val = (U.conj().T @ H @ U).real[0][0]\n", + " return val\n", + "\n", + "Z = np.array([[cost_xz([x, y]) for x in X] for y in Y]).reshape(len(Y), len(X))\n", + "surf = ax.plot_surface(xx, yy, Z, cmap='viridis')\n", + "ax.set_xlabel(r\"$\\theta_1$\")\n", + "ax.set_ylabel(r\"$\\theta_2$\")\n", + "ax.set_title(\"Optimization Landscape for Rx-Rz Layer\")\n", + "\n", + "\n", + "plt.show()\n", + "\n", + "time_span = time.time() - time_start \n", + "print('The main program segment has run in total ', time_span, ' seconds')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Gradient Analysis Tool\n", + "\n", + "Based on an important role that gradients play in phenomena such as barren plateaus, we developed a simple gradient analysis tool in Paddle Quantum to assist users in viewing gradients of each parameter in the circuit. This tool can be used to facilitate subsequent research on quantum neural networks.\n", + "\n", + "Note that the users only need to define the **circuit** and **loss function** separately when using the gradient analysis tool, and there is no need to write their networks.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Application I: Unsupervised Learning\n", + "\n", + "For this case, we focus on variational quantum algorithms similar to the Variational Quantum Eigensolver (VQE). Suppose the objective function is the typical parameterized cost function used in VQA: $O(\\theta) = \\left\\langle0\\dots 0\\right\\lvert U^{\\dagger}(\\theta)HU(\\theta) \\left\\lvert0\\dots 0\\right\\rangle$，where $U(\\theta)$ is a parameterized quantum circuit, $H$ is a Hamiltonian and $\\theta = [\\theta_1, \\theta_2, \\dots, \\theta_n]$ is a list of trainable parameters in the circuit.\n", + "\n", + "Here we use VQE to demonstrate the usage of this gradient analysis tool.\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Paddle Quantum Implement\n", + "\n", + "Firstly, import the packages needed for the problem." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Import related modules from Paddle Quantum and PaddlePaddle\n", + "from paddle_quantum.qinfo import pauli_str_to_matrix, random_pauli_str_generator\n", + "from paddle_quantum.hamiltonian import Hamiltonian\n", + "# GradTool package\n", + "from paddle_quantum.gradtool import random_sample, show_gradient, plot_loss_grad, show_gradient" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Define Quantum Circuits\n", + "\n", + "Next, construct the parameterized quantum circuit $U(\\theta)$ in the objective function. Here we still use the random circuit defined above." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Define Objective Function\n", + "\n", + "Note here that in the gradient analysis module we call the function in the form of ``loss_func(circuit, *args)`` to calculate the objective function value. This means that the second argument is a variable argument, and the user is able to construct their own objective function form as needed." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# objective function\n", + "def loss_func(circuit: Circuit, H: Hamiltonian) -> paddle.Tensor:\n", + " return circuit().expec_val(H, shots = 0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then set some parameters required for the application." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Hyper parameter settings\n", + "np.random.seed(42) # Fixed Numpy random seed\n", + "N = 2 # Set the number of qubits\n", + "samples = 300 # Set the number of sampled random network structures\n", + "THETA_SIZE = N # Set the size of the parameter theta\n", + "ITR = 120 # Set the number of iterations\n", + "LR = 0.1 # Set the learning rate\n", + "SEED = 1 # Fixed the randomly initialized seed in the optimizer" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Randomly generate quantum circuits and a list of Hamiltonian information." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--Ry(0.785)----Rx(1.077)----*--\n", + " | \n", + "--Ry(0.785)----Rz(0.623)----z--\n", + " \n", + "Hamiltonian info: -0.6880109593275947 Z1\n", + "0.7323522915498704 Z0\n", + "-0.8871768419457995 Y0, Y1\n", + "-0.7724600283015672 X1\n", + "-0.39151551408092455 Y1\n", + "0.22370578944475894 Y0, Z1\n" + ] + } + ], + "source": [ + "# paddle.seed(SEED)\n", + "target = np.random.choice(3, N)\n", + "# Random generate parameters between 0 and 2*Pi \n", + "theta = paddle.rand([THETA_SIZE]).astype('float32') * 2 * pi\n", + "theta.stop_gradient = False\n", + "cir = rand_circuit(theta, target, N)\n", + "print(cir)\n", + "# Random generate Hamiltonian information, in Pauli string format\n", + "H_l = Hamiltonian(random_pauli_str_generator(N, terms=7))\n", + "print('Hamiltonian info: ', H_l)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "``cir`` and ``H_l`` are the parameters needed for the objective function ``loss_func``." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the gradient analysis tool, we can get the results of the gradient sampling of each parameter in the circuit. There are three modes ``single``, ``max``, and ``random`` for users to choose, where ``single`` returns the mean and variance of each parameter after sampling the circuit multiple times, ``max`` mode returns the mean and variance of the maximum value of all parameter gradients in each round, and ``random`` calculates the mean and variance of random value of all parameter gradients in each round.\n", + "\n", + "We sample the circuit 300 times, and here we choose the ``single`` mode to see the mean and variance of the gradient of each variable parameter in the circuit, while the default ``param=0`` means plot gradient distribution of the first parameter.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: 100%|###################################################| 300/300 [00:03<00:00, 77.68it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of gradient for all parameters: \n", + "theta 1 : 0.015548194\n", + "theta 2 : -0.026560133\n", + "Variance of gradient for all parameters: \n", + "theta 1 : 0.20417707\n", + "theta 2 : 0.13769649\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "grad_mean_list, grad_variance_list = random_sample(cir, loss_func, samples, H_l, mode='single', param=0) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The user can also use the ``plot_loss_grad`` function to show the gradient and loss values variation during the training process." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 0%| | 0/120 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_loss_grad(cir, loss_func, ITR, LR, H_l)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As shown above, the loss value does not change after a few dozen times, and the gradient is very close to 0.\n", + "In order to see the difference between the optimal solution and the theoretical value clearly, we calculate the eigenvalues of the Hamiltonian ``H_l``." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Training: 100%|###################################################| 120/120 [00:01<00:00, 87.80it/s]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "optimal result: -1.2294903\n", + "real energy： -2.064555\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "loss, grad = show_gradient(cir, loss_func, ITR, LR, H_l)\n", + "H_matrix = H_l.construct_h_matrix()\n", + "\n", + "print(\"optimal result: \", loss[-1])\n", + "print(\"real energy：\", np.linalg.eigh(H_matrix)[0][0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The comparison shows that there is still a gap between the optimal solution obtained from the training of this circuit and the actual value." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### More qubits\n", + "\n", + "Since in the barren plateau effect, the gradient disappears exponentially with increasing the number of quantum bits. Then, we will see what happens to the sampled gradients when we increase the number of qubits(here we sample by choosing ``max`` mode)." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: 100%|###################################################| 300/300 [00:03<00:00, 75.81it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of max gradient\n", + "0.72318614\n", + "Variance of max gradient\n", + "0.0966615\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: 0%| | 0/300 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: 0%| | 0/300 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: 0%| | 0/300 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Hyper parameter settings\n", + "selected_qubit = [2, 4, 6, 8]\n", + "means, variances = [], []\n", + "\n", + "# Keep increasing the number of qubits\n", + "for N in selected_qubit:\n", + " grad_info = []\n", + " THETA_SIZE = N \n", + " target = np.random.choice(3, N)\n", + " # Generate a value from 0 to 2PI\n", + " theta = paddle.rand([THETA_SIZE]).astype('float32') * 2 * pi\n", + " theta.stop_gradient = False\n", + " cir = rand_circuit(theta, target, N)\n", + " \n", + " H_l = Hamiltonian(random_pauli_str_generator(N, terms=10))\n", + " \n", + " grad_mean_list, grad_variance_list = random_sample(cir, loss_func, samples, H_l, mode='max') \n", + " # Record sampling information\n", + " means.append(grad_mean_list)\n", + " variances.append(grad_variance_list)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To compare the mean and variance of the maximum gradient of each parameter, we plot them." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "We then draw the statistical results of this sampled gradient:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "means = np.array(means)\n", + "variances = np.array(variances)\n", + "\n", + "n = np.array(selected_qubit)\n", + "print(\"We then draw the statistical results of this sampled gradient:\")\n", + "fig = plt.figure(figsize=plt.figaspect(0.3))\n", + "\n", + "# ============= The first figure =============\n", + "# Calculate the relationship between the average gradient of random sampling and the number of qubits\n", + "plt.subplot(1, 2, 1)\n", + "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 gradient\".format(samples))\n", + "plt.xlim([1,9])\n", + "plt.grid()\n", + "\n", + "# ============= The second figure =============\n", + "# Calculate the relationship between the variance of the randomly sampled gradient and the number of qubits\n", + "plt.subplot(1, 2, 2)\n", + "plt.plot(n, np.log(variances), \"v-\")\n", + "plt.xlabel(r\"Qubit #\")\n", + "plt.ylabel(r\"$ \\partial \\theta_{i} \\langle 0|H |0\\rangle$ Variance\")\n", + "plt.title(\"Variance of {} sampled gradient\".format(samples))\n", + "plt.xlim([1,9])\n", + "plt.grid()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It can be seen that as the number of qubits increases, the maximum value of the gradient of all parameters obtained by multiple sampling is constantly close to 0, and the variance is also decreasing." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To further see how the gradient changes as the number of quantum bits increases, we might as well visualize the influence of choosing different qubits on the optimization landscape:\n", + "\n", + "![BP-fig-qubit_landscape_compare](./figures/BP-fig-qubit_landscape_compare.png \"(a) Optimization landscape sampled for 2,4,and 6 qubits from left to right in different z-axis scale. (b) Same landscape in a fixed z-axis scale.\")\n", + "\n", + "$\\theta_1$ and $\\theta_2$ are the first two circuit parameters, and the remaining parameters are all fixed to $\\pi$. This way, it helps us visualize the shape of this high-dimensional manifold. Unsurprisingly, the landscape becomes more flatter as $n$ increases. **Notice the rapidly decreasing scale in the $z$-axis**. Compared with the 2-qubit case, the optimized landscape of 6 qubits is very flat.\n", + "\n", + "Note that only when the network structure and loss function meet certain conditions, i.e. unitary 2-design (see paper [1]), this effect will appear.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Application II: Quantum encoded classical data\n", + "\n", + "Supervised learning is one of the important applications of quantum neural networks. However, the barren plateau phenomenon limits the performance of quantum variational algorithms in such problems. Therefore, how to design more efficient circuits and loss functions to avoid the barren plateau phenomenon is one of the important research directions of quantum neural networks at present.\n", + "\n", + "In fact, it has been shown that using Renyi divergence as a loss function in the training of generative model can effectively avoid the barren plateau phenomenon [[3]](https://arxiv.org/abs/2106.09567). \n", + "The gradient analysis tools allow us to quickly analyze the information related to the gradient in a supervised learning model, which can facilitate researchers to try to explore different quantum circuits and loss functions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here, we present an example using the dataset provided by [Encoding Classical Data into Quantum States](./tutorial/machine_learning/DataEncoding_EN.ipynb)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Paddle Quantum Implement\n", + "\n", + "Firstly, import the packages needed for the problem." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from paddle_quantum.dataset import Iris\n", + "from paddle_quantum.gradtool import random_sample_supervised, plot_supervised_loss_grad" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Define Quantum Circuits\n", + "\n", + "Next, construct the parameterized quantum circuit $U(\\theta)$." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def U_theta(n: int, depth: int):\n", + " # Initialize the quantum circuit\n", + " cir = Circuit(n)\n", + "\n", + " # rotation gates \n", + " cir.rz()\n", + " cir.ry()\n", + " cir.rz()\n", + "\n", + " # default depth = 1\n", + " # Build adjacent CNOT gates and RY rotation gates \n", + " for _ in range(3, depth + 3):\n", + " cir.cnot()\n", + " cir.ry()\n", + " \n", + " return cir" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Define Objective Function\n", + "\n", + "Here the objective function ``loss_fun`` is defined, and the second parameter is still the variable ``*args``." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def loss_func(cir: Circuit, *args):\n", + " # input the quantum states and training labels\n", + " state_in = args[0]\n", + " label = args[1]\n", + " # Convert Numpy array to tensor\n", + " label_pp = paddle.to_tensor(label).reshape([-1, 1])\n", + " \n", + " Utheta = cir.unitary_matrix()\n", + " \n", + " # Since Utheta is learned, we use row vector operations here to speed up the training without affecting the results\n", + " state_out = state_in @ Utheta\n", + " \n", + " # Measure the expected value of the Pauli Z operator \n", + " Ob = paddle.to_tensor(pauli_str_to_matrix([[1.0, 'z0']], qubit_num))\n", + " E_Z = state_out @ Ob @ paddle.transpose(paddle.conj(state_out), perm=[0, 2, 1])\n", + "\n", + " # Mapping into label \n", + " state_predict = paddle.real(E_Z)[:, 0] * 0.5 + 0.5\n", + " loss = paddle.mean((state_predict - label_pp) ** 2) # mean-squared error\n", + " \n", + " return loss\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Define the dataset\n", + "\n", + "Here, we use [Iris dataset](./tutorial/machine_learning/DataEncoding_EN.ipynb) to do the experiment." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--Rz(0.275)----Ry(1.589)----Rz(5.910)----*----x----Ry(0.235)--\n", + " | | \n", + "--Rz(2.328)----Ry(2.518)----Rz(5.586)----x----*----Ry(2.902)--\n", + " \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\fluid\\framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " elif dtype == np.bool:\n" + ] + } + ], + "source": [ + "time_start = time.time()\n", + "\n", + "# Hyper parameter settings\n", + "test_rate = 0.2\n", + "qubit_num = 2 # Don't give too many qubits, otherwise it will be seriously overfitted\n", + "depth = 1\n", + "lr = 0.1\n", + "BATCH = 4\n", + "EPOCH = 4\n", + "SAMPLE = 300\n", + "\n", + "# dataset\n", + "iris = Iris(encoding='amplitude_encoding', num_qubits=qubit_num, test_rate=test_rate, classes=[0,1], return_state=True)\n", + "\n", + "# Get inputs and labels for the dataset\n", + "train_x, train_y = iris.train_x, iris.train_y # train_x, test_x here is paddle.tensor type, train_y，test_y here is ndarray type.\n", + "test_x, test_y = iris.test_x, iris.test_y\n", + "testing_data_num = len(test_y)\n", + "training_data_num = len(train_y)\n", + "\n", + "\n", + "# Creating trainable parameters for circuits\n", + "# Creating Circuits\n", + "circuit = U_theta(qubit_num, depth)\n", + "\n", + "print(circuit)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's look at the variation of the loss function values and gradients during training with EPOCH=4 and BATCH=4." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\jingmingrui\\Anaconda3\\envs\\pd_dep\\lib\\site-packages\\paddle\\tensor\\creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n", + "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n", + " if data.dtype == np.object:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "loss,grad = plot_supervised_loss_grad(circuit, loss_func, N=qubit_num, EPOCH = EPOCH, LR = lr,BATCH = BATCH, TRAIN_X=train_x, TRAIN_Y=train_y)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can see that after ten steps of iteration, the value of the loss function only fluctuates in a small range, indicating that the training process is stable." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then we randomly sample the initial parameters of the model 300 times, and here we choose the ``max`` mode to see the mean and variance of the maximum gradient for all parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: 100%|###################################################| 300/300 [00:03<00:00, 92.32it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mean of max gradient\n", + "0.15071002\n", + "Variance of max gradient\n", + "0.0035270636\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "mean, variance = random_sample_supervised(circuit,loss_func, N=qubit_num, sample_num=SAMPLE, BATCH=BATCH, TRAIN_X=train_x, TRAIN_Y=train_y, mode='max')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "The trainability problem is a core direction of current research in quantum neural networks, and the gradient analysis tool provided by Quantum Paddle supports users to diagnose the trainability of the model, facilitating the study of subsequent problems such as barren plateaus." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## References\n", + "\n", + "[1] McClean, J. R., Boixo, S., Smelyanskiy, V. N., Babbush, R. & Neven, H. Barren plateaus in quantum neural network training landscapes. [Nat. Commun. 9, 4812 (2018).](https://www.nature.com/articles/s41467-018-07090-4)\n", + "\n", + "[2] Cerezo, M., Sone, A., Volkoff, T., Cincio, L. & Coles, P. J. Cost-Function-Dependent Barren Plateaus in Shallow Quantum Neural Networks. [arXiv:2001.00550 (2020).](https://arxiv.org/abs/2001.00550)\n", + "\n", + "[3] Kieferova, Maria, Ortiz Marrero Carlos, and Nathan Wiebe. \"Quantum Generative Training Using R\\'enyi Divergences.\" arXiv preprint [arXiv:2106.09567 (2021).](https://arxiv.org/abs/2106.09567)" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "2c4627ff4a417355d61049564f513ba5a6282bdfd3c46a5a6bb293c3faa304ed" + }, + "kernelspec": { + "display_name": "Python 3.8.13 ('pd_dep')", + "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.8.13" + }, + "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": true + }, + "varInspector": { + "cols": { + "lenName": 16, + "lenType": 16, + "lenVar": 40 + }, + "kernels_config": { + "python": { + "delete_cmd_postfix": "", + "delete_cmd_prefix": "del ", + "library": "var_list.py", + "varRefreshCmd": "print(var_dic_list())" + }, + "r": { + "delete_cmd_postfix": ") ", + "delete_cmd_prefix": "rm(", + "library": "var_list.r", + "varRefreshCmd": "cat(var_dic_list()) " + } + }, + "types_to_exclude": [ + "module", + "function", + "builtin_function_or_method", + "instance", + "_Feature" + ], + "window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorials/qnn_research/Expressibility_CN.ipynb b/tutorials/qnn_research/Expressibility_CN.ipynb new file mode 100644 index 0000000..1619a99 --- /dev/null +++ b/tutorials/qnn_research/Expressibility_CN.ipynb @@ -0,0 +1,707 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9479f1e0", + "metadata": {}, + "source": [ + "# 量子神经网络的表达能力\n", + "\n", + "Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved." + ] + }, + { + "cell_type": "markdown", + "id": "c352b2aa", + "metadata": {}, + "source": [ + "## 概览" + ] + }, + { + "cell_type": "markdown", + "id": "3a195bcc", + "metadata": {}, + "source": [ + "在量子机器学习中，量子神经网络的**表达能力**是决定量子机器学习任务能否成功的关键因素。一般来说，量子神经网络拟设的表达能力越强，量子机器学习能够搜索到全局最优解的可能性就越大。本教程首先介绍量子神经网络表达能力的基本概念，随后将在量桨中展示如何通过布洛赫球感受不同拟设表达能力的差别。最后介绍一种定量分析量子神经网络表达能力的方法，并评估量桨提供的量子神经网络模板在不同深度下的表达能力。" + ] + }, + { + "cell_type": "markdown", + "id": "0f4583d7", + "metadata": {}, + "source": [ + "## 基本概念" + ] + }, + { + "cell_type": "markdown", + "id": "c03d7dcf", + "metadata": {}, + "source": [ + "我们先来回顾一下量子机器学习算法的基本流程。在量子机器学习中，我们往往设计一个损失函数 $\\mathcal{L}$，并通过优化一个酉变换 $U$ 使得损失函数最小化：\n", + "\n", + "$$\n", + "\\min_U\\mathcal{L}(U)=\\min_U \\text{tr}[HU\\rho_{in}U^\\dagger],\\tag{1}\n", + "$$\n", + "\n", + "算法背后的数学原理保证当我们遍历完所有可能的酉变换后，损失函数能取到的最小值就对应于我们问题的解。而在实际操作中，我们采用量子神经网络将酉变换参数化：\n", + "\n", + "$$\n", + "U=U(\\vec{\\theta})=U_D(\\vec{\\theta}_D)\\dots U_1(\\vec{\\theta}_1),\\tag{2}\n", + "$$\n", + "\n", + "其中每个 $U_j(\\vec{\\theta}_j),j\\in[1,D]$ 代表一层量子神经网络，$\\vec{\\theta}_j$ 代表该层对应的参数。此时，通过调整量子神经网络中的参数 $\\vec{\\theta}$，我们就可以进行对酉变换 $U$ 的优化，进而最小化损失函数 $\\mathcal{L}$：\n", + "\n", + "$$\n", + "\\min_{\\vec{\\theta}}\\mathcal{L}(\\vec{\\theta})=\\min_{\\vec{\\theta}} \\text{tr}[HU(\\vec{\\theta})\\rho_{in}U(\\vec{\\theta})^\\dagger].\\tag{3}\n", + "$$\n", + "\n", + "然而，细心的读者此时可能已经发现了量子神经网络的一个不足：对于一个给定的神经网络拟设，**遍历所有的参数并不一定可以保证遍历所有的酉变换**。作为一个简单的例子，如果我们只允许使用一个 $R_Y$ 旋转门作为单比特量子神经网络 $U(\\theta)=R_Y(\\theta)$，显然（除去全局相位）$U(\\theta)$ 不能表示任何矩阵元含虚部的复酉矩阵。而当允许使用 $R_Y$ 和 $R_Z$ 旋转门时，如果我们搭建量子神经网络为 $U(\\vec{\\theta})=R_Z(\\theta_1)R_Y(\\theta_2)R_Z(\\theta_3)$，$U(\\vec{\\theta})$ （除去全局相位）将能够表示所有的单比特酉矩阵 [1]。\n", + "\n", + "如果我们将神经网络的表达能力定义为**在遍历电路参数 $\\vec{\\theta}$ 时电路能够表达的酉变换的多少**，那么，一个表达能力强的量子神经网络将更有可能包含那些使得损失函数 $\\mathcal{L}$ 取到全局最小值的酉变换；相反地，如果一个量子神经网络 $U_{weak}$ 的表达能力太弱以至于不包含任何能将损失函数最小化的酉变换，那么基于优化 $U_{weak}$ 的量子机器学习任务就很可能会失败。\n", + "\n", + "接下来我们基于量桨，通过观察单量子比特酉门遍历布洛赫球的能力直观地感受量子神经网络的表达能力。" + ] + }, + { + "cell_type": "markdown", + "id": "3412d8c6", + "metadata": {}, + "source": [ + "## 直观感受表达能力：遍历布洛赫球" + ] + }, + { + "cell_type": "markdown", + "id": "5bd49ecf", + "metadata": {}, + "source": [ + "对于单量子比特的简单情况，我们可以直接观察量子神经网络如何将固定输入遍历布洛赫球表面。对于一个给定的神经网络拟设 $U(\\vec{\\theta})$，由于网络的输入往往是固定的（不妨设为 $|0\\rangle$），通过均匀地采样神经网络参数 $\\vec{\\theta}$，神经网络的输出态 $U(\\vec{\\theta})|0\\rangle$ 将散落在布洛赫球表面。显然，如果输出态在球面分布地越广越均匀，那么神经网络拟设 $U$ 的表达能力也就越强，包含损失函数全局最优的可能性也就越大。\n", + "\n", + "为在量桨实现这一功能，首先引入必要的包：" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e05a5803", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import paddle\n", + "import paddle_quantum as pq\n", + "from paddle_quantum.ansatz.circuit import Circuit\n", + "from paddle_quantum.visual import plot_state_in_bloch_sphere" + ] + }, + { + "cell_type": "markdown", + "id": "14f70b6b", + "metadata": {}, + "source": [ + "首先，我们只允许使用一个 $R_Y$ 旋转门作为单比特量子神经网络 $U(\\theta)=R_Y(\\theta)$。通过在 $[0,2\\pi]$ 均匀采样参数 $\\theta$ 并将 $U(\\theta)$ 作用在固定输入 $|0\\rangle$ 上，我们便得到量子神经网络 $U(\\theta)$ 的输出分布。通过量桨内置的 plot_bloch_sphere_from_input 函数，我们可以直接观察 $U(\\theta)|0\\rangle$ 在布洛赫球面上的分布：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "04344561", + "metadata": { + "scrolled": false + }, + "outputs": [], + "source": [ + "num_qubit = 1 # 设定量子比特数\n", + "num_sample = 2000 # 设定采样次数\n", + "outputs_y = list() # 储存采样电路输出\n", + "\n", + "for _ in range(num_sample):\n", + " # 初始化量子神经网络\n", + " pq.set_backend('density_matrix')\n", + " cir = Circuit(num_qubit)\n", + " # 作用 Ry 旋转门，旋转角度随机\n", + " cir.ry(0)\n", + " # 输出态的密度矩阵\n", + " rho = cir(pq.state.zero_state(num_qubit))\n", + " outputs_y.append(rho)\n", + " \n", + "# 量桨内置的 plot_bloch_sphere_from_input 函数\n", + "# plot_state_in_bloch_sphere(outputs_y, save_gif=True, filename='figures/bloch_y.gif')" + ] + }, + { + "cell_type": "markdown", + "id": "97e80f54", + "metadata": {}, + "source": [ + "![bloch_y.gif](./figures/expressibility-fig-bloch_y.gif)" + ] + }, + { + "cell_type": "markdown", + "id": "7198779e", + "metadata": {}, + "source": [ + "可见，量子神经网络 $U(\\theta)=R_Y(\\theta)$ 的输出只能分布于布洛赫球面上的一个圆环（尽管在圆环上的分布是均匀的）。类似地，我们考虑包含两个参数的神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ 和 三个参数的神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 的输出分布：" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0530af37", + "metadata": {}, + "outputs": [], + "source": [ + "outputs_yz = list() # 储存采样电路输出\n", + "for _ in range(num_sample):\n", + " # 初始化量子神经网络\n", + " cir = Circuit(num_qubit)\n", + " # 作用 Ry 和 Rz 旋转门，旋转角度随机\n", + " cir.ry(0)\n", + " cir.rz(0)\n", + " # 输出态的密度矩阵\n", + " rho = cir(pq.state.zero_state(num_qubit))\n", + " outputs_yz.append(rho)\n", + "\n", + "# plot_state_in_bloch_sphere(outputs_yz, save_gif=True, filename='figures/bloch_yz.gif')\n", + "\n", + "\n", + "outputs_yzy = list() # 储存采样电路输出\n", + "for _ in range(num_sample):\n", + " # 初始化量子神经网络\n", + " cir = Circuit(num_qubit)\n", + " # 作用 Ry,Rz,Ry 旋转门，旋转角度随机\n", + " cir.ry(0)\n", + " cir.rz(0)\n", + " cir.ry(0)\n", + " # 输出态的密度矩阵\n", + " rho = cir(pq.state.zero_state(num_qubit))\n", + " outputs_yzy.append(rho)\n", + " \n", + "# plot_state_in_bloch_sphere(outputs_yzy, save_gif=True, filename='figures/bloch_yzy.gif')" + ] + }, + { + "cell_type": "markdown", + "id": "8dbde635", + "metadata": {}, + "source": [ + "![bloch_yz.gif](./figures/expressibility-fig-bloch_yz.gif)" + ] + }, + { + "cell_type": "markdown", + "id": "58b0d055", + "metadata": {}, + "source": [ + "![bloch_yzy.gif](./figures/expressibility-fig-bloch_yzy.gif)" + ] + }, + { + "cell_type": "markdown", + "id": "4e195d35", + "metadata": {}, + "source": [ + "可见，神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ 的输出可以分布在整个布洛赫球表面了，虽然在两级（$|0\\rangle$ 和 $|1\\rangle$）附近的分布会更加密集；而神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 的输出在球面的分布是比较均匀的。" + ] + }, + { + "cell_type": "markdown", + "id": "7972ed41", + "metadata": {}, + "source": [ + "在单量子比特的低维情形下我们可以借助布洛赫球定性观察量子神经网络的表达能力。而在一般的多量子比特应用中，我们必须借助统计数学的工具对表达能力定量分析。接下来我们将引入量子态之间保真度分布的 K-L 散度作为量化神经网络的表达能力的指标，并计算一种常见拟设的表达能力。" + ] + }, + { + "cell_type": "markdown", + "id": "11ca0aeb", + "metadata": {}, + "source": [ + "## 定量分析表达能力：K-L 散度" + ] + }, + { + "cell_type": "markdown", + "id": "1275e46a", + "metadata": {}, + "source": [ + "### 保真度分布与 K-L 散度" + ] + }, + { + "cell_type": "markdown", + "id": "54ae96a6", + "metadata": {}, + "source": [ + "在文献 [2] 中，作者提出了基于神经网络输出态之间的保真度概率分布的表达能力量化方法。对任意量子神经网络 $U(\\vec{\\theta})$，采样两次神经网络参数（设为 $\\vec{\\phi}$ 和 $\\vec{\\psi}$），则两个量子电路输出态之间的保真度 $F=|\\langle0|U(\\vec{\\phi})^\\dagger U(\\vec{\\psi})|0\\rangle|^2$ 服从某个概率分布：\n", + "$$\n", + "F\\sim{P}(f).\\tag{4}\n", + "$$\n", + "文献 [2] 指出，量子神经网络 $U$ 能够均匀地分布在所有酉矩阵上时（此时称 $U$ 服从哈尔分布），保真度的概率分布 $P_\\text{Haar}(f)$ 满足\n", + "$$\n", + "P_\\text{Haar}(f)=(2^{n}-1)(1-f)^{2^n-2}.\\tag{5}\n", + "$$\n", + "\n", + "量桨提供了直接从哈尔分布采样酉矩阵的函数。观察哈尔分布酉矩阵输出的量子态保真度服从的概率分布：" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "b9dbeb68", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from paddle_quantum.linalg import haar_unitary\n", + "from paddle_quantum.qinfo import state_fidelity\n", + "from paddle_quantum.state.common import to_state\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import FuncFormatter\n", + "from scipy import integrate\n", + "\n", + "# 定义绘制直方图的函数\n", + "def plot_hist(data, num_bin, title_str):\n", + " def to_percent(y, position):\n", + " return str(np.around(y*100, decimals=2)) + '%'\n", + " plt.hist(data, weights=[1./len(data)]*len(data), bins=np.linspace(0, 1, num=num_bin), facecolor=\"blue\", edgecolor=\"black\", alpha=0.7)\n", + " plt.xlabel(\"Fidelity\")\n", + " plt.ylabel(\"frequency\")\n", + " plt.title(title_str)\n", + " formatter = FuncFormatter(to_percent)\n", + " plt.gca().yaxis.set_major_formatter(formatter)\n", + " plt.show()\n", + " \n", + " \n", + "# 定义计算哈尔采样输出保真度分布的函数\n", + "def p_F_haar(n, s, b=50, draw=False):\n", + " f_list = list()\n", + " # 开始采样\n", + " for i in range(s):\n", + " # 采样第一个酉变换\n", + " u1 = haar_unitary(n)\n", + " # 输入 |0> 时酉变换的输出\n", + " phi1 = u1[:,0]\n", + " rho1 = to_state(np.outer(phi1, phi1.conj()))\n", + " # 采样第二个酉变换\n", + " u2 = haar_unitary(n)\n", + " phi2 = u2[:,0]\n", + " # 输入 |0> 时酉变换的输出\n", + " rho2 = to_state(np.outer(phi2, phi2.conj()))\n", + " # 计算两个采样输出之间的保真度\n", + " f_list.append(state_fidelity(rho1, rho2)**2)\n", + " f_list = np.array(f_list)\n", + " # 绘制概率分布图\n", + " if draw:\n", + " title_str = \"haar, %d qubit(s)\" % num_qubit\n", + " plot_hist(f_list, b, title_str)\n", + " sample_distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", + " # 根据公式计算概率分布函数的理论值，用于后期计算 K-L 散度\n", + " theory_distribution = np.zeros_like(sample_distribution)\n", + " for index in range(len(theory_distribution)):\n", + " def p_continues(f):\n", + " return (2 ** n - 1) * (1 - f) ** (2 ** n - 2)\n", + " lower = 1/b*index\n", + " upper = lower + 1/b\n", + " theory_distribution[index], _ = integrate.quad(p_continues,lower,upper)\n", + " return sample_distribution, theory_distribution\n", + "\n", + "\n", + "num_qubit = 1\n", + "p_haar_1qubit, theory_haar_1qubit = p_F_haar(num_qubit, num_sample, draw=True)\n", + "num_qubit = 2\n", + "p_haar_2qubit, theory_haar_2qubit = p_F_haar(num_qubit, num_sample, draw=True)" + ] + }, + { + "cell_type": "markdown", + "id": "8680f5b2", + "metadata": {}, + "source": [ + "可见保真度分布大致服从 $P_\\text{Haar}$。类似地，我们也能计算之前定义的单比特量子神经网络 $R_Y(\\theta)$，$R_Y(\\theta_1)R_Z(\\theta_2)$ 和 $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 输出的保真度概率分布：" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "2af57d70", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEWCAYAAACnlKo3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAZhUlEQVR4nO3de7hddZ3f8fdHgmhERSV4CcTgDYfqqJhW1GccKIpIBaYIBeWmD4rX8VKsRUVttTKDg3iZqjQKIxcvTDHa2KJIQcqMFcaADKLoEGOEcBEUxRnRIZhv/1grdntyTrJZZ1/OPuf9ep79ZK/fWnvv78o5yWf/fr91SVUhSVIX9xt3AZKkyWWISJI6M0QkSZ0ZIpKkzgwRSVJnhogkqTNDRJLUmSEijViS9Ul+neSfktyW5NNJdhx3XVIXhog0HgdV1Y7A04FnAG8fbzlSN4aINEZVdRtwEfD0JNclOWjzuiTbJ/lpkmeMr0Jp6wwRaYyS7Aq8CFgLnAMc3bP6QODWqvr2OGqT+hGvnSWNVpL1wM5AATsClwIvARYDPwCWVtUvk1wA/F1VfWBctUrbYk9EGo8/qaoHA/sATwZ2rqpbgG8AL0myE00P5TNjq1DqgyEijVFV/R/g08BpbdPZNENahwPfrKqbx1Sa1JdF4y5AEh8G1id5GvAl4OPAIwGHsTTn2RORxqyq7qCZVH93Vf0a+AKwO7BqrIVJfXBiXZpjkrwbeFJVHb3NjaUxczhLmkOSPBw4Hjhm3LVI/XA4S5ojkrwKuAn4SlVdPu56pH44nCVJ6syeiCSpswU3J7LzzjvX8uXLx12GJE2Uq6666qdVtWRq+4ILkeXLl7NmzZpxlyFJEyXJj6drdzhLktSZISJJ6swQkSR1ZohIkjozRCRJnRkikqTODBFJUmeGiCSps6GFSJKzktye5LqetocnuTjJDe2fD5vhtce129yQ5Li2bYckX01yXZLX9Wy7Mslew9oPSdLMhnnG+qeB/0pzs53NTgIuqao/T3JSu/wfe1/UXgr7PcAKoICrkqwG/gj4W+AUmvtQf7y9E9x2VXX1EPfjdw499HjWr799i/bly3dh1aozR1GCJM0pQwuRqro8yfIpzYcA+7TPzwYuY0qIAC8ELq6qOwGSXAwcAPwCWAxsD6Td9n3AawZb+czWr7+dpUu/PE37QaMqQZLmlFHPiTyyqm5tn99Gcx/pqZbS3FNhsw1t28XAcuAK4KNJDgaurqpbtvWhSU5IsibJmjvuuGM29UuSeoztAoxVVUn6vplJVd0LvAwgyfbARcAhSU4HlgHnVNXqGV67ElgJsGLFCm+gIkkDMuqeyE+SPBqg/XPLCQa4GditZ3nXtq3X62jmWvYG7gKOAE4ceLWSpK0adYisBo5rnx8H/I9ptrkI2D/Jw9qjt/Zv2wBo215MEyKLgU00E/APHGLdkqRpDPMQ388B3wT2SLIhyfHAnwMvSHID8Px2mSQrknwKoJ1Qfx/wrfbx3s2T7K13A++vqk004fJHwHeAc4e1L5Kk6Q3z6KyXzrBqv2m2XQO8smf5LOCsGd73LT3Pf0PTU5EkjYFnrEuSOjNEJEmdGSKSpM4MEUlSZ4aIJKkzQ0SS1JkhIknqzBCRJHVmiEiSOjNEJEmdGSKSpM4MEUlSZ2O7KZUkafAOPfR41q/f8lZNy5fvwqpVZw788wwRSZpH1q+/naVLvzxN+0FD+TyHsyRJnRkikqTODBFJUmeGiCSpM0NEktSZISJJ6swQkSR1ZohIkjozRCRJnRkikqTODBFJUmeGiCSpM0NEktSZISJJ6swQkSR1ZohIkjozRCRJnRkikqTOxhIiSd6S5LtJrkvyuSQPmLJ+hyTnJ1mb5Moky9v25ya5NsmaJE9s23ZK8rUkBqIkjdjI/+NNshR4I7Ciqp4CbAccOWWz44GfV9UTgA8Bp7btJwIHAm8GXtO2nQycUlWbhly6JGmKcX17XwQ8MMkiYDFwy5T1hwBnt88vAPZLEmBju/1iYGOSxwO7VdVlI6lakvR7Fo36A6vq5iSnATcCvwa+VlVfm7LZUuCmdvt7k9wFPAL4M+Cc9nXHAKfR9ES2KskJwAkAy5YtG9CeSJLGMZz1MJqexu7AY4AHJTm6n9dW1TVVtXdV7Qs8Dri1ecucn+S8JI+c4XUrq2pFVa1YsmTJgPZEkjSO4aznAz+qqjuqaiOwCnjOlG1uBnYDaIe8Hgr8bPPKdmjrZOB9wHuAtwGfpJlrkSSNyDhC5EZg7ySL2zDYD7h+yjargePa54cBl1ZV9aw/Friwqu6kmR/Z1D4WD7VySdLvGcecyJVJLgCuBu4Fvg2sTPJeYE1VrQbOBM5Nsha4k56jt5IsBl4O7N82nQ5cCNwDvGxU+yFJGkOIAFTVe2iGoXq9u2f9b4DDZ3jt3cC+Pct/Azx1CGVKkrbBE/QkSZ0ZIpKkzgwRSVJnhogkqTNDRJLUmSEiSerMEJEkdWaISJI6M0QkSZ0ZIpKkzgwRSVJnhogkqTNDRJLUmSEiSerMEJEkdWaISJI6M0QkSZ0ZIpKkzgwRSVJnhogkqTNDRJLUmSEiSerMEJEkdWaISJI6M0QkSZ0ZIpKkzgwRSVJn2wyRJFcleX2Sh42iIEnS5OinJ3IE8BjgW0k+n+SFSTLkuiRJE2CbIVJVa6vqncCTgM8CZwE/TvKfkzx82AVKkuauvuZEkvwh8EHgL4AvAIcDvwQuHV5pkqS5btG2NkhyFfAL4EzgpKr653bVlUmeO8TaJElzXD89kcOrar+q+mxPgABQVYd2+dAkOyW5IMn3k1yf5NlT1ifJR5OsTXJtkr3a9j3aif5rN78myaIk/zvJ4i61SJK66ydEXplkp80LSR6W5L/M8nM/Any1qp4MPA24fsr6FwFPbB8nAJ9o218NvAk4EHhr2/Za4LyqunuWNUmS7qN+QuRFVfWLzQtV9XOa/8Q7SfJQ4Hk0w2NU1T297986BDinGlcAOyV5NLARWNw+NrbhdhBwTtd6JEndbXNOBNguyQ6bh7KSPBDYYRafuTtwB/BXSZ4GXAW8qap+1bPNUuCmnuUNbdvHaAJjB5peybuAU6pq09Y+MMkJND0ali1bNovSJUm9+umJfAa4JMnxSY4HLgbOnsVnLgL2Aj5RVc8AfgWc1M8Lq+rGqtqnqp4N3A3sClyf5Nwk5yd50gyvW1lVK6pqxZIlS2ZRuiSp1zZ7IlV1apJrgf3apvdV1UWz+MwNwIaqurJdvoAtQ+RmYLee5V3btl7vB04G3gh8ClgPnAIcNYvaJEn3QT/DWVTVV4CvDOIDq+q2JDcl2aOqfkATTt+bstlq4A1JPg88C7irqm7dvDLJHwO3VNUN7VFZm9qHR2hJ0gj1c57IocCpwC5A2kdV1UNm8bl/Cnwmyf2BdcArkryG5o3PAC6kmbxfSzNs9YqeekLTAzmibVpJM+S2iOZILUnSiPTTE/kAcFBVTT0Mt7OqugZYMaX5jJ71Bbx+htcW8IKe5etp5lgkSSPWz8T6TwYZIJKk+aOfnsiaJOcDXwJ+d8Z6Va0aVlGSpMnQT4g8hGZeYv+etgIMEUla4Po5xPcV29pGkrQw9XNnwycluSTJde3yHyY5efilSZLmun4m1j8JvJ3mulVU1bXAkcMsSpI0GfoJkcVV9XdT2u4dRjGSpMnST4j8NMnjaSbTSXIYcOvWXyJJWgj6OTrr9TRnhT85yc3Aj4Cjh1qVJGki9HN01jrg+UkeBNyvqv5x+GVJkiZBP9fOeveUZQCq6r1DqkmSNCH6Gc7qvVnUA4AXs+XtbCVJC1A/w1kf7F1Ochowm/uJSJLmiX6OzppqMc1NoiRJC1w/cyLfoT28F9gOWAI4HyJJ6mtO5MU9z++luTS8JxtKkvoKkamH9D5k8xFaAFV150ArkiRNjH5C5GpgN+DnNLfG3Qm4sV1XwOOGUpkkac7rJ0QuBr5YVRcCJHkR8CdV9eqhVjZB1q37IXvtddAW7cuX78KqVWeOoSJJGo1+QmTvqnrV5oWq+kqSDwyxpolzzz2wdOmXt2hfv37LYJGk+aSfELmlvX/Iee3yUcAtwytJkjQp+jlP5KU0h/V+keaWuEvaNknSAtfPGet3Am9K8qCq+tW2tpckLRz93B73OUm+R3u9rCRPS/LxoVcmSZrz+hnO+hDwQuBnAFX198DzhlmUJGky9HXtrKq6aUrTb4dQiyRpwvRzdNZNSZ4DVJLtgTfhpeAlSfTXE3kNzS1ylwI3A09vlyVJC9xWeyJJtgM+UlVHjageSdIE2WpPpKp+Czw2yf1HVI8kaYL0MyeyDvhGktX03Cq3qk4fWlWSpIkwY08kybnt04OB/9lu++CehyRpgdtaT+SZSR5Dc9n3vxz0B7fzLWuAm6vqxVPW7QCcAzyT5vyUI6pqfZLnAp8A7gFeWlU3JNkJ+GvggKraNOg6JUkz21qInAFcAuxO85/9ZmEw9xHZfKjwQ6ZZdzzw86p6QpIjgVOBI4ATgQOB5TRHjZ0InAycYoBI0ujNOJxVVR+tqj8A/qqqHtfz2L2qZhUgSXYF/g3wqRk2OQQ4u31+AbBfmtspbgQWt4+NSR4P7FZVl82mHklSN/1cgPG1Q/jcDwNvY+a5laXATe3n35vkLuARwJ/RDHP9GjgGOI2mJ7JVSU4ATgBYtmzZLEuXJG3W12VPBinJi4Hbq+qq+/raqrqmqvauqn1phtNubd4y5yc5L8kjZ3jdyqpaUVUrlixZMrsdkCT9Tj+H+A7ac4GDkxwIPAB4SJLzquronm1uprmv+4Yki4CH0l4AEprUoOmBHEkz6f82mnmSNwLvHMVOSNI4HXro8axff/sW7evW/ZilS0dXx8hDpKreDrwdIMk+wFunBAjAauA44JvAYcClVVU9648FLqyqO5MsBja1j8XDrV6S5ob162+f9rbc3//+niOtYxw9kWkleS+wpqpWA2cC5yZZC9xJ0+PYvN1i4OXA/m3T6cCFNIf9vmyUNUvSQjfWEGmPqrqsff7unvbfAIfP8Jq7gX17lv8GeOow65QkTW/kE+uSpPnDEJEkdWaISJI6M0QkSZ0ZIpKkzgwRSVJnc+Y8EUlaqGY6+xxg+fJdWLXqzBFX1D9DRJLGbKazz5t1B424mvvG4SxJUmeGiCSpM0NEktSZISJJ6swQkSR1ZohIkjozRCRJnRkikqTOPNlwTGY6Q3Wun50qSb0MkTGZ6QzVuX52qiT1MkQkaQ5bt+6H7LXXll8u1637MUuXjqGgKQwRSZrD7rmHaUctvv/9PcdQzZYMEUkTzfnF8TJEJE005xfHyxAZopnGMpt1049nzvQav1VJmosMkSGaaSwTZh7PnOk1fquSNBd5sqEkqTNDRJLUmSEiSerMOZEJ5+GNksbJEJlwHt4oaZwczpIkdWaISJI6czhrntraiY7Ol0galJGHSJLdgHOARwIFrKyqj0zZJsBHgAOBu4GXV9XVSfYAPgtsD7y6qr6ZZBHwVeDgqrp7hLsyp23tREfnSyQNyjh6IvcCJ7ah8GDgqiQXV9X3erZ5EfDE9vEs4BPtn68G3gSspwmZlwCvBc4zQOYnjz6T5raRh0hV3Qrc2j7/xyTXA0uB3hA5BDinqgq4IslOSR4NbAQWt4+NSXYCDgIOGOEuaIQ8+kya28Y6J5JkOfAM4Mopq5YCN/Usb2jbPkYzFLYDTa/kXcApVbVpG59zAnACwLJlywZRuqQ5zouZjsbYQiTJjsAXgDdX1S/7eU1V3Qjs077+CcCuwPVJzgXuD7yrqv5hmtetBFYCrFixogayA5LmNC9mOhpjCZEk29MEyGeqatU0m9wM7NazvGvb1uv9wMnAG4FP0cyTnAIcNeh6JQ2Wc13zxziOzgpwJnB9VZ0+w2argTck+TzNhPpd7VzK5vf4Y+CWqrohyWJgU/tYPNzqJQ2Cc13zxzh6Is8FjgG+k+Satu0dwDKAqjoDuJDm8N61NIf4vmLzi9sQOhk4om1aCXyGZl9eO/zyx2Om8d2Zbm4laXrOlQzWOI7O+lsg29imgNdvZd0LepavB/YaZI1z0UzjuzPd3ErS9JwrGSzPWNfAzTTeDX7bW2hm+l2wBz1/GCIauJnGu5t1fttbSGb6XbAHPX8YIguQY8KTayH38uZir8ajzAyRBckx4cm1kHt5c7FX41Fmhoj6MGnftiat3umM4lv3fPh7GqRRXPl6LvamZssQ0TZN2retSat3OqP41j0f/p4GaRRXvp6LvanZMkQ0UvNhPmYhz0uoPwvpvC5DRCM1H+ZjFvK8hPqzkM7rMkS04M3Us7jttg086lG7btG+tW+T86GnJd0XhogWvK2NUz/zmfft2+R86GlJ94UhogVjvo9TD6oXZG9qS/P9d2c2DBEtGPN9nHpQvSB7U1ua7787s2GI6HfG+W3Lb3qTbT6e/6D+GCL6nXF+2/Kb3mSbj+c/qD/3G3cBkqTJZYhIkjpzOEudzcU5lFF9/kI0ir9zf66TxxBRZ3NxDmVUn78QjeLv3J/r5DFEpBGY6Rt2l7PipbnEEJFGYGu9tvt6Vrw0lxgi0jznOTgaJkNEmuc8B0fD5CG+kqTODBFJUmeGiCSpM0NEktSZISJJ6swQkSR1ZohIkjozRCRJnRkikqTODBFJUmdjCZEkByT5QZK1SU6aZv0OSc5v11+ZZHnb/twk1yZZk+SJbdtOSb6WxECUpBEb+X+8SbYDPga8CNgTeGmSqRfxOR74eVU9AfgQcGrbfiJwIPBm4DVt28nAKVW1acilS5KmGMe3938FrK2qdVV1D/B54JAp2xwCnN0+vwDYL0mAjcDi9rExyeOB3arqspFULkn6Pamq0X5gchhwQFW9sl0+BnhWVb2hZ5vr2m02tMs/BJ4F7AqcAfwaOAY4DXhXVd2wjc88ATihXdwD+EHH8ncGftrxtZPKfV4YFto+L7T9hdnv82OrasnUxom6FHxVXQPsDZDkecCtzdOcT9NLObGqfjLN61YCK2f7+UnWVNWK2b7PJHGfF4aFts8LbX9hePs8juGsm4HdepZ3bdum3SbJIuChwM82r2yHtk4G3ge8B3gb8EngjUOrWpK0hXGEyLeAJybZPcn9gSOB1VO2WQ0c1z4/DLi0fn/c7Vjgwqq6k2Z+ZFP7WDzUyiVJv2fkw1lVdW+SNwAXAdsBZ1XVd5O8F1hTVauBM4Fzk6wF7qQJGgCSLAZeDuzfNp0OXAjcA7xsyOXPekhsArnPC8NC2+eFtr8wpH0e+cS6JGn+8AQ9SVJnhogkqTNDZBpdL8syqfrY33+f5HvtJWcuSfLYcdQ5SNva557tXpKkkkz84aD97HOSf9f+rL+b5LOjrnHQ+vjdXpbk60m+3f5+HziOOgclyVlJbm/PtZtufZJ8tP37uDbJXrP+0Kry0fOgmez/IfA44P7A3wN7TtnmdcAZ7fMjgfPHXfeQ93dfYHH7/LWTvL/97nO73YOBy4ErgBXjrnsEP+cnAt8GHtYu7zLuukewzyuB17bP9wTWj7vuWe7z84C9gOtmWH8g8BUgNOfcXTnbz7QnsqXZXJZlEm1zf6vq61V1d7t4Bc25PZOsn58xNOchnQr8ZpTFDUk/+/wq4GNV9XOAqrp9xDUOWj/7XMBD2ucPBW4ZYX0DV1WX0xzROpNDgHOqcQWwU5JHz+YzDZEtLQVu6lne0LZNu01V3QvcBTxiJNUNXj/72+t4mm8yk2yb+9x283erqv81ysKGqJ+f85OAJyX5RpIrkhwwsuqGo599/k/A0Uk20Jwq8KejKW1s7uu/922aqMueaLySHA2sAP543LUMU3tbgdNpzkdaSBbRDGntQ9PbvDzJU6vqF+MsasheCny6qj6Y5Nk056c9pbwqeN/siWxp1pdlmTD97C9Jng+8Ezi4qv55RLUNy7b2+cHAU4DLkqynGTtePeGT6/38nDcAq6tqY1X9CPgHmlCZVP3s8/HAXwNU1TeBB9BcqHC+6uvf+31hiGxpEJdlmSTb3N8kzwD+G02ATPo4OWxjn6vqrqrauaqWV9Vymnmgg6tqzXjKHYh+fq+/RNMLIcnONMNb60ZY46D1s883AvsBJPkDmhC5Y6RVjtZq4Nj2KK29gbuq6tbZvKHDWVPULC/LMmn63N+/AHYE/nt7/MCNVXXw2IqepT73eV7pc58vAvZP8j3gt8B/qKpJ7WH3u88nAp9M8haaSfaXT/AXQpJ8juaLwM7tPM97gO0BquoMmnmfA4G1wN3AK2b9mRP89yVJGjOHsyRJnRkikqTODBFJUmeGiCSpM0NEktSZISINQJLfJrmm57E8yf+dYdtPJzlsG+/3u22SfCrJnu3zdwy+eqk7zxORBuPXVfX0KW3PGcQbV9UrexbfAZwyiPeVBsEQkYYkyT9V1Y7tFZ7/EngBzcXv7unZ5pk01+naEfgpzclut055n8uAt9JcHeGBSa4BvktzmfM7q+rD7XbvB26vqo8Md8+k/8/hLGkwHtgzlPXFKev+LbAHzf0qjqXtoSTZniZcDquqZwJnAe+f6QOq6iTaHk9VHdVuf2z7XvejuXLCeYPdLWnr7IlIgzHdcNZmzwM+V1W/BW5JcmnbvgfNhR4vbi8nsx3Q93WMqmp9kp+11zZ7JPDtSb5MiSaTISKNT4DvVtWzZ/Een6K5ZP2jaHom0kg5nCUN3+XAEUm2a+8it2/b/gNgSXsfC5Jsn+RfbOO9NrbDYJt9ETgA+Jc0FxqURsqeiDR8XwT+NfA9mkuPfxOgqu5pD+P9aJKH0vx7/DDNpPlMVgLXJrm6qo5q3+PrwC/a4TJppLyKrzTB2gn1q4HDq+qGcdejhcfhLGlCtScgrgUuMUA0LvZEJEmd2RORJHVmiEiSOjNEJEmdGSKSpM4MEUlSZ/8P3P8TD53nHzcAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 定义计算量子神经网络输出保真度分布的函数\n", + "def p_F_qnn(n, s, g, b=50, draw=False):\n", + " f_list = list()\n", + " rho_sample = outputs_y\n", + " title_str = \"Ry\"\n", + " if g == 2:\n", + " rho_sample = outputs_yz\n", + " title_str = \"Ry-Rz\"\n", + " elif g == 3:\n", + " rho_sample = outputs_yzy\n", + " title_str = \"Ry-Rz-Ry\"\n", + " # 使用之前采样的数据计算保真度分布\n", + " for index in range(int(s / 2)):\n", + " rho1 = rho_sample[index]\n", + " rho2 = rho_sample[index+int(num_sample / 2)]\n", + " f_list.append(state_fidelity(rho1, rho2)**2)\n", + " f_list = np.array(f_list)\n", + " # 绘制概率分布图\n", + " if draw:\n", + " plot_hist(f_list, b, title_str)\n", + " distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", + " return distribution\n", + " \n", + " \n", + "num_qubit = 1\n", + "p_y = p_F_qnn(num_qubit, num_sample, 1, draw=True)\n", + "p_yz = p_F_qnn(num_qubit, num_sample, 2, draw=True)\n", + "p_yzy = p_F_qnn(num_qubit, num_sample, 3, draw=True)" + ] + }, + { + "cell_type": "markdown", + "id": "18e05d9e", + "metadata": {}, + "source": [ + "可见，$R_Y-R_Z-R_Y$ 门组成的神经网络的输出保真度分布与均匀酉矩阵的表现最为接近。统计数学中的 K-L 散度（也称相对熵）可以衡量两个概率分布之间的差异。两个离散概率分布 $P,Q$ 之间的 K-L 散度定义为\n", + "$$\n", + "D_{KL}(P||Q)=\\sum_jP(j)\\ln\\frac{P(j)}{Q(j)}.\\tag{6}\n", + "$$\n", + "如果将量子神经网络输出的保真度分布记为 $P_\\text{QNN}(f)$，则量子神经网络的表达能力定义为 $P_\\text{QNN}(f)$ 和 $P_\\text{Haar}(f)$ 之间的 K-L 散度 [2]：\n", + "$$\n", + "\\text{Expr}_\\text{QNN}=D_{KL}(P_\\text{QNN}(f)||P_\\text{Haar}(f)).\\tag{7}\n", + "$$\n", + "因此，当 $P_\\text{QNN}(f)$ 越接近 $P_\\text{Haar}(f)$ 时，$\\text{Expr}$ 将越小（越趋近于 0），量子神经网络的表达能力也就越强；反之，$\\text{Expr}$ 越大，量子神经网络的表达能力也就越弱。\n", + "\n", + "我们可以根据该定义直接计算单比特量子神经网络 $R_Y(\\theta)$，$R_Y(\\theta_1)R_Z(\\theta_2)$ 和 $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 的表达能力：" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "1d73cffe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ry，Ry-Rz，和 Ry-Rz-Rz 神经网络的表达能力分别为 0.24，0.03，和 0.01。\n" + ] + } + ], + "source": [ + "from scipy.stats import entropy\n", + "# 使用 scipy 的 entropy 函数计算相对熵（即 K-L 散度）\n", + "expr_y = entropy(p_y, theory_haar_1qubit)\n", + "expr_yz = entropy(p_yz, theory_haar_1qubit)\n", + "expr_yzy = entropy(p_yzy, theory_haar_1qubit)\n", + "print(\"Ry，Ry-Rz，和 Ry-Rz-Rz 神经网络的表达能力分别为 %.2f，%.2f，和 %.2f。\" %(expr_y, expr_yz, expr_yzy))" + ] + }, + { + "cell_type": "markdown", + "id": "e33d696a", + "metadata": {}, + "source": [ + "### 评估量子神经网络拟设的表达能力" + ] + }, + { + "cell_type": "markdown", + "id": "763d2532", + "metadata": {}, + "source": [ + "现在，我们拥有了定量研究任何量子神经网络拟设表达能力的工具——K-L 散度。作为一个实际应用，我们来探究量桨内置拟设 complex_entangled_layer 的表达能力随电路深度的变化。这里我们设置电路的宽度为 4-qubit。" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "c557d91a", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "哈尔采样输出的保真度服从分布：\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEWCAYAAACnlKo3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAcVklEQVR4nO3de5wdZYHm8d9DCJHIfQgIDbERkV3GQYxZQF0Qh4uYjxBFBBG5DRhUWMFFZxgFYUFYr4h4wwhRQFTcIWgYUcyCDKsjLCFiuMkSehrJBRIMtxE1CXn2j6pmDt2n05VKnz453c/38zmfVL31VtX75tJP6n2r6sg2ERERdWzU7gZERETnSohERERtCZGIiKgtIRIREbUlRCIioraESERE1JYQiVFJUq+kg9rdjpEmyZJePci2YyX9fIj9J0h6QNIOQ9TbU9K/rk9bY3RIiESMEEmbSHpQ0qJ2nN/2tbYPaWhPs8CZAdxue+kQx1oAPC3psBY0NTpIQiRiPUjaeB2qfxxY3qq2DJMPAtdUrHstcGoL2xIdICESo9lekhZIekbSdZJeBiBpa0n/LGm5pKfK5Z36dpJ0UnnF8JykHkmnNmw7QNIiSf8g6XHg21UaImkX4P3A/6xQ9+OSlkpaIunvGq8YJN0m6ZSGuidK+mW/Q0wr2/2kpM9L2qh/XUm3l3V/K+nfJR0taTLwKuDOhuNPK4e3npO0WNLHGs5zG3CgpAlVfg9idEqIxGh2FHAosAuwJ3BiWb4RxQ//VwKTgT8BX23YbxnwDmAL4CTgS5KmNGx/BbBNuf+Mim35CvCJ8lyDknQo8DHgYGA3oM68zruAqcAUYDrwd/0r2N6/XHyd7c1sXwf8DdBje3VD1SuBU21vDrwWuLXhGIuBVcDuNdoYo0RCJEazy2wvsb0CuBHYC8D2H2xfb/t5288BFwFv6dvJ9k9sP+LCvwA/B/ZrOO4a4Dzbf7G91lAAkPQuYJztGyq0+Sjg27bvs/1H4PxqXX2Jz9peYfv3wKXAMRX32wp4rl/ZKmAPSVvYfsr2/H7bnyv3izEqIRKj2eMNy88DmwFImijpm5IelfQscDuwlaRx5fa3S7pD0gpJTwPTgG0bjrXc9p+rNEDSy4HPAR+p2OYdgcca1h+tuF+j/vvvWHG/p4DN+5W9m6L/j0r6F0lv7Ld9c+DpGm2MUSIhEmPRWRRDMPvY3gLoG9pROb5/PfAFYHvbWwE3AWrYf11efb0b0A38n3IOZTawg6THJXU3qb8U2LlhfXK/7X8EJjasv6LJMfrvv6RiWxcAuzTeLGD7LtvTge2AHwE/7NsmqQvYBHio4vFjFEqIxFi0OcXcxNOStgHOa9i2CTCB4i6q1ZLeDhwy8BAvVU5+H9Bk030UP9T3Kj+nAE+Uy481qf9D4ERJe0ia2K9tAPcAR5RXU68GTm5yjI+XNw/sDJwBXDdIs5+gmEgHwPYiYCGwd9mnTcpnS7a0vQp4lmIor89bgFtt/2WQ48cYkBCJsehSYFPgSeAO4Gd9G8o5ko9Q/DB/CngfMGdtByt/WD8H3Nt/m+3Vth/v+wArgDXl+gtN6v+0bN+tFD/Qb+1X5UvASooAuIriNtv+fgzcTRE4P6GYHG/mfOAqSU9LOqos+yZwXEOd44Dectjvg8CxDduOBS4f5NgxRihfShWxfiS9H/hr2//YouMb2M32wlYcv9+5JgC/AQ5c2wOHkvYEvmm7/xxJjDEJkYgN3EiGSMS6ynBWRETUliuRiIioLVciERFR27q8PG5U2Hbbbd3d3d3uZkREdJS77777SduT+pePuRDp7u5m3rx57W5GRERHkdT07QkZzoqIiNoSIhERUVtCJCIiakuIREREbQmRiIioLSESERG1JUQiIqK2hEhERNSWEImIiNrG3BPr6+OII06mt3fZgPLu7u2YPXuw7/2JiBi9EiLroLd3GV1dNzYpP6wNrYmIaL8MZ0VERG0JkYiIqK1lISJpZ0m/kPSApPslnVGWny9psaR7ys+0QfY/VNJDkhZKOruh/FpJCyRd3FB2jqR3tqovERHRXCvnRFYDZ9meL2lz4G5Jc8ttX7L9hcF2lDQO+BpwMLAIuEvSnLK9f7K9p6S5krYEJgL72P50C/sSERFNtOxKxPZS2/PL5eeAB4GuirvvDSy03WN7JfADYDqwCthU0kbAeOAF4ALgvOFuf0REDG1E5kQkdQOvB+4si04vh6RmSdq6yS5dwGMN64uALtsPAsuB+cCNwKuBjfrCai3nnyFpnqR5y5cvX8/eREREn5aHiKTNgOuBM20/C3wD2BXYC1gKfHFdjmf7TNt72f4icCFwrqRPSvqhpA8Mss9M21NtT500acC3O0ZERE0tDRFJ4ykC5FrbswFsP2H7BdtrgG9RDF31txjYuWF9p7Ks8djTgbuBzYBdbR8FHClp4vD3JCIimmnl3VkCrgQetH1JQ/kODdXeBdzXZPe7gN0k7SJpE+C9wJyGY4wHzgQ+B2wKuNw0DthkGLsRERFr0cq7s94MHAfcK+mesuwTwDGS9qL4wd8LnAogaUfgCtvTbK+WdDpwM0UwzLJ9f8OxTwOusv28pAXAREn3AjfZfrqFfYqIiAYtCxHbvwTUZNNNg9RfAkxrWL9pLXUvbVg2cMz6tDUiIurJE+sREVFbQiQiImpLiERERG0JkYiIqC0hEhERtSVEIiKitoRIRETUlhCJiIjaEiIREVFbQiQiImpLiERERG0JkYiIqC0hEhERtSVEIiKitoRIRETUlhCJiIjaEiIREVFbQiQiImpLiERERG0JkYiIqC0hEhERtSVEIiKitoRIRETUlhCJiIjaEiIREVFbQiQiImpLiERERG0JkYiIqC0hEhERtSVEIiKitoRIRETU1rIQkbSzpF9IekDS/ZLOKMu3kTRX0sPlr1sPsv8JZZ2HJZ1Qlk2Q9DNJ90n6cEPdmZKmtKovERHRXCuvRFYDZ9neA9gXOE3SHsDZwC22dwNuKddfQtI2wHnAPsDewHll2LwN+CWwJ3BcWfd1wDjb81vYl4iIaKJlIWJ7ad8PdtvPAQ8CXcB04Kqy2lXAO5vs/jZgru0Vtp8C5gKHAquAicB4QGXdC4FzW9SNiIhYixGZE5HUDbweuBPY3vbSctPjwPZNdukCHmtYX1SWzQW6gTuAyyQdDsy3vWSI88+QNE/SvOXLl69PVyIiosHGrT6BpM2A64EzbT8r6cVtti3JVY9lezXwvvK444GbgemSLgEmA1fbntNkv5nATICpU6dWPl9VPT2PMGXKYQPKu7u3Y/bsK4f7dBERG4yWhkj5g/564Frbs8viJyTtYHuppB2AZU12XQwc0LC+E3BbvzofBq6mmG95BjgauBUYECKttnIldHXdOKC8t3dgsEREjCatvDtLwJXAg7Yvadg0BzihXD4B+HGT3W8GDpG0dTmhfkhZ1nfsrYF3UITIRGANYGDT4e5HREQMrpVzIm+muIPqbyXdU36mAZ8BDpb0MHBQuY6kqZKuALC9gmLC/K7yc0FZ1udTwEW211CEy37AvcA1LexPRET007LhLNu/5D/uoOrvwCb15wGnNKzPAmYNcuyPNiz/meJKJSIiRlieWI+IiNoSIhERUVtCJCIiakuIREREbQmRiIioLSESERG1JUQiIqK2hEhERNSWEImIiNoSIhERUVtCJCIiakuIREREbQmRiIioLSESERG1JUQiIqK2hEhERNSWEImIiNoSIhERUVtCJCIiakuIREREbQmRiIioLSESERG1JUQiIqK2IUNE0t2STpO09Ug0KCIiOkeVK5GjgR2BuyT9QNLbJKnF7YqIiA4wZIjYXmj7k8BrgO8Bs4BHJf0PSdu0uoEREbHhqjQnImlP4IvA54HrgfcAzwK3tq5pERGxodt4qAqS7gaeBq4Ezrb9l3LTnZLe3MK2RUTEBm7IEAHeY7un2QbbRwxzeyIiooNUGc46RdJWfSuStpb06dY1KSIiOkWVEHm77af7Vmw/BUxrWYsiIqJjVAmRcZIm9K1I2hSYsJb6ffVmSVom6b6GsvMlLZZ0T/lpGkaSDpX0kKSFks5uKL9W0gJJFzeUnSPpnRX6ERERw6zKnMi1wC2Svl2unwRcVWG/7wBfBa7uV/4l218YbCdJ44CvAQcDiyieT5lTtvVPtveUNFfSlsBEYB/bGV6LiGiDIUPE9mclLQAOLIsutH1zhf1ul9Rdo017Awv7JvMl/QCYDvwI2FTSRsB44AXgAuC8GucYET09jzBlymFNt3V3b8fs2VeOcIsiIoZXlSsRbP8U+OkwnfN0SccD84CzyjmWRl3AYw3riyiuNh6UtByYD1wDvBrYyPb8oU4oaQYwA2Dy5MnD0IVqVq6Erq4bm27r7W0eLhERnaTKu7OOkPSwpGckPSvpOUnP1jzfN4Bdgb2ApRQPMFZm+0zbe9n+InAhcK6kT0r6oaQPrGW/mban2p46adKkmk2PiIj+qkysfw443PaWtrewvbntLeqczPYTtl+wvQb4FsXQVX+LgZ0b1ncqy14kaTpwN7AZsKvto4AjJU2s066IiKinSog8YfvB4TiZpB0aVt8F3Nek2l3AbpJ2kbQJ8F5gTsMxxgNnUoTbpoDLTeOATYajnRERUU2VOZF5kq6jmNjue+UJtmevbSdJ3wcOALaVtIhiAvwASXtR/ODvBU4t6+4IXGF7mu3Vkk4HbqYIhlm272849GnAVbafLyf8J0q6F7ip8XmWiIhovSohsgXwPHBIQ5mBtYaI7WOaFDe9Hcn2EhoeYLR9E3DTIHUvbVg20Ow8ERExAqrc4nvSSDQkIiI6T5W7s14j6Za+J88l7SnpnNY3LSIiNnRVJta/BfwjsArA9gKKye6IiBjjqoTIRNv/t1/Z6lY0JiIiOkuVEHlS0q6Ut9JKOpLiQcGIiBjjqtyddRowE/hPkhYD/wa8v6WtioiIjlDl7qwe4CBJL6d4V9VzrW9WRER0girfsf6pfusA2L6gRW2KiIgOUWU4648Nyy8D3gEMy2tQIiKis1UZznrJm3YlfYHilSQRETHGVbk7q7+JFG/WjYiIMa7KnMi9vPRNuZMovlEwIiLGuCpzIu9oWF5N8Wr4PGwYERGVQqT/Lb1b9N2hBWB7xbC2KCIiOkaVEJlP8U2DTwECtgJ+X24z8KqWtCwiIjZ4VSbW5wKH2d7W9l9RDG/93PYuthMgERFjWJUQ2bf8kigAbP8UeFPrmhQREZ2iynDWkvL7Q75brh8LLGldkyIiolNUuRI5huK23hsovhJ3EvlK2oiIoNoT6yuAMyS93PYfh6ofERFjR5Wvx32TpAco35cl6XWSvt7ylkVExAavynDWl4C3AX8AsP1bYP9WNioiIjpDpXdn2X6sX9ELLWhLRER0mCp3Zz0m6U2AJY0HziCvgo+ICKpdiXyQ4ityu4DFwF7lekREjHFrvRKRNA74su1jR6g9ERHRQdZ6JWL7BeCVkjYZofZEREQHqTIn0gP8StIcGr4q1/YlLWtVRER0hEGvRCRdUy4eDvxzWXfzhk9ERIxxa7sSeYOkHSle+/6VEWpPRER0kLWFyOXALcAuwLyGcpHvEYmICNYSIrYvAy6T9A3bH1rXA0uaRfHdI8tsv7Ys2wa4DugGeoGjbD/VZN8TgHPK1U/bvkrSBODHwE7A121/vaw7E7jc9vx1bWM79fQ8wpQphw0o7+7ejtmzr2xDiyIi1l2VFzCuc4CUvgN8Fbi6oexs4Bbbn5F0drn+D407lUFzHjCV4orn7nJSfz/gl8DFwK+Ar0t6HTCu0wIEYOVK6Oq6cUB5b+/AYImI2FBVeu1JHbZvB/p///p04Kpy+SrgnU12fRsw1/aK8iplLnAosAqYCIynGFIDuBA4d3hbHhERVbUsRAaxve2l5fLjwPZN6nQBje/qWlSWzaUYBruDYpjtcGC+7SG/IEvSDEnzJM1bvnz5+rQ/IiIaVHlOpCVsW5LXof5q4H0A5Tu8bgamS7oEmAxcbXvOIPvOBGYCTJ06tfI5IyJi7Ub6SuQJSTsAlL8ua1JnMbBzw/pOZVmjD1PMtewLPAMcDZw17K2NiIi1GukQmQOcUC6fQHG3VX83A4dI2lrS1sAhZRkAZdk7KEJkIrCGYgJ+0xa2OyIimmhZiEj6PvBrYHdJiySdDHwGOFjSw8BB5TqSpkq6Al78Ot4LgbvKzwVlWZ9PARfZXkMRLvsB9wLXEBERI6plcyK2jxlk04FN6s4DTmlYnwXMGuS4H21Y/jPFlUpERLTBSA9nRUTEKJIQiYiI2hIiERFRW0IkIiJqS4hERERtCZGIiKgtIRIREbUlRCIioraESERE1JYQiYiI2hIiERFRW0IkIiJqS4hERERtCZGIiKgtIRIREbUlRCIioraESERE1JYQiYiI2hIiERFRW8u+Yz3q6el5hClTDhtQ3t29HbNnX9mGFkVEDC4hsoFZuRK6um4cUN7bOzBYIiLaLcNZERFRW0IkIiJqS4hERERtCZGIiKgtIRIREbXl7qwOd8QRJ9Pbu6zpttwWHBGtlhDpcL29y5reElxsy23BEdFaGc6KiIjaciXSIQZ7kr2n51G6utrQoIgIEiIdY7An2X/3uz3a0JqIiEJbhrMk9Uq6V9I9kuY12S5Jl0laKGmBpCll+e6S7i7L3liWbSzpf0uaONL9iIgY69p5JfJW208Osu3twG7lZx/gG+WvpwJnAL3Al4F3Ax8Cvmv7+VY3OCIiXmpDHc6aDlxt28AdkraStAOwCphYflZJ2go4DDi0bS2NiBjD2hUiBn4uycA3bc/st70LeKxhfVFZ9jXgamACxVXJucDFttes7WSSZgAzACZPnjwsHYiIiPbd4vtfbU+hGLY6TdL+VXay/XvbB9h+I/A8sBPwoKRrJF0n6TWD7DfT9lTbUydNmjRsnYiIGOvaEiK2F5e/LgNuAPbuV2UxsHPD+k5lWaOLgHOAjwBXAH8PnNeK9kZERHMjHiKSXi5p875l4BDgvn7V5gDHl3dp7Qs8Y3tpwzHeAiyx/TDF/Mia8pM7tCIiRlA75kS2B26Q1Hf+79n+maQPAti+HLgJmAYspBi2OqlvZxU7ngMcXRbNBK4tj/WhEepDRETQhhCx3QO8rkn55Q3LBk4bZH8DBzesPwhMGf6WRkTEUPLurIiIqC0hEhERtSVEIiKitoRIRETUlhCJiIjaEiIREVFbQiQiImpLiERERG0JkYiIqC0hEhERtSVEIiKitg31mw1jGPT0PMKUKYcNKO/u3o7Zs69sQ4siYrRJiIxiK1dCV9eNA8p7ewcGS0REHRnOioiI2nIlMgZlmCsihktCZAzKMFdEDJcMZ0VERG0JkYiIqC0hEhERtSVEIiKitoRIRETUlhCJiIjaEiIREVFbnhOJIR1xxMn09i4bUJ6HEyMiIRIvGuxJ9p6eR9lvvwUDyvNwYkQkROJFgz3J/rvf7dGG1kREJ8icSERE1JYQiYiI2jKcFS2RyfiIsSEhEi3R27ssbwqOGAMSIlHbYHdzFdsepaur+j65QonoTG0JEUmHAl8GxgFX2P5Mv+0TgKuBNwB/AI623SvpzcA3gJXAMbYflrQV8EPgUNtrRrAbY95gd3PB4Hd05btMIkaXEQ8RSeOArwEHA4uAuyTNsf1AQ7WTgadsv1rSe4HPAkcDZwHTgG7gg+X6OcDFCZDOliuUiM7UjiuRvYGFtnsAJP0AmA40hsh04Pxy+Z+Ar0oSsAqYWH5WSdoV2Nn2bSPT9GiVdb1CGWziHuDxxxfxilfsVLk8QRVRn2yP7AmlIymGnk4p148D9rF9ekOd+8o6i8r1R4B9gJ2Ay4E/AccBXwDOtf3wEOecAcwoV3cHHqrZ/G2BJ2vu26nS57EhfR791re/r7Q9qX9hR02s274H2BdA0v7A0mJR11FcpZxl+4km+80EZq7v+SXNsz11fY/TSdLnsSF9Hv1a1d92PGy4GNi5YX2nsqxpHUkbA1tSTLBTloliLuRC4Dzg74FvAR9pWasjImKAdoTIXcBuknaRtAnwXmBOvzpzgBPK5SOBW/3ScbfjgZtsr6CYH1lTfia2tOUREfESIz6cZXu1pNOBmylu8Z1l+35JFwDzbM8BrgSukbQQWEERNABImgicCBxSFl0C3ERx2+/7Wtz89R4S60Dp89iQPo9+LenviE+sR0TE6JEXMEZERG0JkYiIqC0h0oSkQyU9JGmhpLObbJ8g6bpy+52SutvQzGFVoc//XdIDkhZIukXSK9vRzuE0VJ8b6r1bkiV19O2gVfor6ajyz/l+Sd8b6TYOtwp/rydL+oWk35R/t6e1o53DSdIsScvK5+2abZeky8rfkwWSpqzXCW3n0/ChmOx/BHgVsAnwW2CPfnU+DFxeLr8XuK7d7R6BPr8VmFguf2gs9LmstzlwO3AHMLXd7W7xn/FuwG+Arcv17drd7hHo80zgQ+XyHkBvu9s9DP3eH5gC3DfI9mnATwFRPHd35/qcL1ciA734WhbbK4G+17I0mg5cVS7/E3Bg+exKpxqyz7Z/Yfv5cvUOiud7OlmVP2conkX6LPDnkWxcC1Tp7weAr9l+CsB28/fKdI4qfTawRbm8JbBkBNvXErZvp7irdTDTgatduAPYStIOdc+XEBmoC3isYX1RWda0ju3VwDPAX41I61qjSp8bnUzxP5lONmSfy8v8nW3/ZCQb1iJV/oxfA7xG0q8k3VG+bbuTVenz+cD7JS2ieFTgv41M09pqXf+9r1VHvfYk2k/S+4GpwFva3ZZWkrQRxTNIJ7a5KSNpY4ohrQMorjRvl/Q3tp9uZ6Na7BjgO7a/KOmNFM+nvdZ5K3hluRIZaL1fy9KBqvQZSQcBnwQOt/2XEWpbqwzV582B1wK3SeqlGDue08GT61X+jBcBc2yvsv1vwP+jCJVOVaXPJ1N8HxG2fw28jOJFhaNZpX/vVSVEBhqO17J0miH7LOn1wDcpAqTTx8phiD7bfsb2tra7bXdTzAMdbntee5q73qr8vf4RxVUIkralGN7qGcE2Drcqff49cCCApP9MESLLR7SVI28OcHx5l9a+wDO2l9Y9WIaz+vF6vpalE1Xs8+eBzYD/Vd5D8Hvbh7et0eupYp9HjYr9vRk4RNIDwAvAx2137BV2xT6fBXxL0kcpJtlP7PD/ECLp+xT/Gdi2nOs5DxgPYPtyirmfacBC4HngpPU6X4f/fkVERBtlOCsiImpLiERERG0JkYiIqC0hEhERtSVEIiKitoRIxDCQ9IKkexo+3ZL+dZC635F05BDHe7GOpCsk7VEuf2L4Wx9RX54TiRgef7K9V7+yNw3HgW2f0rD6CeDi4ThuxHBIiES0iKR/t71Z+YbnrwAHU7z4bmVDnTdQvKNrM+BJiofdlvY7zm3AxyjejrCppHuA+ylec77C9qVlvYuAZba/3NqeRfyHDGdFDI9NG4aybui37V3A7hTfV3E85RWKpPEU4XKk7TcAs4CLBjuB7bMpr3hsH1vWP7481kYUb0747vB2K2LtciUSMTyaDWf12R/4vu0XgCWSbi3Ld6d4yePc8lUy44DK7zCy3SvpD+V7zbYHftPJrymJzpQQiWgfAffbfuN6HOMKitfVv4LiyiRiRGU4K6L1bgeOljSu/Aa5t5blDwGTyu+xQNJ4SX89xLFWlcNgfW4ADgX+C8WLBiNGVK5EIlrvBuBvgQcoXj3+awDbK8vbeC+TtCXFv8dLKSbNBzMTWCBpvu1jy2P8Ani6HC6LGFF5i29EBysn1OcD77H9cLvbE2NPhrMiOlT5AOJC4JYESLRLrkQiIqK2XIlERERtCZGIiKgtIRIREbUlRCIioraESERE1Pb/AQ4+EaPVHH0hAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "正在采样深度为 1 的电路...\n", + " 采样第 0 个样本...\n", + " 采样第 400 个样本...\n", + " 采样第 800 个样本...\n", + " 采样第 1200 个样本...\n", + " 采样第 1600 个样本...\n", + " 采样完毕\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "正在采样深度为 2 的电路...\n", + " 采样第 0 个样本...\n", + " 采样第 400 个样本...\n", + " 采样第 800 个样本...\n", + " 采样第 1200 个样本...\n", + " 采样第 1600 个样本...\n", + " 采样完毕\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "正在采样深度为 3 的电路...\n", + " 采样第 0 个样本...\n", + " 采样第 400 个样本...\n", + " 采样第 800 个样本...\n", + " 采样第 1200 个样本...\n", + " 采样第 1600 个样本...\n", + " 采样完毕\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "深度为 1,2,3 的神经网络的表达能力分别为 [0.2949 0.0234 0.0077]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 定义计算保真度分布的函数\n", + "def p_F_cel(n, d, s, b=50, draw=False):\n", + " pq.set_backend('state_vector')\n", + " f_list = list()\n", + " for index in range(int(s / 2)):\n", + " if 2 * index % 400 == 0:\n", + " print(\" 采样第 %d 个样本...\" % (2 * index))\n", + " cir1 = Circuit(n)\n", + " # 作用 complex_entangled_layer 层\n", + " cir1.complex_entangled_layer('full', n, d)\n", + " # 输出态的态矢量\n", + " rho1 = cir1(pq.state.zero_state(n))\n", + " \n", + " cir2 = Circuit(n)\n", + " # 作用 complex_entangled_layer 层\n", + " cir2.complex_entangled_layer('full', n, d)\n", + " # 输出态的态矢量\n", + " rho2 = cir2(pq.state.zero_state(n))\n", + " \n", + " # 计算保真度\n", + " f_list.append(abs(np.inner(rho1.data.numpy(), rho2.data.numpy().conj())**2))\n", + " \n", + " print(\" 采样完毕\")\n", + " f_list = np.array(f_list)\n", + " # 绘制概率分布图\n", + " if draw:\n", + " title_str = \"complex entangled layer, %d layer(s)\" % d\n", + " plot_hist(f_list, b, title_str)\n", + " distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", + " return distribution\n", + "\n", + "\n", + "# 设置电路宽度和最大深度\n", + "num_qubit = 4\n", + "max_depth = 3\n", + "# 计算哈尔采样对应的保真度分布\n", + "print(\"哈尔采样输出的保真度服从分布：\")\n", + "p_haar_4qubit, theory_haar_4qubit = p_F_haar(num_qubit, num_sample, draw=True)\n", + "Expr_cel = list()\n", + "# 计算不同深度的神经网络的表达能力\n", + "for DEPTH in range(1, max_depth + 1):\n", + " print(\"正在采样深度为 %d 的电路...\" % DEPTH)\n", + " p_cel = p_F_cel(num_qubit, DEPTH, num_sample, draw=True)\n", + " expr = entropy(p_cel, theory_haar_4qubit)\n", + " Expr_cel.append(expr)\n", + "# 比较不同深度的神经网络的表达能力\n", + "print(\"深度为 1,2,3 的神经网络的表达能力分别为\", np.around(Expr_cel, decimals=4))\n", + "plt.plot(range(1, max_depth + 1), Expr_cel, marker='>')\n", + "plt.xlabel(\"depth\")\n", + "plt.yscale('log')\n", + "plt.ylabel(\"Expr.\")\n", + "plt.xticks(range(1, max_depth + 1))\n", + "plt.title(\"Expressibility vs Circuit Depth\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2f1b3485", + "metadata": {}, + "source": [ + "可见随着电路深度的增加，量子神经网络的表达能力也在逐渐增强。感兴趣的读者不妨自己动手尝试一下其他量桨内置拟设的表达能力计算，以及比较不同拟设之间表达能力的差别。" + ] + }, + { + "cell_type": "markdown", + "id": "9e5dd645", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Nielsen, Michael A., and Isaac L. Chuang. \"Quantum Computation and Quantum Information.\" Cambridge University Press, 2010.\n", + "\n", + "[2] Sim, Sukin, Peter D. Johnson, and Alán Aspuru‐Guzik. \"Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum‐classical algorithms.\" [Advanced Quantum Technologies 2.12 (2019): 1900070](https://onlinelibrary.wiley.com/doi/abs/10.1002/qute.201900070)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/qnn_research/Expressibility_EN.ipynb b/tutorials/qnn_research/Expressibility_EN.ipynb new file mode 100644 index 0000000..8bcc83b --- /dev/null +++ b/tutorials/qnn_research/Expressibility_EN.ipynb @@ -0,0 +1,705 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "caeb98e4", + "metadata": {}, + "source": [ + "# Expressibility of Quantum Neural Network\n", + "\n", + "Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved." + ] + }, + { + "cell_type": "markdown", + "id": "e2ca4dd8", + "metadata": {}, + "source": [ + "## Overview" + ] + }, + { + "cell_type": "markdown", + "id": "64692af7", + "metadata": {}, + "source": [ + "In quantum machine learning, the **expressibility** of quantum neural networks is a crucial factor in quantum machine learning tasks. In general, the stronger the expressiveness of the proposed quantum neural network, the higher the likelihood that quantum machine learning can search for the global optimal solution. This tutorial first introduces the basic concept of the expressibility of quantum neural networks. Then we will show how to exhibit the difference in the expressibility of different ansatz through Bloch spheres in Paddle Quantum. Finally, a method for quantitatively analyzing the expressibility of quantum neural networks is introduced, and the expressibility of quantum neural network templates provided by Paddle Quantum is evaluated at different depths." + ] + }, + { + "cell_type": "markdown", + "id": "482a9afe", + "metadata": {}, + "source": [ + "## Background" + ] + }, + { + "cell_type": "markdown", + "id": "1ddbe430", + "metadata": {}, + "source": [ + "Let us first review the basic process of quantum machine learning algorithms. In quantum machine learning, we tend to design a loss function $\\mathcal{L}$ and minimize the loss function by optimizing a unitary $U$\n", + "\n", + "$$\n", + "\\min_U\\mathcal{L}(U)=\\min_U \\text{Tr}[HU\\rho_{in}U^\\dagger].\\tag{1}\n", + "$$\n", + "\n", + "The mathematical principle behind the algorithm guarantees that the minimum value that the loss function can take corresponds to the solution of our problem when we have traversed all possible unitaries. In practice, we use quantum neural networks to parameterize the unitaries as follows\n", + "\n", + "$$\n", + "U=U(\\vec{\\theta})=U_D(\\vec{\\theta}_D)\\dots U_1(\\vec{\\theta}_1),\\tag{2}\n", + "$$\n", + "\n", + "where each $U_j(\\vec{\\theta}_j),j\\in[1,D]$ represents a layer of the quantum neural network, and $\\vec{\\theta}_j$ represents the parameters corresponding to that layer. At this point, by adjusting the parameters $\\vec{\\theta}$ in the quantum neural network, we can perform the optimization of the unitary $U$ and thus minimize the loss function $\\mathcal{L}$.\n", + "\n", + "$$\n", + "\\min_{\\vec{\\theta}}\\mathcal{L}(\\vec{\\theta})=\\min_{\\vec{\\theta}} \\text{Tr}[HU(\\vec{\\theta})\\rho_{in}U(\\vec{\\theta})^\\dagger].\\tag{3}\n", + "$$\n", + "\n", + "However, careful readers may have noticed a shortcoming of quantum neural networks at this point: for a given neural network fit, ** traversing all the parameters does not necessarily guarantee traversing all the unitaries**. As a simple example, if we allow only one $R_Y$ rotation gate as a single-qubit quantum neural network $U(\\theta)=R_Y(\\theta)$, it is clear that (up to a global phase) $U(\\theta)$ cannot represent any complex unitary with the imaginary part of matrix elements. And when allowing the use of $R_Y$ and $R_Z$ revolving gates, if we build the quantum neural network as $U(\\vec{\\theta})=R_Z(\\theta_1)R_Y(\\theta_2)R_Z(\\theta_3)$, $U(\\vec{\\theta})$ (up to a global phase) will be able to represent all the single-qubit unitaries [1].\n", + "\n", + "If we define the expressibility of a neural network as **the number of unitaries that the circuit can express when traversing the circuit parameters $\\vec{\\theta}$**, then a quantum neural network with strong expressibility will be more likely to contain those unitaries that globally minimize the loss function $\\mathcal{L}$; conversely, if a quantum neural network $U_{ weak}$ is so weak that it does not contain any unitary that minimize the loss function, then a quantum machine learning task based on optimizing $U_{weak}$ is likely to fail.\n", + "\n", + "Next, we visualize the expressibility of quantum neural networks based on Paddle Quantum by looking at the ability of a single qubit to traverse the Bloch sphere through unitaries." + ] + }, + { + "cell_type": "markdown", + "id": "b8205717", + "metadata": {}, + "source": [ + "## Intuition: traversing the Bloch sphere" + ] + }, + { + "cell_type": "markdown", + "id": "df8f0a68", + "metadata": {}, + "source": [ + "In the one qubit case, we can directly observe how a quantum neural network traverses the surface of a Bloch sphere with a fixed input. For a given neural network ansatz $U(\\vec{\\theta})$, since the input to the network tends to be fixed (we set it to $|0\\rangle$), by uniformly sampling the neural network parameters $\\vec{\\theta}$, the output state of the neural network $U(\\vec{\\theta})|0\\rangle$ will be scattered over the surface of the Bloch sphere. Obviously, if the output states are more widely and uniformly distributed on the surface of the sphere, the more expressive the neural network ansatz $U$ will be, and the more likely it will contain the global optimum of the loss function.\n", + "\n", + "To implement this function in Paddle, we first import necessary packages." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3810b843", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import paddle\n", + "import paddle_quantum as pq\n", + "from paddle_quantum.ansatz.circuit import Circuit\n", + "from paddle_quantum.visual import plot_state_in_bloch_sphere" + ] + }, + { + "cell_type": "markdown", + "id": "2dc0318c", + "metadata": {}, + "source": [ + "First, we allow only one $R_Y$ rotation gate to construct quantum neural network $U(\\theta)=R_Y(\\theta)$. By uniformly sampling the parameter $\\theta$ at $[0,2\\pi]$ and acting $U(\\theta)$ on a fixed input $|0\\rangle$, we obtain the output distribution of the quantum neural network $U(\\theta)$. With the built-in plot_bloch_sphere_from_input function of Paddle Quantum, we can directly observe the distribution of $U(\\theta)|0\\rangle$ on the Bloch sphere as follows." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8cc9cff3", + "metadata": {}, + "outputs": [], + "source": [ + "num_qubit = 1 # the number of qubit\n", + "num_sample = 2000 # the number of sample\n", + "outputs_y = list() # save QNN outputs\n", + "\n", + "for _ in range(num_sample):\n", + " # initialize QNN ansatz\n", + " pq.set_backend('density_matrix')\n", + " cir = Circuit(num_qubit)\n", + " # apply Ry with a random rotating angle\n", + " cir.ry(0)\n", + " # output a density operator\n", + " rho = cir(pq.state.zero_state(num_qubit))\n", + " outputs_y.append(rho)\n", + " \n", + "# built-in function of Paddle Quantum to plot on Bloch sphere\n", + "# plot_state_in_bloch_sphere(outputs_y, save_gif=True, filename='figures/bloch_y.gif')" + ] + }, + { + "cell_type": "markdown", + "id": "351b12a4", + "metadata": {}, + "source": [ + "![bloch_y.gif](./figures/expressibility-fig-bloch_y.gif)" + ] + }, + { + "cell_type": "markdown", + "id": "1bd42a83", + "metadata": {}, + "source": [ + "It can be seen that the output of the quantum neural network $U(\\theta)=R_Y(\\theta)$ can only be distributed in a circle on the Bloch sphere (although the distribution is uniform over the circle). Similarly, we consider the neural network $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ with two parameters and the neural network $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ with three parameters. The output distribution is:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c0330832", + "metadata": {}, + "outputs": [], + "source": [ + "outputs_yz = list() # save QNN outputs\n", + "for _ in range(num_sample):\n", + " # initialize QNN ansatz\n", + " cir = Circuit(num_qubit)\n", + " # apply Ry and Rz with random rotating angles\n", + " cir.ry(0)\n", + " cir.rz(0)\n", + " # output a density operator\n", + " rho = cir(pq.state.zero_state(num_qubit))\n", + " outputs_yz.append(rho)\n", + "\n", + "# plot_state_in_bloch_sphere(outputs_yz, save_gif=True, filename='figures/bloch_yz.gif')\n", + "\n", + "\n", + "outputs_yzy = list() # save QNN outputs\n", + "for _ in range(num_sample):\n", + " # initialize QNN ansatz\n", + " cir = Circuit(num_qubit)\n", + " # apply Ry, Rz, and Ry with random rotating angles\n", + " cir.ry(0)\n", + " cir.rz(0)\n", + " cir.ry(0)\n", + " # output a density operator\n", + " rho = cir(pq.state.zero_state(num_qubit))\n", + " outputs_yzy.append(rho)\n", + " \n", + "# plot_state_in_bloch_sphere(outputs_yzy, save_gif=True, filename='figures/bloch_yzy.gif')" + ] + }, + { + "cell_type": "markdown", + "id": "02877b2a", + "metadata": {}, + "source": [ + "![bloch_yz.gif](./figures/expressibility-fig-bloch_yz.gif)" + ] + }, + { + "cell_type": "markdown", + "id": "377bbcbf", + "metadata": {}, + "source": [ + "![bloch_yzy.gif](./figures/expressibility-fig-bloch_yzy.gif)" + ] + }, + { + "cell_type": "markdown", + "id": "2213837b", + "metadata": {}, + "source": [ + "It can be seen that the output of the neural network $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ can be distributed over the entire surface of the Bloch sphere now, although the distribution is more concentrated near the two polars ($|0\\rangle$ and $|1\\rangle$); and the output of the neural network $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ is more uniformly distributed over the surface of the sphere." + ] + }, + { + "cell_type": "markdown", + "id": "7d225e68", + "metadata": {}, + "source": [ + "In the low-dimensional case of single qubit, we can qualitatively observe the expressibility of quantum neural networks with the help of Bloch spheres. In general situations with multiple qubits, we have to analyze the expressibility quantitatively via statistical mathematical tools. Next, we will introduce the K-L divergence of the fidelity distribution among quantum states to quantify the expressibility of a quantum neural network and calculate the expressibility of a commonly used ansatz." + ] + }, + { + "cell_type": "markdown", + "id": "5638c30a", + "metadata": {}, + "source": [ + "## Quantitative analysis of expressibility by the K-L divergence" + ] + }, + { + "cell_type": "markdown", + "id": "f35faa47", + "metadata": {}, + "source": [ + "### Fidelity distribution and the K-L divergence" + ] + }, + { + "cell_type": "markdown", + "id": "c681b230", + "metadata": {}, + "source": [ + "In [2], the authors proposed a method for quantifying the expressive power based on the probability distribution of fidelity between the output states of a quantum neural network. For any quantum neural network $U(\\vec{\\theta})$, sampling the neural network parameters twice (let them be $\\vec{\\phi}$ and $\\vec{\\psi}$), the fidelity $F=|\\langle0|U(\\vec{\\phi})^\\dagger U(\\vec{\\psi}) |0\\rangle|^2$ subjects to some probability distribution\n", + "$$\n", + "F\\sim{P}(f).\\tag{4}\n", + "$$\n", + "According to [2], when a quantum neural network $U$ can uniformly represent unitaries (now we call that $U$ subjects to the Haar measure), the probability distribution of fidelity $P_\\text{Haar}(f)$ satisfies\n", + "$$\n", + "P_\\text{Haar}(f)=(2^{n}-1)(1-f)^{2^n-2}.\\tag{5}\n", + "$$\n", + "\n", + "Paddle Quantum provides functions that sample unitaries from the Haar measure. We evaluate the probability distribution that the fidelity of the outputs of the Haar random unitaries subjects to:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "409b2dc8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "from paddle_quantum.linalg import haar_unitary\n", + "from paddle_quantum.qinfo import state_fidelity\n", + "from paddle_quantum.state.common import to_state\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import FuncFormatter\n", + "from scipy import integrate\n", + "\n", + "# plot histgram\n", + "def plot_hist(data, num_bin, title_str):\n", + " def to_percent(y, position):\n", + " return str(np.around(y*100, decimals=2)) + '%'\n", + " plt.hist(data, weights=[1./len(data)]*len(data), bins=np.linspace(0, 1, num=num_bin), facecolor=\"blue\", edgecolor=\"black\", alpha=0.7)\n", + " plt.xlabel(\"Fidelity\")\n", + " plt.ylabel(\"frequency\")\n", + " plt.title(title_str)\n", + " formatter = FuncFormatter(to_percent)\n", + " plt.gca().yaxis.set_major_formatter(formatter)\n", + " plt.show()\n", + " \n", + " \n", + "# evaluate the probability distribution of F generated by a Haar random unitary\n", + "def p_F_haar(n, s, b=50, draw=False):\n", + " f_list = list()\n", + " # sampling\n", + " for i in range(s):\n", + " # sample a unitary\n", + " u1 = haar_unitary(n)\n", + " # the output of u1\n", + " phi1 = u1[:,0]\n", + " rho1 = to_state(np.outer(phi1, phi1.conj()))\n", + " # sample a unitary\n", + " u2 = haar_unitary(n)\n", + " phi2 = u2[:,0]\n", + " # the output of u2\n", + " rho2 = to_state(np.outer(phi2, phi2.conj()))\n", + " # compute fidality\n", + " f_list.append(state_fidelity(rho1, rho2)**2)\n", + " f_list = np.array(f_list)\n", + " # plot histgram\n", + " if draw:\n", + " title_str = \"haar, %d qubit(s)\" % num_qubit\n", + " plot_hist(f_list, b, title_str)\n", + " sample_distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", + " # compute a theoretical distribution\n", + " theory_distribution = np.zeros_like(sample_distribution)\n", + " for index in range(len(theory_distribution)):\n", + " def p_continues(f):\n", + " return (2 ** n - 1) * (1 - f) ** (2 ** n - 2)\n", + " lower = 1/b*index\n", + " upper = lower + 1/b\n", + " theory_distribution[index], _ = integrate.quad(p_continues,lower,upper)\n", + " return sample_distribution, theory_distribution\n", + "\n", + "\n", + "num_qubit = 1\n", + "p_haar_1qubit, theory_haar_1qubit = p_F_haar(num_qubit, num_sample, draw=True)\n", + "num_qubit = 2\n", + "p_haar_2qubit, theory_haar_2qubit = p_F_haar(num_qubit, num_sample, draw=True)" + ] + }, + { + "cell_type": "markdown", + "id": "581fe296", + "metadata": {}, + "source": [ + "It can be seen that the fidelity distribution roughly obeys $P_\\text{Haar}$. Similarly, we can compute the probability distributions of the fidelity of the outputs of the previously defined single-qubit quantum neural networks $R_Y(\\theta)$, $R_Y(\\theta_1)R_Z(\\theta_2)$ and $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "eeb57c55", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# evaluate the probability distribution of F generated by QNNs\n", + "def p_F_qnn(n, s, g, b=50, draw=False):\n", + " f_list = list()\n", + " rho_sample = outputs_y\n", + " title_str = \"Ry\"\n", + " if g == 2:\n", + " rho_sample = outputs_yz\n", + " title_str = \"Ry-Rz\"\n", + " elif g == 3:\n", + " rho_sample = outputs_yzy\n", + " title_str = \"Ry-Rz-Ry\"\n", + " # use previously collected data to compute fidelity\n", + " for index in range(int(s / 2)):\n", + " rho1 = rho_sample[index]\n", + " rho2 = rho_sample[index+int(num_sample / 2)]\n", + " f_list.append(state_fidelity(rho1, rho2)**2)\n", + " f_list = np.array(f_list)\n", + " # plot histgram\n", + " if draw:\n", + " plot_hist(f_list, b, title_str)\n", + " distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", + " return distribution\n", + " \n", + " \n", + "num_qubit = 1\n", + "p_y = p_F_qnn(num_qubit, num_sample, 1, draw=True)\n", + "p_yz = p_F_qnn(num_qubit, num_sample, 2, draw=True)\n", + "p_yzy = p_F_qnn(num_qubit, num_sample, 3, draw=True)" + ] + }, + { + "cell_type": "markdown", + "id": "d204622b", + "metadata": {}, + "source": [ + "Evidently, the fidelity distribution of the outputs of the neural network composed of $R_Y-R_Z-R_Y$ gates is closest to that of the Haar random unitary. The K-L divergence (also called relative entropy) in statistical mathematics can measure the difference between two probability distributions. The K-L divergence between two discrete probability distributions $P,Q$ is defined as\n", + "$$\n", + "D_{KL}(P||Q)=\\sum_jP(j)\\ln\\frac{P(j)}{Q(j)}.\\tag{6}\n", + "$$\n", + "If the fidelity distribution of the outputs of a quantum neural network is denoted as $P_\\text{QNN}(f)$, the expressibility of the quantum neural network is defined as the K-L divergence between $P_\\text{QNN}(f)$ and $P_\\text{Haar}(f)$ [2]\n", + "$$\n", + "\\text{Expr}_\\text{QNN}=D_{KL}(P_\\text{QNN}(f)||P_\\text{Haar}(f)).\\tag{7}\n", + "$$\n", + "Therefore, the closer $P_\\text{QNN}(f)$ is to $P_\\text{Haar}(f)$, the smaller the $\\text{Expr}$ will be (more close to 0), and the more expressive the quantum neural network will be; conversely, the larger the $\\text{Expr}$ is, the less expressive the quantum neural network will be.\n", + "\n", + "We can directly calculate the expressibility of single-qubit quantum neural networks $R_Y(\\theta)$, $R_Y(\\theta_1)R_Z(\\theta_2)$ and $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ according to this definition." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "cc1bb1b3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The expressiblity of Ry, Ry-Rz, and Ry-Rz-Rz are 0.21, 0.05, and 0.02, respectively.\n" + ] + } + ], + "source": [ + "from scipy.stats import entropy\n", + "# calcutale relative entropy (K-L divergence)\n", + "expr_y = entropy(p_y, theory_haar_1qubit)\n", + "expr_yz = entropy(p_yz, theory_haar_1qubit)\n", + "expr_yzy = entropy(p_yzy, theory_haar_1qubit)\n", + "print(\"The expressiblity of Ry, Ry-Rz, and Ry-Rz-Rz are %.2f, %.2f, and %.2f, respectively.\" %(expr_y, expr_yz, expr_yzy))" + ] + }, + { + "cell_type": "markdown", + "id": "6c781089", + "metadata": {}, + "source": [ + "### Evaluate the expressibility of QNNs" + ] + }, + { + "cell_type": "markdown", + "id": "c35a6791", + "metadata": {}, + "source": [ + "We now have our tool, the K-L divergence, to quantitatively study the expressibility of any quantum neural network ansatz. As a practical application, let us explore the variation of the expressibility of a Paddle Quantum QNN tamplate with different circuit depth. Here we set the width of the circuit to 4-qubit." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "17d5b27b", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "F generated by a Haar random unitaty：\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sampling QNNs with depth 1...\n", + " sampling 0-th sample...\n", + " sampling 400-th sample...\n", + " sampling 800-th sample...\n", + " sampling 1200-th sample...\n", + " sampling 1600-th sample...\n", + " sample finished\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sampling QNNs with depth 2...\n", + " sampling 0-th sample...\n", + " sampling 400-th sample...\n", + " sampling 800-th sample...\n", + " sampling 1200-th sample...\n", + " sampling 1600-th sample...\n", + " sample finished\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sampling QNNs with depth 3...\n", + " sampling 0-th sample...\n", + " sampling 400-th sample...\n", + " sampling 800-th sample...\n", + " sampling 1200-th sample...\n", + " sampling 1600-th sample...\n", + " sample finished\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The expressibility of depth 1, 2 and 3 is [0.2715 0.0152 0.0096]\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# evaluate the probability distribution of F generated by the complex entangled QNN\n", + "def p_F_cel(n, d, s, b=50, draw=False):\n", + " pq.set_backend('state_vector')\n", + " f_list = list()\n", + " for index in range(int(s / 2)):\n", + " if 2 * index % 400 == 0:\n", + " print(\" sampling %d-th sample...\" % (2 * index))\n", + " cir1 = Circuit(n)\n", + " # add complex entangled layers\n", + " cir1.complex_entangled_layer('full', n, d)\n", + " # output a state vector\n", + " rho1 = cir1(pq.state.zero_state(n))\n", + " \n", + " cir2 = Circuit(n)\n", + " # add complex entangled layers\n", + " cir2.complex_entangled_layer('full', n, d)\n", + " # output another state vector\n", + " rho2 = cir2(pq.state.zero_state(n))\n", + " \n", + " # calculate fidelity\n", + " f_list.append(abs(np.inner(rho1.data.numpy(), rho2.data.numpy().conj()))**2)\n", + " \n", + " print(\" sample finished\")\n", + " f_list = np.array(f_list)\n", + " # plot histgram\n", + " if draw:\n", + " title_str = \"complex entangled layer, %d layer(s)\" % d\n", + " plot_hist(f_list, b, title_str)\n", + " distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n", + " return distribution\n", + "\n", + "\n", + "# set the width and maximal depth \n", + "num_qubit = 4\n", + "max_depth = 3\n", + "# evaluate the probability distribution of F generated by a Haar random unitaty\n", + "print(\"F generated by a Haar random unitaty：\")\n", + "p_haar_4qubit, theory_haar_4qubit = p_F_haar(num_qubit, num_sample, draw=True)\n", + "Expr_cel = list()\n", + "# evaluate the expressibility of QNNs with different depth\n", + "for DEPTH in range(1, max_depth + 1):\n", + " print(\"sampling QNNs with depth %d...\" % DEPTH)\n", + " p_cel = p_F_cel(num_qubit, DEPTH, num_sample, draw=True)\n", + " expr = entropy(p_cel, theory_haar_4qubit)\n", + " Expr_cel.append(expr)\n", + "# compare the expressibility\n", + "print(\"The expressibility of depth 1, 2 and 3 is\", np.around(Expr_cel, decimals=4))\n", + "plt.plot(range(1, max_depth + 1), Expr_cel, marker='>')\n", + "plt.xlabel(\"depth\")\n", + "plt.yscale('log')\n", + "plt.ylabel(\"Expr.\")\n", + "plt.xticks(range(1, max_depth + 1))\n", + "plt.title(\"Expressibility vs Circuit Depth\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3548ed5c", + "metadata": {}, + "source": [ + "As we would observe, the expressibility of the quantum neural network is gradually enhanced with the increase of circuit depth. Interested readers are welcome to try to evaluate the expressibility of other Paddle Quantum QNN templates, and compare the difference in expressibility between different templates." + ] + }, + { + "cell_type": "markdown", + "id": "699d3925", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## References\n", + "\n", + "[1] Nielsen, Michael A., and Isaac L. Chuang. \"Quantum Computation and Quantum Information.\" Cambridge University Press, 2010.\n", + "\n", + "[2] Sim, Sukin, Peter D. Johnson, and Alán Aspuru‐Guzik. \"Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum‐classical algorithms.\" [Advanced Quantum Technologies 2.12 (2019): 1900070](https://onlinelibrary.wiley.com/doi/abs/10.1002/qute.201900070)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/qnn_research/Fisher_CN.ipynb b/tutorials/qnn_research/Fisher_CN.ipynb similarity index 69% rename from tutorial/qnn_research/Fisher_CN.ipynb rename to tutorials/qnn_research/Fisher_CN.ipynb index 8ed323d..f7d6659 100644 --- a/tutorial/qnn_research/Fisher_CN.ipynb +++ b/tutorials/qnn_research/Fisher_CN.ipynb @@ -2,35 +2,36 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "source": [ "# 量子费舍信息\n", "\n", " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## 概览\n", "\n", "本教程简要介绍经典费舍信息（classical Fisher information, CFI）和量子费舍信息（quantum Fisher information, QFI）的概念及其在量子机器学习中的应用，并展示如何调用量桨来计算它们。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## 背景\n", "\n", "量子费舍信息这一概念源自量子传感领域，现已逐渐成为研究参数化量子系统的通用工具 [[1]](https://arxiv.org/abs/2103.15191)，例如描述过参数化现象 [[2]](https://arxiv.org/abs/2102.01659)，量子自然梯度下降 [[3]](https://arxiv.org/abs/1909.02108) 等。量子费舍信息是经典费舍信息在量子系统中的自然类比。经典费舍信息刻画了一个参数化的『概率分布』对其参数变化的灵敏度，而量子费舍信息刻画了一个参数化的『量子态』对其参数变化的灵敏度。\n", "\n", "按照传统的介绍方式，经典费舍信息会作为数理统计中参数估计的一部分内容出现，但对于初学者来说可能是复杂且不直观的。本教程将从几何的角度出发来介绍经典费舍信息，这不仅有助于直观理解，且更容易由此看出其与量子费舍信息之间的联系。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 经典费舍信息\n", "\n", @@ -109,11 +110,11 @@ "为什么 $\\mathcal{I}(\\boldsymbol{\\theta})$ 称为『信息』？这是因为，CFIM 刻画了概率分布在对应参数一个领域内的灵敏度，或称锐度。对参数变化越灵敏，说明我们越容易将其同其它概率分布区分开来，进一步地，说明我们需要越少的样本就可以完成这种区分，那么每个样本中平均所含的信息量就越多。\n", "\n", "参数化量子电路（parameterized quantum circuit, PQC）的测量结果会形成一个概率分布，因此可以对不同的测量基定义不同的 CFIM。目前在 NISQ 设备上计算 CFIM 的主要挑战是，可能出现的测量结果的数量会随着量子比特数的增加而指数地增加，这意味着可能有很多小概率的测量结果从未出现过，导致 CFIM 的计算出现发散。一些可能的解决方案包括直接忽略小的概率事件，以及贝叶斯更新等 [[1]](https://arxiv.org/abs/2103.15191)。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 量子费舍信息\n", "\n", @@ -149,7 +150,7 @@ "\\end{aligned}\n", "\\tag{9}\n", "$$\n", - "其中 $\\boldsymbol{e}_{i}$ 是 $\\theta_i$ 对应方向的单位向量。\n", + "其中 $\\boldsymbol{e}_{i}$ 是 $\\theta_i$ 对应方向的单位向量。值得注意的是，参数平移规则不能直接适用于单比特旋转门的参数间有依赖关系的情况，例如受控旋转门等。\n", "\n", "- 利用有限差分计算 QFIM 沿一个确定方向的投影 [[1]](https://arxiv.org/abs/2103.15191)\n", "$$\n", @@ -179,11 +180,11 @@ "$$\n", "\n", "更多细节请参考这篇综述 [[1]](https://arxiv.org/abs/2103.15191) 。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 经典与量子费舍信息的关系\n", "\n", @@ -195,11 +196,11 @@ "$$\n", "\n", "此处 $\\mathcal{E}$ 表示测量对应的量子操作。正定矩阵间不等式的含义是，大的减去小的结果仍然是一个正定矩阵。由于对量子态的测量永远无法提取出比量子态本身更多的信息，因此上式的成立是很自然的。数学上这根源于保真度距离对于保迹量子操作的单调性 [[1]](https://arxiv.org/abs/2103.15191)。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 应用：有效维数\n", "\n", @@ -244,50 +245,50 @@ "这个定义乍看起来可能很迷惑，因为它比上文通过秩来定义要复杂得多。然而，它实际上可以在无限样本的极限下 $n\\rightarrow \\infty$ 回到 CFIM 最大秩的定义 [[6]](https://arxiv.org/abs/2011.00027)。若忽略定义中的一些系数和取对数的操作，此处定义的有效维数可以粗略地看作归一化 CFIM 加上一个单位矩阵的本征谱的几何平均。依据几何平均与算术平均间的不等式关系，可知本征谱分布越均匀，有效维数越大。这和我们的直觉是一致的。在这个意义上，它可以看作是一个软化版本的有效维数。\n", "\n", "另外，费舍信息不仅可以用来计算模型的表达能力，还可以用来表征模型的可训练性。如果费舍信息矩阵的矩阵元在参数空间的平均随体系规模的增大而指数地趋于零，即概率分布/量子态对参数变化的灵敏度指数地趋于零，那么我们将无法高效地区分它们，也就意味着贫瘠高原现象的存在 [[6]](https://arxiv.org/abs/2011.00027)。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## 调用量桨计算费舍信息" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 计算量子费舍信息\n", "\n", "利用量桨工具，通过以下步骤我们就可以方便地算出 QFIM。\n", "\n", - "1. 调用 `UAnsatz` 类定义一个量子电路。\n", + "1. 调用 `Circuit` 类定义一个量子电路。\n", "2. 调用 `QuantumFisher` 类定义一个 QFIM 计算器。\n", "3. 调用 `get_qfisher_matrix()` 方法计算 QFIM。\n", "\n", - "其中计算器 `QuantumFisher` 会追踪量子电路 `UAnsatz` 的实时变化。\n", + "其中计算器 `QuantumFisher` 会追踪量子电路 `Circuit` 的实时变化。\n", "\n", "现在来着手写代码。首先导入一些必要的包。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 15, + "metadata": {}, + "outputs": [], "source": [ "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.ansatz import Circuit\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from paddle_quantum.utils import QuantumFisher, ClassicalFisher\n", + "from paddle_quantum.fisher import QuantumFisher, ClassicalFisher\n", "import warnings\n", "warnings.filterwarnings(\"ignore\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "然后定义量子电路。作为一个简单的例子，我们采用布洛赫角表示的单个量子比特\n", "\n", @@ -305,152 +306,163 @@ "\\end{matrix}\\right).\n", "\\tag{19}\n", "$$" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 2, + "metadata": {}, + "outputs": [], "source": [ "def circuit_bloch():\n", - " cir = UAnsatz(1)\n", - " theta = 2 * np.pi * np.random.random(2)\n", - " theta = paddle.to_tensor(theta, stop_gradient=False, dtype='float64')\n", - " cir.ry(theta[0], which_qubit=0)\n", - " cir.rz(theta[1], which_qubit=0)\n", - " \n", + " cir = Circuit(1)\n", + " cir.ry()\n", + " cir.rz()\n", " return cir" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 3, - "source": [ - "cir = circuit_bloch()\n", - "print(cir)" - ], + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "--Ry(1.888)----Rz(2.181)--\n", + "--Ry(0.826)----Rz(4.587)--\n", " \n" ] } ], - "metadata": {} + "source": [ + "cir = circuit_bloch()\n", + "print(cir)" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "定义 QFIM 计算器然后计算不同 $\\theta$ 对应的 QFIM 矩阵元 $\\mathcal{F}_{\\phi\\phi}$ 。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 4, - "source": [ - "qf = QuantumFisher(cir)\n", - "# 记录 QFIM 的矩阵元 F_{phi,phi}\n", - "list_qfisher_elements = []\n", - "num_thetas = 21\n", - "thetas = np.linspace(0, np.pi, num_thetas)\n", - "for theta in thetas:\n", - " list_param = cir.get_param().tolist()\n", - " list_param[0] = theta\n", - " cir.update_param(list_param)\n", - " # 计算 QFIM\n", - " qfim = qf.get_qfisher_matrix()\n", - " print(f'The QFIM at {np.array(list_param)} is \\n {qfim.round(14)}.')\n", - " list_qfisher_elements.append(qfim[1][1])" - ], + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "The QFIM at [0. 2.18107874] is \n", + "The QFIM at [0. 4.58719969] is \n", " [[1. 0.]\n", " [0. 0.]].\n", - "The QFIM at [0.15707963 2.18107874] is \n", + "The QFIM at [0.15707963 4.58719969] is \n", " [[1. 0. ]\n", - " [0. 0.02447174]].\n", - "The QFIM at [0.31415927 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.0954915]].\n", - "The QFIM at [0.4712389 2.18107874] is \n", + " [0. 0.02447182]].\n", + "The QFIM at [0.31415927 4.58719969] is \n", " [[1. 0. ]\n", - " [0. 0.20610737]].\n", - "The QFIM at [0.62831853 2.18107874] is \n", - " [[ 1. -0. ]\n", - " [-0. 0.3454915]].\n", - "The QFIM at [0.78539816 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.5]].\n", - "The QFIM at [0.9424778 2.18107874] is \n", - " [[ 1. -0. ]\n", - " [-0. 0.6545085]].\n", - "The QFIM at [1.09955743 2.18107874] is \n", + " [0. 0.09549146]].\n", + "The QFIM at [0.4712389 4.58719969] is \n", " [[1. 0. ]\n", - " [0. 0.79389263]].\n", - "The QFIM at [1.25663706 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.9045085]].\n", - "The QFIM at [1.41371669 2.18107874] is \n", + " [0. 0.20610736]].\n", + "The QFIM at [0.62831853 4.58719969] is \n", + " [[ 1.0000000e+00 -8.1719260e-08]\n", + " [-8.1719260e-08 3.4549149e-01]].\n", + "The QFIM at [0.78539816 4.58719969] is \n", + " [[ 1.00000000e+00 -1.49011600e-08]\n", + " [-1.49011600e-08 5.00000017e-01]].\n", + "The QFIM at [0.9424778 4.58719969] is \n", + " [[ 1.00000000e+00 -3.05229200e-08]\n", + " [-3.05229200e-08 6.54508507e-01]].\n", + "The QFIM at [1.09955743 4.58719969] is \n", " [[1. 0. ]\n", - " [0. 0.97552826]].\n", - "The QFIM at [1.57079633 2.18107874] is \n", - " [[1. 0.]\n", - " [0. 1.]].\n", - "The QFIM at [1.72787596 2.18107874] is \n", + " [0. 0.79389268]].\n", + "The QFIM at [1.25663706 4.58719969] is \n", + " [[ 9.99999881e-01 -1.25257100e-08]\n", + " [-1.25257100e-08 9.04508410e-01]].\n", + "The QFIM at [1.41371669 4.58719969] is \n", " [[1. 0. ]\n", - " [0. 0.97552826]].\n", - "The QFIM at [1.88495559 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.9045085]].\n", - "The QFIM at [2.04203522 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.79389263]].\n", - "The QFIM at [2.19911486 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.6545085]].\n", - "The QFIM at [2.35619449 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.5]].\n", - "The QFIM at [2.51327412 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.3454915]].\n", - "The QFIM at [2.67035376 2.18107874] is \n", - " [[ 1. -0. ]\n", - " [-0. 0.20610737]].\n", - "The QFIM at [2.82743339 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.0954915]].\n", - "The QFIM at [2.98451302 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.02447174]].\n", - "The QFIM at [3.14159265 2.18107874] is \n", - " [[1. 0.]\n", - " [0. 0.]].\n" + " [0. 0.97552822]].\n", + "The QFIM at [1.57079633 4.58719969] is \n", + " [[0.99999988 0. ]\n", + " [0. 0.99999988]].\n", + "The QFIM at [1.72787596 4.58719969] is \n", + " [[9.99999881e-01 5.18176500e-08]\n", + " [5.18176500e-08 9.75528170e-01]].\n", + "The QFIM at [1.88495559 4.58719969] is \n", + " [[1.00000024e+00 4.79417900e-08]\n", + " [4.79417900e-08 9.04508749e-01]].\n", + "The QFIM at [2.04203522 4.58719969] is \n", + " [[1.00000000e+00 6.73742000e-08]\n", + " [6.73742000e-08 7.93892595e-01]].\n", + "The QFIM at [2.19911486 4.58719969] is \n", + " [[1.00000000e+00 8.17192500e-08]\n", + " [8.17192500e-08 6.54508507e-01]].\n", + "The QFIM at [2.35619449 4.58719969] is \n", + " [[0.99999976 0. ]\n", + " [0. 0.49999986]].\n", + "The QFIM at [2.51327412 4.58719969] is \n", + " [[1.0000000e+00 8.1719250e-08]\n", + " [8.1719250e-08 3.4549149e-01]].\n", + "The QFIM at [2.67035376 4.58719969] is \n", + " [[0.99999988 0. ]\n", + " [0. 0.20610746]].\n", + "The QFIM at [2.82743339 4.58719969] is \n", + " [[ 1.00000000e+00 -3.54160700e-08]\n", + " [-3.54160700e-08 9.54916844e-02]].\n", + "The QFIM at [2.98451302 4.58719969] is \n", + " [[0.99999976 0. ]\n", + " [0. 0.02447181]].\n", + "The QFIM at [3.14159265 4.58719969] is \n", + " [[ 1.0000000e+00 -1.2644054e-07]\n", + " [-1.2644054e-07 0.0000000e+00]].\n" ] } ], - "metadata": {} + "source": [ + "qf = QuantumFisher(cir)\n", + "# 记录 QFIM 的矩阵元 F_{phi,phi}\n", + "list_qfisher_elements = []\n", + "num_thetas = 21\n", + "thetas = np.linspace(0, np.pi, num_thetas)\n", + "for theta in thetas:\n", + " list_param = cir.param.tolist()\n", + " list_param[0] = theta\n", + " cir.update_param(list_param)\n", + " # 计算 QFIM\n", + " qfim = qf.get_qfisher_matrix()\n", + " print(f'The QFIM at {np.array(list_param)} is \\n {qfim.round(14)}.')\n", + " list_qfisher_elements.append(qfim[1][1])" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "画出 $\\mathcal{F}_{\\phi\\phi}$ 随 $\\theta$ 变化的图像。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# 创建图像\n", "fig = plt.figure(figsize=(9, 6))\n", @@ -466,25 +478,11 @@ "ax.set_xlabel('$\\\\theta$', fontsize=label_font_size)\n", "ax.set_ylabel('QFIM element $\\\\mathcal{F}_{\\\\phi\\\\phi}$', fontsize=label_font_size)\n", "ax.tick_params(labelsize=label_font_size)" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "可以看到程序输出和解析结果是一致的。\n", "\n", @@ -511,59 +509,104 @@ "$$\n", "\n", "定义相应的量子电路。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 6, + "metadata": {}, + "outputs": [], "source": [ "def circuit_hardeff_2qubit():\n", - " cir = UAnsatz(2)\n", - " theta = 2 * np.pi * np.random.random(4)\n", - " theta = paddle.to_tensor(theta, stop_gradient=False, dtype='float64')\n", - " cir.ry(theta[0], which_qubit=0)\n", - " cir.ry(theta[1], which_qubit=1)\n", - " cir.cnot(control=[0, 1])\n", - " cir.ry(theta[2], which_qubit=0)\n", - " cir.ry(theta[3], which_qubit=1)\n", + " cir = Circuit(2)\n", + " cir.ry()\n", + " cir.cnot([0, 1])\n", + " cir.ry()\n", "\n", " return cir" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 7, - "source": [ - "cir = circuit_hardeff_2qubit()\n", - "print(cir)" - ], + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "--Ry(2.614)----*----Ry(3.253)--\n", + "--Ry(3.322)----*----Ry(1.502)--\n", " | \n", - "--Ry(2.906)----x----Ry(5.027)--\n", + "--Ry(2.820)----x----Ry(6.056)--\n", " \n" ] } ], - "metadata": {} + "source": [ + "cir = circuit_hardeff_2qubit()\n", + "print(cir)" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "定义 QFIM 计算器并计算不同 $\\theta$ 对应的 QFIM 在 $\\boldsymbol{v}=(1,1,1,1)$ 方向上的投影 $\\boldsymbol{v}^T\\mathcal{F}\\boldsymbol{v}$ （固定 $\\theta_1=\\theta_2=\\theta$）。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The QFI norm along [1, 1, 1, 1] at [0. 0. 1.50244081 6.05584192] is 6.00315457.\n", + "The QFI norm along [1, 1, 1, 1] at [0.31415927 0.31415927 1.50244081 6.05584192] is 5.91733027.\n", + "The QFI norm along [1, 1, 1, 1] at [0.62831853 0.62831853 1.50244081 6.05584192] is 5.83627391.\n", + "The QFI norm along [1, 1, 1, 1] at [0.9424778 0.9424778 1.50244081 6.05584192] is 5.83150589.\n", + "The QFI norm along [1, 1, 1, 1] at [1.25663706 1.25663706 1.50244081 6.05584192] is 5.92686631.\n", + "The QFI norm along [1, 1, 1, 1] at [1.57079633 1.57079633 1.50244081 6.05584192] is 6.00792258.\n", + "The QFI norm along [1, 1, 1, 1] at [1.88495559 1.88495559 1.50244081 6.05584192] is 5.85534601.\n", + "The QFI norm along [1, 1, 1, 1] at [2.19911486 2.19911486 1.50244081 6.05584192] is 5.38331038.\n", + "The QFI norm along [1, 1, 1, 1] at [2.51327412 2.51327412 1.50244081 6.05584192] is 4.49167993.\n", + "The QFI norm along [1, 1, 1, 1] at [2.82743339 2.82743339 1.50244081 6.05584192] is 3.27580421.\n", + "The QFI norm along [1, 1, 1, 1] at [3.14159265 3.14159265 1.50244081 6.05584192] is 1.98361799.\n", + "The QFI norm along [1, 1, 1, 1] at [3.45575192 3.45575192 1.50244081 6.05584192] is 0.86783892.\n", + "The QFI norm along [1, 1, 1, 1] at [3.76991118 3.76991118 1.50244081 6.05584192] is 0.24795494.\n", + "The QFI norm along [1, 1, 1, 1] at [4.08407045 4.08407045 1.50244081 6.05584192] is 0.26226001.\n", + "The QFI norm along [1, 1, 1, 1] at [4.39822972 4.39822972 1.50244081 6.05584192] is 0.90598547.\n", + "The QFI norm along [1, 1, 1, 1] at [4.71238898 4.71238898 1.50244081 6.05584192] is 2.02176400.\n", + "The QFI norm along [1, 1, 1, 1] at [5.02654825 5.02654825 1.50244081 6.05584192] is 3.31871778.\n", + "The QFI norm along [1, 1, 1, 1] at [5.34070751 5.34070751 1.50244081 6.05584192] is 4.53936095.\n", + "The QFI norm along [1, 1, 1, 1] at [5.65486678 5.65486678 1.50244081 6.05584192] is 5.40715063.\n", + "The QFI norm along [1, 1, 1, 1] at [5.96902604 5.96902604 1.50244081 6.05584192] is 5.87441809.\n", + "The QFI norm along [1, 1, 1, 1] at [6.28318531 6.28318531 1.50244081 6.05584192] is 6.00315457.\n", + "The QFI norm along [1, 1, 1, 1] at [6.59734457 6.59734457 1.50244081 6.05584192] is 5.92209829.\n", + "The QFI norm along [1, 1, 1, 1] at [6.91150384 6.91150384 1.50244081 6.05584192] is 5.83627391.\n", + "The QFI norm along [1, 1, 1, 1] at [7.2256631 7.2256631 1.50244081 6.05584192] is 5.83150589.\n", + "The QFI norm along [1, 1, 1, 1] at [7.53982237 7.53982237 1.50244081 6.05584192] is 5.92686631.\n", + "The QFI norm along [1, 1, 1, 1] at [7.85398163 7.85398163 1.50244081 6.05584192] is 6.00792258.\n", + "The QFI norm along [1, 1, 1, 1] at [8.1681409 8.1681409 1.50244081 6.05584192] is 5.87441809.\n", + "The QFI norm along [1, 1, 1, 1] at [8.48230016 8.48230016 1.50244081 6.05584192] is 5.38331038.\n", + "The QFI norm along [1, 1, 1, 1] at [8.79645943 8.79645943 1.50244081 6.05584192] is 4.48691182.\n", + "The QFI norm along [1, 1, 1, 1] at [9.1106187 9.1106187 1.50244081 6.05584192] is 3.28534056.\n", + "The QFI norm along [1, 1, 1, 1] at [9.42477796 9.42477796 1.50244081 6.05584192] is 1.97884973.\n", + "The QFI norm along [1, 1, 1, 1] at [9.73893723 9.73893723 1.50244081 6.05584192] is 0.87737556.\n", + "The QFI norm along [1, 1, 1, 1] at [10.05309649 10.05309649 1.50244081 6.05584192] is 0.24318658.\n", + "The QFI norm along [1, 1, 1, 1] at [10.36725576 10.36725576 1.50244081 6.05584192] is 0.26702836.\n", + "The QFI norm along [1, 1, 1, 1] at [10.68141502 10.68141502 1.50244081 6.05584192] is 0.90598547.\n", + "The QFI norm along [1, 1, 1, 1] at [10.99557429 10.99557429 1.50244081 6.05584192] is 2.01222750.\n", + "The QFI norm along [1, 1, 1, 1] at [11.30973355 11.30973355 1.50244081 6.05584192] is 3.32348596.\n", + "The QFI norm along [1, 1, 1, 1] at [11.62389282 11.62389282 1.50244081 6.05584192] is 4.52028855.\n", + "The QFI norm along [1, 1, 1, 1] at [11.93805208 11.93805208 1.50244081 6.05584192] is 5.39761453.\n", + "The QFI norm along [1, 1, 1, 1] at [12.25221135 12.25221135 1.50244081 6.05584192] is 5.86965007.\n", + "The QFI norm along [1, 1, 1, 1] at [12.56637061 12.56637061 1.50244081 6.05584192] is 5.99838655.\n" + ] + } + ], "source": [ "qf = QuantumFisher(cir)\n", "v = [1, 1, 1, 1]\n", @@ -572,7 +615,7 @@ "num_thetas = 41\n", "thetas = np.linspace(0, np.pi * 4, num_thetas)\n", "for theta in thetas:\n", - " list_param = cir.get_param().tolist()\n", + " list_param = cir.param.tolist()\n", " list_param[0] = theta\n", " list_param[1] = theta\n", " cir.update_param(list_param)\n", @@ -582,61 +625,26 @@ " f'The QFI norm along {v} at {np.array(list_param)} is {qfisher_norm:.8f}.'\n", " )\n", " list_qfisher_norm.append(qfisher_norm)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "The QFI norm along [1, 1, 1, 1] at [0. 0. 3.2533421 5.02652273] is 5.99962501.\n", - "The QFI norm along [1, 1, 1, 1] at [0.31415927 0.31415927 3.2533421 5.02652273] is 5.93033916.\n", - "The QFI norm along [1, 1, 1, 1] at [0.62831853 0.62831853 3.2533421 5.02652273] is 5.84133590.\n", - "The QFI norm along [1, 1, 1, 1] at [0.9424778 0.9424778 3.2533421 5.02652273] is 5.84309143.\n", - "The QFI norm along [1, 1, 1, 1] at [1.25663706 1.25663706 3.2533421 5.02652273] is 5.93367838.\n", - "The QFI norm along [1, 1, 1, 1] at [1.57079633 1.57079633 3.2533421 5.02652273] is 5.99962501.\n", - "The QFI norm along [1, 1, 1, 1] at [1.88495559 1.88495559 3.2533421 5.02652273] is 5.86697827.\n", - "The QFI norm along [1, 1, 1, 1] at [2.19911486 2.19911486 3.2533421 5.02652273] is 5.38230779.\n", - "The QFI norm along [1, 1, 1, 1] at [2.51327412 2.51327412 3.2533421 5.02652273] is 4.49128513.\n", - "The QFI norm along [1, 1, 1, 1] at [2.82743339 2.82743339 3.2533421 5.02652273] is 3.28287364.\n", - "The QFI norm along [1, 1, 1, 1] at [3.14159265 3.14159265 3.2533421 5.02652273] is 1.97995933.\n", - "The QFI norm along [1, 1, 1, 1] at [3.45575192 3.45575192 3.2533421 5.02652273] is 0.87758767.\n", - "The QFI norm along [1, 1, 1, 1] at [3.76991118 3.76991118 3.2533421 5.02652273] is 0.25010151.\n", - "The QFI norm along [1, 1, 1, 1] at [4.08407045 4.08407045 3.2533421 5.02652273] is 0.26070618.\n", - "The QFI norm along [1, 1, 1, 1] at [4.39822972 4.39822972 3.2533421 5.02652273] is 0.90660775.\n", - "The QFI norm along [1, 1, 1, 1] at [4.71238898 4.71238898 3.2533421 5.02652273] is 2.01995733.\n", - "The QFI norm along [1, 1, 1, 1] at [5.02654825 5.02654825 3.2533421 5.02652273] is 3.32425271.\n", - "The QFI norm along [1, 1, 1, 1] at [5.34070751 5.34070751 3.2533421 5.02652273] is 4.52539873.\n", - "The QFI norm along [1, 1, 1, 1] at [5.65486678 5.65486678 3.2533421 5.02652273] is 5.40406149.\n", - "The QFI norm along [1, 1, 1, 1] at [5.96902604 5.96902604 3.2533421 5.02652273] is 5.87599852.\n", - "The QFI norm along [1, 1, 1, 1] at [6.28318531 6.28318531 3.2533421 5.02652273] is 5.99962501.\n", - "The QFI norm along [1, 1, 1, 1] at [6.59734457 6.59734457 3.2533421 5.02652273] is 5.93033916.\n", - "The QFI norm along [1, 1, 1, 1] at [6.91150384 6.91150384 3.2533421 5.02652273] is 5.84133590.\n", - "The QFI norm along [1, 1, 1, 1] at [7.2256631 7.2256631 3.2533421 5.02652273] is 5.84309143.\n", - "The QFI norm along [1, 1, 1, 1] at [7.53982237 7.53982237 3.2533421 5.02652273] is 5.93367838.\n", - "The QFI norm along [1, 1, 1, 1] at [7.85398163 7.85398163 3.2533421 5.02652273] is 5.99962501.\n", - "The QFI norm along [1, 1, 1, 1] at [8.1681409 8.1681409 3.2533421 5.02652273] is 5.86697827.\n", - "The QFI norm along [1, 1, 1, 1] at [8.48230016 8.48230016 3.2533421 5.02652273] is 5.38230779.\n", - "The QFI norm along [1, 1, 1, 1] at [8.79645943 8.79645943 3.2533421 5.02652273] is 4.49128513.\n", - "The QFI norm along [1, 1, 1, 1] at [9.1106187 9.1106187 3.2533421 5.02652273] is 3.28287364.\n", - "The QFI norm along [1, 1, 1, 1] at [9.42477796 9.42477796 3.2533421 5.02652273] is 1.97995933.\n", - "The QFI norm along [1, 1, 1, 1] at [9.73893723 9.73893723 3.2533421 5.02652273] is 0.87758767.\n", - "The QFI norm along [1, 1, 1, 1] at [10.05309649 10.05309649 3.2533421 5.02652273] is 0.25010151.\n", - "The QFI norm along [1, 1, 1, 1] at [10.36725576 10.36725576 3.2533421 5.02652273] is 0.26070618.\n", - "The QFI norm along [1, 1, 1, 1] at [10.68141502 10.68141502 3.2533421 5.02652273] is 0.90660775.\n", - "The QFI norm along [1, 1, 1, 1] at [10.99557429 10.99557429 3.2533421 5.02652273] is 2.01995733.\n", - "The QFI norm along [1, 1, 1, 1] at [11.30973355 11.30973355 3.2533421 5.02652273] is 3.32425271.\n", - "The QFI norm along [1, 1, 1, 1] at [11.62389282 11.62389282 3.2533421 5.02652273] is 4.52539873.\n", - "The QFI norm along [1, 1, 1, 1] at [11.93805208 11.93805208 3.2533421 5.02652273] is 5.40406149.\n", - "The QFI norm along [1, 1, 1, 1] at [12.25221135 12.25221135 3.2533421 5.02652273] is 5.87599852.\n", - "The QFI norm along [1, 1, 1, 1] at [12.56637061 12.56637061 3.2533421 5.02652273] is 5.99962501.\n" - ] - } - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# 创建图像\n", "fig = plt.figure(figsize=(9, 6))\n", @@ -654,57 +662,36 @@ "ax.set_ylabel('QFI norm along $v=(1,1,1,1)$', fontsize=label_font_size)\n", "ax.set_ylim([-1, 9])\n", "ax.tick_params(labelsize=label_font_size)" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "可以看到程序的输出和解析结果是一致的。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### 计算有效量子维数\n", "\n", "利用量桨，我们可以通过调用 `get_eff_qdim()` 方法方便地计算有效量子维数（effective quantum dimension, EQD）。以下是上面提到的 hardware-efficient 拟设的 EQD 计算示例。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 10, - "source": [ - "cir = circuit_hardeff_2qubit()\n", - "qf = QuantumFisher(cir)\n", - "print(cir)\n", - "print(f'The number of parameters is {len(cir.get_param().tolist())}.')\n", - "print(f'The EQD is {qf.get_eff_qdim()}. \\n')" - ], + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "--Ry(4.248)----*----Ry(1.233)--\n", + "--Ry(4.207)----*----Ry(2.825)--\n", " | \n", - "--Ry(6.121)----x----Ry(4.717)--\n", + "--Ry(1.769)----x----Ry(4.774)--\n", " \n", "The number of parameters is 4.\n", "The EQD is 3. \n", @@ -712,52 +699,35 @@ ] } ], - "metadata": {} + "source": [ + "cir = circuit_hardeff_2qubit()\n", + "qf = QuantumFisher(cir)\n", + "print(cir)\n", + "print(f'The number of parameters is {len(cir.param.tolist())}.')\n", + "print(f'The EQD is {qf.get_eff_qdim()}. \\n')" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "在这个例子中，EQD 比参数个数要少，这实际上可以通过控制电路上两个 $R_y$ 可以直接合并这一点上看出来。这可以通过替换其中一个 $R_y$ 门为 $R_x$ 门来修复，这会使得 EQD 增长 1。\n", "\n", "如果继续在电路上增加门，EQD 会无限增长吗？答案显然是不会，这是因为对于 $n$ 个量子比特，量子态的实数自由度为 $2\\cdot 2^n-2$，其中减 $2$ 是由于归一化和全局相位无关性这两条约束。这说明无论门的数量为多少，EQD 都不会超过 $2\\cdot 2^n-2$。我们可以通过下面的例子做一简单的验证。" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 11, - "source": [ - "def circuit_hardeff_overparam():\n", - " cir = UAnsatz(2)\n", - " theta = 2 * np.pi * np.random.random(8)\n", - " theta = paddle.to_tensor(theta, stop_gradient=False, dtype='float64')\n", - " cir.ry(theta[0], which_qubit=0)\n", - " cir.ry(theta[1], which_qubit=1)\n", - " cir.rx(theta[2], which_qubit=0)\n", - " cir.rx(theta[3], which_qubit=1)\n", - " cir.cnot(control=[0, 1])\n", - " cir.ry(theta[4], which_qubit=0)\n", - " cir.ry(theta[5], which_qubit=1)\n", - " cir.rx(theta[6], which_qubit=0)\n", - " cir.rx(theta[7], which_qubit=1)\n", - "\n", - " return cir\n", - "\n", - "\n", - "cir = circuit_hardeff_overparam()\n", - "qf = QuantumFisher(cir)\n", - "print(cir)\n", - "print(f'The number of parameters is {len(cir.get_param().tolist())}.')\n", - "print(f'The EQD is {qf.get_eff_qdim()}. \\n')" - ], + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "--Ry(0.173)----Rx(5.837)----*----Ry(3.082)----Rx(3.997)--\n", + "--Ry(1.794)----Rx(3.255)----*----Ry(2.579)----Rx(4.742)--\n", " | \n", - "--Ry(1.354)----Rx(0.536)----x----Ry(5.267)----Rx(5.647)--\n", + "--Ry(1.964)----Rx(1.118)----x----Ry(1.707)----Rx(0.770)--\n", " \n", "The number of parameters is 8.\n", "The EQD is 6. \n", @@ -765,106 +735,113 @@ ] } ], - "metadata": {} - }, - { - "cell_type": "markdown", "source": [ - "### 计算经典费舍信息和有效维数\n", + "def circuit_hardeff_overparam():\n", + " cir = Circuit(2)\n", + " cir.ry()\n", + " cir.rx()\n", + " cir.cnot([0, 1])\n", + " cir.ry()\n", + " cir.rx()\n", + "\n", + " return cir\n", "\n", - "这里我们举一个简单的例子来展示如何利用量桨对于一个量子神经网络计算式 (16) 中的有效维数。\n", "\n", - "首先，定义经典数据到量子数据的编码方式。" - ], - "metadata": {} + "cir = circuit_hardeff_overparam()\n", + "qf = QuantumFisher(cir)\n", + "print(cir)\n", + "print(f'The number of parameters is {len(cir.param.tolist())}.')\n", + "print(f'The EQD is {qf.get_eff_qdim()}. \\n')" + ] }, { - "cell_type": "code", - "execution_count": 12, + "cell_type": "markdown", + "metadata": {}, "source": [ - "def U_theta(x, theta, num_qubits, depth, encoding):\n", - " cir = UAnsatz(num_qubits)\n", - " if encoding == 'IQP':\n", - " S = [[i, i + 1] for i in range(num_qubits - 1)]\n", - " cir.iqp_encoding(x, num_repeats=1, pattern=S)\n", - " cir.complex_entangled_layer(theta, depth)\n", - " elif encoding == 're-uploading':\n", - " for i in range(depth):\n", - " cir.complex_entangled_layer(theta[i:i + 1], depth=1)\n", - " for j in range(num_qubits):\n", - " cir.rx(x[j], which_qubit=j)\n", - " cir.complex_entangled_layer(theta[-1:], depth=1)\n", - " else:\n", - " raise RuntimeError('Non-existent encoding method')\n", - " return cir" - ], - "outputs": [], - "metadata": {} + "### 计算经典费舍信息和有效维数\n", + "\n", + "这里我们举一个简单的例子来展示如何利用量桨对于一个量子神经网络计算式 (16) 中的有效维数。" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "然后调用飞桨定义量子神经网络和相应的损失函数。" - ], - "metadata": {} + "调用飞桨定义量子神经网络和相应的损失函数。" + ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 12, + "metadata": {}, + "outputs": [], "source": [ "import paddle.nn as nn\n", + "from paddle_quantum.gate import IQPEncoding, ComplexEntangledLayer, RX\n", + "from paddle_quantum.hamiltonian import Hamiltonian\n", + "from paddle_quantum.state import zero_state\n", "\n", "class QuantumNeuralNetwork(nn.Layer):\n", " def __init__(self, num_qubits, depth, encoding):\n", " super().__init__()\n", - " self.num_qubits, self.depth, self.encoding = num_qubits, depth, encoding\n", - " if self.encoding == 'IQP':\n", - " self.theta = self.create_parameter(\n", - " shape=[self.depth, self.num_qubits, 3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0,\n", - " high=2 *\n", - " np.pi),\n", - " dtype='float64',\n", - " is_bias=False)\n", - " elif self.encoding == 're-uploading':\n", - " self.theta = self.create_parameter(\n", - " shape=[self.depth + 1, self.num_qubits, 3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0,\n", - " high=2 *\n", - " np.pi),\n", - " dtype='float64',\n", - " is_bias=False)\n", + " self.num_qubits, self.encoding = num_qubits, encoding\n", + " self.S = [[i, i + 1] for i in range(num_qubits - 1)]\n", + " self.init_state = zero_state(num_qubits)\n", + " \n", + " if encoding == 'IQP':\n", + " self.complex_layer = nn.LayerList([ComplexEntangledLayer(num_qubits=num_qubits, depth=depth)])\n", + " elif encoding == 're-uploading':\n", + " self.complex_layers = nn.LayerList([ComplexEntangledLayer(num_qubits=num_qubits) for _ in range(depth + 1)])\n", " else:\n", " raise RuntimeError('Non-existent encoding method')\n", "\n", " def forward(self, x):\n", " if not paddle.is_tensor(x):\n", - " x = paddle.to_tensor(x)\n", - " cir = U_theta(x, self.theta, self.num_qubits, self.depth,\n", - " self.encoding)\n", - " cir.run_state_vector()\n", - " return cir.expecval([[1.0, 'z0']]) * paddle.to_tensor(\n", - " [0.5], dtype='float64') + paddle.to_tensor([0.5], dtype='float64')" - ], - "outputs": [], - "metadata": {} + " x = paddle.to_tensor(x, dtype='float32')\n", + "\n", + " state = self.init_state\n", + " if self.encoding == 'IQP':\n", + " state = IQPEncoding(x, qubits_idx=self.S)(state)\n", + " state = self.complex_layer[0](state)\n", + " else:\n", + " for i in range(depth):\n", + " state = self.complex_layers[i](state)\n", + " for j in range(num_qubits):\n", + " state = RX(j, param=x[j].item())(state)\n", + " state = self.complex_layers[depth](state)\n", + "\n", + " return state.expec_val(Hamiltonian([[1.0, 'z0']])) * 0.5 + 0.5" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "最后，定义 CFIM 计算器并计算不同大小的训练集对应的有效维数。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "running in get_gradient: 100%|##################################| 1000/1000 [00:45<00:00, 22.07it/s]\n" + ] + } + ], "source": [ + "from paddle_quantum import set_backend\n", + "\n", "# 配置模型参数\n", "num_qubits = 4\n", "depth = 2\n", "num_inputs = 100\n", "num_thetas = 10\n", + "set_backend('state_vector')\n", "# 定义 CFIM 计算器\n", "cfim = ClassicalFisher(model=QuantumNeuralNetwork,\n", " num_thetas=num_thetas,\n", @@ -877,72 +854,63 @@ "# 计算不同样本大小对应的有效维数\n", "n = [5000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000, 1000000]\n", "effdim = cfim.get_eff_dim(fim, n)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "running in get_gradient: 100%|##################################| 1000/1000 [02:05<00:00, 7.94it/s]\n" - ] - } - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "画出有效维数与参数个数之比随训练集大小的变化规律。" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 19, - "source": [ - "fig = plt.figure(figsize=(9, 6))\n", - "ax = fig.add_subplot(111)\n", - "print('the number of parameters：%s' % cfim.num_params)\n", - "ax.plot(n, np.array(effdim) / cfim.num_params)\n", - "label_font_size = 14\n", - "ax.set_xlabel('sample size', fontsize=label_font_size)\n", - "ax.set_ylabel('effective dimension / number of parameters', fontsize=label_font_size)\n", - "ax.tick_params(labelsize=label_font_size)" - ], + "execution_count": 14, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "the number of parameters：24\n" ] }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], - "metadata": {} + "source": [ + "fig = plt.figure(figsize=(9, 6))\n", + "ax = fig.add_subplot(111)\n", + "print('the number of parameters：%s' % cfim.num_params)\n", + "ax.plot(n, np.array(effdim) / cfim.num_params)\n", + "label_font_size = 14\n", + "ax.set_xlabel('sample size', fontsize=label_font_size)\n", + "ax.set_ylabel('effective dimension / number of parameters', fontsize=label_font_size)\n", + "ax.tick_params(labelsize=label_font_size)" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## 总结\n", "\n", "本教程从几何的角度简要介绍了经典费舍信息和量子费舍信息的概念及二者之间的关系，并以有效维数为例阐述了它们在量子机器学习中的应用，最后展示了如何调用量桨来具体地计算它们。" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "_______\n", "\n", @@ -959,13 +927,15 @@ "[5] Datta, Nilanjana, and Felix Leditzky. \"A limit of the quantum Rényi divergence.\" [Journal of Physics A: Mathematical and Theoretical 47.4 (2014): 045304.](https://iopscience.iop.org/article/10.1088/1751-8113/47/4/045304)\n", "\n", "[6] Abbas, Amira, et al. \"The power of quantum neural networks.\" [Nature Computational Science 1.6 (2021): 403-409.](https://www.nature.com/articles/s43588-021-00084-1)" - ], - "metadata": {} + ] } ], "metadata": { + "interpreter": { + "hash": "2ab84abaf8d5bbc8765aba8eb82d11e7069f2ff20e8f79b8a9cdeccefd2ac4da" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.13 ('pq_new')", "language": "python", "name": "python3" }, @@ -979,9 +949,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" } }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/tutorial/qnn_research/Fisher_EN.ipynb b/tutorials/qnn_research/Fisher_EN.ipynb similarity index 54% rename from tutorial/qnn_research/Fisher_EN.ipynb rename to tutorials/qnn_research/Fisher_EN.ipynb index 4593e26..871b91c 100644 --- a/tutorial/qnn_research/Fisher_EN.ipynb +++ b/tutorials/qnn_research/Fisher_EN.ipynb @@ -2,35 +2,36 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "source": [ "# Quantum Fisher Information\n", "\n", " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Overview\n", "\n", "In this tutorial, we briefly introduce the concepts of the classical and quantum Fisher information, along with their applications in quantum machine learning, and show how to compute them with Paddle Quantum." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Background\n", "\n", "The quantum Fisher information (QFI) originates from the field of quantum sensing and have been versatile tools to study parameterized quantum systems [[1]](https://arxiv.org/abs/2103.15191), such as characterizing the overparameterization [[2]](https://arxiv.org/abs/2102.01659) and performing the quantum natural gradient descent [[3]](https://arxiv.org/abs/1909.02108). The QFI is a quantum analogue of the classical Fisher information (CFI). The CFI characterizes the sensibility of a parameterized **probability distribution** to parameter changes, while the QFI characterizes the sensibility of a parameterized **quantum state** to parameter changes.\n", "\n", "In a traditional introduction, the CFI will appear as a quantity of parameter estimation in mathematical statistics, which might be complicated and confusing for the beginners. This tutorial will introduce the CFI from a geometric point of view, which is not only helpful for intuitive understanding, but also easier to see the relationship between the CFI and QFI." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Classical Fisher information\n", "\n", @@ -108,11 +109,11 @@ "Why is $\\mathcal{I}(\\boldsymbol{\\theta})$ called \"information\"? Geometrically, the CFIM characterizes the sensitivity / sharpness of a probability distribution in the vicinity of $\\boldsymbol{\\theta}$. The more sensitive it is to a parameter change, the easier one can discriminate it from others, the fewer samples are needed to discriminate it, the more information per sample can give.\n", "\n", "The measurement outcomes from a parameterized quantum circuit (PQC) form a parameterized probability distribution. So one can define a CFIM for each kind of measurement on a PQC. Currently, the main challenge of calculating CFIM on NISQ devices is that the number of possible measurement outputs increases exponentially with the number of qubits, which means that there may be many measurement outputs with low probabilities that never appear, leading to divergence in CFIM calculations. Possible solutions includes neglecting small probabilities (cause diverge) and Bayesian updating [[1]](https://arxiv.org/abs/2103.15191)." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Quantum Fisher information\n", "\n", @@ -148,7 +149,7 @@ "\\end{aligned}\n", "\\tag{9}\n", "$$\n", - "where $\\boldsymbol{e}_{i}$ denotes the unit vector corresponding to $\\theta_i$.\n", + "where $\\boldsymbol{e}_{i}$ denotes the unit vector corresponding to $\\theta_i$. Note that the parameter shift rule can not be directly applied to the case where there are dependencies among parameters in single-qubit rotation gates, such as controlled rotation gates.\n", "\n", "- applying the finite difference expression to calculate the projection along a certain direction [[1]](https://arxiv.org/abs/2103.15191)\n", "$$\n", @@ -178,11 +179,11 @@ "$$\n", "\n", "Please see the review [[1]](https://arxiv.org/abs/2103.15191) for more details." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### The relation between CFIM and QFIM\n", "\n", @@ -194,11 +195,11 @@ "$$\n", "\n", "where $\\mathcal{E}$ denotes the quantum operation corresponding to the measurement, and the inequality between two positive matrices means that the large minus the small is still a positive matrix. This is a natural result since measurements can not extract more information than the quantum state itself, which mathematically stems from the monotonicity of the fidelity distance with respect to trace-preserving quantum operations [[1]](https://arxiv.org/abs/2103.15191)." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Application: effective dimension\n", "\n", @@ -243,50 +244,50 @@ "This definition might be strange and confusing at first glance, which is far more complicated than the maximal rank of the CFIM. However, it can converge to the maximal rank of the CFIM in the limit of infinite samples $n\\rightarrow \\infty$ [[6]](https://arxiv.org/abs/2011.00027). Regardless of the coefficients and the logarithm, the effective dimension here can be seen roughly as the geometric mean of the spectrum of the normalized CFIM plus an identity, then averaging over the parameter space. Associated with the inequality between the geometric mean and the arithmetic mean, we may expect that a more uniform empirical CFIM spectrum leads to a larger effective dimension, which is consistent with our natural impression. In this sense, it is a \"soft\" version of the effective dimension.\n", "\n", "In addition, the Fisher information can not only provide an capacity measure, but also can serve as an indicator of trainability. If the entries of the Fisher information vanish exponentially with the system size averaging over the parameter space, i.e. the sensitivity becomes exponentially small, we can not distinguish them efficiently, which indicates the existence of barrens plateaus [[6]](https://arxiv.org/abs/2011.00027)." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Paddle Quantum Implementation" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Calculate the QFIM\n", "\n", "With Paddle Quantum, one can obtain the QFIM conveniently by the following steps.\n", "\n", - "1. Define a quantum circuit using `UAnsatz`.\n", + "1. Define a quantum circuit using `Circuit`.\n", "2. Define a `QuantumFisher` class as a calculator of the QFIM.\n", "3. Use the method `get_qfisher_matrix()` to calculate the QFIM.\n", "\n", - "The calculator `QuantumFisher` will keep track of the change of the circuit `UAnsatz`.\n", + "The calculator `QuantumFisher` will keep track of the change of the circuit `Circuit`.\n", "\n", "Now let's code. Firstly, import packages." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 16, + "metadata": {}, + "outputs": [], "source": [ "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.ansatz import Circuit\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", - "from paddle_quantum.utils import QuantumFisher, ClassicalFisher\n", + "from paddle_quantum.fisher import QuantumFisher, ClassicalFisher\n", "import warnings\n", "warnings.filterwarnings(\"ignore\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Then, define a quantum circuit. As a simple example, we exploit a single qubit parameterized by two Bloch angles\n", "\n", @@ -304,54 +305,122 @@ "\\end{matrix}\\right).\n", "\\tag{19}\n", "$$" - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 17, + "metadata": {}, + "outputs": [], "source": [ "def circuit_bloch():\n", - " cir = UAnsatz(1)\n", - " theta = 2 * np.pi * np.random.random(2)\n", - " theta = paddle.to_tensor(theta, stop_gradient=False, dtype='float64')\n", - " cir.ry(theta[0], which_qubit=0)\n", - " cir.rz(theta[1], which_qubit=0)\n", - " \n", + " cir = Circuit(1)\n", + " cir.ry()\n", + " cir.rz()\n", " return cir" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 3, - "source": [ - "cir = circuit_bloch()\n", - "print(cir)" - ], + "execution_count": 18, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "--Ry(1.888)----Rz(2.181)--\n", + "--Ry(2.384)----Rz(5.641)--\n", " \n" ] } ], - "metadata": {} + "source": [ + "cir = circuit_bloch()\n", + "print(cir)" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Define a QFIM calculator and calculate the QFIM element $\\mathcal{F}_{\\phi\\phi}$ corresponding to different $\\theta$." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The QFIM at [0. 5.64109135] is \n", + " [[ 9.99999881e-01 0.00000000e+00]\n", + " [ 0.00000000e+00 -5.96046400e-08]].\n", + "The QFIM at [0.15707963 5.64109135] is \n", + " [[1.00000000e+00 6.53168000e-09]\n", + " [6.53168000e-09 2.44715806e-02]].\n", + "The QFIM at [0.31415927 5.64109135] is \n", + " [[1.0000000e+00 6.0467490e-08]\n", + " [6.0467490e-08 9.5491401e-02]].\n", + "The QFIM at [0.4712389 5.64109135] is \n", + " [[1.00000000e+00 3.25239200e-08]\n", + " [3.25239200e-08 2.06107365e-01]].\n", + "The QFIM at [0.62831853 5.64109135] is \n", + " [[0.99999988 0. ]\n", + " [0. 0.34549142]].\n", + "The QFIM at [0.78539816 5.64109135] is \n", + " [[ 9.99999881e-01 -3.67179700e-08]\n", + " [-3.67179700e-08 4.99999940e-01]].\n", + "The QFIM at [0.9424778 5.64109135] is \n", + " [[1. 0. ]\n", + " [0. 0.65450851]].\n", + "The QFIM at [1.09955743 5.64109135] is \n", + " [[0.99999976 0. ]\n", + " [0. 0.79389244]].\n", + "The QFIM at [1.25663706 5.64109135] is \n", + " [[0.99999988 0. ]\n", + " [0. 0.90450845]].\n", + "The QFIM at [1.41371669 5.64109135] is \n", + " [[ 1.00000000e+00 -4.52859700e-08]\n", + " [-4.52859700e-08 9.75528206e-01]].\n", + "The QFIM at [1.57079633 5.64109135] is \n", + " [[1.000000e+00 4.214685e-08]\n", + " [4.214685e-08 1.000000e+00]].\n", + "The QFIM at [1.72787596 5.64109135] is \n", + " [[1. 0. ]\n", + " [0. 0.97552827]].\n", + "The QFIM at [1.88495559 5.64109135] is \n", + " [[ 1.00000000e+00 -3.54160800e-08]\n", + " [-3.54160800e-08 9.04508529e-01]].\n", + "The QFIM at [2.04203522 5.64109135] is \n", + " [[ 9.99999881e-01 -8.24729700e-08]\n", + " [-8.24729700e-08 7.93892489e-01]].\n", + "The QFIM at [2.19911486 5.64109135] is \n", + " [[ 1.00000000e+00 -1.02392670e-07]\n", + " [-1.02392670e-07 6.54508507e-01]].\n", + "The QFIM at [2.35619449 5.64109135] is \n", + " [[9.99999762e-01 3.67179700e-08]\n", + " [3.67179700e-08 4.99999905e-01]].\n", + "The QFIM at [2.51327412 5.64109135] is \n", + " [[ 9.99999881e-01 -3.05229200e-08]\n", + " [-3.05229200e-08 3.45491419e-01]].\n", + "The QFIM at [2.67035376 5.64109135] is \n", + " [[1.0000000e+00 3.2523910e-08]\n", + " [3.2523910e-08 2.0610763e-01]].\n", + "The QFIM at [2.82743339 5.64109135] is \n", + " [[9.99999881e-01 4.79417900e-08]\n", + " [4.79417900e-08 9.54914519e-02]].\n", + "The QFIM at [2.98451302 5.64109135] is \n", + " [[1. 0. ]\n", + " [0. 0.02447182]].\n", + "The QFIM at [3.14159265 5.64109135] is \n", + " [[ 9.99999881e-01 8.42936900e-08]\n", + " [ 8.42936900e-08 -5.96046400e-08]].\n" + ] + } + ], "source": [ "qf = QuantumFisher(cir)\n", "# Record the QFIM element F_{phi,phi}\n", @@ -359,97 +428,40 @@ "num_thetas = 21\n", "thetas = np.linspace(0, np.pi, num_thetas)\n", "for theta in thetas:\n", - " list_param = cir.get_param().tolist()\n", + " list_param = cir.param.tolist()\n", " list_param[0] = theta\n", " cir.update_param(list_param)\n", " # Calculate the QFIM\n", " qfim = qf.get_qfisher_matrix()\n", " print(f'The QFIM at {np.array(list_param)} is \\n {qfim.round(14)}.')\n", " list_qfisher_elements.append(qfim[1][1])" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "The QFIM at [0. 2.18107874] is \n", - " [[1. 0.]\n", - " [0. 0.]].\n", - "The QFIM at [0.15707963 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.02447174]].\n", - "The QFIM at [0.31415927 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.0954915]].\n", - "The QFIM at [0.4712389 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.20610737]].\n", - "The QFIM at [0.62831853 2.18107874] is \n", - " [[ 1. -0. ]\n", - " [-0. 0.3454915]].\n", - "The QFIM at [0.78539816 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.5]].\n", - "The QFIM at [0.9424778 2.18107874] is \n", - " [[ 1. -0. ]\n", - " [-0. 0.6545085]].\n", - "The QFIM at [1.09955743 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.79389263]].\n", - "The QFIM at [1.25663706 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.9045085]].\n", - "The QFIM at [1.41371669 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.97552826]].\n", - "The QFIM at [1.57079633 2.18107874] is \n", - " [[1. 0.]\n", - " [0. 1.]].\n", - "The QFIM at [1.72787596 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.97552826]].\n", - "The QFIM at [1.88495559 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.9045085]].\n", - "The QFIM at [2.04203522 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.79389263]].\n", - "The QFIM at [2.19911486 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.6545085]].\n", - "The QFIM at [2.35619449 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.5]].\n", - "The QFIM at [2.51327412 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.3454915]].\n", - "The QFIM at [2.67035376 2.18107874] is \n", - " [[ 1. -0. ]\n", - " [-0. 0.20610737]].\n", - "The QFIM at [2.82743339 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.0954915]].\n", - "The QFIM at [2.98451302 2.18107874] is \n", - " [[1. 0. ]\n", - " [0. 0.02447174]].\n", - "The QFIM at [3.14159265 2.18107874] is \n", - " [[1. 0.]\n", - " [0. 0.]].\n" - ] - } - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Plot the outputs of the QFIM element $\\mathcal{F}_{\\phi\\phi}$ as function of $\\theta$." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "# Create a figure\n", "fig = plt.figure(figsize=(9, 6))\n", @@ -465,25 +477,11 @@ "ax.set_xlabel('$\\\\theta$', fontsize=label_font_size)\n", "ax.set_ylabel('QFIM element $\\\\mathcal{F}_{\\\\phi\\\\phi}$', fontsize=label_font_size)\n", "ax.tick_params(labelsize=label_font_size)" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "We can see that the outputs are consistent with the analytical results.\n", "\n", @@ -510,59 +508,104 @@ "$$\n", "\n", "Define the corresponding quantum circuit." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 21, + "metadata": {}, + "outputs": [], "source": [ "def circuit_hardeff_2qubit():\n", - " cir = UAnsatz(2)\n", - " theta = 2 * np.pi * np.random.random(4)\n", - " theta = paddle.to_tensor(theta, stop_gradient=False, dtype='float64')\n", - " cir.ry(theta[0], which_qubit=0)\n", - " cir.ry(theta[1], which_qubit=1)\n", - " cir.cnot(control=[0, 1])\n", - " cir.ry(theta[2], which_qubit=0)\n", - " cir.ry(theta[3], which_qubit=1)\n", + " cir = Circuit(2)\n", + " cir.ry()\n", + " cir.cnot([0, 1])\n", + " cir.ry()\n", "\n", " return cir" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 7, - "source": [ - "cir = circuit_hardeff_2qubit()\n", - "print(cir)" - ], + "execution_count": 22, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "--Ry(2.614)----*----Ry(3.253)--\n", + "--Ry(0.069)----*----Ry(5.656)--\n", " | \n", - "--Ry(2.906)----x----Ry(5.027)--\n", + "--Ry(0.001)----x----Ry(5.061)--\n", " \n" ] } ], - "metadata": {} + "source": [ + "cir = circuit_hardeff_2qubit()\n", + "print(cir)" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Define a QFIM calculator and calculate the quantum Fisher-Rao norm $\\boldsymbol{v}^T\\mathcal{F}\\boldsymbol{v}$ along the direction $\\boldsymbol{v}=(1,1,1,1)$ corresponding to different $\\theta$ (set $\\theta_1=\\theta_2=\\theta$)." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The QFI norm along [1, 1, 1, 1] at [0. 0. 5.65593147 5.06090069] is 6.00792258.\n", + "The QFI norm along [1, 1, 1, 1] at [0.31415927 0.31415927 5.65593147 5.06090069] is 5.93163433.\n", + "The QFI norm along [1, 1, 1, 1] at [0.62831853 0.62831853 5.65593147 5.06090069] is 5.85534601.\n", + "The QFI norm along [1, 1, 1, 1] at [0.9424778 0.9424778 5.65593147 5.06090069] is 5.83627391.\n", + "The QFI norm along [1, 1, 1, 1] at [1.25663706 1.25663706 5.65593147 5.06090069] is 5.93163433.\n", + "The QFI norm along [1, 1, 1, 1] at [1.57079633 1.57079633 5.65593147 5.06090069] is 6.01269060.\n", + "The QFI norm along [1, 1, 1, 1] at [1.88495559 1.88495559 5.65593147 5.06090069] is 5.87441809.\n", + "The QFI norm along [1, 1, 1, 1] at [2.19911486 2.19911486 5.65593147 5.06090069] is 5.37854233.\n", + "The QFI norm along [1, 1, 1, 1] at [2.51327412 2.51327412 5.65593147 5.06090069] is 4.49644803.\n", + "The QFI norm along [1, 1, 1, 1] at [2.82743339 2.82743339 5.65593147 5.06090069] is 3.28057238.\n", + "The QFI norm along [1, 1, 1, 1] at [3.14159265 3.14159265 5.65593147 5.06090069] is 1.98361799.\n", + "The QFI norm along [1, 1, 1, 1] at [3.45575192 3.45575192 5.65593147 5.06090069] is 0.87260724.\n", + "The QFI norm along [1, 1, 1, 1] at [3.76991118 3.76991118 5.65593147 5.06090069] is 0.25749165.\n", + "The QFI norm along [1, 1, 1, 1] at [4.08407045 4.08407045 5.65593147 5.06090069] is 0.26702836.\n", + "The QFI norm along [1, 1, 1, 1] at [4.39822972 4.39822972 5.65593147 5.06090069] is 0.91552211.\n", + "The QFI norm along [1, 1, 1, 1] at [4.71238898 4.71238898 5.65593147 5.06090069] is 2.04083701.\n", + "The QFI norm along [1, 1, 1, 1] at [5.02654825 5.02654825 5.65593147 5.06090069] is 3.32825413.\n", + "The QFI norm along [1, 1, 1, 1] at [5.34070751 5.34070751 5.65593147 5.06090069] is 4.54412905.\n", + "The QFI norm along [1, 1, 1, 1] at [5.65486678 5.65486678 5.65593147 5.06090069] is 5.40715063.\n", + "The QFI norm along [1, 1, 1, 1] at [5.96902604 5.96902604 5.65593147 5.06090069] is 5.89349018.\n", + "The QFI norm along [1, 1, 1, 1] at [6.28318531 6.28318531 5.65593147 5.06090069] is 6.01269060.\n", + "The QFI norm along [1, 1, 1, 1] at [6.59734457 6.59734457 5.65593147 5.06090069] is 5.94117037.\n", + "The QFI norm along [1, 1, 1, 1] at [6.91150384 6.91150384 5.65593147 5.06090069] is 5.85057798.\n", + "The QFI norm along [1, 1, 1, 1] at [7.2256631 7.2256631 5.65593147 5.06090069] is 5.83150589.\n", + "The QFI norm along [1, 1, 1, 1] at [7.53982237 7.53982237 5.65593147 5.06090069] is 5.93163433.\n", + "The QFI norm along [1, 1, 1, 1] at [7.85398163 7.85398163 5.65593147 5.06090069] is 6.00315457.\n", + "The QFI norm along [1, 1, 1, 1] at [8.1681409 8.1681409 5.65593147 5.06090069] is 5.87918611.\n", + "The QFI norm along [1, 1, 1, 1] at [8.48230016 8.48230016 5.65593147 5.06090069] is 5.38331038.\n", + "The QFI norm along [1, 1, 1, 1] at [8.79645943 8.79645943 5.65593147 5.06090069] is 4.49167993.\n", + "The QFI norm along [1, 1, 1, 1] at [9.1106187 9.1106187 5.65593147 5.06090069] is 3.29487691.\n", + "The QFI norm along [1, 1, 1, 1] at [9.42477796 9.42477796 5.65593147 5.06090069] is 1.98361799.\n", + "The QFI norm along [1, 1, 1, 1] at [9.73893723 9.73893723 5.65593147 5.06090069] is 0.88691220.\n", + "The QFI norm along [1, 1, 1, 1] at [10.05309649 10.05309649 5.65593147 5.06090069] is 0.24795494.\n", + "The QFI norm along [1, 1, 1, 1] at [10.36725576 10.36725576 5.65593147 5.06090069] is 0.26702836.\n", + "The QFI norm along [1, 1, 1, 1] at [10.68141502 10.68141502 5.65593147 5.06090069] is 0.90598547.\n", + "The QFI norm along [1, 1, 1, 1] at [10.99557429 10.99557429 5.65593147 5.06090069] is 2.02176400.\n", + "The QFI norm along [1, 1, 1, 1] at [11.30973355 11.30973355 5.65593147 5.06090069] is 3.32825413.\n", + "The QFI norm along [1, 1, 1, 1] at [11.62389282 11.62389282 5.65593147 5.06090069] is 4.52982475.\n", + "The QFI norm along [1, 1, 1, 1] at [11.93805208 11.93805208 5.65593147 5.06090069] is 5.40715063.\n", + "The QFI norm along [1, 1, 1, 1] at [12.25221135 12.25221135 5.65593147 5.06090069] is 5.88395414.\n", + "The QFI norm along [1, 1, 1, 1] at [12.56637061 12.56637061 5.65593147 5.06090069] is 6.00792258.\n" + ] + } + ], "source": [ "qf = QuantumFisher(cir)\n", "v = [1, 1, 1, 1]\n", @@ -571,71 +614,36 @@ "num_thetas = 41\n", "thetas = np.linspace(0, np.pi * 4, num_thetas)\n", "for theta in thetas:\n", - " list_param = cir.get_param().tolist()\n", + " list_param = cir.param.tolist()\n", " list_param[0] = theta\n", " list_param[1] = theta\n", " cir.update_param(list_param)\n", - " # Calculate the QFI norm\n", + " # 计算 QFIM 投影\n", " qfisher_norm = qf.get_qfisher_norm(v)\n", " print(\n", " f'The QFI norm along {v} at {np.array(list_param)} is {qfisher_norm:.8f}.'\n", " )\n", " list_qfisher_norm.append(qfisher_norm)" - ], + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, "outputs": [ { - "output_type": "stream", - "name": "stdout", - "text": [ - "The QFI norm along [1, 1, 1, 1] at [0. 0. 3.2533421 5.02652273] is 5.99962501.\n", - "The QFI norm along [1, 1, 1, 1] at [0.31415927 0.31415927 3.2533421 5.02652273] is 5.93033916.\n", - "The QFI norm along [1, 1, 1, 1] at [0.62831853 0.62831853 3.2533421 5.02652273] is 5.84133590.\n", - "The QFI norm along [1, 1, 1, 1] at [0.9424778 0.9424778 3.2533421 5.02652273] is 5.84309143.\n", - "The QFI norm along [1, 1, 1, 1] at [1.25663706 1.25663706 3.2533421 5.02652273] is 5.93367838.\n", - "The QFI norm along [1, 1, 1, 1] at [1.57079633 1.57079633 3.2533421 5.02652273] is 5.99962501.\n", - "The QFI norm along [1, 1, 1, 1] at [1.88495559 1.88495559 3.2533421 5.02652273] is 5.86697827.\n", - "The QFI norm along [1, 1, 1, 1] at [2.19911486 2.19911486 3.2533421 5.02652273] is 5.38230779.\n", - "The QFI norm along [1, 1, 1, 1] at [2.51327412 2.51327412 3.2533421 5.02652273] is 4.49128513.\n", - "The QFI norm along [1, 1, 1, 1] at [2.82743339 2.82743339 3.2533421 5.02652273] is 3.28287364.\n", - "The QFI norm along [1, 1, 1, 1] at [3.14159265 3.14159265 3.2533421 5.02652273] is 1.97995933.\n", - "The QFI norm along [1, 1, 1, 1] at [3.45575192 3.45575192 3.2533421 5.02652273] is 0.87758767.\n", - "The QFI norm along [1, 1, 1, 1] at [3.76991118 3.76991118 3.2533421 5.02652273] is 0.25010151.\n", - "The QFI norm along [1, 1, 1, 1] at [4.08407045 4.08407045 3.2533421 5.02652273] is 0.26070618.\n", - "The QFI norm along [1, 1, 1, 1] at [4.39822972 4.39822972 3.2533421 5.02652273] is 0.90660775.\n", - "The QFI norm along [1, 1, 1, 1] at [4.71238898 4.71238898 3.2533421 5.02652273] is 2.01995733.\n", - "The QFI norm along [1, 1, 1, 1] at [5.02654825 5.02654825 3.2533421 5.02652273] is 3.32425271.\n", - "The QFI norm along [1, 1, 1, 1] at [5.34070751 5.34070751 3.2533421 5.02652273] is 4.52539873.\n", - "The QFI norm along [1, 1, 1, 1] at [5.65486678 5.65486678 3.2533421 5.02652273] is 5.40406149.\n", - "The QFI norm along [1, 1, 1, 1] at [5.96902604 5.96902604 3.2533421 5.02652273] is 5.87599852.\n", - "The QFI norm along [1, 1, 1, 1] at [6.28318531 6.28318531 3.2533421 5.02652273] is 5.99962501.\n", - "The QFI norm along [1, 1, 1, 1] at [6.59734457 6.59734457 3.2533421 5.02652273] is 5.93033916.\n", - "The QFI norm along [1, 1, 1, 1] at [6.91150384 6.91150384 3.2533421 5.02652273] is 5.84133590.\n", - "The QFI norm along [1, 1, 1, 1] at [7.2256631 7.2256631 3.2533421 5.02652273] is 5.84309143.\n", - "The QFI norm along [1, 1, 1, 1] at [7.53982237 7.53982237 3.2533421 5.02652273] is 5.93367838.\n", - "The QFI norm along [1, 1, 1, 1] at [7.85398163 7.85398163 3.2533421 5.02652273] is 5.99962501.\n", - "The QFI norm along [1, 1, 1, 1] at [8.1681409 8.1681409 3.2533421 5.02652273] is 5.86697827.\n", - "The QFI norm along [1, 1, 1, 1] at [8.48230016 8.48230016 3.2533421 5.02652273] is 5.38230779.\n", - "The QFI norm along [1, 1, 1, 1] at [8.79645943 8.79645943 3.2533421 5.02652273] is 4.49128513.\n", - "The QFI norm along [1, 1, 1, 1] at [9.1106187 9.1106187 3.2533421 5.02652273] is 3.28287364.\n", - "The QFI norm along [1, 1, 1, 1] at [9.42477796 9.42477796 3.2533421 5.02652273] is 1.97995933.\n", - "The QFI norm along [1, 1, 1, 1] at [9.73893723 9.73893723 3.2533421 5.02652273] is 0.87758767.\n", - "The QFI norm along [1, 1, 1, 1] at [10.05309649 10.05309649 3.2533421 5.02652273] is 0.25010151.\n", - "The QFI norm along [1, 1, 1, 1] at [10.36725576 10.36725576 3.2533421 5.02652273] is 0.26070618.\n", - "The QFI norm along [1, 1, 1, 1] at [10.68141502 10.68141502 3.2533421 5.02652273] is 0.90660775.\n", - "The QFI norm along [1, 1, 1, 1] at [10.99557429 10.99557429 3.2533421 5.02652273] is 2.01995733.\n", - "The QFI norm along [1, 1, 1, 1] at [11.30973355 11.30973355 3.2533421 5.02652273] is 3.32425271.\n", - "The QFI norm along [1, 1, 1, 1] at [11.62389282 11.62389282 3.2533421 5.02652273] is 4.52539873.\n", - "The QFI norm along [1, 1, 1, 1] at [11.93805208 11.93805208 3.2533421 5.02652273] is 5.40406149.\n", - "The QFI norm along [1, 1, 1, 1] at [12.25221135 12.25221135 3.2533421 5.02652273] is 5.87599852.\n", - "The QFI norm along [1, 1, 1, 1] at [12.56637061 12.56637061 3.2533421 5.02652273] is 5.99962501.\n" - ] + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" } ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 9, "source": [ "# Create a figure\n", "fig= plt.figure(figsize=(9, 6))\n", @@ -653,57 +661,36 @@ "ax.set_ylabel('QFI norm along $v=(1,1,1,1)$', fontsize=label_font_size)\n", "ax.set_ylim([-1, 9])\n", "ax.tick_params(labelsize=label_font_size)" - ], - "outputs": [ - { - "output_type": "display_data", - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": { - "needs_background": "light" - } - } - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "We can see that the outputs are consistent with the analytical results." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Calculate the effective quantum dimension\n", "\n", "With Paddle Quantum, one can obtain the effective quantum dimension (EQD) by simply using the method `get_eff_qdim()`. For example, the EQD of the hardware-efficient ansatz shown above can be calculated as follows." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 10, - "source": [ - "cir = circuit_hardeff_2qubit()\n", - "qf = QuantumFisher(cir)\n", - "print(cir)\n", - "print(f'The number of parameters is {len(cir.get_param().tolist())}.')\n", - "print(f'The EQD is {qf.get_eff_qdim()}. \\n')" - ], + "execution_count": 25, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "--Ry(4.248)----*----Ry(1.233)--\n", + "--Ry(3.567)----*----Ry(2.500)--\n", " | \n", - "--Ry(6.121)----x----Ry(4.717)--\n", + "--Ry(2.784)----x----Ry(2.298)--\n", " \n", "The number of parameters is 4.\n", "The EQD is 3. \n", @@ -711,52 +698,35 @@ ] } ], - "metadata": {} + "source": [ + "cir = circuit_hardeff_2qubit()\n", + "qf = QuantumFisher(cir)\n", + "print(cir)\n", + "print(f'The number of parameters is {len(cir.param.tolist())}.')\n", + "print(f'The EQD is {qf.get_eff_qdim()}. \\n')" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "In this example, the EQD is smaller than the number of parameters, which can be easily seen from the fact that the two $R_y$ gates on the control wire can be merged without changing anything. This inefficiency can be fixed by simply replacing one of the $R_y$ gates with a $R_x$ gate, and then the EQD will increase by one.\n", "\n", "If we continue to add gates to the circuit, can we make the EQD grow indefinitely? The answer is clearly no. Provided $n$ qubits, an obvious upper bound can be given by the real number degrees of freedom in a general quantum state, which is equal to $2\\cdot 2^n-2$. The minus two reflect the two constraints of normalization and global phase independence. This can be verified by the following example." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 11, - "source": [ - "def circuit_hardeff_overparam():\n", - " cir = UAnsatz(2)\n", - " theta = 2 * np.pi * np.random.random(8)\n", - " theta = paddle.to_tensor(theta, stop_gradient=False, dtype='float64')\n", - " cir.ry(theta[0], which_qubit=0)\n", - " cir.ry(theta[1], which_qubit=1)\n", - " cir.rx(theta[2], which_qubit=0)\n", - " cir.rx(theta[3], which_qubit=1)\n", - " cir.cnot(control=[0, 1])\n", - " cir.ry(theta[4], which_qubit=0)\n", - " cir.ry(theta[5], which_qubit=1)\n", - " cir.rx(theta[6], which_qubit=0)\n", - " cir.rx(theta[7], which_qubit=1)\n", - "\n", - " return cir\n", - "\n", - "\n", - "cir = circuit_hardeff_overparam()\n", - "qf = QuantumFisher(cir)\n", - "print(cir)\n", - "print(f'The number of parameters is {len(cir.get_param().tolist())}.')\n", - "print(f'The EQD is {qf.get_eff_qdim()}. \\n')" - ], + "execution_count": 26, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ - "--Ry(0.173)----Rx(5.837)----*----Ry(3.082)----Rx(3.997)--\n", + "--Ry(2.514)----Rx(3.037)----*----Ry(5.264)----Rx(0.932)--\n", " | \n", - "--Ry(1.354)----Rx(0.536)----x----Ry(5.267)----Rx(5.647)--\n", + "--Ry(5.648)----Rx(5.991)----x----Ry(4.027)----Rx(2.537)--\n", " \n", "The number of parameters is 8.\n", "The EQD is 6. \n", @@ -764,106 +734,113 @@ ] } ], - "metadata": {} + "source": [ + "def circuit_hardeff_overparam():\n", + " cir = Circuit(2)\n", + " cir.ry()\n", + " cir.rx()\n", + " cir.cnot([0, 1])\n", + " cir.ry()\n", + " cir.rx()\n", + "\n", + " return cir\n", + "\n", + "\n", + "cir = circuit_hardeff_overparam()\n", + "qf = QuantumFisher(cir)\n", + "print(cir)\n", + "print(f'The number of parameters is {len(cir.param.tolist())}.')\n", + "print(f'The EQD is {qf.get_eff_qdim()}. \\n')" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "### Calculate the CFIM and effective dimension\n", "\n", - "Here we exploit a brief example to show how to calculate the effective dimension defined in Eq.(16) with respect to a quantum neural network with Paddle Quantum.\n", - "\n", - "Firstly, define the encoding method from classical data to quantum data." - ], - "metadata": {} - }, - { - "cell_type": "code", - "execution_count": 12, - "source": [ - "def U_theta(x, theta, num_qubits, depth, encoding):\n", - " cir = UAnsatz(num_qubits)\n", - " if encoding == 'IQP':\n", - " S = [[i, i + 1] for i in range(num_qubits - 1)]\n", - " cir.iqp_encoding(x, num_repeats=1, pattern=S)\n", - " cir.complex_entangled_layer(theta, depth)\n", - " elif encoding == 're-uploading':\n", - " for i in range(depth):\n", - " cir.complex_entangled_layer(theta[i:i + 1], depth=1)\n", - " for j in range(num_qubits):\n", - " cir.rx(x[j], which_qubit=j)\n", - " cir.complex_entangled_layer(theta[-1:], depth=1)\n", - " else:\n", - " raise RuntimeError('Non-existent encoding method')\n", - " return cir" - ], - "outputs": [], - "metadata": {} + "Here we exploit a brief example to show how to calculate the effective dimension defined in Eq.(16) with respect to a quantum neural network with Paddle Quantum." + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "Then, define our quantum neural network along with the loss function using PaddlePaddle." - ], - "metadata": {} + "Define our quantum neural network along with the loss function using PaddlePaddle." + ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 27, + "metadata": {}, + "outputs": [], "source": [ "import paddle.nn as nn\n", + "from paddle_quantum.gate import IQPEncoding, ComplexEntangledLayer, RX\n", + "from paddle_quantum.hamiltonian import Hamiltonian\n", + "from paddle_quantum.state import zero_state\n", "\n", "class QuantumNeuralNetwork(nn.Layer):\n", " def __init__(self, num_qubits, depth, encoding):\n", " super().__init__()\n", - " self.num_qubits, self.depth, self.encoding = num_qubits, depth, encoding\n", - " if self.encoding == 'IQP':\n", - " self.theta = self.create_parameter(\n", - " shape=[self.depth, self.num_qubits, 3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0,\n", - " high=2 *\n", - " np.pi),\n", - " dtype='float64',\n", - " is_bias=False)\n", - " elif self.encoding == 're-uploading':\n", - " self.theta = self.create_parameter(\n", - " shape=[self.depth + 1, self.num_qubits, 3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0,\n", - " high=2 *\n", - " np.pi),\n", - " dtype='float64',\n", - " is_bias=False)\n", + " self.num_qubits, self.encoding = num_qubits, encoding\n", + " self.S = [[i, i + 1] for i in range(num_qubits - 1)]\n", + " self.init_state = zero_state(num_qubits)\n", + " \n", + " if encoding == 'IQP':\n", + " self.complex_layer = nn.LayerList([ComplexEntangledLayer(num_qubits=num_qubits, depth=depth)])\n", + " elif encoding == 're-uploading':\n", + " self.complex_layers = nn.LayerList([ComplexEntangledLayer(num_qubits=num_qubits) for _ in range(depth + 1)])\n", " else:\n", " raise RuntimeError('Non-existent encoding method')\n", "\n", " def forward(self, x):\n", " if not paddle.is_tensor(x):\n", - " x = paddle.to_tensor(x)\n", - " cir = U_theta(x, self.theta, self.num_qubits, self.depth,\n", - " self.encoding)\n", - " cir.run_state_vector()\n", - " return cir.expecval([[1.0, 'z0']]) * paddle.to_tensor(\n", - " [0.5], dtype='float64') + paddle.to_tensor([0.5], dtype='float64')" - ], - "outputs": [], - "metadata": {} + " x = paddle.to_tensor(x, dtype='float32')\n", + "\n", + " state = self.init_state\n", + " if self.encoding == 'IQP':\n", + " state = IQPEncoding(x, qubits_idx=self.S)(state)\n", + " state = self.complex_layer[0](state)\n", + " else:\n", + " for i in range(depth):\n", + " state = self.complex_layers[i](state)\n", + " for j in range(num_qubits):\n", + " state = RX(j, param=x[j].item())(state)\n", + " state = self.complex_layers[depth](state)\n", + "\n", + " return state.expec_val(Hamiltonian([[1.0, 'z0']])) * 0.5 + 0.5" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Finally, define a CFIM calculator and calculate the effective dimension corresponding to different size of training samples." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "running in get_gradient: 100%|##################################| 1000/1000 [00:47<00:00, 20.99it/s]\n" + ] + } + ], "source": [ + "from paddle_quantum import set_backend\n", + "\n", "# Configure model parameters\n", "num_qubits = 4\n", "depth = 2\n", "num_inputs = 100\n", "num_thetas = 10\n", + "set_backend('state_vector')\n", "# Define the CFIM calculator\n", "cfim = ClassicalFisher(model=QuantumNeuralNetwork,\n", " num_thetas=num_thetas,\n", @@ -876,72 +853,63 @@ "# Compute the effective dimension for different size of samples\n", "n = [5000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000, 1000000]\n", "effdim = cfim.get_eff_dim(fim, n)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stderr", - "text": [ - "running in get_gradient: 100%|##################################| 1000/1000 [02:05<00:00, 7.94it/s]\n" - ] - } - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Plot the ratio of the effective dimension over number of parameters vs. sample size." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 19, - "source": [ - "fig = plt.figure(figsize=(9, 6))\n", - "ax = fig.add_subplot(111)\n", - "print('the number of parameters：%s' % cfim.num_params)\n", - "ax.plot(n, np.array(effdim) / cfim.num_params)\n", - "label_font_size = 14\n", - "ax.set_xlabel('sample size', fontsize=label_font_size)\n", - "ax.set_ylabel('effective dimension / number of parameters', fontsize=label_font_size)\n", - "ax.tick_params(labelsize=label_font_size)" - ], + "execution_count": 29, + "metadata": {}, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "text": [ "the number of parameters：24\n" ] }, { - "output_type": "display_data", "data": { + "image/png": "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", "text/plain": [ "
" - ], - "image/png": "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" + ] }, "metadata": { "needs_background": "light" - } + }, + "output_type": "display_data" } ], - "metadata": {} + "source": [ + "fig = plt.figure(figsize=(9, 6))\n", + "ax = fig.add_subplot(111)\n", + "print('the number of parameters: %s' % cfim.num_params)\n", + "ax.plot(n, np.array(effdim) / cfim.num_params)\n", + "label_font_size = 14\n", + "ax.set_xlabel('sample size', fontsize=label_font_size)\n", + "ax.set_ylabel('effective dimension / number of parameters', fontsize=label_font_size)\n", + "ax.tick_params(labelsize=label_font_size)" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Conclusion\n", "\n", "This tutorial briefly introduces the concept of classical and quantum Fisher information and their relationship from a geometric point of view. Then, we illustrates their applications in quantum machine learning by taking effective dimension as an example. Finally, we show how to actually perform calculations of these quantities with Paddle Quantum." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "_______\n", "\n", @@ -958,13 +926,15 @@ "[5] Datta, Nilanjana, and Felix Leditzky. \"A limit of the quantum Rényi divergence.\" [Journal of Physics A: Mathematical and Theoretical 47.4 (2014): 045304.](https://iopscience.iop.org/article/10.1088/1751-8113/47/4/045304)\n", "\n", "[6] Abbas, Amira, et al. \"The power of quantum neural networks.\" [Nature Computational Science 1.6 (2021): 403-409.](https://www.nature.com/articles/s43588-021-00084-1)" - ], - "metadata": {} + ] } ], "metadata": { + "interpreter": { + "hash": "2ab84abaf8d5bbc8765aba8eb82d11e7069f2ff20e8f79b8a9cdeccefd2ac4da" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.13 ('pq_new')", "language": "python", "name": "python3" }, @@ -978,9 +948,9 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" } }, "nbformat": 4, "nbformat_minor": 5 -} \ No newline at end of file +} diff --git a/tutorial/qnn_research/Noise_CN.ipynb b/tutorials/qnn_research/Noise_CN.ipynb similarity index 55% rename from tutorial/qnn_research/Noise_CN.ipynb rename to tutorials/qnn_research/Noise_CN.ipynb index 2ad5577..3478c27 100644 --- a/tutorial/qnn_research/Noise_CN.ipynb +++ b/tutorials/qnn_research/Noise_CN.ipynb @@ -72,7 +72,7 @@ "\\tag{5}\n", "$$\n", "\n", - "该信道的物理含义可以理解为存在 $p$ 的概率将 $|0\\rangle$ 态反转到 $|1\\rangle$ 态上，反之亦然。在 Paddle Quantum 中，可以通过 `UAnsatz.bit_flip(p, which_qubit)` 来添加该信道，其中 `p` 代表噪声大小。\n", + "该信道的物理含义可以理解为存在 $p$ 的概率将 $|0\\rangle$ 态反转到 $|1\\rangle$ 态上，反之亦然。在 Paddle Quantum 中，可以通过 `Circuit.bit_flip(p, which_qubit)` 来添加该信道，其中 `p` 代表噪声大小。\n", "\n", "**注释：** 对于一个量子信道，其 *Kraus* 算符表示未必是唯一的 [3]。" ] @@ -89,7 +89,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 5, "id": "scheduled-attraction", "metadata": { "ExecuteTime": { @@ -100,7 +100,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -113,29 +113,33 @@ { "data": { "text/plain": [ - "{'0': 1024}" + "{'0': 1.0, '1': 0.0}" ] }, - "execution_count": 1, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum import Backend\n", + "\n", + "# 切换至密度矩阵模式\n", + "paddle_quantum.set_backend('density_matrix')\n", "\n", "# 设置量子比特数\n", "num_qubits = 1\n", "\n", "# 初始化量子电路\n", - "cir = UAnsatz(num_qubits)\n", + "cir = Circuit(num_qubits)\n", "\n", "# 制备 |0> 态\n", - "init_state = cir.run_density_matrix()\n", + "init_state = paddle_quantum.state.zero_state(num_qubits)\n", "\n", - "# 进行计算基上测量，默认 shots=1024\n", - "cir.measure(plot=True)" + "# 进行计算基上测量\n", + "cir(init_state).measure(shots = 1024, plot = True)\n" ] }, { @@ -149,7 +153,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "id": "fiscal-literature", "metadata": { "ExecuteTime": { @@ -161,7 +165,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -176,8 +180,8 @@ "output_type": "stream", "text": [ "经过了 bit flip 信道之后的量子态是：\n", - " [[0.9+0.j 0. +0.j]\n", - " [0. +0.j 0.1+0.j]]\n" + " [[0.8999999+0.j 0. +0.j]\n", + " [0. +0.j 0.1 +0.j]]\n" ] } ], @@ -190,11 +194,11 @@ "\n", "# 执行电路\n", "# 注释：噪声信道只能在 density matrix 模式下运行\n", - "fin_state = cir.run_density_matrix()\n", + "fin_state = cir(init_state)\n", "\n", "# 测量结果\n", - "cir.measure(plot=True)\n", - "print('经过了 bit flip 信道之后的量子态是：\\n', fin_state.numpy())" + "fin_state.measure(shots = 1024, plot = True)\n", + "print('经过了 bit flip 信道之后的量子态是：\\n', fin_state.data.numpy())" ] }, { @@ -308,7 +312,7 @@ " 该信道描述的是系统与外界环境在**有限温度下交换能量**的噪声模型，同时也是**超导量子计算中的常见噪声** [4]。其表达形式较为复杂，感兴趣的读者可以进一步的阅读 [API 文档](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html) 和相应的参考文献。\n", "\n", "\n", - "**注释：** 在 Paddle Quantum 中，我们可以通过 `UAnsatz.phase_flip()`，`UAnsatz.bit_phase_flip()`， `UAnsatz.depolarizing()`，`UAnsatz.pauli_channel()`, `UAnsatz.amplitude_damping()`，`UAnsatz.phase_damping()`以及 `UAnsatz.generalized_amplitude_damping()` 来添加上述噪声。\n", + "**注释：** 在 Paddle Quantum 中，我们可以通过 `Circuit.phase_flip()`，`Circuit.bit_phase_flip()`， `Circuit.depolarizing()`，`Circuit.pauli_channel()`, `Circuit.amplitude_damping()`，`Circuit.phase_damping()`以及 `Circuit.generalized_amplitude_damping()` 来添加上述噪声。\n", "\n", "**注释：** 通常会选择振幅阻尼信道和相位阻尼信道来建模实际量子设备中的噪声，因为这两种信道可以较好的描述真实量子系统中的物理过程（可以用来建模 $T_1$ 和 $T_2$ 噪声）。" ] @@ -320,12 +324,12 @@ "source": [ "### 自定义信道\n", "\n", - "此外，我们也可以通过 `UAnsatz.customized_channel()` 来向电路中添加自定义噪声。具体的，该方法支持用自定义的 *Kraus* 算符来建模任意的噪声模型，我们自定义的方式来搭建比特反转信道为例：" + "此外，我们也可以通过 `Circuit.kraus_repr()` 来向电路中添加自定义噪声。具体的，该方法支持用自定义的 *Kraus* 算符来建模任意的噪声模型，我们自定义的方式来搭建比特反转信道为例：" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "id": "mobile-death", "metadata": { "ExecuteTime": { @@ -339,12 +343,12 @@ "output_type": "stream", "text": [ "经过了自定义信道之后的量子态是：\n", - " [[0.9+0.j 0. +0.j]\n", - " [0. +0.j 0.1+0.j]]\n", + " [[0.90000004+0.j 0. +0.j]\n", + " [0. +0.j 0.1 +0.j]]\n", "\n", "经过了比特反转信道之后的量子态是：\n", - " [[0.9+0.j 0. +0.j]\n", - " [0. +0.j 0.1+0.j]]\n", + " [[0.8999999+0.j 0. +0.j]\n", + " [0. +0.j 0.1 +0.j]]\n", "\n", "两个态是否相同？ True\n" ] @@ -353,34 +357,33 @@ "source": [ "import paddle\n", "import numpy as np\n", - "from paddle_quantum.circuit import UAnsatz\n", "\n", "# 设置噪声参数\n", "p = 0.1\n", "\n", "# 我们用自定义的 Kraus 算符来描述一个比特反转信道\n", - "# 注意 Kraus 算符的数据类型应为 complex_128\n", - "e_0 = paddle.to_tensor(np.sqrt(1 - p) * np.array([[1, 0], [0, 1]], dtype='complex128'))\n", - "e_1 = paddle.to_tensor(np.sqrt(p) * np.array([[0, 1], [1, 0]], dtype='complex128'))\n", + "complex_dtype = paddle_quantum.get_dtype()\n", + "e_0 = paddle.to_tensor(np.sqrt(1 - p) * np.array([[1, 0], [0, 1]], dtype=complex_dtype))\n", + "e_1 = paddle.to_tensor(np.sqrt(p) * np.array([[0, 1], [1, 0]], dtype=complex_dtype))\n", "Kraus_ops = [e_0, e_1]\n", "\n", "# 初始化量子电路\n", "num_qubits = 1\n", - "cir = UAnsatz(num_qubits)\n", + "cir = Circuit(num_qubits)\n", "\n", "# 添加自定义噪声，其输入为 Kraus 算符的列表\n", - "cir.customized_channel(Kraus_ops, 0)\n", + "cir.kraus_repr(Kraus_ops, 0)\n", "\n", "# 执行电路\n", - "fin_state = cir.run_density_matrix()\n", + "fin_state = cir(init_state)\n", "\n", "# 比较结果\n", - "cir_1 = UAnsatz(num_qubits)\n", + "cir_1 = Circuit(num_qubits)\n", "cir_1.bit_flip(p, 0)\n", - "fin_state_1 = cir_1.run_density_matrix()\n", - "print('经过了自定义信道之后的量子态是：\\n', fin_state.numpy())\n", - "print('\\n经过了比特反转信道之后的量子态是：\\n', fin_state_1.numpy())\n", - "print('\\n两个态是否相同？', bool((fin_state - fin_state_1).abs().sum() < 1e-8))" + "fin_state_1 = cir_1(init_state)\n", + "print('经过了自定义信道之后的量子态是：\\n', fin_state.data.numpy())\n", + "print('\\n经过了比特反转信道之后的量子态是：\\n', fin_state_1.data.numpy())\n", + "print('\\n两个态是否相同？', bool((fin_state.data - fin_state_1.data).abs().sum() < 1e-6))" ] }, { @@ -404,7 +407,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 8, "id": "spread-monkey", "metadata": { "ExecuteTime": { @@ -426,7 +429,7 @@ "source": [ "import paddle\n", "from paddle import matmul, trace\n", - "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.ansatz import Circuit\n", "from paddle_quantum.state import bell_state\n", "\n", "# 噪声参数\n", @@ -435,26 +438,26 @@ "\n", "# 创建用来模拟噪声的量子电路\n", "num_qubits = 2\n", - "cir = UAnsatz(num_qubits)\n", + "cir = Circuit(num_qubits)\n", "\n", "# 这里的初态是制备好的贝尔态\n", - "init_state = paddle.to_tensor(bell_state(2))\n", + "init_state = bell_state(2)\n", "\n", "# 分别在两个量子比特上添加去极化信道，表示在传输过程中引入的噪声\n", "cir.depolarizing(p_trans, 0)\n", "cir.depolarizing(p_trans, 1)\n", "\n", "# 用模拟噪声的电路来演化该初态\n", - "status_mid = cir.run_density_matrix(init_state)\n", + "status_mid = cir(init_state)\n", "\n", "# 分别在两个量子比特上添加振幅阻尼信道，表示在保存过程中引入的噪声\n", "cir.amplitude_damping(p_store, 0)\n", "cir.amplitude_damping(p_store, 1)\n", "\n", "# 用模拟噪声的电路来演化该初态\n", - "status_fin = cir.run_density_matrix(status_mid)\n", - "fidelity_mid = paddle.real(trace(matmul(init_state, status_mid)))\n", - "fidelity_fin = paddle.real(trace(matmul(init_state, status_fin)))\n", + "status_fin = cir(status_mid)\n", + "fidelity_mid = paddle.real(trace(matmul(init_state.data, status_mid.data)))\n", + "fidelity_fin = paddle.real(trace(matmul(init_state.data, status_fin.data)))\n", "\n", "print(\"初态和贝尔态之间的保真度为\", 1)\n", "print(\"经过了传输（去极化信道）之后的纠缠对和贝尔态的保真度为 {:.5f}\".format(fidelity_mid.numpy()[0]))\n", @@ -491,7 +494,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 9, "id": "unavailable-october", "metadata": { "ExecuteTime": { @@ -503,14 +506,8 @@ "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\n", - "\n", - "# 首先生成泡利字符串表示下的哈密顿量\n", - "H_info = [[0.4, 'z0'], [0.4, 'z1'], [0.2, 'x0,x1']]\n", - "\n", - "# 把记录的关于哈密顿量的信息转化为矩阵表示\n", - "H_matrix = pauli_str_to_matrix(H_info, num_qubits)\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.qinfo import pauli_str_to_matrix\n", "\n", "# 超参数设置\n", "num_qubits = 2\n", @@ -518,12 +515,19 @@ "ITR = 100\n", "LR = 0.4\n", "SEED = 999 \n", - "p = 0.1" + "p = 0.1\n", + "\n", + "# 首先生成泡利字符串表示下的哈密顿量\n", + "H_info = [[0.4, 'z0'], [0.4, 'z1'], [0.2, 'x0,x1']]\n", + "\n", + "# 把记录的关于哈密顿量的信息转化为矩阵表示\n", + "complex_dtype = paddle_quantum.get_dtype()\n", + "H_matrix = pauli_str_to_matrix(H_info, num_qubits).numpy().astype(complex_dtype)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 11, "id": "protected-difficulty", "metadata": { "ExecuteTime": { @@ -537,94 +541,81 @@ "output_type": "stream", "text": [ "========== Training Noisy VQE ==========\n", - "iter: 0 loss: -0.0782\n", - "iter: 10 loss: -0.6395\n", - "iter: 20 loss: -0.6548\n", - "iter: 30 loss: -0.6547\n", - "iter: 40 loss: -0.6591\n", - "iter: 50 loss: -0.6608\n", - "iter: 60 loss: -0.6618\n", + "iter: 0 loss: -0.3881\n", + "iter: 10 loss: -0.6246\n", + "iter: 20 loss: -0.6454\n", + "iter: 30 loss: -0.6611\n", + "iter: 40 loss: -0.6608\n", + "iter: 50 loss: -0.6616\n", + "iter: 60 loss: -0.6620\n", "iter: 70 loss: -0.6621\n", "iter: 80 loss: -0.6621\n", - "iter: 90 loss: -0.6621\n", + "iter: 90 loss: -0.6622\n", "========== Training Noise Free VQE ==========\n", - "iter: 0 loss: 0.1521\n", - "iter: 10 loss: -0.7413\n", - "iter: 20 loss: -0.8208\n", - "iter: 30 loss: -0.8170\n", - "iter: 40 loss: -0.8169\n", - "iter: 50 loss: -0.8241\n", - "iter: 60 loss: -0.8238\n", - "iter: 70 loss: -0.8245\n", - "iter: 80 loss: -0.8245\n", + "iter: 0 loss: 0.0636\n", + "iter: 10 loss: -0.6282\n", + "iter: 20 loss: -0.7518\n", + "iter: 30 loss: -0.8124\n", + "iter: 40 loss: -0.8229\n", + "iter: 50 loss: -0.8208\n", + "iter: 60 loss: -0.8243\n", + "iter: 70 loss: -0.8242\n", + "iter: 80 loss: -0.8246\n", "iter: 90 loss: -0.8246\n", "\n", - "含噪电路计算得到的基态能量是: -0.6621559864367315 Ha\n", - "不含噪电路计算得到的基态能量是: -0.8246026782552648 Ha\n", - "真实的基态能量为: -0.8246211251235321 Ha\n" + "含噪电路计算得到的基态能量是: -0.6621563 Ha\n", + "不含噪电路计算得到的基态能量是: -0.82461804 Ha\n", + "真实的基态能量为: -0.82462114 Ha\n" ] } ], "source": [ "class vqe_noisy(paddle.nn.Layer):\n", " \n", - " def __init__(self, shape, dtype='float64'):\n", + " def __init__(self):\n", " super(vqe_noisy, self).__init__()\n", - " \n", - " # 初始化一个长度为theta_size的可学习参数列表，并用[0, 2*pi]的均匀分布来填充初始值\n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0., high=2*np.pi), \n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # 定义损失函数和前向传播机制\n", - " def forward(self):\n", - " \n", + "\n", " # 初始量子电路\n", - " cir = UAnsatz(num_qubits)\n", + " self.cir = Circuit(num_qubits)\n", " \n", " # 添加参数化量子电路\n", - " cir.ry(self.theta[0], 0)\n", - " cir.ry(self.theta[1], 1)\n", + " self.cir.ry([0, 1])\n", + " \n", + " self.cir.cnot([0, 1])\n", " \n", - " cir.cnot([0, 1])\n", - " \n", - " cir.ry(self.theta[2], 0)\n", - " cir.ry(self.theta[3], 1)\n", + " self.cir.ry([0, 1])\n", " \n", " # 添加振幅阻尼 AD 噪声\n", - " cir.amplitude_damping(p, 0)\n", - " cir.amplitude_damping(p, 1)\n", + " self.cir.amplitude_damping(p, [0, 1])\n", " \n", + " # 定义损失函数和前向传播机制\n", + " def forward(self):\n", + "\n", " # 运行密度矩阵模式\n", - " cir.run_density_matrix()\n", - " \n", + " state = self.cir(init_state)\n", + "\n", " # 关于观测量 H_info 的期望值\n", - " loss = cir.expecval(H_info)\n", + " loss = loss_func(state)\n", " \n", - " return loss\n", + " return loss, self.cir\n", " \n", "# 创建一个不含噪声的 VQE 电路\n", "class vqe_noise_free(paddle.nn.Layer):\n", " \n", - " def __init__(self, shape, dtype='float64'):\n", + " def __init__(self):\n", " super(vqe_noise_free, self).__init__()\n", - " \n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0., high=2*np.pi), \n", - " dtype=dtype, is_bias=False)\n", - " \n", + "\n", + " self.cir = Circuit(num_qubits)\n", + " self.cir.ry([0, 1])\n", + " self.cir.cnot([0, 1])\n", + " self.cir.ry([0, 1])\n", + "\n", " def forward(self):\n", " \n", - " cir = UAnsatz(num_qubits)\n", - " cir.ry(self.theta[0], 0)\n", - " cir.ry(self.theta[1], 1) \n", - " cir.cnot([0, 1])\n", - " cir.ry(self.theta[2], 0)\n", - " cir.ry(self.theta[3], 1)\n", - " cir.run_density_matrix()\n", - " loss = cir.expecval(H_info)\n", + " state = self.cir(init_state)\n", + " loss = loss_func(state)\n", " \n", - " return loss\n", + " return loss, self.cir\n", " \n", "# 训练含噪 VQE 电路\n", "print('========== Training Noisy VQE ==========')\n", @@ -632,16 +623,22 @@ "parameter_list = []\n", "\n", "# 定义参数维度\n", - "vqe = vqe_noisy([theta_size])\n", + "vqe = vqe_noisy()\n", "\n", "# 一般来说，我们利用Adam优化器来获得相对好的收敛，当然你可以改成SGD或者是RMS prop.\n", - "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = vqe.parameters()) \n", + "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = vqe.parameters())\n", + "\n", + "# 定义初始态\n", + "init_state = paddle_quantum.state.zero_state(num_qubits)\n", + "\n", + "# 定义损失函数\n", + "loss_func = paddle_quantum.loss.ExpecVal(paddle_quantum.Hamiltonian(H_info))\n", "\n", "# 优化循环\n", "for itr in range(ITR):\n", "\n", " # 前向传播计算损失函数\n", - " loss = vqe()\n", + " loss, cir = vqe()\n", "\n", " # 反向传播极小化损失函数\n", " loss.backward()\n", @@ -659,12 +656,12 @@ "loss_list_no_noise = []\n", "parameter_list_no_noise = []\n", "\n", - "vqe_no_noise = vqe_noise_free([theta_size])\n", + "vqe_no_noise = vqe_noise_free()\n", "opt_no_noise = paddle.optimizer.Adam(learning_rate = LR, parameters = vqe_no_noise.parameters()) \n", "\n", "for itr in range(ITR):\n", "\n", - " loss = vqe_no_noise()\n", + " loss, cir = vqe_no_noise()\n", "\n", " loss.backward()\n", " opt_no_noise.minimize(loss)\n", @@ -722,7 +719,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -736,7 +733,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/qnn_research/Noise_EN.ipynb b/tutorials/qnn_research/Noise_EN.ipynb similarity index 54% rename from tutorial/qnn_research/Noise_EN.ipynb rename to tutorials/qnn_research/Noise_EN.ipynb index 1091a62..bda786f 100644 --- a/tutorial/qnn_research/Noise_EN.ipynb +++ b/tutorials/qnn_research/Noise_EN.ipynb @@ -68,7 +68,7 @@ "\\tag{5}\n", "$$\n", "\n", - "The physical meaning of this quantum channel is there exist a probability $p$ that the state $|0\\rangle$ will flip into $|1\\rangle$, and vice versa. In Paddle Quantum, we can use this quantum channel by `UAnsatz.bit_flip(p, which_qubit)`, where `p` is the noise level.\n", + "The physical meaning of this quantum channel is there exist a probability $p$ that the state $|0\\rangle$ will flip into $|1\\rangle$, and vice versa. In Paddle Quantum, we can use this quantum channel by `Circuit.bit_flip(p, which_qubit)`, where `p` is the noise level.\n", "\n", "**Note:** For a quantum channel, the Kraus operator representation is not necessarily unique [3]." ] @@ -84,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-04-09T02:32:24.919291Z", @@ -94,7 +94,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEDCAYAAAA4FgP0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAARqUlEQVR4nO3de7BdZX3G8e+TcBEFpULqYC6CNWiDCmJER20Fr8SqwWtBqpWqkQoWp1OVdqzUaqdaL60WNKZK8TIFa0VEjTBWReqtQigXg0YjF0mhI6j1WsXIr3/sHdnu7HP2Tsjah+T9fmbOnL3e913r/JJJ8mS9611rpaqQJLVr3lwXIEmaWwaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjdpvrArbV/vvvXwceeOBclyFJO5V169bdUlULRvXtdEFw4IEHcumll851GZK0U0ly/Ux9Tg1JUuMMAklqnEEgSY0zCCSpcQaBJDWusyBIcmaS7yT56gz9SfL2JBuTXJnk8K5qkSTNrMszgrOAo2fpXwEs7X+tAt7ZYS2SpBl0FgRVdTHwvVmGrATeVz1fBvZNckBX9UiSRpvLG8oWAjcMbG/qt900PDDJKnpnDSxZsmS7f+CBp35iu/fVru+6N/zeXJcgzYm5vFicEW0jX5dWVWuqanlVLV+wYOQd0pKk7TSXQbAJWDywvQi4cY5qkaRmzWUQnA88v7966BHAD6pqq2khSVK3OrtGkORs4Ehg/ySbgNOA3QGqajWwFngysBH4KXBCV7VIkmbWWRBU1XFj+gs4qaufL0majHcWS1LjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhrXaRAkOTrJhiQbk5w6ov8eST6W5Iok65Oc0GU9kqStdRYESeYDZwArgGXAcUmWDQ07Cbi6qg4FjgTekmSPrmqSJG2tyzOCI4CNVXVNVd0KnAOsHBpTwD5JAuwNfA/Y3GFNkqQhXQbBQuCGge1N/bZBpwO/DdwIXAWcUlW3dViTJGlIl0GQEW01tP0k4HLg3sBhwOlJ7r7VgZJVSS5NcunNN9+8o+uUpKZ1GQSbgMUD24vo/c9/0AnAudWzEbgWeMDwgapqTVUtr6rlCxYs6KxgSWpRl0FwCbA0yUH9C8DHAucPjfk28DiAJPcC7g9c02FNkqQhu3V14KranORk4EJgPnBmVa1PcmK/fzXwOuCsJFfRm0p6VVXd0lVNkqStdRYEAFW1Flg71LZ64PONwBO7rEGSNDvvLJakxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcRMFQZJHJblb//MfJHlrkvt0W5okaRomPSN4J/DTJIcCrwSuB97XWVWSpKmZNAg2V1UBK4G3VdXbgH26K0uSNC27TTjuR0n+HHge8DtJ5gO7d1eWJGlaJj0j+H3g58AfVdX/AAuBN3VWlSRpaiYKgv4//h8G9uw33QJ8pKuiJEnTM+mqoRcD/wa8q9+0EDivo5okSVM06dTQScCjgB8CVNU3gd/sqihJ0vRMGgQ/r6pbt2wk2Q2obkqSJE3TpEHwuSR/AeyV5AnAh4CPjdspydFJNiTZmOTUGcYcmeTyJOuTfG7y0iVJO8KkQXAqcDNwFfASYC3w6tl26C8xPQNYASwDjkuybGjMvsA7gKdV1SHAs7eleEnSHTfRfQRVdRvwT/2vSR0BbKyqawCSnEPvhrSrB8Y8Fzi3qr7d/znf2YbjS5J2gFmDIMm/VtVzklzFiGsCVfXgWXZfCNwwsL0JePjQmIOB3ZNcRO9O5bdVlY+ukKQpGndGcEr/+1O249gZ0TYcJrsBDwUeB+wFfCnJl6vqG792oGQVsApgyZIl21GKJGkms14jqKqb+h9fWlXXD34BLx1z7E3A4oHtRcCNI8ZcUFU/qapbgIuBQ0fUsaaqllfV8gULFoz5sZKkbTHpxeInjGhbMWafS4ClSQ5KsgdwLHD+0JiP0nt20W5J7kpv6uhrE9YkSdoBxl0j+GN6//O/b5IrB7r2Ab4w275VtTnJycCFwHzgzKpan+TEfv/qqvpakguAK4HbgHdX1Ve3/5cjSdpW464R/AvwSeBv6S0h3eJHVfW9cQevqrX0lpoOtq0e2n4TPsBOkubMuCCoqrouyUnDHUnuOUkYSJLu3CY5I3gKsI7eip/BlUAF3LejuiRJUzJrEFTVU/rfD5pOOZKkaRt3sfjw2fqr6rIdW44kadrGTQ29ZZa+Ah67A2uRJM2BcVNDR02rEEnS3Bg3NfTYqvpMkmeM6q+qc7spS5I0LeOmhh4DfAZ46oi+AgwCSdrJjZsaOq3//YTplCNJmrZJX16/X5K3J7ksybokb0uyX9fFSZK6N+lD586h94ayZwLP6n/+YFdFSZKmZ6I3lAH3rKrXDWy/PskxHdQjSZqySc8IPpvk2CTz+l/PAT7RZWGSpOkYt3z0R9z+jKE/BT7Q75oH/Bg4rdPqJEmdG7dqaJ9pFSJJmhuTXiMgyW8AS4G7bGmrqou7KEqSND0TBUGSF9F7kf0i4HLgEcCX8FlDkrTTm/Ri8SnAw4Dr+88fegi9JaSSpJ3cpEHws6r6GUCSPavq68D9uytLkjQtk14j2JRkX+A84FNJvg/c2FVRkqTpmSgIqurp/Y9/leSzwD2ACzqrSpI0Nduyauhw4NH07iv4QlXd2llVkqSpmfShc68B3gvsB+wP/HOSV3dZmCRpOiY9IzgOeMjABeM3AJcBr++qMEnSdEy6aug6Bm4kA/YEvrXDq5EkTd24Zw39I71rAj8H1if5VH/7CcDnuy9PktS1cVNDl/a/rwM+MtB+USfVSJKmbtxD59675XOSPYCD+5sbquoXXRYmSZqOSZ81dCS9VUPX0Xsk9eIkf+hD5yRp5zfpqqG3AE+sqg0ASQ4GzgYe2lVhkqTpmHTV0O5bQgCgqr4B7N5NSZKkaZr0jGBdkvcA7+9vH0/vArIkaSc3aRCcCJwE/Am9awQXA+/oqihJ0vSMnRpKMg9YV1VvrapnVNXTq+rvq+rnE+x7dJINSTYmOXWWcQ9L8sskz9rG+iVJd9DYIKiq24ArkizZlgMnmQ+cAawAlgHHJVk2w7g3Ahduy/ElSTvGpFNDB9C7s/grwE+2NFbV02bZ5whgY1VdA5DkHGAlcPXQuJcBH6b3BjRJ0pRNGgSv3Y5jLwRuGNjeBDx8cECShcDT6b372CCQpDkw7llDd6F3ofh+wFXAe6pq84THzoi2Gtr+B+BVVfXLZNTwX9WxClgFsGTJNs1QSZLGGHdG8F7gF8B/cPtc/ykTHnsTsHhgexFbv95yOXBOPwT2B56cZHNVnTc4qKrWAGsAli9fPhwmkqQ7YFwQLKuqBwH07yP4yjYc+xJgaZKDgP8GjgWeOzigqg7a8jnJWcDHh0NAktStcUHwqwfLVdXm2aZvhvXHn0xvNdB84MyqWp/kxH7/6u2oV5K0g40LgkOT/LD/OcBe/e0AVVV3n23nqloLrB1qGxkAVfWCiSqWJO1Q4x5DPX9ahUiS5sakD52TJO2iDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUuE6DIMnRSTYk2Zjk1BH9xye5sv/1xSSHdlmPJGlrnQVBkvnAGcAKYBlwXJJlQ8OuBR5TVQ8GXges6aoeSdJoXZ4RHAFsrKprqupW4Bxg5eCAqvpiVX2/v/llYFGH9UiSRugyCBYCNwxsb+q3zeSFwCc7rEeSNMJuHR47I9pq5MDkKHpB8OgZ+lcBqwCWLFmyo+qTJNHtGcEmYPHA9iLgxuFBSR4MvBtYWVXfHXWgqlpTVcuravmCBQs6KVaSWtVlEFwCLE1yUJI9gGOB8wcHJFkCnAs8r6q+0WEtkqQZdDY1VFWbk5wMXAjMB86sqvVJTuz3rwZeA+wHvCMJwOaqWt5VTZKkrXV5jYCqWgusHWpbPfD5RcCLuqxBkjQ77yyWpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuMMAklqnEEgSY0zCCSpcQaBJDXOIJCkxhkEktQ4g0CSGmcQSFLjDAJJapxBIEmNMwgkqXEGgSQ1ziCQpMYZBJLUOINAkhpnEEhS4wwCSWqcQSBJjTMIJKlxBoEkNc4gkKTGdRoESY5OsiHJxiSnjuhPkrf3+69McniX9UiSttZZECSZD5wBrACWAcclWTY0bAWwtP+1CnhnV/VIkkbr8ozgCGBjVV1TVbcC5wArh8asBN5XPV8G9k1yQIc1SZKG7NbhsRcCNwxsbwIePsGYhcBNg4OSrKJ3xgDw4yQbdmypzdofuGWui7izyBvnugKN4J/RHec+M3V0GQQZ0VbbMYaqWgOs2RFF6XZJLq2q5XNdhzQT/4xOR5dTQ5uAxQPbi4Abt2OMJKlDXQbBJcDSJAcl2QM4Fjh/aMz5wPP7q4ceAfygqm4aPpAkqTudTQ1V1eYkJwMXAvOBM6tqfZIT+/2rgbXAk4GNwE+BE7qqRyM53aY7O/+MTkGqtpqSlyQ1xDuLJalxBoEkNc4gkKTGdXkfge5kkjyA3t3cC+ndr3EjcH5VfW1OC5M0pzwjaESSV9F7zEeAr9Bb3hvg7FEPBJTuTJK4orBDrhpqRJJvAIdU1S+G2vcA1lfV0rmpTBovyberaslc17GrcmqoHbcB9wauH2o/oN8nzakkV87UBdxrmrW0xiBox8uBTyf5Jrc/6G8JcD/g5LkqShpwL+BJwPeH2gN8cfrltMMgaERVXZDkYHqPB19I7y/XJuCSqvrlnBYn9Xwc2LuqLh/uSHLR1KtpiNcIJKlxrhqSpMYZBJLUOINAu7Qki5J8NMk3k1yT5PQke06w349naP/rJI/vf355krvOMO4pSf4ryRVJrk7ykn77MSPe3T1q/4nGSTuCQaBdVpIA5wLn9e+TWArsBfzd9h6zql5TVf/e33w5sFUQJNmd3uOTn1pVhwIPAS7qdx8DTPIP/KTjpDvMi8XaZSV5HHBaVf3uQNvd6d1LsRh4FrC8qk7u930ceHNVXdQ/I3gXcBS95YzHVtXNSc6it7rl3sCbgQ3ALVV11MDPuCfwdeA+VfV/A+2P7O/7g/7XM4HH0nsf9x703svxPOCwEeMAzgAW0Ht3x4ur6us75DdKzfOMQLuyQ4B1gw1V9UPgOnr3T8zmbsBlVXU48DngtKHjvJ3es5qOGgyBft/36L197/okZyc5Psm8qvpiv/0VVXVYVX0LOLeqHtY/c/ga8MIZxq0BXlZVDwX+DHjHNv9uSDPwPgLtykLv4Xqj2se5Dfhg//MH6E0xTayqXpTkQcDj6f3D/QTgBSOGPjDJ64F9gb3pvdHv14tN9gYeCXyoN9sFwNjrHNKkDALtytZz+7QK8KupoXvRm9J5IL9+VnyXWY61zXOoVXUVcFWS9wPXMjoIzgKOqaorkrwAOHLEmHnA/1bVYdtagzQJp4a0K/s0cNckzwdIMh94C3B6f+7+OuCwJPOSLKZ31/UW8+hdQwB4LvD5Ecf/EbDPcGOSvZMcOdB0GLc/42l4n32Am/oXmI8fdez+dNa1SZ7dP36SHDrbL1zaFgaBdlnVWwnxdOBZ/WcsfRe4rar+pj/kC/T+p34VvQu/lw3s/hPgkCTr6F3Q/esRP2IN8Mkknx1qD/DKJBuSXA68ltvPBs4BXtFfWvpbwF8C/wl8it4FZmYYdzzwwiRX0DvTWblNvxnSLFw1pGb0V+2cDTyjqtaNGy+1wiCQpMY5NSRJjTMIJKlxBoEkNc4gkKTGGQSS1DiDQJIaZxBIUuP+H8qMdZflk6M0AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -107,29 +107,32 @@ { "data": { "text/plain": [ - "{'0': 1024}" + "{'0': 1.0, '1': 0.0}" ] }, - "execution_count": 1, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "\n", + "# Change to density matrix mode\n", + "paddle_quantum.set_backend('density_matrix')\n", "\n", "# Define the number of qubits, here we use one single qubit\n", "num_qubits = 1\n", "\n", "# Initialize the quantum circuit\n", - "cir = UAnsatz(num_qubits)\n", + "cir = Circuit(num_qubits)\n", "\n", "# Initialize the qubit to |0><0| \n", - "init_state = cir.run_density_matrix()\n", + "init_state = paddle_quantum.state.zero_state(num_qubits)\n", "\n", "# Mesure in the computational basis \n", - "cir.measure(plot=True)" + "cir(init_state).measure(shots = 1024, plot = True)" ] }, { @@ -142,7 +145,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2021-04-09T02:32:25.168455Z", @@ -153,7 +156,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ "
" ] @@ -168,8 +171,8 @@ "output_type": "stream", "text": [ "Quantum state after the bit flip quantum channel：\n", - " [[0.9+0.j 0. +0.j]\n", - " [0. +0.j 0.1+0.j]]\n" + " [[0.8999999+0.j 0. +0.j]\n", + " [0. +0.j 0.1 +0.j]]\n" ] } ], @@ -182,11 +185,11 @@ "\n", "# Execute the circuit\n", "# Note: Noisy module in Paddle Quantum only supports density matrix operation mode\n", - "fin_state = cir.run_density_matrix()\n", + "fin_state = cir(init_state)\n", "\n", "# Measure in the computational basis\n", - "cir.measure(plot=True)\n", - "print('Quantum state after the bit flip quantum channel：\\n', fin_state.numpy())" + "fin_state.measure(shots = 1024, plot = True)\n", + "print('Quantum state after the bit flip quantum channel：\\n', fin_state.data.numpy())" ] }, { @@ -296,7 +299,7 @@ " The generalized amplitude damping channel describes energy exchange between the system and the environment at **finite temperatures**. It is a common noise in superconducting quantum computations [4]. Interested readers can find more information here [API document](https://qml.baidu.com/api/paddle_quantum.circuit.uansatz.html).\n", "\n", "\n", - "**Note：** In Paddle Quantum, we can use these noisy channels through `UAnsatz.phase_flip()`, `UAnsatz.bit_phase_flip()`, `UAnsatz.depolarizing()`, `UAnsatz.pauli_channel()`, `UAnsatz.amplitude_damping()`, `UAnsatz.phase_damping()`, and `UAnsatz.generalized_amplitude_damping()`.\n", + "**Note：** In Paddle Quantum, we can use these noisy channels through `Circuit.phase_flip()`, `Circuit.bit_phase_flip()`, `Circuit.depolarizing()`, `Circuit.pauli_channel()`, `Circuit.amplitude_damping()`, `Circuit.phase_damping()`, and `Circuit.generalized_amplitude_damping()`.\n", "\n", "**Note：** One usually choose the amplitude damping channel and the phase damping channel to model noises since they describe the physical process in real quantum systems (modeling $T_1$ and $T_2$ process)." ] @@ -307,12 +310,12 @@ "source": [ "### Customized Channel\n", "\n", - "One can also use `UAnsatz.customized_channel()` in Paddle Quantum to add customized noisy channels. This is accomplished through user-defined Kraus operators. Here, we provide an example to reproduce the bit flip channel using customized_channel function:" + "One can also use `Circuit.customized_channel()` in Paddle Quantum to add customized noisy channels. This is accomplished through user-defined Kraus operators. Here, we provide an example to reproduce the bit flip channel using customized_channel function:" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "ExecuteTime": { "end_time": "2021-04-09T02:54:20.758898Z", @@ -325,12 +328,12 @@ "output_type": "stream", "text": [ "quantum state after the customized channel:\n", - " [[0.9+0.j 0. +0.j]\n", - " [0. +0.j 0.1+0.j]]\n", + " [[0.90000004+0.j 0. +0.j]\n", + " [0. +0.j 0.1 +0.j]]\n", "\n", " quantum state after the bit flip channel：\n", - " [[0.9+0.j 0. +0.j]\n", - " [0. +0.j 0.1+0.j]]\n", + " [[0.8999999+0.j 0. +0.j]\n", + " [0. +0.j 0.1 +0.j]]\n", "\n", " are the two the same？ True\n" ] @@ -339,35 +342,33 @@ "source": [ "import paddle\n", "import numpy as np\n", - "from paddle_quantum.circuit import UAnsatz\n", "\n", "# Noise level\n", "p = 0.1\n", "\n", "# We use customized Kraus operator to represent the bit flip channel\n", - "# Note that the data type of a Kraus operator is complex_128\n", - "a_0 = paddle.to_tensor(np.sqrt(1 - p) * np.array([[1, 0], [0, 1]], dtype='complex128'))\n", - "a_1 = paddle.to_tensor(np.sqrt(p) * np.array([[0, 1], [1, 0]], dtype='complex128'))\n", + "complex_dtype = paddle_quantum.get_dtype()\n", + "a_0 = paddle.to_tensor(np.sqrt(1 - p) * np.array([[1, 0], [0, 1]], dtype=complex_dtype))\n", + "a_1 = paddle.to_tensor(np.sqrt(p) * np.array([[0, 1], [1, 0]], dtype=complex_dtype))\n", "Kraus_ops = [a_0, a_1]\n", "\n", "# Initialize the circuit\n", "num_qubits = 1\n", - "cir = UAnsatz(num_qubits)\n", + "cir = Circuit(num_qubits)\n", "\n", "# Add customized channel, input is a list of Kraus operators\n", - "cir.customized_channel(Kraus_ops, 0)\n", + "cir.kraus_repr(Kraus_ops, 0)\n", "\n", "# Execute the circuit\n", - "fin_state = cir.run_density_matrix()\n", - "\n", + "fin_state = cir(init_state)\n", "\n", "# Compare the results\n", - "cir_1 = UAnsatz(num_qubits)\n", + "cir_1 = Circuit(num_qubits)\n", "cir_1.bit_flip(p, 0)\n", - "fin_state_1 = cir_1.run_density_matrix()\n", - "print('quantum state after the customized channel:\\n', fin_state.numpy())\n", - "print('\\n quantum state after the bit flip channel：\\n', fin_state_1.numpy())\n", - "print('\\n are the two the same？', bool((fin_state - fin_state_1).abs().sum() < 1e-8))" + "fin_state_1 = cir_1(init_state)\n", + "print('quantum state after the customized channel:\\n', fin_state.data.numpy())\n", + "print('\\n quantum state after the bit flip channel：\\n', fin_state_1.data.numpy())\n", + "print('\\n are the two the same？', bool((fin_state.data - fin_state_1.data).abs().sum() < 1e-6))" ] }, { @@ -376,12 +377,12 @@ "source": [ "## Discussion: Simulating noisy entanglement resources with Paddle Quantum\n", "\n", - "Many important quantum technologies require pre-shared entanglement resources, including quantum teleportation, state transformation, and distributed quantum computing. For instance, we want the allocated entanglement resources are in **maximally entangled states** under ideal circumstances. But in reality, noise always exists due to interactions between the system and the environment during preparation stage, transmission, and preservation. Here, we use the depolarized channel to simulate how a white noise could affect Bell states: " + "Many important quantum technologies require pre-shared entanglement resources, including quantum teleportation, state transformation, and distributed quantum computing. For instance, we want the allocated entanglement resources are in **maximally entangled states** under ideal circumstances. But in reality, noise always exists due to interactions between the system and the environment during preparation stage, transmission, and preservation. Here, we use the depolarizing channel to simulate how a white noise could affect Bell states: " ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-04-09T02:58:30.352039Z", @@ -394,7 +395,7 @@ "output_type": "stream", "text": [ "Fidelity between the initial state and the Bell state 1\n", - "after transmission (depolarized channel), the fidelity between the entangled state and Bell state 0.81333\n", + "after transmission (depolarizing channel), the fidelity between the entangled state and Bell state 0.81333\n", "after preservation (amplitude damping channel), the fidelity between the entangled state and Bell state 0.66752\n" ] } @@ -402,7 +403,7 @@ "source": [ "import paddle\n", "from paddle import matmul, trace\n", - "from paddle_quantum.circuit import UAnsatz\n", + "from paddle_quantum.ansatz import Circuit\n", "from paddle_quantum.state import bell_state\n", "\n", "# Noise level\n", @@ -411,29 +412,29 @@ "\n", "# Initialize the circuit\n", "num_qubits = 2\n", - "cir = UAnsatz(num_qubits)\n", + "cir = Circuit(num_qubits)\n", "\n", "# The initial state is Bell state\n", - "init_state = paddle.to_tensor(bell_state(2))\n", + "init_state = bell_state(2)\n", "\n", - "# Apply the depolarized channel to each qubit, modeling the noise introduced by transmission\n", + "# Apply the depolarizing channel to each qubit, modeling the noise introduced by transmission\n", "cir.depolarizing(p_trans, 0)\n", "cir.depolarizing(p_trans, 1)\n", "\n", "# Execute the circuit \n", - "status_mid = cir.run_density_matrix(init_state)\n", + "status_mid = cir(init_state)\n", "\n", "# Apply the amplitude damping channel to each qubit, modeling the noise introduced by storage\n", "cir.amplitude_damping(p_store, 0)\n", "cir.amplitude_damping(p_store, 1)\n", "\n", "# Execute the circuit\n", - "status_fin = cir.run_density_matrix(status_mid)\n", - "fidelity_mid = paddle.real(trace(matmul(init_state, status_mid)))\n", - "fidelity_fin = paddle.real(trace(matmul(init_state, status_fin)))\n", + "status_fin = cir(status_mid)\n", + "fidelity_mid = paddle.real(trace(matmul(init_state.data, status_mid.data)))\n", + "fidelity_fin = paddle.real(trace(matmul(init_state.data, status_fin.data)))\n", "\n", "print(\"Fidelity between the initial state and the Bell state\", 1)\n", - "print(\"after transmission (depolarized channel), the fidelity between the entangled state and Bell state {:.5f}\".format(fidelity_mid.numpy()[0]))\n", + "print(\"after transmission (depolarizing channel), the fidelity between the entangled state and Bell state {:.5f}\".format(fidelity_mid.numpy()[0]))\n", "print(\"after preservation (amplitude damping channel), the fidelity between the entangled state and Bell state {:.5f}\".format(fidelity_fin.numpy()[0]))" ] }, @@ -465,7 +466,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2021-04-09T03:06:13.534545Z", @@ -476,14 +477,8 @@ "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\n", - "\n", - "# Construct Hamiltonian using Pauli string\n", - "H_info = [[0.4, 'z0'], [0.4, 'z1'], [0.2, 'x0,x1']]\n", - "\n", - "# Convert the Pauli string to a matrix\n", - "H_matrix = pauli_str_to_matrix(H_info, num_qubits)\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.qinfo import pauli_str_to_matrix\n", "\n", "# Hyperparameters\n", "num_qubits = 2\n", @@ -491,12 +486,19 @@ "ITR = 100\n", "LR = 0.4\n", "SEED = 999 \n", - "p = 0.1" + "p = 0.1\n", + "\n", + "# Construct Hamiltonian using Pauli string\n", + "H_info = [[0.4, 'z0'], [0.4, 'z1'], [0.2, 'x0,x1']]\n", + "\n", + "# Convert the Pauli string to a matrix\n", + "complex_dtype = paddle_quantum.get_dtype()\n", + "H_matrix = pauli_str_to_matrix(H_info, num_qubits).numpy().astype(complex_dtype)" ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 14, "metadata": { "ExecuteTime": { "end_time": "2021-04-09T03:06:36.986422Z", @@ -509,94 +511,81 @@ "output_type": "stream", "text": [ "========== Training Noisy VQE ==========\n", - "iter: 0 loss: 0.1974\n", - "iter: 10 loss: -0.6107\n", - "iter: 20 loss: -0.6515\n", - "iter: 30 loss: -0.6567\n", - "iter: 40 loss: -0.6600\n", - "iter: 50 loss: -0.6620\n", + "iter: 0 loss: -0.2139\n", + "iter: 10 loss: -0.6206\n", + "iter: 20 loss: -0.6481\n", + "iter: 30 loss: -0.6588\n", + "iter: 40 loss: -0.6599\n", + "iter: 50 loss: -0.6607\n", "iter: 60 loss: -0.6618\n", "iter: 70 loss: -0.6621\n", "iter: 80 loss: -0.6621\n", "iter: 90 loss: -0.6621\n", "========== Training Noise Free VQE ==========\n", - "iter: 0 loss: -0.5251\n", - "iter: 10 loss: -0.7949\n", - "iter: 20 loss: -0.8090\n", - "iter: 30 loss: -0.8227\n", - "iter: 40 loss: -0.8241\n", - "iter: 50 loss: -0.8242\n", - "iter: 60 loss: -0.8246\n", - "iter: 70 loss: -0.8246\n", + "iter: 0 loss: -0.0799\n", + "iter: 10 loss: -0.7243\n", + "iter: 20 loss: -0.8103\n", + "iter: 30 loss: -0.8180\n", + "iter: 40 loss: -0.8230\n", + "iter: 50 loss: -0.8240\n", + "iter: 60 loss: -0.8243\n", + "iter: 70 loss: -0.8245\n", "iter: 80 loss: -0.8246\n", "iter: 90 loss: -0.8246\n", "\n", - "Ground state energy from noisy circuit: -0.6621521112461377 Ha\n", - "Ground state energy from noiseless circuit: -0.8246151650552795 Ha\n", - "Actual ground state energy: -0.8246211251235321 Ha\n" + "Ground state energy from noisy circuit: -0.66215336 Ha\n", + "Ground state energy from noiseless circuit: -0.82461333 Ha\n", + "Actual ground state energy: -0.82462114 Ha\n" ] } ], "source": [ "class vqe_noisy(paddle.nn.Layer):\n", " \n", - " def __init__(self, shape, dtype='float64'):\n", + " def __init__(self):\n", " super(vqe_noisy, self).__init__()\n", - " \n", - " # Initialize a learnable parameter list with length theta_size, initial values are sampled from uniform distribution between [0, 2*pi]\n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0., high=2*np.pi), \n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # Define loss function and forward function\n", - " def forward(self):\n", - " \n", + "\n", " # Initialize circuit\n", - " cir = UAnsatz(num_qubits)\n", + " self.cir = Circuit(num_qubits)\n", " \n", " # Add parameterized gates\n", - " cir.ry(self.theta[0], 0)\n", - " cir.ry(self.theta[1], 1)\n", + " self.cir.ry([0, 1])\n", " \n", - " cir.cnot([0, 1])\n", + " self.cir.cnot([0, 1])\n", " \n", - " cir.ry(self.theta[2], 0)\n", - " cir.ry(self.theta[3], 1)\n", + " self.cir.ry([0, 1])\n", " \n", " # Add amplitude damping channel\n", - " cir.amplitude_damping(p, 0)\n", - " cir.amplitude_damping(p, 1)\n", - " \n", + " self.cir.amplitude_damping(p, [0, 1])\n", + " \n", + " # Define loss function and forward function\n", + " def forward(self):\n", + " \n", " # Execute the circuit\n", - " cir.run_density_matrix()\n", + " state = self.cir(init_state)\n", " \n", " # Expectation value of Hamiltonian \n", - " loss = cir.expecval(H_info)\n", + " loss = loss_func(state)\n", " \n", - " return loss\n", + " return loss, self.cir\n", " \n", "# Construct a noiseless circuit\n", "class vqe_noise_free(paddle.nn.Layer):\n", " \n", - " def __init__(self, shape, dtype='float64'):\n", + " def __init__(self):\n", " super(vqe_noise_free, self).__init__()\n", " \n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0., high=2*np.pi), \n", - " dtype=dtype, is_bias=False)\n", - " \n", + " self.cir = Circuit(num_qubits)\n", + " self.cir.ry([0, 1])\n", + " self.cir.cnot([0, 1])\n", + " self.cir.ry([0, 1])\n", + "\n", " def forward(self):\n", " \n", - " cir = UAnsatz(num_qubits)\n", - " cir.ry(self.theta[0], 0)\n", - " cir.ry(self.theta[1], 1) \n", - " cir.cnot([0, 1])\n", - " cir.ry(self.theta[2], 0)\n", - " cir.ry(self.theta[3], 1)\n", - " cir.run_density_matrix()\n", - " loss = cir.expecval(H_info)\n", + " state = self.cir(init_state)\n", + " loss = loss_func(state)\n", " \n", - " return loss\n", + " return loss, self.cir\n", " \n", "# Train noisy VQE circuit\n", "print('========== Training Noisy VQE ==========')\n", @@ -604,16 +593,22 @@ "parameter_list = []\n", "\n", "# Define the dimension of parameters\n", - "vqe = vqe_noisy([theta_size])\n", + "vqe = vqe_noisy()\n", "\n", "# Generally, we use Adam optimizer to get a better convergence, you can change to SVG or RMS prop.\n", - "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = vqe.parameters()) \n", + "opt = paddle.optimizer.Adam(learning_rate = LR, parameters = vqe.parameters()) \n", + "\n", + "# Define initial state\n", + "init_state = paddle_quantum.state.zero_state(num_qubits)\n", + "\n", + "# Define loss function\n", + "loss_func = paddle_quantum.loss.ExpecVal(paddle_quantum.Hamiltonian(H_info))\n", "\n", "# Optimization iteration\n", "for itr in range(ITR):\n", "\n", " # Forward, to calculate loss function\n", - " loss = vqe()\n", + " loss, cir = vqe()\n", "\n", " # Backpropagate to minimize the loss function\n", " loss.backward()\n", @@ -631,12 +626,12 @@ "loss_list_no_noise = []\n", "parameter_list_no_noise = []\n", "\n", - "vqe_no_noise = vqe_noise_free([theta_size])\n", + "vqe_no_noise = vqe_noise_free()\n", "opt_no_noise = paddle.optimizer.Adam(learning_rate = LR, parameters = vqe_no_noise.parameters()) \n", "\n", "for itr in range(ITR):\n", "\n", - " loss = vqe_no_noise()\n", + " loss, cir = vqe_no_noise()\n", "\n", " loss.backward()\n", " opt_no_noise.minimize(loss)\n", @@ -690,8 +685,11 @@ } ], "metadata": { + "interpreter": { + "hash": "4261e4eef114648d37e4a637967bd8d2966507f48b194e5e336ba3366b740269" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.13 ('pq-ns-icode')", "language": "python", "name": "python3" }, @@ -705,7 +703,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorials/qnn_research/VAns_CN.ipynb b/tutorials/qnn_research/VAns_CN.ipynb new file mode 100644 index 0000000..da662a2 --- /dev/null +++ b/tutorials/qnn_research/VAns_CN.ipynb @@ -0,0 +1,685 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# VAns—可变结构电路" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Copyright (c) 2022 Institute for Quantum Computing, Baidu Inc. All Rights Reserved." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "变分量子算法 (Variational Quantum Algorithm, VQA) 是一种使用经典优化器来训练参数化量子电路从而最小化特定的损失函数的算法。常见的变分量子算法，例如变分量子本征求解器（Variational Quantum Eigensolvers, VQE）和量子近似优化算法（Quantum Approximate Optimization Algorithm, QAOA），需要一个预设的固定参数化量子电路来完成优化过程。当电路过于简单时，其表达能力不够强，不足以得到目标损失函数的最优值。另一方面，如果电路过于复杂，虽然其表达能力很强，但是会受到贫瘠高原现象（Barren Plateau, BP）的影响，梯度的消失会使得优化器无法得到全局最优的解。所以，我们需要选择合适的电路结构来解决特定的问题，而一个好的电路设计算法就可以帮助我们找到这种电路。\n", + "\n", + "在本教程中，我们将介绍一种叫做 VAns 的可变结构电路算法 [1]，这种算法可以针对特定的问题找到一个较浅的电路完成优化过程。从一个简单的初始电路开始，VAns 算法在优化的过程中会不断向电路中添加和删减量子门模块，从而在优化损失函数的同时也能保持较短的电路的深度。我们将以量子本征求解这个问题作为例子来展示 VAns 算法，并和原来使用固定电路结构的 VQE 算法进行对比。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 算法流程" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "VAns 算法由如下步骤组成：\n", + "1. 准备一个简单的初始电路，使用经典优化器对电路参数进行调整，最小化目标损失函数，记录最优值。\n", + "2. 从一个集合中随机选择量子门模块（如下图所示，各量子门模块仅由 $R_y$ 门、$R_z$ 门，和 $CNOT$ 门组成），随机选择插入模块所作用的量子比特，并将模块添加到电路末尾。添加模块中的量子门的参数都初始化为 $0$ ，这样添加的模块一开始等同于 $I$。\n", + "\n", + "![Inserting Blocks](./figures/vans-fig-blocks.png)\n", + "\n", + "3. 根据下图中的规则化简电路，对化简后的电路进行优化，更新其参数，获得损失函数的当前最优值。比较当前损失函数最优值与上一个记录的最优值，根据设定的阈值决定是否接受新电路。若接受新电路，则继续遍历电路中的量子门，并删除不会降低损失的门，将精简过的电路记为当前电路，并记录其最优损失。若拒绝则直接回到第2步。\n", + "\n", + "![Simplification rules](./figures/vans-fig-rules.png)\n", + "\n", + "4. 重复步骤2-3，达到设定的迭代次数后停止，输出电路和最优损失。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 量桨实现" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们以求解氢分子的基态能量为例来展示如何在量桨上使用 VAns 算法，这里我们着重展示如何优化和精简电路结构，优化损失函数的过程同[变分量子本征求解器（VQE）](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html)。我们通过下面几行代码引入必要的包。" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import paddle\n", + "import paddle_quantum\n", + "import paddle_quantum.qchem as qchem\n", + "import numpy as np\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.ansatz.vans import Inserter, Simplifier, VAns, cir_decompose\n", + "from paddle_quantum.hamiltonian import Hamiltonian\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "np.random.seed(11)\n", + "paddle.seed(11)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们首先需要构造氢分子的哈密顿量，具体的说明可见[变分量子本征求解器（VQE）](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html)。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "geo = qchem.geometry(structure=[[\"H\", [-0.0, 0.0, 0.0]], [\"H\", [-0.0, 0.0, 0.74]]])\n", + "# 将分子信息存储在 molecule 里，包括单体积分（one-body integrations），双体积分（two-body integrations），分子的哈密顿量等\n", + "molecule = qchem.get_molecular_data(\n", + " geometry=geo,\n", + " basis=\"sto-3g\",\n", + " charge=0,\n", + " multiplicity=1,\n", + " method=\"fci\",\n", + " if_save=True,\n", + " if_print=True,\n", + ")\n", + "# 提取哈密顿量\n", + "molecular_hamiltonian = qchem.spin_hamiltonian(\n", + " molecule=molecule,\n", + " filename=None,\n", + " multiplicity=1,\n", + " mapping_method=\"jordan_wigner\",\n", + ")\n", + "# n 为量子比特数\n", + "n = molecular_hamiltonian.n_qubits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "接下来我们需要定义损失函数，也就是电路输出量子态关于该哈密顿量的期望值。" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# 定义损失函数\n", + "def loss_func(cir: Circuit, H: Hamiltonian) -> paddle.Tensor:\n", + " return cir().expec_val(H)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "在训练前，我们还需要设定一些有关 VAns 算法和优化器的参数。读者可以自行调整这些参数来观察 VAns 算法的变化。" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "EPSI = 0.001 # 插入模块初始化参数的浮动范围\n", + "IR = 1 # 添加模块的速率\n", + "ITERI = 120 # 参数优化的迭代次数\n", + "ITERO = 5 # 结构优化的迭代次数\n", + "LR = 0.1 # 学习率\n", + "T = 0.01 # 删除量子门时允许损失值上升的范围\n", + "A = 100 # 对于更新电路的采纳率\n", + "IS0 = True # 如果初始态为 |0>, 则设为 True\n", + "\n", + "paddle_quantum.set_backend('state_vector') # 设置运行模式为态矢量模式" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# 初始化一个 VAns 的模块对象\n", + "vans = VAns(n, loss_func, molecular_hamiltonian,\n", + " epsilon=EPSI,\n", + " insert_rate=IR,\n", + " iter=ITERI,\n", + " iter_out=ITERO,\n", + " LR=LR,\n", + " threshold=T,\n", + " accept_wall=A,\n", + " zero_init_state=IS0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 初始电路" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们给出了一个简单的初始电路，其参数是从均匀分布中随机选取的。对于这个初始电路，我们运行优化过程使损失函数最小化。优化过程和普通的 VQE 算法相同，参数 **iter** 和 **LR** 分别决定了优化器迭代次数和学习率。记录优化后的参数化电路以及损失，将其作为结构优化的起始点。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 20 loss: [-0.99608546]\n", + "iter: 40 loss: [-1.0926807]\n", + "iter: 60 loss: [-1.1136395]\n", + "iter: 80 loss: [-1.1163319]\n", + "iter: 100 loss: [-1.1167175]\n", + "iter: 120 loss: [-1.1167547]\n", + "当前电路:\n", + "--Rx(3.144)----Rz(3.512)----*----Rx(6.286)----Rz(2.441)-------------------------------------------------------------x--\n", + " | | \n", + "----------------------------x----Rx(4.249)----Rz(3.141)----Rx(4.246)----Rz(5.477)----*------------------------------|--\n", + " | | \n", + "--Rx(0.001)----Rz(5.499)----*--------------------------------------------------------x----Rx(3.141)----Rz(2.688)----|--\n", + " | | \n", + "----------------------------x----Rx(0.003)----Rz(2.362)----Rx(0.003)----Rz(1.500)-----------------------------------*--\n", + " \n" + ] + } + ], + "source": [ + "# 优化初始电路\n", + "itr_loss = vans.optimization(vans.cir) \n", + "\n", + "# 更新 vans 的损失值\n", + "vans.loss = itr_loss\n", + "\n", + "# 打印当前电路\n", + "print(\"当前电路:\\n\" + str(vans.cir))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 插入量子门模块" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "现在我们从量子门模块集合中随机选取模块，随机选取插入模块所作用的量子比特，并将模块插入到当前电路的尾端。注意新插入模块中的量子门的参数都被设置为 $0$，这样添加模块前后的电路实际上是相同的，也就是说更新后的电路可以继承之前电路的损失。下面的代码展示了如何在电路中插入模块。一次插入模块的数量由参数 **insert_rate** 决定。另一个参数 **epsilon** 是用来设定插入模块初始参数与 $0$ 之间的差别。" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "添加过后的电路:\n", + "--Rx(3.144)----Rz(3.512)----*----Rx(6.286)----Rz(2.441)----------------------------------------------------------------------------------------------------x--\n", + " | | \n", + "----------------------------x----Rz(0.000)----Rx(0.000)----Rx(-0.00)----Rx(4.249)----Rz(3.141)----Rx(4.246)----Rz(5.477)----*------------------------------|--\n", + " | | \n", + "--Rx(0.001)----Rz(5.499)----*-----------------------------------------------------------------------------------------------x----Rx(3.141)----Rz(2.688)----|--\n", + " | | \n", + "----------------------------x----Rx(0.003)----Rz(2.362)----Rx(0.003)----Rz(1.500)--------------------------------------------------------------------------*--\n", + " \n" + ] + } + ], + "source": [ + "# 向电路中添加模块，在这么做之前需要将电路从 layer 分解为量子门\n", + "new_cir = cir_decompose(vans.cir)\n", + "new_cir = Inserter.insert_identities(new_cir, vans.insert_rate, vans.epsilon)\n", + "\n", + "# 打印更新过后的电路\n", + "print(\"添加过后的电路:\\n\" + str(new_cir))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 简化电路" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "接下来我们需要化简当前的量子电路。化简电路的规则十分简单：\n", + "1. 将连续的 $CNOT$ 门合并消除；\n", + "2. 将连续的旋转门合并起来；\n", + "3. 若电路初始态为 $|0\\rangle$，删除电路前端的 $CNOT$ 门 和 $Rz$ 门；\n", + "4. 交换旋转门和 $CNOT$ 门的位置以便进一步化简。\n", + "\n", + "化简电路后，我们对电路中的参数进行优化以最小化损失函数，得到更新参数后的电路和对应的损失值。如果新的损失值小于之前记录的损失值，我们就接受这个电路作为新电路。如果新损失值大于之前的损失值，那么我们以一定概率接受这个电路，接受的概率与参数 **accept_wall** 有关。为了进一步简化电路，在接受新电路后，我们还会遍历电路中的量子门，如果删除某个量子门后，损失不会降低或者只会提高一个小于 **threshold** 的值，那么我们将该量子门删除，否则将其保留。" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--Rx(3.144)----Rz(3.512)----*----Rx(6.286)----Rz(2.441)------------------------------------------------x--\n", + " | | \n", + "----------------------------x----Rz(4.491)----Rx(4.470)----Rz(8.712)----*------------------------------|--\n", + " | | \n", + "--Rx(0.001)----Rz(5.499)----*-------------------------------------------x----Rx(3.141)----Rz(2.688)----|--\n", + " | | \n", + "----------------------------x----Rz(3.604)----Rx(5.126)----Rz(4.462)-----------------------------------*--\n", + " \n", + "iter: 20 loss: [-1.1121466]\n", + "iter: 40 loss: [-1.1123195]\n", + "iter: 60 loss: [-1.1158162]\n", + "iter: 80 loss: [-1.1166465]\n", + "iter: 100 loss: [-1.1167465]\n", + "iter: 120 loss: [-1.1167578]\n", + "Accpet the new circuit!\n", + " start deleting gates\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " 12 gates are deleted!\n" + ] + } + ], + "source": [ + "# 根据简化规则简化电路\n", + "new_cir = Simplifier.simplify_circuit(new_cir, vans.zero_init_state)\n", + "\n", + "# 打印简化过后的电路\n", + "print(new_cir)\n", + "\n", + "# 对简化过后的电路进行优化\n", + "itr_loss = vans.optimization(new_cir)\n", + "\n", + "# 计算损失值的变化\n", + "relative_diff = (itr_loss - vans.loss) / np.abs(itr_loss)\n", + "\n", + "# 若损失值降低或升高的幅度不大于设定的阈值，那么就接受电路\n", + "if relative_diff <= 0 or np.random.random() <= np.exp(\n", + " -relative_diff * vans.accept_wall\n", + "):\n", + " print(\"Accpet the new circuit!\")\n", + "\n", + " # 移除不会降低损失的量子门\n", + " new_cir = vans.delete_gates(new_cir, itr_loss)\n", + " new_cir = Simplifier.simplify_circuit(new_cir, vans.zero_init_state)\n", + " itr_loss = loss_func(new_cir, *vans.loss_args)\n", + " vans.loss = itr_loss\n", + "else:\n", + " print(\"Decline the new circuit!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "简化后的电路如下所示。" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "当前电路为:\n", + "--Rx(3.142)----*----------------------x--\n", + " | | \n", + "---------------x----*-----------------|--\n", + " | | \n", + "--------------------x----Rx(3.142)----|--\n", + " | \n", + "--------------------------------------*--\n", + " \n" + ] + } + ], + "source": [ + "# 更新当前电路\n", + "vans.cir = new_cir\n", + "\n", + "print(\"当前电路为:\\n\" + str(vans.cir))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "我们将上述的插入量子门模块和简化电路的步骤一起作为电路结构优化的一次迭代，总的迭代次数由参数 **iter_out** 决定。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 简化版本" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "上述过程清晰明了地展示了 VAns 的运行步骤和原理，包括了量子门模块添加以及电路简化的过程，然而实际在量桨中使用 VAns 可以不必了解这些繁杂的步骤，因为量桨提供了一个经过封装的 VAns 算法，以便用户进行调用。下面的一行代码可以完成所有的电路结构优化以及参数训练过程。" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Out iteration 1 for structure optimization:\n", + "iter: 20 loss: [-1.1167215]\n", + "iter: 40 loss: [-1.1166948]\n", + "iter: 60 loss: [-1.1167493]\n", + "iter: 80 loss: [-1.116759]\n", + "iter: 100 loss: [-1.1167591]\n", + "iter: 120 loss: [-1.1167595]\n", + " Current loss: [-1.1167595]\n", + " Current cir:\n", + "--Rx(3.142)----*----------------------x--\n", + " | | \n", + "---------------x----*-----------------|--\n", + " | | \n", + "--------------------x----Rx(3.142)----|--\n", + " | \n", + "--------------------------------------*--\n", + " \n", + "\n", + "Out iteration 2 for structure optimization:\n", + "iter: 20 loss: [-1.0998794]\n", + "iter: 40 loss: [-1.1144476]\n", + "iter: 60 loss: [-1.1166729]\n", + "iter: 80 loss: [-1.1167666]\n", + "iter: 100 loss: [-1.1207738]\n", + "iter: 120 loss: [-1.1371526]\n", + " accpet the new circuit!\n", + " start deleting gates\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " 2 gates are deleted!\n", + " Current loss: -1.1369835138320923\n", + " Current cir:\n", + "--Rx(3.142)----*------------------------------------------------------------------x--\n", + " | | \n", + "---------------x----*----Rx(-0.24)----Rz(1.462)----*--------*---------------------|--\n", + " | | | | \n", + "--------------------|------------------------------|--------x--------Rx(3.142)----|--\n", + " | | | \n", + "--------------------x------------------------------x----Rz(3.103)-----------------*--\n", + " \n", + "\n", + "Out iteration 3 for structure optimization:\n", + "iter: 20 loss: [-1.108532]\n", + "iter: 40 loss: [-1.1331518]\n", + "iter: 60 loss: [-1.1366322]\n", + "iter: 80 loss: [-1.1372447]\n", + "iter: 100 loss: [-1.1372827]\n", + "iter: 120 loss: [-1.1372826]\n", + " accpet the new circuit!\n", + " start deleting gates\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " 3 gates are deleted!\n", + " Current loss: -1.1372838020324707\n", + " Current cir:\n", + "--Rx(3.142)----*------------------------------------------------------------------x--\n", + " | | \n", + "---------------x----*----Rx(-0.22)----Rz(1.497)----*--------*---------------------|--\n", + " | | | | \n", + "--------------------|------------------------------|--------x--------Rx(3.141)----|--\n", + " | | | \n", + "--------------------x------------------------------x----Rz(3.068)-----------------*--\n", + " \n", + "\n", + "Out iteration 4 for structure optimization:\n", + "iter: 20 loss: [-1.137021]\n", + "iter: 40 loss: [-1.1371992]\n", + "iter: 60 loss: [-1.137272]\n", + "iter: 80 loss: [-1.137283]\n", + "iter: 100 loss: [-1.1372836]\n", + "iter: 120 loss: [-1.137284]\n", + " accpet the new circuit!\n", + " start deleting gates\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " 1 gates are deleted!\n", + " Current loss: -1.1372839212417603\n", + " Current cir:\n", + "--Rx(3.141)----*------------------------------------------------------------------x--\n", + " | | \n", + "---------------x----*----Rx(-0.22)----Rz(1.497)----*--------*---------------------|--\n", + " | | | | \n", + "--------------------|------------------------------|--------x--------Rx(3.141)----|--\n", + " | | | \n", + "--------------------x------------------------------x----Rz(3.068)-----------------*--\n", + " \n", + "\n", + "Out iteration 5 for structure optimization:\n", + "iter: 20 loss: [-1.137092]\n", + "iter: 40 loss: [-1.1371393]\n", + "iter: 60 loss: [-1.1372617]\n", + "iter: 80 loss: [-1.1372828]\n", + "iter: 100 loss: [-1.1372836]\n", + "iter: 120 loss: [-1.1372839]\n", + " accpet the new circuit!\n", + " start deleting gates\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " 2 gates are deleted!\n", + " Current loss: -1.1372840404510498\n", + " Current cir:\n", + "--Rx(3.141)----*------------------------------------------------------------------x--\n", + " | | \n", + "---------------x----*----Rx(-0.22)----Rz(1.497)----*--------*---------------------|--\n", + " | | | | \n", + "--------------------|------------------------------|--------x--------Rx(3.141)----|--\n", + " | | | \n", + "--------------------x------------------------------x----Rz(3.068)-----------------*--\n", + " \n", + "\n", + "\n", + "\n", + "The final loss: -1.1372840404510498\n", + "The final circuit:\n", + "--Rx(3.141)----*------------------------------------------------------------------x--\n", + " | | \n", + "---------------x----*----Rx(-0.22)----Rz(1.497)----*--------*---------------------|--\n", + " | | | | \n", + "--------------------|------------------------------|--------x--------Rx(3.141)----|--\n", + " | | | \n", + "--------------------x------------------------------x----Rz(3.068)-----------------*--\n", + " \n" + ] + } + ], + "source": [ + "# 使用 VAns 中内置的 train() 函数直接完成整个训练过程\n", + "vans.train()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "最终 VAns 算法给出的电路如下：" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "最终电路:\n", + "--Rx(3.141)----*------------------------------------------------------------------x--\n", + " | | \n", + "---------------x----*----Rx(-0.22)----Rz(1.497)----*--------*---------------------|--\n", + " | | | | \n", + "--------------------|------------------------------|--------x--------Rx(3.141)----|--\n", + " | | | \n", + "--------------------x------------------------------x----Rz(3.068)-----------------*--\n", + " \n", + "最终损失:\n", + "-1.1372840404510498\n" + ] + } + ], + "source": [ + "print(\"最终电路:\\n\" + str(vans.cir))\n", + "print(\"最终损失:\\n\" + str(vans.loss))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 与原始 VQE 的对比" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "通过上面的结果我们不难发现，通过 VAns 得到的电路仅含有5个参数，电路的深度为9，得到的最小损失值为 $-1.13728392$ Ha。而原始的 VQE 算法（见[变分量子本征求解器（VQE）](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html)）则需要一个含12个参数且深度为11的电路，由此可见 VAns 可以极大的减少电路中的参数数量并保持较浅的的电路深度。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Bilkis, M., et al. \"A semi-agnostic ansatz with variable structure for quantum machine learning.\" [arXiv preprint arXiv:2103.06712 (2021).](https://arxiv.org/abs/2103.06712)" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "9043b12ec77a531919bc05f05830335d23baf822720cbea14b03018197d26545" + }, + "kernelspec": { + "display_name": "Python 3.8.0 ('paddle-quantum-dev')", + "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.8.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/qnn_research/VAns_EN.ipynb b/tutorials/qnn_research/VAns_EN.ipynb new file mode 100644 index 0000000..cf1d630 --- /dev/null +++ b/tutorials/qnn_research/VAns_EN.ipynb @@ -0,0 +1,722 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "241d2f96", + "metadata": {}, + "source": [ + "# VAns—Variable Ansatz" + ] + }, + { + "cell_type": "markdown", + "id": "c94780c9", + "metadata": {}, + "source": [ + "Copyright (c) 2022 Institute for Quantum Computing, Baidu Inc. All Rights Reserved." + ] + }, + { + "cell_type": "markdown", + "id": "d84c0b5d", + "metadata": {}, + "source": [ + "## Overview" + ] + }, + { + "cell_type": "markdown", + "id": "96c37591", + "metadata": {}, + "source": [ + "Variational Quantum Algorithms (VQA) are about to tune parameters of quantum circuits to minimize an objective function of interest. The commonly used VQAs, like Variational Quantum Eigensolvers (VQE) and Quantum Approximate Optimization Algorithm (QAOA), perform optimization using a user-defined ansatz with fixed structure. However, if the ansatz is too simple or shallow, the expressivity of the circuit will not be insufficient to get the optimal value for the objective function. On the other side, if the ansatz is overly complicated or long, we may encounter barren plateau effect, which impedes us from obtaining the global minimum value. Thus, a circuit structure design search algorithm will be helpful to find the appropriate circuit for a specific task.\n", + "\n", + "In this tutorial, we will discuss a circuit architecture design search algorithm called Variable ansatz (VAns) [1]. Starting with an initial circuit, VAns keeps inserting and deleting gates during the optimization process in order to minimize the loss function as well as keep the circuit shallow. We will use this method to accomplish an adjusted version of VQE task and compare the resulting circuit with the original VQE circuit." + ] + }, + { + "cell_type": "markdown", + "id": "365bdd44", + "metadata": {}, + "source": [ + "## Pipeline" + ] + }, + { + "cell_type": "markdown", + "id": "89b09ff3", + "metadata": {}, + "source": [ + "VAns consists of the following steps: \n", + "1. Start with an initial circuit. Run the inner optimization, which is just the original VQE process, and get the optimal value. \n", + "2. Randomly choose a block from the 'pool' (As the following figure shows, each block only consists of $R_y$, $R_z$, and $CNOT$ gates), and insert the block at the end of circuit. Qubits that the block is applied on are also uniformly sampled. The parameters of the inserted gates are initialized to $0$ so that the inserted circuit is equivalent to identity. \n", + "\n", + "![Inserting Blocks](./figures/vans-fig-blocks.png)\n", + "\n", + "3. Simplify the circuit according to the following rules. Run the optimization process, and get the optimal value of loss function. Compare the loss value to the previously stored one, decide whether to accept the new circuit or not according to a pre-defined threshold. If the circuit is accepted, remove gates that do not lower the loss, set the circuit as the current circuit and store the corresponding loss value.\n", + "\n", + "![Simplification rules](./figures/vans-fig-rules.png)\n", + "\n", + "4. Repeat steps 2-3 for chosen number of iterations, output the resulting circuit and the optimal loss value.\n" + ] + }, + { + "cell_type": "markdown", + "id": "6f4130bd", + "metadata": {}, + "source": [ + "## Paddle Quantum Implementation" + ] + }, + { + "cell_type": "markdown", + "id": "1acdd35e", + "metadata": {}, + "source": [ + "We consider to get the ground state energy of Hydrogen molecule using [Variation Quantum Eigensolver (VQE)](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html) together with VAns to optimize the circuit structure as well. First, we import the required packages." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "722c14f5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import paddle\n", + "import paddle_quantum\n", + "import paddle_quantum.qchem as qchem\n", + "import numpy as np\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.ansatz.vans import Inserter, Simplifier, VAns, cir_decompose\n", + "from paddle_quantum.hamiltonian import Hamiltonian\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\")\n", + "np.random.seed(11)\n", + "paddle.seed(11)" + ] + }, + { + "cell_type": "markdown", + "id": "09179a6b", + "metadata": {}, + "source": [ + "Before using the VAns algorithm, we need to get the Hamiltonian for Hydrogen. Details can be found in the VQE tutorial." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c3f64aec", + "metadata": {}, + "outputs": [], + "source": [ + "geo = qchem.geometry(structure=[[\"H\", [-0.0, 0.0, 0.0]], [\"H\", [-0.0, 0.0, 0.74]]])\n", + "# Save molecule information in to variable molecule, including one-body integrations, molecular and Hamiltonian\n", + "molecule = qchem.get_molecular_data(\n", + " geometry=geo,\n", + " basis=\"sto-3g\",\n", + " charge=0,\n", + " multiplicity=1,\n", + " method=\"fci\",\n", + " if_save=True,\n", + " if_print=True,\n", + ")\n", + "# Recall Hamiltonian\n", + "molecular_hamiltonian = qchem.spin_hamiltonian(\n", + " molecule=molecule,\n", + " filename=None,\n", + " multiplicity=1,\n", + " mapping_method=\"jordan_wigner\",\n", + ")\n", + "# n is the number of qubits\n", + "n = molecular_hamiltonian.n_qubits" + ] + }, + { + "cell_type": "markdown", + "id": "8e90a098", + "metadata": {}, + "source": [ + "Then we define the loss function, which is simply the expectation value of the Hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "930b71a4", + "metadata": {}, + "outputs": [], + "source": [ + "# Define the loss function\n", + "def loss_func(cir: Circuit, H: Hamiltonian) -> paddle.Tensor:\n", + " return cir().expec_val(H)" + ] + }, + { + "cell_type": "markdown", + "id": "40d33794", + "metadata": {}, + "source": [ + "Next, we also need to set some training hyper-parameters before training." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "9c5bfe04", + "metadata": {}, + "outputs": [], + "source": [ + "EPSI = 0.001 # set the epsilon\n", + "IR = 1 # set the insertion rate\n", + "ITERI = 120 # set the number of iterations used for VQE\n", + "ITERO = 5 # set the number of iterations used for structure optimization\n", + "LR = 0.1 # set the learning rate\n", + "T = 0.01 # set the threshold\n", + "A = 100 # set the accept wall\n", + "IS0 = True # if the initial state is |0>, set to true\n", + "\n", + "paddle_quantum.set_backend('state_vector') # set the backend to state vector" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "6981e732", + "metadata": {}, + "outputs": [], + "source": [ + "# initialize the framework\n", + "vans = VAns(n, loss_func, molecular_hamiltonian,\n", + " epsilon=EPSI,\n", + " insert_rate=IR,\n", + " iter=ITERI,\n", + " iter_out=ITERO,\n", + " LR=LR,\n", + " threshold=T,\n", + " accept_wall=A,\n", + " zero_init_state=IS0)" + ] + }, + { + "cell_type": "markdown", + "id": "4349bb43", + "metadata": {}, + "source": [ + "### Initial Circuit" + ] + }, + { + "cell_type": "markdown", + "id": "0d4f3052", + "metadata": {}, + "source": [ + "We give a default initial circuit with uniformly sampled parameters. Then run the optimization process to get the optimal parameters in this initial circuit. The optimization process is the same as in the original VQE. Hyperparameters **iter** and **LR** are used in this process.The obtained loss function and the circuit with optimized parameters will be the initial point for the architecture optimization process. Note that the circuit is simplified when we decided to use this optimized circuit as the current starting point. Details of simplification can be found later." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f76b20bc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 20 loss: [-0.99608546]\n", + "iter: 40 loss: [-1.0926807]\n", + "iter: 60 loss: [-1.1136395]\n", + "iter: 80 loss: [-1.1163319]\n", + "iter: 100 loss: [-1.1167175]\n", + "iter: 120 loss: [-1.1167547]\n", + "Current circuit is:\n", + "--Rx(3.144)----Rz(3.512)----*----Rx(6.286)----Rz(2.441)-------------------------------------------------------------x--\n", + " | | \n", + "----------------------------x----Rx(4.249)----Rz(3.141)----Rx(4.246)----Rz(5.477)----*------------------------------|--\n", + " | | \n", + "--Rx(0.001)----Rz(5.499)----*--------------------------------------------------------x----Rx(3.141)----Rz(2.688)----|--\n", + " | | \n", + "----------------------------x----Rx(0.003)----Rz(2.362)----Rx(0.003)----Rz(1.500)-----------------------------------*--\n", + " \n" + ] + } + ], + "source": [ + "# Optimize the initial circuit\n", + "itr_loss = vans.optimization(vans.cir) \n", + "\n", + "# Update the loss\n", + "vans.loss = itr_loss\n", + "\n", + "# Print out the current circuit\n", + "print(\"Current circuit is:\\n\" + str(vans.cir))" + ] + }, + { + "cell_type": "markdown", + "id": "c95a7574", + "metadata": {}, + "source": [ + "### Insertion" + ] + }, + { + "cell_type": "markdown", + "id": "22f6d70a", + "metadata": {}, + "source": [ + "Now, we randomly choose a block from the 'pool', and insert the block at the end of circuit. Qubits that the block is applied on are also uniformly sampled. The parameters of the inserted set of gates are initialized to $0$ so that the new circuit can take the advantage of the previously optimized circuit since they act as identity. The code below inserts sets of gates into the circuit. The number of sets of gates depends on the hyperparameter **insert_rate**. Another hyperparameter **epsilon** is used to determine the variance from $0$ of initial parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "8dcdf789", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Circuit after insertion:\n", + "--Rx(3.144)----Rz(3.512)----*----Rx(6.286)----Rz(2.441)----------------------------------------------------------------------------------------------------x--\n", + " | | \n", + "----------------------------x----Rz(0.000)----Rx(0.000)----Rx(-0.00)----Rx(4.249)----Rz(3.141)----Rx(4.246)----Rz(5.477)----*------------------------------|--\n", + " | | \n", + "--Rx(0.001)----Rz(5.499)----*-----------------------------------------------------------------------------------------------x----Rx(3.141)----Rz(2.688)----|--\n", + " | | \n", + "----------------------------x----Rx(0.003)----Rz(2.362)----Rx(0.003)----Rz(1.500)--------------------------------------------------------------------------*--\n", + " \n" + ] + } + ], + "source": [ + "# Insert indentity blocks into the current circuit, before doing so, need to\n", + "# decompose the circuit from layers to gates\n", + "new_cir = cir_decompose(vans.cir)\n", + "new_cir = Inserter.insert_identities(new_cir, vans.insert_rate, vans.epsilon)\n", + "\n", + "# Print the updated circuit\n", + "print(\"Circuit after insertion:\\n\" + str(new_cir))" + ] + }, + { + "cell_type": "markdown", + "id": "cd07eeef", + "metadata": {}, + "source": [ + "### Simplification" + ] + }, + { + "cell_type": "markdown", + "id": "54a3fdd0", + "metadata": {}, + "source": [ + "Then we will simplify the new circuit. Rules are pretty simple:\n", + "1. Combine consecutive $CNOT$ gates.\n", + "2. Combine rotations gates.\n", + "3. Remove $CNOT$ gates and $Rz$ gates in the front of the circuit if the initial state is $|0\\rangle$.\n", + "4. Commute rotation gates and $CNOT$ gates if the circuit can be further simplified in doing so.\n", + "\n", + "Then we run the parameter optimization process again and get the new minimized value for the loss function. If the new value is smaller than the previous value or the difference between them is smaller than a value that depends on the hyperparameter **accept_wall**, we accpet the new circuit as the current circuit. After accepting the new circuit, we will remove gates that do not lower the loss or lower the loss within a **threshold**." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "d41b36e1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--Rx(3.144)----Rz(3.512)----*----Rx(6.286)----Rz(2.441)------------------------------------------------x--\n", + " | | \n", + "----------------------------x----Rz(4.491)----Rx(4.470)----Rz(8.712)----*------------------------------|--\n", + " | | \n", + "--Rx(0.001)----Rz(5.499)----*-------------------------------------------x----Rx(3.141)----Rz(2.688)----|--\n", + " | | \n", + "----------------------------x----Rz(3.604)----Rx(5.126)----Rz(4.462)-----------------------------------*--\n", + " \n", + "iter: 20 loss: [-1.1121466]\n", + "iter: 40 loss: [-1.1123195]\n", + "iter: 60 loss: [-1.1158162]\n", + "iter: 80 loss: [-1.1166465]\n", + "iter: 100 loss: [-1.1167465]\n", + "iter: 120 loss: [-1.1167578]\n", + "Accpet the new circuit!\n", + " start deleting gates\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " 12 gates are deleted!\n" + ] + } + ], + "source": [ + "# Simplify the updated circuit according to the simplification rules\n", + "new_cir = Simplifier.simplify_circuit(new_cir, vans.zero_init_state)\n", + "\n", + "# Print the simplied circuits\n", + "print(new_cir)\n", + "\n", + "# Then optimize the simplified circuits\n", + "itr_loss = vans.optimization(new_cir)\n", + "\n", + "# Calculate the change of loss\n", + "relative_diff = (itr_loss - vans.loss) / np.abs(itr_loss)\n", + "\n", + "# If the loss is decreased or increased within a threshold, accept the new circuit\n", + "if relative_diff <= 0 or np.random.random() <= np.exp(\n", + " -relative_diff * vans.accept_wall\n", + "):\n", + " print(\"Accpet the new circuit!\")\n", + "\n", + " # Remove gates that do not lower the loss\n", + " new_cir = vans.delete_gates(new_cir, itr_loss)\n", + " new_cir = Simplifier.simplify_circuit(new_cir, vans.zero_init_state)\n", + " itr_loss = loss_func(new_cir, *vans.loss_args)\n", + " vans.loss = itr_loss\n", + "else:\n", + " print(\"Decline the new circuit!\")" + ] + }, + { + "cell_type": "markdown", + "id": "bb98738a", + "metadata": {}, + "source": [ + "Then we update the current circuit to the new circuit." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "27a16d15", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The current circuit:\n", + "--Rx(3.142)----*----------------------x--\n", + " | | \n", + "---------------x----*-----------------|--\n", + " | | \n", + "--------------------x----Rx(3.142)----|--\n", + " | \n", + "--------------------------------------*--\n", + " \n" + ] + } + ], + "source": [ + "# Update the current circuit\n", + "vans.cir = new_cir\n", + "\n", + "print(\"The current circuit:\\n\" + str(vans.cir))" + ] + }, + { + "cell_type": "markdown", + "id": "1a8c71b9", + "metadata": {}, + "source": [ + "The insertion and simplification together forms one iteration for the architecture optimization process. The number of iterations is determined by the hyperparameter **iter_out**. " + ] + }, + { + "cell_type": "markdown", + "id": "d53c077c", + "metadata": {}, + "source": [ + "### Simple version" + ] + }, + { + "cell_type": "markdown", + "id": "e8383ce1", + "metadata": {}, + "source": [ + "While you can customize your own optimization process by adjusting insertion and simplification processes and implementing the training process, Paddle Quantum provides an elegant version of VAns. You can complete the architecture optimization all at once." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "c47505f7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Out iteration 1 for structure optimization:\n", + "iter: 20 loss: [-1.1167217]\n", + "iter: 40 loss: [-1.1166946]\n", + "iter: 60 loss: [-1.1167494]\n", + "iter: 80 loss: [-1.116759]\n", + "iter: 100 loss: [-1.1167591]\n", + "iter: 120 loss: [-1.1167595]\n", + " Current loss: [-1.1167595]\n", + " Current cir:\n", + "--Rx(3.142)----*----------------------x--\n", + " | | \n", + "---------------x----*-----------------|--\n", + " | | \n", + "--------------------x----Rx(3.142)----|--\n", + " | \n", + "--------------------------------------*--\n", + " \n", + "\n", + "Out iteration 2 for structure optimization:\n", + "iter: 20 loss: [-1.099879]\n", + "iter: 40 loss: [-1.1144477]\n", + "iter: 60 loss: [-1.1166729]\n", + "iter: 80 loss: [-1.1167666]\n", + "iter: 100 loss: [-1.1207733]\n", + "iter: 120 loss: [-1.1371529]\n", + " accpet the new circuit!\n", + " start deleting gates\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " 2 gates are deleted!\n", + " Current loss: -1.136983871459961\n", + " Current cir:\n", + "--Rx(3.142)----*------------------------------------------------------------------x--\n", + " | | \n", + "---------------x----*----Rx(-0.24)----Rz(1.462)----*--------*---------------------|--\n", + " | | | | \n", + "--------------------|------------------------------|--------x--------Rx(3.142)----|--\n", + " | | | \n", + "--------------------x------------------------------x----Rz(3.103)-----------------*--\n", + " \n", + "\n", + "Out iteration 3 for structure optimization:\n", + "iter: 20 loss: [-1.1085321]\n", + "iter: 40 loss: [-1.1331517]\n", + "iter: 60 loss: [-1.1366321]\n", + "iter: 80 loss: [-1.1372447]\n", + "iter: 100 loss: [-1.1372826]\n", + "iter: 120 loss: [-1.1372824]\n", + " accpet the new circuit!\n", + " start deleting gates\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " 3 gates are deleted!\n", + " Current loss: -1.1372839212417603\n", + " Current cir:\n", + "--Rx(3.142)----*------------------------------------------------------------------x--\n", + " | | \n", + "---------------x----*----Rx(-0.22)----Rz(1.497)----*--------*---------------------|--\n", + " | | | | \n", + "--------------------|------------------------------|--------x--------Rx(3.141)----|--\n", + " | | | \n", + "--------------------x------------------------------x----Rz(3.068)-----------------*--\n", + " \n", + "\n", + "Out iteration 4 for structure optimization:\n", + "iter: 20 loss: [-1.137021]\n", + "iter: 40 loss: [-1.1371994]\n", + "iter: 60 loss: [-1.1372718]\n", + "iter: 80 loss: [-1.137283]\n", + "iter: 100 loss: [-1.1372836]\n", + "iter: 120 loss: [-1.1372839]\n", + " accpet the new circuit!\n", + " start deleting gates\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " 1 gates are deleted!\n", + " Current loss: -1.1372839212417603\n", + " Current cir:\n", + "--Rx(3.141)----*------------------------------------------------------------------x--\n", + " | | \n", + "---------------x----*----Rx(-0.22)----Rz(1.497)----*--------*---------------------|--\n", + " | | | | \n", + "--------------------|------------------------------|--------x--------Rx(3.141)----|--\n", + " | | | \n", + "--------------------x------------------------------x----Rz(3.068)-----------------*--\n", + " \n", + "\n", + "Out iteration 5 for structure optimization:\n", + "iter: 20 loss: [-1.1370927]\n", + "iter: 40 loss: [-1.1371398]\n", + "iter: 60 loss: [-1.1372617]\n", + "iter: 80 loss: [-1.1372828]\n", + "iter: 100 loss: [-1.1372832]\n", + "iter: 120 loss: [-1.137284]\n", + " accpet the new circuit!\n", + " start deleting gates\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: reject deletion\n", + " Deletion: accept deletion with acceptable loss\n", + " Deletion: accept deletion with acceptable loss\n", + " 2 gates are deleted!\n", + " Current loss: -1.1372839212417603\n", + " Current cir:\n", + "--Rx(3.141)----*------------------------------------------------------------------x--\n", + " | | \n", + "---------------x----*----Rx(-0.22)----Rz(1.497)----*--------*---------------------|--\n", + " | | | | \n", + "--------------------|------------------------------|--------x--------Rx(3.141)----|--\n", + " | | | \n", + "--------------------x------------------------------x----Rz(3.068)-----------------*--\n", + " \n", + "\n", + "\n", + "\n", + "The final loss: -1.1372839212417603\n", + "The final circuit:\n", + "--Rx(3.141)----*------------------------------------------------------------------x--\n", + " | | \n", + "---------------x----*----Rx(-0.22)----Rz(1.497)----*--------*---------------------|--\n", + " | | | | \n", + "--------------------|------------------------------|--------x--------Rx(3.141)----|--\n", + " | | | \n", + "--------------------x------------------------------x----Rz(3.068)-----------------*--\n", + " \n" + ] + } + ], + "source": [ + "# optimization process all at once\n", + "vans.train()" + ] + }, + { + "cell_type": "markdown", + "id": "5c1ec809", + "metadata": {}, + "source": [ + "The final circuit we got from VAns is" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "61d49bb5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Final circuit:\n", + "--Rx(3.141)----*------------------------------------------------------------------x--\n", + " | | \n", + "---------------x----*----Rx(-0.22)----Rz(1.497)----*--------*---------------------|--\n", + " | | | | \n", + "--------------------|------------------------------|--------x--------Rx(3.141)----|--\n", + " | | | \n", + "--------------------x------------------------------x----Rz(3.068)-----------------*--\n", + " \n", + "Final loss:\n", + "-1.1372839212417603\n" + ] + } + ], + "source": [ + "print(\"Final circuit:\\n\" + str(vans.cir))\n", + "print(\"Final loss:\\n\" + str(vans.loss))" + ] + }, + { + "cell_type": "markdown", + "id": "b78222d3", + "metadata": {}, + "source": [ + "## Comparison with original VQE" + ] + }, + { + "cell_type": "markdown", + "id": "f2387269", + "metadata": {}, + "source": [ + "The circuit we got using VAns consists of only 5 parameters and the depth of the circuit is 9. The minimized loss value is $-1.13728392$ Ha. Comparing to the fixed ansatz used in the original VQE tutorial, where the circuit consists of 12 parameters and with depth 11, VAns reduces the number of parameters needed while keeps the circuit shallower. " + ] + }, + { + "cell_type": "markdown", + "id": "c21e251e", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## References\n", + "\n", + "[1] Bilkis, M., et al. \"A semi-agnostic ansatz with variable structure for quantum machine learning.\" [arXiv preprint arXiv:2103.06712 (2021).](https://arxiv.org/abs/2103.06712)" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "9043b12ec77a531919bc05f05830335d23baf822720cbea14b03018197d26545" + }, + "kernelspec": { + "display_name": "Python 3.8.0 ('paddle-quantum-dev')", + "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.8.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/qnn_research/VQCC_CN.ipynb b/tutorials/qnn_research/VQCC_CN.ipynb similarity index 70% rename from tutorial/qnn_research/VQCC_CN.ipynb rename to tutorials/qnn_research/VQCC_CN.ipynb index 8141319..a9baa89 100644 --- a/tutorial/qnn_research/VQCC_CN.ipynb +++ b/tutorials/qnn_research/VQCC_CN.ipynb @@ -75,16 +75,17 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "ae8f2fdb", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import dagger, trace_distance\n", - "from paddle_quantum.state import density_op_random" + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.linalg import dagger\n", + "from paddle_quantum.state import random_state, zero_state" ] }, { @@ -97,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "4663732b", "metadata": { "scrolled": true @@ -115,7 +116,7 @@ " [0, 0, 0, 0, 0, 1, 0, 0],\n", " [0, 0, 0, 0, 0, 0, 0, 1],\n", " [0, 0, 0, 0, 0, 0, 1, 0]],\n", - " dtype=\"float64\"))" + " dtype=\"float32\"))" ] }, { @@ -125,22 +126,22 @@ "source": [ "### 搭建量子电路\n", "\n", - "不同的量子神经网络（Quantum Neural Network, QNN）表达能力不同，此处我们选择的是量桨中内置的 `complex_entangled_layer(theta, D)` 模板构造表达能力较强的电路模板搭建 QNN：" + "不同的量子神经网络（Quantum Neural Network, QNN）表达能力不同，此处我们选择的是量桨中内置的 `complex_entangled_layer()` 模板构造表达能力较强的电路模板搭建 QNN：" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "4e400e2e", "metadata": {}, "outputs": [], "source": [ "# 构建量子电路\n", - "def Circuit(theta, n, D):\n", + "def qcircuit(n, D):\n", " # 初始化 n 个量子比特的量子电路\n", - " cir = UAnsatz(n)\n", + " cir = Circuit(n)\n", " # 内置的包含 U3 门和 CNOT 门的强纠缠电路模板\n", - " cir.complex_entangled_layer(theta[:D], D)\n", + " cir.complex_entangled_layer('full', n, D)\n", "\n", " return cir" ] @@ -157,28 +158,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "29c9ed4a", "metadata": {}, "outputs": [], "source": [ - "# 训练模型cost-function\n", - "class Net(paddle.nn.Layer):\n", - " def __init__(self, shape, dtype=\"float64\", ):\n", - " super(Net, self).__init__()\n", - "\n", - " self.theta = self.create_parameter(shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype=dtype, is_bias=False)\n", + "# 定义损失函数\n", + "def loss_func(cir, target_u):\n", + " # 量子电路的矩阵表示\n", + " V = cir.unitary_matrix()\n", + " # 直接构造 (1) 式为损失函数\n", + " loss = 1 - (dagger(V).matmul(target_u).trace().abs() / V.shape[0]) ** 2\n", "\n", - " def forward(self, n, D):\n", - " # 量子电路的矩阵表示\n", - " cir = Circuit(self.theta, n, D)\n", - " V = cir.U\n", - " # 直接构造 (1) 式为损失函数\n", - " loss =1 - (dagger(V).matmul(U_0).trace().abs() / V.shape[0]) ** 2\n", - "\n", - " return loss, cir " + " return loss" ] }, { @@ -188,18 +180,18 @@ "source": [ "### 配置训练模型 —— 模型参数\n", "\n", - "对 QNN 进行训练前，我们还需要进行一些训练的超参数设置，主要是 QNN 计算模块的层数 $D$、学习速率 LR 以及训练的总迭代次数 ITR。此处我们设置学习速率为 0.1，迭代次数为 150 次。读者可以自行调整来直观感受下超参数调整对训练效果的影响。" + "对 QNN 进行训练前，我们还需要进行一些训练的超参数设置，主要是 QNN 计算模块的层数 $D$、学习速率 LR 以及训练的总迭代次数 ITR。此处我们设置学习速率为 0.2，迭代次数为 150 次。读者可以自行调整来直观感受下超参数调整对训练效果的影响。" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "4046e5b0", "metadata": {}, "outputs": [], "source": [ "D = 5 # 量子电路的层数\n", - "LR = 0.1 # 基于梯度下降的优化方法的学习率\n", + "LR = 0.2 # 基于梯度下降的优化方法的学习率\n", "ITR = 150 # 训练的总迭代次数" ] }, @@ -213,7 +205,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "7103bf1c", "metadata": {}, "outputs": [ @@ -221,11 +213,11 @@ "name": "stdout", "output_type": "stream", "text": [ - "iter: 30 loss: 0.1571\n", - "iter: 60 loss: 0.0063\n", - "iter: 90 loss: 0.0004\n", + "iter: 30 loss: 0.0318\n", + "iter: 60 loss: 0.0018\n", + "iter: 90 loss: 0.0001\n", "iter: 120 loss: 0.0000\n", - "iter: 150 loss: 0.0000\n", + "iter: 150 loss: -0.0000\n", "\n", "训练后的电路：\n", "--U----*---------x----U----*---------x----U----*---------x----U----*---------x----U----*---------x--\n", @@ -235,41 +227,36 @@ "--U---------x----*----U---------x----*----U---------x----*----U---------x----*----U---------x----*--\n", " \n", "优化后的参数 theta:\n", - " [[[ 6.283e+00 3.005e+00 2.493e+00]\n", - " [ 1.571e+00 3.141e+00 7.068e+00]\n", - " [-7.850e-01 3.141e+00 1.571e+00]]\n", - "\n", - " [[ 4.712e+00 1.571e+00 4.713e+00]\n", - " [ 1.571e+00 -1.000e-03 1.571e+00]\n", - " [ 6.283e+00 4.427e+00 1.857e+00]]\n", + " [[[[ 4.712 6.283 3.927]\n", + " [ 3.142 3.713 4.499]\n", + " [ 5.498 4.712 4.712]]\n", "\n", - " [[ 6.283e+00 2.003e+00 3.494e+00]\n", - " [ 4.713e+00 -1.571e+00 -0.000e+00]\n", - " [ 3.142e+00 2.248e+00 5.390e+00]]\n", + " [[ 1.571 1.571 4.712]\n", + " [ 4.712 4.712 4.712]\n", + " [ 3.142 2.022 3.593]]\n", "\n", - " [[ 3.142e+00 1.158e+00 5.085e+00]\n", - " [ 3.927e+00 3.142e+00 4.713e+00]\n", - " [ 1.571e+00 4.712e+00 2.356e+00]]\n", + " [[-0.785 4.713 1.571]\n", + " [ 0.785 1.571 6.283]\n", + " [ 6.283 0.48 0.305]]\n", "\n", - " [[ 3.140e+00 6.180e+00 6.180e+00]\n", - " [ 1.571e+00 1.571e+00 3.142e+00]\n", - " [ 0.000e+00 3.770e-01 2.764e+00]]\n", + " [[ 4.712 0.785 6.283]\n", + " [ 1.571 -0. 3.142]\n", + " [ 3.142 3.844 3.844]]\n", "\n", - " [[ 6.107e+00 5.604e+00 5.597e+00]\n", - " [ 3.890e-01 5.391e+00 4.620e-01]\n", - " [ 3.935e+00 3.262e+00 9.850e-01]]]\n" + " [[ 6.283 0.987 3.725]\n", + " [ 4.712 4.712 6.284]\n", + " [ 6.283 1.993 4.29 ]]]]\n" ] } ], "source": [ - "# 确定网络参数维度\n", - "net = Net(shape=[D + 1, n, 3])\n", + "cir = qcircuit(n, D)\n", "# 使用 Adam 优化器\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=cir.parameters())\n", "\n", "# 进行迭代\n", "for itr in range(1, ITR + 1):\n", - " loss, cir = net.forward(n, D)\n", + " loss = loss_func(cir, U_0)\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", @@ -280,7 +267,7 @@ " print(\"\\n训练后的电路：\")\n", " print(cir)\n", "\n", - "theta_opt = net.theta.numpy()\n", + "theta_opt = cir.parameters()\n", "print(\"优化后的参数 theta:\\n\", np.around(theta_opt, decimals=3))" ] }, @@ -304,7 +291,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "12678dff", "metadata": {}, "outputs": [ @@ -313,25 +300,25 @@ "output_type": "stream", "text": [ "sample: 1 :\n", - " trace distance is 0.00039\n", + " trace distance is 0.00023\n", "sample: 2 :\n", - " trace distance is 0.00038\n", + " trace distance is 0.00027\n", "sample: 3 :\n", - " trace distance is 0.00041\n", + " trace distance is 0.00026\n", "sample: 4 :\n", - " trace distance is 0.00043\n", + " trace distance is 0.00027\n", "sample: 5 :\n", - " trace distance is 0.00032\n", + " trace distance is 0.00024\n", "sample: 6 :\n", - " trace distance is 0.00036\n", + " trace distance is 0.00024\n", "sample: 7 :\n", - " trace distance is 0.0003\n", + " trace distance is 0.00025\n", "sample: 8 :\n", - " trace distance is 0.0004\n", + " trace distance is 0.00024\n", "sample: 9 :\n", - " trace distance is 0.00038\n", + " trace distance is 0.00024\n", "sample: 10 :\n", - " trace distance is 0.00042\n" + " trace distance is 0.00027\n" ] } ], @@ -339,11 +326,13 @@ "s = 10 # 定义随机生成密度矩阵的数量\n", "\n", "for i in range(s):\n", - " sampled = paddle.to_tensor(density_op_random(3).astype('complex128')) # 随机生成 3 量子比特的密度矩阵 sampled\n", - " simulated_output = paddle.matmul(paddle.matmul(cir.U, sampled), dagger(cir.U)) # sampled 经过近似酉算子演化后的结果\n", - " real_output = paddle.matmul(paddle.matmul(paddle.to_tensor(U_0), sampled), dagger(paddle.to_tensor(U_0))) # sampled 经过目标酉算子演化后的结果\n", + " paddle_quantum.set_backend('density_matrix') # 切换至密度矩阵模式\n", + " sampled = random_state(3) # 随机生成 3 量子比特的密度矩阵 sampled\n", + " simulated_output = paddle.matmul(paddle.matmul(cir.unitary_matrix(), sampled.data), dagger(cir.unitary_matrix())) # sampled 经过近似酉算子演化后的结果\n", + " real_output = paddle.matmul(paddle.matmul(paddle.to_tensor(U_0), sampled.data), dagger(paddle.to_tensor(U_0))) # sampled 经过目标酉算子演化后的结果\n", " print('sample:', i + 1, ':')\n", - " d = trace_distance(real_output.numpy(), simulated_output.numpy())\n", + " A = simulated_output.numpy() - real_output.numpy()\n", + " d = 1 / 2 * np.sum(np.abs(np.linalg.eigvals(A)))\n", " print(' trace distance is', np.around(d, decimals=5)) # 输出两种结果间的迹距离\n" ] }, @@ -398,7 +387,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "id": "d6852694", "metadata": {}, "outputs": [], @@ -406,23 +395,23 @@ "n = 3 # 设定量子比特数\n", "\n", "# 构建量子电路\n", - "def Circuit(theta, n, D):\n", + "def qcircuit(n, D):\n", " \n", " # 初始化 2n 个量子比特的量子电路\n", - " cir = UAnsatz(2 * n)\n", + " cir = Circuit(2 * n)\n", + " cir.h(list(range(n)))\n", " for i in range(n):\n", - " cir.h(i)\n", " cir.cnot([i, n + i])\n", + " \n", " # 构建 U 的电路\n", - " cir.ccx([0, 1, 2])\n", + " cir.toffoli([0, 1, 2])\n", " \n", " # 构建 QNN\n", - " cir.complex_entangled_layer(theta, D, [3, 4, 5])\n", + " cir.complex_entangled_layer([3, 4, 5], n, D)\n", "\n", " for l in range(n):\n", " cir.cnot([n - 1 - l, 2 * n - 1 - l])\n", - " for m in range(n):\n", - " cir.h(m)\n", + " cir.h(list(range(n)))\n", "\n", " return cir" ] @@ -439,32 +428,21 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "id": "7ee10c61", "metadata": {}, "outputs": [], "source": [ - "class Net(paddle.nn.Layer):\n", - " def __init__(self, shape, dtype=\"float64\", ):\n", - " super(Net, self).__init__()\n", - " \n", - " # 初始化层数以及各角度的参数，并用 [0, 2 * pi] 的均匀分布来填充角度的初始值\n", - " self.D = D\n", - " self.theta = self.create_parameter(shape=[D, n, 3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype=dtype, is_bias=False)\n", - "\n", - " # 定义损失函数和向前传播机制\n", - " def forward(self):\n", - " \n", - " # 量子电路的矩阵表示\n", - " cir = Circuit(self.theta, n, self.D)\n", - " # 输出经过线路后量子态的密度矩阵 rho\n", - " rho = cir.run_density_matrix()\n", - " # 计算损失函数 loss，其中输出密度矩阵的第一个元素即为全零态的概率\n", - " loss = 1 - paddle.real(rho[0][0])\n", + "# 定义损失函数\n", + "def loss_func(cir):\n", + " paddle_quantum.set_backend('density_matrix')\n", + " # 输出经过线路后量子态的密度矩阵 rho\n", + " init_state = zero_state(2 * n)\n", + " rho = cir(init_state)\n", + " # 计算损失函数 loss，其中输出密度矩阵的第一个元素即为全零态的概率\n", + " loss = 1 - paddle.real(rho.data[0][0])\n", "\n", - " return loss, cir" + " return loss " ] }, { @@ -479,7 +457,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "id": "280e2858", "metadata": {}, "outputs": [], @@ -501,7 +479,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "id": "77919a34", "metadata": {}, "outputs": [ @@ -509,65 +487,57 @@ "name": "stdout", "output_type": "stream", "text": [ - "iter: 20 loss: 0.2235\n", - "iter: 40 loss: 0.0187\n", - "iter: 60 loss: 0.0029\n", - "iter: 80 loss: 0.0004\n", + "iter: 20 loss: 0.0720\n", + "iter: 40 loss: 0.0127\n", + "iter: 60 loss: 0.0013\n", + "iter: 80 loss: 0.0002\n", "iter: 100 loss: 0.0000\n", "iter: 120 loss: 0.0000\n", "\n", "训练后的电路：\n", - "电路形式输入的 U 的近似电路：\n", - " --H----*------------------------*-------------------------------------------------------------------------------------------------------------*----H--\n", - " | | | \n", - "-------|----H----*--------------*--------------------------------------------------------------------------------------------------------*----|----H--\n", - " | | | | | \n", - "-------|---------|----H----*----X---------------------------------------------------------------------------------------------------*----|----|----H--\n", - " | | | | | | \n", - "-------x---------|---------|----U----*---------x----U----*---------x----U----*---------x----U----*---------x----U----*---------x----|----|----x-------\n", - " | | | | | | | | | | | | | | \n", - "-----------------x---------|----U----x----*----|----U----x----*----|----U----x----*----|----U----x----*----|----U----x----*----|----|----x------------\n", - " | | | | | | | | | | | | \n", - "---------------------------x----U---------x----*----U---------x----*----U---------x----*----U---------x----*----U---------x----*----x-----------------\n", - " \n" + "--H----*--------------*-------------------------------------------------------------------------------------------------------------*----H--\n", + " | | | \n", + "--H----|----*---------*--------------------------------------------------------------------------------------------------------*----|----H--\n", + " | | | | | \n", + "--H----|----|----*----X---------------------------------------------------------------------------------------------------*----|----|----H--\n", + " | | | | | | \n", + "-------x----|----|----U----*---------x----U----*---------x----U----*---------x----U----*---------x----U----*---------x----|----|----x-------\n", + " | | | | | | | | | | | | | | \n", + "------------x----|----U----x----*----|----U----x----*----|----U----x----*----|----U----x----*----|----U----x----*----|----|----x------------\n", + " | | | | | | | | | | | | \n", + "-----------------x----U---------x----*----U---------x----*----U---------x----*----U---------x----*----U---------x----*----x-----------------\n", + " \n" ] } ], "source": [ - "# 确定网络的参数维度\n", - "net = Net(D)\n", - "\n", + "cir = qcircuit(n, D)\n", "# 使用 Adam 优化器\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=cir.parameters())\n", "\n", - "# 优化循环\n", + "# 进行迭代\n", "for itr in range(1, ITR + 1):\n", - " \n", - " # 前向传播计算损失函数\n", - " loss, cir= net.forward()\n", - " \n", - " # 反向传播极小化损失函数\n", + " loss = loss_func(cir)\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", "\n", - " # 打印训练结果\n", " if itr % 20 == 0:\n", - " print(\"iter:\",itr,\"loss:\",\"%.4f\" % loss.numpy())\n", + " print(\"iter:\", itr, \"loss:\", \"%.4f\" % loss.numpy())\n", " if itr == ITR:\n", " print(\"\\n训练后的电路：\")\n", - " print('电路形式输入的 U 的近似电路：\\n', cir)\n" + " print(cir)" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "id": "df546ac5", "metadata": {}, "outputs": [], "source": [ "# 存储优化后的参数\n", - "theta_opt = net.theta.numpy()" + "theta_opt = cir.parameters()[0]" ] }, { @@ -590,7 +560,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "0c339ca3", "metadata": {}, "outputs": [ @@ -599,46 +569,50 @@ "output_type": "stream", "text": [ "sample 1 :\n", - " trace distance is 0.00132\n", + " trace distance is 0.00159\n", "sample 2 :\n", - " trace distance is 0.00148\n", + " trace distance is 0.00153\n", "sample 3 :\n", - " trace distance is 0.00119\n", + " trace distance is 0.00149\n", "sample 4 :\n", - " trace distance is 0.00116\n", + " trace distance is 0.00153\n", "sample 5 :\n", - " trace distance is 0.00128\n", + " trace distance is 0.00142\n", "sample 6 :\n", - " trace distance is 0.00141\n", + " trace distance is 0.00167\n", "sample 7 :\n", - " trace distance is 0.00138\n", + " trace distance is 0.00158\n", "sample 8 :\n", - " trace distance is 0.00132\n", + " trace distance is 0.0016\n", "sample 9 :\n", - " trace distance is 0.00141\n", + " trace distance is 0.00153\n", "sample 10 :\n", - " trace distance is 0.00147\n" + " trace distance is 0.00152\n" ] } ], "source": [ "s = 10 # 定义随机生成密度矩阵的数量\n", - "for i in range(s):\n", - " sampled = paddle.to_tensor(density_op_random(3).astype('complex128')) # 随机生成 4 量子比特的密度矩阵 sampled\n", "\n", + "for i in range(s):\n", + " paddle_quantum.set_backend('density_matrix') # 切换至密度矩阵模式 \n", + " sampled = random_state(3) # 随机生成 3 量子比特的密度矩阵 sampled\n", " # 构造目标酉算子对应的电路\n", - " cir_1 = UAnsatz(3)\n", - " cir_1.ccx([0, 1, 2])\n", + " cir_1 = Circuit(3)\n", + " cir.toffoli([0, 1, 2])\n", " # sampled 经过目标酉算子演化后的结果\n", - " real_output = paddle.matmul(paddle.matmul(cir_1.U, sampled), dagger(cir_1.U))\n", + " real_output = paddle.matmul(paddle.matmul(cir_1.unitary_matrix(), sampled.data), dagger(cir_1.unitary_matrix()))\n", "\n", " # 构造近似酉算子对应的电路\n", - " cir_2 = UAnsatz(3)\n", - " cir_2.complex_entangled_layer(paddle.to_tensor(theta_opt), D, [0, 1, 2])\n", + " cir_2 = Circuit(3)\n", + " for j in range(D):\n", + " cir_2.u3(qubits_idx='full', num_qubits=3, param=theta_opt[j])\n", + " cir_2.cnot(qubits_idx='cycle')\n", " # sampled 经过近似酉算子演化后的结果\n", - " simulated_output = paddle.matmul(paddle.matmul(cir_2.U, sampled), dagger(cir_2.U))\n", + " simulated_output = paddle.matmul(paddle.matmul(cir_2.unitary_matrix(), sampled.data), dagger(cir_2.unitary_matrix()))\n", "\n", - " d = trace_distance(real_output.numpy(), simulated_output.numpy())\n", + " A = simulated_output.numpy() - real_output.numpy()\n", + " d = 1 / 2 * np.sum(np.abs(np.linalg.eigvals(A)))\n", " print('sample', i + 1, ':')\n", " print(' trace distance is', np.around(d, decimals=5)) # 输出两种结果间的迹距离" ] @@ -681,8 +655,11 @@ } ], "metadata": { + "interpreter": { + "hash": "f7cfecff1ef1940b21a48efa1b88278bb096bd916f13c2df11af4810c38b47e1" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.0 ('pq')", "language": "python", "name": "python3" }, @@ -696,7 +673,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.0" } }, "nbformat": 4, diff --git a/tutorial/qnn_research/VQCC_EN.ipynb b/tutorials/qnn_research/VQCC_EN.ipynb similarity index 72% rename from tutorial/qnn_research/VQCC_EN.ipynb rename to tutorials/qnn_research/VQCC_EN.ipynb index 0d6687e..308fccd 100644 --- a/tutorial/qnn_research/VQCC_EN.ipynb +++ b/tutorials/qnn_research/VQCC_EN.ipynb @@ -75,16 +75,17 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "ae8f2fdb", "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import dagger, trace_distance\n", - "from paddle_quantum.state import density_op_random" + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.linalg import dagger\n", + "from paddle_quantum.state import random_state, zero_state" ] }, { @@ -97,12 +98,13 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "4663732b", "metadata": {}, "outputs": [], "source": [ "n = 3 # Number of qubits\n", + "\n", "# The matrix form of Toffoli gate\n", "U_0 = paddle.to_tensor(np.matrix([[1, 0, 0, 0, 0, 0, 0, 0],\n", " [0, 1, 0, 0, 0, 0, 0, 0],\n", @@ -112,7 +114,7 @@ " [0, 0, 0, 0, 0, 1, 0, 0],\n", " [0, 0, 0, 0, 0, 0, 0, 1],\n", " [0, 0, 0, 0, 0, 0, 1, 0]],\n", - " dtype=\"float64\"))" + " dtype=\"float32\"))" ] }, { @@ -122,22 +124,22 @@ "source": [ "### Constructing quantum circuits\n", "\n", - "Different QNNs have different expressibility. Here we choose the `complex_entangled_layer(theta, D)` function built-in in Paddle Quantum to construct QNN:" + "Different QNNs have different expressibility. Here we choose the `complex_entangled_layer()` function built-in in Paddle Quantum to construct QNN:" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "4e400e2e", "metadata": {}, "outputs": [], "source": [ "# Constructing quantum circuit\n", - "def Circuit(theta, n, D):\n", + "def qcircuit(n, D):\n", " # Initialize the circuit\n", - " cir = UAnsatz(n)\n", + " cir = Circuit(n)\n", " # Call the built-in QNN template\n", - " cir.complex_entangled_layer(theta[:D], D)\n", + " cir.complex_entangled_layer('full', n, D)\n", "\n", " return cir" ] @@ -155,28 +157,19 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "29c9ed4a", "metadata": {}, "outputs": [], "source": [ - "# Training loss function\n", - "class Net(paddle.nn.Layer):\n", - " def __init__(self, shape, dtype=\"float64\", ):\n", - " super(Net, self).__init__()\n", - "\n", - " self.theta = self.create_parameter(shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype=dtype, is_bias=False)\n", - "\n", - " def forward(self, n, D):\n", - " # The matrix form of the circuit\n", - " cir = Circuit(self.theta, n, D)\n", - " V = cir.U\n", - " # Construct Eq.(1) as the loss function\n", - " loss =1 - (dagger(V).matmul(U_0).trace().abs() / V.shape[0]) ** 2\n", + "# Define the loss function\n", + "def loss_func(cir, target_u):\n", + " # The matrix form of the circuit\n", + " V = cir.unitary_matrix()\n", + " # Construct Eq.(1) as the loss function\n", + " loss = 1 - (dagger(V).matmul(target_u).trace().abs() / V.shape[0]) ** 2\n", "\n", - " return loss, cir " + " return loss " ] }, { @@ -186,18 +179,18 @@ "source": [ "### Setting up the training model - model parameters\n", "\n", - "Before training the QNN, we also need to set some training hyperparameters, mainly the depth (D) of repeated blocks, the learning rate (LR), and the number of iterations (ITR). Here we set the learning rate to 0.1 and the number of iterations to 150. The reader can adjust the hyperparameters to observe the impact on the training effect." + "Before training the QNN, we also need to set some training hyperparameters, mainly the depth (D) of repeated blocks, the learning rate (LR), and the number of iterations (ITR). Here we set the learning rate to 0.2 and the number of iterations to 150. The reader can adjust the hyperparameters to observe the impact on the training effect." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "4046e5b0", "metadata": {}, "outputs": [], "source": [ "D = 5 # Set the depth of QNN\n", - "LR = 0.1 # Set the learning rate\n", + "LR = 0.2 # Set the learning rate\n", "ITR = 150 # Set the number of optimization iterations" ] }, @@ -211,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "7103bf1c", "metadata": {}, "outputs": [ @@ -219,13 +212,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "iter: 30 loss: 0.1627\n", - "iter: 60 loss: 0.0033\n", + "iter: 30 loss: 0.0563\n", + "iter: 60 loss: 0.0029\n", "iter: 90 loss: 0.0001\n", "iter: 120 loss: 0.0000\n", "iter: 150 loss: 0.0000\n", "\n", - "The trained circuit：\n", + "The trained circuit:\n", "--U----*---------x----U----*---------x----U----*---------x----U----*---------x----U----*---------x--\n", " | | | | | | | | | | \n", "--U----x----*----|----U----x----*----|----U----x----*----|----U----x----*----|----U----x----*----|--\n", @@ -233,41 +226,36 @@ "--U---------x----*----U---------x----*----U---------x----*----U---------x----*----U---------x----*--\n", " \n", "The trained parameter theta:\n", - " [[[ 1.571 3.142 3.927]\n", - " [ 4.713 3.142 2.355]\n", - " [ 5.498 1.574 2.95 ]]\n", + " [[[[ 1.571 -0. 4.776]\n", + " [ 3.141 1.091 1.877]\n", + " [ 1.571 0.785 3.814]]\n", "\n", - " [[ 3.927 6.284 1.571]\n", - " [ 5.498 3.142 4.712]\n", - " [ 5.498 2.961 1.571]]\n", + " [[ 4.712 0. 3.927]\n", + " [ 3.142 3.404 1.833]\n", + " [ 1.57 3.141 6.283]]\n", "\n", - " [[ 4.712 -1.571 6.281]\n", - " [ 6.284 4.77 4.655]\n", - " [ 3.143 1.93 0.359]]\n", + " [[ 0.786 0. 6.283]\n", + " [ 3.142 3.352 1.782]\n", + " [ 1.571 6.283 4.712]]\n", "\n", - " [[ 3.142 2.668 0.917]\n", - " [ 5.403 3.144 5.496]\n", - " [ 3.142 4.319 5.89 ]]\n", + " [[ 6.283 1.919 3.579]\n", + " [ 3.927 5.946 4.712]\n", + " [ 4.712 3.863 1.571]]\n", "\n", - " [[ 1.571 0.881 1.571]\n", - " [ 1.571 6.972 1.571]\n", - " [ 4.712 2.452 1.57 ]]\n", - "\n", - " [[ 4.517 4.301 0.18 ]\n", - " [ 1.329 1.815 1.277]\n", - " [ 1.398 0.87 2.132]]]\n" + " [[ 0. 1.603 5.914]\n", + " [ 3.142 5.805 5.469]\n", + " [ 3.142 -1.259 5.361]]]]\n" ] } ], "source": [ - "# Determine shape of parameter of the network\n", - "net = Net(shape=[D + 1, n, 3])\n", + "cir = qcircuit(n, D)\n", "# Using Adam optimizer to obtain relatively good convergence\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=cir.parameters())\n", "\n", "# Optimization loop\n", "for itr in range(1, ITR + 1):\n", - " loss, cir = net.forward(n, D)\n", + " loss = loss_func(cir, U_0)\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", @@ -275,10 +263,10 @@ " if itr % 30 == 0:\n", " print(\"iter:\", itr, \"loss:\", \"%.4f\" % loss.numpy())\n", " if itr == ITR:\n", - " print(\"\\nThe trained circuit：\")\n", + " print(\"\\nThe trained circuit:\")\n", " print(cir)\n", "\n", - "theta_opt = net.theta.numpy()\n", + "theta_opt = cir.parameters()\n", "print(\"The trained parameter theta:\\n\", np.around(theta_opt, decimals=3))" ] }, @@ -302,7 +290,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "12678dff", "metadata": {}, "outputs": [ @@ -311,25 +299,25 @@ "output_type": "stream", "text": [ "sample 1 :\n", - " trace distance is 0.00054\n", + " trace distance is 0.00041\n", "sample 2 :\n", - " trace distance is 0.00047\n", + " trace distance is 0.0004\n", "sample 3 :\n", - " trace distance is 0.00047\n", + " trace distance is 0.00042\n", "sample 4 :\n", - " trace distance is 0.00046\n", + " trace distance is 0.00045\n", "sample 5 :\n", - " trace distance is 0.0005\n", + " trace distance is 0.00037\n", "sample 6 :\n", - " trace distance is 0.00043\n", + " trace distance is 0.00041\n", "sample 7 :\n", - " trace distance is 0.00054\n", + " trace distance is 0.00042\n", "sample 8 :\n", - " trace distance is 0.00049\n", + " trace distance is 0.00039\n", "sample 9 :\n", - " trace distance is 0.00045\n", + " trace distance is 0.00043\n", "sample 10 :\n", - " trace distance is 0.00045\n" + " trace distance is 0.00041\n" ] } ], @@ -337,11 +325,13 @@ "s = 10 # Set the number of randomly generated density matrices\n", "\n", "for i in range(s):\n", - " sampled = paddle.to_tensor(density_op_random(3).astype('complex128')) # randomly generated density matrix of 3 qubits sampled\n", - " simulated_output = paddle.matmul(paddle.matmul(cir.U, sampled), dagger(cir.U)) # sampled after approximate unitary evolution\n", - " real_output = paddle.matmul(paddle.matmul(paddle.to_tensor(U_0), sampled), dagger(paddle.to_tensor(U_0))) # sampled after target unitary evolution\n", + " paddle_quantum.set_backend('density_matrix') # change to density matrix mode \n", + " sampled = random_state(3) # randomly generated density matrix of 3 qubits sampled\n", + " simulated_output = paddle.matmul(paddle.matmul(cir.unitary_matrix(), sampled.data), dagger(cir.unitary_matrix())) # sampled after approximate unitary evolution\n", + " real_output = paddle.matmul(paddle.matmul(paddle.to_tensor(U_0), sampled.data), dagger(paddle.to_tensor(U_0))) # sampled after target unitary evolution\n", " print('sample', i + 1, ':')\n", - " d = trace_distance(real_output.numpy(), simulated_output.numpy())\n", + " A = simulated_output.numpy() - real_output.numpy()\n", + " d = 1 / 2 * np.sum(np.abs(np.linalg.eigvals(A)))\n", " print(' trace distance is', np.around(d, decimals=5)) # print trace distance\n" ] }, @@ -397,7 +387,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 10, "id": "d6852694", "metadata": {}, "outputs": [], @@ -405,23 +395,23 @@ "n = 3 # Number of qubits\n", "\n", "# Construct the total quantum circuit\n", - "def Circuit(theta, n, D):\n", + "def qcircuit(n, D):\n", " \n", " # Initialize the circuit of 2n qubits \n", - " cir = UAnsatz(2 * n)\n", + " cir = Circuit(2 * n)\n", + " cir.h(list(range(n)))\n", " for i in range(n):\n", - " cir.h(i)\n", " cir.cnot([i, n + i])\n", + "\n", " # Construct the circuit of U\n", - " cir.ccx([0, 1, 2])\n", + " cir.toffoli([0, 1, 2])\n", "\n", " # Construct QNN\n", - " cir.complex_entangled_layer(theta, D, [3, 4, 5])\n", + " cir.complex_entangled_layer([3, 4, 5], n, D)\n", " \n", " for l in range(n):\n", " cir.cnot([n - 1 - l, 2 * n - 1 - l])\n", - " for m in range(n):\n", - " cir.h(m)\n", + " cir.h(list(range(n)))\n", " \n", " return cir" ] @@ -438,31 +428,21 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "id": "7ee10c61", "metadata": {}, "outputs": [], "source": [ - "class Net(paddle.nn.Layer):\n", - " def __init__(self, shape, dtype=\"float64\", ):\n", - " super(Net, self).__init__()\n", - " \n", - " # Initialize the theta parameter list and fill the initial value with the uniform distribution of [0, 2*pi]\n", - " self.D = D\n", - " self.theta = self.create_parameter(shape=[D, n, 3],\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2 * np.pi),\n", - " dtype=dtype, is_bias=False)\n", + "# Define loss function\n", + "def loss_func(self):\n", + " paddle_quantum.set_backend('density_matrix') \n", + " # Output the density matrix rho of the quantum state after the circuit\n", + " init_state = zero_state(2 * n)\n", + " rho = cir(init_state)\n", + " # Define loss function\n", + " loss = 1 - paddle.real(rho.data[0][0])\n", "\n", - " # Define loss function and forward propagation mechanism\n", - " def forward(self): \n", - " # The matrix form of circuit\n", - " cir = Circuit(self.theta, n, self.D)\n", - " # Output the density matrix rho of the quantum state after the circuit\n", - " rho = cir.run_density_matrix()\n", - " # Define loss function\n", - " loss = 1 - paddle.real(rho[0][0])\n", - "\n", - " return loss, cir" + " return loss" ] }, { @@ -477,7 +457,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "id": "280e2858", "metadata": {}, "outputs": [], @@ -499,7 +479,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "id": "77919a34", "metadata": {}, "outputs": [ @@ -507,44 +487,38 @@ "name": "stdout", "output_type": "stream", "text": [ - "iter: 20 loss: 0.1733\n", - "iter: 40 loss: 0.0678\n", - "iter: 60 loss: 0.0236\n", - "iter: 80 loss: 0.0020\n", + "iter: 20 loss: 0.3032\n", + "iter: 40 loss: 0.0080\n", + "iter: 60 loss: 0.0011\n", + "iter: 80 loss: 0.0002\n", "iter: 100 loss: 0.0001\n", "iter: 120 loss: 0.0000\n", "\n", - "The trained circuit：\n", - "Approximate circuit of U with circuit form input：\n", - " --H----*------------------------*-------------------------------------------------------------------------------------------------------------*----H--\n", - " | | | \n", - "-------|----H----*--------------*--------------------------------------------------------------------------------------------------------*----|----H--\n", - " | | | | | \n", - "-------|---------|----H----*----X---------------------------------------------------------------------------------------------------*----|----|----H--\n", - " | | | | | | \n", - "-------x---------|---------|----U----*---------x----U----*---------x----U----*---------x----U----*---------x----U----*---------x----|----|----x-------\n", - " | | | | | | | | | | | | | | \n", - "-----------------x---------|----U----x----*----|----U----x----*----|----U----x----*----|----U----x----*----|----U----x----*----|----|----x------------\n", - " | | | | | | | | | | | | \n", - "---------------------------x----U---------x----*----U---------x----*----U---------x----*----U---------x----*----U---------x----*----x-----------------\n", - " \n" + "The trained circuit:\n", + "Approximate circuit of U with circuit form input:\n", + " --H----*--------------*-------------------------------------------------------------------------------------------------------------*----H--\n", + " | | | \n", + "--H----|----*---------*--------------------------------------------------------------------------------------------------------*----|----H--\n", + " | | | | | \n", + "--H----|----|----*----X---------------------------------------------------------------------------------------------------*----|----|----H--\n", + " | | | | | | \n", + "-------x----|----|----U----*---------x----U----*---------x----U----*---------x----U----*---------x----U----*---------x----|----|----x-------\n", + " | | | | | | | | | | | | | | \n", + "------------x----|----U----x----*----|----U----x----*----|----U----x----*----|----U----x----*----|----U----x----*----|----|----x------------\n", + " | | | | | | | | | | | | \n", + "-----------------x----U---------x----*----U---------x----*----U---------x----*----U---------x----*----U---------x----*----x-----------------\n", + " \n" ] } ], "source": [ - "# Determine the parameter dimension of the network\n", - "net = Net(D)\n", - "\n", + "cir = qcircuit(n, D)\n", "# Use Adam optimizer for better performance\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=cir.parameters())\n", "\n", "# Optimization loop\n", "for itr in range(1, ITR + 1):\n", - " \n", - " # Forward propagation calculates the loss function\n", - " loss, cir= net.forward()\n", - " \n", - " # Use back propagation to minimize the loss function\n", + " loss = loss_func(cir)\n", " loss.backward()\n", " opt.minimize(loss)\n", " opt.clear_grad()\n", @@ -553,19 +527,19 @@ " if itr % 20 == 0:\n", " print(\"iter:\",itr,\"loss:\",\"%.4f\" % loss.numpy())\n", " if itr == ITR:\n", - " print(\"\\nThe trained circuit：\")\n", - " print('Approximate circuit of U with circuit form input：\\n', cir)\n" + " print(\"\\nThe trained circuit:\")\n", + " print('Approximate circuit of U with circuit form input:\\n', cir)\n" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "id": "777ca58e", "metadata": {}, "outputs": [], "source": [ "# Storage optimized parameters\n", - "theta_opt = net.theta.numpy()" + "theta_opt = cir.parameters()[0]" ] }, { @@ -588,7 +562,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "id": "0c339ca3", "metadata": { "scrolled": false @@ -599,46 +573,50 @@ "output_type": "stream", "text": [ "sample 1 :\n", - " trace distance is 0.00694\n", + " trace distance is 0.00245\n", "sample 2 :\n", - " trace distance is 0.00775\n", + " trace distance is 0.00239\n", "sample 3 :\n", - " trace distance is 0.00657\n", + " trace distance is 0.00236\n", "sample 4 :\n", - " trace distance is 0.00727\n", + " trace distance is 0.00222\n", "sample 5 :\n", - " trace distance is 0.00642\n", + " trace distance is 0.00235\n", "sample 6 :\n", - " trace distance is 0.00705\n", + " trace distance is 0.00251\n", "sample 7 :\n", - " trace distance is 0.00586\n", + " trace distance is 0.00241\n", "sample 8 :\n", - " trace distance is 0.00569\n", + " trace distance is 0.00248\n", "sample 9 :\n", - " trace distance is 0.00803\n", + " trace distance is 0.00228\n", "sample 10 :\n", - " trace distance is 0.00635\n" + " trace distance is 0.00242\n" ] } ], "source": [ "s = 10 # Set the number of randomly generated density matrices\n", "for i in range(s):\n", - " sampled = paddle.to_tensor(density_op_random(3).astype('complex128')) # randomly generated density matrix of 4 qubits sampled\n", + " paddle_quantum.set_backend('density_matrix') # change to density matrix mode \n", + " sampled = random_state(3) # randomly generated density matrix of 4 qubits sampled\n", "\n", " # Construct the circuit of target unitary\n", - " cir_1 = UAnsatz(3)\n", - " cir_1.ccx([0, 1, 2])\n", + " cir_1 = Circuit(3)\n", + " cir.toffoli([0, 1, 2])\n", " # sampled after target unitary evolution\n", - " real_output = paddle.matmul(paddle.matmul(cir_1.U, sampled), dagger(cir_1.U))\n", + " real_output = paddle.matmul(paddle.matmul(cir_1.unitary_matrix(), sampled.data), dagger(cir_1.unitary_matrix()))\n", "\n", " # Construct the circuit of approximate unitary\n", - " cir_2 = UAnsatz(3)\n", - " cir_2.complex_entangled_layer(paddle.to_tensor(theta_opt), D, [0, 1, 2])\n", + " cir_2 = Circuit(3)\n", + " for j in range(D):\n", + " cir_2.u3(qubits_idx='full', num_qubits=3, param=theta_opt[j])\n", + " cir_2.cnot(qubits_idx='cycle')\n", " # sampled after approximate unitary evolution\n", - " simulated_output = paddle.matmul(paddle.matmul(cir_2.U, sampled), dagger(cir_2.U))\n", + " simulated_output = paddle.matmul(paddle.matmul(cir_2.unitary_matrix(), sampled.data), dagger(cir_2.unitary_matrix()))\n", "\n", - " d = trace_distance(real_output.numpy(), simulated_output.numpy())\n", + " A = simulated_output.numpy() - real_output.numpy()\n", + " d = 1 / 2 * np.sum(np.abs(np.linalg.eigvals(A)))\n", " print('sample', i + 1, ':')\n", " print(' trace distance is', np.around(d, decimals=5)) # print trace distance" ] @@ -681,8 +659,11 @@ } ], "metadata": { + "interpreter": { + "hash": "f7cfecff1ef1940b21a48efa1b88278bb096bd916f13c2df11af4810c38b47e1" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.0 ('pq')", "language": "python", "name": "python3" }, @@ -696,7 +677,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.0" } }, "nbformat": 4, diff --git a/tutorial/qnn_research/figures/BP-fig-2qubit_landscape.png b/tutorials/qnn_research/figures/BP-fig-2qubit_landscape.png similarity index 100% rename from tutorial/qnn_research/figures/BP-fig-2qubit_landscape.png rename to tutorials/qnn_research/figures/BP-fig-2qubit_landscape.png diff --git a/tutorial/qnn_research/figures/BP-fig-Barren_circuit.png b/tutorials/qnn_research/figures/BP-fig-Barren_circuit.png similarity index 100% rename from tutorial/qnn_research/figures/BP-fig-Barren_circuit.png rename to tutorials/qnn_research/figures/BP-fig-Barren_circuit.png diff --git a/tutorial/qnn_research/figures/BP-fig-barren-cn.png b/tutorials/qnn_research/figures/BP-fig-barren-cn.png similarity index 100% rename from tutorial/qnn_research/figures/BP-fig-barren-cn.png rename to tutorials/qnn_research/figures/BP-fig-barren-cn.png diff --git a/tutorial/qnn_research/figures/BP-fig-barren.png b/tutorials/qnn_research/figures/BP-fig-barren.png similarity index 100% rename from tutorial/qnn_research/figures/BP-fig-barren.png rename to tutorials/qnn_research/figures/BP-fig-barren.png diff --git a/tutorial/qnn_research/figures/BP-fig-landscape2.png b/tutorials/qnn_research/figures/BP-fig-landscape2.png similarity index 100% rename from tutorial/qnn_research/figures/BP-fig-landscape2.png rename to tutorials/qnn_research/figures/BP-fig-landscape2.png diff --git a/tutorial/qnn_research/figures/BP-fig-output_11_2.png b/tutorials/qnn_research/figures/BP-fig-output_11_2.png similarity index 100% rename from tutorial/qnn_research/figures/BP-fig-output_11_2.png rename to tutorials/qnn_research/figures/BP-fig-output_11_2.png diff --git a/tutorial/qnn_research/figures/BP-fig-output_8_0.png b/tutorials/qnn_research/figures/BP-fig-output_8_0.png similarity index 100% rename from tutorial/qnn_research/figures/BP-fig-output_8_0.png rename to tutorials/qnn_research/figures/BP-fig-output_8_0.png diff --git a/tutorial/qnn_research/figures/BP-fig-qubit_landscape.png b/tutorials/qnn_research/figures/BP-fig-qubit_landscape.png similarity index 100% rename from tutorial/qnn_research/figures/BP-fig-qubit_landscape.png rename to tutorials/qnn_research/figures/BP-fig-qubit_landscape.png diff --git a/tutorial/qnn_research/figures/BP-fig-qubit_landscape_compare.png b/tutorials/qnn_research/figures/BP-fig-qubit_landscape_compare.png similarity index 100% rename from tutorial/qnn_research/figures/BP-fig-qubit_landscape_compare.png rename to tutorials/qnn_research/figures/BP-fig-qubit_landscape_compare.png diff --git a/tutorial/qnn_research/figures/FIM-fig-Sphere-metric.png b/tutorials/qnn_research/figures/FIM-fig-Sphere-metric.png similarity index 100% rename from tutorial/qnn_research/figures/FIM-fig-Sphere-metric.png rename to tutorials/qnn_research/figures/FIM-fig-Sphere-metric.png diff --git a/tutorial/qnn_research/figures/expressibility-fig-bloch_y.gif b/tutorials/qnn_research/figures/expressibility-fig-bloch_y.gif similarity index 100% rename from tutorial/qnn_research/figures/expressibility-fig-bloch_y.gif rename to tutorials/qnn_research/figures/expressibility-fig-bloch_y.gif diff --git a/tutorial/qnn_research/figures/expressibility-fig-bloch_yz.gif b/tutorials/qnn_research/figures/expressibility-fig-bloch_yz.gif similarity index 100% rename from tutorial/qnn_research/figures/expressibility-fig-bloch_yz.gif rename to tutorials/qnn_research/figures/expressibility-fig-bloch_yz.gif diff --git a/tutorial/qnn_research/figures/expressibility-fig-bloch_yzy.gif b/tutorials/qnn_research/figures/expressibility-fig-bloch_yzy.gif similarity index 100% rename from tutorial/qnn_research/figures/expressibility-fig-bloch_yzy.gif rename to tutorials/qnn_research/figures/expressibility-fig-bloch_yzy.gif diff --git a/tutorials/qnn_research/figures/vans-fig-blocks.png b/tutorials/qnn_research/figures/vans-fig-blocks.png new file mode 100644 index 0000000..b70fb33 Binary files /dev/null and b/tutorials/qnn_research/figures/vans-fig-blocks.png differ diff --git a/tutorials/qnn_research/figures/vans-fig-rules.png b/tutorials/qnn_research/figures/vans-fig-rules.png new file mode 100644 index 0000000..eb040cb Binary files /dev/null and b/tutorials/qnn_research/figures/vans-fig-rules.png differ diff --git a/tutorial/qnn_research/figures/vqcc-fig-circuit.png b/tutorials/qnn_research/figures/vqcc-fig-circuit.png similarity index 100% rename from tutorial/qnn_research/figures/vqcc-fig-circuit.png rename to tutorials/qnn_research/figures/vqcc-fig-circuit.png diff --git a/tutorial/quantum_simulation/BuildingMolecule_CN.ipynb b/tutorials/quantum_simulation/BuildingMolecule_CN.ipynb similarity index 91% rename from tutorial/quantum_simulation/BuildingMolecule_CN.ipynb rename to tutorials/quantum_simulation/BuildingMolecule_CN.ipynb index ef92543..a1563b8 100644 --- a/tutorial/quantum_simulation/BuildingMolecule_CN.ipynb +++ b/tutorials/quantum_simulation/BuildingMolecule_CN.ipynb @@ -83,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "d354c5dd", "metadata": {}, "outputs": [], @@ -110,18 +110,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "29945676", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Hartree-Fock energy for H2-O1_sto-3g_singlet (10 electrons) is -73.96770387867429.\n" - ] - } - ], + "outputs": [], "source": [ "from paddle_quantum.qchem import get_molecular_data\n", "\n", @@ -159,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "a9a906ad", "metadata": {}, "outputs": [ @@ -167,13 +159,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[-3.2911e+01 5.5623e-01 2.8755e-01 9.7627e-16 -7.4568e-02 -9.4552e-02 2.8670e-01]\n", - " [ 5.5623e-01 -8.0729e+00 -4.0904e-02 4.2578e-16 1.7890e-01 3.5048e-01 -1.3460e+00]\n", - " [ 2.8755e-01 -4.0904e-02 -7.3355e+00 1.1465e-16 4.1911e-01 5.2109e-01 7.0928e-01]\n", - " [ 9.7627e-16 4.2578e-16 1.1465e-16 -7.5108e+00 4.1730e-15 8.3317e-15 -8.4993e-16]\n", - " [-7.4568e-02 1.7890e-01 4.1911e-01 4.1730e-15 -5.7849e+00 2.0887e+00 1.2427e-01]\n", - " [-9.4552e-02 3.5048e-01 5.2109e-01 8.3317e-15 2.0887e+00 -5.0803e+00 1.3967e-02]\n", - " [ 2.8670e-01 -1.3460e+00 7.0928e-01 -8.4993e-16 1.2427e-01 1.3967e-02 -5.0218e+00]]\n" + "[[-3.2911e+01 5.5623e-01 2.8755e-01 1.4640e-15 -7.4568e-02 -9.4552e-02 2.8670e-01]\n", + " [ 5.5623e-01 -8.0729e+00 -4.0904e-02 -1.6823e-15 1.7890e-01 3.5048e-01 -1.3460e+00]\n", + " [ 2.8755e-01 -4.0904e-02 -7.3355e+00 -4.8424e-15 4.1911e-01 5.2109e-01 7.0928e-01]\n", + " [ 1.4640e-15 -1.6823e-15 -4.8424e-15 -7.5108e+00 -1.4127e-14 -2.6576e-14 -1.5008e-15]\n", + " [-7.4568e-02 1.7890e-01 4.1911e-01 -1.4127e-14 -5.7849e+00 2.0887e+00 1.2427e-01]\n", + " [-9.4552e-02 3.5048e-01 5.2109e-01 -2.6576e-14 2.0887e+00 -5.0803e+00 1.3967e-02]\n", + " [ 2.8670e-01 -1.3460e+00 7.0928e-01 -1.5008e-15 1.2427e-01 1.3967e-02 -5.0218e+00]]\n" ] } ], @@ -199,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "069cfcd5", "metadata": {}, "outputs": [], @@ -228,7 +220,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "c136344d", "metadata": {}, "outputs": [ @@ -296,16 +288,16 @@ "text": [ "There are 193 terms in H2O Hamiltonian in total.\n", "The first 10 terms are \n", - " -72.10615980544183 I\n", - "-0.007310917992546845 X0, X1, Y2, Y3\n", - "0.005246087073083395 X0, X1, Y2, Z3, Z4, Y5\n", - "0.0016283548447088131 X0, X1, Y2, Z3, Z4, Z5, Z6, Y7\n", - "0.005246087073083395 X0, X1, X3, X4\n", - "0.0016283548447088131 X0, X1, X3, Z4, Z5, X6\n", - "-0.005994544380559041 X0, X1, Y4, Y5\n", - "0.0013876441781026563 X0, X1, Y4, Z5, Z6, Y7\n", - "0.001387644178102656 X0, X1, X5, X6\n", - "-0.009538223793221256 X0, X1, Y6, Y7\n" + " -72.10615980544185 I\n", + "-0.007310917992546774 X0, X1, Y2, Y3\n", + "0.0052460870730834325 X0, X1, Y2, Z3, Z4, Y5\n", + "0.0016283548447087654 X0, X1, Y2, Z3, Z4, Z5, Z6, Y7\n", + "0.0052460870730834325 X0, X1, X3, X4\n", + "0.0016283548447087654 X0, X1, X3, Z4, Z5, X6\n", + "-0.005994544380559027 X0, X1, Y4, Y5\n", + "0.001387644178102622 X0, X1, Y4, Z5, Z6, Y7\n", + "0.001387644178102622 X0, X1, X5, X6\n", + "-0.009538223793221182 X0, X1, Y6, Y7\n" ] } ], @@ -348,8 +340,11 @@ } ], "metadata": { + "interpreter": { + "hash": "f7cfecff1ef1940b21a48efa1b88278bb096bd916f13c2df11af4810c38b47e1" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.0 ('pq')", "language": "python", "name": "python3" }, diff --git a/tutorial/quantum_simulation/BuildingMolecule_EN.ipynb b/tutorials/quantum_simulation/BuildingMolecule_EN.ipynb similarity index 87% rename from tutorial/quantum_simulation/BuildingMolecule_EN.ipynb rename to tutorials/quantum_simulation/BuildingMolecule_EN.ipynb index 245f91f..5079640 100644 --- a/tutorial/quantum_simulation/BuildingMolecule_EN.ipynb +++ b/tutorials/quantum_simulation/BuildingMolecule_EN.ipynb @@ -2,14 +2,15 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "source": [ "# Building Molecular Hamiltonian\n", "*Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.*" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Overview\n", "\n", @@ -32,11 +33,11 @@ "when we use [atomic units](https://en.wikipedia.org/wiki/Hartree_atomic_units). Our electronic problem contains $N$ electrons and $M$ nucleus. We use $x_i$ to denote position of the $i$-th electron, and use $R_I$ to denote position of the $I$-th nuclei. \n", "\n", "This tutorial will have the following parts. Let's first talk about how to construct a molecule in `qchem`. After that, we will briefly describe how to calculate [Hartree Fock](https://en.wikipedia.org/wiki/Hartree%E2%80%93Fock_method) single particle orbitals by calling external quantum chemistry within Paddle Quantum. Next, we show how we can obtain the Hamiltonian in second quantization representation. Finally, we describe how to transform the Fermionic Hamiltonian to Pauli strings recognized by quantum computer." - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Defining the molecular structure\n", "In this example, we show how to construct water molecule from its chemical formula and coordinates of atoms. \n", @@ -46,54 +47,54 @@ "Within Paddle Quantum, we specify the atom as a list whose first element is the atomic symbol and the second element is another list that contains its Cartesian coordinate. The molecule is thus a bigger list composed of atoms' list.\n", "\n", "**Note: As to the environment setting, please refer to [README.md](https://github.com/PaddlePaddle/Quantum/blob/master/README.md).**" - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 1, + "metadata": {}, + "outputs": [], "source": [ "# Eliminate noisy python warnings\n", "import warnings\n", "\n", "warnings.filterwarnings(\"ignore\")" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 2, + "metadata": {}, + "outputs": [], "source": [ "# in Angstrom\n", "h2o_structure_direct = [[\"H\", [-0.02111417,0.8350417,1.47688078]], # H stands for hydrogen element in water\n", " [\"O\", [0.0, 0.0, 0.0]], # O stands for oxygen element in water\n", " [\"H\", [-0.00201087,0.45191737,-0.27300254]]]" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Instead of specifying molecular structure directly, we can also pass the \\*.xyz file to the `geometry` function to get the same structure." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, + "metadata": {}, + "outputs": [], "source": [ "from paddle_quantum.qchem import geometry\n", "\n", "h2o_structure_xyz = geometry(file=\"h2o.xyz\")\n", "assert h2o_structure_xyz == h2o_structure_direct" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Calculate Hartree Fock orbitals\n", "Hartree Fock method uses the [Slater determinant](https://en.wikipedia.org/wiki/Slater_determinant) to represent the $N$-electron wavefunction. It could provide us with a set of single particle orbitals which are often taken as input to more advanced quantum chemistry methods. \n", @@ -101,12 +102,13 @@ "Paddle Quantum uses psi4 [1] as its quantum chemistry engine. We could use the `get_molecular_data` function provided in `qchem` module to manage the quantum chemistry calculation and get the necessary information about the molecule. `get_molecular_data` function takes molecular structure, total molecular charge, and spin multiplicity as its major inputs, it will return an OpenFermion [2] `MolecularData` object. \n", "\n", "Let's continue with our water molecule example. To run the Hartree Fock calculation, we need to set the `method` keyword argument to *scf* (Self Consistent Field). We can also improve the quality of Hartree Fock calculation by specifying the type of [basis set](https://en.wikipedia.org/wiki/Basis_set_(chemistry)) in the `basis` argument. " - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, + "metadata": {}, + "outputs": [], "source": [ "from paddle_quantum.qchem import get_molecular_data\n", "\n", @@ -125,20 +127,11 @@ "from openfermion.chem import MolecularData\n", "\n", "assert isinstance(h2o_moledata, MolecularData)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "Hartree-Fock energy for H2-O1_sto-3g_singlet (10 electrons) is -73.96770387867429.\n" - ] - } - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Molecular Hamiltonian in second quantization form\n", "When we study many electron quantum systems, it's often convenient to write Hamiltonian at the beginning of this tutorial in [second quantization](https://en.wikipedia.org/wiki/Second_quantization) representation \n", @@ -147,12 +140,27 @@ "\\hat{H}=\\sum_{p,q}h_{pq}\\hat{c}^{\\dagger}_p\\hat{c}_q+\\frac{1}{2}\\sum_{p,q,r,s}v_{pqrs}\\hat{c}^{\\dagger}_p\\hat{c}^{\\dagger}_q\\hat{c}_r\\hat{c}_s,\\tag{3}$$\n", "\n", "where $p$, $q$, $r$ and $s$ are Hartree Fock orbitals computed in the previous section. $\\hat{c}^{\\dagger}_p$ and $\\hat{c}_q$ are creation and annihilation operations, respectively. The two coefficients $h_{pq}$ and $v_{pqrs}$ are called molecular integrals, and can be obtained from `MolecularData` object in the following way." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[-3.2911e+01 5.5623e-01 2.8755e-01 1.4640e-15 -7.4568e-02 -9.4552e-02 2.8670e-01]\n", + " [ 5.5623e-01 -8.0729e+00 -4.0904e-02 -1.6823e-15 1.7890e-01 3.5048e-01 -1.3460e+00]\n", + " [ 2.8755e-01 -4.0904e-02 -7.3355e+00 -4.8424e-15 4.1911e-01 5.2109e-01 7.0928e-01]\n", + " [ 1.4640e-15 -1.6823e-15 -4.8424e-15 -7.5108e+00 -1.4127e-14 -2.6576e-14 -1.5008e-15]\n", + " [-7.4568e-02 1.7890e-01 4.1911e-01 -1.4127e-14 -5.7849e+00 2.0887e+00 1.2427e-01]\n", + " [-9.4552e-02 3.5048e-01 5.2109e-01 -2.6576e-14 2.0887e+00 -5.0803e+00 1.3967e-02]\n", + " [ 2.8670e-01 -1.3460e+00 7.0928e-01 -1.5008e-15 1.2427e-01 1.3967e-02 -5.0218e+00]]\n" + ] + } + ], "source": [ "import numpy as np \n", "np.set_printoptions(precision=4, linewidth=150)\n", @@ -163,34 +171,20 @@ "\n", "print(hpq)\n", "# print(vpqrs)" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "[[-3.2911e+01 5.5623e-01 2.8755e-01 9.7627e-16 -7.4568e-02 -9.4552e-02 2.8670e-01]\n", - " [ 5.5623e-01 -8.0729e+00 -4.0904e-02 4.2578e-16 1.7890e-01 3.5048e-01 -1.3460e+00]\n", - " [ 2.8755e-01 -4.0904e-02 -7.3355e+00 1.1465e-16 4.1911e-01 5.2109e-01 7.0928e-01]\n", - " [ 9.7627e-16 4.2578e-16 1.1465e-16 -7.5108e+00 4.1730e-15 8.3317e-15 -8.4993e-16]\n", - " [-7.4568e-02 1.7890e-01 4.1911e-01 4.1730e-15 -5.7849e+00 2.0887e+00 1.2427e-01]\n", - " [-9.4552e-02 3.5048e-01 5.2109e-01 8.3317e-15 2.0887e+00 -5.0803e+00 1.3967e-02]\n", - " [ 2.8670e-01 -1.3460e+00 7.0928e-01 -8.4993e-16 1.2427e-01 1.3967e-02 -5.0218e+00]]\n" - ] - } - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Most of the time, we don't need to extract those integrals and assemble the Hamiltonian manually, *qchem* module has already helped us take care of this by providing the `fermionic_hamiltonian` function." - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, + "metadata": {}, + "outputs": [], "source": [ "from paddle_quantum.qchem import fermionic_hamiltonian\n", "\n", @@ -204,20 +198,29 @@ "from openfermion.ops import FermionOperator\n", "\n", "assert isinstance(H_of_water, FermionOperator)" - ], - "outputs": [], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "By specifying `active_electrons` and `active_orbitals` keyword arguments, we can reduce the number of freedom of our Hamiltonian and thus reduce the number of terms in the spin Hamiltonian described in the next section. We can also use `active_space` function in *qchem* to return a list of *core* orbitals and *active* orbitals. " - ], - "metadata": {} + ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "List of core orbitals: [0, 1, 2]\n", + "List of active orbitals: [3, 4, 5, 6]\n" + ] + } + ], "source": [ "from paddle_quantum.qchem import active_space\n", "\n", @@ -230,21 +233,11 @@ "\n", "print(\"List of core orbitals: {:}\".format(core_orbits_list))\n", "print(\"List of active orbitals: {:}\".format(act_orbits_list))" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "List of core orbitals: [0, 1, 2]\n", - "List of active orbitals: [3, 4, 5, 6]\n" - ] - } - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## From Fermionic Hamiltonian to spin Hamiltonian\n", "In quantum computing, we only have qubit operators composed of Pauli matrices\n", @@ -266,12 +259,32 @@ "> Alternatively, we also provide Bravyi-Kitaev transformation, by changing the argument, mapping_method, to 'bravyi_kitaev'.\n", "\n", "In *paddle quantum*, Hamiltonian is encoded in *pauli_str*. To avoid tedious manipulation of *string* object, we have provided `spin_hamiltonian` function which can generate the needed *pauli_str* from molecular structure on the fly." - ], - "metadata": {} + ] }, { "cell_type": "code", "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "There are 193 terms in H2O Hamiltonian in total.\n", + "The first 10 terms are \n", + " -72.10615980544185 I\n", + "-0.007310917992546774 X0, X1, Y2, Y3\n", + "0.0052460870730834325 X0, X1, Y2, Z3, Z4, Y5\n", + "0.0016283548447087654 X0, X1, Y2, Z3, Z4, Z5, Z6, Y7\n", + "0.0052460870730834325 X0, X1, X3, X4\n", + "0.0016283548447087654 X0, X1, X3, Z4, Z5, X6\n", + "-0.005994544380559027 X0, X1, Y4, Y5\n", + "0.001387644178102622 X0, X1, Y4, Z5, Z6, Y7\n", + "0.001387644178102622 X0, X1, X5, X6\n", + "-0.009538223793221182 X0, X1, Y6, Y7\n" + ] + } + ], "source": [ "from paddle_quantum.qchem import spin_hamiltonian\n", "\n", @@ -285,38 +298,18 @@ "\n", "print('There are ', pauli_H_of_water_.n_terms, 'terms in H2O Hamiltonian in total.')\n", "print('The first 10 terms are \\n', pauli_H_of_water_[:10])" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "There are 193 terms in H2O Hamiltonian in total.\n", - "The first 10 terms are \n", - " -72.10615980544183 I\n", - "-0.007310917992546845 X0, X1, Y2, Y3\n", - "0.005246087073083395 X0, X1, Y2, Z3, Z4, Y5\n", - "0.0016283548447088131 X0, X1, Y2, Z3, Z4, Z5, Z6, Y7\n", - "0.005246087073083395 X0, X1, X3, X4\n", - "0.0016283548447088131 X0, X1, X3, Z4, Z5, X6\n", - "-0.005994544380559041 X0, X1, Y4, Y5\n", - "0.0013876441781026563 X0, X1, Y4, Z5, Z6, Y7\n", - "0.001387644178102656 X0, X1, X5, X6\n", - "-0.009538223793221256 X0, X1, Y6, Y7\n" - ] - } - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "Great! Now you know how to build a proper Hamiltonian from a given molecular structure, let's move further and see how to use [variational quantum eigensolver](./VQE_EN.ipynb) (VQE) to determine the ground state of hydrogen molecule.\n" - ], - "metadata": {} + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "---\n", "## References\n", @@ -325,16 +318,15 @@ "\n", "[2] [OpenFermion: the electronic structure package for quantum computers\n", "](https://iopscience.iop.org/article/10.1088/2058-9565/ab8ebc)" - ], - "metadata": {} + ] } ], "metadata": { "interpreter": { - "hash": "33c5d9dde9504794a92749aa5ec8a05187e008f4d7e74daf7ce0e98d5c6e004a" + "hash": "f7cfecff1ef1940b21a48efa1b88278bb096bd916f13c2df11af4810c38b47e1" }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.0 ('pq')", "language": "python", "name": "python3" }, @@ -353,4 +345,4 @@ }, "nbformat": 4, "nbformat_minor": 2 -} \ No newline at end of file +} diff --git a/tutorial/quantum_simulation/ClassicalShadow_Application_CN.ipynb b/tutorials/quantum_simulation/ClassicalShadow_Application_CN.ipynb similarity index 72% rename from tutorial/quantum_simulation/ClassicalShadow_Application_CN.ipynb rename to tutorials/quantum_simulation/ClassicalShadow_Application_CN.ipynb index 7da870c..a3f9da9 100644 --- a/tutorial/quantum_simulation/ClassicalShadow_Application_CN.ipynb +++ b/tutorials/quantum_simulation/ClassicalShadow_Application_CN.ipynb @@ -56,15 +56,15 @@ "在量子化学领域，核心任务之一是求解一个量子尺度上封闭物理系统的哈密顿量 $\\hat{H}$ 的基态能量及其对应的基态，主要的实现方法是通过在量子设备上准备一个参数化的试探波函数 $|\\Psi(\\theta)\\rangle$，然后结合经典机器学习中的优化算法（例如梯度下降法）去不断地调整、优化参数 $\\theta$ 使得期望值 $\\langle\\Psi(\\theta)|\\hat{H}| \\Psi(\\theta)\\rangle$ 最小化。这套方案的基本原理是基于 Rayleigh-Ritz 变分原理。\n", "\n", "$$\n", - "E_{0}=\\min _{\\theta}\\langle\\Psi(\\theta)|\\hat{H}| \\Psi(\\theta)\\rangle,\\tag{1}\n", + "E_{0}=\\min _{\\theta}\\langle\\Psi(\\theta)|\\hat{H}| \\Psi(\\theta)\\rangle, \\tag{1}\n", "$$\n", "\n", - "其中 $E_{0}$ 表示该系统的基态能量。从数值分析的角度来看，该问题可以被理解为求解一个离散化哈密顿量 $\\hat{H}$ （埃尔米特矩阵）的最小本征值 $\\lambda_{\\min }$ 和其对应的本征向量 $\\left|\\Psi_{0}\\right\\rangle$ 。经典影子发挥作用的场景就是每一次优化中计算 $\\langle\\Psi(\\theta)|\\hat{H}| \\Psi(\\theta)\\rangle = \\operatorname{tr}(\\hat{H}\\rho )$ 的部分（其中 $ \\rho = | \\Psi(\\theta)\\rangle\\langle\\Psi(\\theta)| $）。\n", + "其中 $E_{0}$ 表示该系统的基态能量。从数值分析的角度来看，该问题可以被理解为求解一个离散化哈密顿量 $\\hat{H}$ （埃尔米特矩阵）的最小本征值 $\\lambda_{\\min }$ 和其对应的本征向量 $\\left|\\Psi_{0}\\right\\rangle$ 。经典影子发挥作用的场景就是每一次优化中计算 $\\langle\\Psi(\\theta)|\\hat{H}| \\Psi(\\theta)\\rangle = \\operatorname{tr}(\\hat{H}\\rho )$ 的部分（其中 $\\rho = | \\Psi(\\theta)\\rangle\\langle\\Psi(\\theta)|$）。\n", "\n", "于是问题转化为：对于一个 $n$ 个量子比特的量子态 $\\rho$ 和一个可写成一组泡利算子$\\{I,X,Y,Z\\}^{\\otimes n}$线性组合的可观测量（哈密顿量）$\\hat{H}$，\n", "\n", "$$\n", - "\\hat{H}=\\sum_{Q \\in\\{I, X, Y, Z\\} ^{\\otimes n}} \\alpha_{Q} Q \\quad \\text{where} \\quad \\alpha_{Q} \\in \\mathbb{R} ,\\tag{2}\n", + "\\hat{H}=\\sum_{Q \\in\\{I, X, Y, Z\\} ^{\\otimes n}} \\alpha_{Q} Q, \\quad \\text{where} \\quad \\alpha_{Q} \\in \\mathbb{R}, \\tag{2}\n", "$$\n", "\n", "如何用经典影子来估计可观测量期望值 $\\operatorname{tr}(\\hat{H}\\rho )$ ？\n", @@ -103,12 +103,12 @@ "id": "e094e752", "metadata": {}, "source": [ - "在量桨中，我们基于经典影子提供了 shadow 功能，主要包含两个函数，支持用户使用上述基于经典影子的三种算法来估计可观测量的期望值，以及获取未知量子态的经典影子数据。下面我们将展示如何基于量桨中的 shadow 功能来实现氢分子（$H_{2}$）和氢化锂（$LiH$）基态能量估计。" + "在量桨中，我们基于经典影子提供了 shadow 功能，主要包含两个函数，支持用户使用上述基于经典影子的三种算法来估计可观测量的期望值，以及获取未知量子态的经典影子数据。下面我们将展示如何基于量桨中的 shadow 功能来实现氢分子（H$_{2}$）和氢化锂（LiH）基态能量估计。" ] }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "efc769b4", "metadata": { "scrolled": false @@ -117,11 +117,13 @@ "source": [ "# 导入需要的包\n", "import numpy as np\n", - "from numpy import pi as PI\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", + "import paddle_quantum as pq\n", + "from paddle_quantum import Hamiltonian\n", "from paddle_quantum.VQE.chemistrysub import H2_generator\n", - "from paddle_quantum.utils import Hamiltonian" + "from paddle_quantum.loss import ExpecVal\n", + "from paddle_quantum.state import zero_state, to_state\n", + "from paddle_quantum.qinfo import shadow_trace" ] }, { @@ -129,7 +131,7 @@ "id": "a58e8871", "metadata": {}, "source": [ - "### 估计氢分子（$H_{2}$）基态能量" + "### 估计氢分子（H$_{2}$）基态能量" ] }, { @@ -137,12 +139,12 @@ "id": "ebda5aeb", "metadata": {}, "source": [ - "导入拥有 4 个量子比特的氢分子（$H_{2}$）的哈密顿量（用户具体可以参考[变分量子本征求解器](./VQE_CN.ipynb) 教程，来获得氢分子（$H_{2}$）哈密顿量）。" + "导入拥有 4 个量子比特的氢分子（H$_{2}$）的哈密顿量（用户具体可以参考[变分量子本征求解器](./VQE_CN.ipynb) 教程，来获得氢分子（H$_{2}$）哈密顿量）。" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "70b8fdef", "metadata": { "scrolled": false @@ -152,7 +154,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "H2 hamiltonian = -0.04207897647782277 I0\n", + "H2 hamiltonian = -0.04207897647782277 I\n", "0.17771287465139946 Z0\n", "0.1777128746513994 Z1\n", "-0.2427428051314046 Z2\n", @@ -183,72 +185,12 @@ "id": "0d6a6532", "metadata": {}, "source": [ - "为了展示如何用基于经典影子的算法来估计基态能量，我们首先通过量桨中的 VQE 来估计氢分子（$H_{2}$）的基态。" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "id": "1bc042c1", - "metadata": {}, - "outputs": [], - "source": [ - "def U_theta(theta, hamiltonian, N, D):\n", - " \"\"\"\n", - " Quantum Neural Network\n", - " \"\"\"\n", - " \n", - " # 按照量子比特数量/网络宽度初始化量子神经网络\n", - " cir = UAnsatz(N)\n", - " \n", - " # 内置的 {R_y + CNOT} 电路模板\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", - " # 量子神经网络作用在默认的初始态 |0000> 上\n", - " cir.run_state_vector()\n", - " \n", - " # 计算给定哈密顿量的期望值\n", - " expectation_val = cir.expecval(hamiltonian)\n", - "\n", - " return expectation_val, cir\n", - "\n", - "class StateNet(paddle.nn.Layer):\n", - " \"\"\"\n", - " Construct the model net\n", - " \"\"\"\n", - "\n", - " def __init__(self, shape, dtype=\"float64\"):\n", - " super(StateNet, self).__init__()\n", - " \n", - " # 初始化 theta 参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # 定义损失函数和前向传播机制\n", - " def forward(self, hamiltonian, N, D):\n", - " \n", - " # 计算损失函数/期望值\n", - " loss, cir = U_theta(self.theta, hamiltonian, N, D)\n", - "\n", - " return loss, cir" - ] - }, - { - "cell_type": "markdown", - "id": "1c53b204", - "metadata": {}, - "source": [ - "在搭建了 VQE 算法的量子神经网络和定义了损失函数后，我们可以通过训练量子神经网络估计氢分子（$H_{2}$）的基态能量，及基态所对应的量子电路，" + "为了展示如何用基于经典影子的算法来估计基态能量，我们首先通过量桨中的 VQE 来估计氢分子（H$_{2}$）的基态，并得到基态所对应的量子电路。" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "40036ae4", "metadata": {}, "outputs": [ @@ -256,23 +198,23 @@ "name": "stdout", "output_type": "stream", "text": [ - "iter: 20 loss: -1.0193\n", - "iter: 20 Ground state energy: -1.0193 Ha\n", - "iter: 40 loss: -1.1227\n", - "iter: 40 Ground state energy: -1.1227 Ha\n", - "iter: 60 loss: -1.1342\n", - "iter: 60 Ground state energy: -1.1342 Ha\n", - "iter: 80 loss: -1.1359\n", - "iter: 80 Ground state energy: -1.1359 Ha\n", + "iter: 20 loss: -1.0562\n", + "iter: 20 estimated ground state energy: -1.0562 Ha\n", + "iter: 40 loss: -1.1200\n", + "iter: 40 estimated ground state energy: -1.1200 Ha\n", + "iter: 60 loss: -1.1344\n", + "iter: 60 estimated ground state energy: -1.1344 Ha\n", + "iter: 80 loss: -1.1360\n", + "iter: 80 estimated ground state energy: -1.1360 Ha\n", "\n", "训练后的电路：\n", - "--Ry(6.288)----*--------------x----Ry(0.019)----*--------------x----Ry(3.133)--\n", + "--Ry(6.286)----*--------------x----Ry(-0.00)----*--------------x----Ry(3.159)--\n", " | | | | \n", - "--Ry(3.143)----x----*---------|----Ry(3.337)----x----*---------|----Ry(3.139)--\n", + "--Ry(6.277)----x----*---------|----Ry(-0.21)----x----*---------|----Ry(6.269)--\n", " | | | | \n", - "--Ry(6.278)---------x----*----|----Ry(6.287)---------x----*----|----Ry(3.140)--\n", + "--Ry(3.137)---------x----*----|----Ry(6.286)---------x----*----|----Ry(6.272)--\n", " | | | | \n", - "--Ry(3.147)--------------x----*----Ry(3.130)--------------x----*----Ry(6.277)--\n", + "--Ry(6.277)--------------x----*----Ry(6.290)--------------x----*----Ry(3.145)--\n", " \n" ] } @@ -281,14 +223,22 @@ "ITR = 80 # 设置训练的总迭代次数\n", "LR = 0.4 # 设置学习速率\n", "D = 2 # 设置量子神经网络中重复计算模块的深度 Depth\n", - "N = H2_hamiltonian.n_qubits \n", + "N = H2_hamiltonian.n_qubits # 获取量子比特数\n", + "\n", + "paddle.seed(42)\n", + "# 初始化待训练的量子电路\n", + "cir_H_2 = pq.ansatz.Circuit(N)\n", + "cir_H_2.real_entangled_layer(depth=D)\n", + "cir_H_2.ry()\n", + "\n", + "# 定义初始态\n", + "init_state = zero_state(N)\n", "\n", - "# 确定网络的参数维度\n", - "net = StateNet(shape=[D + 1, N, 1])\n", + "# 定义损失函数\n", + "loss_func = ExpecVal(H2_hamiltonian)\n", "\n", - "# 一般来说，我们利用 Adam 优化器来获得相对好的收敛，\n", - "# 当然你可以改成 SGD 或者是 RMS prop.\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "# 一般来说，我们利用Adam优化器来获得相对好的收敛，\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=cir_H_2.parameters())\n", "\n", "# 记录优化结果\n", "summary_iter, summary_loss = [], []\n", @@ -297,7 +247,8 @@ "for itr in range(1, ITR + 1):\n", "\n", " # 前向传播计算损失函数\n", - " loss, cir = net(H2_hamiltonian, N, D)\n", + " state = cir_H_2(init_state)\n", + " loss = loss_func(state)\n", "\n", " # 反向传播极小化损失函数\n", " loss.backward()\n", @@ -311,11 +262,11 @@ " # 打印结果\n", " if itr % 20 == 0:\n", " print(\"iter:\", itr, \"loss:\", \"%.4f\" % loss.numpy())\n", - " print(\"iter:\", itr, \"Ground state energy:\", \"%.4f Ha\" \n", + " print(\"iter:\", itr, \"estimated ground state energy:\", \"%.4f Ha\" \n", " % loss.numpy())\n", " if itr == ITR:\n", " print(\"\\n训练后的电路：\") \n", - " print(cir)" + " print(cir_H_2)" ] }, { @@ -331,13 +282,13 @@ "id": "c9891733", "metadata": {}, "source": [ - "此时，我们获得了生成氢分子（$H_{2}$）的基态所对应的量子电路。在此电路上，我们可以直接运行 `shadow_trace` 函数，来获得使用经典影子算法估计得到的基态能量。\n", + "此时，我们获得了生成氢分子（H$_{2}$）的基态所对应的量子电路。在此电路上，我们可以直接运行 `shadow_trace` 函数，来获得使用经典影子算法估计得到的基态能量。\n", "在 `shadow_trace` 函数中，我们的输入为需要估计的哈密顿量、采样次数、以及所选择使用的采样算法。用户可以通过指定 `method` 参数来选择想要使用的采样算法。其中 CS 的适用范围更广，速度最快，但是其估计精度可能稍差；LBCS 的精度更高，但在哈密顿量的项数较高时运行偏慢；APS 的精度也会更高，但是量子比特数目较大时运行偏慢。 " ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "3b31e57d", "metadata": {}, "outputs": [ @@ -345,23 +296,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "H2 ground state energy = -1.135877449718475\n", - "H2 ground state energy CS= -1.161406335762599\n", - "H2 ground state energy LBCS= -1.113975649597432\n", - "H2 ground state energy APS= -1.1028385525105113\n" + "H2 ground state energy = -1.1359991\n", + "H2 ground state energy CS= -1.1532653284115573\n", + "H2 ground state energy LBCS= -1.1219509441210997\n", + "H2 ground state energy APS= -1.18267941594884\n" ] } ], "source": [ "# 估计出的基态对应的实际能量值\n", - "H2_energy = cir.expecval(H2_hamiltonian).numpy()[0]\n", - "\n", + "H2_energy = loss_func(cir_H_2()).numpy()[0]\n", "# 采样次数\n", "sample = 1500 \n", "# 分别采用三种算法估计可观测量期望值，即基态能量\n", - "H2_energy_CS = cir.shadow_trace(H2_hamiltonian, sample, method=\"CS\")\n", - "H2_energy_LBCS = cir.shadow_trace(H2_hamiltonian, sample, method=\"LBCS\")\n", - "H2_energy_APS = cir.shadow_trace(H2_hamiltonian, sample, method=\"APS\")\n", + "H2_energy_CS = shadow_trace(cir_H_2(), H2_hamiltonian, sample, method=\"CS\")\n", + "H2_energy_LBCS = shadow_trace(cir_H_2(), H2_hamiltonian, sample, method=\"LBCS\")\n", + "H2_energy_APS = shadow_trace(cir_H_2(), H2_hamiltonian, sample, method=\"APS\")\n", "\n", "print('H2 ground state energy = ', H2_energy)\n", "print('H2 ground state energy CS= ', H2_energy_CS)\n", @@ -374,12 +324,18 @@ "id": "1cb856da", "metadata": {}, "source": [ - "现在让我们采用对哈密顿量逐项测量的传统方法来估计氢分子（$H_{2}$）的基态能量，" + "现在让我们采用对哈密顿量逐项测量的传统方法来估计氢分子（H$_{2}$）的基态能量，" ] }, + { + "cell_type": "markdown", + "id": "28af249f", + "metadata": {}, + "source": [] + }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "id": "3ae0242c", "metadata": {}, "outputs": [ @@ -387,13 +343,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "H2 ground state energy traditional = -1.1376572756490493\n" + "H2 ground state energy traditional = -1.13771533304257\n" ] } ], "source": [ "# 使用哈密顿量逐项测量方法来估计基态能量\n", - "H2_energy_traditional = cir.expecval(H2_hamiltonian, shots=100).numpy()[0]\n", + "H2_energy_traditional = cir_H_2().expec_val(H2_hamiltonian, shots=100)\n", "print('H2 ground state energy traditional = ', H2_energy_traditional)" ] }, @@ -402,7 +358,7 @@ "id": "b2e1ad02", "metadata": {}, "source": [ - "我们可以看到在 1500 次采样下，三种算法估计的基态能量与 VQE 算法估计出的基态的实际能量已经十分接近，而逐项测量的方法是针对哈密顿量中的每一项各进行 100 次测量，氢分子（$H_{2}$）哈密顿量有15项，相当于测量了 1500 次，得到的结果与 VQE 算法估计出的基态的实际能量的差距也较小。在这种小规模的情况，基于经典影子的算法与逐项测量的方法比并没有体现出明显的优势，但在大规模量子系统场景下，该类算法需要的采样次数仅仅是关于哈密顿量项数的常数级别的增长，逐项测量或已有的一些方法则需要关于哈密顿量项数呈多项式甚至指数级别增长的采样次数，来达到同样精度 [1]。事实上，[2] 中指出对于 CS 算法以及 LBCS 算法，我们得到的估计的平均误差 $\\epsilon$，方差 $\\operatorname{var}(\\nu)$ 以及采样次数 $S$ 有如下关系关系：\n", + "我们可以看到在 1500 次采样下，三种算法估计的基态能量与 VQE 算法估计出的基态的实际能量已经十分接近，而逐项测量的方法是针对哈密顿量中的每一项各进行 100 次测量，氢分子（H_$2$）哈密顿量有 15 项，相当于测量了 1500 次，得到的结果与 VQE 算法估计出的基态的实际能量的差距也较小。在这种小规模的情况，基于经典影子的算法与逐项测量的方法比并没有体现出明显的优势，但在大规模量子系统场景下，该类算法需要的采样次数仅仅是关于哈密顿量项数的常数级别的增长，逐项测量或已有的一些方法则需要关于哈密顿量项数呈多项式甚至指数级别增长的采样次数，来达到同样精度 [1]。事实上，[2] 中指出对于 CS 算法以及 LBCS 算法，我们得到的估计的平均误差 $\\epsilon$，方差 $\\operatorname{var}(\\nu)$ 以及采样次数 $S$ 有如下关系关系：\n", "\n", "$$\n", "S = O(\\epsilon^{-2} \\operatorname{var}(\\nu) ), \\tag{3}\n", @@ -427,7 +383,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "fc6b465c", "metadata": {}, "outputs": [ @@ -435,7 +391,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[('yyxz', '1100'), ('xyxz', '1110'), ('zyyy', '1111'), ('zzxy', '1110'), ('xxyx', '1110'), ('zzyz', '1100'), ('yzyx', '0101'), ('yxxy', '0001'), ('zyzx', '1101'), ('xyyy', '1011')]\n" + "[('zyzx', '1001'), ('xyzx', '0100'), ('yxyx', '1100'), ('yxzx', '0001'), ('zxxx', '1010'), ('xxyx', '0000'), ('zyxy', '1011'), ('xxzz', '0100'), ('xxzz', '1100'), ('yxzx', '0100')]\n" ] } ], @@ -443,9 +399,9 @@ "from paddle_quantum.shadow import shadow_sample\n", "\n", "# 在态矢量模式下运行电路，获得当前电路输出态\n", - "H2_rho = np.array(cir.run_state_vector())\n", + "H2_rho = to_state(cir_H_2().data)\n", "# 获得经典影子的数据，输出成 list 的形式\n", - "H2_sample_data_CS = shadow_sample(H2_rho, H2_qubit, sample_shots=10, mode='state_vector', \n", + "H2_sample_data_CS = shadow_sample(H2_rho, H2_qubit, sample_shots=10, mode='density_matrix', \n", " hamiltonian=H2_hamiltonian, method='CS')\n", "print(H2_sample_data_CS)" ] @@ -455,7 +411,7 @@ "id": "e74ffd18", "metadata": {}, "source": [ - "### 估计氢化锂（$LiH$）基态能量" + "### 估计氢化锂（LiH）基态能量" ] }, { @@ -463,12 +419,12 @@ "id": "e4480cb6", "metadata": {}, "source": [ - "接下来考虑氢化锂（$LiH$）的基态能量，这里我们直接读取预先计算好的文件，以此来生成具有 12 个量子比特的氢化锂（$LiH$）的泡利形式的分子哈密顿量。" + "接下来考虑氢化锂（LiH）的基态能量，这里我们直接读取预先计算好的文件，以此来生成具有 12 个量子比特的氢化锂（LiH）的泡利形式的分子哈密顿量。" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "6916c8a4", "metadata": {}, "outputs": [], @@ -485,12 +441,12 @@ "id": "61d8fd59", "metadata": {}, "source": [ - "接下来，我们同样可以通过运行 VQE 电路估计其分子哈密顿量的基态。这里，由于该分子哈密顿量较大，VQE 所需要的训练时间较长，我们直接提供了已经训练后的 VQE 电路的参数，用户可以通过它直接获得估计的 $LiH$ 的基态并在其上测试基于经典影子的方法。" + "接下来，我们同样可以通过运行 VQE 电路估计其分子哈密顿量的基态。这里，由于该分子哈密顿量较大，VQE 所需要的训练时间较长，我们直接提供了已经训练后的 VQE 电路的参数，用户可以通过它直接获得估计的 LiH 的基态并在其上测试基于经典影子的方法。" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "fe326409", "metadata": {}, "outputs": [ @@ -506,9 +462,19 @@ "# 读取事先训练好的参数\n", "pretrained_parameters = paddle.load('LiH_VQE_parameters.pdtensor')\n", "N = LiH_hamiltonian.n_qubits\n", - "# 根据该参数运行 VQE 电路\n", - "energy, cir = U_theta(pretrained_parameters, LiH_hamiltonian, N, D)\n", - "print('预训练 VQE 得到的基态能量为：%.4f ' % energy.numpy())" + "\n", + "# 按照量子比特数量/网络宽度初始化量子神经网络\n", + "cir_LiH = pq.ansatz.Circuit(N)\n", + "\n", + "# 内置的 {R_y + CNOT} 电路模板\n", + "cir_LiH.real_entangled_layer(depth=D)\n", + "cir_LiH.ry()\n", + "cir_LiH.update_param(pretrained_parameters)\n", + "\n", + "# 计算哈密顿量为 LiH 时的期望值\n", + "expec_val_LiH = cir_LiH().expec_val(LiH_hamiltonian, shots=0)\n", + "\n", + "print('预训练 VQE 得到的基态能量为：%.4f ' % expec_val_LiH)" ] }, { @@ -516,14 +482,14 @@ "id": "8f8ff501", "metadata": {}, "source": [ - "得到了估计的氢化锂分子（$LiH$）基态所对应的电路后，我们直接使用 `shadow_trace` 函数进行随机测量即可。同时，由于该分子哈密顿量有 631 项，为了保证两类方法测量次数一致，我们规定函数 `shadow_trace` 的 `sample = 1262`，函数 `expecval` 的 `shots = 2`。\n", + "得到了估计的氢化锂分子（LiH）基态所对应的电路后，我们直接使用 `shadow_trace` 函数进行随机测量即可。同时，由于该分子哈密顿量有 631 项，为了保证两类方法测量次数一致，我们规定函数 `shadow_trace` 的 `sample = 1262`，函数 `expecval` 的 `shots = 2`。\n", "\n", - "又因为 $LiH$ 基态的量子比特数为 12，所以对 $LiH$ 的基态做不同的泡利测量时，共有 $3^{12}$ 种可能的测量组合，那么仅仅进行 1262 次采样从而得到估值，具有随机性。于是，我们分别运行 20 次上述四种方法，取这 20 个样本数据的均值作为做为各个算法的估计值，并计算样本方差，对算法进行简单的比较。（运行下述代码块需要的时间可能较长，通常至少需要 1 个小时）" + "又因为 LiH 基态的量子比特数为 12，所以对 LiH 的基态做不同的泡利测量时，共有 $3^{12}$ 种可能的测量组合，那么仅仅进行 1262 次采样从而得到估值，具有随机性。于是，我们分别运行 20 次上述四种方法，取这 20 个样本数据的均值作为做为各个算法的估计值，并计算样本方差，对算法进行简单的比较。（运行下述代码块需要的时间可能较长，通常需要 20 分钟左右）" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 16, "id": "8f3684ce", "metadata": {}, "outputs": [ @@ -531,12 +497,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "LiH ground state energy = -7.771980394176657\n", - "ave LiH ground state energy CS = -7.835791570579005\n", - "ave LiH ground state energy LBCS = -7.7622296662623445\n", - "ave LiH ground state energy APS = -7.762836542787509\n", - "ave LiH ground state energy traditional = -7.8964746269601465\n", - "time = 4206.216086864471\n" + "LiH ground state energy = -7.77198\n", + "ave LiH ground state energy CS = -7.850611450035954\n", + "ave LiH ground state energy LBCS = -7.793319461201525\n", + "ave LiH ground state energy APS = -7.774484195247901\n", + "ave LiH ground state energy traditional = -7.622710303123105\n", + "time = 1003.3228180408478\n" ] } ], @@ -550,16 +516,17 @@ "estimator_traditional = []\n", "\n", "# 估计出的基态对应的实际能量值\n", - "LiH_energy = cir.expecval(LiH_hamiltonian).numpy()[0]\n", + "LiH_energy = cir_LiH().expec_val(LiH_hamiltonian, shots=0)\n", "\n", "# 运行算法次数\n", "n = 20 \n", "\n", "for i in range(n):\n", - " LiH_energy_CS = cir.shadow_trace(LiH_hamiltonian, 1262, method=\"CS\")\n", - " LiH_energy_LBCS = cir.shadow_trace(LiH_hamiltonian, 1262, method=\"LBCS\")\n", - " LiH_energy_APS = cir.shadow_trace(LiH_hamiltonian, 1262, method=\"APS\")\n", - " LiH_energy_traditional = cir.expecval(LiH_hamiltonian, shots=2).numpy()[0]\n", + " \n", + " LiH_energy_CS = shadow_trace(cir_LiH(), LiH_hamiltonian, 1262, method=\"CS\")\n", + " LiH_energy_LBCS = shadow_trace(cir_LiH(), LiH_hamiltonian, 1262, method=\"LBCS\")\n", + " LiH_energy_APS = shadow_trace(cir_LiH(), LiH_hamiltonian, 1262, method=\"APS\")\n", + " LiH_energy_traditional = cir_LiH().expec_val(LiH_hamiltonian, shots=2)\n", "\n", " estimator_CS.append(LiH_energy_CS) \n", " estimator_LBCS.append(LiH_energy_LBCS) \n", @@ -572,7 +539,7 @@ "ave_LiH_energy_traditional = np.mean(estimator_traditional)\n", "end = time.time() \n", "\n", - "print(\"LiH ground state energy = \", LiH_energy)\n", + "print(\"LiH ground state energy = \", LiH_energy.numpy()[0])\n", "print(\"ave LiH ground state energy CS = \", ave_LiH_energy_CS)\n", "print(\"ave LiH ground state energy LBCS = \", ave_LiH_energy_LBCS)\n", "print(\"ave LiH ground state energy APS = \", ave_LiH_energy_APS)\n", @@ -585,12 +552,12 @@ "id": "89469273", "metadata": {}, "source": [ - "从结果来看，基于经典影子算法得到的均值比逐项测量的更接近 VQE 算法估计出的 $LiH$ 基态的实际能量，且算法的误差均在文献 [3] 理论估计的精度之内。那么各算法的样本方差又是怎样的呢？" + "从结果来看，基于经典影子算法得到的均值比逐项测量的更接近 VQE 算法估计出的 LiH 基态的实际能量，且算法的误差均在文献 [3] 理论估计的精度之内。那么各算法的样本方差又是怎样的呢？" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 17, "id": "742f4f15", "metadata": {}, "outputs": [ @@ -598,16 +565,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "LiH variance CS = 0.034596840359755784\n", - "LiH variance LBCS = 0.016602696085670984\n", - "LiH variance APS = 0.0016603026356630662\n", - "LiH variance traditional = 0.13200055652163223\n" + "LiH variance CS = 0.20268237699326175\n", + "LiH variance LBCS = 0.016956271213630907\n", + "LiH variance APS = 0.0028097294191431854\n", + "LiH variance traditional = 0.11731067295981745\n" ] } ], "source": [ "# 计算样本方差\n", - "\n", "variance_CS = []\n", "variance_LBCS = []\n", "variance_APS = []\n", @@ -635,7 +601,7 @@ "id": "d40ef806", "metadata": {}, "source": [ - "可以看到，APS 算法的样本方差是最低的，其次是 LBCS 算法，接着是 CS 算法，最后是逐项测量的方法。据此，我们可以发现哈密顿量的项数规模增大后，基于经典影子的算法与逐项测量的方法相比，在同等代价下精度更高，且更加稳定。其中 APS 算法是最稳定的。\n", + "可以看到，APS 算法的样本方差是最低的，其次是 LBCS 算法，接着是逐项测量的方法，最后是 CS 算法。据此，我们可以发现哈密顿量的项数规模增大后，基于经典影子的算法与逐项测量的方法相比，在同等代价下精度更高，且更加稳定。其中 APS 算法是最稳定的。\n", "\n", "值得一提的是，对于经典影子算法来说 12 个量子比特的场景仍不能较好地展现出其与现有一些算法相比的巨大优势。在具有更多量子比特的大规模系统中，其在算法代价上的优势才能更好地被展现 [1]。" ] @@ -680,8 +646,11 @@ } ], "metadata": { + "interpreter": { + "hash": "4261e4eef114648d37e4a637967bd8d2966507f48b194e5e336ba3366b740269" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.13 ('pq-ns-icode')", "language": "python", "name": "python3" }, @@ -695,7 +664,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.11" + "version": "3.8.13" } }, "nbformat": 4, diff --git a/tutorial/quantum_simulation/ClassicalShadow_Application_EN.ipynb b/tutorials/quantum_simulation/ClassicalShadow_Application_EN.ipynb similarity index 69% rename from tutorial/quantum_simulation/ClassicalShadow_Application_EN.ipynb rename to tutorials/quantum_simulation/ClassicalShadow_Application_EN.ipynb index 9102279..623f467 100644 --- a/tutorial/quantum_simulation/ClassicalShadow_Application_EN.ipynb +++ b/tutorials/quantum_simulation/ClassicalShadow_Application_EN.ipynb @@ -56,7 +56,7 @@ "In the field of quantum chemistry, one of the core tasks is to solve for ground state energy of the Hamiltonian $\\hat{H}$ on a closed physical system on a quantum scale and its corresponding ground state. The main method is to prepare a parameterized trial wave function $|\\Psi(\\theta)\\rangle$. Then, the parameter $\\theta$ is being continuously adjusted and optimized to minimize the expected value $\\langle\\Psi(\\theta)|\\hat{H}| \\Psi(\\theta)\\rangle$ using classical optimization algorithms (such as gradient descent method). The principle of this scheme is based on Rayleigh-Ritz variational principle,\n", "\n", "$$\n", - "E_{0}=\\min _{\\theta}\\langle\\Psi(\\theta)|\\hat{H}| \\Psi(\\theta)\\rangle \\tag{1}\n", + "E_{0}=\\min _{\\theta}\\langle\\Psi(\\theta)|\\hat{H}| \\Psi(\\theta)\\rangle, \\tag{1}\n", "$$\n", "\n", "where $E_{0}$ represents the ground state energy of the system. Numerically, the problem can be understood as solving for the minimum eigenvalue $\\lambda_{\\min }$ of a discretized Hamiltonian $\\hat{H}$ (Hermitian matrix) and its corresponding eigenvector $\\left|\\Psi_{0}\\right\\rangle$. Where the classical shadow comes into play is to calculate the $\\langle\\Psi(\\theta)|\\hat{H}| \\Psi(\\theta)\\rangle = \\operatorname{tr}(\\hat{H}\\rho )$ part in every optimization iteration where $ \\rho = | \\Psi(\\theta)\\rangle\\langle\\Psi(\\theta)|$.\n", @@ -64,7 +64,7 @@ "The problem is then transformed into: for a quantum state $\\rho$ of $n$ qubits and an observable (Hamiltonian) $\\hat{H}$ that can be written as a linear combination of a set of Pauli operators $\\{I, X, Y, Z\\}^{\\otimes n}$,\n", "\n", "$$\n", - "\\hat{H}=\\sum_{Q \\in\\{I, X, Y, Z\\} ^{\\otimes n}} \\alpha_{Q} Q \\quad \\text{where} \\quad \\alpha_{Q} \\in \\mathbb{R}, \\tag{2}\n", + "\\hat{H}=\\sum_{Q \\in\\{I, X, Y, Z\\} ^{\\otimes n}} \\alpha_{Q} Q, \\quad \\text{where} \\quad \\alpha_{Q} \\in \\mathbb{R}, \\tag{2}\n", "$$\n", "\n", "how to estimate the observable's expectation value $\\operatorname{tr}(\\hat{H}\\rho )$ using the classical shadow?\n", @@ -104,12 +104,12 @@ "id": "e094e752", "metadata": {}, "source": [ - "In Paddle Quantum, we provide the shadow function, which mainly includes two parts to use the above three algorithms to estimate the expectation value of the observable and obtain the classical shadow data of unknown quantum states. Next, we will show how to implement finding the ground state energy estimation of $H_{2}$ and $LiH$ based on the shadow function in Paddle Quantum." + "In Paddle Quantum, we provide the shadow function, which mainly includes two parts to use the above three algorithms to estimate the expectation value of the observable and obtain the classical shadow data of unknown quantum states. Next, we will show how to implement finding the ground state energy estimation of H$_2$ and LiH based on the shadow function in Paddle Quantum." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "efc769b4", "metadata": { "scrolled": false @@ -118,11 +118,13 @@ "source": [ "# Import all the dependencies\n", "import numpy as np\n", - "from numpy import pi as PI\n", "import paddle\n", - "from paddle_quantum.circuit import UAnsatz\n", + "import paddle_quantum as pq\n", + "from paddle_quantum import Hamiltonian\n", "from paddle_quantum.VQE.chemistrysub import H2_generator\n", - "from paddle_quantum.utils import Hamiltonian" + "from paddle_quantum.loss import ExpecVal\n", + "from paddle_quantum.state import zero_state, to_state\n", + "from paddle_quantum.qinfo import shadow_trace" ] }, { @@ -130,7 +132,7 @@ "id": "a58e8871", "metadata": {}, "source": [ - "### Estimate the ground state energy of hydrogen molecule ($H_{ 2}$)" + "### Estimate the ground state energy of hydrogen molecule (H$_{ 2}$)" ] }, { @@ -138,12 +140,12 @@ "id": "ebda5aeb", "metadata": {}, "source": [ - "Import the Hamiltonian of $H_2$ with 4 qubits (for details, please refer to [Variational Quantum Eigensolver](./VQE_CN.ipynb) tutorial to obtain $H_2$ molecular Hamiltonian)." + "Import the Hamiltonian of H$_2$ with 4 qubits (for details, please refer to [Variational Quantum Eigensolver](./VQE_EN.ipynb) tutorial to obtain H$_2$ molecular Hamiltonian)." ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "70b8fdef", "metadata": { "scrolled": false @@ -153,7 +155,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "H2 hamiltonian = -0.04207897647782277 I0\n", + "H2 hamiltonian = -0.04207897647782277 I\n", "0.17771287465139946 Z0\n", "0.1777128746513994 Z1\n", "-0.2427428051314046 Z2\n", @@ -184,96 +186,36 @@ "id": "0d6a6532", "metadata": {}, "source": [ - "To show how to estimate the ground state energy using the classical-shadow-based algorithm, we first get the estimated ground state of $H_{2}$ using the VQE algorithm in Paddle Quantum." + "To show how to estimate the ground state energy using the classical-shadow-based algorithm, we first get the estimated ground state of H$_2$ and the quantum circuit corresponding to the ground state using the VQE algorithm in Paddle Quantum. " ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "1bc042c1", "metadata": {}, - "outputs": [], - "source": [ - "def U_theta(theta, hamiltonian, N, D):\n", - " \"\"\"\n", - " Quantum Neural Network\n", - " \"\"\"\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", - " 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 |0000>\n", - " cir.run_state_vector()\n", - " \n", - " # Calculate the expected value of a given Hamiltonian\n", - " expectation_val = cir.expecval(hamiltonian)\n", - "\n", - " return expectation_val, cir\n", - "\n", - "class StateNet(paddle.nn.Layer):\n", - " \"\"\"\n", - " Construct the model net\n", - " \"\"\"\n", - "\n", - " def __init__(self, shape, dtype=\"float64\"):\n", - " super(StateNet, self).__init__()\n", - " \n", - " # Assign the theta parameter list to be the trainable parameter list of the circuit\n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # Define loss function and forward propagation mechanism\n", - " def forward(self, hamiltonian, N, D):\n", - " \n", - " # Calculate the loss function/expected value\n", - " loss, cir = U_theta(self.theta, hamiltonian, N, D)\n", - "\n", - " return loss, cir" - ] - }, - { - "cell_type": "markdown", - "id": "1c53b204", - "metadata": {}, - "source": [ - "After building the quantum neural network of the VQE algorithm and defining the loss function, we can estimate the ground state energy of $H_{2}$ and the quantum circuit corresponding to the ground state by training the quantum neural network." - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "id": "40036ae4", - "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "iter: 20 loss: -1.0865\n", - "iter: 20 Ground state energy: -1.0865 Ha\n", - "iter: 40 loss: -1.1284\n", - "iter: 40 Ground state energy: -1.1284 Ha\n", - "iter: 60 loss: -1.1355\n", - "iter: 60 Ground state energy: -1.1355 Ha\n", + "iter: 20 loss: -1.0562\n", + "iter: 20 estimated ground state energy: -1.0562 Ha\n", + "iter: 40 loss: -1.1200\n", + "iter: 40 estimated ground state energy: -1.1200 Ha\n", + "iter: 60 loss: -1.1344\n", + "iter: 60 estimated ground state energy: -1.1344 Ha\n", "iter: 80 loss: -1.1360\n", - "iter: 80 Ground state energy: -1.1360 Ha\n", + "iter: 80 estimated ground state energy: -1.1360 Ha\n", "\n", - "The trained circuit:\n", - "--Ry(-1.57)----*--------------x----Ry(4.713)----*--------------x----Ry(3.129)--\n", + "The trained circuit：\n", + "--Ry(6.286)----*--------------x----Ry(-0.00)----*--------------x----Ry(3.159)--\n", " | | | | \n", - "--Ry(5.091)----x----*---------|----Ry(1.768)----x----*---------|----Ry(3.711)--\n", + "--Ry(6.277)----x----*---------|----Ry(-0.21)----x----*---------|----Ry(6.269)--\n", " | | | | \n", - "--Ry(0.997)---------x----*----|----Ry(4.696)---------x----*----|----Ry(3.180)--\n", + "--Ry(3.137)---------x----*----|----Ry(6.286)---------x----*----|----Ry(6.272)--\n", " | | | | \n", - "--Ry(4.753)--------------x----*----Ry(4.701)--------------x----*----Ry(-0.37)--\n", + "--Ry(6.277)--------------x----*----Ry(6.290)--------------x----*----Ry(3.145)--\n", " \n" ] } @@ -281,15 +223,23 @@ "source": [ "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 = H2_hamiltonian.n_qubits \n", + "D = 2 # Set the depth of the repetitive calculation module in QNN\n", + "N = H2_hamiltonian.n_qubits # number of qubits\n", "\n", - "# Determine the parameter dimension of the network\n", - "net = StateNet(shape=[D + 1, N, 1])\n", + "paddle.seed(42)\n", + "# Initialization of quantum circuit\n", + "cir_H_2 = pq.ansatz.Circuit(N)\n", + "cir_H_2.real_entangled_layer(depth=D)\n", + "cir_H_2.ry()\n", + "\n", + "# Set initial state\n", + "init_state = zero_state(N)\n", + "\n", + "# Define the loss function\n", + "loss_func = ExpecVal(H2_hamiltonian)\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", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=cir_H_2.parameters())\n", "\n", "# Record optimization results\n", "summary_iter, summary_loss = [], []\n", @@ -298,7 +248,8 @@ "for itr in range(1, ITR + 1):\n", "\n", " # Forward propagation to calculate loss function\n", - " loss, cir = net(H2_hamiltonian, N, D)\n", + " state = cir_H_2(init_state)\n", + " loss = loss_func(state)\n", "\n", " # Use back propagation to minimize the loss function\n", " loss.backward()\n", @@ -312,11 +263,11 @@ " # 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", + " print(\"iter:\", itr, \"estimated ground state energy:\", \"%.4f Ha\" \n", " % loss.numpy())\n", " if itr == ITR:\n", - " print(\"\\nThe trained circuit:\") \n", - " print(cir)" + " print(\"\\nThe trained circuit：\") \n", + " print(cir_H_2)" ] }, { @@ -332,12 +283,12 @@ "id": "c9891733", "metadata": {}, "source": [ - "At this point, we've obtained the quantum circuit for generating the ground state of $H_{2}$. We can run the `shadow_trace` function on this circuit to obtain the estimated ground state energy. In the `shadow_trace` function, our inputs are the Hamiltonian to be estimated, the number of samples, and the method selected. You can choose the sampling mode you want by specifying the parameter `method`. Among them, CS has a broader application range and the fastest speed, but its estimation accuracy may be slightly poor; LBCS has a higher accuracy, but it runs slower as the number of terms of Hamiltonian grows; APS also has higher accuracy, but it runs slower when the number of qubits is large." + "At this point, we've obtained the quantum circuit for generating the ground state of H$_2$. We can run the `shadow_trace` function on this circuit to obtain the estimated ground state energy. In the `shadow_trace` function, our inputs are the Hamiltonian to be estimated, the number of samples, and the method selected. You can choose the sampling mode you want by specifying the parameter `method`. Among them, CS has a broader application range and the fastest speed, but its estimation accuracy may be slightly poor; LBCS has a higher accuracy, but it runs slower as the number of terms of Hamiltonian grows; APS also has higher accuracy, but it runs slower when the number of qubits is large." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "3b31e57d", "metadata": {}, "outputs": [ @@ -345,23 +296,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "H2 ground state energy = -1.1360331063822373\n", - "H2 ground state energy CS= -1.1652093330967717\n", - "H2 ground state energy LBCS= -1.1213982275348622\n", - "H2 ground state energy APS= -1.137720214050516\n" + "H2 ground state energy = -1.1359991\n", + "H2 ground state energy CS= -1.1739629297399878\n", + "H2 ground state energy LBCS= -1.1761520023096912\n", + "H2 ground state energy APS= -1.1390595539226058\n" ] } ], "source": [ "# The actual energy value corresponding to the estimated ground state\n", - "H2_energy = cir.expecval(H2_hamiltonian).numpy()[0]\n", - "\n", + "H2_energy = loss_func(cir_H_2()).numpy()[0]\n", "# Sampling times\n", "sample = 1500 \n", "# Three algorithms are used to estimate the expectation value of observable.\n", - "H2_energy_CS = cir.shadow_trace(H2_hamiltonian, sample, method=\"CS\")\n", - "H2_energy_LBCS = cir.shadow_trace(H2_hamiltonian, sample, method=\"LBCS\")\n", - "H2_energy_APS = cir.shadow_trace(H2_hamiltonian, sample, method=\"APS\")\n", + "H2_energy_CS = shadow_trace(cir_H_2(), H2_hamiltonian, sample, method=\"CS\")\n", + "H2_energy_LBCS = shadow_trace(cir_H_2(), H2_hamiltonian, sample, method=\"LBCS\")\n", + "H2_energy_APS = shadow_trace(cir_H_2(), H2_hamiltonian, sample, method=\"APS\")\n", "\n", "print('H2 ground state energy = ', H2_energy)\n", "print('H2 ground state energy CS= ', H2_energy_CS)\n", @@ -374,12 +324,12 @@ "id": "1cb856da", "metadata": {}, "source": [ - "Now let's use the item-by-item measurement method to estimate the ground state energy of $H_{2}$." + "Now let's use the item-by-item measurement method to estimate the ground state energy of H$_2$." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "id": "3ae0242c", "metadata": {}, "outputs": [ @@ -387,13 +337,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "H2 ground state energy traditional = -1.1367622727687419\n" + "H2 ground state energy traditional = -1.1305740736791674\n" ] } ], "source": [ "# Use the item-by-item measurement method to estimate the ground state energy\n", - "H2_energy_traditional = cir.expecval(H2_hamiltonian, shots=100).numpy()[0]\n", + "H2_energy_traditional = cir_H_2().expec_val(H2_hamiltonian, shots=100)\n", "print('H2 ground state energy traditional = ', H2_energy_traditional)" ] }, @@ -402,7 +352,7 @@ "id": "b2e1ad02", "metadata": {}, "source": [ - "We can see that under 1500 samples, the estimated ground state energy by these three algorithms are very close to the energy of the estimated ground state by VQE. The item-by-item measurement method is to make 100 measurements for each item of the Hamiltonian, and there are 15 items of the Hamiltonian of $H_{2}$, which is equivalent to 1500 measurements in total. The difference between the obtained results and the energy of the estimated ground state by VQE is also tiny. In this small-scale situation, the classical-shadow-based algorithms do not show significant advantages over the item-by-item measurement method. But in large-scale qubits scenarios, this algorithm requires only constant-level growth of the number of the Hamiltonian terms. In contrast, the item-by-item measurement method or some other methods require polynomial-level or even exponential-level growth in the number of samples to get the same accuracy[1]. In fact, it is pointed out in [2] that for CS algorithm and LBCS algorithm, the average error of estimation $\\epsilon$, variance $\\operatorname {var}(\\nu)$ and number of samples $S$ are related as follows:\n", + "We can see that under 1500 samples, the estimated ground state energy by these three algorithms are very close to the energy of the estimated ground state by VQE. The item-by-item measurement method is to make 100 measurements for each item of the Hamiltonian, and there are 15 items of the Hamiltonian of H$_2$, which is equivalent to 1500 measurements in total. The difference between the obtained results and the energy of the estimated ground state by VQE is also tiny. In this small-scale situation, the classical-shadow-based algorithms do not show significant advantages over the item-by-item measurement method. But in large-scale qubits scenarios, this algorithm requires only constant-level growth of the number of the Hamiltonian terms. In contrast, the item-by-item measurement method or some other methods require polynomial-level or even exponential-level growth in the number of samples to get the same accuracy[1]. In fact, it is pointed out in [2] that for CS algorithm and LBCS algorithm, the average error of estimation $\\epsilon$, variance $\\operatorname {var}(\\nu)$ and number of samples $S$ are related as follows:\n", "\n", "$$\n", "S = O(\\epsilon^{-2} \\operatorname{var}(\\nu) ), \\tag{3}\n", @@ -427,7 +377,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 9, "id": "fc6b465c", "metadata": {}, "outputs": [ @@ -435,7 +385,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "[('yxxz', '0010'), ('xyzx', '0101'), ('yxyx', '1010'), ('yxyy', '1101'), ('yyyx', '0101'), ('xyxz', '0010'), ('zyxz', '1010'), ('xzyz', '0110'), ('zzzx', '1101'), ('xyxx', '0101')]\n" + "[('zxyy', '1101'), ('xxxz', '0100'), ('xzyz', '1100'), ('zyxy', '1101'), ('zyxz', '1110'), ('xxxz', '1010'), ('xzyx', '1111'), ('yzzx', '1101'), ('yzyy', '1111'), ('yyxy', '1111')]\n" ] } ], @@ -443,9 +393,9 @@ "from paddle_quantum.shadow import shadow_sample\n", "\n", "# Run the circuit in the vector form\n", - "H2_rho = np.array(cir.run_state_vector())\n", + "H2_rho = to_state(cir_H_2().data)\n", "# Get the data of classical shadow and output it in the form of a list\n", - "H2_sample_data_CS = shadow_sample(H2_rho, H2_qubit, sample_shots=10, mode='state_vector', \n", + "H2_sample_data_CS = shadow_sample(H2_rho, H2_qubit, sample_shots=10, mode='density_matrix', \n", " hamiltonian=H2_hamiltonian, method='CS')\n", "print(H2_sample_data_CS)" ] @@ -455,7 +405,7 @@ "id": "e74ffd18", "metadata": {}, "source": [ - "### Estimate the ground state energy of lithium hydride ($LiH$)" + "### Estimate the ground state energy of lithium hydride (LiH)" ] }, { @@ -463,12 +413,12 @@ "id": "e4480cb6", "metadata": {}, "source": [ - "Next, we consider the ground state energy of $LiH$. First, we load from a pre-computed file to generate the molecular Pauli Hamiltonian of $LiH$ with 12 qubits." + "Next, we consider the ground state energy of LiH. First, we load from a pre-computed file to generate the molecular Pauli Hamiltonian of LiH with 12 qubits." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "id": "6916c8a4", "metadata": {}, "outputs": [], @@ -485,12 +435,12 @@ "id": "61d8fd59", "metadata": {}, "source": [ - "Then, we also use the VQE algorithm to obtain the ground state energy and the ground state of $LiH $ and then use the classical shadow algorithm to estimate the ground state energy. Due to the large size of the $LiH$ molecular Hamiltonian, it will take a long time to train the VQE circuit. Hence we provide a set of pre-trained parameters, using which the users could test the classical-shadow-based algorithms on $LiH$ Hamiltonian directly." + "Then, we also use the VQE algorithm to obtain the ground state energy and the ground state of $LiH $ and then use the classical shadow algorithm to estimate the ground state energy. Due to the large size of the LiH molecular Hamiltonian, it will take a long time to train the VQE circuit. Hence we provide a set of pre-trained parameters, using which the users could test the classical-shadow-based algorithms on LiH Hamiltonian directly." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "id": "fe326409", "metadata": {}, "outputs": [ @@ -498,7 +448,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "The pre-trained VQE gets a ground state energy of: -7.7720 \n" + "The pre-trained VQE gets a ground state energy of：-7.7720 \n" ] } ], @@ -506,9 +456,19 @@ "# Load the pre-trained parameters\n", "pretrained_parameters = paddle.load('LiH_VQE_parameters.pdtensor')\n", "N = LiH_hamiltonian.n_qubits\n", + "\n", "# Run the VQE circuit with pre-trained parameters\n", - "energy, cir = U_theta(pretrained_parameters, LiH_hamiltonian, N, D)\n", - "print('The pre-trained VQE gets a ground state energy of: %.4f ' % energy.numpy())" + "cir_LiH = pq.ansatz.Circuit(N)\n", + "\n", + "# Built-in {R_y + CNOT} circuit template\n", + "cir_LiH.real_entangled_layer(depth=D)\n", + "cir_LiH.ry()\n", + "cir_LiH.update_param(pretrained_parameters)\n", + "\n", + "# Calculate expectation value of LiH\n", + "expec_val_LiH = cir_LiH().expec_val(LiH_hamiltonian, shots=0)\n", + "\n", + "print('The pre-trained VQE gets a ground state energy of：%.4f ' % expec_val_LiH)" ] }, { @@ -516,9 +476,9 @@ "id": "8f8ff501", "metadata": {}, "source": [ - "Once we have the circuit corresponding to the $LiH$ ground state, we can directly use the `shadow_trace` function to perform random measurements. Also, since this molecular Hamiltonian has 631 terms, we specify `sample = 1262` for the function `shadow_trace` and `shots = 2` for the function `expecval` in order to ensure that the number of measurements is the same for both types of methods.\n", + "Once we have the circuit corresponding to the LiH ground state, we can directly use the `shadow_trace` function to perform random measurements. Also, since this molecular Hamiltonian has 631 terms, we specify `sample = 1262` for the function `shadow_trace` and `shots = 2` for the function `expecval` in order to ensure that the number of measurements is the same for both types of methods.\n", "\n", - "Since ground state of $LiH$ has 12 qubits, there are $3^{12}$ possible combinations of measurements when doing different Pauli measurements on the ground state of $LiH$. So it is too random to just perform 1262 samples to get the valuation. Thus, we run each of the above four methods 20 times. Then take the mean of these 20 samples of data as the estimation for each algorithm, and calculate the sample variance for a simple comparison of the algorithms.（It may take at least 1 hour to run the following code blocks.）" + "Since the ground state of LiH has 12 qubits, there are $3^{12}$ possible combinations of measurements when doing different Pauli measurements on the ground state of LiH. So it is too random to just perform 1262 samples to get the valuation. Thus, we run each of the above four methods 20 times. Then take the mean of these 20 samples of data as the estimation for each algorithm, and calculate the sample variance for a simple comparison of the algorithms.（It may take 20 minutes to run the following code blocks.）" ] }, { @@ -531,12 +491,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "LiH ground state energy = -7.771980394176657\n", - "ave LiH ground state energy CS = -7.835791570579005\n", - "ave LiH ground state energy LBCS = -7.7622296662623445\n", - "ave LiH ground state energy APS = -7.762836542787509\n", - "ave LiH ground state energy traditional = -7.8964746269601465\n", - "time = 4206.216086864471\n" + "LiH ground state energy = -7.77198\n", + "ave LiH ground state energy CS = -7.783753274753396\n", + "ave LiH ground state energy LBCS = -7.7975030339683995\n", + "ave LiH ground state energy APS = -7.767610962993007\n", + "ave LiH ground state energy traditional = -7.839058153086043\n", + "time = 997.366348028183\n" ] } ], @@ -550,16 +510,17 @@ "estimator_traditional = []\n", "\n", "# The actual energy value corresponding to the estimated ground state\n", - "LiH_energy = cir.expecval(LiH_hamiltonian).numpy()[0]\n", + "LiH_energy = cir_LiH().expec_val(LiH_hamiltonian, shots=0)\n", "\n", "# Number of repetition times\n", "n = 20 \n", "\n", "for i in range(n):\n", - " LiH_energy_CS = cir.shadow_trace(LiH_hamiltonian, 1262, method=\"CS\")\n", - " LiH_energy_LBCS = cir.shadow_trace(LiH_hamiltonian, 1262, method=\"LBCS\")\n", - " LiH_energy_APS = cir.shadow_trace(LiH_hamiltonian, 1262, method=\"APS\")\n", - " LiH_energy_traditional = cir.expecval(LiH_hamiltonian, shots=2).numpy()[0]\n", + " \n", + " LiH_energy_CS = shadow_trace(cir_LiH(), LiH_hamiltonian, 1262, method=\"CS\")\n", + " LiH_energy_LBCS = shadow_trace(cir_LiH(), LiH_hamiltonian, 1262, method=\"LBCS\")\n", + " LiH_energy_APS = shadow_trace(cir_LiH(), LiH_hamiltonian, 1262, method=\"APS\")\n", + " LiH_energy_traditional = cir_LiH().expec_val(LiH_hamiltonian, shots=2)\n", "\n", " estimator_CS.append(LiH_energy_CS) \n", " estimator_LBCS.append(LiH_energy_LBCS) \n", @@ -572,7 +533,7 @@ "ave_LiH_energy_traditional = np.mean(estimator_traditional)\n", "end = time.time() \n", "\n", - "print(\"LiH ground state energy = \", LiH_energy)\n", + "print(\"LiH ground state energy = \", LiH_energy.numpy()[0])\n", "print(\"ave LiH ground state energy CS = \", ave_LiH_energy_CS)\n", "print(\"ave LiH ground state energy LBCS = \", ave_LiH_energy_LBCS)\n", "print(\"ave LiH ground state energy APS = \", ave_LiH_energy_APS)\n", @@ -585,7 +546,7 @@ "id": "89469273", "metadata": {}, "source": [ - "From the results, the mean values obtained by the classical-shadow-based algorithms are closer to the energy of the estimated ground state of $LiH$ by VQE than the item-by-item measurement method, and the errors of the algorithms are all within the accuracy of theoretical estimation in reference [3]. So, what about the sample variance of each algorithm?" + "From the results, the mean values obtained by the classical-shadow-based algorithms are closer to the energy of the estimated ground state of LiH by VQE than the item-by-item measurement method, and the errors of the algorithms are all within the accuracy of theoretical estimation in reference [3]. So, what about the sample variance of each algorithm?" ] }, { @@ -598,10 +559,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "LiH variance CS = 0.034596840359755784\n", - "LiH variance LBCS = 0.016602696085670984\n", - "LiH variance APS = 0.0016603026356630662\n", - "LiH variance traditional = 0.13200055652163223\n" + "LiH variance CS = 0.16361385286362298\n", + "LiH variance LBCS = 0.00737079062689379\n", + "LiH variance APS = 0.001474679255929788\n", + "LiH variance traditional = 0.10573796291575038\n" ] } ], @@ -634,7 +595,7 @@ "id": "d40ef806", "metadata": {}, "source": [ - "It can be seen that the APS algorithm has the lowest sample variance, followed by the LBCS algorithm, then the CS algorithm, and finally the item-by-item measurement method. Accordingly, we can find that after the increase in the number of terms of the Hamiltonian, the classical-shadow-based algorithm has higher accuracy and more stability at the same cost than the item-by-item measurement method. Among them, the APS algorithm is the most stable one.\n", + "It can be seen that the APS algorithm has the lowest sample variance, followed by the LBCS algorithm, then the item-by-item measurement method, and finally the CS algorithm. Accordingly, we can find that after the increase in the number of terms of the Hamiltonian, the classical-shadow-based algorithm has higher accuracy and more stability at the same cost than the item-by-item measurement method. Among them, the APS algorithm is the most stable one.\n", "\n", "It is worth mentioning that for the classical shadow algorithm, the scene of 12 qubits still can not show its significant advantages compared with some existing algorithms. In large-scale systems with more qubits, its advantages can be better demonstrated [1]." ] @@ -679,8 +640,11 @@ } ], "metadata": { + "interpreter": { + "hash": "4261e4eef114648d37e4a637967bd8d2966507f48b194e5e336ba3366b740269" + }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3.8.13 ('pq-ns-icode')", "language": "python", "name": "python3" }, @@ -694,7 +658,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.11" + "version": "3.8.13" } }, "nbformat": 4, diff --git a/tutorials/quantum_simulation/ClassicalShadow_Intro_CN.ipynb b/tutorials/quantum_simulation/ClassicalShadow_Intro_CN.ipynb new file mode 100644 index 0000000..a8c331e --- /dev/null +++ b/tutorials/quantum_simulation/ClassicalShadow_Intro_CN.ipynb @@ -0,0 +1,379 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "prescription-lighter", + "metadata": {}, + "source": [ + "# 未知量子态的经典影子" + ] + }, + { + "cell_type": "markdown", + "id": "loaded-consultation", + "metadata": {}, + "source": [ + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "id": "comfortable-guidance", + "metadata": {}, + "source": [ + "## 概览" + ] + }, + { + "cell_type": "markdown", + "id": "cellular-armstrong", + "metadata": {}, + "source": [ + "对于一个未知量子系统中的量子态 $\\rho$，如何去获取它所包含的信息是一个十分基础且重要的问题。本教程将讨论如何通过经典影子（classical shadow） 技术用经典的数据来描述一个未知的量子态，从而可以高效地对该量子态的诸多性质进行有效估计。在 NISQ （noisy intermediate-scale quantum）时代，这个技术可以很好地帮助我们用经典资源来交换量子资源，在将量子态的信息用经典数据描述后，可以用经典机器学习等方法来解决一些量子问题。并且利用这个方法，一些现有的变分量子算法（例如变分量子本征求解器（variational quantum eigensolver, VQE））实现中的量子电路运行次数等代价将减小，进而提升算法的速度。" + ] + }, + { + "cell_type": "markdown", + "id": "stainless-enemy", + "metadata": {}, + "source": [ + "## 经典影子" + ] + }, + { + "cell_type": "markdown", + "id": "7020ecd5", + "metadata": {}, + "source": [ + "经典影子的直觉来源于现实生活中的影子。我们用一束光垂直照向一个多面体，会在桌面上得到一个它的影子，旋转这个多面体，我们可以看到它不同形状的影子。在多次旋转后，这一系列的影子很自然地就反映了这个多面体的一些信息。类似地，在量子世界，如果我对一个量子态进行一次酉变换，然后进行一次测量，是否也能得到一个量子态的“影子”？经典影子的构建就和这个例子有相似之处，它的过程如下：\n", + "\n", + "首先，我们对 $n$ 个量子比特系统中的一个未知量子态 $\\rho$ 作用一个酉变换：$\\rho \\mapsto U \\rho U^{\\dagger}$ ，然后用计算基态去对每个量子位做测量。对于测量的结果这里用 $|\\hat{b}\\rangle$ 举例解释：对 $|\\hat{b}\\rangle$ 进行之前酉变换的逆变换得到 $U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U$。我们知道，测得的量子态 $|\\hat{b}\\rangle\\langle\\hat{b}|$ 在计算基态下的期望为：\n", + "\n", + "$$\n", + "\\mathbb{E}(|\\hat{b}\\rangle\\langle\\hat{b}|) = \\sum_{b \\in \\{0,1\\}^{n}} \\operatorname{Pr}(|\\hat{b}\\rangle\\langle\\hat{b}| = |b\\rangle\\langle b|)\\cdot |b\\rangle \\langle b|= \\sum_{b \\in \\{0,1\\}^{n}}\\langle b|U\\rho U^{\\dagger} |b\\rangle |b\\rangle \\langle b|. \\tag{1}\n", + "$$\n", + "\n", + "那么进行了逆操作后，$U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U$ 的期望就是 $\\sum_{b \\in \\{0,1\\}^{n}}\\langle b|U\\rho U^{\\dagger} |b\\rangle U^{\\dagger}|b\\rangle \\langle b|U$。在这个过程中，酉变换 $U$ 是从一个固定的集合中随机选取。当我们重复这一过程，对每次随机选取的 $U$ 也求平均时，可以得到：\n", + "\n", + "$$\n", + "\\mathbb{E}_{U \\sim \\mathcal{U}\\left(n\\right)}(\\mathbb{E}(U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U))=\\sum_{b \\in \\{0,1\\}^{n}}\\mathbb{E}_{U \\sim \\mathcal{U}\\left(n\\right)}(\\langle b|U\\rho U^{\\dagger} |b\\rangle U^{\\dagger}|b\\rangle \\langle b|U), \\tag{2}\n", + "$$ \n", + "\n", + "其中 $\\mathcal{U}\\left(n\\right)$ 是给定的一个作用在 $n$ 个量子比特上的酉变换集合。\n", + "\n", + "如果把这个期望的结果记作 $\\mathcal{M}(\\rho)$ ，则 $\\mathcal{M}$ 将会是一个从 $\\rho$ 到 $\\mathcal{M}(\\rho)$ 的映射。当 $\\mathcal{M}$ 线性可逆时 [1]，初始的量子态 $\\rho$ 就可以表达为\n", + "\n", + "$$\n", + "\\rho=\\mathcal{M}^{-1}(\\mathbb{E}_{U \\sim \\mathcal{U} \\left(n\\right)}(\\mathbb{E}(U^{\\dagger}|\\hat{b}\\rangle\\langle \\hat{b}|U))) = \\mathbb{E}_{U \\sim \\mathcal{U} \\left(n\\right)}(\\mathbb{E}(\\mathcal{M}^{-1} (U^{\\dagger}|\\hat{b}\\rangle\\langle \\hat{b}|U))). \\tag{3}\n", + "$$\n", + "\n", + "有了 $\\mathcal{M}^{-1}$后，每一次采样 $U$ ，对 $U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U$ 作用 $\\mathcal{M}^{-1}$ 的结果 $\\hat{\\rho} = \\mathcal{M}^{-1}(U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U)$ 被我们称为 $\\rho$ 的一个快照（snapshot），重复这个过程 $N$ 次后得到 $N$ 个关于 $\\rho$ 的快照的集合：\n", + "\n", + "$$\n", + "\\text{S}(\\rho ; N)=\\{\\hat{\\rho}_{1}=\\mathcal{M}^{-1}(U_{1}^{\\dagger}|\\hat{b}_{1}\\rangle\\langle\\hat{b}_{1}| U_{1}), \\ldots, \\hat{\\rho}_{N}=\\mathcal{M}^{-1}(U_{N}^{\\dagger}|\\hat{b}_{N}\\rangle\\langle\\hat{b}_{N}| U_{N})\\}. \\tag{4}\n", + "$$\n", + "\n", + "我们把 $\\text{S}(\\rho; N)$ 就称为 $\\rho$ 的经典影子。值得一提的是，$\\mathcal{M}$ 具体是什么取决于我们选取的采样集合 $\\mathcal{U}$，例如当该集合选定为 Clifford 群时，我们有: \n", + "\n", + "$$\n", + "\\mathcal{M}(\\rho)=\\mathbb{E}_{U \\sim \\operatorname{Cl} \\left(n\\right)}(\\mathbb{E}(U^{\\dagger}|\\hat{b}\\rangle\\langle \\hat{b}|U)) = \\frac{1}{2^{n}+1}\\rho+\\frac{1}{2^{n}+1}I. \\tag{5}\n", + "$$\n", + "\n", + "（有关 $\\mathcal{M}$ 的表达式为何如（5）所示，读者可以参考 [1]）。于是：\n", + "\n", + "$$\n", + "\\mathcal{M}^{-1}(\\frac{1}{2^{n}+1}\\rho+\\frac{1}{2^{n}+1}I)=\\rho \\Rightarrow \\mathcal{M}^{-1}(\\rho) = (2^{n}+1)\\rho-I. \\tag{6}\n", + "$$\n", + "\n", + "构建了经典影子之后，它是如何帮助我们有效估计量子态的性质的呢？[1] 中指出，关于量子态 $\\rho$ 的一些线性性质就十分适合用经典影子技术来估计，例如 $\\rho$ 在某个可观测量 $\\mathcal{O}$ 下的期望：$o=\\operatorname{tr}\\left(\\mathcal{O} \\rho\\right)$，我们记 $\\hat{o}=\\operatorname{tr}\\left(\\mathcal{O} \\hat{\\rho}\\right)$，那么根据（3）式，就有 $\\mathbb{E}[\\hat{o}]=\\operatorname{tr}\\left(\\mathcal{O} \\rho\\right)$。与之相关的应用与实现，读者可以阅读另一篇教程：[基于经典影子的量子态性质估计](./ClassicalShadow_Application_CN.ipynb)。\n", + "\n", + "接下来，我们将在量桨中展示对一个随机生成的量子态 $\\rho$ 构建其经典影子的过程，帮助读者更好地理解与感受经典影子这个技术。其中选取 Clifford 群作为酉变换的采样集合（具体有关 Clifford 群的性质以及如何从中均匀随机采样 Clifford 变换，感兴趣的读者可以参考 [1]、[3] 以及量桨中的 `Clifford` 类）。" + ] + }, + { + "cell_type": "markdown", + "id": "chinese-talent", + "metadata": {}, + "source": [ + "## Paddle Quantum 代码实现" + ] + }, + { + "cell_type": "markdown", + "id": "proved-hypothesis", + "metadata": {}, + "source": [ + "首先，我们导入需要用到的包。" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "freelance-steps", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "import paddle\n", + "import matplotlib.pyplot as plt\n", + "import paddle_quantum as pq\n", + "from paddle_quantum.qinfo import trace_distance\n", + "from paddle_quantum.state import to_state" + ] + }, + { + "cell_type": "markdown", + "id": "blessed-italian", + "metadata": {}, + "source": [ + "接下来，我们随机生成量子态 $\\rho$。" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "39527cf9", + "metadata": {}, + "outputs": [], + "source": [ + "# 设置量子比特数目\n", + "n_qubit = 2\n", + "pq.set_backend('density_matrix')\n", + "\n", + "# 随机生成纯态 rho\n", + "rho_random = pq.state.random_state(n_qubit, rank=1) \n", + "\n", + "# 定义 |0> 和 |1>\n", + "ket_0 = np.array([[1,0]]).T\n", + "ket_1 = np.array([[0,1]]).T\n", + "\n", + "# 定义单位矩阵与 M 逆的系数\n", + "I = np.eye(2**n_qubit)\n", + "coefficient = float(2**n_qubit + 1)" + ] + }, + { + "cell_type": "markdown", + "id": "painful-crossing", + "metadata": {}, + "source": [ + "下一步，我们定义在测量时所需要的电路，并对我们记录测量结果做一些准备。" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "dependent-abortion", + "metadata": {}, + "outputs": [], + "source": [ + "def measure_by_clifford(phi, num_qubit):\n", + " \"\"\"\n", + " 对 phi 进行 Clifford 变换后，进行计算基态下的测量\n", + " \"\"\"\n", + " # 通过 Paddle Quantum 的 Clifford 类，来随机选取一个 Clifford operator，并生成其电路\n", + " clif = pq.gate.clifford.Clifford(num_qubit)\n", + " # 运行电路\n", + " cir = clif.circuit()\n", + " # 获取电路的酉矩阵形式\n", + " cl = cir.unitary_matrix().numpy()\n", + " # 对这一次采样后的运行结果进行一次测量\n", + " result = cir(phi).measure(shots=1)\n", + " bitstring = [k for k, v in result.items() if v == 1.0]\n", + " # 将测量的比特串结果记成态矢量形式\n", + " bhat = [[1.]]\n", + " for i in bitstring[0]:\n", + " if i == '0':\n", + " bhat = np.kron(bhat, ket_0)\n", + " elif i == '1':\n", + " bhat = np.kron(bhat, ket_1)\n", + " return bhat, cl" + ] + }, + { + "cell_type": "markdown", + "id": "collect-fellow", + "metadata": {}, + "source": [ + "### 进行酉变换的采样与经典影子的构建" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "authorized-welcome", + "metadata": {}, + "outputs": [], + "source": [ + "# 选定采样次数\n", + "S = 800" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "specified-balloon", + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "estimator_rho = []\n", + "tracedistance = []\n", + "\n", + "for sample in range(S):\n", + " \n", + " bhat, cl = measure_by_clifford(rho_random, n_qubit)\n", + "\n", + " # 根据推导的 M 逆来得到 shadow\n", + " hat_rho = coefficient * cl.conj().T @ bhat @ bhat.T @ cl - I\n", + " estimator_rho.append(hat_rho)\n", + " \n", + " # 对 shadow 求平均（因为在实际操作中，我们不能实现（3）式中的求期望，只能对得到的 classical shadow 求平均来近似）\n", + " ave_estimate = sum(estimator_rho) / len(estimator_rho)\n", + " # 计算迹距离\n", + " tracedistance.append(trace_distance(rho_random, to_state(paddle.to_tensor(ave_estimate))).numpy())" + ] + }, + { + "cell_type": "markdown", + "id": "boolean-overview", + "metadata": {}, + "source": [ + "最后，我们输出用经典影子近似的 $\\rho$ 与真实 $\\rho$ 的矩阵表示，以及他们的迹距离。迹距离越接近 0 则说明用经典影子近似的 $\\rho$ 越接近真实的量子态。" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "german-columbia", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "输出的量子态近似： [[0.159+0.j 0.241+0.131j 0.244-0.025j 0.234+0.056j]\n", + " [0.241-0.131j 0.409+0.j 0.209-0.125j 0.431-0.019j]\n", + " [0.244+0.025j 0.209+0.125j 0.078+0.j 0.234+0.175j]\n", + " [0.234-0.056j 0.431+0.019j 0.234-0.175j 0.353+0.j ]]\n", + "--------------------------------------------------\n", + "初始输入的量子态： [[0.109+0.j 0.175+0.135j 0.124-0.02j 0.146+0.106j]\n", + " [0.175-0.135j 0.449+0.j 0.173-0.186j 0.366-0.011j]\n", + " [0.124+0.02j 0.173+0.186j 0.144+0.j 0.146+0.148j]\n", + " [0.146-0.106j 0.366+0.011j 0.146-0.148j 0.298+0.j ]]\n", + "量子态近似与真实量子态的迹距离： 0.258\n" + ] + } + ], + "source": [ + "print('输出的量子态近似：', np.around(ave_estimate, decimals=3))\n", + "print('-' * 50)\n", + "print('初始输入的量子态：', np.around(rho_random.numpy(), decimals=3))\n", + "print('量子态近似与真实量子态的迹距离：', np.around(tracedistance[-1][0], decimals=3))" + ] + }, + { + "cell_type": "markdown", + "id": "independent-inspiration", + "metadata": {}, + "source": [ + "可以看到，用经典影子近似的 $\\rho$ 与真实的量子态 $\\rho$ 在矩阵表示上已经十分接近，在 800 次的采样左右，两者的迹距离已经在 0.2 左右。下图展示了迹距离随着采样次数增多而下降的关系。" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "superb-merchandise", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 打印出量子态的近似与初始量子态的迹距离结果图\n", + "fig,ax = plt.subplots(figsize=(10, 10))\n", + "plt.xlabel('number of samples', fontsize=18)\n", + "plt.ylabel('trace distance', fontsize=18)\n", + "j = range(len(tracedistance)) \n", + "plt.plot(j, tracedistance, 'r', label=\"trace_distance\")\n", + "\"\"\"open the grid\"\"\"\n", + "plt.grid(True)\n", + "plt.legend(fontsize=14)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "graphic-oklahoma", + "metadata": {}, + "source": [ + "## 总结" + ] + }, + { + "cell_type": "markdown", + "id": "unavailable-health", + "metadata": {}, + "source": [ + "本教程介绍了经典影子的基本原理与一些理论知识。在展示的案例中，我们基于量桨对一个随机生成的 2 个量子比特量子态构建了其经典影子。直观地感受了经典影子可以对一个未知的量子态做较好的近似。事实上，[2] 中指出在许多场景下，要求对量子系统进行完整的经典描述可能是多余的。相反，准确地估计量子系统的某些特性通常就足够了，这也是经典影子真正的重要性所在。在经典影子应用的教程（[基于经典影子的量子态性质估计](./ClassicalShadow_Application_CN.ipynb)）中，将具体介绍经典影子的应用以及如何在量桨中使用 shadow 功能。" + ] + }, + { + "cell_type": "markdown", + "id": "adopted-taste", + "metadata": {}, + "source": [ + "## 参考文献" + ] + }, + { + "cell_type": "markdown", + "id": "described-swiss", + "metadata": {}, + "source": [ + "[1] Huang, Hsin-Yuan, Richard Kueng, and John Preskill. \"Predicting many properties of a quantum system from very few measurements.\" [Nature Physics 16.10 (2020): 1050-1057.](https://authors.library.caltech.edu/102787/1/2002.08953.pdf)\n", + "\n", + "[2] Aaronson, Scott. \"Shadow tomography of quantum states.\" [SIAM Journal on Computing 49.5 (2019): STOC18-368.](https://dl.acm.org/doi/abs/10.1145/3188745.3188802) \n", + "\n", + "[3] Bravyi, Sergey, and Dmitri Maslov. \"Hadamard-free circuits expose the structure of the Clifford group.\" [IEEE Transactions on Information Theory 67.7 (2021): 4546-4563.](https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=9435351)" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "0c785fa01a45293a2a325c4fa624f41b05f7fdafa1fed21e8d0fe069247007dc" + }, + "kernelspec": { + "display_name": "Python 3.8.13 ('new_pq')", + "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.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/quantum_simulation/ClassicalShadow_Intro_EN.ipynb b/tutorials/quantum_simulation/ClassicalShadow_Intro_EN.ipynb new file mode 100644 index 0000000..fc3fa0a --- /dev/null +++ b/tutorials/quantum_simulation/ClassicalShadow_Intro_EN.ipynb @@ -0,0 +1,352 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "damaged-friendship", + "metadata": {}, + "source": [ + "# The Classical Shadow of Unknown Quantum States" + ] + }, + { + "cell_type": "markdown", + "id": "quarterly-leone", + "metadata": {}, + "source": [ + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "id": "widespread-clone", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "For the quantum state $\\rho$ in an unknown quantum system, obtaining the information it contains is a fundamental and essential problem. This tutorial will discuss how to use the classical shadow to describe an unknown quantum state with classical data so that many quantum state properties can be efficiently estimated. In the era of NISQ (noisy intermediate-scale quantum), the classical shadow helps us trade quantum for classical resources. After describing the information of the quantum state with classical data, some quantum problems can be solved by methods such as classical machine learning. And using this method, the cost of the quantum circuit running times in some existing variational quantum algorithms like variational quantum eigensolver (VQE) may be reduced so that an acceleration can be achieved." + ] + }, + { + "cell_type": "markdown", + "id": "remarkable-season", + "metadata": {}, + "source": [ + "## The Classical Shadow\n", + "\n", + "The intuition of the classical shadow comes from shadows in real life. If we use a beam of light to illuminate a polyhedron vertically, we get a shadow of it. Rotating this polyhedron, we can see its different shadows. After many rotations, this series of shadows naturally reflect some information about this polyhedron. Similarly, in the quantum world, if we perform a unitary transformation on a quantum state and then perform a measurement, can we also get a \"shadow\" of the quantum state? The construction of the classical shadow is analogous to this example. Its construction process is as follows:\n", + "\n", + "First, we apply a unitary transformation to an unknown quantum state $\\rho$ in an $n$ qubits system: $\\rho \\mapsto U \\rho U^{\\dagger}$, and then measure each qubit in the computational basis. For the measurement result, we use $|\\hat{b}\\rangle$ as an example. We perform the inverse transformation of the previous unitary on $|\\hat{b}\\rangle$ to get $U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U$. We know that the expectation of the measured quantum state $|\\hat{b}\\rangle\\langle\\hat{b}|$ is: \n", + "\n", + "$$\n", + "\\mathbb{E}(|\\hat{b}\\rangle\\langle\\hat{b}|) = \\sum_{b \\in \\{0,1\\}^{n}} \\operatorname{Pr}(|\\hat{b}\\rangle\\langle\\hat{b}| = |b\\rangle\\langle b|)\\cdot |b\\rangle \\langle b|= \\sum_{b \\in \\{0,1\\}^{n}}\\langle b|U\\rho U^{\\dagger} |b\\rangle |b\\rangle \\langle b|. \\tag{1}\n", + "$$\n", + "\n", + "Then after the reverse operation, the expectation value of $U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U$ is $\\sum_{b \\in \\{0,1\\}^{n}}\\langle b|U\\rho U^{\\dagger} |b\\rangle U^{\\dagger}|b\\rangle \\langle b|U$. In this process, the unitary transformation $U$ is randomly selected from a fixed set. \n", + "When we repeat this process and average $U$, we can get:\n", + "\n", + "$$\n", + "\\mathbb{E}_{U \\sim \\mathcal{U}\\left(n\\right)}(\\mathbb{E}(U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U))=\\sum_{b \\in \\{0,1\\}^{n}}\\mathbb{E}_{U \\sim \\mathcal{U}\\left(n\\right)}(\\langle b|U\\rho U^{\\dagger} |b\\rangle U^{\\dagger}|b\\rangle \\langle b|U) \\tag{2}\n", + "$$\n", + "\n", + "where $\\mathcal{U}\\left(n\\right)$ is a given unitary transformation set on $n$ qubits.\n", + "\n", + "If this expectation value is recorded as $\\mathcal{M}(\\rho)$, then $\\mathcal{M}$ will be a map from $\\rho$ to $\\mathcal{M}(\\rho)$. When $\\mathcal{M}$ is linear and reversible [1], the initial quantum state $\\rho$ can be expressed as\n", + "\n", + "$$\n", + "\\rho=\\mathcal{M}^{-1}(\\mathbb{E}_{U \\sim \\mathcal{U} \\left(n\\right)}(\\mathbb{E}(U^{\\dagger}|\\hat{b}\\rangle\\langle \\hat{b}|U))) = \\mathbb{E}_{U \\sim \\mathcal{U} \\left(n\\right)}(\\mathbb{E}(\\mathcal{M}^{-1} (U^{\\dagger}|\\hat{b}\\rangle\\langle \\hat{b}|U))). \\tag{3}\n", + "$$\n", + "\n", + "With $\\mathcal{M}^{-1}$, every time $U$ is sampled, we compute $\\hat{\\rho} = \\mathcal{M }^{-1}(U^{\\dagger}|\\hat{b}\\rangle\\langle\\hat{b}|U)$ and name it a snapshot. After repeating this process $N$ times, we get $N$ collections of snapshots about $\\rho$:\n", + "\n", + "$$\n", + "\\text{S}(\\rho ; N)=\\{\\hat{\\rho}_{1}=\\mathcal{M}^{-1}(U_{1}^{\\dagger}|\\hat{b}_{1}\\rangle\\langle\\hat{b}_{1}| U_{1}), \\ldots, \\hat{\\rho}_{N}=\\mathcal{M}^{-1}(U_{N}^{\\dagger}|\\hat{b}_{N}\\rangle\\langle\\hat{b}_{N}| U_{N})\\}. \\tag{4}\n", + "$$\n", + "\n", + "We call $\\text{S}(\\rho; N)$ the classical shadow of $\\rho$. It is worth mentioning that what exactly $\\mathcal{M}$ is depends on the sampling set $\\mathcal{U}$ we select. For example, when we select the Clifford group as the sampling set $\\mathcal{U}$, we have:\n", + "\n", + "$$\n", + "\\mathcal{M}(\\rho)=\\mathbb{E}_{U \\sim \\operatorname{Cl} \\left(n\\right)}(\\mathbb{E}(U^{\\dagger}|\\hat{b}\\rangle\\langle \\hat{b}|U)) = \\frac{1}{2^{n}+1}\\rho+\\frac{1}{2^{n}+1}I. \\tag{5}\n", + "$$\n", + "\n", + "Readers may refer to [1] for details about why $\\mathcal{M}$ is as (5). It follows that\n", + "\n", + "$$\n", + "\\mathcal{M}^{-1}(\\frac{1}{2^{n}+1}\\rho+\\frac{1}{2^{n}+1}I)=\\rho \\Rightarrow \\mathcal{M}^{-1}(\\rho) = (2^{n}+1)\\rho-I. \\tag{6}\n", + "$$\n", + "\n", + "After constructing the classical shadow, how does it help us to effectively estimate the properties of the quantum state? Some linear properties of quantum state $\\rho$ are very suitable to be estimated by the classical shadow, for example, the expectation value of $\\rho$ of an observable $\\mathcal{O}$: $o =\\operatorname{tr}\\left(\\mathcal{O} \\rho\\right)$ [1]. Let $\\hat{o}=\\operatorname{tr}\\left(\\mathcal{O} \\hat{\\rho}\\right)$, then according to (3), there is $\\mathbb{E}[\\hat{o}]=\\operatorname{tr}\\left(\\mathcal{O} \\rho\\right)$. We provide detailed applications and implementations in our following tutorial: [Estimation of Quantum State Properties Based on the Classical Shadow](./ClassicalShadow_Application_EN.ipynb)." + ] + }, + { + "cell_type": "markdown", + "id": "metropolitan-subdivision", + "metadata": {}, + "source": [ + "Next, we will show the process of constructing the classical shadow for a randomly selected quantum state $\\rho$ in Paddle Quantum to help readers understand how the classical shadow works. And we will use the Clifford group as the sampling set of the unitary transformation (specifically about the properties of the Clifford group and how to sample uniformly distributed Clifford operators from it randomly, readers can refer to [1], [3], and the `Clifford` class in Paddle Quantum)." + ] + }, + { + "cell_type": "markdown", + "id": "regional-binary", + "metadata": {}, + "source": [ + "## Paddle Quantum Implementation" + ] + }, + { + "cell_type": "markdown", + "id": "military-project", + "metadata": {}, + "source": [ + "First, we need to import all the dependencies:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "stopped-kennedy", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import paddle\n", + "import matplotlib.pyplot as plt\n", + "import paddle_quantum as pq\n", + "from paddle_quantum.qinfo import trace_distance\n", + "from paddle_quantum.state import to_state" + ] + }, + { + "cell_type": "markdown", + "id": "activated-found", + "metadata": {}, + "source": [ + "Next, we randomly generate a quantum state $\\rho$." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "union-freedom", + "metadata": {}, + "outputs": [], + "source": [ + "# Number of qubits\n", + "n_qubit = 2\n", + "pq.set_backend('density_matrix')\n", + "\n", + "# Randomly generate a state \n", + "rho_random = pq.state.random_state(n_qubit, rank=1) \n", + "\n", + "# Define |0> and |1>\n", + "ket_0 = np.array([[1,0]]).T\n", + "ket_1 = np.array([[0,1]]).T\n", + "\n", + "# Define I and coefficient\n", + "I = np.eye(2**n_qubit)\n", + "coefficient = float(2**n_qubit + 1)" + ] + }, + { + "cell_type": "markdown", + "id": "turkish-danish", + "metadata": {}, + "source": [ + "In the next step, we define the circuit required for the measurement and prepare us to record the results." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "threatened-coach", + "metadata": {}, + "outputs": [], + "source": [ + "def measure_by_clifford(phi, num_qubit):\n", + " \"\"\"\n", + " After applying Clifford operation on rho, obtain measurement in the computational basis\n", + " \"\"\"\n", + " # Use the Clifford class of Paddle Quantum to randomly select a Clifford operator and generate its circuit\n", + " clif = pq.gate.clifford.Clifford(num_qubit)\n", + " # Run the circuit\n", + " cir = clif.circuit()\n", + " # Get the unitary implemented by the circuit\n", + " cl = cir.unitary_matrix().numpy()\n", + " # Single measurement\n", + " result = cir(phi).measure(shots=1)\n", + " bitstring = [k for k, v in result.items() if v == 1.0]\n", + "\n", + " # Use this to record results of measurement\n", + " bhat = [[1.]]\n", + " for i in bitstring[0]:\n", + " if i == '0':\n", + " bhat = np.kron(bhat, ket_0)\n", + " elif i == '1':\n", + " bhat = np.kron(bhat, ket_1)\n", + " return bhat, cl" + ] + }, + { + "cell_type": "markdown", + "id": "neutral-sender", + "metadata": {}, + "source": [ + "### Sampling unitary and building the classical shadow" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "dietary-lucas", + "metadata": {}, + "outputs": [], + "source": [ + "# Select the number of samples\n", + "S = 800\n", + "\n", + "estimator_rho = []\n", + "tracedistance = []\n", + "\n", + "for sample in range(S):\n", + " \n", + " bhat, cl = measure_by_clifford(rho_random, n_qubit)\n", + "\n", + " # Get the shadow according to the deduced M inverse\n", + " hat_rho = coefficient * cl.conj().T @ bhat @ bhat.T @ cl - I\n", + " estimator_rho.append(hat_rho)\n", + " \n", + " # Compute the average of the shadows \n", + " # Since in actual operation, we cannot achieve the expectation value in (3), we can only approximate rho by averaging the classical shadow obtained.\n", + " ave_estimate = sum(estimator_rho) / len(estimator_rho) \n", + " # Calculate trace distance\n", + " tracedistance.append(trace_distance(rho_random, to_state(paddle.to_tensor(ave_estimate))).numpy())" + ] + }, + { + "cell_type": "markdown", + "id": "excited-dividend", + "metadata": {}, + "source": [ + "Finally, we output the matrix representation of an approximation of $\\rho$ by the classical shadow and the real $\\rho$. Also, we output their trace distance. The closer the trace distance is to 0, the closer the approximation is to the real quantum state." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "frank-sussex", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Approximation: [[0.434+0.j 0.319-0.084j 0.392+0.045j 0.161-0.008j]\n", + " [0.319+0.084j 0.178+0.j 0.286+0.033j 0.211+0.048j]\n", + " [0.392-0.045j 0.286-0.033j 0.356+0.j 0.25 +0.009j]\n", + " [0.161+0.008j 0.211-0.048j 0.25 -0.009j 0.031+0.j ]]\n", + "--------------------------------------------------\n", + "Real state: [[0.419+0.j 0.27 -0.036j 0.38 +0.057j 0.142+0.036j]\n", + " [0.27 +0.036j 0.178+0.j 0.24 +0.07j 0.088+0.035j]\n", + " [0.38 -0.057j 0.24 -0.07j 0.353+0.j 0.133+0.013j]\n", + " [0.142-0.036j 0.088-0.035j 0.133-0.013j 0.051+0.j ]]\n", + "Trace distance between approximation and real state: [0.225]\n" + ] + } + ], + "source": [ + "print('Approximation: ', np.around(ave_estimate, decimals=3))\n", + "print('-' * 50)\n", + "print('Real state: ', np.around(rho_random.numpy(), decimals=3))\n", + "print('Trace distance between approximation and real state: ', np.around(tracedistance[-1][0], decimals=3))" + ] + }, + { + "cell_type": "markdown", + "id": "governing-springer", + "metadata": {}, + "source": [ + "As you can see, our approximation of $\\rho$ is very close to the real quantum state $\\rho$ in the matrix representation. With about 800 samplings, the trace distance between the approximation and the real state is already around 0.2. The relation between their trace distance and the number of samplings is shown below." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "hungarian-bangladesh", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Print out the result\n", + "fig,ax = plt.subplots(figsize=(10, 10))\n", + " \n", + "plt.xlabel('number of samples', fontsize=18)\n", + "plt.ylabel('trace distance', fontsize=18)\n", + "j = range(len(tracedistance)) \n", + "plt.plot(j, tracedistance, 'r', label=\"trace_distance\")\n", + "\"\"\"open the grid\"\"\"\n", + "plt.grid(True)\n", + "plt.legend(fontsize=14)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "ambient-actor", + "metadata": {}, + "source": [ + "## Conclusion\n", + "\n", + "This tutorial introduces some theoretical knowledge of the classical shadow. In this example, we constructed the classical shadow of a random 2-qubit quantum state in Paddle Quantum. We can intuitively understand that the classical shadow can make a good approximation to an unknown quantum state. In fact, [2] pointed out demanding full classical descriptions of quantum systems may be excessive for many concrete tasks. Instead, it is often sufficient to accurately predict certain properties of the quantum system. This is where the fundamental importance of the classical shadow lies. Another tutorial ([Estimation of Quantum State Properties Based on the Classical Shadow](./ClassicalShadow_Application_EN.ipynb)) will continue to introduce the applications of the classical shadow and how to use the shadow function in Paddle Quantum." + ] + }, + { + "cell_type": "markdown", + "id": "through-order", + "metadata": {}, + "source": [ + "## References\n", + "[1] Huang, Hsin-Yuan, Richard Kueng, and John Preskill. \"Predicting many properties of a quantum system from very few measurements.\" [Nature Physics 16.10 (2020): 1050-1057.](https://authors.library.caltech.edu/102787/1/2002.08953.pdf) \n", + "\n", + "[2] Aaronson, Scott. \"Shadow tomography of quantum states.\" [SIAM Journal on Computing 49.5 (2019): STOC18-368.](https://dl.acm.org/doi/abs/10.1145/3188745.3188802) \n", + "\n", + "[3] Bravyi, Sergey, and Dmitri Maslov. \"Hadamard-free circuits expose the structure of the Clifford group.\" [IEEE Transactions on Information Theory 67.7 (2021): 4546-4563.](https://ieeexplore.ieee.org/stamp/stamp.jsp?arnumber=9435351)" + ] + } + ], + "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.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/quantum_simulation/DistributedVQE_CN.ipynb b/tutorials/quantum_simulation/DistributedVQE_CN.ipynb new file mode 100644 index 0000000..6a49c72 --- /dev/null +++ b/tutorials/quantum_simulation/DistributedVQE_CN.ipynb @@ -0,0 +1,574 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "c1a5f1e6", + "metadata": {}, + "source": [ + "# 基于施密特分解的分布式变分量子本征求解器\n", + "\n", + "*Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.*" + ] + }, + { + "cell_type": "markdown", + "id": "cf44390c", + "metadata": { + "tags": [] + }, + "source": [ + "## 概览\n", + "\n", + "在物理和化学等学科中，一个非常重要的问题就是提取分子、原子等物理系统的基态信息。系统的基态是由系统对应的哈密顿量决定的。目前普遍认为量子计算机在求解哈密顿量基态问题上具有优势。[变分量子本征求解器](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html)（variational quantum eigensolver, VQE），作为有望在近期展现量子优势的算法之一，为研究者们提供了可以在含噪的中等规模量子（NISQ）设备上研究量子化学的可能。然而，目前 NISQ 设备仍存在许多局限性，阻碍了大规模量子算法的运行。例如，受限于现有量子设备所能提供的量子比特数，研究者们无法利用 VQE 在 NISQ 设备上模拟真实的大分子。为了突破这一限制，许多分布式方案 [1-3] 相继被提出。\n", + "在本教程中，我们以 [4] 提出的基于施密特分解的 VQE 为例，向读者展示如何利用 Paddle Quantum 实现分布式量子算法。" + ] + }, + { + "cell_type": "markdown", + "id": "f3fcc1b4", + "metadata": {}, + "source": [ + "## 施密特分解\n", + "\n", + "对于任意处于复合系统 $AB$ 上的纯态 $|\\psi\\rangle$，我们有如下平凡分解:\n", + "\n", + "$$\n", + "|\\psi\\rangle=\\sum_{ij}a_{ij}|i\\rangle\\otimes|j\\rangle,\n", + "\\tag{1}\n", + "$$\n", + "\n", + "其中 $|i\\rangle$ 和 $|j\\rangle$ 分别是子系统 $A$、$B$ 上的计算基底，$a_{ij}$ 是某复矩阵 $a$ 的元素。接下来，我们对矩阵 $a$ 运用[奇异值分解](https://zh.wikipedia.org/wiki/奇异值分解)（singular value decomposition, SVD），即，$a = udv$，其中 $u,v$ 是酉矩阵，$d$ 是对角矩阵。那么，$a_{ij}=\\sum_ku_{ik}d_{kk}v_{kj}$。\n", + "\n", + "通过定义 \n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "|k_A\\rangle\\equiv & \\sum_iu_{ik}|i\\rangle=u|k\\rangle,\\\\\n", + "|k_B\\rangle\\equiv & \\sum_jv_{kj}|j\\rangle=v^T|k\\rangle,\\\\\n", + "\\lambda_k\\equiv & d_{kk},\\end{aligned}\n", + "\\tag{2}\n", + "$$\n", + "\n", + "我们可以把（1）式重写为\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + " |\\psi\\rangle &= \\sum_{ijk}u_{ik}d_{kk}v_{kj}|i\\rangle\\otimes|j\\rangle \\\\\n", + " &= \\sum_{k}\\lambda_{k}\\Big(\\sum_iu_{ik}|i\\rangle\\Big)\\otimes\\Big(\\sum_jv_{kj}|j\\rangle\\Big) \\\\\n", + " &=\\sum_{k}\\lambda_k(u|k\\rangle\\otimes v^T|k\\rangle)\\\\\n", + " &=\\sum_{k}\\lambda_k|k_A\\rangle\\otimes|k_B\\rangle.\n", + "\\end{aligned}\n", + "\\tag{3}\n", + "$$\n", + "\n", + "形如 $|\\psi\\rangle=\\sum_k\\lambda_k|k_A\\rangle\\otimes|k_B\\rangle$ 的分解方式就称为 **施密特分解** [5]。同时，$\\{\\lambda_k\\}_k$ 被称作施密特系数，非零 $\\lambda_k$ 的数量被称为 $|\\psi\\rangle$ 的施密特秩。事实上，奇异值分解的性质还保证了 $\\lambda_k\\in\\mathbb{R}^+$ 及 $\\sum_k\\lambda_k^2=1$。" + ] + }, + { + "cell_type": "markdown", + "id": "620e053c", + "metadata": { + "tags": [] + }, + "source": [ + "## 基于施密特分解的分布式 VQE\n", + "\n", + "作为标准 VQE [6] 的一个变种，分布式 VQE 同样试图寻找一个 $N$ 量子比特哈密顿量 $\\hat{H}=\\sum_tc_t\\hat{H}_t^{(A)}\\otimes\\hat{H}_t^{(B)}$ 的基态及其能量，其中 $\\hat{H}_t^{(A)},\\hat{H}_t^{(B)}$ 是分别作用于子系统 $A$、$B$ 上的哈密顿量分量（我们假设 $A$、$B$ 都包含 $N/2$ 量子比特）。\n", + "\n", + "我们从如下试探波函数开始：\n", + "\n", + "$$\n", + "|\\psi\\rangle\\equiv\\sum_{k=1}^S\\lambda_k\\Big(U(\\boldsymbol{\\theta})|k\\rangle\\Big)\\otimes\\Big(V(\\boldsymbol{\\phi})|k\\rangle\\Big)\n", + "\\tag{4},\n", + "$$\n", + "\n", + "其中 $\\boldsymbol{\\lambda}\\equiv(\\lambda_1, \\lambda_2,...,\\lambda_S)^T$，$1\\leq S\\leq 2^{N/2}$ 是一个用户定义的常数。根据施密特分解，目标基态同样可写成（4）式的形式。因此，通过寻找合适的参数向量 $\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}$ 和 $\\boldsymbol{\\phi}$，我们可以在任意误差内近似目标基态。\n", + "\n", + "接下来，对于所有 $i,j=1,...,S$，我们在一台 $N/2$ 量子比特的量子计算机上计算如下项：\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "E_{ijt}^A(\\boldsymbol{\\theta}) &\\equiv \\langle i|U^\\dagger(\\boldsymbol{\\theta}) \\hat{H}_t^{(A)} U(\\boldsymbol{\\theta})|j\\rangle,\\\\\n", + "E_{ijt}^B(\\boldsymbol{\\phi}) &\\equiv \\langle i|V^\\dagger(\\boldsymbol{\\phi}) \\hat{H}_t^{(B)} V(\\boldsymbol{\\phi}))|j\\rangle.\n", + "\\end{aligned}\n", + "\\tag{5}\n", + "$$\n", + "\n", + "然后，在一台经典计算机上，我们根据如下定义构造一个 $S\\times S$ 维的矩阵 $M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$：\n", + "\n", + "$$\n", + "[M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})]_{ij}\\equiv\\sum_tc_tE_{ijt}^A(\\boldsymbol{\\theta})E_{ijt}^B(\\boldsymbol{\\phi}).\n", + "\\tag{6}\n", + "$$\n", + "\n", + "这样，目标基态能量就可以写为 \n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "E_{tar} &= \\min_{\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}} \\langle{\\psi}|\\hat{H}|\\psi\\rangle \\\\\n", + " &= \\min_{\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}}\\Big(\\sum_{i,j=1}^S\\lambda_i\\lambda_j[M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})]_{ij}\\Big)\\\\\n", + " &= \\min_{\\boldsymbol{\\theta}, \\boldsymbol{\\phi}} E(\\boldsymbol{\\theta},\\boldsymbol{\\phi}),\n", + "\\end{aligned}\n", + "\\tag{7}\n", + "$$\n", + "\n", + "其中 $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})\\equiv\\min_{\\boldsymbol{\\lambda}} \\boldsymbol{\\lambda}^T M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})\\boldsymbol{\\lambda}$。根据线性代数的内容，不难发现，$E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ 正是矩阵 $M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ 的最小特征值，可以通过经典算法求得。\n", + "\n", + "最终，我们重复如上过程，并使用基于梯度下降的优化方法最小化 $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$，使其趋近于 $E_{tar}$。\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "f79d3333", + "metadata": { + "tags": [] + }, + "source": [ + "## 量桨实现\n", + "\n", + "首先，我们导入必要的包。由于我们要使用飞桨和量桨的最新功能，请确保您的 *PaddlePaddle* >= 2.2.0 且 *Paddle Quantum* >= 2.2.0。" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "bb7c0db4", + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "import paddle\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.qinfo import pauli_str_to_matrix, schmidt_decompose\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "id": "c84dd264", + "metadata": {}, + "source": [ + "定义一些全局常数：" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "27e4ce36", + "metadata": {}, + "outputs": [], + "source": [ + "N = 10 # 量子比特数\n", + "SEED = 16 # 固定随机种子\n", + "ITR = 100 # 设置迭代次数\n", + "LR = 0.1 # 设置学习率\n", + "D = 3 # 设置量子神经网络的层数" + ] + }, + { + "cell_type": "markdown", + "id": "3db38f56", + "metadata": {}, + "source": [ + "下面这一函数经典地计算出哈密顿量 $H$ 的基态信息（基态对能量和施密特秩），以作为后面量子模型的基准参照。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "32b310ed", + "metadata": {}, + "outputs": [], + "source": [ + "def get_ground_state_info(H):\n", + "\n", + " # 计算 H 的特征值与特征向量\n", + " vals, vecs = paddle.linalg.eigh(H)\n", + " # 获取基态\n", + " ground_state = paddle_quantum.State(vecs[:, 0])\n", + " # 获取基态能量\n", + " ground_state_energy = vals.tolist()[0]\n", + " print(f'The ground state energy is {ground_state_energy:.5f} Ha.')\n", + " # 对基态运用施密特分解\n", + " l, _, _ = schmidt_decompose(ground_state)\n", + " print(f'Schmidt rank of the ground state is {l.size}.')\n", + "\n", + " return ground_state_energy" + ] + }, + { + "cell_type": "markdown", + "id": "8c2c88d3", + "metadata": {}, + "source": [ + "现在，我们生成一个哈密顿量并计算其基态信息。" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6149b4d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The ground state energy is -0.99783 Ha.\n", + "Schmidt rank of the ground state is 3.\n" + ] + } + ], + "source": [ + "# 固定随机种子\n", + "np.random.seed(SEED)\n", + "\n", + "# 硬编码一个哈密顿量\n", + "coefs = [-0.8886258, 0.453882]\n", + "pauli_str = ['x0,z1,z2,z4,x5,y6,y7,x8,x9', 'y0,x1,x2,x3,y4,x5,z6,z7,y8,x9']\n", + "pauli_str_A = ['x0,z1,z2,z4', 'y0,x1,x2,x3,y4'] # 子系统 A 的泡利字符串\n", + "pauli_str_B = ['x0,y1,y2,x3,x4', 'x0,z1,z2,y3,x4'] # 子系统 B 的泡利字符串\n", + "\n", + "# 把相关对象转换为张量形式\n", + "H_mtr = paddle.to_tensor(pauli_str_to_matrix(zip(coefs, pauli_str), n=N))\n", + "coefs = paddle.to_tensor(coefs)\n", + "H_A = [pauli_str_to_matrix([[1., pstr]], n=N//2) for pstr in pauli_str_A]\n", + "H_A = paddle.to_tensor(np.stack(H_A))\n", + "H_B = [pauli_str_to_matrix([[1., pstr]], n=N-N//2) for pstr in pauli_str_B]\n", + "H_B = paddle.to_tensor(np.stack(H_B))\n", + "\n", + "# 计算该哈密顿量的基态信息\n", + "ground_state_energy = get_ground_state_info(H_mtr)" + ] + }, + { + "cell_type": "markdown", + "id": "9abf331c", + "metadata": {}, + "source": [ + "准备好一个哈密顿量后，我们可以构建一个分布式 VQE 来求解它。" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "32cacc67", + "metadata": {}, + "outputs": [], + "source": [ + "# 构造参数化量子电路\n", + "def U_cir(N, D):\n", + " \n", + " cir = Circuit(N) # 初始化一个宽度为 N 量子比特的电路\n", + " cir.complex_entangled_layer('full', N, D) # 添加量子门\n", + " return cir \n", + "\n", + "# 把参数化电路作用在计算基底上\n", + "# 并返回一个形状为 [2**N, num_states] 的张量\n", + "def output_states(num_states, N, cir):\n", + " # 创建 num_states 个计算基底\n", + " basis = paddle.eye(2**N, num_states)\n", + "\n", + " # 获取参数化电路的矩阵\n", + " U = cir.unitary_matrix()\n", + " \n", + " # 把参数化电路作用在这些基底上\n", + " vec = U @ basis \n", + " \n", + " return vec" + ] + }, + { + "cell_type": "markdown", + "id": "0ca5787c", + "metadata": {}, + "source": [ + "以下代码是本教程的核心。请读者仔细阅读，并与前文的公式叙述做比较。" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "6ebf5159", + "metadata": {}, + "outputs": [], + "source": [ + "# 构造分布式模型\n", + "class DistributedVQE(paddle.nn.Layer):\n", + " def __init__(self, N, D, S):\n", + " super().__init__()\n", + " paddle.seed(SEED)\n", + "\n", + " self.S = S # 定义常数 S\n", + " self.N = N\n", + " self.cir = [U_cir(N//2, D), U_cir(N - N//2, D)]\n", + " \n", + " # 分布式 VQE 的核心逻辑\n", + " def forward(self):\n", + " # 分别获得子系统 A、B 上的 U|k> 和 V|k> \n", + " vec_A = output_states(self.S, self.N//2, self.cir[0])\n", + " vec_B = output_states(self.S, self.N - self.N//2, self.cir[1])\n", + " \n", + " # 计算由前文定义的 E_{ijt}^A 和 E_{ijt}^B 组成的张量 E_A, E_B\n", + " E_A = vec_A.conj().t() @ H_A @ vec_A\n", + " E_B = vec_B.conj().t() @ H_B @ vec_B\n", + " M = (coefs.reshape([-1, 1, 1]) * E_A * E_B).sum(0)\n", + "\n", + " # 计算矩阵 M 的最小特征值\n", + " eigval = paddle.linalg.eigvalsh(M)\n", + " loss = eigval[0]\n", + " \n", + " return loss" + ] + }, + { + "cell_type": "markdown", + "id": "d04669ff", + "metadata": {}, + "source": [ + "定义训练函数。" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "066f5e72", + "metadata": {}, + "outputs": [], + "source": [ + "def train(model):\n", + " start_time = time.time() # 用以计算该函数的运行时长\n", + " params = sum([cir.parameters() for cir in model.cir], [])\n", + " # 我们使用基于梯度下降的优化器 Adam 来优化 theta 和 phi\n", + " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=params)\n", + " summary_loss = [] # 记录损失历史\n", + "\n", + " # 迭代优化\n", + " for itr in range(ITR):\n", + " # 前向传播，计算损失函数\n", + " loss = model()\n", + " # 后向传播，优化损失函数\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + " # 更新优化结果\n", + " summary_loss.append(loss.numpy())\n", + " # 打印中间结果\n", + " if (itr+1) % 20 == 0:\n", + " print(f\"iter: {itr+1}, loss: {loss.tolist()[0]: .4f} Ha\")\n", + "\n", + " print(f'Ground truth is {ground_state_energy:.4f} Ha')\n", + " print(f'Training took {time.time() - start_time:.2f}s')\n", + " \n", + " plt.plot(list(range(ITR)), summary_loss, color='r', label='loss')\n", + " plt.hlines(y=ground_state_energy, xmin=0, xmax=ITR, linestyle=':', label='ground truth')\n", + " plt.legend()\n", + " plt.title(f'Loss for {type(model).__name__} on a {N}-qubit Hamiltonian')\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "c8770b19", + "metadata": {}, + "source": [ + "现在，我们实例化并训练分布式模型。" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "78b46dcc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 20, loss: -0.9244 Ha\n", + "iter: 40, loss: -0.9906 Ha\n", + "iter: 60, loss: -0.9968 Ha\n", + "iter: 80, loss: -0.9977 Ha\n", + "iter: 100, loss: -0.9978 Ha\n", + "Ground truth is -0.9978 Ha\n", + "Training took 11.81s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 注意，由于我们构造的哈密顿量在两子系统间相互作用较小，我们只需设置 S = 4.\n", + "#（更多解释请见总结部分）\n", + "vqe = DistributedVQE(N, D, S=4)\n", + "train(vqe)" + ] + }, + { + "cell_type": "markdown", + "id": "9eb85055", + "metadata": {}, + "source": [ + "在上图中，我们用虚线画出了真实的基态能量。可以看到，loss 曲线收敛至虚线，表明我们的分布式 VQE 成功找到了该哈密顿量的基态能量。然而，要妥当地评估我们的模型，我们还需将它与标准 VQE 做比较。因此，下面我们构建标准 VQE 模型：" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "2fff9166", + "metadata": {}, + "outputs": [], + "source": [ + "class StandardVQE(paddle.nn.Layer):\n", + " def __init__(self, N, D, S):\n", + " super().__init__()\n", + " paddle.seed(SEED)\n", + " self.N = N\n", + " self.S = S\n", + " self.cir = [U_cir(N, D)]\n", + " \n", + " def forward(self):\n", + " vec = output_states(self.S, self.N, self.cir[0])\n", + " loss = vec.conj().t() @ H_mtr @ vec\n", + " return loss.cast('float64').flatten()" + ] + }, + { + "cell_type": "markdown", + "id": "8bc5dcfd", + "metadata": {}, + "source": [ + "实例化并训练标准 VQE。" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "a35f3eb4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 20, loss: -0.8365 Ha\n", + "iter: 40, loss: -0.9852 Ha\n", + "iter: 60, loss: -0.9958 Ha\n", + "iter: 80, loss: -0.9975 Ha\n", + "iter: 100, loss: -0.9978 Ha\n", + "Ground truth is -0.9978 Ha\n", + "Training took 2252.27s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "svqe = StandardVQE(N, D, S=1)\n", + "train(svqe) # 训练标准 VQE" + ] + }, + { + "cell_type": "markdown", + "id": "5688a618", + "metadata": {}, + "source": [ + "有趣的是，通过比较两个模型的运行时间，我们发现，分布式 VQE 的运行速度比标准 VQE 快了一百多倍！事实上，这很容易理解：在分布式模型中，我们只需模拟两个 $N/2$ 量子比特的酉变换，这无论在时间还是空间上，都比标准 VQE 中模拟一个 $N$ 量子比特的酉变换高效得多。" + ] + }, + { + "cell_type": "markdown", + "id": "94cda668", + "metadata": { + "tags": [] + }, + "source": [ + "## 总结\n", + "\n", + "在此教程中，我们构造了一个分布式 VQE 并展示了其部分优势：\n", + "- NISQ 设备的计算范围得以拓展。通过分布式策略，我们可以运行超过硬件量子比特数的量子算法。\n", + "- 计算效率得到提升。对于量子过程的经典模拟而言，分布式算法降低了酉矩阵的维度，因此降低了模拟这些矩阵所需的时间、空间消耗。\n", + "\n", + "同时，需要注意的是，用户定义的常数 $S$ 在训练准确度和效率上扮演了重要角色：\n", + "- 对于子系统间相互作用弱的哈密顿量而言，其基态在子系统间纠缠较弱 [7]。因此，其施密特秩较低，可以被一个较小的 $S$ 精确且高效地模拟。事实上，我们所给的演示及大多数物理、化学中有意义的哈密顿量都具有此性质。\n", + "- 相反的，对于子系统间相互作用强的哈密顿量而言，其基态在子系统间纠缠较强，因此需要一个较大的 $S$ 来模拟。但是，无论如何，$S$ 的上界是 $2^{N/2}$，因此矩阵 $M$ 的维度上界是 $2^{N/2}\\times2^{N/2}$，这仍然比初始哈密顿量的维度（$2^{N}\\times 2^{N}$）小。因此，该算法的效率总是优于纯经典模拟。" + ] + }, + { + "cell_type": "markdown", + "id": "922679aa", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "_______\n", + "\n", + "# 参考文献\n", + "\n", + "[1] Fujii, Keisuke, et al. \"Deep Variational Quantum Eigensolver: a divide-and-conquer method for solving a larger problem with smaller size quantum computers.\" [arXiv preprint arXiv:2007.10917 (2020)](https://arxiv.org/abs/2007.10917).\n", + "\n", + "[2] Zhang, Yu, et al. \"Variational Quantum Eigensolver with Reduced Circuit Complexity.\" [arXiv preprint arXiv:2106.07619 (2021)](https://arxiv.org/abs/2106.07619).\n", + "\n", + "[3] Peng, Tianyi et al. \"Simulating Large Quantum Circuits On A Small Quantum Computer\". [Physical Review Letters 125.15, (2020): 150504](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.125.150504).\n", + "\n", + "[4] Eddins, Andrew, et al. \"Doubling the size of quantum simulators by entanglement forging.\" [arXiv preprint arXiv:2104.10220 (2021)](https://arxiv.org/abs/2104.10220).\n", + "\n", + "[5] Nielsen, Michael A., and Isaac L. Chuang. Quantum Computation and Quantum Information. Cambridge University Press, 2010.\n", + "\n", + "[6] Moll, Nikolaj, et al. \"Quantum optimization using variational algorithms on near-term quantum devices.\" [Quantum Science and Technology 3.3 (2018): 030503](https://iopscience.iop.org/article/10.1088/2058-9565/aab822).\n", + "\n", + "[7] Khatri, Sumeet, and Mark M. Wilde. \"Principles of quantum communication theory: A modern approach.\" [arXiv preprint arXiv:2011.04672 (2020)](https://arxiv.org/abs/2011.04672)." + ] + } + ], + "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.8.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/quantum_simulation/DistributedVQE_EN.ipynb b/tutorials/quantum_simulation/DistributedVQE_EN.ipynb new file mode 100644 index 0000000..7c4b2a4 --- /dev/null +++ b/tutorials/quantum_simulation/DistributedVQE_EN.ipynb @@ -0,0 +1,547 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Distributed Variational Quantum Eigensolver Based on Schmidt Decomposition\n", + "*Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.*" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Overview\n", + "\n", + "Retrieving ground state information of a Hamiltonian is amongst the essential questions in physics and chemistry. Currently, it is widely believed that quantum computers are advantageous in solving this kind of problem. As one of the promising algorithms to demonstrate quantum supremacy in the near term, [Variational Quantum Eigensolver (VQE)](https://qml.baidu.com/tutorials/quantum-simulation/variational-quantum-eigensolver.html)\n", + "enables the study of quantum chemistry on Noisy Intermediate-Scale Quantum (NISQ) devices. However, various technical limitations still exist on current NISQ hardware, forbidding the deployment of large-scale quantum algorithms. For example, limited by the number of available qubits, researchers have not been able to simulate realistic large molecules with high precision. To overcome this barrier, researchers have proposed a wide range of distributed strategies [1-3]. In this tutorial, we take the distributed VQE based on Schmidt decomposition, proposed in [4], as an example to demonstrate how to implement distributed quantum algorithms using Paddle Quantum." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Schmidt Decomposition\n", + "We start with the following trivial decomposition for any pure state $|\\psi\\rangle$ of a composite system $AB$:\n", + "\n", + "$$\n", + "|\\psi\\rangle=\\sum_{ij}a_{ij}|i\\rangle\\otimes|j\\rangle,\n", + "\\tag{1}\n", + "$$\n", + "\n", + "where $|i\\rangle$ and $|j\\rangle$ are computational bases of subsystems $A$ and $B$ respectively, and $a_{ij}$ are elements of some complex matrix $a$. Then, we apply [singular value decomposition (SVD)](https://en.wikipedia.org/wiki/Singular_value_decomposition)\n", + "on $a$, i.e., $a = udv$ with $u,v$ being unitary and $d$ diagonal. Hence, $a_{ij}=\\sum_ku_{ik}d_{kk}v_{kj}$. \n", + "\n", + "By defining\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "|k_A\\rangle\\equiv & \\sum_iu_{ik}|i\\rangle=u|k\\rangle,\\\\\n", + "|k_B\\rangle\\equiv & \\sum_jv_{kj}|j\\rangle=v^T|k\\rangle,\\\\\n", + "\\lambda_k\\equiv & d_{kk},\n", + "\\end{aligned}\n", + "\\tag{2}\n", + "$$\n", + "\n", + "we may rewrite Eq. (1) as\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + " |\\psi\\rangle &= \\sum_{ijk}u_{ik}d_{kk}v_{kj}|i\\rangle\\otimes|j\\rangle \\\\\n", + " &= \\sum_{k}\\lambda_{k}\\Big(\\sum_iu_{ik}|i\\rangle\\Big)\\otimes\\Big(\\sum_jv_{kj}|j\\rangle\\Big) \\\\\n", + " &=\\sum_{k}\\lambda_k(u|k\\rangle\\otimes v^T|k\\rangle)\\\\\n", + " &=\\sum_{k}\\lambda_k|k_A\\rangle\\otimes|k_B\\rangle.\n", + "\\end{aligned}\n", + "\\tag{3}\n", + "$$\n", + "\n", + "The decomposition of $|\\psi\\rangle$ into the form of $\\sum_k\\lambda_k|k_A\\rangle\\otimes|k_B\\rangle$ is known as its ***Schmidt decomposition*** [5], with $\\{\\lambda_k\\}_k$ called the *Schmidt coefficients* and the number of non-zero $\\lambda_k$'s its *Schmidt rank*. In fact, the property of SVD also guarantees that $\\lambda_k\\in\\mathbb{R}^+$ and $\\sum_k\\lambda_k^2=1$. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Distributed VQE Based on Schmidt Decomposition\n", + "\n", + "As a variation of the standard VQE [6], the distributed VQE also seeks to solve the ground state and its energy of an $N$-qubit Hamiltonian $\\hat{H}=\\sum_tc_t\\hat{H}_t^{(A)}\\otimes\\hat{H}_t^{(B)}$， where $\\hat{H}_t^{(A)},\\hat{H}_t^{(B)}$ are Hamiltonian terms on subsystems $A,B$ respectively (we have assumed that $A$, $B$ both have $N/2$ qubits).\n", + "\n", + "To start with, we write the trial wave function as\n", + "\n", + "$$\n", + "|\\psi\\rangle\\equiv\\sum_{k=1}^S\\lambda_k\\Big(U(\\boldsymbol{\\theta})|k\\rangle\\Big)\\otimes\\Big(V(\\boldsymbol{\\phi})|k\\rangle\\Big),\n", + "\\tag{4}\n", + "$$\n", + "\n", + "for some $\\boldsymbol{\\lambda}\\equiv(\\lambda_1, \\lambda_2,...,\\lambda_S)^T$ and $1\\leq S\\leq 2^{N/2}$ a user-defined constant. According to Schmidt decomposition, the target ground state also has the form of Eq. (4) and hence can be approximated with high precision by choosing appropriate parameters $\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}$ and $\\boldsymbol{\\phi}$.\n", + "\n", + "Now, for all $i,j=1,...,S$, we evaluate the following terms on an $N/2$-qubit quantum computer:\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "E_{ijt}^A(\\boldsymbol{\\theta}) &\\equiv \\langle i|U^\\dagger(\\boldsymbol{\\theta}) \\hat{H}_t^{(A)} U(\\boldsymbol{\\theta})|j\\rangle,\\\\\n", + "E_{ijt}^B(\\boldsymbol{\\phi}) &\\equiv \\langle i|V^\\dagger(\\boldsymbol{\\phi}) \\hat{H}_t^{(B)} V(\\boldsymbol{\\phi}))|j\\rangle.\n", + "\\end{aligned}\n", + "\\tag{5}\n", + "$$\n", + "\n", + "Then, on a classical computer, we construct an $S\\times S$ dimensional matrix $M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ according to\n", + "\n", + "$$\n", + "[M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})]_{ij}\\equiv\\sum_tc_tE_{ijt}^A(\\boldsymbol{\\theta})E_{ijt}^B(\\boldsymbol{\\phi}).\n", + "\\tag{6}\n", + "$$\n", + "\n", + "In this way, the target ground state energy can be written as \n", + "$$\n", + "\\begin{aligned}\n", + "E_{tar} &= \\min_{\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}} \\langle{\\psi}|\\hat{H}|\\psi\\rangle \\\\\n", + " &= \\min_{\\boldsymbol{\\lambda}, \\boldsymbol{\\theta}, \\boldsymbol{\\phi}}\\Big(\\sum_{i,j=1}^S\\lambda_i\\lambda_j[M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})]_{ij}\\Big)\\\\\n", + " &= \\min_{\\boldsymbol{\\theta}, \\boldsymbol{\\phi}} E(\\boldsymbol{\\theta},\\boldsymbol{\\phi}),\n", + "\\end{aligned}\n", + "\\tag{7}\n", + "$$\n", + "\n", + "where $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})\\equiv\\min_{\\boldsymbol{\\lambda}} \\boldsymbol{\\lambda}^T M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})\\boldsymbol{\\lambda}$. By linear algebra, we see that $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ is exactly the minimal eigenvalue of $M(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$, which can be solved using classical algorithms.\n", + "\n", + "Finally, we repeat the whole process and minimize $E(\\boldsymbol{\\theta},\\boldsymbol{\\phi})$ to approximate $E_{tar}$ using gradient-based optimization methods." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Paddle Quantum implementation\n", + "\n", + "First of all, we import necessary packages. Please make sure that you have *PaddlePaddle* >= 2.2.0 and *Paddle Quantum* >= 2.2.0, as we will use some of their latest features." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import time\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "import paddle\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.qinfo import pauli_str_to_matrix, schmidt_decompose\n", + "import warnings\n", + "\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define some global constants:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "N = 10 # Number of qubits\n", + "SEED = 16 # Fix a random seed\n", + "ITR = 100 # Set the number of learning iterations\n", + "LR = 0.1 # Set the learning rate\n", + "D = 3 # Set the depth for QNN" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following function classically calculates the ground state information (the energy and the Schmidt rank of the ground state) of a Hamiltonian $H$, which we will use as the ground truth to benchmark our quantum models." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def get_ground_state_info(H):\n", + "\n", + " # Calculate the eigenvalues and eigenvectors of H\n", + " vals, vecs = paddle.linalg.eigh(H)\n", + " # Retrieve the ground state\n", + " ground_state = paddle_quantum.State(vecs[:, 0])\n", + " # Retrieve the ground state energy\n", + " ground_state_energy = vals.tolist()[0]\n", + " print(f'The ground state energy is {ground_state_energy:.5f} Ha.')\n", + " # Run Schmidt decomposition on the ground state.\n", + " l, _, _ = schmidt_decompose(ground_state)\n", + " print(f'Schmidt rank of the ground state is {l.size}.')\n", + "\n", + " return ground_state_energy" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we generate a Hamiltonian and calculate its ground state information." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The ground state energy is -0.99783 Ha.\n", + "Schmidt rank of the ground state is 32.\n" + ] + } + ], + "source": [ + "# Fix a random seed\n", + "np.random.seed(SEED)\n", + "\n", + "# Hard code a random a Hamiltonian\n", + "coefs = [-0.8886258, 0.453882]\n", + "pauli_str = ['x0,z1,z2,z4,x5,y6,y7,x8,x9', 'y0,x1,x2,x3,y4,x5,z6,z7,y8,x9']\n", + "pauli_str_A = ['x0,z1,z2,z4', 'y0,x1,x2,x3,y4'] # pauli substring for system A\n", + "pauli_str_B = ['x0,y1,y2,x3,x4', 'x0,z1,z2,y3,x4'] # pauli substring for system B\n", + "\n", + "# Convert relavent object into Tensor form\n", + "H_mtr = paddle.to_tensor(pauli_str_to_matrix(zip(coefs, pauli_str), n=N))\n", + "coefs = paddle.to_tensor(coefs)\n", + "H_A = [pauli_str_to_matrix([[1., pstr]], n=N//2) for pstr in pauli_str_A]\n", + "H_A = paddle.to_tensor(np.stack(H_A))\n", + "H_B = [pauli_str_to_matrix([[1., pstr]], n=N-N//2) for pstr in pauli_str_B]\n", + "H_B = paddle.to_tensor(np.stack(H_B))\n", + "\n", + "# calculate the ground state information\n", + "ground_state_energy = get_ground_state_info(H_mtr)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we have prepared a Hamiltonian, we may build a distributed VQE to solve it." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Construct parameterized circuit\n", + "def U_cir(N, D):\n", + " \n", + " cir = Circuit(N) # Initialize an N-qubit-width circuit\n", + " cir.complex_entangled_layer('full', N, D) # Add quantum gates\n", + " return cir \n", + "\n", + "# Apply a parameterized circuit on the conputational bases\n", + "# and return a tensor of shape [2**N, num_states]\n", + "def output_states(num_states, N, cir):\n", + " # Create num_states-many computational bases\n", + " basis = paddle.eye(2**N, num_states)\n", + " \n", + " # Acquire a matrix of the parameterized circuit\n", + " U = cir.unitary_matrix()\n", + " \n", + " # Apply the parameterized circuit on these bases\n", + " vec = U @ basis \n", + " \n", + " return vec" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The code below is core to this tutorial. Please compare them with the formulae given in the beginning section and make sure that they are well understood." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Construct the distributed model\n", + "class DistributedVQE(paddle.nn.Layer):\n", + " def __init__(self, N, D, S):\n", + " super().__init__()\n", + " paddle.seed(SEED)\n", + "\n", + " self.S = S # Define constant S\n", + " self.N = N\n", + " self.cir = [U_cir(N//2, D), U_cir(N - N//2, D)]\n", + " \n", + " # The core logic of distributed VQE\n", + " def forward(self):\n", + " # Obtain U|k> and V|k> for subsystems A and B respectively \n", + " vec_A = output_states(self.S, self.N//2, self.cir[0])\n", + " vec_B = output_states(self.S, self.N - self.N//2, self.cir[1])\n", + " \n", + " # Calculate tensor E_A, E_B, which have elements E_{ijt}^A and E_{ijt}^B, as per defined in above\n", + " E_A = vec_A.conj().t() @ H_A @ vec_A\n", + " E_B = vec_B.conj().t() @ H_B @ vec_B\n", + " M = (coefs.reshape([-1, 1, 1]) * E_A * E_B).sum(0)\n", + "\n", + " # Find the minimal eigenvalue of M\n", + " eigval = paddle.linalg.eigvalsh(M)\n", + " loss = eigval[0]\n", + " \n", + " return loss" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define training function." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "def train(model):\n", + " start_time = time.time() # To calculate the running time of this function\n", + " params = sum([cir.parameters() for cir in model.cir], [])\n", + " # We will use Adam, a gradient-based optimizer to optimize theta and phi\n", + " opt = paddle.optimizer.Adam(learning_rate=LR, parameters=params)\n", + " summary_loss = [] # Save loss history\n", + "\n", + " # Optimization iteration\n", + " for itr in range(ITR):\n", + " # Forward propagation to calculates the loss function\n", + " loss = model()\n", + " # Backward propagation to optimize the loss function\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + " # Update optimization result\n", + " summary_loss.append(loss.numpy())\n", + " # Print itermediary result\n", + " if (itr+1) % 20 == 0:\n", + " print(f\"iter: {itr+1}, loss: {loss.tolist()[0]: .4f} Ha\")\n", + "\n", + " print(f'Ground truth is {ground_state_energy:.4f} Ha')\n", + " print(f'Training took {time.time() - start_time:.2f}s')\n", + " \n", + " plt.plot(list(range(ITR)), summary_loss, color='r', label='loss')\n", + " plt.hlines(y=ground_state_energy, xmin=0, xmax=ITR, linestyle=':', label='ground truth')\n", + " plt.legend()\n", + " plt.title(f'Loss for {type(model).__name__} on a {N}-qubit Hamiltonian')\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, we are ready to instantiate the model and train it!" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 20, loss: -0.9244 Ha\n", + "iter: 40, loss: -0.9906 Ha\n", + "iter: 60, loss: -0.9968 Ha\n", + "iter: 80, loss: -0.9977 Ha\n", + "iter: 100, loss: -0.9978 Ha\n", + "Ground truth is -0.9978 Ha\n", + "Training took 7.24s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Note that we manually set S = 4 as the Hamiltonian we just created interacts weakly across the subsystems.\n", + "# (See the Conclusion section for further description)\n", + "vqe = DistributedVQE(N, D, S=4)\n", + "train(vqe)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have plotted the actual ground state energy as a dotted line in the figure above. We see that the loss curve converges to the dotted line, meaning that our distributed VQE successfully found the ground state energy of the Hamiltonian. However, to properly evaluate our model, we need to compare it with the standard VQE, which we build below:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "class StandardVQE(paddle.nn.Layer):\n", + " def __init__(self, N, D, S):\n", + " super().__init__()\n", + " paddle.seed(SEED)\n", + " self.N = N\n", + " self.S = S\n", + " self.cir = [U_cir(N, D)]\n", + "\n", + " def forward(self):\n", + " vec = output_states(self.S, self.N, self.cir[0])\n", + " loss = vec.conj().t() @ H_mtr @ vec\n", + " return loss.cast('float64').flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Instantiate and train the StandardVQE." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 20, loss: -0.8365 Ha\n", + "iter: 40, loss: -0.9852 Ha\n", + "iter: 60, loss: -0.9958 Ha\n", + "iter: 80, loss: -0.9975 Ha\n", + "iter: 100, loss: -0.9978 Ha\n", + "Ground truth is -0.9978 Ha\n", + "Training took 1278.13s\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "svqe = StandardVQE(N, D, S=1)\n", + "train(svqe) # Train the standard VQE " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Interestingly, by comparing the running time of the two models, we find that the distributed model runs 100 times faster than the standard VQE! In fact, this is easy to understand: in a distributed model, we only need to simulate two $N/2$-qubit unitary transformations, which is, of course, much more time- and space-efficient than simulating an $N$-qubit unitary transformation in the standard VQE." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "## Conclusion\n", + "\n", + "In this tutorial, we built a distributed VQE and demonstrated some of its advantages:\n", + "- The capability of NISQ devices is expanded. Distributed strategies enable the deployment of quantum algorithms which require qubits that exceed the capability of current hardware.\n", + "- The computation efficiency is improved. For classical simulation of quantum processes, distributed algorithms reduce the dimension of unitary matrices, hence reducing the space and time cost for simulating them.\n", + "\n", + "In the meantime, one must note that $S$, as a user-defined constant, plays a key role in the training accuracy and efficiency:\n", + "- For Hamiltonians which encode weak inter-subsystem interactions, their ground states are weakly entangled across the subsystems [7]. Hence, the Schmidt ranks are small and can be accurately and efficiently simulated by a small $S$. In fact, our example and most physically and chemically interesting Hamiltonians fall into this category.\n", + "- In contrast, for Hamiltonians which encode strong inter-subsystem interactions, their ground states are strongly entangled. Hence, a large $S$ may be required. But anyway, $S$ is upper-bounded by $2^{N/2}$ and thus the dimension of $M$ is upper-bounded by $2^{N/2}\\times2^{N/2}$, which is still much smaller than the dimension of the initial Hamiltonian ($2^{N}\\times 2^{N}$). Consequently, the efficiency of this algorithm is always better than the purely classical simulation." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "jp-MarkdownHeadingCollapsed": true, + "tags": [] + }, + "source": [ + "_______\n", + "\n", + "# References\n", + "\n", + "[1] Fujii, Keisuke, et al. \"Deep Variational Quantum Eigensolver: a divide-and-conquer method for solving a larger problem with smaller size quantum computers.\" [arXiv preprint arXiv:2007.10917 (2020)](https://arxiv.org/abs/2007.10917).\n", + "\n", + "[2] Zhang, Yu, et al. \"Variational Quantum Eigensolver with Reduced Circuit Complexity.\" [arXiv preprint arXiv:2106.07619(2021)](https://arxiv.org/abs/2106.07619).\n", + "\n", + "[3] Peng, Tianyi et al. \"Simulating Large Quantum Circuits On A Small Quantum Computer\". [Physical Review Letters 125.15, (2020): 150504](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.125.150504).\n", + "\n", + "[4] Eddins, Andrew, et al. \"Doubling the size of quantum simulators by entanglement forging.\" [arXiv preprint arXiv:2104.10220 (2021)](https://arxiv.org/abs/2104.10220).\n", + "\n", + "[5] Nielsen, Michael A., and Isaac L. Chuang. Quantum Computation and Quantum Information. Cambridge University Press, 2010.\n", + "\n", + "[6] Moll, Nikolaj, et al. \"Quantum optimization using variational algorithms on near-term quantum devices.\" [Quantum Science and Technology 3.3 (2018): 030503](https://iopscience.iop.org/article/10.1088/2058-9565/aab822).\n", + "\n", + "[7] Khatri, Sumeet, and Mark M. Wilde. \"Principles of quantum communication theory: A modern approach.\" [arXiv preprint arXiv:2011.04672 (2020)](https://arxiv.org/abs/2011.04672)." + ] + } + ], + "metadata": { + "interpreter": { + "hash": "9043b12ec77a531919bc05f05830335d23baf822720cbea14b03018197d26545" + }, + "kernelspec": { + "display_name": "Python 3.8.0 ('paddle-quantum-dev')", + "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.8.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/quantum_simulation/GibbsState_CN.ipynb b/tutorials/quantum_simulation/GibbsState_CN.ipynb similarity index 79% rename from tutorial/quantum_simulation/GibbsState_CN.ipynb rename to tutorials/quantum_simulation/GibbsState_CN.ipynb index d49c0cd..6f8936d 100644 --- a/tutorial/quantum_simulation/GibbsState_CN.ipynb +++ b/tutorials/quantum_simulation/GibbsState_CN.ipynb @@ -71,7 +71,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:55:59.838299Z", @@ -81,14 +81,12 @@ "outputs": [], "source": [ "import scipy\n", - "from numpy import array, concatenate, zeros\n", - "from numpy import pi as PI\n", - "from numpy import trace as np_trace\n", "import paddle\n", - "from paddle import matmul, trace, real\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.state import density_op\n", - "from paddle_quantum.utils import state_fidelity, partial_trace, pauli_str_to_matrix" + "from numpy import trace as np_trace\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.state import zero_state, State\n", + "from paddle_quantum.qinfo import state_fidelity, partial_trace, pauli_str_to_matrix" ] }, { @@ -148,14 +146,14 @@ "H = [[-1.0, 'z0,z1'], [-1.0, 'z1,z2'], [-1.0, 'z0,z2']]\n", "\n", "# 生成哈密顿量的矩阵信息\n", - "hamiltonian = pauli_str_to_matrix(H, N_SYS_B)\n", + "hamiltonian = pauli_str_to_matrix(H, N_SYS_B).numpy()\n", "\n", "# 生成理想情况下的目标吉布斯态 rho\n", "rho_G = scipy.linalg.expm(-1 * beta * hamiltonian) / np_trace(scipy.linalg.expm(-1 * beta * hamiltonian))\n", "\n", "# 设置成 Paddle quantum 所支持的数据类型\n", - "hamiltonian = hamiltonian.astype(\"complex128\")\n", - "rho_G = rho_G.astype(\"complex128\")" + "hamiltonian = hamiltonian.astype(\"complex64\")\n", + "rho_G = paddle.to_tensor(rho_G, dtype=\"complex64\")" ] }, { @@ -178,7 +176,7 @@ "- 初始化其中的变量参数，$\\theta$ 代表我们量子神经网络中的参数组成的向量。\n", " \n", "\n", - "接下来我们根据上图中的电路设计，通过 Paddle Quantum 的 `UAnsatz` 类和内置的 `real_entangled_layer(theta, D)` 电路模板来高效搭建量子神经网络。" + "接下来我们根据上图中的电路设计，通过 Paddle Quantum 的 `Circuit` 类和内置的 `real_entangled_layer` 电路模板来高效搭建量子神经网络。" ] }, { @@ -192,25 +190,19 @@ }, "outputs": [], "source": [ - "def U_theta(initial_state, theta, N, D):\n", + "def U_theta(num_qubits: int, depth: int) -> Circuit:\n", " \"\"\"\n", " 量子神经网络\n", " \"\"\"\n", - " \n", - " # 按照量子比特数量/网络宽度初始化量子神经网络\n", - " cir = UAnsatz(N)\n", + " cir = Circuit(num_qubits)\n", " \n", " # 内置的 {R_y + CNOT} 电路模板\n", - " cir.real_entangled_layer(theta[:D], D)\n", + " cir.real_entangled_layer(depth=depth)\n", " \n", " # 铺上最后一层 R_y 旋转门\n", - " for i in range(N):\n", - " cir.ry(theta=theta[D][i][0], which_qubit=i)\n", - " \n", - " # 量子神经网络作用在给定的初始态上\n", - " final_state = cir.run_density_matrix(initial_state)\n", - "\n", - " return final_state, cir" + " cir.ry()\n", + " \n", + " return cir" ] }, { @@ -249,37 +241,24 @@ }, "outputs": [], "source": [ - "class Net(paddle.nn.Layer):\n", - " def __init__(self, shape, dtype='float64'):\n", - " super(Net, self).__init__()\n", - " \n", - " # 初始化 theta 参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " self.theta = self.create_parameter(shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # 初始化 rho = |0..0><0..0| 的密度矩阵\n", - " self.initial_state = paddle.to_tensor(density_op(N))\n", - "\n", - " # 定义损失函数和前向传播机制\n", - " def forward(self, H, N, N_SYS_B, D):\n", - "\n", - " # 施加量子神经网络\n", - " rho_AB, cir = U_theta(self.initial_state, self.theta, N, D)\n", - "\n", - " # 计算偏迹 partial trace 来获得子系统B所处的量子态 rho_B\n", - " rho_B = partial_trace(rho_AB, 2 ** (N - N_SYS_B), 2 ** (N_SYS_B), 1)\n", - " \n", - " # 计算三个子损失函数\n", - " rho_B_squre = matmul(rho_B, rho_B)\n", - " loss1 = real(trace(matmul(rho_B, H)))\n", - " loss2 = real(trace(rho_B_squre)) * 2 / beta\n", - " loss3 = -(real(trace(matmul(rho_B_squre, rho_B))) + 3) / (2 * beta)\n", - " \n", - " # 最终的损失函数\n", - " loss = loss1 + loss2 + loss3 \n", - "\n", - " return loss, rho_B, cir" + " # 定义损失函数\n", + "def loss_func(cir: Circuit, Hamiltonian: paddle.Tensor, N_SYS_B: int) -> paddle.Tensor:\n", + " # 施加量子神经网络\n", + " rho_AB = cir(zero_state(N))\n", + " \n", + " # 计算偏迹 partial trace 来获得子系统B所处的量子态 rho_B\n", + " rho_B = partial_trace(rho_AB, 2 ** (N - N_SYS_B), 2 ** (N_SYS_B), 1)\n", + " \n", + " # 计算三个子损失函数\n", + " rho_B_squre = rho_B @ rho_B\n", + " loss1 = paddle.real(paddle.trace(rho_B @ Hamiltonian))\n", + " loss2 = paddle.real(paddle.trace(rho_B_squre)) * 2 / beta\n", + " loss3 = -(paddle.real(paddle.trace(rho_B_squre @ rho_B)) + 3) / (2 * beta)\n", + " \n", + " # 最终的损失函数\n", + " loss = loss1 + loss2 + loss3 \n", + " \n", + " return loss, rho_B" ] }, { @@ -343,42 +322,45 @@ "name": "stdout", "output_type": "stream", "text": [ - "iter: 10 loss: -3.1085 fid: 0.9241\n", + "iter: 10 loss: -3.1084 fid: 0.9241\n", "iter: 20 loss: -3.3375 fid: 0.9799\n", "iter: 30 loss: -3.3692 fid: 0.9897\n", "iter: 40 loss: -3.3990 fid: 0.9929\n", "iter: 50 loss: -3.4133 fid: 0.9959\n", "\n", - "训练后的电路：\n", - "--Ry(6.262)----*--------------X----Ry(0.747)--\n", + "训练后的电路: \n", + "--Ry(6.290)----*--------------x----Ry(0.260)--\n", " | | \n", - "--Ry(4.710)----X----*---------|----Ry(6.253)--\n", + "--Ry(4.745)----x----*---------|----Ry(6.249)--\n", " | | \n", - "--Ry(-0.01)---------X----*----|----Ry(-0.03)--\n", + "--Ry(-0.01)---------x----*----|----Ry(-0.05)--\n", " | | \n", - "--Ry(-0.00)--------------X----*----Ry(6.312)--\n", + "--Ry(0.017)--------------x----*----Ry(6.310)--\n", " \n" ] } ], "source": [ "paddle.seed(SEED)\n", + "\n", + "# 设置计算模式为密度矩阵模式\n", + "paddle_quantum.set_backend(backend='density_matrix')\n", " \n", "# 我们需要将 Numpy array 转换成 Paddle 中支持的 Tensor\n", "H = paddle.to_tensor(hamiltonian)\n", "\n", "# 确定网络的参数维度\n", - "net = Net(shape=[D + 1, N, 1])\n", + "circuit = U_theta(N, D)\n", "\n", "# 一般来说，我们利用 Adam 优化器来获得相对好的收敛，\n", "# 当然你可以改成 SGD 或者是 RMS prop.\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=circuit.parameters())\n", "\n", "# 优化循环\n", "for itr in range(1, ITR + 1):\n", " \n", " # 前向传播计算损失函数并返回生成的量子态 rho_B\n", - " loss, rho_B, cir = net(H, N, N_SYS_B, D)\n", + " loss, rho_B = loss_func(circuit, H, N_SYS_B)\n", " \n", " # 反向传播极小化损失函数\n", " loss.backward()\n", @@ -386,15 +368,14 @@ " opt.clear_grad()\n", "\n", " # 转换成 Numpy array 用以计算量子态的保真度 F(rho_B, rho_G)\n", - " rho_B = rho_B.numpy()\n", - " fid = state_fidelity(rho_B, rho_G)\n", - " \n", + " fid = state_fidelity(State(rho_B), State(rho_G))\n", + "\n", " # 打印训练结果\n", " if itr % 10 == 0:\n", - " print('iter:', itr, 'loss:', '%.4f' % loss.numpy(), 'fid:', '%.4f' % fid)\n", + " print('iter:', itr, 'loss:', '%.4f' % loss.numpy(), 'fid:', '%.4f' % fid.numpy())\n", " if itr == ITR:\n", - " print(\"\\n训练后的电路：\")\n", - " print(cir)" + " print(\"\\n训练后的电路: \")\n", + " print(circuit)" ] }, { @@ -450,7 +431,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/quantum_simulation/GibbsState_EN.ipynb b/tutorials/quantum_simulation/GibbsState_EN.ipynb similarity index 77% rename from tutorial/quantum_simulation/GibbsState_EN.ipynb rename to tutorials/quantum_simulation/GibbsState_EN.ipynb index 8271e58..012a74e 100644 --- a/tutorial/quantum_simulation/GibbsState_EN.ipynb +++ b/tutorials/quantum_simulation/GibbsState_EN.ipynb @@ -68,7 +68,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:56:40.078886Z", @@ -78,14 +78,12 @@ "outputs": [], "source": [ "import scipy\n", - "from numpy import array, concatenate, zeros\n", - "from numpy import pi as PI\n", - "from numpy import trace as np_trace\n", "import paddle\n", - "from paddle import matmul, trace, real\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.state import density_op\n", - "from paddle_quantum.utils import state_fidelity, partial_trace, pauli_str_to_matrix" + "from numpy import trace as np_trace\n", + "import paddle_quantum\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.state import zero_state, State\n", + "from paddle_quantum.qinfo import state_fidelity, partial_trace, pauli_str_to_matrix" ] }, { @@ -115,7 +113,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:56:40.099967Z", @@ -132,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:56:40.201757Z", @@ -145,14 +143,14 @@ "H = [[-1.0,'z0,z1'], [-1.0,'z1,z2'], [-1.0,'z0,z2']]\n", "\n", "# Generate matrix information of Hamiltonian\n", - "hamiltonian = pauli_str_to_matrix(H, N_SYS_B)\n", + "hamiltonian = pauli_str_to_matrix(H, N_SYS_B).numpy()\n", "\n", "# Generate the ideal target Gibbs state rho\n", "rho_G = scipy.linalg.expm(-1 * beta * hamiltonian) / np_trace(scipy.linalg.expm(-1 * beta * hamiltonian))\n", "\n", "# Set to the data type supported by Paddle Quantum\n", - "hamiltonian = hamiltonian.astype(\"complex128\")\n", - "rho_G = rho_G.astype(\"complex128\")" + "hamiltonian = hamiltonian.astype(\"complex64\")\n", + "rho_G = paddle.to_tensor(rho_G, dtype=\"complex64\")" ] }, { @@ -174,12 +172,12 @@ "- Initialize the variable ${\\bf{\\theta }}$ that represents the vector of parameters in our QNN.\n", " \n", "\n", - "Next, we use Paddle Quantum's `UAnsatz` class and the built-in `real_entangled_layer(theta, D)` circuit template to build a QNN based on the circuit design in the above figure." + "Next, we use Paddle Quantum's `Circuit` class and the built-in `real_entangled_layer` circuit template to build a QNN based on the circuit design in the above figure." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:56:40.213503Z", @@ -188,25 +186,20 @@ }, "outputs": [], "source": [ - "def U_theta(initial_state, theta, N, D):\n", + "def U_theta(num_qubits: int, depth: int) -> Circuit:\n", " \"\"\"\n", " Quantum Neural Network\n", " \"\"\"\n", - " \n", - " # Initialize the QNN according to the number of qubits/network width\n", - " cir = UAnsatz(N)\n", + " # Initialize the QNN according to the number of qubits\n", + " cir = Circuit(num_qubits)\n", " \n", " # Built-in {R_y + CNOT} circuit template\n", - " cir.real_entangled_layer(theta[:D], D)\n", + " cir.real_entangled_layer(depth=depth)\n", " \n", - " # Add the last layer of R_y rotation gates\n", - " for i in range(N):\n", - " cir.ry(theta=theta[D][i][0], which_qubit=i)\n", - " \n", " # The QNN acts on a given initial state\n", - " final_state = cir.run_density_matrix(initial_state)\n", - "\n", - " return final_state, cir" + " cir.ry()\n", + " \n", + " return cir" ] }, { @@ -236,7 +229,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:56:40.238960Z", @@ -245,37 +238,24 @@ }, "outputs": [], "source": [ - "class Net(paddle.nn.Layer):\n", - " def __init__(self, shape, dtype='float64'):\n", - " super(Net, self).__init__()\n", - " \n", - " # Initialize parameters theta with the uniform distribution of [0, 2*pi]\n", - " self.theta = self.create_parameter(shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", - " # Initialize the density matrix rho = |0..0><0..0|\n", - " self.initial_state = paddle.to_tensor(density_op(N))\n", - "\n", - " # Define loss function and forward propagation mechanism\n", - " def forward(self, H, N, N_SYS_B, D):\n", - "\n", - " # Apply QNN\n", - " rho_AB, cir = U_theta(self.initial_state, self.theta, N, D)\n", - "\n", - " # Calculate partial trace to obtain the quantum state rho_B of subsystem B\n", - " rho_B = partial_trace(rho_AB, 2 ** (N-N_SYS_B), 2 ** (N_SYS_B), 1)\n", - " \n", - " # Calculate the three parts of the loss function\n", - " rho_B_squre = matmul(rho_B, rho_B)\n", - " loss1 = real(trace(matmul(rho_B, H)))\n", - " loss2 = real(trace(rho_B_squre)) * 2 / beta\n", - " loss3 = -(real(trace(matmul(rho_B_squre, rho_B))) + 3) / (2 * beta)\n", - " \n", - " # Final loss function\n", - " loss = loss1 + loss2 + loss3\n", - "\n", - " return loss, rho_B, cir" + " # define loss function\n", + "def loss_func(cir: Circuit, Hamiltonian: paddle.Tensor, N_SYS_B: int) -> paddle.Tensor:\n", + " # Apply QNN\n", + " rho_AB = cir(zero_state(N))\n", + " \n", + " # Calculate partial trace to obtain the quantum state rho_B of subsystem B\n", + " rho_B = partial_trace(rho_AB, 2 ** (N - N_SYS_B), 2 ** (N_SYS_B), 1)\n", + " \n", + " # Calculate the three parts of the loss function\n", + " rho_B_squre = rho_B @ rho_B\n", + " loss1 = paddle.real(paddle.trace(rho_B @ Hamiltonian))\n", + " loss2 = paddle.real(paddle.trace(rho_B_squre)) * 2 / beta\n", + " loss3 = -(paddle.real(paddle.trace(rho_B_squre @ rho_B)) + 3) / (2 * beta)\n", + " \n", + " # 最终的损失函数\n", + " loss = loss1 + loss2 + loss3 \n", + " \n", + " return loss, rho_B" ] }, { @@ -294,7 +274,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 13, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:56:40.966455Z", @@ -327,7 +307,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 14, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T08:56:50.509486Z", @@ -339,20 +319,20 @@ "name": "stdout", "output_type": "stream", "text": [ - "iter: 10 loss: -3.1085 fid: 0.9241\n", + "iter: 10 loss: -3.1084 fid: 0.9241\n", "iter: 20 loss: -3.3375 fid: 0.9799\n", "iter: 30 loss: -3.3692 fid: 0.9897\n", "iter: 40 loss: -3.3990 fid: 0.9929\n", "iter: 50 loss: -3.4133 fid: 0.9959\n", "\n", - "The trained circuit:\n", - "--Ry(6.262)----*--------------X----Ry(0.747)--\n", + "The trained circuit: \n", + "--Ry(6.290)----*--------------x----Ry(0.260)--\n", " | | \n", - "--Ry(4.710)----X----*---------|----Ry(6.253)--\n", + "--Ry(4.745)----x----*---------|----Ry(6.249)--\n", " | | \n", - "--Ry(-0.01)---------X----*----|----Ry(-0.03)--\n", + "--Ry(-0.01)---------x----*----|----Ry(-0.05)--\n", " | | \n", - "--Ry(-0.00)--------------X----*----Ry(6.312)--\n", + "--Ry(0.017)--------------x----*----Ry(6.310)--\n", " \n" ] } @@ -360,21 +340,24 @@ "source": [ "paddle.seed(SEED)\n", " \n", + "# Set calculation mode as density matrix \n", + "paddle_quantum.set_backend(backend='density_matrix') \n", + " \n", "# Convert Numpy array to Tensor supported in PaddlePaddle\n", "H = paddle.to_tensor(hamiltonian)\n", "\n", "# Determine the parameter dimension of the network\n", - "net = Net(shape=[D + 1, N, 1])\n", + "circuit = U_theta(N, D)\n", "\n", "# Generally speaking, we use Adam optimizer to get relatively good convergence\n", "# Of course, it can be changed to SGD or RMS prop.\n", - "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=circuit.parameters())\n", "\n", "# Optimization loops\n", "for itr in range(1, ITR + 1):\n", " \n", " # Run forward propagation to calculate the loss function and return the generated quantum state rho_B\n", - " loss, rho_B, cir = net(H, N, N_SYS_B, D)\n", + " loss, rho_B = loss_func(circuit, H, N_SYS_B)\n", " \n", " # Run back propagation to minimize the loss function\n", " loss.backward()\n", @@ -382,15 +365,14 @@ " opt.clear_grad()\n", "\n", " # Convert to Numpy array to calculate the fidelity of the quantum state F(rho_B, rho_G)\n", - " rho_B = rho_B.numpy()\n", - " fid = state_fidelity(rho_B, rho_G)\n", + " fid = state_fidelity(State(rho_B), State(rho_G))\n", " \n", " # Print training results\n", - " if itr% 10 == 0:\n", - " print('iter:', itr,'loss:','%.4f'% loss.numpy(),'fid:','%.4f'% fid)\n", + " if itr % 10 == 0:\n", + " print('iter:', itr, 'loss:', '%.4f' % loss.numpy(), 'fid:', '%.4f' % fid.numpy())\n", " if itr == ITR:\n", - " print(\"\\nThe trained circuit:\")\n", - " print(cir)" + " print(\"\\nThe trained circuit: \")\n", + " print(circuit)" ] }, { @@ -431,7 +413,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorials/quantum_simulation/HamiltonianSimulation_CN.ipynb b/tutorials/quantum_simulation/HamiltonianSimulation_CN.ipynb new file mode 100644 index 0000000..eabc3b7 --- /dev/null +++ b/tutorials/quantum_simulation/HamiltonianSimulation_CN.ipynb @@ -0,0 +1,735 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fffbbaec", + "metadata": {}, + "source": [ + "# 利用 Product Formula 模拟时间演化\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "id": "e6f9a147", + "metadata": {}, + "source": [ + "## 概述\n", + "\n", + "量子力学中系统的能量由哈密顿量算符 $H$ 描述，求解给定系统的哈密顿量的全部或者部分性质，构成了凝聚态物理、计算化学和高能物理等一系列学科的核心问题。然而，由于系统的自由度随系统增大呈指数级增加，导致一般情况下无法利用经典计算机有效模拟量子系统——即便用光全世界的内存和硬盘也不能直接储存一个仅几百量子比特的系统的态矢量。与经典计算机不同，量子计算机由于其所有的操作都是直接作用在同样为指数级别的态空间上，因而在模拟一个量子系统上量子计算机具有经典计算机无法比拟的优势。实际上，设计一个可控的量子系统来高效模拟自然界中的量子系统，正是费曼在上世纪 80 年代提出量子计算这一概念时的最初想法：\n", + " \n", + "> _\"Nature isn't classical, dammit, and if you want to make a simulation of nature, you'd better make it quantum mechanical, and by golly it's a wonderful problem, because it doesn't look so easy.\"_\n", + ">\n", + "> --- \"Simulating physics with computers\", 1982, Richard P. Feynman [1]\n", + "\n", + "通用量子计算机以及一系列量子模拟器的发展令费曼的设想有了实现的可能。在通用量子计算机上进行数字量子模拟（digital quantum simulation）—— 利用量子门构造量子线路从而实现量子模拟，由于该方法具有较高的可拓展性和通用性，因而被认为是最有潜力的技术路线。\n", + "\n", + "本教程讲述了如何利用 Paddle Quantum 模拟量子系统的时间演化过程，主要分为以下三个部分：\n", + "1. 如何在 Paddle Quantum 中创建并操作一个 `Hamiltonian` 对象\n", + "2. 如何利用 `construct_trotter_circuit` 来构建时间演化电路\n", + "3. Suzuki product formula 方法的原理，以及如何进一步搭建任意阶的 Trotter-Suzuki 电路\n", + "\n", + "\n", + "## 定义系统哈密顿量\n", + "\n", + "在介绍如何搭建时间演化电路之前，读者可以先熟悉一下 Paddle Quantum 中的哈密顿量。目前用户需要通过定义一个列表的形式来创建哈密顿量，列表中的元素应为哈密顿量中的每一项的系数与其泡利算符。作为教程，我们首先考虑一个简单的哈密顿量：\n", + "\n", + "$$\n", + "H = Z \\otimes Z\n", + "\\tag{1}\n", + "$$\n", + "\n", + "该哈密顿量描述了两个量子比特之间的一种简单相互作用：当两个量子比特同时处于 $|0\\rangle$ 态或者 $|1\\rangle$ 态时，系统的能量为 $+1$；相反，当两个量子比特的态不同时，系统的能量为 $-1$。\n", + "\n", + "接下来，用户可以在 Paddle Quantum 中创建这一哈密顿量：" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1a17d7d8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0 Z0, Z1\n" + ] + } + ], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "from paddle_quantum.hamiltonian import Hamiltonian\n", + "\n", + "h = Hamiltonian([[1, 'Z0, Z1']])\n", + "print(h)" + ] + }, + { + "cell_type": "markdown", + "id": "64ef6a63", + "metadata": {}, + "source": [ + "目前，Paddle Quantum 中的哈密顿量类 `Hamiltonian` 支持自动合并同类项，加减法、索引以及拆分等操作：" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "ff08a2a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0 Z0, Z1\n" + ] + } + ], + "source": [ + "h = Hamiltonian([[0.5, 'Z0, Z1'], [0.5, 'Z1, Z0']], compress=True)\n", + "print(h)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "fec891a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "h + h: 2.0 Z0, Z1\n", + "h * 2: 2.0 Z0, Z1\n", + "h: 1.0 Z0, Z1\n" + ] + } + ], + "source": [ + "print('h + h:', h + h)\n", + "print('h * 2:', h * 2)\n", + "print('h:', h[:])" + ] + }, + { + "cell_type": "markdown", + "id": "d2be41b1", + "metadata": {}, + "source": [ + "同时，内置的 `decompose_pauli_words()` 和 `decompose_with_sites()` 方法可以将哈密顿量分解为更加方便处理的形式：" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "40fcc0b6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pauli words 分解： ([1.0], ['ZZ'])\n", + "Pauli with sites 分解： ([1.0], ['ZZ'], [[0, 1]])\n" + ] + } + ], + "source": [ + "print('Pauli words 分解：', h.decompose_pauli_words())\n", + "print('Pauli with sites 分解：', h.decompose_with_sites())" + ] + }, + { + "cell_type": "markdown", + "id": "95945ddd", + "metadata": {}, + "source": [ + "除此之外，`construct_h_matrix()` 还可以创建其在泡利 $Z$ 基底下的矩阵形式：" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "497ff8fd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[ 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]], dtype=complex64)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h.construct_h_matrix()" + ] + }, + { + "cell_type": "markdown", + "id": "719696dd", + "metadata": {}, + "source": [ + "## 模拟时间演化\n", + "\n", + "根据量子力学的基本公理，在确定了一个系统的哈密顿量之后，该系统随时间演化的过程可以由如下方程描述\n", + "\n", + "$$\n", + "i \\hbar \\frac{\\partial}{\\partial t} | \\psi \\rangle = H | \\psi \\rangle,\n", + "\\tag{2}\n", + "$$\n", + "\n", + "$\\hbar$ 为约化普朗克常数。该方程正是著名的薛定谔方程。因此，对于一个不含时的哈密顿量，系统的时间演化方程可以写为\n", + "\n", + "$$\n", + "|\\psi(t) \\rangle = U(t) | \\psi (0) \\rangle, ~ U(t) = e^{- i H t}.\n", + "\\tag{3}\n", + "$$\n", + "\n", + "这里我们取自然单位 $\\hbar=1$，$U(t)$ 为时间演化算符。利用量子线路来模拟时间演化过程的核心思想是利用量子电路构建出的酉变换模拟和近似该时间演化算符。在量桨中，我们提供了 `construct_trotter_circuit(circuit, Hamiltonian)` 函数来构建对应某一个哈密顿量的时间演化电路。下面，就让我们用刚刚创建的哈密顿量来测试一下：" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "3449029b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--*-----------------*--\n", + " | | \n", + "--x----Rz(2.000)----x--\n", + " \n" + ] + } + ], + "source": [ + "from paddle_quantum.trotter import construct_trotter_circuit\n", + "from paddle_quantum.ansatz import Circuit\n", + "\n", + "cir = Circuit()\n", + "construct_trotter_circuit(cir, h, tau=1, steps=1) \n", + "print(cir)" + ] + }, + { + "cell_type": "markdown", + "id": "e3dc6c7f", + "metadata": {}, + "source": [ + "可以看到，我们已经创建了针对 `h` 的基本量子模拟电路，它可以根据输入的 `tau` 来模拟任意时间长度的时间演化。\n", + "\n", + "此时，如果检查该电路对应的酉变换的矩阵形式，会发现它与时间演化算符 $e^{-iHt}$ 完全一致。这里，我们先使用 `gate_fidelity` 来计算量子电路的酉矩阵和时间演化算符的酉矩阵之间的保真度。保真度越接近 1 时代表两个酉矩阵代表的演化过程越相似。在下文，我们还会引入更加严格的误差定义。" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8d312985", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "电路的酉算符和时间演化算符之间的保真度为： 1.000\n" + ] + } + ], + "source": [ + "from scipy import linalg\n", + "from paddle_quantum.qinfo import gate_fidelity\n", + "\n", + "# 计算 e^{-iHt} 和电路的酉矩阵之间的保真度\n", + "print('电路的酉算符和时间演化算符之间的保真度为： %.3f' \n", + " % gate_fidelity(cir.unitary_matrix(), linalg.expm(-1 * 1j * h.construct_h_matrix())))" + ] + }, + { + "cell_type": "markdown", + "id": "fa34ba8a", + "metadata": {}, + "source": [ + "实际上，这是因为泡利算符组成的张量积对应的任意角度旋转算符都可以被很好的分解为门电路的形式。比如在这个例子中我们只需要改变电路中 Rz 门的角度，就可以实现任意 $e^{-i Z\\otimes Z t}$ 演化算符的模拟。那么，这是否意味着可以用类似的电路形式来对任意的写成泡利形式的哈密顿量进行完美的模拟呢？答案是否定的。考虑一个稍微复杂一些的哈密顿量：\n", + "\n", + "$$\n", + "H = Z \\otimes Z + X \\otimes I + I \\otimes X.\n", + "\\tag{4}\n", + "$$\n", + "\n", + "同样地，让我们用 `construct_trotter_circuit` 来构建它所对应的时间演化电路：" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "40bcf1e4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--*-----------------*----Rx(2.000)--\n", + " | | \n", + "--x----Rz(2.000)----x----Rx(2.000)--\n", + " \n", + "电路的酉算符和时间演化算符之间的保真度为： 0.681\n" + ] + } + ], + "source": [ + "h_2 = Hamiltonian([[1, 'Z0, Z1'], [1, 'X0'], [1, 'X1']]) # 不需要写出单位算符\n", + "cir = Circuit()\n", + "construct_trotter_circuit(cir, h_2, tau=1, steps=1)\n", + "print(cir)\n", + "print('电路的酉算符和时间演化算符之间的保真度为： %.3f' \n", + " % gate_fidelity(cir.unitary_matrix().numpy(), linalg.expm(-1 * 1j * h_2.construct_h_matrix())))" + ] + }, + { + "cell_type": "markdown", + "id": "27f0a4ed", + "metadata": {}, + "source": [ + "可以看到，此时电路对应的酉矩阵和时间演化矩阵之间的保真度 $<1$，说明该电路无法正确地模拟系统的时间演化过程。\n", + "\n", + "其实，对于我们此时构建的电路而言，它对应的酉变换为 $e^{-iZ\\otimes Z t} e^{-i (X\\otimes I + I\\otimes X)t}$，而时间演化算符为 $e^{-iZ\\otimes Z t - i(X\\otimes I + I\\otimes X)t}$。而对于一个量子系统而言，当两个算符不对易，即 $[A, B] \\neq 0$ 时，$e^{A+B} \\neq e^A e^B$。在这里，因为泡利算符 $X$ 和 $Z$ 之间并不对易，所以电路对应的酉变换并不等于正确的时间演化算符。\n", + "\n", + "除了利用保真度来描述量子电路和希望模拟的时间演化算符之间的相似性之外，我们还可以定义如下的误差 $\\epsilon$ 来刻画模拟演化电路和演化算符之间的距离，\n", + "\n", + "$$\n", + "\\epsilon(U) = \\Vert e^{-iHt} - U \\Vert,\n", + "\\tag{5}\n", + "$$\n", + "\n", + "其中 $\\Vert \\cdot \\Vert$ 表示取最大的本征（奇异）值的模。这样的定义比起保真度而言更好的描述了量子态在不同的演化算符作用下产生的偏差，是一种更加严谨的定义模拟时间演化误差的方式。我们在下文中也会多次用到该误差。" + ] + }, + { + "cell_type": "markdown", + "id": "9a0f9969", + "metadata": {}, + "source": [ + "### Product formula 与 Suzuki 分解\n", + "\n", + "Seth Lloyd 在 1996 年的文章中指出，可以将一整段的演化时间 $t$ 拆分为 $r$ 份较短的“时间块”来减小模拟时间演化的误差 [2]。考虑一个更一般的哈密顿量形式 $H = \\sum_{k=1}^{L} h_k$，其中 $h_k$ 是作用在一部分系统上的子哈密顿量。通过泰勒展开，不难发现其模拟误差是一个二阶项，即\n", + "\n", + "$$\n", + "e^{-iHt} = \\prod_{k=1}^{L} e^{-i h_k t} + O(t^2).\n", + "\\tag{6}\n", + "$$\n", + "\n", + "那么，我们令 $\\tau = t/r$，并考虑演化算符 $\\left(e^{-iH \\tau}\\right)^r$，其演化误差为\n", + "\n", + "$$\n", + "e^{-iHt} = \\left(e^{-iH \\tau}\\right)^r = \\left(\\prod_{k=1}^{L} e^{-i h_k \\tau} + O(\\tau^2) \\right)^r = \\left(\\prod_{k=1}^{L} e^{-i h_k \\tau} \\right)^r + O\\left(\\frac{t^2}{r}\\right).\n", + "\\tag{7}\n", + "$$\n", + "\n", + "上式告诉我们，只要将一整段演化时间拆为足够多的“片段”，就可以达到任意高的模拟精度，这就是 product formula 的基本思想。不过，(7) 中给出的误差只是一个粗略的估计。在实际情况中，为了估计达到某一模拟精度所需要的量子电路深度，就需要进一步推导其更严格的误差上界。下面，我们展示一个比较简略的误差上界计算过程，对具体的计算过程不感兴趣的读者可以直接跳至 (11) 阅读这部分的结论。\n", + "\n", + "记函数 $f$ 泰勒展开至 $k$ 阶之后的余项为 $\\mathcal{R}_k(f)$, 我们需要用到如下两个结论：\n", + "\n", + "$$\n", + "\\left\\Vert \\mathcal{R}_k \\left( \\prod_{k=1}^{L} \\exp (-i h_k \\tau) \\right) \\right\\Vert\n", + "\\leq\n", + "\\mathcal{R}_k \\left( \\exp \\left( \\sum_{k=1}^{L} \\vert \\tau \\vert \\cdot \\Vert h_k \\Vert \\right) \\right),\n", + "\\tag{8}\n", + "$$\n", + "\n", + "$$\n", + "\\vert \\mathcal{R}_k(\\exp (\\alpha)) \\vert \\leq \\frac{\\vert \\alpha \\vert^{k+1}}{(k+1)!} \\exp ( \\vert \\alpha \\vert ), ~\n", + "\\forall \\alpha \\in \\mathbb{C}.\n", + "\\tag{9}\n", + "$$\n", + "\n", + "这两个结论的证明略微有一些繁琐，故在此略去，感兴趣的读者可以参考 [3] 中的 F.1 节。利用 (5) 中的定义，模拟误差可以写为\n", + "\n", + "$$\n", + "\\epsilon\\left(e^{-iH\\tau}, U_{\\rm circuit}\\right) = \\left \\Vert \\exp\\left(-i\\sum_{k=1}^L h_k \\tau\\right) - \\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right \\Vert.\n", + "\\tag{10}\n", + "$$\n", + "\n", + "我们已经知道，此时的误差是泰勒展开至一阶后的余项，再利用 (8)，(9) 和三角不等式，可以将 (10) 中的误差上界进行计算：\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\left \\Vert \\exp\\left(-i\\sum_{k=1}^L h_k \\tau\\right) - \\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right \\Vert\n", + "=~&\n", + "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\left( -i \\sum_{k=1}^{L} h_k \\tau \\right) - \\prod_{k=1}^{L} \\exp (-i h_k \\tau) \\right) \\right \\Vert\n", + "\\\\\n", + "\\leq~&\n", + "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\left( -i \\sum_{k=1}^{L} h_k \\tau \\right) \\right) \\right \\Vert\n", + "+\n", + "\\left \\Vert \\mathcal{R}_1 \\left( \\prod_{k=1}^{L} \\exp (-i h_k \\tau) \\right) \\right \\Vert\n", + "\\\\\n", + "\\leq~ &\n", + "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\left( \\vert \\tau \\vert \\cdot \\left \\Vert \\sum_{k=1}^{L} h_k \\right \\Vert \\right) \\right) \\right \\Vert\n", + "+ \n", + "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\sum_{k=1}^{L} \\left( \\vert \\tau \\vert \\cdot \\Vert h_k \\Vert \\right) \\right) \\right \\Vert\n", + "\\\\\n", + "\\leq~&\n", + "2 \\mathcal{R}_1 \\left( \\exp ( \\vert \\tau \\vert L \\Lambda ) \\right )\n", + "\\\\\n", + "\\leq~&\n", + " ( \\vert \\tau \\vert L \\Lambda )^2 \\exp ( \\vert \\tau \\vert L \\Lambda ),\n", + "\\end{aligned}\n", + "\\tag{11}\n", + "$$\n", + "\n", + "其中 $\\Lambda = \\max_k \\Vert h_k \\Vert$。随后考虑完整的演化时间 $t = r \\cdot \\tau$，那么模拟长度为 $t$ 的时间演化算符时的误差为：\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\left \\Vert \\left ( \\exp\\left(-i\\sum_{k=1}^L h_k \\tau \\right)\\right)^r - \\left (\\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right)^r \\right \\Vert\n", + "\\leq ~&\n", + "r \\left \\Vert \\exp\\left(-i\\sum_{k=1}^L h_k \\tau\\right) - \\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right \\Vert\n", + "\\\\\n", + "=~& r ( \\tau L \\Lambda )^2 \\exp ( \\vert \\tau \\vert L \\Lambda )\n", + "\\\\\n", + "=~& \\frac{( t L \\Lambda )^2}{r} \\exp \\left( \\frac{\\vert t \\vert L \\Lambda}{r} \\right).\n", + "\\end{aligned}\n", + "\\tag{12}\n", + "$$\n", + "\n", + "这里用到了量子电路中误差线性累积的结论，即 $\\Vert U^r - V^r \\Vert \\leq r\\Vert U - V \\Vert$，不熟悉这一结论的读者可以参考 [4] 中的 4.5.3 节。至此，我们就计算出了 product formula 对于一段完整的演化时间 $t$ 的模拟误差上界，即 (7) 式中的二阶项 $O(t^2/r)$。 \n", + "\n", + "实际上，我们还可以通过 Suzuki 分解的方法来进一步优化对每一个“时间块”内的时间演化算符 $e^{-iH\\tau}$ 的模拟精度。对于哈密顿量 $H = \\sum_{k=1}^{L} a_k h_k$，其时间演化算符的 Suzuki 分解可以写为\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "S_1(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\tau)，\n", + "\\\\\n", + "S_2(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\frac{\\tau}{2})\\prod_{k=L}^0 \\exp ( -i h_k \\frac{\\tau}{2})，\n", + "\\\\\n", + "S_{2k}(\\tau) &= [S_{2k - 2}(p_k\\tau)]^2S_{2k - 2}\\left( (1-4p_k)\\tau\\right)[S_{2k - 2}(p_k\\tau)]^2,\n", + "\\end{aligned}\n", + "\\tag{13}\n", + "$$\n", + "\n", + "对于 $k > 1, k\\in\\mathbb{Z}$，其中 $p_k = 1/(4 - 4^{1/(2k - 1)})$。先前推导的 product formula 实际上只使用了一阶的 Suzuki 分解 $S_1(\\tau)$ 来对每个“时间块”进行模拟，因此也被称为一阶 Suzuki product formula，或者简称一阶 product formula。Suzuki product formula 在物理中也经常被称为 Trotter-Suzuki 分解方法。对于更高阶的 product formula 而言，使用 (10-12) 中类似的计算，可以证明第 $2k$ 阶 product formula 的整体误差上界为：\n", + "\n", + "$$\n", + "\\epsilon\\left(e^{-iHt}, \\left(S_{2k}(\\tau)\\right)^r\\right)\n", + "\\leq\n", + "\\frac{(2L5^{k-1}\\Lambda\\vert t \\vert)^{2k+1}}{3r^{2k}} \\exp \\left( \\frac{2L5^{k-1}\\Lambda\\vert t \\vert}{r} \\right),\n", + "~ k > 1.\n", + "\\tag{14}\n", + "$$\n", + "\n", + "在得到了模拟误差上界的基础上，还可以进一步计算达到一定最小精度 $\\epsilon$ 时所需要的电路深度的下界。需要指出的是，(12) 和 (14) 中给出的误差上界的计算是十分宽松的。近年来，许多工作都进一步地给出了更加紧致的上界 [3, 5-6]。此外，也有人提出了不基于 Suzuki 分解的 product formula [7]。" + ] + }, + { + "cell_type": "markdown", + "id": "f3bf6fb2", + "metadata": {}, + "source": [ + "![image.png](./figures/trotter_suzuki_circuit.png)\n", + "
图1：Suzuki product formula 电路的示意图
" + ] + }, + { + "cell_type": "markdown", + "id": "e0c26758", + "metadata": {}, + "source": [ + "### 利用 Paddle Quantum 验证基于 Suzuki-product formula 的时间演化电路\n", + "\n", + "尽管人们不断的在优化 Suzuki-product formula 的误差上界，但是在实际使用中，真实的误差往往和理论上给出的上界有一定差距，也就是说，我们现在能计算的理论上的 product formula 误差依然只是一个十分宽松的上界 [3]。因此，对于一个真实的物理系统，我们往往需要通过数值实验来计算其真实的误差，从而给出一个经验性的误差上界（empirical bound）。这样的数值试验对于计算在一定精度下模拟某一时间演化过程所需要的电路深度十分重要。\n", + "\n", + "在刚刚介绍的 `construct_trotter_circuit` 函数中，用户也可以通过改变传入参数 `tau`、`steps`、`order` 来实现对任意阶 Suzuki product formula 电路的创建。下面，我们就利用该函数的这一功能来验证一下 Suzuki product formula 的误差。\n", + "\n", + "继续使用先前的哈密顿量：" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "86de7992", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "H = 1.0 Z0, Z1\n", + "1.0 X0\n", + "1.0 X1\n" + ] + } + ], + "source": [ + "print('H =', h_2)" + ] + }, + { + "cell_type": "markdown", + "id": "2e183412", + "metadata": {}, + "source": [ + "这里我们通过改变 `tau` 和 `steps` 两个参数来将 $t=1$ 的演化过程进行拆分。（提示：$\\tau \\cdot n_{\\rm steps} = t$）" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "240ed09f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--*-----------------*----Rx(0.667)----*-----------------*----Rx(0.667)----*-----------------*----Rx(0.667)--\n", + " | | | | | | \n", + "--x----Rz(0.667)----x----Rx(0.667)----x----Rz(0.667)----x----Rx(0.667)----x----Rz(0.667)----x----Rx(0.667)--\n", + " \n", + "电路的酉算符和时间演化算符之间的保真度为： 0.984\n" + ] + } + ], + "source": [ + "# 将长度为 t 的时间演化过程拆为 r 份\n", + "r = 3\n", + "t = 1\n", + "cir = Circuit()\n", + "# 搭建时间演化电路，tau 为每个“时间块”的演化时间，故为 t/r，steps 是“时间块”的重复次数 r\n", + "construct_trotter_circuit(cir, h_2, tau=t/r, steps=r)\n", + "print(cir)\n", + "print('电路的酉算符和时间演化算符之间的保真度为： %.3f' \n", + " % gate_fidelity(cir.unitary_matrix().numpy(), linalg.expm(-1 * 1j * h_2.construct_h_matrix())))" + ] + }, + { + "cell_type": "markdown", + "id": "4708cad9", + "metadata": {}, + "source": [ + "我们发现，通过将 $t=1$ 的模拟时间拆分为三个“时间块”，模拟误差被成功减小了。\n", + "\n", + "如果进一步地增加拆分后的“时间块”的数量的话，误差还可以被进一步减小：" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "abc3742d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 导入一些作图和计算误差需要的额外包\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def get_fid(n_steps):\n", + " t = 1\n", + " cir = Circuit()\n", + " construct_trotter_circuit(cir, h_2, tau=t/n_steps, steps=n_steps)\n", + " return gate_fidelity(cir.unitary_matrix(), linalg.expm(-1 * 1j * h_2.construct_h_matrix())).item()\n", + "plt.axhline(1, ls='--', color='black')\n", + "plt.semilogy(np.arange(1, 11), [get_fid(r) for r in np.arange(1, 11)], 'o-')\n", + "plt.xlabel('number of steps', fontsize=12)\n", + "plt.ylabel('fidelity', fontsize=12)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f8381126", + "metadata": {}, + "source": [ + "不仅如此，我们还可以通过改变 product formula 的阶数来减小模拟误差。目前，`construct_trotter_circuit` 函数支持通过参数 `order` 来实现任意阶数的 Suzuki product formula。下面，就让我们来分别计算一下一阶和二阶时间演化电路的误差随着 $\\tau$ 大小的变化，并和上文中计算的理论误差上界进行对比：" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "d3256b18", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# 计算两个酉矩阵之间的 L1 谱距离，即 (5) 中定义的误差\n", + "def calculate_error(U1, U2):\n", + " return np.abs(linalg.eig(U1 - U2)[0]).max()\n", + "\n", + "# 封装计算误差的函数，自由参数为每个时间块的长度 tau 和 product formula 的阶数 order\n", + "def calculate_total_error(tau, order=1):\n", + " h_2 = Hamiltonian([[1, 'Z0, Z1'], [1, 'X0'], [1, 'X1']])\n", + " cir = Circuit()\n", + " # 应为总时长为 1，故 steps = int(1/tau)，注意传入的 tau 需要可以整除 1\n", + " construct_trotter_circuit(cir, h_2, tau=tau, steps=int(1/tau), order=order)\n", + " cir_U = cir.unitary_matrix().numpy()\n", + " U_evolve = linalg.expm(-1 * 1j * h_2.construct_h_matrix())\n", + " return calculate_error(cir_U, U_evolve)\n", + "\n", + "# 不同的参数 tau，注意它们需要可以整除 1\n", + "taus = np.array([0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1])\n", + "errors = []\n", + "\n", + "# 记录对应不同 tau 的总误差\n", + "for tau in taus:\n", + " errors.append(calculate_total_error(tau)) \n", + "\n", + "# 可视化结果\n", + "plt.loglog(taus, errors, 'o-', label='error')\n", + "plt.loglog(taus, (3 * taus**2 * (1/taus) * np.exp(3 * taus)), label='bound') # 按照 (10) 计算的一阶误差上界\n", + "plt.legend()\n", + "plt.xlabel(r'$\\tau$', fontsize=12)\n", + "plt.ylabel(r'$\\Vert U_{\\rm cir} - \\exp(-iHt) \\Vert$', fontsize=12)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "2fdbf168", + "metadata": {}, + "source": [ + "下面，我们将 `order` 设置为 2，并计算二阶 product formula 的误差：" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "a3db610c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "taus = np.array([0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1])\n", + "errors = []\n", + "\n", + "for tau in taus:\n", + " errors.append(calculate_total_error(tau, order=2)) # 通过 order=2 指定 Suzuki 分解的阶数 \n", + "\n", + "plt.loglog(taus, errors, 'o-', label='error')\n", + "plt.loglog(taus, (2 * taus * 3 )**3 / 3 * (1/taus) * np.exp(3 * taus), '-', label='bound') # 按照 (12) 计算的二阶误差上界\n", + "plt.legend()\n", + "plt.xlabel(r'$\\tau$', fontsize=12)\n", + "plt.ylabel(r'$\\Vert U_{\\rm cir} - \\exp(-iHt) \\Vert$', fontsize=12)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8c468fd4", + "metadata": {}, + "source": [ + "可以看到，实际计算出的模拟误差都小于其理论上界，说明这样的结果是符合预期的。\n", + "\n", + "## 小结\n", + "\n", + "本教程介绍了 Paddle Quantum 中构建模拟时间演化电路的功能，并对其背后的理论基础——Suzuki product formula 进行了介绍。利用该功能，用户可以通过搭建对于自定义哈密顿量的任意阶 product formula 电路来模拟不同物理系统的时间演化过程。\n", + "\n", + "量子模拟本身是一个比较宽泛的话题，其应用也十分广泛：凝聚态物理中的多体局域化、时间晶体、高温超导、拓扑序的研究；量子化学中的分子动力学模拟、反应模拟；高能物理中的场论模拟；乃至核物理和宇宙学中的相关研究。本教程中介绍的 Suzuki product formula 与基于通用量子计算机的数字量子模拟只是量子模拟的一部分，许多不基于通用量子计算机的量子模拟器，例如在冷原子、超导、离子阱以及光子等平台上做的模拟量子模拟（analogue quantum simulation）也是一个十分重要的方向。鉴于篇幅，本教程中无法进一步对这些内容逐一展开介绍，感兴趣的读者可以阅读 14 年的这篇综述文章 [8]。对于一些更新的结果，也可以参考这篇中文综述 [9]。\n", + "\n", + "在后续的教程 [模拟一维海森堡链的自旋动力学](./SimulateHeisenberg_CN.ipynb) 中，我们以凝聚态物理中的自旋模型为例，进一步地展示了如何利用本文中介绍的内容来进行量子多体模型的动力学模拟。同时，该教程也将介绍如何搭建不基于 Suzuki 分解的自定义时间演化电路。" + ] + }, + { + "cell_type": "markdown", + "id": "01705a8d", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 参考资料\n", + "\n", + "[1] Feynman, R. P. \"Simulating physics with computers.\" International Journal of Theoretical Physics 21.6 (1982).\n", + " \n", + "[2] Lloyd, Seth. \"Universal quantum simulators.\" [Science (1996): 1073-1078](https://www.jstor.org/stable/2899535).\n", + "\n", + "[3] Childs, Andrew M., et al. \"Toward the first quantum simulation with quantum speedup.\" [Proceedings of the National Academy of Sciences 115.38 (2018): 9456-9461](https://www.pnas.org/content/115/38/9456.short).\n", + "\n", + "[4] Nielsen, Michael A., and Isaac Chuang. \"Quantum computation and quantum information.\" (2002): 558-559.\n", + "\n", + "[5] Tran, Minh C., et al. \"Destructive error interference in product-formula lattice simulation.\" [Physical Review Letters 124.22 (2020): 220502](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.124.220502).\n", + "\n", + "[6] Childs, Andrew M., and Yuan Su. \"Nearly optimal lattice simulation by product formulas.\" [Physical Review Letters 123.5 (2019): 050503](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.123.050503).\n", + "\n", + "[7] Campbell, Earl. \"Random compiler for fast Hamiltonian simulation.\" [Physical Review Letters 123.7 (2019): 070503](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.123.070503).\n", + "\n", + "[8] Georgescu, Iulia M., Sahel Ashhab, and Franco Nori. \"Quantum simulation.\" [Reviews of Modern Physics 86.1 (2014): 153](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.86.153).\n", + "\n", + "[9] 范桁. \"量子计算与量子模拟.\" [物理学报 67.12(2018):16-25](http://wulixb.iphy.ac.cn/article/id/72211)." + ] + } + ], + "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.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/quantum_simulation/HamiltonianSimulation_EN.ipynb b/tutorials/quantum_simulation/HamiltonianSimulation_EN.ipynb new file mode 100644 index 0000000..d349112 --- /dev/null +++ b/tutorials/quantum_simulation/HamiltonianSimulation_EN.ipynb @@ -0,0 +1,734 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "7d09a637", + "metadata": {}, + "source": [ + "# Hamiltonian Simulation with Product Formula\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "id": "280b8be1", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "In quantum mechanics, a system's energy is described with a Hamiltonian operator $H$. Solving all or partial properties of the Hamiltonian of a given system constitutes a central problem in many disciplines, including condensed matter physics, computational chemistry, high-energy physics, etc. However, the degrees of freedom of a quantum system grow exponentially with its system size, which leads to the inability to effectively simulate quantum systems using classical computers - the quantum state of several hundred qubits cannot be directly stored even with all the storage resources in the world. Unlike classical computers, quantum computers perform all operations directly on the exponentially large Hilbert space, thus having a natural advantage over classical computer when simulating a quantum system. Matter of fact, designing a controlled quantum system to efficiently simulate quantum systems in nature was Feynman's original idea when he first introduced the concept of quantum computing in the 1980s:\n", + " \n", + "> _\"Nature isn't classical, dammit, and if you want to make a simulation of nature, you'd better make it quantum mechanical, and by golly it's a wonderful problem, because it doesn't look so easy.\"_\n", + ">\n", + "> --- \"Simulating physics with computers\", 1982, Richard P. Feynman [1]\n", + "\n", + "\n", + "The development of universal quantum computers and a series of quantum simulators has made it possible to realize Feynman's vision. Digital quantum simulation on a universal quantum computer (i.e. quantum simulation by constructing quantum circuits through quantum gates) is considered to be to have the largest potential due to its scalability and generality.\n", + "\n", + "In this tutorial, we introduce Hamiltonian simulation in Paddle Quantum. It will be divided into three parts:\n", + "1. How to construct a system's Hamiltonian using `Hamiltonian` class.\n", + "2. How to create the time-evolving circuit with `construct_trotter_circuit()` function.\n", + "3. The Suzuki product formula algorithm and how to create its corresponding circuit up to arbitrary order.\n", + "\n", + "## Define the system's Hamiltonian \n", + "Before demoing how to construct a time-evolving circuit, we will first introduce to readers how to construct a `Hamiltonian` object in Paddle Quantum. Users could create a `Hamiltonian` object by specifying a list of Pauli string containing the coefficients and Pauli operators of each term. First let's consider a simple Hamiltonian:\n", + "\n", + "$$\n", + "H = Z \\otimes Z\n", + "\\tag{1}\n", + "$$\n", + "\n", + "This Hamiltonian describes a simple interaction between two qubits: when both qubits are in $|0\\rangle$ or $|1\\rangle$ , the energy of the system is $+1$; conversely when the two qubits are in different states, the energy of the system is $-1$.\n", + "\n", + "The user could construct this Hamiltonian by:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "b1546d21", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0 Z0, Z1\n" + ] + } + ], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "from paddle_quantum.hamiltonian import Hamiltonian\n", + "\n", + "h = Hamiltonian([[1, 'Z0, Z1']])\n", + "print(h)" + ] + }, + { + "cell_type": "markdown", + "id": "99ff7830", + "metadata": {}, + "source": [ + "The `Hamiltonian` class in Paddle Quantum supports automatic merging of equal terms, addition, subtraction, indexing, and splitting:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "82fae2f8", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.0 Z0, Z1\n" + ] + } + ], + "source": [ + "h = Hamiltonian([[0.5, 'Z0, Z1'], [0.5, 'Z1, Z0']], compress=True)\n", + "print(h)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "37ea39a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "h + h: 2.0 Z0, Z1\n", + "h * 2: 2.0 Z0, Z1\n", + "h: 1.0 Z0, Z1\n" + ] + } + ], + "source": [ + "print('h + h:', h + h)\n", + "print('h * 2:', h * 2)\n", + "print('h:', h[:])" + ] + }, + { + "cell_type": "markdown", + "id": "34438c9e", + "metadata": {}, + "source": [ + "The `decompose_pauli_words()` and `decompose_with_sites()` methods can decompose the Hamiltonian into more manageable forms:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "8f292d61", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pauli words decomposition: ([1.0], ['ZZ'])\n", + "Pauli with sites decomposition: ([1.0], ['ZZ'], [[0, 1]])\n" + ] + } + ], + "source": [ + "print('Pauli words decomposition:', h.decompose_pauli_words())\n", + "print('Pauli with sites decomposition:', h.decompose_with_sites())" + ] + }, + { + "cell_type": "markdown", + "id": "10254485", + "metadata": {}, + "source": [ + "In addition, `construct_h_matrix()` will construct its matrix in the $Z$ Pauli basis:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "73dac520", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "matrix([[ 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]], dtype=complex64)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h.construct_h_matrix()" + ] + }, + { + "cell_type": "markdown", + "id": "3a320cb9", + "metadata": {}, + "source": [ + "## Simulate the time evolution\n", + "\n", + "According to one of the fundamental axioms of quantum mechanics, the evolution of a system over time can be described by\n", + "\n", + "$$\n", + "i \\hbar \\frac{\\partial}{\\partial t} | \\psi \\rangle = H | \\psi \\rangle,\n", + "\\tag{2}\n", + "$$\n", + "\n", + "$\\hbar$ is the reduced Planck constant. This equation is the well-known Schrödinger equation. Thus, for a time independent Hamiltonian, the time evolution equation of the system can be written as\n", + "\n", + "$$\n", + "|\\psi(t) \\rangle = U(t) | \\psi (0) \\rangle, ~ U(t) = e^{- i H t}.\n", + "\\tag{3}\n", + "$$\n", + "\n", + "Here we take the natural unit $\\hbar=1$ and $U(t)$ is the time evolution operator. The idea of simulating the time evolution process with quantum circuits is to approximate this time evolution operator using the unitary transformation constructed by quantum circuits. In Paddle Quantum, we provide the `construct_trotter_circuit(circuit, Hamiltonian)` function to construct a time-evolving circuit corresponding to a Hamiltonian. Now, let us test it with the Hamiltonian we just constructed:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f983834e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--*-----------------*--\n", + " | | \n", + "--x----Rz(2.000)----x--\n", + " \n" + ] + } + ], + "source": [ + "from paddle_quantum.trotter import construct_trotter_circuit\n", + "from paddle_quantum.ansatz import Circuit\n", + "\n", + "cir = Circuit()\n", + "construct_trotter_circuit(cir, h, tau=1, steps=1) \n", + "print(cir)" + ] + }, + { + "cell_type": "markdown", + "id": "988ffa8b", + "metadata": {}, + "source": [ + "We can see that a quantum circuit has been constructed for `h`, which can simulate the time evolution of arbitrary time length based on the input `tau`.\n", + "\n", + "By calculating the matrix form of this circuit, one can see that it is identical to the time evolution operator $e^{-iHt}$. Here, we use `gate_fidelity` to calculate the fidelity between the unitary matrix of the quantum circuit and the unitary matrix of the time evolution operator. These two processes are identical when the fidelity is equal to 1. We note that a more formal definition of simulation error will be introduced at the end of this section. For now, let's consider fidelity as the criteria of similarity between two evolution processes (unitary operators)." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "52f3dff9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The fidelity is: 0.471\n" + ] + } + ], + "source": [ + "from scipy import linalg\n", + "from paddle_quantum.qinfo import gate_fidelity\n", + "\n", + "# calculate the fidelity between e^{-iHt} and the unitary matrix of circuit\n", + "print('The fidelity is: %.3f' \n", + " % gate_fidelity(cir.unitary_matrix(), linalg.expm(-1 * 1j * h.construct_h_matrix())))" + ] + }, + { + "cell_type": "markdown", + "id": "075faf9a", + "metadata": {}, + "source": [ + "Actually, this is because any rotation associated with a tensor product of the pauli operators can be efficiently decomposed into a circuit. In this example, we could change the angle of the Rz gate to simulate any $e^{-i Z\\otimes Z t}$ evolutionary operator. Does this mean that the time-evolving operator of any Pauli Hamiltonian could be perfectly simulated with a quantum circuit? Unfortunately, the answer is negative. Let us consider a slightly more complicated Hamiltonian:\n", + "\n", + "$$\n", + "H = Z \\otimes Z + X \\otimes I + I \\otimes X.\n", + "\\tag{4}\n", + "$$\n", + "\n", + "Similarly, let's use `construct_trotter_circuit` to construct its corresponding time-evolving circuit:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8ec1213d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--*-----------------*----Rx(2.000)--\n", + " | | \n", + "--x----Rz(2.000)----x----Rx(2.000)--\n", + " \n", + "The fidelity is: 0.681\n" + ] + } + ], + "source": [ + "h_2 = Hamiltonian([[1, 'Z0, Z1'], [1, 'X0'], [1, 'X1']]) # no need to write out unit operator\n", + "cir = Circuit()\n", + "construct_trotter_circuit(cir, h_2, tau=1, steps=1)\n", + "print(cir)\n", + "print('The fidelity is: %.3f' \n", + " % gate_fidelity(cir.unitary_matrix().numpy(), linalg.expm(-1 * 1j * h_2.construct_h_matrix())))" + ] + }, + { + "cell_type": "markdown", + "id": "f75bd0c7", + "metadata": {}, + "source": [ + "This time the fidelity is less than $1$, which means the circuit cannot correctly simulate the time-evolution process of the system.\n", + "\n", + "The reason is that, the unitary transformation of the circuit is $e^{-iZ\\otimes Z t} e^{-i (X\\otimes I + I\\otimes X)t}$, while the time evolution operator is $e^{-iZ\\otimes Z t - i(X\\otimes I + I\\otimes X)t}$. And for a quantum system, $e^{A+B} \\neq e^A e^B$ when $[A, B] \\neq 0$. Here, since $[X, Z] \\neq 0$, the corresponding unitary transformation of the circuit is not equal to the correct time-evolution operator.\n", + "\n", + "In addition to using the fidelity to describe the similarity between the quantum circuit and the time-evolving operator that one wishes to simulate, one can define the error $\\epsilon$ as follows\n", + "\n", + "$$\n", + "\\epsilon(U) = \\Vert e^{-iHt} - U \\Vert,\n", + "\\tag{5}\n", + "$$\n", + "\n", + "where $\\Vert \\cdot \\Vert$ denotes the mode of the largest eigen (singular) value. Such a definition better describes the deviation of the quantum state under different evolution operators and it is a more rigorous way to define the simulation time evolution error. We note that the simulation error of this form will be used repeatedly in the next section." + ] + }, + { + "cell_type": "markdown", + "id": "3109b3f5", + "metadata": {}, + "source": [ + "### Product formula and Suzuki decomposition\n", + "\n", + "In 1996, Seth Lloyd showed that the error in simulating time evolution can be reduced by splitting a whole evolution time $t$ into $r$ shorter \"time blocks\" [2]. Consider a more general Hamiltonian of the form $H = \\sum_{k=1}^{L} h_k$, where $h_k$ acts on a part of the system. By Taylor expansion, it is not difficult to find that the simulation error is a second-order term, i.e.\n", + "\n", + "$$\n", + "e^{-iHt} = \\prod_{k=1}^{L} e^{-i h_k t} + O(t^2).\n", + "\\tag{6}\n", + "$$\n", + "\n", + "Let $\\tau = t/r$ and consider the evolution operator $\\left(e^{-iH \\tau}\\right)^r$, then its error can be derived from \n", + "\n", + "$$\n", + "e^{-iHt} = \\left(e^{-iH \\tau}\\right)^r = \\left(\\prod_{k=1}^{L} e^{-i h_k \\tau} + O(\\tau^2) \\right)^r = \\left(\\prod_{k=1}^{L} e^{-i h_k \\tau} \\right)^r + O\\left(\\frac{t^2}{r}\\right).\n", + "\\tag{7}\n", + "$$\n", + "\n", + "The above equation states that an arbitrarily high simulation accuracy can be achieved by splitting the whole evolution time into enough \"pieces\". This is the basic idea of the product formula. However, the error given in (7) is only a rough estimate. In practice, in order to estimate the depth of the quantum circuit required to achieve a certain simulation accuracy, an exact upper bound on the error needs to be further computed. In the following, we show a relatively abbreviated procedure for calculating the error upper bound and readers who are not interested in details can skip to the conclusion on the error bound in (11).\n", + "\n", + "Let us note the remainder Taylor expansion of the function $f$ up to order $k$ to be $\\mathcal{R}_k(f)$. And the two following statements are needed for the calculating of the error bound:\n", + "\n", + "$$\n", + "\\left\\Vert \\mathcal{R}_k \\left( \\prod_{k=1}^{L} \\exp (-i h_k \\tau) \\right) \\right\\Vert\n", + "\\leq\n", + "\\mathcal{R}_k \\left( \\exp \\left( \\sum_{k=1}^{L} \\vert \\tau \\vert \\cdot \\Vert h_k \\Vert \\right) \\right),\n", + "\\tag{8}\n", + "$$\n", + "\n", + "$$\n", + "\\vert \\mathcal{R}_k(\\exp (\\alpha)) \\vert \\leq \\frac{\\vert \\alpha \\vert^{k+1}}{(k+1)!} \\exp ( \\vert \\alpha \\vert ), ~\n", + "\\forall \\alpha \\in \\mathbb{C}.\n", + "\\tag{9}\n", + "$$\n", + "\n", + "We omit the proofs of these two statements due to length limitations and interested reader could refer to Section F.1 in [3]. As defined in (5), the simulation error can be written as\n", + "\n", + "$$\n", + "\\epsilon\\left(e^{-iH\\tau}, U_{\\rm circuit}\\right) = \\left \\Vert \\exp\\left(-i\\sum_{k=1}^L h_k \\tau\\right) - \\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right \\Vert.\n", + "\\tag{10}\n", + "$$\n", + "\n", + "We already know that simulation error is the reminder of the time-evolving operators' Taylor expansion to the first order. Then using (8), (9) and the triangular inequality, the upper bound on the error in (10) can be calculated as follows\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\left \\Vert \\exp\\left(-i\\sum_{k=1}^L h_k \\tau\\right) - \\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right \\Vert\n", + "=~&\n", + "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\left( -i \\sum_{k=1}^{L} h_k \\tau \\right) - \\prod_{k=1}^{L} \\exp (-i h_k \\tau) \\right) \\right \\Vert\n", + "\\\\\n", + "\\leq~&\n", + "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\left( -i \\sum_{k=1}^{L} h_k \\tau \\right) \\right) \\right \\Vert\n", + "+\n", + "\\left \\Vert \\mathcal{R}_1 \\left( \\prod_{k=1}^{L} \\exp (-i h_k \\tau) \\right) \\right \\Vert\n", + "\\\\\n", + "\\leq~ &\n", + "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\left( \\vert \\tau \\vert \\cdot \\left \\Vert \\sum_{k=1}^{L} h_k \\right \\Vert \\right) \\right) \\right \\Vert\n", + "+ \n", + "\\left \\Vert \\mathcal{R}_1 \\left( \\exp \\sum_{k=1}^{L} \\left( \\vert \\tau \\vert \\cdot \\Vert h_k \\Vert \\right) \\right) \\right \\Vert\n", + "\\\\\n", + "\\leq~&\n", + "2 \\mathcal{R}_1 \\left( \\exp ( \\vert \\tau \\vert L \\Lambda ) \\right )\n", + "\\\\\n", + "\\leq~&\n", + " ( \\vert \\tau \\vert L \\Lambda )^2 \\exp ( \\vert \\tau \\vert L \\Lambda ),\n", + "\\end{aligned}\n", + "\\tag{11}\n", + "$$\n", + "\n", + "with $\\Lambda = \\max_k \\Vert h_k \\Vert$. Considering the complete evolution time $t = r \\cdot \\tau$, the error when simulating a time evolution operator of length $t$ is\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "\\left \\Vert \\left ( \\exp\\left(-i\\sum_{k=1}^L h_k \\tau \\right)\\right)^r - \\left (\\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right)^r \\right \\Vert\n", + "\\leq ~&\n", + "r \\left \\Vert \\exp\\left(-i\\sum_{k=1}^L h_k \\tau\\right) - \\prod_{k=1}^{L} \\exp\\left(-i h_k \\tau \\right) \\right \\Vert\n", + "\\\\\n", + "=~& r ( \\tau L \\Lambda )^2 \\exp ( \\vert \\tau \\vert L \\Lambda )\n", + "\\\\\n", + "=~& \\frac{( t L \\Lambda )^2}{r} \\exp \\left( \\frac{\\vert t \\vert L \\Lambda}{r} \\right).\n", + "\\end{aligned}\n", + "\\tag{12}\n", + "$$\n", + "\n", + "Here we use the conclusion of linear accumulation of errors in quantum circuits, i.e. $\\Vert U^r - V^r \\Vert \\leq r\\Vert U - V \\Vert$, and the reader who is not familiar with this conclusion can refer to Section 4.5.3 in [4]. At this point, we have calculated an upper bound on the simulation error of the product formula for a complete period of evolution time $t$, i.e., the second-order term $O(t^2/r)$ in Eq. (7). \n", + "\n", + "In fact, we can further optimize the simulation accuracy for the time-evolution operator $e^{-iH\\tau}$ within each \"time block\" by the Suzuki decomposition. For the Hamiltonian $H = \\sum_{k=1}^{L} h_k$, the Suzuki decomposition of the time evolution operator can be written as\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "S_1(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\tau),\n", + "\\\\\n", + "S_2(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\frac{\\tau}{2})\\prod_{k=L}^0 \\exp ( -i h_k \\frac{\\tau}{2}),\n", + "\\\\\n", + "S_{2k}(\\tau) &= [S_{2k - 2}(p_k\\tau)]^2S_{2k - 2}\\left( (1-4p_k)\\tau\\right)[S_{2k - 2}(p_k\\tau)]^2,\n", + "\\end{aligned}\n", + "\\tag{13}\n", + "$$\n", + "\n", + "For $k > 1, k\\in\\mathbb{Z}$, where $p_k = 1/(4 - 4^{1/(2k - 1)})$. The previously derived product formula actually uses only the first-order Suzuki decomposition $S_1(\\tau)$ to simulate each \"time block\". Therefore it's also known as the first-order Suzuki product formula, or simply the first-order product formula. In some scenarios, the Suzuki product formula is also referred to as the Trotter-Suzuki decomposition. For higher-order product formulas, using similar calculations as in (10-12), it can be shown that the error bound on the error for the $2k$-th order product formula is：\n", + "\n", + "$$\n", + "\\epsilon\\left(e^{-iHt}, \\left(S_{2k}(\\tau)\\right)^r\\right)\n", + "\\leq\n", + "\\frac{(2L5^{k-1}\\Lambda\\vert t \\vert)^{2k+1}}{3r^{2k}} \\exp \\left( \\frac{2L5^{k-1}\\Lambda\\vert t \\vert}{r} \\right),\n", + "~ k > 1.\n", + "\\tag{14}\n", + "$$\n", + "\n", + "With the upper bound on the simulation error obtained, it is possible to further calculate the lower bound on the circuit depth required to reach a certain minimum accuracy $\\epsilon$. It should be noted that the error bounds given in (12) and (14) are calculated very loosely. In recent years, many works have gone further to give tighter upper bounds [3, 5-6]. In addition, product formulas that are not based on the Suzuki decomposition have also been proposed [7]." + ] + }, + { + "cell_type": "markdown", + "id": "f3bf6fb2", + "metadata": {}, + "source": [ + "![image.png](./figures/trotter_suzuki_circuit.png)\n", + "
Fig 1: The circuit of Suzuki product formula
" + ] + }, + { + "cell_type": "markdown", + "id": "0b3ff06a", + "metadata": {}, + "source": [ + "### Verification of Suzuki-product formula-based time-evolving circuits using Paddle Quantum\n", + "\n", + "Although the upper bound on the error of the Suzuki-product formula has been continuously optimized, in practice, the real error is often different from the theoretical upper bound, i.e., the theoretical product formula error that we can calculate now is still only a very loose upper bound [3]. Therefore, for a real physical system, we often need to calculate the real error through numerical experiments to give an empirical bound on the error. Such numerical experiments are important as they could be used to determine the circuit depth needed to simulate a certain time evolution process at a certain accuracy.\n", + "\n", + "In the `construct_trotter_circuit` function, It constructs by default a circuit based on the first order product formula. Users can create simulation circuits of higher order product formulas with more time blocks by manipulating the arguments `tau`, `steps`, `order`. As the last part of this tutorial, we will demonstrate how these options work in Paddle Quantum.\n", + "\n", + "Using the previous Hamiltonian:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "b1609917", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "H = 1.0 Z0, Z1\n", + "1.0 X0\n", + "1.0 X1\n" + ] + } + ], + "source": [ + "print('H =', h_2)" + ] + }, + { + "cell_type": "markdown", + "id": "a6ecb816", + "metadata": {}, + "source": [ + "Here we split the evolution of $t=1$ by changing the `tau` and `steps`. (Hint: $\\tau \\cdot n_{\\rm steps} = t$)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "e559b726", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--*-----------------*----Rx(0.667)----*-----------------*----Rx(0.667)----*-----------------*----Rx(0.667)--\n", + " | | | | | | \n", + "--x----Rz(0.667)----x----Rx(0.667)----x----Rz(0.667)----x----Rx(0.667)----x----Rz(0.667)----x----Rx(0.667)--\n", + " \n", + "The fidelity is: 0.984\n" + ] + } + ], + "source": [ + "# Split the time evolution process of length t into r blocks\n", + "r = 3\n", + "t = 1\n", + "cir = Circuit()\n", + "# Construct the time evolution circuit, tau is the evolution time of each \"time block\", i.e. t/r\n", + "# Steps is the number of repetitions of the \"time block\" r\n", + "construct_trotter_circuit(cir, h_2, tau=t/r, steps=r)\n", + "print(cir)\n", + "print('The fidelity is: %.3f' \n", + " % gate_fidelity(cir.unitary_matrix().numpy(), linalg.expm(-1 * 1j * h_2.construct_h_matrix())))" + ] + }, + { + "cell_type": "markdown", + "id": "5b94d8ec", + "metadata": {}, + "source": [ + "We can see that by splitting the simulation time of $t=1$ into three \"time blocks\", the simulation error was successfully reduced.\n", + "\n", + "The error could be further reduced if we further split the evolution process into more 'pieces':" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "95e891f9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Import the required packages\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "def get_fid(n_steps):\n", + " t = 1\n", + " cir = Circuit()\n", + " construct_trotter_circuit(cir, h_2, tau=t/n_steps, steps=n_steps)\n", + " return gate_fidelity(cir.unitary_matrix(), linalg.expm(-1 * 1j * h_2.construct_h_matrix())).item()\n", + "plt.axhline(1, ls='--', color='black')\n", + "plt.semilogy(np.arange(1, 11), [get_fid(r) for r in np.arange(1, 11)], 'o-')\n", + "plt.xlabel('number of steps', fontsize=12)\n", + "plt.ylabel('fidelity', fontsize=12)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "a6b86ebb", + "metadata": {}, + "source": [ + "In addition, we can reduce the simulation error by changing the order of the product formula. Currently, the `construct_trotter_circuit` supports the Suzuki product formula of any order using the argument `order`. Let us calculate the errors of the first and second-order time-evolving circuits separately, observe their variation with $\\tau$. Then compare them with the theoretical upper bounds calculated above:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "23fd4bee", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate the L1 spectral distance between the two unitary matrices, i.e. the error defined in (5)\n", + "def calculate_error(U1, U2):\n", + " return np.abs(linalg.eig(U1 - U2)[0]).max()\n", + "\n", + "# Encapsulates the function that calculates the error, \n", + "# with the free parameters being the length of each time block tau and the order of the product formula\n", + "def calculate_total_error(tau, order=1):\n", + " h_2 = Hamiltonian([[1, 'Z0, Z1'], [1, 'X0'], [1, 'X1']])\n", + " cir = Circuit()\n", + " # A total time of 1, so steps = int(1/tau), the input tau needs to be divisible by 1\n", + " construct_trotter_circuit(cir, h_2, tau=tau, steps=int(1/tau), order=order)\n", + " cir_U = cir.unitary_matrix().numpy()\n", + " U_evolve = linalg.expm(-1 * 1j * h_2.construct_h_matrix())\n", + " return calculate_error(cir_U, U_evolve)\n", + "\n", + "# Different parameters tau, they need to be divisible by 1\n", + "taus = np.array([0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1])\n", + "errors = []\n", + "\n", + "# Record the total error corresponding to different tau\n", + "for tau in taus:\n", + " errors.append(calculate_total_error(tau)) \n", + "\n", + "# print the graph\n", + "plt.loglog(taus, errors, 'o-', label='error')\n", + "plt.loglog(taus, (3 * taus**2 * (1/taus) * np.exp(3 * taus)), label='bound') # 按照 (10) 计算的一阶误差上界\n", + "plt.legend()\n", + "plt.xlabel(r'$\\tau$', fontsize=12)\n", + "plt.ylabel(r'$\\Vert U_{\\rm cir} - \\exp(-iHt) \\Vert$', fontsize=12)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "9c30f384", + "metadata": {}, + "source": [ + "Next, we set `order` to 2 and calculate the error of the second-order product formula:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "f9fd7378", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "taus = np.array([0.005, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1])\n", + "errors = []\n", + "\n", + "for tau in taus:\n", + " errors.append(calculate_total_error(tau, order=2)) # Specify the order of the Suzuki decomposition \n", + "\n", + "plt.loglog(taus, errors, 'o-', label='error')\n", + "plt.loglog(taus, (2 * taus * 3 )**3 / 3 * (1/taus) * np.exp(3 * taus), '-', label='bound') # The upper bound of the second-order error calculated according to (12)\n", + "plt.legend()\n", + "plt.xlabel(r'$\\tau$', fontsize=12)\n", + "plt.ylabel(r'$\\Vert U_{\\rm cir} - \\exp(-iHt) \\Vert$', fontsize=12)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "f7fff06b", + "metadata": {}, + "source": [ + "As expected, the actual calculated simulation errors are all smaller than their theoretical upper bounds.\n", + "\n", + "## Conclusion\n", + "\n", + "This tutorial introduces how to construct a time-evolving circuit with Paddle Quantum and the theoretical basis behind it, i.e.the Suzuki product formula. Users can construct arbitrary order product formula circuits with custom Hamiltonian to simulate the time evolution of different physical systems.\n", + "\n", + "Quantum simulation is a vast subject and it covers a wide range of applications: the study of many-body localization, time crystals, high-temperature superconductivity, and topological order in condensed matter physics; molecular dynamics simulations and reaction simulations in quantum chemistry; field theory simulations in high-energy physics; even related applications in nuclear physics and cosmology. The Suzuki product formula and digital quantum simulations based on general-purpose quantum computers presented in this tutorial are only part of the quantum simulations. The quantum simulator not based on general-purpose quantum computers, such as analogue quantum simulations on cold atom, superconductor, ion trap and photon platforms also constitute very important topics. For readers who are interested on its applications and general background, we recommend this review [8]. \n", + "\n", + "In the subsequent tutorial [Simulating spin dynamics in one-dimensional Heisenberg chains](./SimulateHeisenberg_EN.ipynb), using the spin model in condensed matter physics as an example, we further show how to perform dynamics simulations of quantum many-body models. In the meantime, we also demonstrate how to design a customized time evolving circuit not based on the Suzuki decomposition.\n" + ] + }, + { + "cell_type": "markdown", + "id": "0705577b", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## References\n", + "\n", + "[1] Feynman, R. P. \"Simulating physics with computers.\" International Journal of Theoretical Physics 21.6 (1982).\n", + " \n", + "[2] Lloyd, Seth. \"Universal quantum simulators.\" [Science (1996): 1073-1078](https://www.jstor.org/stable/2899535).\n", + "\n", + "[3] Childs, Andrew M., et al. \"Toward the first quantum simulation with quantum speedup.\" [Proceedings of the National Academy of Sciences 115.38 (2018): 9456-9461](https://www.pnas.org/content/115/38/9456.short).\n", + "\n", + "[4] Nielsen, Michael A., and Isaac Chuang. \"Quantum computation and quantum information.\" (2002): 558-559.\n", + "\n", + "[5] Tran, Minh C., et al. \"Destructive error interference in product-formula lattice simulation.\" [Physical Review Letters 124.22 (2020): 220502](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.124.220502).\n", + "\n", + "[6] Childs, Andrew M., and Yuan Su. \"Nearly optimal lattice simulation by product formulas.\" [Physical Review Letters 123.5 (2019): 050503](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.123.050503).\n", + "\n", + "[7] Campbell, Earl. \"Random compiler for fast Hamiltonian simulation.\" [Physical Review Letters 123.7 (2019): 070503](https://journals.aps.org/prl/abstract/10.1103/PhysRevLett.123.070503).\n", + "\n", + "[8] Georgescu, Iulia M., Sahel Ashhab, and Franco Nori. \"Quantum simulation.\" [Reviews of Modern Physics 86.1 (2014): 153](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.86.153)." + ] + } + ], + "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.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorial/quantum_simulation/LiH_VQE_parameters.pdtensor b/tutorials/quantum_simulation/LiH_VQE_parameters.pdtensor similarity index 100% rename from tutorial/quantum_simulation/LiH_VQE_parameters.pdtensor rename to tutorials/quantum_simulation/LiH_VQE_parameters.pdtensor diff --git a/tutorial/quantum_simulation/LiH_hamiltonian.txt b/tutorials/quantum_simulation/LiH_hamiltonian.txt similarity index 100% rename from tutorial/quantum_simulation/LiH_hamiltonian.txt rename to tutorials/quantum_simulation/LiH_hamiltonian.txt diff --git a/tutorial/quantum_simulation/SSVQE_CN.ipynb b/tutorials/quantum_simulation/SSVQE_CN.ipynb similarity index 86% rename from tutorial/quantum_simulation/SSVQE_CN.ipynb rename to tutorials/quantum_simulation/SSVQE_CN.ipynb index a45237c..2718db2 100644 --- a/tutorial/quantum_simulation/SSVQE_CN.ipynb +++ b/tutorials/quantum_simulation/SSVQE_CN.ipynb @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:12:57.571029Z", @@ -29,9 +29,11 @@ "import numpy\n", "from numpy import pi as PI\n", "import paddle \n", + "import paddle_quantum\n", "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" + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.qinfo import random_pauli_str_generator, pauli_str_to_matrix\n", + "from paddle_quantum.linalg import dagger" ] }, { @@ -67,7 +69,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:12:57.604652Z", @@ -91,7 +93,8 @@ "print(\"Random Hamiltonian in Pauli string format = \\n\", hamiltonian)\n", "\n", "# 生成 Hamilton 量的矩阵信息\n", - "H = pauli_str_to_matrix(hamiltonian, N)" + "complex_dtype = paddle_quantum.get_dtype()\n", + "H = pauli_str_to_matrix(hamiltonian, N).astype(complex_dtype)" ] }, { @@ -107,7 +110,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:12:57.673600Z", @@ -116,17 +119,15 @@ }, "outputs": [], "source": [ - "THETA_SIZE = 15 # 量子神经网络中参数的数量\n", - "\n", - "def U_theta(theta, N):\n", + "def U_theta(num_qubits: int) -> Circuit:\n", " \"\"\"\n", " U_theta\n", " \"\"\"\n", " # 按照量子比特数量/网络宽度初始化量子神经网络\n", - " cir = UAnsatz(N)\n", + " cir = Circuit(num_qubits)\n", " \n", " # 调用内置的量子神经网络模板\n", - " cir.universal_2_qubit_gate(theta, [0, 1])\n", + " cir.universal_two_qubits([0, 1])\n", "\n", " # 返回量子神经网络的电路\n", " return cir" @@ -153,7 +154,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:12:58.591349Z", @@ -163,22 +164,17 @@ "outputs": [], "source": [ "class Net(paddle.nn.Layer):\n", - " def __init__(self, shape, dtype='float64'):\n", + " def __init__(self, num_qubits: int):\n", " super(Net, self).__init__()\n", - " \n", - " # 初始化 theta 参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " self.theta = self.create_parameter(shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", + "\n", + " # 构造量子神经网络\n", + " self.cir = U_theta(num_qubits)\n", " \n", " # 定义损失函数和前向传播机制\n", - " def forward(self, H, N):\n", - " \n", - " # 构造量子神经网络\n", - " cir = U_theta(self.theta, N)\n", - " U = cir.U\n", + " def forward(self, H):\n", " \n", " # 计算损失函数\n", + " U = self.cir.unitary_matrix()\n", " loss_struct = paddle.real(matmul(matmul(dagger(U), H), U))\n", "\n", " # 输入计算基去计算每个子期望值，相当于取 U^dagger*H*U 的对角元 \n", @@ -192,7 +188,7 @@ " weight = 4 - i\n", " loss += weight * loss_components[i]\n", " \n", - " return loss, loss_components, cir" + " return loss, loss_components, self.cir" ] }, { @@ -205,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:12:59.351881Z", @@ -230,7 +226,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:13:07.503094Z", @@ -251,13 +247,7 @@ "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" + "iter: 100 loss: -5.9848\n" ] } ], @@ -268,7 +258,7 @@ "hamiltonian = paddle.to_tensor(H)\n", "\n", "# 确定网络的参数维度\n", - "net = Net(shape=[THETA_SIZE])\n", + "net = Net(N)\n", "\n", "# 一般来说，我们利用 Adam 优化器来获得相对好的收敛，\n", "# 当然你可以改成 SGD 或者是 RMS prop.\n", @@ -278,7 +268,7 @@ "for itr in range(1, ITR + 1):\n", "\n", " # 前向传播计算损失函数并返回估计的能谱\n", - " loss, loss_components, cir = net(hamiltonian, N)\n", + " loss, loss_components, cir = net(hamiltonian)\n", "\n", " # 在动态图机制下，反向传播极小化损失函数\n", " loss.backward()\n", @@ -287,10 +277,7 @@ "\n", " # 打印训练结果\n", " if itr % 10 == 0:\n", - " print('iter:', itr, 'loss:', '%.4f' % loss.numpy()[0])\n", - " if itr == ITR:\n", - " print(\"\\n训练后的电路：\")\n", - " print(cir)" + " print('iter:', itr, 'loss:', '%.4f' % loss.numpy()[0])" ] }, { @@ -307,21 +294,21 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "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" + "The estimated ground state energy is: [-2.1876235]\n", + "The theoretical ground state energy is: -2.187902\n", + "The estimated 1st excited state energy is: [-0.13721023]\n", + "The theoretical 1st excited state energy is: -0.13704127073287964\n", + "The estimated 2nd excited state energy is: [0.85251486]\n", + "The theoretical 2nd excited state energy is: 0.8523274064064026\n", + "The estimated 3rd excited state energy is: [1.4723194]\n", + "The theoretical 3rd excited state energy is: 1.4726158380508423\n" ] } ], @@ -397,7 +384,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/quantum_simulation/SSVQE_EN.ipynb b/tutorials/quantum_simulation/SSVQE_EN.ipynb similarity index 85% rename from tutorial/quantum_simulation/SSVQE_EN.ipynb rename to tutorials/quantum_simulation/SSVQE_EN.ipynb index 3c92b15..eb8823c 100644 --- a/tutorial/quantum_simulation/SSVQE_EN.ipynb +++ b/tutorials/quantum_simulation/SSVQE_EN.ipynb @@ -2,6 +2,7 @@ "cells": [ { "cell_type": "markdown", + "metadata": {}, "source": [ "# Subspace-search Variational Quantum Eigensolver\n", "\n", @@ -12,30 +13,32 @@ "- 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, - "source": [ - "import numpy\n", - "from numpy import pi as PI\n", - "import paddle \n", - "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": [], + "execution_count": 2, "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", + "import paddle \n", + "import paddle_quantum\n", + "from paddle import matmul\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.qinfo import random_pauli_str_generator, pauli_str_to_matrix\n", + "from paddle_quantum.linalg import dagger" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Background\n", "\n", @@ -46,93 +49,92 @@ "\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": [], + "execution_count": 3, "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, - "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)" - ], + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:27.804177Z", + "start_time": "2021-04-30T09:12:27.779339Z" + } + }, "outputs": [ { - "output_type": "stream", "name": "stdout", + "output_type": "stream", "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" ] } ], - "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", + "complex_dtype = paddle_quantum.get_dtype()\n", + "H = pauli_str_to_matrix(hamiltonian, N).astype(complex_dtype)" + ] }, { "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, + "execution_count": 6, + "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", - "def U_theta(theta, N):\n", + "def U_theta(num_qubits: int) -> Circuit:\n", " \"\"\"\n", " U_theta\n", " \"\"\"\n", " # Initialize the quantum neural network according to the number of qubits/network width\n", - " cir = UAnsatz(N)\n", + " cir = Circuit(num_qubits)\n", " \n", " # Call the built-in quantum neural network template\n", - " cir.universal_2_qubit_gate(theta, [0, 1])\n", + " cir.universal_two_qubits([0, 1])\n", "\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", @@ -147,30 +149,31 @@ "$$\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": 6, + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:28.432737Z", + "start_time": "2021-04-30T09:12:28.423798Z" + } + }, + "outputs": [], "source": [ "class Net(paddle.nn.Layer):\n", - " def __init__(self, shape, dtype='float64'):\n", + " def __init__(self, num_qubits: int):\n", " super(Net, self).__init__()\n", " \n", - " # Initialize the theta parameter list and fill the initial value with the uniform distribution of [0, 2*pi]\n", - " self.theta = self.create_parameter(shape=shape,\n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", - " \n", + " # Build quantum neural network\n", + " self.cir = U_theta(num_qubits)\n", + "\n", " # Define loss function and forward propagation mechanism\n", " def forward(self, H, N):\n", " \n", - " # Build quantum neural network\n", - " cir = U_theta(self.theta, N)\n", - " U = cir.U\n", - " \n", " # Calculate the loss function\n", + " U = self.cir.unitary_matrix()\n", " loss_struct = paddle.real(matmul(matmul(dagger(U), H), U))\n", "\n", " # Enter the computational basis to calculate the expected value \n", @@ -185,53 +188,70 @@ " 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" - } - } + " return loss, loss_components, self.cir" + ] }, { "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": 7, - "source": [ - "ITR = 100 # Set the total number of iterations of training\n", - "LR = 0.3 # Set the learning rate" - ], - "outputs": [], + "execution_count": 8, "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": 9, + "execution_count": 10, + "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" + ] + } + ], "source": [ "paddle.seed(SEED)\n", "\n", @@ -239,7 +259,7 @@ "hamiltonian = paddle.to_tensor(H)\n", "\n", "# Determine the parameter dimension of the network\n", - "net = Net(shape=[THETA_SIZE])\n", + "net = Net(N)\n", "\n", "# We use Adam optimizer for better performance\n", "# One can change it to SGD or RMSprop.\n", @@ -258,44 +278,12 @@ "\n", " # Print training results\n", " if itr% 10 == 0:\n", - " print('iter:', itr,'loss:','%.4f'% loss.numpy()[0])\n", - " 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" - } - } + " print('iter:', itr,'loss:','%.4f'% loss.numpy()[0])" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ "## Benchmarking\n", "\n", @@ -303,12 +291,33 @@ "- 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": 10, + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:12:45.991342Z", + "start_time": "2021-04-30T09:12:45.976287Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The estimated ground state energy is: [-2.1876235]\n", + "The theoretical ground state energy is: -2.187902\n", + "The estimated 1st excited state energy is: [-0.13721023]\n", + "The theoretical 1st excited state energy is: -0.13704127073287964\n", + "The estimated 2nd excited state energy is: [0.85251486]\n", + "The theoretical 2nd excited state energy is: 0.8523274064064026\n", + "The estimated 3rd excited state energy is: [1.4723194]\n", + "The theoretical 3rd excited state energy is: 1.4726158380508423\n" + ] + } + ], "source": [ "def output_ordinalvalue(num):\n", " r\"\"\"\n", @@ -340,32 +349,11 @@ " print('The theoretical {} excited state energy is: {}'.format(\n", " output_ordinalvalue(i), numpy.linalg.eigh(H)[0][i])\n", " )" - ], - "outputs": [ - { - "output_type": "stream", - "name": "stdout", - "text": [ - "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" - ] - } - ], - "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", @@ -380,14 +368,16 @@ "[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": { + "interpreter": { + "hash": "1ba3360425d54dc61cc146cb8ddc529b6d51be6719655a3ca16cefddffc9595a" + }, "kernelspec": { - "name": "python3", - "display_name": "Python 3.8.10 64-bit ('paddle_quantum_test': conda)" + "display_name": "Python 3.8.10 64-bit ('paddle_quantum_test': conda)", + "name": "python3" }, "language_info": { "codemirror_mode": { @@ -399,7 +389,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.10" + "version": "3.8.13" }, "toc": { "base_numbering": 1, @@ -413,11 +403,8 @@ "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/tutorials/quantum_simulation/SimulateHeisenberg_CN.ipynb b/tutorials/quantum_simulation/SimulateHeisenberg_CN.ipynb new file mode 100644 index 0000000..a6c3c80 --- /dev/null +++ b/tutorials/quantum_simulation/SimulateHeisenberg_CN.ipynb @@ -0,0 +1,604 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9d3716bb", + "metadata": {}, + "source": [ + "# 模拟一维海森堡链的自旋动力学\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "id": "c0832e9f", + "metadata": {}, + "source": [ + "## 概述\n", + "\n", + "模拟一个量子系统的性质，是量子计算机的重要应用之一。一般来说，分析一个量子系统的性质需要先写出其哈密顿量 $H$，而对于不同尺度下的物理系统而言，这个哈密顿量往往具有不同的形式。以量子化学为例，一个分子的性质主要由电子-电子之间的库伦相互作用而决定，因此其哈密顿量中的每一项都是由作用在电子波函数上的费米子算符写成的。而量子计算机的基本组成单元量子比特（qubit）以及常用的泡利算符，对应着物理上的自旋和自旋算符。因此，若想在量子计算机上对分子性质进行模拟，则往往需要进行从费米子算符到泡利算符的转换，例如 Jordan-Wigner 变换、Bravyi-Kitaev 变换等等。这也就使得量子计算机需要消耗更多的资源来进行分子哈密顿量的模拟。因此，对于近期的量子设备而言，最有可能率先实现的便是对量子自旋系统的量子模拟——因为这些系统的哈密顿量可以直接写成泡利算符的形式。\n", + "\n", + "在本教程中，我们选取了一个比较经典的量子自旋模型——海森堡模型，并将展示如何利用 Paddle Quantum 来进行一维海森堡自旋链的时间演化模拟。我们主要会使用 `construct_trotter_circuit()` 函数来搭建基于 product formula 的模拟时间演化电路，在先前的教程 [利用 Product Formula 模拟时间演化](./HamiltonianSimulation_CN.ipynb) 中有对该方法较为详细的理论介绍，在本教程中也会有较为简略的回顾。本教程将主要着眼于实际的应用，可以分为两个部分：\n", + "- 海森堡模型的物理背景以及利用 Paddle Quantum 对其时间演化进行模拟 \n", + "- 基于随机置换来搭建自定义时间演化电路" + ] + }, + { + "cell_type": "markdown", + "id": "988b3a47", + "metadata": {}, + "source": [ + "---\n", + "在进一步介绍本教程中涉及的物理背景之前，我们先来回顾一下利用量子电路来模拟时间演化的基本思想，对这部分内容已经比较熟悉的读者可以直接跳至 **海森堡自旋链与其动力学模拟** 继续阅读。\n", + "\n", + "### 利用 Suzuki product formula 模拟时间演化\n", + "\n", + "让我们先回顾一下使用 Suzuki product formula 来模拟时间演化的基本思想：对于一个被不含时的哈密顿量 $H = \\sum_k^L h_k$ 描述的量子系统，其时间演化算符可以写为\n", + "\n", + "$$\n", + "U(t) = e^{-iHt},\n", + "\\tag{1}\n", + "$$\n", + "\n", + "该算符可以被进一步拆分为 $r$ 份，即\n", + "\n", + "$$\n", + "e^{-iHt} = \\left( e^{-iH \\tau} \\right)^r, ~\\tau=\\frac{t}{r}.\n", + "\\tag{2}\n", + "$$\n", + "\n", + "对于每一个 $e^{-iH \\tau}$ 算符而言，其 Suzuki 分解为\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "S_1(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\tau),\n", + "\\\\\n", + "S_2(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\frac{\\tau}{2})\\prod_{k=L}^0 \\exp ( -i h_k \\frac{\\tau}{2}),\n", + "\\\\\n", + "S_{2k+2}(\\tau) &= [S_{2k}(p_k\\tau)]^2S_{2k}\\left( (1-4p_k)\\tau\\right)[S_{2k}(p_k\\tau)]^2.\n", + "\\end{aligned}\n", + "\\tag{3}\n", + "$$\n", + "\n", + "回到完整的时间演化算符 $U(t)$，利用第 $k$ 阶的 Suzuki 分解，它可以被写为\n", + "\n", + "$$\n", + "U(t) = e^{-iHt} = \\left( S_{k}\\left(\\frac{t}{r}\\right) \\right)^r.\n", + "\\tag{4}\n", + "$$\n", + "\n", + "这种模拟时间演化的方法被称为 Suzuki product formula，它可以有效地模拟时间演化过程至任意精度 [1]。在另一份教程 [利用 Product Formula 模拟时间演化](./HamiltonianSimulation_CN.ipynb) 中，我们展示了其误差上界的计算过程，感兴趣的读者可以前往阅读。\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "ab3f7311", + "metadata": {}, + "source": [ + "## 海森堡模型与其动力学模拟\n", + "\n", + "海森堡（Heisenberg）模型，是量子磁性以及量子多体物理研究中十分重要的一个模型。它的哈密顿量为\n", + "\n", + "$$\n", + "H = \\sum_{\\langle i, j\\rangle} \n", + "\\left( J_x S^x_{i} S^x_{j} + J_y S^y_{i} S^y_{j} + J_z S^z_{i} S^z_{j} \\right)\n", + "+\n", + "\\sum_{i} h_z S^z_i, \n", + "\\tag{5}\n", + "$$\n", + "\n", + "其中 $\\langle i, j\\rangle$ 取决于具体的格点几何结构，$J_x, J_y, J_z$ 分别为 $xyz$ 三个方向上的自旋耦合强度，$h_z$ 是 $z$ 方向上的外加磁场。若取 $J_z = 0$，(5) 式也可以用来描述 XY 模型的哈密顿量；取 $J_x = J_y = 0$，(5) 式则可以用来描述伊辛模型（Ising model）的哈密顿量。注意在这里，我们使用了量子多体物理里面比较常用的多体自旋算符 $S^x_i, S^y_i, S^z_i$，它是一个作用在多体波函数上的算符。\n", + "对于自旋-1/2 系统而言，多体自旋算符可以被简单地写为泡利算符的张量积形式（省略一个 $\\hbar/2$ 的系数）\n", + "\n", + "$$\n", + "S^P_{i} = \\left ( \\otimes_{j=0}^{i-1} I \\right ) \\otimes \\sigma_{P} \\otimes \\left ( \\otimes_{j=i+1}^{L} I \\right ),\n", + "P \\in \\{ x, y, z \\},\n", + "\\tag{6}\n", + "$$\n", + "\n", + "其中 $\\sigma_{P}$ 是泡利算符，我们也经常用 $XYZ$ 算符来表示它们。需要说明的是，海森堡模型并不是一个假想模型：从描述电子在格点系统上运动的赫巴德模型（Hubbard model）出发，在一定的极限条件下，电子会被固定在格点上并形成半满填充。此时，描述电子的赫巴德模型就退化为了描述自旋的海森堡模型，而 (5) 式中的自旋-自旋相互作用则是电子-电子之间的相互作用在这个极限下的一种有效交换相互作用 [2]。尽管做了许多的近似，但是海森堡模型依然成功地预言了许多实际材料在低温下的性质 [3]。比如读者可能在高中课本上就学习过的 $\\rm Cu(NO_3)_2 \\cdot 2.5 H_2 O$ 二点五水合硝酸铜在 $\\sim 3K$ 的低温下的行为就可以被自旋-1/2 一维交错海森堡链所描述 [4]。\n", + "\n", + "取决于其具体的格点结构，海森堡模型上可以展示出丰富的量子现象。一维海森堡链可以被用来描述铁磁性与反铁磁性，对称性破缺以及无能隙激发。在二维阻挫格点系统上，海森堡模型可以被用来描述量子自旋液体态-这是一种包含了长程纠缠的新奇量子物态 [5]。若考虑一个外加的无序磁场时，海森堡模型还可以用来研究多体局域化现象（many-body localization, MBL），这是一种违反了热化假说的奇特现象，指的是一个量子多体系统经过了无穷长的时间演化后也不会热化，依然保留着其初态有关的信息 [6]。\n", + "\n", + "模拟海森堡模型的时间演化过程，也被称为动力学模拟，可以帮助人们探索量子系统非平衡态相关的性质，从而用来寻找新奇的量子物相：例如前文提到的多体局域相，又或者更加有趣的时间晶体相 [7]。除了理论，动力学模拟对于实际的物理实验也有着重要的意义。这是因为自旋关联函数（也通常被称为动力学结构因子）直接决定了散射实验中的截面，或者是核磁共振实验的结果 [3]，该函数则是由含时的自旋算符 $\\langle S(t) S(0) \\rangle$ 的积分决定的。因此，通过计算不同理论模型的动力学演化，人们可以进一步对真实材料中的物理模型进行分析。\n", + "\n", + "### 利用 Paddle Quantum 实现海森堡链的动力学模拟" + ] + }, + { + "cell_type": "markdown", + "id": "aea361f7", + "metadata": {}, + "source": [ + "下面，我们则会通过一个实际的例子：链长为 5 的含有无序外磁场的海森堡链，来展示如何在 Paddle Quantum 中搭建其时间演化电路。首先，我们引入相关的包。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c873819", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import numpy as np\n", + "from scipy.linalg import expm\n", + "import matplotlib.pyplot as plt\n", + "import paddle\n", + "from paddle_quantum.trotter import construct_trotter_circuit, get_1d_heisenberg_hamiltonian\n", + "from paddle_quantum.hamiltonian import Hamiltonian, SpinOps\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.qinfo import gate_fidelity \n", + "from paddle_quantum.linalg import dagger\n", + "from paddle_quantum import State, set_backend" + ] + }, + { + "cell_type": "markdown", + "id": "6c81929b", + "metadata": {}, + "source": [ + "接下来，我们利用 `get_1d_heisenberg_hamiltonian()` 函数来得到一个一维海森堡链的哈密顿量： " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "88fa56fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "系统的哈密顿量为：\n", + "1.0 X0, X1\n", + "1.0 Y0, Y1\n", + "2.0 Z0, Z1\n", + "1.0 X1, X2\n", + "1.0 Y1, Y2\n", + "2.0 Z1, Z2\n", + "1.0 X2, X3\n", + "1.0 Y2, Y3\n", + "2.0 Z2, Z3\n", + "1.0 X3, X4\n", + "1.0 Y3, Y4\n", + "2.0 Z3, Z4\n", + "0.9659664717905148 Z0\n", + "0.18140478374146563 Z1\n", + "-0.2360298339665814 Z2\n", + "-0.035571124976342405 Z3\n", + "-0.044290276761568936 Z4\n" + ] + } + ], + "source": [ + "h = get_1d_heisenberg_hamiltonian(length=5, j_x=1, j_y=1, j_z=2, h_z=2 * np.random.rand(5) - 1, periodic_boundary_condition=False)\n", + "print('系统的哈密顿量为：')\n", + "print(h)" + ] + }, + { + "cell_type": "markdown", + "id": "0793414b", + "metadata": {}, + "source": [ + "得到了哈密顿量之后，可以进一步通过 `construct_trotter_circuit()` 来构建时间演化电路。此外，若直接写出演化算符的矩阵形式，也可以计算系统随时间演化的精确解。这里我们用到了量桨中的 `Hamiltonian.construct_h_matrix()` 方法，它可以计算给定哈密顿量在泡利 $Z$ 基底下的矩阵形式。通过比较 `Circuit.unitary_matrix()`，即电路的酉矩阵形式，以及精确的演化算符，可以计算出该电路模拟时间演化的保真度。" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5052fb32", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "电路的酉矩阵与正确的演化算符之间的保真度为：0.59\n" + ] + } + ], + "source": [ + "# 计算演化时长为 t 时的精确演化算符\n", + "def get_evolve_op(t): \n", + " return paddle.to_tensor(expm(-1j * t * h.construct_h_matrix()), dtype='complex64')\n", + "\n", + "# 设置演化时长以及模拟的步长\n", + "t = 3\n", + "r = 10\n", + "# 搭建模拟演化电路\n", + "set_backend('state_vector')\n", + "cir_evolve = Circuit()\n", + "construct_trotter_circuit(cir_evolve, h, tau=t/r, steps=r, order=2)\n", + "# 得到电路的酉矩阵并计算与精确演化算符之间的保真度\n", + "U_cir = cir_evolve.unitary_matrix()\n", + "print('电路的酉矩阵与正确的演化算符之间的保真度为：%.2f' % gate_fidelity(get_evolve_op(t), U_cir))" + ] + }, + { + "cell_type": "markdown", + "id": "ce487d74", + "metadata": {}, + "source": [ + "#### 根据对易关系重新排列哈密顿量\n", + "\n", + "对于 product formula 而言，可以通过重新排列哈密顿量中的每一项减小其模拟误差。因为 product formula 的误差是由哈密顿量中不对易项所产生的，所以一种自然的重新排列思路就是将哈密顿量中相互对易的项放在一起。比如，我们可以将哈密顿量分解为四个部分\n", + "\n", + "$$\n", + "H = H_x + H_y + H_z + H_{\\rm other},\n", + "\\tag{7}\n", + "$$\n", + "\n", + "其中 $H_x, H_y, H_z$ 分别为仅由泡利 $X, Y, Z$ 算符构成的项，$H_{\\rm other}$ 为剩余项。对于 (5) 中的海森堡链的哈密顿量而言，所有的项都可以被分类为 $H_x, H_y, H_z$ 三项。不仅如此，对于一维最近邻相互作用系统而言，它也可以被分为奇偶两个部分\n", + "\n", + "$$\n", + "H = H_{\\rm even} + H_{\\rm odd},\n", + "\\tag{8}\n", + "$$\n", + "\n", + "其中 $H_{\\rm even}$ 为 $(0, 1), (2, 3), ...$ 格点上的相互作用项，$H_{\\rm odd}$ 为 $(1, 2), (3, 4), ...$ 格点上的相互作用项。 不过需要指出的是，这两种排列方式都不能减少其理论上的误差上界。并且从经验的角度来说，它们也不是总能减小实际的模拟误差。实际上，确定对于某一类哈密顿量而言模拟误差的排列方式，是一个十分值得探索的问题。对于量桨中的 `construct_h_matrix()` 函数而言，用户可以通过指定 `grouping='xyz'` 或者 `grouping='even_odd'` 来实现上文中提到的两种重新排列方式，此外，通过传入参数 `permutation` 也可以指定自定义排列顺序。关于后一点，本教程将在下文章节 **设计基于随机置换的自定义时间演化电路** 中进一步介绍。下面，先让我们来看一下关于 `grouping` 参数的使用方法：" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b2eaca4c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "原始保真度为： Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=True,\n", + " [0.58580196])\n", + "XYZ 排列后的模拟保真度为： Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=True,\n", + " [0.73854429])\n", + "奇偶排列后的模拟保真度为： Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=True,\n", + " [0.74752402])\n" + ] + } + ], + "source": [ + "# 保持同样的时间演化参数，但是在通过 'grouping=\"xyz\"' 和 'groping=\"even_odd\"' 指定哈密顿量排列\n", + "cir_evolve_xyz = Circuit()\n", + "cir_evolve_even_odd = Circuit()\n", + "construct_trotter_circuit(cir_evolve_xyz, h, tau=t/r, steps=r, order=2, grouping='xyz')\n", + "construct_trotter_circuit(cir_evolve_even_odd, h, tau=t/r, steps=r, order=2, grouping='even_odd')\n", + "U_cir_xyz = cir_evolve_xyz.unitary_matrix()\n", + "U_cir_even_odd = cir_evolve_even_odd.unitary_matrix()\n", + "print('原始保真度为：', gate_fidelity(get_evolve_op(t), U_cir))\n", + "print('XYZ 排列后的模拟保真度为：', gate_fidelity(get_evolve_op(t), U_cir_xyz))\n", + "print('奇偶排列后的模拟保真度为：', gate_fidelity(get_evolve_op(t), U_cir_even_odd))" + ] + }, + { + "cell_type": "markdown", + "id": "f18e3f16", + "metadata": {}, + "source": [ + "#### 初态制备以及对演化后的末态进行观测\n", + "\n", + "下面，我们来制备系统的初态。一般来说，在研究量子多体系统的动力学行为时，一种做法是将系统的初态制备为各种不同的直积态。在量桨中，我们默认的初态为 $\\vert 0...0 \\rangle$，这里我们可以通过 $X$ 门来将奇数格点上的自旋进行翻转，这样系统的初态就制备为了 $\\vert 01010 \\rangle$ 态，用自旋来标记的话则是 $\\vert \\downarrow \\uparrow \\downarrow \\uparrow \\downarrow \\rangle$ 态。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0ff6736", + "metadata": {}, + "outputs": [], + "source": [ + "# 创建一个用于制备初态的电路，并通过演化得到初态\n", + "cir = Circuit(5)\n", + "cir.x(1)\n", + "cir.x(3)\n", + "init_state = cir()" + ] + }, + { + "cell_type": "markdown", + "id": "ffa62418", + "metadata": {}, + "source": [ + "通过将系统的初态 `init_state` 传入线路，我们可以利用刚刚定义的量子线路来演化该初态，并得到演化后的末态。对于演化后的末态，可以使用 `State.expec_val()` 方法来测量其上的可观测量。这里我们简单地考虑对每个格点上的自旋状态进行观测，即测量可观测量 $\\langle S^z_i \\rangle$，其对应的 Pauli string 为 `[[1, 'Zi']]`（i 为格点下标）。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "88d5e1b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "演化后格点 0 上自旋的 z 方向期望为： Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=False,\n", + " [0.65030456])\n" + ] + } + ], + "source": [ + "output_state = cir_evolve_even_odd(init_state)\n", + "print('演化后格点 0 上自旋的 z 方向期望为：', output_state.expec_val(Hamiltonian([[1, 'Z0']]), shots = 0))" + ] + }, + { + "cell_type": "markdown", + "id": "e70d9fba", + "metadata": {}, + "source": [ + "类似地，通过调整模拟演化的时间长度以及测量的量子比特编号，我们可以绘制出系统中的每个自旋的状态随着时间的完整变化过程。注意这里为了计算理论上的精确解，我们使用了 `SpinOps` 类来构建 $S_i^z$ 算符的矩阵形式，并通过 $\\langle \\psi(t) \\vert S_i^z \\vert \\psi(t) \\rangle$ 来计算其期望值。" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6c4c03ea", + "metadata": {}, + "outputs": [], + "source": [ + "def get_evolution_z_obs(h, t_total, order=None, n_steps=None, exact=None):\n", + " \"\"\"\n", + " 该函数可以计算演化过程 t 中系统每个格点上的 Sz 可观测量的变化过程\n", + " 通过 order, n_steps 控制 trotter-suzuki 分解的步长和阶数\n", + " 通过设置 exact=True 可以计算对应的精确解\n", + " \"\"\"\n", + " z_obs_total = []\n", + " for t in np.linspace(0., t_total, t_total * 3 + 1):\n", + " z_obs = []\n", + " # 通过演化算符或者运行电路得到末态\n", + " if exact:\n", + " spin_operators = SpinOps(h.n_qubits)\n", + " fin_state = get_evolve_op(t) @ init_state.data\n", + " else:\n", + " cir_evolve = Circuit(5)\n", + " construct_trotter_circuit(cir_evolve, h, tau=t/n_steps, steps=n_steps, order=order, grouping='even_odd')\n", + " fin_state = cir_evolve(init_state)\n", + " # 对每个格点上的可观测量进行观测\n", + " for site in range(h.n_qubits):\n", + " if exact:\n", + " observable = paddle.to_tensor(spin_operators.sigz_p[site], dtype='complex64')\n", + " z_obs.append(dagger(fin_state) @ observable @ fin_state)\n", + " else:\n", + " z_obs.append(fin_state.expec_val(Hamiltonian([[1, 'Z' + str(site)]]), shots=0))\n", + " z_obs_total.append(z_obs)\n", + " return np.array(z_obs_total).real \n", + "\n", + "def plot_comparison(**z_obs_to_plot):\n", + " \"\"\" \n", + " 绘制不同的演化结果进行对比，默认每个传入的参数都是 get_evolution_z_obs() 函数的输出并具有同样的演化时间\n", + " \"\"\"\n", + " fig, axes = plt.subplots(1, len(z_obs_to_plot), figsize = [len(z_obs_to_plot) * 3, 5.5])\n", + " \n", + " ax_idx = 0\n", + " for label in z_obs_to_plot.keys():\n", + " im = axes[ax_idx].imshow(z_obs_to_plot[label], cmap='coolwarm_r', interpolation='kaiser', origin='lower')\n", + " axes[ax_idx].set_title(label, fontsize=15)\n", + " ax_idx += 1\n", + "\n", + " for ax in axes:\n", + " ax.set_xlabel('site', fontsize=15)\n", + " ax.set_yticks(np.arange(0, z_obs_total_exact.shape[0], 3))\n", + " ax.set_yticklabels(np.arange(0, z_obs_total_exact.shape[0]/3, 1))\n", + " ax.set_xticks(np.arange(z_obs_total_exact.shape[1]))\n", + " ax.set_xticklabels(np.arange(z_obs_total_exact.shape[1]))\n", + "\n", + " axes[0].set_ylabel('t', fontsize=15)\n", + " cax = fig.add_axes([0.92, 0.125, 0.02, 0.755])\n", + " \n", + " \n", + " fig.colorbar(im, cax)\n", + " cax.set_ylabel(r'$\\langle S^z_i (t) \\rangle$', fontsize=15)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3735e79a", + "metadata": {}, + "outputs": [], + "source": [ + "# 分别计算时长为 3 时，通过步长为 25、5 的电路得到的演化过程，以及精确解\n", + "z_obs_total_exact = get_evolution_z_obs(h, t_total=3, exact=True)\n", + "z_obs_total_cir = get_evolution_z_obs(h, order=1, n_steps=25, t_total=3)\n", + "z_obs_total_cir_short = get_evolution_z_obs(h, order=1, n_steps=5, t_total=3)\n", + "\n", + "plot_comparison(\n", + " Exact=z_obs_total_exact,\n", + " L25_Circuit=z_obs_total_cir,\n", + " L5_Circuit=z_obs_total_cir_short)" + ] + }, + { + "cell_type": "markdown", + "id": "707ecfdf", + "metadata": {}, + "source": [ + "我们观察到当线路的深度为 25 时（注意这里的深度指的是时间块的数量而不是量子门的层数），量子电路可以较好的模拟系统在完整演化时间内的自旋动力学。若使用较浅的量子线路，则只能正确模拟系统的行为至一定的时间。\n", + "\n", + "**思考：** 读者是否可以尝试来测量自旋空间关联函数 $\\langle S_i^z S_j^{z} \\rangle$ 并观察其随时间的变化？" + ] + }, + { + "cell_type": "markdown", + "id": "af97d494", + "metadata": {}, + "source": [ + "## 设计基于随机置换的自定义时间演化电路\n", + "\n", + "### 随机置换\n", + "\n", + "尽管从物理的角度上看来，将哈密顿量中的对易项重新排列在一起来减小模拟误差是符合直觉的，但是许多证据都表明，固定一种哈密顿量排列的演化策略将会导致模拟误差不断地累积，反而不如将哈密顿量的排列顺序在每个“时间块”中都进行随机置换来得有效 [8, 9]。人们发现，通过不断地将哈密顿量的排列顺序进行随机置换，其演化过程中造成的随机误差比起固定排列时的累积误差来说更加“无害” [8]。无论是在理论上的误差上界与经验性的实验都表明，这种随机排列的演化策略比起固定排列的 Suzuki product formula 具有更小的误差 [9]。" + ] + }, + { + "cell_type": "markdown", + "id": "63f289c5", + "metadata": {}, + "source": [ + "### 搭建自定义时间演化电路\n", + "\n", + "量桨中的 `construct_trotter_circuit()` 函数会默认根据 Suzuki product formula 以及输入哈密顿量的顺序来添加时间演化电路。同时，用户可以通过设置 `method='custom'` 并同时向参数 `permutation` 以及 `coefficient` 传入数组的方式来自定义时间演化策略。\n", + "\n", + "**提醒：** 用户在使用 `coefficient`、`tau` 以及 `steps` 参数时需要小心它们之间的关系。一般情况下，传入 `coefficient` 的数组应当是归一化的，即它本身描述的是 $t=1$ 的时间演化过程。在这个基础上，通过设置更多的 `steps`，该函数会将传入的自定义参数所描述的时间演化策略作为一个基本的“时间块”并进行重复，其中每个时间块的演化时长由参数 `tau` 决定。举个例子，若设置 `permutation=np.arange(h.n_qubits)` 且 `coefficient=np.ones(h.n_qubits)`，此时通过 `tau` 与 `steps` 来定义的时间演化电路与一阶 product formula 电路是完全一致的。" + ] + }, + { + "cell_type": "markdown", + "id": "e72345ac", + "metadata": {}, + "source": [ + "让我们进一步实际展示一下该自定义功能：考虑和之前相同的哈密顿量，现在我们通过设计一个时间演化电路来测试上文提到的随机置换的结论，即我们希望搭建一个类似于一阶 product formula 的电路，只不过在每个”时间块“内的哈密顿量排列是完全随机且独立的。通过传入一个形状为 `(n_steps, h.n_terms)` 且其每一行都是一个随机置换 $P(N)$ 的数组至参数 `permutation`，就可以实现这一想法：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1740ec7f", + "metadata": {}, + "outputs": [], + "source": [ + "# 自定义 permutation 参数的一个例子\n", + "permutation = np.vstack([np.random.permutation(h.n_terms) for i in range(100)])" + ] + }, + { + "cell_type": "markdown", + "id": "23a1eb6d", + "metadata": {}, + "source": [ + "接下来，为了验证，可以分别计算该随机电路以及一阶 product formula 在不同电路深度下与精确解之间的保真度来进行比较：" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "73084cfc", + "metadata": {}, + "outputs": [], + "source": [ + "def compare(n_steps):\n", + " \"\"\"\n", + " 比较一阶 product formula 以及随机置换方法在同样的步长的情况下对于固定演化时长 t=2 时的保真度\n", + " 输入参数控制步长，输出分别为一阶 product formula 以及随机置换的保真度\n", + " \"\"\"\n", + " t = 2\n", + " cir_evolve = Circuit()\n", + " construct_trotter_circuit(cir_evolve, h, tau=t/n_steps, steps=n_steps, order=1)\n", + " U_cir = cir_evolve.unitary_matrix()\n", + " fid_suzuki = gate_fidelity(get_evolve_op(t), U_cir)\n", + " cir_permute = Circuit()\n", + " permutation = np.vstack([np.random.permutation(h.n_terms) for i in range(n_steps)])\n", + " # 当不指定 coefficient 参数时，会默认根据 permutation 的形状设置一个归一化且均匀的 coefficient\n", + " construct_trotter_circuit(cir_permute, h, tau=t, steps=1, method='custom', permutation=permutation)\n", + " U_cir = cir_permute.unitary_matrix()\n", + " fid_random = gate_fidelity(get_evolve_op(t), U_cir)\n", + " return fid_suzuki, fid_random\n", + "\n", + "# 比较在不同步长时的两种方案的保真度\n", + "# 出于运行时间的考虑，只进行一次试验，感兴趣的读者可以进行多次重复实验并计算其 error bar\n", + "n_range = [100, 200, 500, 1000]\n", + "result = [compare(n) for n in n_range]\n", + "\n", + "result = 1 - np.array(result)\n", + "plt.loglog(n_range, result[:, 0], 'o-', label='1st order PF')\n", + "plt.loglog(n_range, result[:, 1], 'o-', label='Random')\n", + "plt.xlabel(r'Trotter number $r$', fontsize=12)\n", + "plt.ylabel(r'Error: $1 - {\\rm Fid}$', fontsize=12)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "85f72361", + "metadata": {}, + "source": [ + "图中，“1st order PF” 指按照固定顺序搭建的一阶 product formula 电路。与预期一样，随机置换确实可以在相同的电路深度下达到比一阶 product formula 更好的模拟效果。\n", + "\n", + "**思考：** 在 [9] 中，作者指出这种随机的策略在没有利用任何与哈密顿量有关的信息的前提下就取得了更小的误差，那么有理由相信存在一种方法可以在利用哈密顿量信息的同时进一步减小该误差。这对于人们设计更好的模拟时间演化策略带来了启发。" + ] + }, + { + "cell_type": "markdown", + "id": "4f193c11", + "metadata": {}, + "source": [ + "## 小结\n", + "\n", + "对于量子多体系统的动力学性质进行研究，是理解新奇量子物态的重要手段。由于其高度纠缠的量子力学本质，无论是在理论上还是在实验上的研究都是十分困难的。时至今日，人们对于不同几何结构，不同相互作用下的二维，乃至包含了无序性的一维系统上的物理现象都没能完全理解。另一方面，通用量子计算机以及量子模拟器的快速发展给这一问题的解决带来了新的希望。以通用量子计算机为例，通过搭建量子电路，其优势在于可以模拟各种复杂情况下的系统演化过程，例如，模拟其哈密顿量随时间周期性变化的系统从而寻找“时间晶体”的存在。随着量子比特数目和控制能力的进一步提高，通用量子计算机有望在近未来内在模拟量子系统时间演化这一任务上超越经典计算机，这其中，最有希望最先取得进展的就是量子自旋系统的模拟。\n", + "\n", + "本教程主要介绍了如何在量桨中模拟一个真实量子自旋模型的时间演化过程，并且进一步探讨了基于量桨来设计新的时间演化策略的可能性。通过 `construct_trotter_circuit()` 函数以及 `Hamiltonian` 和 `SpinOps` 类中提供的各种方法，用户现在可以简单地设计并测试不同搭建时间演化的策略。我们也鼓励读者在更多的物理系统上尝试不同的时间演化策略，并一起探索更加高效的量子模拟电路。" + ] + }, + { + "cell_type": "markdown", + "id": "ff5b39fa", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Childs, Andrew M., et al. \"Toward the first quantum simulation with quantum speedup.\" [Proceedings of the National Academy of Sciences 115.38 (2018): 9456-9461](https://www.pnas.org/content/115/38/9456.short).\n", + "\n", + "[2] Eckle, Hans-Peter. Models of Quantum Matter: A First Course on Integrability and the Bethe Ansatz. [Oxford University Press, 2019](https://oxford.universitypressscholarship.com/view/10.1093/oso/9780199678839.001.0001/oso-9780199678839).\n", + "\n", + "[3] Mikeska, Hans-Jürgen, and Alexei K. Kolezhuk. \"One-dimensional magnetism.\" Quantum magnetism. Springer, Berlin, Heidelberg, 2004. 1-83.\n", + "\n", + "[4] Berger, L., S. A. Friedberg, and J. T. Schriempf. \"Magnetic Susceptibility of $\\rm Cu(NO_3)_2·2.5 H_2O$ at Low Temperature.\" [Physical Review 132.3 (1963): 1057](https://journals.aps.org/pr/abstract/10.1103/PhysRev.132.1057).\n", + "\n", + "[5] Broholm, C., et al. \"Quantum spin liquids.\" [Science 367.6475 (2020)](https://science.sciencemag.org/content/367/6475/eaay0668).\n", + "\n", + "[6] Abanin, Dmitry A., et al. \"Colloquium: Many-body localization, thermalization, and entanglement.\" [Reviews of Modern Physics 91.2 (2019): 021001](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.91.021001).\n", + "\n", + "[7] Medenjak, Marko, Berislav Buča, and Dieter Jaksch. \"Isolated Heisenberg magnet as a quantum time crystal.\" [Physical Review B 102.4 (2020): 041117](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.102.041117).\n", + "\n", + "[8] Wallman, Joel J., and Joseph Emerson. \"Noise tailoring for scalable quantum computation via randomized compiling.\" [Physical Review A 94.5 (2016): 052325](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.94.052325).\n", + "\n", + "[9] Childs, Andrew M., Aaron Ostrander, and Yuan Su. \"Faster quantum simulation by randomization.\" [Quantum 3 (2019): 182](https://quantum-journal.org/papers/q-2019-09-02-182/)." + ] + }, + { + "cell_type": "markdown", + "id": "154d1a3a", + "metadata": {}, + "source": [ + "\n", + "\n", + "from scipy import linalg\n", + "import matplotlib.pyplot as plt\n", + "from paddle_quantum.hamiltonian import SpinOps, Hamiltonian\n", + "\n" + ] + } + ], + "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.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/quantum_simulation/SimulateHeisenberg_EN.ipynb b/tutorials/quantum_simulation/SimulateHeisenberg_EN.ipynb new file mode 100644 index 0000000..4e0d806 --- /dev/null +++ b/tutorials/quantum_simulation/SimulateHeisenberg_EN.ipynb @@ -0,0 +1,604 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "9d3716bb", + "metadata": {}, + "source": [ + "# Simulate the Spin Dynamics on a Heisenberg Chain\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "id": "c0832e9f", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "The simulation of quantum systems is one of the many important applications of quantum computers. In general, the system's properties are characterized by its Hamiltonian operator $H$. For physical systems at different scales, their Hamiltonian takes different forms. For example in quantum chemistry, where we are often interested in the properties of molecules, which are determined mostly by electron-electron Coulomb interactions. As a consequence, a molecular Hamiltonian is usually written in the form of fermionic operators which act on the electron's wave function. On the other hand, the basic computational unit of a quantum computer - qubit, and its corresponding operations, correspond to spin and spin operators in physics. So in order to simulate a molecular Hamiltonian on a quantum computer, one needs to first map fermionic operators into spin operators with mappings such as Jordan-Wigner or Bravyi-Kitaev transformation, etc. Those transformations often create additional overhead for quantum simulation algorithms, make them more demanding in terms of a quantum computer's number of qubits, connectivity, and error control. It was commonly believed that one of the most near-term applications for quantum computers it the simulation of quantum spin models, whose Hamiltonian are natively composed of Pauli operators. \n", + "\n", + "This tutorial will demonstrate how to simulate the time evolution process of a one-dimensional Heisenberg chain, one of the most commonly studied quantum spin models. This tutorial is based on the `construct_trotter_circuit()`, which can construct the Trotter-Suzuki or any custom trotterization circuit to simulate the time-evolving operator. We have already covered some of the basic usage as well as the theoretical background in another tutorial [Hamiltonian Simulation with Product Formula](./HamiltonianSimulation_EN.ipynb). A brief introduction of the Suzuki product formula is provided below for readers who are not familiar with it. In the remainder of this tutorial, we will be focusing on two parts:\n", + "- Simulating the spin dynamics on a Heisenberg chain\n", + "- Using randomized permutation to build a custom trotter circuit" + ] + }, + { + "cell_type": "markdown", + "id": "988b3a47", + "metadata": {}, + "source": [ + "---\n", + "Before discussing the physical background of the Heisenberg model, let's go over the basic concepts of time evolution simulation with a quantum circuit. Readers already familiar with this or uninterested in such details could choose to skip to the section of **Heisenberg model and its dynamical simulation** to continue reading.\n", + "\n", + "### Simulate the time evolution with Suzuki product formula\n", + "\n", + "The core idea of the Suzuki product formula can be described as follows: First, for a time-independent Hamiltonian $H = \\sum_k^L h_k$, the system's time evolution operator is \n", + "\n", + "$$\n", + "U(t) = e^{-iHt}.\n", + "\\tag{1}\n", + "$$\n", + "\n", + "Further dividing it into $r$ pieces, we have\n", + "\n", + "$$\n", + "e^{-iHt} = \\left( e^{-iH \\tau} \\right)^r, ~\\tau=\\frac{t}{r}.\n", + "\\tag{2}\n", + "$$\n", + "\n", + "This strategy is sometimes referred to as \"Totterization\". \n", + "\n", + "And for each $e^{-iH \\tau}$ operator, its Suzuki decompositions are\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "S_1(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\tau),\n", + "\\\\\n", + "S_2(\\tau) &= \\prod_{k=0}^L \\exp ( -i h_k \\frac{\\tau}{2})\\prod_{k=L}^0 \\exp ( -i h_k \\frac{\\tau}{2}),\n", + "\\\\\n", + "S_{2k+2}(\\tau) &= [S_{2k}(p_k\\tau)]^2S_{2k}\\left( (1-4p_k)\\tau\\right)[S_{2k}(p_k\\tau)]^2.\n", + "\\end{aligned}\n", + "\\tag{3}\n", + "$$\n", + "\n", + "Back to the original time evolution operator $U(t)$, with the $k$-th order Suzuki decomposition, it can be reformulated as\n", + "\n", + "$$\n", + "U(t) = e^{-iHt} = \\left( S_{k}\\left(\\frac{t}{r}\\right) \\right)^r.\n", + "\\tag{4}\n", + "$$\n", + "\n", + "The above scheme is referred to as the Suzuki product formula or Trotter-Suzuki decomposition. It is proven that it could efficiently simulate any time evolution process of a system with a k-local Hamiltonian up to arbitrary precision [1]. In another tutorial [Hamiltonian Simulation with Product Formula](./HamiltonianSimulation_EN.ipynb), we have shown how to calculate its error upper bound.\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "id": "ab3f7311", + "metadata": {}, + "source": [ + "## Heisenberg Model and Its Dynamic Simulation\n", + "\n", + "The Heisenberg model is arguably one of the most commonly used model in the research of quantum magnetism and quantum many-body physics. Its Hamiltonian can be expressed as \n", + "\n", + "$$\n", + "H = \\sum_{\\langle i, j\\rangle} \n", + "\\left( J_x S^x_{i} S^x_{j} + J_y S^y_{i} S^y_{j} + J_z S^z_{i} S^z_{j} \\right)\n", + "+\n", + "\\sum_{i} h_z S^z_i, \n", + "\\tag{5}\n", + "$$\n", + "\n", + "with $\\langle i, j\\rangle$ depends on the specific lattice structure, $J_x, J_y, J_z$ describe the spin coupling strength respectively in the $xyz$ directions and $h_z$ is the magnetic field applied along the $z$ direction. When taking $J_z = 0$, the Hamiltonian in (5) can be used to describe the XY model; or when taking $J_x = J_y = 0$, then (5) is reduced to the Hamiltonian of Ising model. Note that here we used a notation of many-body spin operators $S^x_i, S^y_i, S^z_i$ which act on each of the local spins, this is slightly different from our usual notations but are very common in the field of quantum many-body physics. For a spin-1/2 system, when neglecting a coefficient of $\\hbar/2$, the many-body spin operators are simple tensor products of Pauli operators, i.e.\n", + "\n", + "$$\n", + "S^P_{i} = \\left ( \\otimes_{j=0}^{i-1} I \\right ) \\otimes \\sigma_{P} \\otimes \\left ( \\otimes_{j=i+1}^{L} I \\right ),\n", + "P \\in \\{ x, y, z \\},\n", + "\\tag{6}\n", + "$$\n", + "\n", + "where the $\\sigma_{P}$ are Pauli operators, which can also be represented as $XYZ$. It is worth noting that while the Heisenberg model is an important theoretical model, but it also describes the physics in realistic materials (crystals). Starting from the Hubbard model, which describes the interactions and movement of electrons on a lattice, under certain conditions, the electrons are fixed to each site and form a half-filling case. In this case, the only left-over interaction is an effective spin-spin exchange interaction and the Hubbard model is reduced to the Heisenberg model [2]. While it seems that many approximations are made, the Heisenberg model has successfully described the properties of many crystal materials at low temperatures [3]. For example, many readers might be familiar with the copper nitrate crystal ($\\rm Cu(NO_3)_2 \\cdot 2.5 H_2 O$), and its behavior at $\\sim 3k$ can be described by an alternating spin-1/2 Heisenberg chain [4].\n", + "\n", + "Depending on the lattice structure, the Heisenberg model can host highly non-trivial quantum phenomena. As a one-dimensional chain, it demonstrates ferromagnetism and anti-ferromagnetism, symmetry breaking and gapless excitations [3]. On frustrated two-dimension lattices, some Heisenberg models constitute candidate models for quantum spin liquids, a long-range entangled quantum matter [5]. When under a disordered external magnet field, the Heisenberg model also can be used in the research of a heated topic, many-body localization, where the system violates the thermalization hypothesis and retains memories of its initial state after infinitely long time's evolution [6]. \n", + "\n", + "Simulating the time evolution of a Heisenberg model, i.e. the dynamical simulation, could help us to investigate the non-equilibrium properties of the system, and it might help us to locate novel quantum phases such as the many-body localized (MBL) phase introduced above or even more interestingly, time crystal phases [7]. Other than developing theories, the dynamic simulation plays a vital role for experimentalists, as the spin correlation function (also referred to as dynamical structure factors) is directly linked to the cross sections for scattering experiments or line shapes in nuclear magnetic resonance (NMR) experiments [3]. And this function, which we omit its exact form here, is a function of integration over $\\langle S(t) S(0) \\rangle$. So that in order to bridge the experiment and theory, one also need to compute the system's evolution in time.\n", + "\n", + "### Use Paddle Quantum to simulate and observe the time evolution process of a Heisenberg chain" + ] + }, + { + "cell_type": "markdown", + "id": "ca09d58d", + "metadata": {}, + "source": [ + "Now, we will take a one dimensional Heisenberg chain under disordered field of length 5 as an example, and demonstrate how the construct its time evolving circuit in Paddle Quantum. First we need to import relevant packages." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5c873819", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings(\"ignore\")\n", + "import numpy as np\n", + "from scipy.linalg import expm\n", + "import matplotlib.pyplot as plt\n", + "import paddle\n", + "from paddle_quantum.trotter import construct_trotter_circuit, get_1d_heisenberg_hamiltonian\n", + "from paddle_quantum.hamiltonian import Hamiltonian, SpinOps\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.qinfo import gate_fidelity \n", + "from paddle_quantum.linalg import dagger\n", + "from paddle_quantum import State, set_backend " + ] + }, + { + "cell_type": "markdown", + "id": "d96d3bcb", + "metadata": {}, + "source": [ + "Then we use `get_1d_heisenberg_hamiltonian()` function to generate the Hamiltonian of a Heisenberg chain." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "88fa56fe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "系统的哈密顿量为：\n", + "1.0 X0, X1\n", + "1.0 Y0, Y1\n", + "2.0 Z0, Z1\n", + "1.0 X1, X2\n", + "1.0 Y1, Y2\n", + "2.0 Z1, Z2\n", + "1.0 X2, X3\n", + "1.0 Y2, Y3\n", + "2.0 Z2, Z3\n", + "1.0 X3, X4\n", + "1.0 Y3, Y4\n", + "2.0 Z3, Z4\n", + "-0.5316240172294089 Z0\n", + "0.0616244938240631 Z1\n", + "0.13492415166906135 Z2\n", + "0.9909026287282454 Z3\n", + "-0.24633413531962578 Z4\n" + ] + } + ], + "source": [ + "h = get_1d_heisenberg_hamiltonian(length=5, j_x=1, j_y=1, j_z=2, h_z=2 * np.random.rand(5) - 1, periodic_boundary_condition=False)\n", + "print('系统的哈密顿量为：')\n", + "print(h)" + ] + }, + { + "cell_type": "markdown", + "id": "0793414b", + "metadata": {}, + "source": [ + "After obtaining its Hamiltonian, we can then pass it to the `construct_trotter_circuit()` function to construct its time evolution circuit. Also, with `Hamiltonian.construct_h_matrix()` who returns the matrix form of a `Hamiltonian` object, we can calculate its exponential, i.e. the exact time-evolving operator. By taking the quantum circuit's unitary matrix `Circuit.unitary_matrix()` and comparing it to the exact time-evolving operator by calculating their fidelity, we can evaluate how well the constructed circuit could describe the correct time evolution process." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5052fb32", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The fidelity between the circuit's unitary and the exact evolution operator is : 0.58\n" + ] + } + ], + "source": [ + "# calculate the exact evolution operator of time t\n", + "def get_evolve_op(t): \n", + " return paddle.to_tensor(expm(-1j * t * h.construct_h_matrix()), dtype='complex64')\n", + "\n", + "# set the total evolution time and the number of trotter steps\n", + "t = 3\n", + "r = 10\n", + "# construct the evolution circuit\n", + "set_backend('state_vector')\n", + "cir_evolve = Circuit()\n", + "construct_trotter_circuit(cir_evolve, h, tau=t/r, steps=r, order=2)\n", + "# get the circuit's unitary matrix and calculate its fidelity to the exact evolution operator\n", + "U_cir = cir_evolve.unitary_matrix()\n", + "print('The fidelity between the circuit\\'s unitary and the exact evolution operator is : %.2f' % gate_fidelity(get_evolve_op(t), U_cir))" + ] + }, + { + "cell_type": "markdown", + "id": "ce487d74", + "metadata": {}, + "source": [ + "#### Permute the Hamiltonian according to commutation relationships\n", + "\n", + "It has been shown that the product formula's simulating error can be reduced by rearranging different terms. Since the error of simulation arises from the non-commuting terms in the Hamiltonian, one natural idea is to permute the Hamiltonian so that commuting terms are put together. For example, we could divide a Hamiltonian into four parts,\n", + "\n", + "$$\n", + "H = H_x + H_y + H_z + H_{\\rm other},\n", + "\\tag{7}\n", + "$$\n", + "\n", + "where $H_x, H_y, H_z$ contain terms only composed of $X, Y, Z$ operators, and $H_{\\rm other}$ are all the other terms. For Hamiltonian describe in (5), all terms can be grouped into $H_x, H_y, H_z$.\n", + "\n", + "Another approach is to decompose the Hamiltonian according to the system geometry. Especially for one-dimensional nearest-neighbor systems, the Hamiltonian can be divided into even and odd terms, \n", + "\n", + "$$\n", + "H = H_{\\rm even} + H_{\\rm odd}.\n", + "\\tag{8}\n", + "$$\n", + "\n", + "where $H_{\\rm even}$ are interactions on sites $(0, 1), (2, 3), ...$ and $H_{\\rm odd}$ are interactions on sites $(1, 2), (3, 4), ...$.\n", + "\n", + "Note that these two permutation strategies do **not** reduce the bound on simulation error, and empirical results return a more case-by-case effect on the error. Nevertheless, we provide the above two decompositions as a built-in option of the `construct_trotter_circuit()` function. By setting the argument `grouping='xyz'` or `grouping='even_odd'`, the function will automatically try to rearrange the Hamiltonian when adding the trotter circuit. Besides, users can also customize permutation by using the argument `permutation`, which we will introduce shortly in the next section. For now, let's test the `grouping` option and check the variations in fidelity:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "b2eaca4c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Original fidelity: Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=True,\n", + " [0.58283895])\n", + "XYZ permuted fidelity: Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=True,\n", + " [0.73197818])\n", + "Even-odd permuted fidelity: Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=True,\n", + " [0.74653322])\n" + ] + } + ], + "source": [ + "# using the same evolution parameters, but set 'grouping=\"xyz\"' and 'grouping=\"even_odd\"'\n", + "cir_evolve_xyz = Circuit()\n", + "cir_evolve_even_odd = Circuit()\n", + "construct_trotter_circuit(cir_evolve_xyz, h, tau=t/r, steps=r, order=2, grouping='xyz')\n", + "construct_trotter_circuit(cir_evolve_even_odd, h, tau=t/r, steps=r, order=2, grouping='even_odd')\n", + "U_cir_xyz = cir_evolve_xyz.unitary_matrix()\n", + "U_cir_even_odd = cir_evolve_even_odd.unitary_matrix()\n", + "print('Original fidelity: ', gate_fidelity(get_evolve_op(t), U_cir))\n", + "print('XYZ permuted fidelity: ', gate_fidelity(get_evolve_op(t), U_cir_xyz))\n", + "print('Even-odd permuted fidelity: ', gate_fidelity(get_evolve_op(t), U_cir_even_odd))" + ] + }, + { + "cell_type": "markdown", + "id": "f18e3f16", + "metadata": {}, + "source": [ + "#### Initial state preparation and final state observation\n", + "\n", + "Now let's prepare the system's initial state. Generally speaking, one common approach when studying the dynamics of a quantum system is to start the evolution from different direct product states. In Paddle Quantum, the default initial state is $\\vert 0...0 \\rangle$, so we can simply apply $X$ gate to different qubits to get a direct product initial state. For example, here we apply $X$ gate to qubits representing spins on odd sites, so the initial state will become $\\vert 01010 \\rangle$, as in spin notation, $\\vert \\downarrow \\uparrow \\downarrow \\uparrow \\downarrow \\rangle$." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e0ff6736", + "metadata": {}, + "outputs": [], + "source": [ + "# create a circuit used for initial state preparation\n", + "cir = Circuit(5)\n", + "cir.x(1)\n", + "cir.x(3)\n", + "init_state = cir()" + ] + }, + { + "cell_type": "markdown", + "id": "e7d5b832", + "metadata": {}, + "source": [ + "By passing the initial state `init_state` into the circuit, we can evolve the initial state with a quantum circuit. Then by `State.expec_val()` method, the expectation value of a user-specified observable on the final state could be measured. For simplicity, we only consider a single-spin observable $\\langle S_i^z \\rangle$ here, its corresponding Pauli string is `[[1, 'Zi']]` (i being an integer)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "88d5e1b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sz observable on the site 0 is： Tensor(shape=[1], dtype=float32, place=CPUPlace, stop_gradient=False,\n", + " [0.73427194])\n" + ] + } + ], + "source": [ + "output_state = cir_evolve_even_odd(init_state)\n", + "print('Sz observable on the site 0 is: ', output_state.expec_val(Hamiltonian([[1, 'Z0']]), shots = 0))" + ] + }, + { + "cell_type": "markdown", + "id": "e70d9fba", + "metadata": {}, + "source": [ + "Similarly, by adjusting the simulation time length and changing the observable, we could plot the entire evolution process of different spins. Note here in order to compute the exact solution, we need to construct the matrix form of each observable $S_i^z$ using `SpinOps` class and calculate their expectation value with $\\langle \\psi(t) \\vert S_i^z \\vert \\psi(t) \\rangle$." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6c4c03ea", + "metadata": {}, + "outputs": [], + "source": [ + "def get_evolution_z_obs(h, t_total, order=None, n_steps=None, exact=None):\n", + " \"\"\" \n", + " a function to calculate a system's Sz observable on each site for an entire evolution process t\n", + " specify the order the trotter length by setting order and n_steps\n", + " set exact=True to get the exact results\n", + " \"\"\"\n", + " z_obs_total = []\n", + " for t in np.linspace(0., t_total, t_total * 3 + 1):\n", + " z_obs = []\n", + " # get the final state by either evolving with a circuit or the exact operator\n", + " if exact:\n", + " spin_operators = SpinOps(h.n_qubits)\n", + " fin_state = get_evolve_op(t) @ init_state.data\n", + " else:\n", + " cir_evolve = Circuit(5)\n", + " construct_trotter_circuit(cir_evolve, h, tau=t/n_steps, steps=n_steps, order=order, grouping='even_odd')\n", + " fin_state = cir_evolve(init_state)\n", + " # measure the observable on each site\n", + " for site in range(h.n_qubits):\n", + " if exact:\n", + " observable = paddle.to_tensor(spin_operators.sigz_p[site], dtype='complex64')\n", + " z_obs.append(dagger(fin_state) @ observable @ fin_state)\n", + " else:\n", + " z_obs.append(fin_state.expec_val(Hamiltonian([[1, 'Z' + str(site)]]), shots=0))\n", + " z_obs_total.append(z_obs)\n", + " return np.array(z_obs_total).real \n", + "\n", + "def plot_comparison(**z_obs_to_plot):\n", + " \"\"\"\n", + " plot comparison between different evolution results\n", + " assume each argument passed into it is returned from get_evolution_z_obs() function for the same t_total\n", + " \"\"\"\n", + " fig, axes = plt.subplots(1, len(z_obs_to_plot), figsize = [len(z_obs_to_plot) * 3, 5.5])\n", + " \n", + " ax_idx = 0\n", + " for label in z_obs_to_plot.keys():\n", + " im = axes[ax_idx].imshow(z_obs_to_plot[label], cmap='coolwarm_r', interpolation='kaiser', origin='lower')\n", + " axes[ax_idx].set_title(label, fontsize=15)\n", + " ax_idx += 1\n", + "\n", + " for ax in axes:\n", + " ax.set_xlabel('site', fontsize=15)\n", + " ax.set_yticks(np.arange(0, z_obs_total_exact.shape[0], 3))\n", + " ax.set_yticklabels(np.arange(0, z_obs_total_exact.shape[0]/3, 1))\n", + " ax.set_xticks(np.arange(z_obs_total_exact.shape[1]))\n", + " ax.set_xticklabels(np.arange(z_obs_total_exact.shape[1]))\n", + "\n", + " axes[0].set_ylabel('t', fontsize=15)\n", + " cax = fig.add_axes([0.92, 0.125, 0.02, 0.755])\n", + " \n", + " \n", + " fig.colorbar(im, cax)\n", + " cax.set_ylabel(r'$\\langle S^z_i (t) \\rangle$', fontsize=15)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3735e79a", + "metadata": {}, + "outputs": [], + "source": [ + "# calculate the evolution process with circuits of trotter number 25 and 5, and the exact result\n", + "z_obs_total_exact = get_evolution_z_obs(h, t_total=3, exact=True)\n", + "z_obs_total_cir = get_evolution_z_obs(h, order=1, n_steps=25, t_total=3)\n", + "z_obs_total_cir_short = get_evolution_z_obs(h, order=1, n_steps=5, t_total=3)\n", + "\n", + "plot_comparison(\n", + " Exact=z_obs_total_exact,\n", + " L25_Circuit=z_obs_total_cir,\n", + " L5_Circuit=z_obs_total_cir_short)" + ] + }, + { + "cell_type": "markdown", + "id": "707ecfdf", + "metadata": {}, + "source": [ + "Observed that with 25 trotter blocks, the circuit could very well simulate the spin dynamics for the entire period. In contrast, the shorter circuit with only 5 trotter blocks could only describe the system's behavior correctly up to a certain time until the simulation breaks down.\n", + "\n", + "**Exercise：** Could the readers try to observe the evolution of spatial spin correlation function $\\langle S_i^z S_j^{z} \\rangle$？" + ] + }, + { + "cell_type": "markdown", + "id": "af97d494", + "metadata": {}, + "source": [ + "## Design customized trotter circuit with random permutation\n", + "\n", + "### Random permutation\n", + "\n", + "Although it seems more physically reasonable to group the commuting terms in the Hamiltonian to achieve better simulation performance, many evidence has shown that using a fixed order Hamiltonian for each trotter block might cause the errors to accumulate. On the other hand, evolving the Hamiltonian according to an random ordering might \"wash-out\" some of the coherent error in the simulation process and replace it with less harmful stochastic noise [8]. Both theoretical analyses on the error upper bound and empirical evidences show that this randomization could effectively reduce the simulation error [9]." + ] + }, + { + "cell_type": "markdown", + "id": "9ecc2ea0", + "metadata": {}, + "source": [ + "### Customize trotter circuit construction\n", + "\n", + "By default, the function `construct_trotter_circuit()` constructs a time evolving circuit according to the Suzuki product formula. However, users could choose to customize both the coefficients and permutations by setting `method='custom'` and passing custom arrays to arguments `permutation` and `coefficient`. \n", + "\n", + "**Note:** The user should be very cautious when using arguments `coefficient`, `tau` and `steps` altogether. By setting `steps` other than 1 and `tau` other than $t$ (the total evolution time), it is possible to further trotterize the custom coefficient and permutation. For example, when setting `permutation=np.arange(h.n_qubits)` and `coefficient=np.ones(h.n_qubits)`, the effect of `tau` and `steps` is exactly the same as constructing the first-order product formula circuit." + ] + }, + { + "cell_type": "markdown", + "id": "8afa9fe1", + "metadata": {}, + "source": [ + "Let us further demonstrate the customization function with a concrete example. With the same spin chain Hamiltonian, now we wish to design an evolution strategy similar to the first-order product formula, however the ordering of the Hamiltonian terms within each trotter block is independently random. We could implement this by pass an arraying of shape `(n_steps, h.n_terms)` to the argument `permutation`, and each row of that array is a random permutation $P(N)$." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f70ab81b", + "metadata": {}, + "outputs": [], + "source": [ + "# An example for customize permutation\n", + "permutation = np.vstack([np.random.permutation(h.n_terms) for i in range(100)])" + ] + }, + { + "cell_type": "markdown", + "id": "8d189064", + "metadata": {}, + "source": [ + "Then, we compare the fidelity of such strategy with the first order product formula under different trotter length." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "6d6910c9", + "metadata": {}, + "outputs": [], + "source": [ + "def compare(n_steps):\n", + " \"\"\"\n", + " compare the first order product formula and random permutation's fidelity for a fixed evolution time t=2\n", + " input n_steps is the number of trotter steps\n", + " output is respectively the first order PF and random permutations' fidelity \n", + " \"\"\"\n", + " t = 2\n", + " cir_evolve = Circuit()\n", + " construct_trotter_circuit(cir_evolve, h, tau=t/n_steps, steps=n_steps, order=1)\n", + " U_cir = cir_evolve.unitary_matrix()\n", + " fid_suzuki = gate_fidelity(get_evolve_op(t), U_cir)\n", + " cir_permute = Circuit()\n", + " permutation = np.vstack([np.random.permutation(h.n_terms) for i in range(n_steps)])\n", + " # when coefficient is not specified, a normalized uniform coefficient will be automatically set\n", + " construct_trotter_circuit(cir_permute, h, tau=t, steps=1, method='custom', permutation=permutation)\n", + " U_cir = cir_permute.unitary_matrix()\n", + " fid_random = gate_fidelity(get_evolve_op(t), U_cir)\n", + " return fid_suzuki, fid_random\n", + "\n", + "# compare the two fidelity for different trotter steps\n", + "# as a demo, we only run the experiment once. Interested readers could run multiple times to calculate the error bar\n", + "n_range = [100, 200, 500, 1000]\n", + "result = [compare(n) for n in n_range]\n", + "\n", + "result = 1 - np.array(result)\n", + "plt.loglog(n_range, result[:, 0], 'o-', label='1st order PF')\n", + "plt.loglog(n_range, result[:, 1], 'o-', label='Random')\n", + "plt.xlabel(r'Trotter number $r$', fontsize=12)\n", + "plt.ylabel(r'Error: $1 - {\\rm Fid}$', fontsize=12)\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "48fc79ff", + "metadata": {}, + "source": [ + "The 1st order PF refers to the first order product formula circuit with a fixed order. As expected, there is a good improvement in the fidelity for randomized trotter circuit over the first order product formula. \n", + "\n", + "**Note:** In [9], the authors noted that the randomization achieved better performance without even utilizing any specific information about the Hamiltonian, and there should be a even more efficient algorithm compared to the simple randomization." + ] + }, + { + "cell_type": "markdown", + "id": "bfe2c24e", + "metadata": {}, + "source": [ + "## Conclusion" + ] + }, + { + "cell_type": "markdown", + "id": "92832953", + "metadata": {}, + "source": [ + "Dynamical simulation plays a central role in the research of exotic quantum states. Due to its highly entangled nature, both experimental and theoretical research constitute highly challenging topics. Up until now, people haven't been able to fully understand the physics on some of the two-dimensional or even one-dimensional spin systems. On the other hand, the rapid development of general quantum computers and a series of quantum simulators give researchers new tools to deal with these challenging problems. Take the general quantum computer as an example, it could use digital simulation to simulate almost any quantum system's evolution process under complex conditions (for example a time-dependent Hamiltonian), which is beyond the reach of any classical computer. As the number of qubits and their precisions grow, it seems more like a question of when will the quantum computer surpass its classical counterpart on the tasks of quantum simulation. And among those tasks, it is commonly believed that the simulation of quantum spin systems will be one of the few cases where this breakthrough will first happen. \n", + "\n", + "We have presented in this tutorial a hands-on case of simulating dynamical process on a quantum spin model with Paddle Quantum, and further discussed the possibility of designing new time-evolving strategies. Users can now easily design and benchmark their time evolution circuits with the `construct_trotter_circuit()` function and methods provided in the `Hamiltonian` and `SpinOps` class. We encourage our users to experiment and explore various time evolution strategies on different quantum systems. " + ] + }, + { + "cell_type": "markdown", + "id": "ff5b39fa", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## References\n", + "\n", + "[1] Childs, Andrew M., et al. \"Toward the first quantum simulation with quantum speedup.\" [Proceedings of the National Academy of Sciences 115.38 (2018): 9456-9461](https://www.pnas.org/content/115/38/9456.short).\n", + "\n", + "[2] Eckle, Hans-Peter. Models of Quantum Matter: A First Course on Integrability and the Bethe Ansatz. [Oxford University Press, 2019](https://oxford.universitypressscholarship.com/view/10.1093/oso/9780199678839.001.0001/oso-9780199678839).\n", + "\n", + "[3] Mikeska, Hans-Jürgen, and Alexei K. Kolezhuk. \"One-dimensional magnetism.\" Quantum magnetism. Springer, Berlin, Heidelberg, 2004. 1-83.\n", + "\n", + "[4] Berger, L., S. A. Friedberg, and J. T. Schriempf. \"Magnetic Susceptibility of $\\rm Cu(NO_3)_2·2.5 H_2O$ at Low Temperature.\" [Physical Review 132.3 (1963): 1057](https://journals.aps.org/pr/abstract/10.1103/PhysRev.132.1057).\n", + "\n", + "[5] Broholm, C., et al. \"Quantum spin liquids.\" [Science 367.6475 (2020)](https://science.sciencemag.org/content/367/6475/eaay0668).\n", + "\n", + "[6] Abanin, Dmitry A., et al. \"Colloquium: Many-body localization, thermalization, and entanglement.\" [Reviews of Modern Physics 91.2 (2019): 021001](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.91.021001).\n", + "\n", + "[7] Medenjak, Marko, Berislav Buča, and Dieter Jaksch. \"Isolated Heisenberg magnet as a quantum time crystal.\" [Physical Review B 102.4 (2020): 041117](https://journals.aps.org/prb/abstract/10.1103/PhysRevB.102.041117).\n", + "\n", + "[8] Wallman, Joel J., and Joseph Emerson. \"Noise tailoring for scalable quantum computation via randomized compiling.\" [Physical Review A 94.5 (2016): 052325](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.94.052325).\n", + "\n", + "[9] Childs, Andrew M., Aaron Ostrander, and Yuan Su. \"Faster quantum simulation by randomization.\" [Quantum 3 (2019): 182](https://quantum-journal.org/papers/q-2019-09-02-182/)." + ] + } + ], + "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.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/tutorials/quantum_simulation/VQE_CN.ipynb b/tutorials/quantum_simulation/VQE_CN.ipynb new file mode 100644 index 0000000..1e6c09d --- /dev/null +++ b/tutorials/quantum_simulation/VQE_CN.ipynb @@ -0,0 +1,555 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 变分量子本征求解器\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 概览\n", + "\n", + "目前普遍认为，量子计算在近期很有前景的一个应用是处理量子化学问题 [1-2]。**变分量子本征求解器** （VQE）作为这个研究方向的核心应用之一，为研究者们提供了可以在目前含噪的中等规模量子设备（NISQ device）上研究量子化学的可能 [1-4]。其核心任务是求解一个量子尺度上封闭物理系统的哈密顿量 $\\hat{H}$ 的基态能量及其对应的量子态。主要的实现方法是通过在量子设备上准备一个参数化的试探波函数 $|\\Psi(\\boldsymbol\\theta)\\rangle$ 然后结合经典机器学习中的优化算法（例如梯度下降法）去不断地调整、优化参数 $\\boldsymbol\\theta$ 使得期望值 $\\langle \\Psi(\\boldsymbol\\theta)|\\hat{H}|\\Psi(\\boldsymbol\\theta)\\rangle$ 最小化。这套方案的基本原理是基于 **Rayleigh-Ritz 变分原理**。 \n", + "\n", + "$$\n", + "E_0 = \\min_{\\boldsymbol\\theta} \\langle \\Psi(\\boldsymbol\\theta)|\\hat{H}|\\Psi(\\boldsymbol\\theta)\\rangle.\n", + "\\tag{1}\n", + "$$\n", + "\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", + "\\tag{2}\n", + "$$\n", + "\n", + "其中 $c_k$ 表示权重系数, $\\sigma_j^{(k)} \\in \\{I,X,Y,Z\\}$ 并且 $M$ 表示所需的量子比特个数。这样一种哈密顿量的表示形式被称为 **泡利字符串**。以下为一个2量子比特的具体例子，\n", + "\n", + "$$\n", + "H= 0.12~Y_0 \\otimes I_1-0.04~X_0\\otimes Z_1.\n", + "\\tag{3}\n", + "$$\n", + "\n", + "在下一节，我们会补充一些关于电子结构问题的背景知识。本质上讨论的就是上述哈密顿量 $H$ 是如何计算的。对于熟悉相关背景的读者，或者主要关心如何在量桨上实现 VQE 的读者，请直接跳转至第三节分析氢分子（$H_2$）基态的具体例子。 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 背景： 电子结构问题\n", + "\n", + "这里，我们集中讨论下量子化学中的一个基本问题 -- **电子结构问题**。更准确的说，我们关心的是给定分子（molecule）的低位能量本征态。这些信息可以帮助我们预测化学反应的速率和分子的稳定结构等等 [6]。假设一个分子由 $N_n$ 个原子核和 $N_e$ 个电子组成，描述该分子系统总能量的哈密顿量算符 $\\hat{H}_{mol}$ 在一次量子化表示下可以写为，\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\hat{H}_{\\text{mol}} & = -\\sum_{i}\\frac{\\nabla_{R_i}^2}{2M_i} - \\sum_{i} \\frac{\\nabla_{r_i}^2}{2} -\\sum_{i,j}\\frac{Z_i}{\\lvert R_i - r_j\\lvert} + \\sum_{i,j>i}\\frac{Z_iZ_j}{\\lvert R_i - R_j\\lvert} + \\sum_{i, j>i}\\frac{1}{\\lvert r_i - r_j\\lvert}, \n", + "\\tag{4}\n", + "\\end{align}\n", + "$$\n", + "\n", + "其中 $R_i、M_i$ 和 $Z_i$ 分别表示第 $i$ 个原子核的位置、质量和原子序数（原子核内质子数），第 $i$ 个电子的位置则表示为 $r_i$。以上公式右边前两项分别代表原子核和电子的总动能。第三项表示带正电的质子和带负电的电子之间的库伦相互吸引作用。最后两项则表示原子核-原子核之间，电子-电子之间的相互排斥作用。这里，分子哈密顿量 $\\hat{H}_\\text{mol}$ 使用的是原子单位制能量 **哈特里能量**（Hartree），记为 Ha。$1$ 哈特里能量的大小为 $[\\hbar^2/(m_ee^2a_0^2)] = 27.2$ 电子伏或 $630$ 千卡/摩尔，其中 $m_e、e$ 和 $a_0$ 分别表示电子质量、基本电荷和玻尔半径。\n", + "\n", + "**注释1：** 在处理电子结构问题时，我们不考虑自旋-轨道耦合以及超精细结构。如果出于计算需要，可以作为微扰加入。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 玻恩-奥本海默近似\n", + "\n", + "由于原子核的质量要远大于电子，因而在同样的相互作用下电子的运动速度会比原子核快很多。所以，将原子核所处的位置看成固定 $R_i =$常数 是一种合理的近似。这种通过在时间尺度上将电子行为和原子核行为去耦合的近似处理思想被称为玻恩-奥本海默近似。作为近似的直接结果，公式（4）中原子核的动能项会被消去并且表示原子核-原子核相互排斥作用的项可以被认为是一个能量移位（这个项是与电子位置 $r_i$ 无关的）从而也可以作为常数项被忽略。经过这些步骤后，我们可以把哈密顿量近似为：\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\hat{H}_{\\text{electron}} & = - \\sum_{i} \\frac{\\nabla_{r_i}^2}{2} -\\sum_{i,j}\\frac{Z_i}{\\lvert R_i - r_j\\lvert} + \\sum_{i, j>i}\\frac{1}{\\lvert r_i - r_j\\lvert} \n", + "\\tag{5},\n", + "\\end{align}\n", + "$$\n", + "\n", + "在经过以上近似后，分子中多电子结构的能级在理论上可以通过求解以下不含时薛定谔方程获得：\n", + "\n", + "$$\n", + "\\hat{H}_{\\text{electron}} |\\Psi_n \\rangle = E_n |\\Psi_n \\rangle,\n", + "\\tag{6}\n", + "$$\n", + "\n", + "其中 $n$ 指代能级。值得注意的是，电子哈密顿量中电子-电子相互排斥作用的求和项数会随着电子数 $N_e$ 的增多至 $N_e(N_e-1)/2$ 项。这意味着对于一个含有16个电子的氧分子（$O_2$）我们需要计算多达120项的相互排斥作用项。 一般来说，这样的问题是无法从理论上精确求解的。正如狄拉克在 [Quantum mechanics of many-electron systems](https://royalsocietypublishing.org/doi/10.1098/rspa.1929.0094) [7] 所指出的那样，\n", + "\n", + "> *The underlying physical laws necessary for the mathematical theory of a large part of physics and the whole of chemistry are thus completely known, and the difficulty is only that the exact application of these laws leads to equations much too complicated to be soluble.* \n", + "> \n", + "> -- Paul Dirac (1929)\n", + "\n", + "由于解析的方法太复杂，那么我们可以采用数值方法来处理。一个最简单的数值方法（离散化方法）就是把上述作用中无限维度希尔伯特空间离散化为等间距排开的立方体晶格点。在这样一个离散化的空间里，主要运算规则为复数域的线性代数。假设空间的每个轴都离散为等间距排开的 $k$ 个点，则 $N$-电子（为了方便去掉下标 $e$）的多体波函数可以写为 [2]：\n", + "\n", + "$$\n", + "|\\Psi \\rangle = \\sum_{\\mathbf{x_1}, \\ldots, \\mathbf{x_N}} \\psi(\\mathbf{x_1}, \\ldots, \\mathbf{x_N}) \\mathcal{A}(|\\mathbf{x_1}, \\ldots, \\mathbf{x_N}\\rangle).\n", + "\\tag{7}\n", + "$$\n", + "\n", + "其中坐标 $|\\mathbf{x_j}\\rangle = |r_j\\rangle |\\sigma_j\\rangle$ 记录第 $j$ 个电子的空间位置信息和自旋，$|r_j\\rangle = |x_j,y_j,z_j\\rangle$ 且 $j\\in \\{1,2,\\cdots,N\\}$, $x_j,y_j,z_j \\in \\{0,1,\\cdots,k-1\\}$ 同时 $\\sigma_j \\in \\{\\downarrow,\\uparrow\\}$ 表示自旋向下和向上。这样一种离散化方式共计需要 $k^{3N}\\times 2^{N}$ 个数据来表示波函数。在这里，$\\mathcal{A}$ 表示反对称化操作（根据泡利不相容原理）并且 $\\psi(\\mathbf{x_1}, \\mathbf{x_2}, \\ldots, \\mathbf{x_N})=\\langle\\mathbf{x_1}, \\mathbf{x_2}, \\ldots, \\mathbf{x_N}|\\Psi\\rangle$。 可以看出，经典计算机存储这样一个波函数需要的内存是随着电子个数呈指数增长的。这使得基于这种离散化的经典数值方法，无法模拟超过几十个电子的系统。那么，我们是不是能够通过量子设备来存储和准备这样一个波函数然后求解基态能量 $E_0$ 呢？在下一节中，我们将以最简单的分子系统 -- 氢分子（$H_2$）为例，讲解 VQE 算法。\n", + "\n", + "**注释2：** 关于量子化学和现有数值计算方法的综述也超过了本教程的处理范围，我们推荐感兴趣的读者去查阅以下经典教材 Helgaker 等人撰写的 *'Molecular Electronic-Structure Theory'* [6] 以及 Szabo & Ostlund 撰写的 *'Modern Quantum Chemistry: Introduction to Advanced Electronic Structure Theory'* [8]。 如果需要弥补量子计算和量子化学之间知识空缺，请参考以下综述文章 [Quantum chemistry in the age of quantum computing](https://pubs.acs.org/doi/10.1021/acs.chemrev.8b00803) [1] 和 [Quantum computational chemistry](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.92.015003) [2] 。\n", + "\n", + "**注释3：** 对于量子化学中的能量计算，我们期望能够达到 **化学精度**（chemical accuracy）$1.6\\times10^{-3}$ Ha 或者 1 千卡/摩尔。\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 氢分子 $H_2$ 基态能量\n", + "\n", + "### 构造电子哈密顿量\n", + "\n", + "首先，让我们通过下面几行代码引入必要的 library 和 package。量桨的量子化学工具包是基于 `psi4` 和 `openfermion` 进行开发的，所以需要读者先行安装这两个语言包。在进入下面的教程之前，我们强烈建议您先阅读[哈密顿量的构造](./BuildingMolecule_CN.ipynb)教程，该教程介绍了如何使用量桨的量子化学工具包。\n", + "\n", + "**注意：关于环境设置，请参考 [README_CN.md](https://github.com/PaddlePaddle/Quantum/blob/master/README_CN.md).**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:13:45.528201Z", + "start_time": "2021-04-30T09:13:43.385553Z" + } + }, + "outputs": [], + "source": [ + "import paddle\n", + "import paddle_quantum.qchem as qchem\n", + "from paddle_quantum.loss import ExpecVal\n", + "from paddle_quantum import Hamiltonian\n", + "from paddle_quantum.state import zero_state, State\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.linalg import dagger\n", + "from paddle_quantum import Backend\n", + "\n", + "import os\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import numpy\n", + "from numpy import pi as PI\n", + "from numpy import savez, zeros\n", + "\n", + "# 无视警告\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "对于具体需要分析的分子，我们需要其**几何构型** (geometry)、**基组**（basis set，例如 STO-3G 基于高斯函数）、**多重度**（multiplicity）以及**分子的净电荷数** (charge) 等多项信息来建模计算出该分子单体积分 (one-body integrations)，双体积分(two-body integrations) 以及哈密顿量等信息。接下来，通过量桨的量子化学工具包将分子的哈密顿量提取出来并储存为 paddle quantum 的 `Hamiltonian` 类，方便我们下一步的操作。" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:13:45.545018Z", + "start_time": "2021-04-30T09:13:45.531302Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FCI energy for H2_sto-3g_singlet (2 electrons) is -1.137283834485513.\n", + "\n", + "The generated h2 Hamiltonian is \n", + " -0.09706626861762556 I\n", + "-0.04530261550868938 X0, X1, Y2, Y3\n", + "0.04530261550868938 X0, Y1, Y2, X3\n", + "0.04530261550868938 Y0, X1, X2, Y3\n", + "-0.04530261550868938 Y0, Y1, X2, X3\n", + "0.1714128263940239 Z0\n", + "0.16868898168693286 Z0, Z1\n", + "0.12062523481381837 Z0, Z2\n", + "0.16592785032250773 Z0, Z3\n", + "0.17141282639402394 Z1\n", + "0.16592785032250773 Z1, Z2\n", + "0.12062523481381837 Z1, Z3\n", + "-0.2234315367466399 Z2\n", + "0.17441287610651626 Z2, Z3\n", + "-0.2234315367466399 Z3\n" + ] + } + ], + "source": [ + "geo = qchem.geometry(structure=[['H', [-0., 0., 0.0]], ['H', [-0., 0., 0.74]]])\n", + "# geo = qchem.geometry(file='h2.xyz')\n", + "\n", + "# 将分子信息存储在 molecule 里，包括单体积分（one-body integrations），双体积分（two-body integrations），分子的哈密顿量等\n", + "molecule = qchem.get_molecular_data(\n", + " geometry=geo,\n", + " basis='sto-3g',\n", + " charge=0,\n", + " multiplicity=1,\n", + " method=\"fci\",\n", + " if_save=True,\n", + " if_print=True\n", + ")\n", + "# 提取哈密顿量\n", + "molecular_hamiltonian = qchem.spin_hamiltonian(molecule=molecule,\n", + " filename=None, \n", + " multiplicity=1, \n", + " mapping_method='jordan_wigner',)\n", + "# 打印结果\n", + "print(\"\\nThe generated h2 Hamiltonian is \\n\", molecular_hamiltonian)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**注释4：** 生成这个哈密顿量的几何构型中，两个氢原子间的原子间隔（interatomic distance）为 $d = 74$ pm。\n", + "\n", + "除了输入分子的几何结构外，我们还支持读取分子的几何构型文件 (`.xyz` 文件)，关于量子化学工具包更多的用法请参考[哈密顿量的构造](./BuildingMolecule_CN.ipynb)教程。如果你需要测试更多分子的几何构型，请移步至这个[数据库](http://smart.sns.it/molecules/index.html)。" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 搭建量子神经网络（QNN）和试探波函数\n", + "\n", + "在实现VQE的过程中，我们首先需要设计量子神经网络QNN（也可以理解为参数化量子电路）来准备试探波函数 $|\\Psi(\\boldsymbol\\theta)\\rangle$。这里，我们提供一个预设好的的深度为 $D$ 层的 4-量子比特的量子电路模板，图中的虚线框内为一层：\n", + "\n", + "![Utheta.jpg](https://release-data.cdn.bcebos.com/PIC%2FUtheta.jpg)\n", + "\n", + "- 我们预设一些该参数化电路的参数，比如宽度为 $N = 4$ 量子位。\n", + "\n", + "- 初始化其中的变量参数，${\\bf{\\theta }}$ 代表我们量子神经网络中的参数组成的向量。\n", + "\n", + "接下来我们根据上图中的电路设计，通过 Paddle Quantum 的 `Circuit` 类和内置的 `real_entangled_layer()` 电路模板来高效搭建量子神经网络。 " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def U_theta(num_qubits: int, depth: int) -> Circuit:\n", + " \"\"\"\n", + " Quantum Neural Network\n", + " \"\"\"\n", + " \n", + " # 按照量子比特数量/网络宽度初始化量子神经网络\n", + " cir = Circuit(num_qubits)\n", + " \n", + " # 内置的 {R_y + CNOT} 电路模板\n", + " cir.real_entangled_layer(depth = depth)\n", + " \n", + " # 铺上最后一列 R_y 旋转门\n", + " cir.ry()\n", + " \n", + " return cir" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 配置训练模型 - 损失函数\n", + "\n", + "现在我们已经有了数据和量子神经网络的架构，我们将进一步定义训练参数、模型和损失函数。通过作用量子神经网络 $U(\\theta)$ 在初始态 $|0..0\\rangle$ 上，我们将得到输出态 $\\left| {\\psi \\left( {\\bf{\\theta }} \\right)} \\right\\rangle $。进一步，在VQE模型中的损失函数一般由量子态 $\\left| {\\psi \\left( {\\bf{\\theta }} \\right)} \\right\\rangle$ 关于哈密顿量 $H$ 的期望值 (能量期望值 expectation value) 给出，\n", + "\n", + "$$\n", + "\\min_{\\boldsymbol\\theta} \\mathcal{L}(\\boldsymbol \\theta) = \\min_{\\boldsymbol\\theta} \\langle \\Psi(\\boldsymbol\\theta)|H |\\Psi(\\boldsymbol\\theta)\\rangle\n", + "= \\min_{\\boldsymbol\\theta} \\sum_k c_k~\\langle \\Psi(\\boldsymbol\\theta)| \\bigotimes_j \\sigma_j^{(k)}|\\Psi(\\boldsymbol\\theta)\\rangle.\n", + "\\tag{8}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "class StateNet(paddle.nn.Layer):\n", + " \"\"\"\n", + " Construct the model net\n", + " \"\"\"\n", + "\n", + " def __init__(self, num_qubits: int, depth: int):\n", + " super(StateNet, self).__init__()\n", + " \n", + " self.depth = depth\n", + " self.num_qubits = num_qubits\n", + " self.cir = U_theta(self.num_qubits, self.depth)\n", + " \n", + " # 定义损失函数和前向传播机制\n", + " def forward(self):\n", + " \n", + " # 运行电路\n", + " state = self.cir(init_state)\n", + " # 计算损失函数\n", + " loss = loss_func(state) \n", + "\n", + " return loss, self.cir" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 配置训练模型 - 模型参数\n", + "\n", + "在进行量子神经网络的训练之前，我们还需要进行一些训练的超参数设置，主要是学习速率（LR, learning rate）、迭代次数（ITR, iteration）和量子神经网络计算模块的深度（D, Depth）。这里我们设定学习速率为 0.5, 迭代次数为 50 次。读者不妨自行调整来直观感受下超参数调整对训练效果的影响。" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:14:03.744957Z", + "start_time": "2021-04-30T09:14:03.738881Z" + } + }, + "outputs": [], + "source": [ + "ITR = 80 # 设置训练的总迭代次数\n", + "LR = 0.4 # 设置学习速率\n", + "D = 2 # 设置量子神经网络中重复计算模块的深度 Depth\n", + "N = molecular_hamiltonian.n_qubits # 设置参与计算的量子比特数" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 进行训练\n", + "\n", + "当训练模型的各项参数都设置完成后，我们将数据转化为 Paddle 中的张量，进而进行量子神经网络的训练。过程中我们用的是Adam Optimizer，也可以调用Paddle中提供的其他优化器。我们将训练过程中的结果存储在summary_data文件中。" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 20 loss: -1.0700\n", + "iter: 20 Ground state energy: -1.0700 Ha\n", + "iter: 40 loss: -1.1309\n", + "iter: 40 Ground state energy: -1.1309 Ha\n", + "iter: 60 loss: -1.1362\n", + "iter: 60 Ground state energy: -1.1362 Ha\n", + "iter: 80 loss: -1.1372\n", + "iter: 80 Ground state energy: -1.1372 Ha\n", + "\n", + "训练后的电路：\n", + "--Ry(7.856)----*--------------x----Ry(4.698)----*--------------x----Ry(6.277)--\n", + " | | | | \n", + "--Ry(1.548)----x----*---------|----Ry(-1.56)----x----*---------|----Ry(5.041)--\n", + " | | | | \n", + "--Ry(3.441)---------x----*----|----Ry(4.474)---------x----*----|----Ry(1.745)--\n", + " | | | | \n", + "--Ry(-0.17)--------------x----*----Ry(1.646)--------------x----*----Ry(3.152)--\n", + " \n" + ] + } + ], + "source": [ + "# 确定网络的参数维度\n", + "net = StateNet(N, D)\n", + "\n", + "# 一般来说，我们利用Adam优化器来获得相对好的收敛，\n", + "# 当然你可以改成SGD或者是RMS prop.\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + "# 定义初始态\n", + "init_state = zero_state(N)\n", + "\n", + "# 定义损失函数\n", + "loss_func = ExpecVal(molecular_hamiltonian)\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", + "# 储存训练结果到 output 文件夹\n", + "os.makedirs(\"output\", exist_ok=True)\n", + "savez(\"./output/summary_data\", iter = summary_iter, \n", + " energy=summary_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### 测试效果\n", + "我们现在已经完成了量子神经网络的训练，通过 VQE 得到的基态能量的估计值大致为 $E_0 \\approx -1.137$ Ha，这与通过 `psi4` 在 sto-3g 基底下使用 FCI (full configuration-interaction) 方法计算得到的基态能量值 $E_0 = -1.13728$ Ha 是在化学精度 $\\varepsilon = 1.6 \\times 10^{-3}$ Ha 内相符合的。" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:14:21.341323Z", + "start_time": "2021-04-30T09:14:20.710152Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result = numpy.load('./output/summary_data.npz')\n", + "\n", + "eig_val, eig_state = numpy.linalg.eig(\n", + " molecular_hamiltonian.construct_h_matrix())\n", + "min_eig_H = numpy.min(eig_val.real)\n", + "min_loss = numpy.ones([len(result['iter'])]) * min_eig_H\n", + "\n", + "plt.figure(1)\n", + "func1, = plt.plot(result['iter'], result['energy'], \n", + " alpha=0.7, marker='', linestyle=\"-\", color='r')\n", + "func_min, = plt.plot(result['iter'], min_loss, \n", + " alpha=0.7, marker='', linestyle=\":\", color='b')\n", + "plt.xlabel('Number of iteration')\n", + "plt.ylabel('Energy (Ha)')\n", + "\n", + "plt.legend(handles=[\n", + " func1,\n", + " func_min\n", + "],\n", + " labels=[\n", + " r'$\\left\\langle {\\psi \\left( {\\theta } \\right)} '\n", + " r'\\right|H\\left| {\\psi \\left( {\\theta } \\right)} \\right\\rangle $',\n", + " 'Ground-state energy',\n", + " ], loc='best')\n", + "plt.text(-15.5, -1.145, f'{min_eig_H:.5f}', fontsize=10, color='b')\n", + "#plt.savefig(\"vqe.png\", bbox_inches='tight', dpi=300)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 通过 VQE 确定原子间隔\n", + "\n", + "还记得在前面的注释中提到我们默认使用的两个氢原子间原子间隔为 $74$ pm 吗？VQE 的另一个用法便是通过在不同的原子间隔下多次运行然后观察运行结果的最小值是在什么原子间隔发生的，这个间隔即为估计得真实原子间隔。\n", + "\n", + "![vqe-fig-dist](figures/vqe-fig-distance.png)\n", + "\n", + "从上图可以看出，最小值确实发生在 $d = 74$ pm (1 pm = $1\\times 10^{-12}$ m) 附近，这是与[实验测得数据](https://cccbdb.nist.gov/exp2x.asp?casno=1333740&charge=0)相符合的 $d_{exp} (H_2) = 74.14$ pm." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## 参考文献\n", + "\n", + "[1] Cao, Yudong, et al. Quantum Chemistry in the Age of Quantum Computing. [Chemical reviews 119.19 (2019): 10856-10915.](https://pubs.acs.org/doi/10.1021/acs.chemrev.8b00803)\n", + "\n", + "[2] McArdle, Sam, et al. Quantum computational chemistry. [Reviews of Modern Physics 92.1 (2020): 015003.](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.92.015003)\n", + "\n", + "\n", + "[3] Peruzzo, A. et al. A variational eigenvalue solver on a photonic quantum processor. [Nat. Commun. 5, 4213 (2014).](https://www.nature.com/articles/ncomms5213)\n", + "\n", + "[4] Moll, Nikolaj, et al. Quantum optimization using variational algorithms on near-term quantum devices. [Quantum Science and Technology 3.3 (2018): 030503.](https://iopscience.iop.org/article/10.1088/2058-9565/aab822)\n", + "\n", + "[5] 徐光宪, 黎乐民, 王德民. 量子化学: 基本原理和从头计算法(上)[M], 第二版. 北京: 科学出版社, 2012; \n", + "\n", + "[6] Helgaker, Trygve, Poul Jorgensen, and Jeppe Olsen. Molecular electronic-structure theory. John Wiley & Sons, 2014.\n", + "\n", + "[7] Dirac, Paul Adrien Maurice. Quantum mechanics of many-electron systems. [Proceedings of the Royal Society of London. Series A, Containing Papers of a Mathematical and Physical Character 123.792 (1929): 714-733.](https://royalsocietypublishing.org/doi/10.1098/rspa.1929.0094)\n", + "\n", + "[8] Szabo, Attila, and Neil S. Ostlund. Modern quantum chemistry: introduction to advanced electronic structure theory. Courier Corporation, 2012." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.8.13" + }, + "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 +} diff --git a/tutorials/quantum_simulation/VQE_EN.ipynb b/tutorials/quantum_simulation/VQE_EN.ipynb new file mode 100644 index 0000000..9d20b85 --- /dev/null +++ b/tutorials/quantum_simulation/VQE_EN.ipynb @@ -0,0 +1,565 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Variational Quantum Eigensolver\n", + "\n", + " Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview\n", + "\n", + "It is widely believed that one of the most promising applications of quantum computing in the near future is solving quantum chemistry problems [1-2]. **Variational Quantum Eigensolver** (VQE) is a strong proof to this possibility of studying quantum chemistry with **Noisy Intermediate-Scale Quantum** (NISQ) devices [1-4]. The core task is to solve the ground state of any molecular Hamiltonian $\\hat{H}$ by preparing a parametrized wave function ansatz $|\\Psi(\\boldsymbol\\theta)\\rangle$ on a quantum computer and adopt classical optimization methods (e.g. gradient descent) to adjust the parameters $\\boldsymbol\\theta$ to minimize the expectation value $\\langle \\Psi(\\boldsymbol\\theta)|\\hat{H}|\\Psi(\\boldsymbol\\theta)\\rangle$. This approach is based on the **Rayleigh-Ritz variational principle**. \n", + "\n", + "$$\n", + "E_0 = \\min_{\\boldsymbol\\theta} \\langle \\Psi(\\boldsymbol\\theta)|\\hat{H}|\\Psi(\\boldsymbol\\theta)\\rangle.\n", + "\\tag{1}\n", + "$$\n", + "\n", + "where $E_0$ denotes the ground state energy. Numerically, it can be understood as finding the smallest eigenvalue $\\lambda_{\\min}$ of a **discretized** Hamiltonian $H$ (hermitian matrix) and its corresponding eigenvector $|\\Psi_0\\rangle$. How such a discretization can be done on a classical computer belongs to the art of quantum chemistry and is far beyond the scope of this tutorial. We will discuss this part with a few words in the background section. In general, such a Hamiltonian $H$ is expressed as a weighted sum of Pauli spin operators $\\{X,Y,Z\\}$ (native to quantum devices) such that this information can be processed on a quantum computer.\n", + "\n", + "$$\n", + "H = \\sum_k c_k ~ \\bigg( \\bigotimes_{j=0}^{M-1} \\sigma_j^{(k)} \\bigg),\n", + "\\tag{2}\n", + "$$\n", + "\n", + "where $\\sigma_j^{(k)} \\in \\{I,X,Y,Z\\}$ and $M$ stands for qubit number. We refer this form of Hamiltonian as **Pauli strings**. For example, \n", + "\n", + "$$\n", + "H= 0.12~Y_0 \\otimes I_1-0.04~X_0\\otimes Z_1.\n", + "\\tag{3}\n", + "$$\n", + "\n", + "In the next section, we will provide a brief review on the electronic structure problem which essentially tells us how to calculate the Hamiltonian $H$. For those who are already familiar with this topic or only interested in how to implement VQE on Paddle Quantum, please skip this part and jump into the illustrative example of hydrogen molecule $H_2$.\n", + "\n", + "## Background: the electronic structure problem\n", + "\n", + "In this section, we focus on one of the fundamental problems in quantum chemistry -- **the electronic structure problem**. To be more specific, we are interested in the low lying energy eigenstates of any given molecule. These knowledge could help predict reaction rates and location of stable structures [5]. Suppose a molecule consists of $N_n$ nuclei and $N_e$ electrons, the first quantized (canonical quantization) Hamiltonian operator $\\hat{H}_{mol}$ describing the total energy of this molecular system can be written as\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\hat{H}_{\\text{mol}} & = -\\sum_{i}\\frac{\\nabla_{R_i}^2}{2M_i} - \\sum_{i} \\frac{\\nabla_{r_i}^2}{2} -\\sum_{i,j}\\frac{Z_i}{\\lvert R_i - r_j\\lvert} + \\sum_{i,j>i}\\frac{Z_iZ_j}{\\lvert R_i - R_j\\lvert} + \\sum_{i, j>i}\\frac{1}{\\lvert r_i - r_j\\lvert}, \n", + "\\tag{4}\n", + "\\end{align}\n", + "$$\n", + "\n", + "where $R_i, M_i,$ and $Z_i$ denote the position, mass and atomic number (the number of protons) of the $i^{th}$ nucleus, and the positions of electrons are $r_i$. The first two sums describe the kinetic energy of nuclei and electrons, respectively. The third sum describes the attractive Coulomb interaction between the positively charged nuclei and the negatively charged electrons. The last two terms represent the repulsive nuclei-nuclei and electron-electron interactions. Here, the molecular Hamiltonian $\\hat{H}_\\text{mol}$ is already in atomic units of energy, **Hartree**. $1$ Hartree is $[\\hbar^2/(m_ee^2a_0^2)] = 27.2$ eV or $630$ kcal/mol, where $m_e, e,$ and $a_0$ stand for the mass of electron, charge of electron, and Bohr radius. \n", + "\n", + "\n", + "**Note:** The spin-orbit interaction and hyperfine interaction are not considered in this picture. They can be treated as perturbations if necessary. \n", + "\n", + "### Born-Oppenheimer approximation\n", + "\n", + "Since the nuclei are much heavier than electrons, the electrons will move much faster than the nuclei. It is reasonable to treat the positions of nuclei as fixed, $R_i =$ constants. This is known as the Born-Oppenheimer approximation by decoupling the behavior of nuclei and electrons in time scale. Consequently, the kinetic energy term of nuclei will disappear and the nuclei-nuclei repulsive interaction term can be viewed as an energy shift (independent of electron positions $r_i$). We could derive the electronic Hamiltonian $\\hat{H}_{\\text{electron}}$ as\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\hat{H}_{\\text{electron}} & = - \\sum_{i} \\frac{\\nabla_{r_i}^2}{2} -\\sum_{i,j}\\frac{Z_i}{\\lvert R_i - r_j\\lvert} + \\sum_{i, j>i}\\frac{1}{\\lvert r_i - r_j\\lvert} \n", + "\\tag{5},\n", + "\\end{align}\n", + "$$\n", + "\n", + "The energy levels of the electrons in the molecule can be found by solving the time independent Schrödinger equation\n", + "\n", + "$$\n", + "\\hat{H}_{\\text{electron}} |\\Psi_n \\rangle = E_n |\\Psi_n \\rangle,\n", + "\\tag{6}\n", + "$$\n", + "\n", + "where $n$ stands for the energy level. Notice the electron repulsion terms scale as $N_e(N_e-1)/2$ which means for the Oxygen molecule $O_2$ carrying 16 electrons there will be 120 electron repulsion terms in total! In general, this problem cannot be solved analytically. As Dirac concluded in [Quantum mechanics of many-electron systems](https://royalsocietypublishing.org/doi/10.1098/rspa.1929.0094) [6],\n", + "\n", + "> *The underlying physical laws necessary for the mathematical theory of a large part of physics and the whole of chemistry are thus completely known, and the difficulty is only that the exact application of these laws leads to equations much too complicated to be soluble.* \n", + ">\n", + "> ​\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t-- Paul Dirac (1929)\n", + "\n", + "A straightforward numerical approach is discretizing the infinite-dimensional Hilbert space into equidistant grid points where linear algebra guides the whole calculation. Suppose each axis of space is discretized into $k$ points, the $N$-electron (drop the subscript e for simplicity) wave function can be written as [2]\n", + "\n", + "$$\n", + "|\\Psi \\rangle = \\sum_{\\mathbf{x_1}, \\ldots, \\mathbf{x_N}} \\psi(\\mathbf{x_1}, \\ldots, \\mathbf{x_N}) \\mathcal{A}(|\\mathbf{x_1}, \\ldots, \\mathbf{x_N}\\rangle).\n", + "\\tag{7}\n", + "$$\n", + "\n", + "where coordinate $|\\mathbf{x_j}\\rangle = |r_j\\rangle |\\sigma_j\\rangle$ records the spatial location and spin of the $j^{th}$ electron, $|r_j\\rangle = |x_j,y_j,z_j\\rangle$ for $j\\in \\{1,2,\\cdots,N\\}$, $x_j,y_j,z_j \\in \\{0,1,\\cdots,k-1\\}$ and $\\sigma_j \\in \\{\\downarrow,\\uparrow\\}$ for spin down or up. There will be $k^{3N}\\times 2^{N}$ complex amplitudes in total. Here, $\\mathcal{A}$ denotes anti-symmetrization and a consequence of the Pauli exclusion principle (electrons are fermion), and $\\psi(\\mathbf{x_1}, \\mathbf{x_2}, \\ldots, \\mathbf{x_N})=\\langle\\mathbf{x_1}, \\mathbf{x_2}, \\ldots, \\mathbf{x_N}|\\Psi\\rangle$. One can see that storing such a wave function already requires **exponentially growing memory** with respect to the number of electrons $N$. This would make classical simulation methods based on this naive numerical approach intractable for systems size larger than few tens of electrons. Now, the question becomes can we prepare such a wave function $|\\Psi\\rangle$ directly on a quantum computer and measure the expectation value $E_0$? In the next section, let's take the simplest molecular system -- hydrogen molecule $H_2$ as a concrete example.\n", + "\n", + "\n", + "\n", + "**Note:** A detailed review on quantum chemistry and existing classical computational methods are far beyond the scope of this tutorial, we refer the enthusiastic readers to the standard textbooks *'Molecular Electronic-Structure Theory'* [5] by Helgaker and *'Modern Quantum Chemistry: Introduction to Advanced Electronic Structure Theory'* [7] by Szabo & Ostlund. To bridge to knowledge gap between quantum chemistry and quantum computing, please check the following review papers [Quantum computational chemistry](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.92.015003) [2] and [Quantum Chemistry in the Age of Quantum Computing](https://pubs.acs.org/doi/10.1021/acs.chemrev.8b00803) [1].\n", + "\n", + "**Note:** For energy calculation, it is desired to reach the **chemical accuracy** of $1.6\\times10^{-3}$ Hartree or 1 kcal/mol . " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ground state of the hydrogen molecule $H_2$\n", + "\n", + "### Building electronic Hamiltonian\n", + "\n", + "First of all, let us import the necessary libraries and packages.`qchem` module in Paddle Quantum is developed basing on `psi4` and `openfermion`, so you need to install these two packages before executing the following codes. We strongly encourage you to read the tutorial [Building molecular Hamiltonian](./BuildingMolecule_EN.ipynb) first, which introduces how to utilize our quantum chemistry toolkit `qchem`.\n", + "\n", + "**Note: As to the environment setting, please refer to [README.md](https://github.com/PaddlePaddle/Quantum/blob/master/README.md).**" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:14:44.970178Z", + "start_time": "2021-04-30T09:14:40.895128Z" + } + }, + "outputs": [], + "source": [ + "import paddle\n", + "import paddle_quantum.qchem as qchem\n", + "from paddle_quantum.loss import ExpecVal\n", + "from paddle_quantum import Hamiltonian\n", + "from paddle_quantum.state import zero_state, State\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.linalg import dagger\n", + "from paddle_quantum import Backend\n", + "\n", + "import os\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import numpy\n", + "from numpy import pi as PI\n", + "from numpy import savez, zeros\n", + "\n", + "# Eliminate noisy python warnings\n", + "import warnings\n", + "warnings.filterwarnings(\"ignore\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To analyze specific molecules, we need several key information such as **geometry**, **basis set** (such as STO-3G), **multiplicity**, and **charge** to model the molecule and achieve more information about the molecule, such as one-body integrations, two-body integrations, and others. Next, through our built-in quantum chemistry toolkit, we could set a `Hamiltonian` class to carry molecule Hamiltonian information, which may simplify the following calculations." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:14:44.982005Z", + "start_time": "2021-04-30T09:14:44.975892Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "FCI energy for H2_sto-3g_singlet (2 electrons) is -1.137283834485513.\n", + "\n", + "The generated h2 Hamiltonian is \n", + " -0.09706626861762556 I\n", + "-0.04530261550868938 X0, X1, Y2, Y3\n", + "0.04530261550868938 X0, Y1, Y2, X3\n", + "0.04530261550868938 Y0, X1, X2, Y3\n", + "-0.04530261550868938 Y0, Y1, X2, X3\n", + "0.1714128263940239 Z0\n", + "0.16868898168693286 Z0, Z1\n", + "0.12062523481381837 Z0, Z2\n", + "0.16592785032250773 Z0, Z3\n", + "0.17141282639402394 Z1\n", + "0.16592785032250773 Z1, Z2\n", + "0.12062523481381837 Z1, Z3\n", + "-0.2234315367466399 Z2\n", + "0.17441287610651626 Z2, Z3\n", + "-0.2234315367466399 Z3\n" + ] + } + ], + "source": [ + "geo = qchem.geometry(structure=[['H', [-0., 0., 0.0]], ['H', [-0., 0., 0.74]]])\n", + "# geo = qchem.geometry(file='h2.xyz')\n", + "\n", + "# Save molecule information in to variable molecule, including one-body integrations, one-body integrations, molecular and Hamiltonian\n", + "molecule = qchem.get_molecular_data(\n", + " geometry=geo,\n", + " basis='sto-3g',\n", + " charge=0,\n", + " multiplicity=1,\n", + " method=\"fci\",\n", + " if_save=True,\n", + " if_print=True\n", + ")\n", + "# Recall Hamiltonian\n", + "molecular_hamiltonian = qchem.spin_hamiltonian(molecule=molecule,\n", + " filename=None, \n", + " multiplicity=1, \n", + " mapping_method='jordan_wigner',)\n", + "# Print results\n", + "print(\"\\nThe generated h2 Hamiltonian is \\n\", molecular_hamiltonian)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note:** This Hamiltonian is generated with an interatomic distance of $d = 74$ pm. \n", + "\n", + "In addition to inputting molecular geometry directly, inputting molecular geometry file (.xyz file) is also allowed. For more information about quantum chemistry toolkit, please refer to the tutorial [Building molecular Hamiltonian](./BuildingMolecule_EN.ipynb). If you need to test the geometric configuration of more molecules, please check out this [database](http://smart.sns.it/molecules/index.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Building QNN and trial wave function\n", + "\n", + "To implement VQE, we firstly need to design a quantum neural network QNN to prepare the wave function ansatz $|\\Psi(\\boldsymbol\\theta)\\rangle$. Here, we provide a 4-qubit quantum circuit template with a depth of $D$ blocks. The dotted frame in the figure below denotes a single block:\n", + "\n", + "\n", + "![Utheta.jpg](https://release-data.cdn.bcebos.com/PIC%2FUtheta.jpg)\n", + "\n", + "Next, we use the `Circuit` class and the built-in `real_entangled_layer()` circuit template in Paddle Quantum to realize this QNN.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:14:50.083041Z", + "start_time": "2021-04-30T09:14:50.062255Z" + } + }, + "outputs": [], + "source": [ + "def U_theta(num_qubits: int, depth: int) -> Circuit:\n", + " \"\"\"\n", + " Quantum Neural Network\n", + " \"\"\"\n", + " \n", + " # Initialize the quantum neural network according to the number of qubits N\n", + " cir = Circuit(num_qubits)\n", + " \n", + " # Built-in {R_y + CNOT} circuit template\n", + " cir.real_entangled_layer(depth = depth)\n", + " \n", + " # Lay R_y gates in the last row\n", + " cir.ry()\n", + " \n", + " return cir" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Setting up the loss function and model\n", + "\n", + "Now that we have the target Hamiltonian and QNN, we will further define the training model and loss function. By applying the QNN $U(\\theta)$ on the initial state $|0..0\\rangle$, we get the output state $|\\psi(\\boldsymbol\\theta)\\rangle $. Then, the loss function to be minimized is the expectation value, \n", + "\n", + "\n", + "$$\n", + "\\min_{\\boldsymbol\\theta} \\mathcal{L}(\\boldsymbol \\theta) = \\min_{\\boldsymbol\\theta} \\langle \\Psi(\\boldsymbol\\theta)|H |\\Psi(\\boldsymbol\\theta)\\rangle\n", + "= \\min_{\\boldsymbol\\theta} \\sum_k c_k~\\langle \\Psi(\\boldsymbol\\theta)| \\bigotimes_j \\sigma_j^{(k)}|\\Psi(\\boldsymbol\\theta)\\rangle.\n", + "\\tag{8}\n", + "$$" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:14:50.183996Z", + "start_time": "2021-04-30T09:14:50.167892Z" + } + }, + "outputs": [], + "source": [ + "class StateNet(paddle.nn.Layer):\n", + " \"\"\"\n", + " Construct the model net\n", + " \"\"\"\n", + "\n", + " def __init__(self, num_qubits: int, depth: int):\n", + " super(StateNet, self).__init__()\n", + " \n", + " self.depth = depth\n", + " self.num_qubits = num_qubits\n", + " self.cir = U_theta(self.num_qubits, self.depth)\n", + " \n", + " # Define loss function and forward propagation mechanism\n", + " def forward(self):\n", + " \n", + " # Run circuit\n", + " state = self.cir(init_state)\n", + "\n", + " # Calculate loss function/expected value\n", + " loss = loss_func(state) \n", + "\n", + " return loss, self.cir" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Hyper-parameters\n", + "\n", + "Before training the QNN, we also need to set some training hyper-parameters, mainly the learning rate (LR), the number of iterations (ITR), and the depth (D) of repeated blocks. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:14:50.222465Z", + "start_time": "2021-04-30T09:14:50.187093Z" + } + }, + "outputs": [], + "source": [ + "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 = molecular_hamiltonian.n_qubits # Set number of qubits" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training\n", + "\n", + "After all the training model parameters are set, we convert the data into Tensor in the Paddle, and then train the quantum neural network. The results of the training process is stored in the summary_data file.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:15:52.165788Z", + "start_time": "2021-04-30T09:15:29.625076Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "iter: 20 loss: -1.0628\n", + "iter: 20 Ground state energy: -1.0628 Ha\n", + "iter: 40 loss: -1.1323\n", + "iter: 40 Ground state energy: -1.1323 Ha\n", + "iter: 60 loss: -1.1361\n", + "iter: 60 Ground state energy: -1.1361 Ha\n", + "iter: 80 loss: -1.1372\n", + "iter: 80 Ground state energy: -1.1372 Ha\n", + "\n", + "Circuit after training:\n", + "--Ry(1.603)----*--------------x----Ry(4.714)----*--------------x----Ry(3.110)--\n", + " | | | | \n", + "--Ry(1.548)----x----*---------|----Ry(1.566)----x----*---------|----Ry(-1.65)--\n", + " | | | | \n", + "--Ry(-0.07)---------x----*----|----Ry(4.486)---------x----*----|----Ry(1.732)--\n", + " | | | | \n", + "--Ry(0.148)--------------x----*----Ry(7.876)--------------x----*----Ry(0.031)--\n", + " \n" + ] + } + ], + "source": [ + "# Determine the parameter dimensions of the network \n", + "net = StateNet(N, D)\n", + "\n", + "# In general, we use the Adam optimizer to obtain relatively good convergence,\n", + "# Of course you can change it to SGD or RMS prop.\n", + "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())\n", + "\n", + "# Define initial state\n", + "init_state = zero_state(N)\n", + "\n", + "# Define loss function\n", + "loss_func = ExpecVal(molecular_hamiltonian)\n", + "\n", + "# Record optimization results\n", + "summary_iter, summary_loss = [], []\n", + "\n", + "# Optimize iterations\n", + "for itr in range(1, ITR + 1):\n", + "\n", + " # Forward propagation calculates the loss function\n", + " loss, cir = net()\n", + "\n", + " # Back propagation minimizes the loss function\n", + " loss.backward()\n", + " opt.minimize(loss)\n", + " opt.clear_grad()\n", + "\n", + " # Update optimization results\n", + " summary_loss.append(loss.numpy())\n", + " summary_iter.append(itr)\n", + "\n", + " # Print results\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(\"\\nCircuit after training:\") \n", + " print(cir)\n", + "\n", + "# Save the training results in the Output folder\n", + "os.makedirs(\"output\", exist_ok=True)\n", + "savez(\"./output/summary_data\", iter = summary_iter, \n", + " energy=summary_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Benchmarking\n", + "We have now completed the training of the quantum neural network, and the estimated value of the ground state energy obtained is $E_0 \\approx -1.137 $ Hartree. The estimation obtained with VQE is consistent with the value of the ground state energy $E_0 = -1.13728$ Hartree calculated by `psi4` at sto-3g basis using the full configuration-interaction (FCI) method within the chemical accuracy $\\varepsilon = 1.6 \\times 10^{-3}$ Hartree.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": { + "ExecuteTime": { + "end_time": "2021-04-30T09:15:18.096944Z", + "start_time": "2021-04-30T09:15:17.481250Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "result = numpy.load('./output/summary_data.npz')\n", + "\n", + "eig_val, eig_state = numpy.linalg.eig(\n", + " molecular_hamiltonian.construct_h_matrix())\n", + "min_eig_H = numpy.min(eig_val.real)\n", + "min_loss = numpy.ones([len(result['iter'])]) * min_eig_H\n", + "\n", + "plt.figure(1)\n", + "func1, = plt.plot(result['iter'], result['energy'], \n", + " alpha=0.7, marker='', linestyle=\"-\", color='r')\n", + "func_min, = plt.plot(result['iter'], min_loss, \n", + " alpha=0.7, marker='', linestyle=\":\", color='b')\n", + "plt.xlabel('Number of iteration')\n", + "plt.ylabel('Energy (Ha)')\n", + "\n", + "plt.legend(handles=[\n", + " func1,\n", + " func_min\n", + "],\n", + " labels=[\n", + " r'$\\left\\langle {\\psi \\left( {\\theta } \\right)} '\n", + " r'\\right|H\\left| {\\psi \\left( {\\theta } \\right)} \\right\\rangle $',\n", + " 'Ground-state energy',\n", + " ], loc='best')\n", + "plt.text(-15.5, -1.145, f'{min_eig_H:.5f}', fontsize=10, color='b')\n", + "#plt.savefig(\"vqe.png\", bbox_inches='tight', dpi=300)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Determining the interatomic distance\n", + "\n", + "Recall the above calculation is done with an interatomic distance $d = 74$ pm between two hydrogen atoms. Another interesting aspect we can try with VQE is determining the true interatomic distance by modifying the `h2.xyz` file. The results are summarize in figure below,\n", + "\n", + "![vqe-fig-dist](figures/vqe-fig-distance.png)\n", + "\n", + "The lowest value is found around $d = 74$ pm (1 pm = $1\\times 10^{-12}$m), which is consistent with the [experimental data](https://cccbdb.nist.gov/exp2x.asp?casno=1333740&charge=0) $d_{exp} (H_2) = 74.14$ pm." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "_______\n", + "\n", + "## References\n", + "\n", + "[1] Cao, Yudong, et al. Quantum Chemistry in the Age of Quantum Computing. [Chemical reviews 119.19 (2019): 10856-10915.](https://pubs.acs.org/doi/10.1021/acs.chemrev.8b00803)\n", + "\n", + "[2] McArdle, Sam, et al. Quantum computational chemistry. [Reviews of Modern Physics 92.1 (2020): 015003.](https://journals.aps.org/rmp/abstract/10.1103/RevModPhys.92.015003)\n", + "\n", + "\n", + "[3] Peruzzo, A. et al. A variational eigenvalue solver on a photonic quantum processor. [Nat. Commun. 5, 4213 (2014).](https://www.nature.com/articles/ncomms5213)\n", + "\n", + "[4] Moll, Nikolaj, et al. Quantum optimization using variational algorithms on near-term quantum devices. [Quantum Science and Technology 3.3 (2018): 030503.](https://iopscience.iop.org/article/10.1088/2058-9565/aab822)\n", + "\n", + "[5] Helgaker, Trygve, Poul Jorgensen, and Jeppe Olsen. Molecular electronic-structure theory. John Wiley & Sons, 2014.\n", + "\n", + "[6] Dirac, Paul Adrien Maurice. Quantum mechanics of many-electron systems. [Proceedings of the Royal Society of London. Series A, Containing Papers of a Mathematical and Physical Character 123.792 (1929): 714-733.](https://royalsocietypublishing.org/doi/10.1098/rspa.1929.0094)\n", + "\n", + "[7] Szabo, Attila, and Neil S. Ostlund. Modern quantum chemistry: introduction to advanced electronic structure theory. Courier Corporation, 2012." + ] + } + ], + "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.8.13" + }, + "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": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "426.667px" + }, + "toc_section_display": true, + "toc_window_display": false + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tutorial/quantum_simulation/VQSD_CN.ipynb b/tutorials/quantum_simulation/VQSD_CN.ipynb similarity index 84% rename from tutorial/quantum_simulation/VQSD_CN.ipynb rename to tutorials/quantum_simulation/VQSD_CN.ipynb index 4ff730a..ecf7f96 100644 --- a/tutorial/quantum_simulation/VQSD_CN.ipynb +++ b/tutorials/quantum_simulation/VQSD_CN.ipynb @@ -22,7 +22,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:17:03.603558Z", @@ -38,8 +38,10 @@ "import scipy.stats\n", "import paddle\n", "from paddle import matmul, trace\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import dagger" + "import paddle_quantum\n", + "from paddle_quantum import intrinsic\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.linalg import dagger" ] }, { @@ -59,15 +61,16 @@ "ExecuteTime": { "end_time": "2021-04-30T09:17:03.622120Z", "start_time": "2021-04-30T09:17:03.609542Z" - } + }, + "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "[[ 0.2569+0.j -0.012 +0.0435j -0.0492-0.0055j -0.0548+0.0682j]\n", - " [-0.012 -0.0435j 0.2959-0.j 0.1061-0.0713j -0.0392-0.0971j]\n", + "[[ 0.2569-0.j -0.012 +0.0435j -0.0492-0.0055j -0.0548+0.0682j]\n", + " [-0.012 -0.0435j 0.2959+0.j 0.1061-0.0713j -0.0392-0.0971j]\n", " [-0.0492+0.0055j 0.1061+0.0713j 0.2145-0.j 0.0294-0.1132j]\n", " [-0.0548-0.0682j -0.0392+0.0971j 0.0294+0.1132j 0.2327+0.j ]]\n" ] @@ -109,15 +112,15 @@ "SEED = 14 # 固定随机种子\n", "THETA_SIZE = 15 # 量子神经网络中参数的数量\n", "\n", - "def U_theta(theta, N):\n", + "def U_theta(N: int) -> Circuit:\n", " \"\"\"\n", " Quantum Neural Network\n", " \"\"\"\n", " \n", " # 按照量子比特数量/网络宽度初始化量子神经网络\n", - " cir = UAnsatz(N)\n", + " cir = Circuit(N)\n", " # 调用内置的量子神经网络模板\n", - " cir.universal_2_qubit_gate(theta, [0, 1])\n", + " cir.universal_two_qubits([0, 1])\n", " # 返回量子神经网络的电路\n", " return cir" ] @@ -144,41 +147,35 @@ "outputs": [], "source": [ "# 输入用来标记的量子态sigma\n", - "sigma = diag([0.1, 0.2, 0.3, 0.4]).astype('complex128') \n", + "sigma = diag([0.1, 0.2, 0.3, 0.4])\n", "\n", "class Net(paddle.nn.Layer):\n", " \"\"\"\n", " Construct the model net\n", " \"\"\"\n", "\n", - " def __init__(self, shape, rho, sigma, dtype='float64'):\n", + " def __init__(self, rho, sigma):\n", " super(Net, self).__init__()\n", " \n", - " \n", - " \n", " # 将 numpy.ndarray 转换成 Paddle 中支持的 Tensor\n", - " self.rho = paddle.to_tensor(rho)\n", - " self.sigma = paddle.to_tensor(sigma)\n", - " \n", - " # 初始化 theta 参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", + " complex_dtype = paddle_quantum.get_dtype()\n", + " self.rho = paddle.cast(paddle.to_tensor(rho), complex_dtype)\n", + " self.sigma = paddle.cast(paddle.to_tensor(sigma), complex_dtype)\n", + "\n", + " # 施加量子神经网络\n", + " self.cir = U_theta(N) \n", "\n", " # 定义损失函数和前向传播机制\n", " def forward(self, N):\n", - " \n", - " # 施加量子神经网络\n", - " cir = U_theta(self.theta, N)\n", - " U = cir.U\n", - " \n", + " \n", " # rho_tilde 是将 U 作用在 rho 后得到的量子态 U*rho*U^dagger \n", + " U = self.cir.unitary_matrix()\n", " rho_tilde = matmul(matmul(U, self.rho), dagger(U))\n", "\n", " # 计算损失函数\n", " loss = trace(matmul(self.sigma, rho_tilde))\n", "\n", - " return paddle.real(loss), rho_tilde, cir" + " return paddle.real(loss), rho_tilde, self.cir" ] }, { @@ -218,7 +215,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:17:10.042819Z", @@ -231,16 +228,10 @@ "output_type": "stream", "text": [ "iter: 0 loss: 0.2494\n", - "iter: 10 loss: 0.1958\n", + "iter: 10 loss: 0.1959\n", "iter: 20 loss: 0.1843\n", "iter: 30 loss: 0.1816\n", - "iter: 40 loss: 0.1805\n", - "\n", - "训练后的电路：\n", - "--U----X----Rz(1.489)----*-----------------X----U--\n", - " | | | \n", - "--U----*----Ry(1.367)----X----Ry(2.749)----*----U--\n", - " \n" + "iter: 40 loss: 0.1805\n" ] } ], @@ -248,7 +239,7 @@ "paddle.seed(SEED)\n", "\n", "# 确定网络的参数维度\n", - "net = Net(shape=[THETA_SIZE], rho=rho, sigma=sigma)\n", + "net = Net(rho=rho, sigma=sigma)\n", "\n", "# 一般来说，我们利用 Adam 优化器来获得相对好的收敛\n", "# 当然你可以改成 SGD 或者是 RMS prop.\n", @@ -268,10 +259,7 @@ "\n", " # 打印训练结果\n", " if itr % 10 == 0:\n", - " print('iter:', itr, 'loss:', '%.4f' % loss.numpy()[0])\n", - " if itr == ITR - 1:\n", - " print(\"\\n训练后的电路：\")\n", - " print(cir)" + " print('iter:', itr, 'loss:', '%.4f' % loss.numpy()[0])" ] }, { @@ -285,7 +273,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:17:13.536415Z", @@ -297,7 +285,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "The estimated spectrum is: [0.49938069 0.29916354 0.10103808 0.10041768]\n", + "The estimated spectrum is: [0.49938068 0.29916352 0.10103808 0.10041767]\n", "The target spectrum is: [0.5 0.3 0.1 0.1]\n" ] } @@ -325,7 +313,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -339,7 +327,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.0" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/quantum_simulation/VQSD_EN.ipynb b/tutorials/quantum_simulation/VQSD_EN.ipynb similarity index 85% rename from tutorial/quantum_simulation/VQSD_EN.ipynb rename to tutorials/quantum_simulation/VQSD_EN.ipynb index 7f2c7c7..64677bd 100644 --- a/tutorial/quantum_simulation/VQSD_EN.ipynb +++ b/tutorials/quantum_simulation/VQSD_EN.ipynb @@ -17,7 +17,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:16:42.117977Z", @@ -33,8 +33,10 @@ "import scipy.stats\n", "import paddle\n", "from paddle import matmul, trace\n", - "from paddle_quantum.circuit import UAnsatz\n", - "from paddle_quantum.utils import dagger" + "import paddle_quantum\n", + "from paddle_quantum import intrinsic\n", + "from paddle_quantum.ansatz import Circuit\n", + "from paddle_quantum.linalg import dagger" ] }, { @@ -67,8 +69,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "[[ 0.2569+0.j -0.012 +0.0435j -0.0492-0.0055j -0.0548+0.0682j]\n", - " [-0.012 -0.0435j 0.2959-0.j 0.1061-0.0713j -0.0392-0.0971j]\n", + "[[ 0.2569-0.j -0.012 +0.0435j -0.0492-0.0055j -0.0548+0.0682j]\n", + " [-0.012 -0.0435j 0.2959+0.j 0.1061-0.0713j -0.0392-0.0971j]\n", " [-0.0492+0.0055j 0.1061+0.0713j 0.2145-0.j 0.0294-0.1132j]\n", " [-0.0548-0.0682j -0.0392+0.0971j 0.0294+0.1132j 0.2327+0.j ]]\n" ] @@ -110,14 +112,14 @@ "SEED = 14 # Fixed random seed\n", "THETA_SIZE = 15 # The number of parameters in the quantum neural network\n", "\n", - "def U_theta(theta, N):\n", + "def U_theta(N: int) -> Circuit:\n", " \"\"\"\n", " Quantum Neural Network\n", " \"\"\"\n", " # Initialize the quantum neural network according to the number of qubits/network width\n", - " cir = UAnsatz(N)\n", + " cir = Circuit(N)\n", " # Call the built-in quantum neural network template\n", - " cir.universal_2_qubit_gate(theta, [0, 1])\n", + " cir.universal_two_qubits([0, 1])\n", " # Return the circuit of the quantum neural network\n", " return cir" ] @@ -154,41 +156,35 @@ "outputs": [], "source": [ "# Enter the quantum state sigma \n", - "sigma = diag([0.1, 0.2, 0.3, 0.4]).astype('complex128')\n", + "sigma = diag([0.1, 0.2, 0.3, 0.4])\n", "\n", "class Net(paddle.nn.Layer):\n", " \"\"\"\n", " Construct the model net\n", " \"\"\"\n", "\n", - " def __init__(self, shape, rho, sigma, dtype='float64'):\n", + " def __init__(self, rho, sigma):\n", " super(Net, self).__init__()\n", " \n", - " \n", - " \n", " # Convert Numpy array to Tensor supported in Paddle \n", - " self.rho = paddle.to_tensor(rho)\n", - " self.sigma = paddle.to_tensor(sigma)\n", - " \n", - " # Initialize the theta parameter list and fill the initial value with the uniform distribution of [0, 2*pi]\n", - " self.theta = self.create_parameter(shape=shape, \n", - " default_initializer=paddle.nn.initializer.Uniform(low=0.0, high=2*PI),\n", - " dtype=dtype, is_bias=False)\n", + " complex_dtype = paddle_quantum.get_dtype()\n", + " self.rho = paddle.cast(paddle.to_tensor(rho), complex_dtype)\n", + " self.sigma = paddle.cast(paddle.to_tensor(sigma), complex_dtype)\n", + "\n", + " # Apply quantum neural network\n", + " self.cir = U_theta(N)\n", "\n", " # Define loss function and forward propagation mechanism\n", " def forward(self, N):\n", " \n", - " # Apply quantum neural network\n", - " cir = U_theta(self.theta, N)\n", - " U = cir.U\n", - "\n", " # rho_tilde is the quantum state U*rho*U^dagger \n", + " U = self.cir.unitary_matrix()\n", " rho_tilde = matmul(matmul(U, self.rho), dagger(U))\n", "\n", " # Calculate the loss function\n", " loss = trace(matmul(self.sigma, rho_tilde))\n", "\n", - " return paddle.real(loss), rho_tilde, cir" + " return paddle.real(loss), rho_tilde, self.cir" ] }, { @@ -227,7 +223,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2021-04-30T09:16:50.340636Z", @@ -240,16 +236,10 @@ "output_type": "stream", "text": [ "iter: 0 loss: 0.2494\n", - "iter: 10 loss: 0.1958\n", + "iter: 10 loss: 0.1959\n", "iter: 20 loss: 0.1843\n", "iter: 30 loss: 0.1816\n", - "iter: 40 loss: 0.1805\n", - "\n", - "The trained circuit:\n", - "--U----X----Rz(1.489)----*-----------------X----U--\n", - " | | | \n", - "--U----*----Ry(1.367)----X----Ry(2.749)----*----U--\n", - " \n" + "iter: 40 loss: 0.1805\n" ] } ], @@ -257,7 +247,7 @@ "paddle.seed(SEED)\n", "\n", "# Determine the parameter dimension of the network\n", - "net = Net(shape=[THETA_SIZE], rho=rho, sigma=sigma)\n", + "net = Net(rho=rho, sigma=sigma)\n", "\n", "# We use Adam optimizer for better performance\n", "# One can change it to SGD or RMSprop.\n", @@ -277,10 +267,7 @@ "\n", " # Print training results\n", " if itr% 10 == 0:\n", - " print('iter:', itr,'loss:','%.4f'% loss.numpy()[0])\n", - " if itr == ITR - 1:\n", - " print(\"\\nThe trained circuit:\")\n", - " print(cir)" + " print('iter:', itr,'loss:','%.4f'% loss.numpy()[0])" ] }, { @@ -306,7 +293,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "The estimated spectrum is: [0.49938069 0.29916354 0.10103808 0.10041768]\n", + "The estimated spectrum is: [0.49938068 0.29916352 0.10103808 0.10041767]\n", "The target spectrum is: [0.5 0.3 0.1 0.1]\n" ] } @@ -349,7 +336,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.3" + "version": "3.8.13" }, "toc": { "base_numbering": 1, diff --git a/tutorial/quantum_simulation/figures/buildingmolecule-fig-h2o.png b/tutorials/quantum_simulation/figures/buildingmolecule-fig-h2o.png similarity index 100% rename from tutorial/quantum_simulation/figures/buildingmolecule-fig-h2o.png rename to tutorials/quantum_simulation/figures/buildingmolecule-fig-h2o.png diff --git a/tutorial/quantum_simulation/figures/trotter_suzuki_circuit.png b/tutorials/quantum_simulation/figures/trotter_suzuki_circuit.png similarity index 100% rename from tutorial/quantum_simulation/figures/trotter_suzuki_circuit.png rename to tutorials/quantum_simulation/figures/trotter_suzuki_circuit.png diff --git a/tutorial/quantum_simulation/figures/vqe-fig-distance.png b/tutorials/quantum_simulation/figures/vqe-fig-distance.png similarity index 100% rename from tutorial/quantum_simulation/figures/vqe-fig-distance.png rename to tutorials/quantum_simulation/figures/vqe-fig-distance.png diff --git a/tutorial/quantum_simulation/h2.xyz b/tutorials/quantum_simulation/h2.xyz similarity index 100% rename from tutorial/quantum_simulation/h2.xyz rename to tutorials/quantum_simulation/h2.xyz diff --git a/tutorial/quantum_simulation/h2o.xyz b/tutorials/quantum_simulation/h2o.xyz similarity index 100% rename from tutorial/quantum_simulation/h2o.xyz rename to tutorials/quantum_simulation/h2o.xyz diff --git a/tutorial/quantum_simulation/hf.xyz b/tutorials/quantum_simulation/hf.xyz similarity index 100% rename from tutorial/quantum_simulation/hf.xyz rename to tutorials/quantum_simulation/hf.xyz diff --git a/tutorials/quantum_simulation/output/summary_data.npz b/tutorials/quantum_simulation/output/summary_data.npz new file mode 100644 index 0000000..1de85fd Binary files /dev/null and b/tutorials/quantum_simulation/output/summary_data.npz differ