{ "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": 145, "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", "from paddle_quantum.state import zero_state\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": 146, "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": 147, "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": 148, "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": 149, "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": "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", "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": 150, "metadata": { "ExecuteTime": { "end_time": "2021-03-02T09:15:06.589265Z", "start_time": "2021-03-02T09:15:06.452691Z" } }, "outputs": [], "source": [ "# 量子数据编码器电路\n", "def encoding_circuit(data, n_qubits):\n", " cir = Circuit(n_qubits)\n", " for i in range(n_qubits):\n", " param = data[0] if i % 2 == 0 else data[1]\n", " cir.ry(qubits_idx=i, param=np.arcsin(param))\n", " cir.rz(qubits_idx=i, param=np.arccos(param**2))\n", " return cir\n", "\n", "\n", "# 经典数据编码成量子态\n", "def datapoints_transform_to_state(data, n_qubits):\n", " \"\"\"\n", " :param data: 形状为 [BATCHSIZE, 2]，numpy向量形式\n", " :param n_qubits: 数据转化后的量子比特数量\n", " :return: 编码后的量子态，大小为 [BATCHSIZE, 1, 2 ^ n_qubits]\n", " \"\"\"\n", "\n", " batchsize, _ = data.shape\n", " res = []\n", " init_state = zero_state(n_qubits)\n", " for i in range(batchsize):\n", " cir = encoding_circuit(data[i], n_qubits)\n", " out_state = cir(init_state)\n", " res.append(out_state.numpy().reshape(1, -1))\n", " res = np.array(res, dtype=paddle_quantum.get_dtype())\n", " return res" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "测试角度编码下得到的量子数据" ] }, { "cell_type": "code", "execution_count": 151, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "作为测试我们输入以上的经典信息:\n", "(x_0, x_1) = (1, 0)\n", "编码后输出的2比特量子态为:\n", "[[[0.49999997-0.49999997j 0. +0.j 0.49999997-0.49999997j\n", " 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": 152, "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": 153, "metadata": {}, "outputs": [], "source": [ "# 搭建整个优化流程图\n", "class Opt_Classifier(paddle_quantum.Operator):\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", " paddle.seed(seed_paras)\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", " self.circuit.rz()\n", " self.circuit.ry()\n", " self.circuit.rz()\n", "\n", " # 对每一层搭建电路\n", " for _ in range(depth):\n", " # 搭建纠缠层\n", " self.circuit.cnot()\n", " # 对每一个量子比特搭建Ry\n", " self.circuit.ry()\n", "\n", " # 定义前向传播机制、计算损失函数 和交叉验证正确率\n", " def forward(self, state_in, label):\n", " \"\"\"\n", " 输入： state_in：输入量子态，shape: [BATCH, 1, 2^n]\n", " label：输入量子态对应标签，shape: [BATCH, 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": 154, "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": 155, "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", " # 存储正确率 acc 等信息\n", " summary_iter, summary_test_acc = [], []\n", "\n", " # 一般来说，我们利用Adam优化器来获得相对好的收敛\n", " # 当然你可以改成SGD或者是RMSprop\n", " myLayer = Opt_Classifier(n=N, depth=DEPTH, seed_paras=seed_paras) # 得到初始化量子电路\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": 156, "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.2157 train acc: 0.9000 test acc: 0.6900\n", "epoch: 3 iter: 4 loss: 0.2033 train acc: 0.4000 test acc: 0.5500\n", "epoch: 6 iter: 4 loss: 0.1467 train acc: 1.0000 test acc: 0.9700\n", "epoch: 9 iter: 4 loss: 0.1287 train acc: 1.0000 test acc: 1.0000\n", "epoch: 12 iter: 4 loss: 0.1215 train acc: 1.0000 test acc: 1.0000\n", "epoch: 15 iter: 4 loss: 0.1202 train acc: 1.0000 test acc: 1.0000\n", "epoch: 18 iter: 4 loss: 0.1197 train acc: 1.0000 test acc: 1.0000\n", "训练后的电路：\n", "--Rz(5.489)----Ry(4.294)----Rz(3.063)----*--------------x----Ry(2.788)--\n", " | | \n", "--Rz(2.359)----Ry(4.117)----Rz(2.727)----x----*---------|----Ry(1.439)--\n", " | | \n", "--Rz(2.349)----Ry(3.474)----Rz(5.971)---------x----*----|----Ry(1.512)--\n", " | | \n", "--Rz(1.973)----Ry(-0.04)----Rz(-0.01)--------------x----*----Ry(2.075)--\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": [ "主程序段总共运行了 44.10896015167236 秒\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 = 10, # 设置随机种子用以初始化各种参数\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": 157, "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": 158, "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", " 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": 159, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Encoding method: amplitude_encoding\n", "epoch: 0 iter: 0 loss: 0.2448 train acc: 0.7000 test acc: 0.5500\n", "epoch: 0 iter: 5 loss: 0.4895 train acc: 0.3000 test acc: 0.6100\n", "epoch: 0 iter: 10 loss: 0.1318 train acc: 0.8000 test acc: 0.5800\n", "epoch: 0 iter: 15 loss: 0.2297 train acc: 0.6000 test acc: 0.6500\n", "Encoding method: angle_encoding\n", "epoch: 0 iter: 0 loss: 0.2437 train acc: 0.6000 test acc: 0.3900\n", "epoch: 0 iter: 5 loss: 0.1325 train acc: 0.8000 test acc: 0.7100\n", "epoch: 0 iter: 10 loss: 0.1397 train acc: 0.8000 test acc: 0.6600\n", "epoch: 0 iter: 15 loss: 0.1851 train acc: 0.6000 test acc: 0.6300\n", "Encoding method: pauli_rotation_encoding\n", "epoch: 0 iter: 0 loss: 0.3170 train acc: 0.6000 test acc: 0.7000\n", "epoch: 0 iter: 5 loss: 0.2119 train acc: 0.7000 test acc: 0.7000\n", "epoch: 0 iter: 10 loss: 0.2736 train acc: 0.7000 test acc: 0.7000\n", "epoch: 0 iter: 15 loss: 0.2186 train acc: 0.7000 test acc: 0.7000\n", "Encoding method: IQP_encoding\n", "epoch: 0 iter: 0 loss: 0.3279 train acc: 0.3000 test acc: 0.6200\n", "epoch: 0 iter: 5 loss: 0.1772 train acc: 0.7000 test acc: 0.7200\n", "epoch: 0 iter: 10 loss: 0.2051 train acc: 0.8000 test acc: 0.6500\n", "epoch: 0 iter: 15 loss: 0.1951 train acc: 0.7000 test acc: 0.6700\n", "Encoding method: complex_entangled_encoding\n", "epoch: 0 iter: 0 loss: 0.5466 train acc: 0.4000 test acc: 0.2900\n", "epoch: 0 iter: 5 loss: 0.2075 train acc: 0.7000 test acc: 0.7000\n", "epoch: 0 iter: 10 loss: 0.2951 train acc: 0.7000 test acc: 0.7000\n", "epoch: 0 iter: 15 loss: 0.2614 train acc: 0.7000 test acc: 0.7000\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": 160, "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": 161, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "epoch: 0 iter: 0 loss: 0.1864 train acc: 0.7500 test acc: 0.9000\n", "epoch: 0 iter: 5 loss: 0.0841 train acc: 1.0000 test acc: 1.0000\n", "epoch: 0 iter: 10 loss: 0.0490 train acc: 1.0000 test acc: 1.0000\n", "epoch: 0 iter: 15 loss: 0.0562 train acc: 1.0000 test acc: 1.0000\n", "epoch: 1 iter: 0 loss: 0.0800 train acc: 1.0000 test acc: 1.0000\n", "epoch: 1 iter: 5 loss: 0.0554 train acc: 1.0000 test acc: 1.0000\n", "epoch: 1 iter: 10 loss: 0.0421 train acc: 1.0000 test acc: 1.0000\n", "epoch: 1 iter: 15 loss: 0.0454 train acc: 1.0000 test acc: 1.0000\n", "epoch: 2 iter: 0 loss: 0.0752 train acc: 1.0000 test acc: 1.0000\n", "epoch: 2 iter: 5 loss: 0.0569 train acc: 1.0000 test acc: 1.0000\n", "epoch: 2 iter: 10 loss: 0.0413 train acc: 1.0000 test acc: 1.0000\n", "epoch: 2 iter: 15 loss: 0.0436 train acc: 1.0000 test acc: 1.0000\n", "epoch: 3 iter: 0 loss: 0.0775 train acc: 1.0000 test acc: 1.0000\n", "epoch: 3 iter: 5 loss: 0.0597 train acc: 1.0000 test acc: 1.0000\n", "epoch: 3 iter: 10 loss: 0.0419 train acc: 1.0000 test acc: 1.0000\n", "epoch: 3 iter: 15 loss: 0.0425 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": 162, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "epoch: 0 iter: 0 loss: 0.3369 train acc: 0.4500 test acc: 0.4700\n", "epoch: 0 iter: 5 loss: 0.2124 train acc: 0.6250 test acc: 0.5750\n", "epoch: 0 iter: 10 loss: 0.2885 train acc: 0.4500 test acc: 0.5550\n", "epoch: 1 iter: 0 loss: 0.2455 train acc: 0.4750 test acc: 0.6300\n", "epoch: 1 iter: 5 loss: 0.1831 train acc: 0.7750 test acc: 0.7550\n", "epoch: 1 iter: 10 loss: 0.1584 train acc: 0.8000 test acc: 0.8000\n", "epoch: 2 iter: 0 loss: 0.2106 train acc: 0.7000 test acc: 0.7800\n", "epoch: 2 iter: 5 loss: 0.1612 train acc: 0.8250 test acc: 0.7600\n", "epoch: 2 iter: 10 loss: 0.1550 train acc: 0.8250 test acc: 0.8300\n", "epoch: 3 iter: 0 loss: 0.1663 train acc: 0.8000 test acc: 0.8400\n", "epoch: 3 iter: 5 loss: 0.1485 train acc: 0.8500 test acc: 0.8450\n", "epoch: 3 iter: 10 loss: 0.1655 train acc: 0.8000 test acc: 0.8350\n", "epoch: 4 iter: 0 loss: 0.1625 train acc: 0.8000 test acc: 0.8700\n", "epoch: 4 iter: 5 loss: 0.1297 train acc: 0.8500 test acc: 0.8400\n", "epoch: 4 iter: 10 loss: 0.1646 train acc: 0.7750 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", "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 }