{ "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": "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" }, "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": "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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": [ "接着对采样不同量子比特数量电路得到的各参数最大梯度的平均值和方差作图,方便比较。" ], "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": "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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 之后,损失函数的值只在一个较小的范围内波动,说明训练过程已经达到了稳定。" ], "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 }