![](\"figures/terminal.png\")
\n",
"\n",
"关于 conda 更多的本地指令请参考 [官方教程](https://docs.conda.io/projects/conda/en/latest/user-guide/getting-started.html)。\n",
"- \n",
"
- Numpy\n", "
- Paddlepaddle 1.8.3 以上\n", "
- Paddle Quantum \n", "
[回到 目录]
\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 量子计算基础" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "量子计算 (Quantum Computing QC )是利用量子物理中特有的现象 (量子叠加态，量子纠缠)来设计相应的量子算法以解决 (物理、化学、计算机等领域)特定的任务。现有的量子计算有好几种模型，比如有基于绝热定理的绝热计算模型以及基于测量的MBQC模型等等。在本手册中，我们主要讨论目前影响力最大、使用最广泛的量子电路（Quantum circuit）模型。在量子电路的框架下，运算最基本的组成单元是量子比特 (qubit)。这与经典计算机中比特 (bit) 的概念很相似。经典比特只能处于0和1两种状态中的某一种 (物理图景上可以对应高低电位)。与之不同的是，量子比特不仅可以处于两个状态$\\lvert {0}\\rangle$ 还有 $\\lvert {1}\\rangle$还可以处于两者的叠加态 (稍后我们来具体讲解下这一概念)。而所谓的量子计算，就是利用量子逻辑门操控这些量子比特。逻辑门运算的基本理论是线性代数，在此我们假定读者已经具备一定的线性代数基础。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 什么是量子比特？" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 数学表示\n", "\n", "在量子力学中，一个微观粒子的量子态可以表示为由两个正规正交基线性组合得到的向量，这些基向量一般可以写为：\n", "\n", "$$ \\lvert {0}\\rangle := \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}, \\quad \\lvert {1}\\rangle := \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} $$\n", "\n", "我们这里向量的表示方法采用了量子物理上传统的狄拉克表示 (bra-ket)。这两个单位正交向量$\\{\\lvert {0}\\rangle, \\lvert {1}\\rangle \\}$，它俩一般被称为**计算基** (computational basis)。物理图景中我们可以认为 $\\lvert {0}\\rangle$ 和 $\\lvert {1}\\rangle$ 分别对应一个原子的能量基态和激发态或者其他一些二分类状态。 一个量子比特所有可能的态可以看作是二维希尔伯特空间中所有的归一化向量，这个希尔伯特空间的一组正规正交基正是$\\{\\lvert {0}\\rangle, \\lvert {1}\\rangle \\}$。而更多的量子比特系统也同样可以由高维度的希尔伯特空间中的的单位向量表示，而这个高维希尔伯特空间的正交基就是$\\{\\lvert {0}\\rangle, \\lvert {1}\\rangle \\}$的张量积。比如说，一个两量子比特 (2-qubit)系统可以被一个4维的希尔伯特空间里的单位复数向量表示，而这个希尔伯特空间的正规正交基是：\n", "\n", "$$ \n", "\\lvert {00}\\rangle = \\lvert {0}\\rangle\\otimes \\lvert {0}\\rangle := \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix}, \\quad \n", "\\lvert {01}\\rangle = \\lvert {0}\\rangle\\otimes \\lvert {1}\\rangle := \\begin{bmatrix} 0 \\\\ 1 \\\\ 0 \\\\ 0 \\end{bmatrix}, \\quad\n", "\\lvert {10}\\rangle = \\lvert {1}\\rangle\\otimes \\lvert {0}\\rangle := \\begin{bmatrix} 0 \\\\ 0 \\\\ 1 \\\\ 0 \\end{bmatrix}, \\quad\n", "\\lvert {11}\\rangle = \\lvert {1}\\rangle\\otimes \\lvert {0}\\rangle := \\begin{bmatrix} 0 \\\\ 0 \\\\ 0 \\\\ 1 \\end{bmatrix}\n", "$$\n", "\n", "我们默认最左边的位置代表第一个量子比特，依此类推。其中符号 $\\otimes$ 是张量积运算。其工作原理大概如下：\n", "给定两个矩阵$A_{m\\times n}$ 还有 $B_{p \\times q}$，那么$A,B$的张量积为\n", "\n", "\n", "$$\n", "A \\otimes B = \n", "\\begin{bmatrix}\n", "a_{11}B & \\cdots & a_{1 n}B\\\\\n", "\\vdots & \\ddots & \\vdots \\\\\n", "a_{m1}B & \\cdots & a_{m n}B\n", "\\end{bmatrix}_{(mp)\\times (nq)}\n", "$$\n", "\n", "一个单量子比特所处的任意量子态 $\\lvert {\\psi}\\rangle$可以写成基向量 $\\lvert {0}\\rangle$ 和 $\\lvert {1}\\rangle$ 的线性叠加，也就是说，它可以被描述成一个$\\lvert {0}\\rangle$ 和 $\\lvert {1}\\rangle$的线性组合\n", "\n", "\n", "$$\\lvert {\\psi}\\rangle = \\alpha \\lvert {0}\\rangle + \\beta \\lvert {1}\\rangle\n", ":= \\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix},\\,\\alpha, \\beta \\in \\mathbb{C}$$\n", "\n", "其中$\\alpha$ 和 $\\beta$ 可以是**复数**，他们表示概率振幅。这意味着当我们测量这个量子比特时，根据波恩法则，测量得到量子比特处于$\\lvert {0}\\rangle$ 状态的概率是$|\\alpha|^2$；而测量得到$\\lvert {1}\\rangle$的概率是$|\\beta|^2$。由于概率相加等于1，我们必须要加入如下的限制条件：\n", "\n", "$$|\\alpha|^2 + |\\beta|^2 = 1$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 布洛赫球面 (Bloch Sphere) 表示\n", "\n", "我们用一个球面上的点来表示一个量子比特可能处于的量子态，这个球面被称为**布洛赫球面**，(见图 1)\n", "\n", "$$ \n", "\\lvert {\\psi}\\rangle = \\alpha \\lvert {0}\\rangle + \\beta \\lvert {1}\\rangle \n", "= \\cos\\bigg(\\frac{\\theta}{2}\\bigg) \\lvert {0}\\rangle + e^{i\\varphi}\\sin\\bigg(\\frac{\\theta}{2}\\bigg) \\lvert {1}\\rangle\n", "$$\n", "\n", "注意：多个量子系统的状态就无法用布洛赫球面来表示。如果是一个经典比特的话，那么它只有两个状态0和1，也就是布洛赫球面的北极和南极。这两个位置恰好对应着$\\lvert {0}\\rangle$ 和 $\\lvert {1}\\rangle$。**而一个量子比特不光可以处于两极，它可以在球面上任意一点，这样一种叠加的状态是经典比特做不到的**。举例来说，量子态 $\\frac{1}{\\sqrt{2}}\\big(\\lvert {0}\\rangle + i\\lvert {1}\\rangle\\big)$就处于球面赤道和 y-正半轴的交界处。" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
![](\"figures/bloch.png\")
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
" \n",
" \n",
" \n",
" \n",
" \n",
"**图 1.** \n",
"单量子比特的布洛赫球面表示. [[图片来源]](https://en.wikipedia.org/wiki/Qubit)\n",
"\n",
"下面的内容面向对量子计算更熟悉的读者。如果你阅读这段感到困难，不用担心，您可以选择略过这一节，这不会对理解接下的内容产生影响。由于量子比特之间的交互以及去相干问题 (Decoherence)，因此，对于一个具有多量子比特的系统来说，它的单量子比特子系统将不再处于纯态 (pure state)，而是演变成混合态 (mixed state)。混合态可以看成不同纯态的按照一定概率的混合。\n",
" **单比特的混合态可以看成是布洛赫球内部的点，而不是存在于球表面**。通常来说，混合态需要用到量子力学的密度矩阵形式来描述，比如\n",
"\n",
"$$ \n",
"\\rho_{\\text{mixed}} \n",
"= \\sum_i P_i \\lvert {\\psi_i}\\rangle\\langle{\\psi_i} \\lvert\n",
"= \\frac{1}{2} \\lvert {0}\\rangle \\langle{0} \\lvert + \\frac{1}{2} \\lvert {1}\\rangle\\langle{1} \\lvert\n",
":= \\frac{1}{2} \\begin{bmatrix} 1 \\\\ 0\\end{bmatrix} \\begin{bmatrix} 1 & 0 \\end{bmatrix} + \\frac{1}{2} \\begin{bmatrix} 0 \\\\ 1\\end{bmatrix} \\begin{bmatrix} 0 & 1 \\end{bmatrix} \n",
"= \\frac{1}{2} \\begin{bmatrix} 1 & 0\\\\ 0 & 1 \\end{bmatrix}\n",
"$$\n",
"\n",
"其中行向量 (bra) $ \\langle{0} \\lvert $ 是列向量 (ket) $\\lvert {0}\\rangle$ 的复共轭转置。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**注：**如需更多信息，可参考维基百科 [链接](https://en.wikipedia.org/wiki/Qubit)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 什么是量子逻辑门?\n",
"\n",
"在经典计算机中，我们可以在经典比特上施加基本的逻辑运算( 非门 NOT, 与非门 NAND, 异或门 XOR, 与门 AND, 或门 OR)并组合成更复杂的运算。而量子计算则有完全不同的一套逻辑运算，它们被称为量子门 (quantum gate)。我们并不能在一个量子计算机上编译现有的C++程序。因为**经典计算机和量子计算机有不同的逻辑门构造，所谓的量子算法是需要利用这些量子门的特殊性来构造的**。\n",
"\n",
"量子门在数学上可以被表示成酉矩阵 (unitary matrix)。酉矩阵操作可以保证向量的长度不变，这是个很好的性质。不然我们对一个纯态量子比特进行操作，会让它劣化成混合态导致其无法接着使用。那么什么是酉矩阵呢？\n",
"\n",
"$$ \n",
"U^{\\dagger}U = UU^{\\dagger} = I,\\,\n",
"\\Vert \\lvert {\\psi}\\rangle \\Vert = \\Vert U\\lvert {\\psi}\\rangle\\Vert = 1\n",
"$$\n",
"\n",
"其中$U^{\\dagger}$是$U$的埃尔米特转置，$I$ 表示单位矩阵。但是酉矩阵作为量子门的物理意义是什么？这意味着**所有的量子门都必须是可逆的**。对于任何一个量子门运算，都可以找到一个与其对应的反向运算。除此之外，酉矩阵必须是个方阵。因为量子门的输入和输出要求有同样数量的量子比特。一个作用在 $n$ 量子比特的量子门可以写成一个 $2^n \\times 2^n$ 的酉矩阵。最常见的（也是物理上最容易实现的）量子门作用在一个或两个量子比特上，就像经典逻辑门那样。"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 单量子比特门\n",
"\n",
"接下来，我们介绍在量子计算中非常重要的单量子比特门，包括泡利矩阵 $\\{X, Y, Z\\}$ 或 $\\{\\sigma_x, \\sigma_y, \\sigma_z\\}$、单比特旋转门 $\\{R_x, R_y, R_z\\}$ 和哈达玛门 $H$。有一个对于经典或量子计算都很重要的门是 **非门 (NOT gate)**，其可以表示成如下酉矩阵：\n",
"\n",
"\n",
"$$ X := \\begin{bmatrix} 0 &1 \\\\ 1 &0 \\end{bmatrix}$$\n",
"\n",
"这个量子门（酉矩阵）作用在单量子比特（一个复向量）上本质上的运算是**矩阵乘以向量**\n",
"\n",
"\n",
"$$ \n",
"X \\lvert {0}\\rangle := \\begin{bmatrix} 0 &1 \\\\ 1 &0 \\end{bmatrix} \\begin{bmatrix} 1 \\\\0 \\end{bmatrix} \n",
"=\\begin{bmatrix} 0 \\\\1 \\end{bmatrix} = \\lvert {1}\\rangle \n",
"\\quad \\text{and} \\quad \n",
"X \\lvert {1}\\rangle := \\begin{bmatrix} 0 &1 \\\\ 1 &0 \\end{bmatrix} \\begin{bmatrix} 0 \\\\1 \\end{bmatrix} \n",
"=\\begin{bmatrix} 1 \\\\0 \\end{bmatrix}=\\lvert {0}\\rangle\n",
"$$\n",
"\n",
"回忆起前面的布洛赫球面表示，这个矩阵 $X$ 作用在一个量子比特（布洛赫球面上的一点）就相当于**关于布洛赫球的X轴旋转角度 $\\pi$**。这就是为什么\n",
" $X$ 可以表示成 $R_x(\\pi)$（只相差了一个无关紧要的全局相位 $e^{-i\\pi/2} = -i$ )。其他两个泡利矩阵 $Y$ 和 $Z$ 在这一点上也非常相似 （代表绕 Y和 Z轴旋转 $\\pi$运算 ）：\n",
"\n",
"\n",
"$$ \n",
"Y := \\begin{bmatrix} 0 &-i \\\\ i &0 \\end{bmatrix}\n",
"\\quad \\text{and} \\quad \n",
"Z := \\begin{bmatrix} 1 &0 \\\\ 0 &-1 \\end{bmatrix}\n",
"$$\n",
"\n",
"一般来说，任何一个在布洛赫球关于相应的轴旋转 $\\theta$ 角度的量子门可以表示为：\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",
"$$\n",
"\n",
"除了旋转门之外，最重要的单比特门就是哈达玛门了。对应的布洛赫球面解释是两个旋转组成的，先是按Z轴旋转$\\pi$，然后按Y轴旋转$\\pi/2$。它的矩阵表示是：\n",
"\n",
"$$H := \\frac{1}{\\sqrt{2}}\\begin{bmatrix} 1 &1 \\\\ 1 &-1 \\end{bmatrix} $$\n",
"\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 两比特量子门\n",
"\n",
"从单量子比特门我们可以拓展到两量子比特门。有两种拓展方式，第一种是只挑选出一个量子比特，在上面施加单量子比特门，其他的量子比特则不受影响。有的时候，您会见到如下图所示的量子电路："
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![](\"figures/hardmad.png\")
\n",
"\n",
" \n",
" \n",
" \n",
" \n",
"**图 2.** \n",
"两量子比特逻辑运算的电路表示和解读. [[图片来源]](https://en.wikipedia.org/wiki/Quantum_logic_gate)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"作用在两量子比特上的量子门可以表示成一个$4\\times4$酉矩阵\n",
"$$\n",
"U = H \\otimes I \n",
"= \\frac{1}{\\sqrt{2}} \\begin{bmatrix} 1 &1 \\\\ 1 &-1 \\end{bmatrix} \n",
"\\otimes \\begin{bmatrix} 1 &0 \\\\ 0 &1 \\end{bmatrix} \n",
"= \\frac{1}{\\sqrt{2}} \\,\n",
"\\begin{bmatrix}\n",
"1 &0 &1 &0 \\\\ \n",
"0 &1 &0 &1 \\\\\n",
"1 &0 &-1 &0 \\\\\n",
"0 &1 &0 &-1 \n",
"\\end{bmatrix}\n",
"$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"另一种拓展方式是作用在全部两个量子比特上。比如CNOT，这个门会使得一个量子比特的状态影响到另一个量子比特的状态\n",
"\n",
"$$\n",
"CNOT := \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",
"$$\n",
"\n",
"我们近距离观察一下它作用在不同的初始量子态上\n",
"\n",
"$$\n",
"CNOT \\lvert {00}\\rangle = \\lvert {00}\\rangle, \\quad\n",
"CNOT \\lvert {01}\\rangle = \\lvert {01}\\rangle, \\quad\n",
"CNOT \\lvert {10}\\rangle = \\lvert {11}\\rangle, \\quad\n",
"CNOT \\lvert {11}\\rangle = \\lvert {10}\\rangle\n",
"$$\n",
"\n",
"也就是说，当第一个量子比特处于 $\\lvert {1}\\rangle$状态时，CNOT会在第二个量子比特上施加$X$门，如果第一个量子比特处于 $\\lvert {0}\\rangle$状态，那么第二个量子比特则不受任何影响。这也是为什么 CNOT 会被称为受控非门。下面是一些常见的量子门及它们的矩阵表示"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![](\"figures/gate.png\")
\n",
"\n",
" \n",
" \n",
" \n",
" \n",
" \n",
"**图 3.** \n",
"常见的量子门. [[图片来源]](https://en.wikipedia.org/wiki/Quantum_logic_gate)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**注**：更多信息可见如下维基百科 [链接](https://en.wikipedia.org/wiki/Quantum_logic_gate)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 什么是量子力学中的测量?\n",
"\n",
"对于一个两分类的量子态，比如电子的自旋（Spin），可以自旋向上。这时我们规定该电子处于 $\\lvert {0}\\rangle$态。当然电子也可以自旋向下，这时我们规定它处于 $\\lvert {1}\\rangle$ 态。神奇的是，电子等微观粒子在被观测之前可以同时处于自旋向上和自旋向下的叠加态 $\\lvert {\\psi}\\rangle =\\alpha \\lvert {0}\\rangle + \\beta \\lvert {1}\\rangle$。那么这个奇怪的叠加态到底指的是什么呢？答案很简单，我们可以去测量一下这个处于\"叠加态\"的电子。值得注意的是，量子力学中的测量通常指的是一个统计结果而不是单次测量。这是由于测量本身的特性会使得观察后的量子态塌缩。就拿我们前面提到的处于 $\\lvert {\\psi}\\rangle$ 态的这个电子来举例，如果我们测量这一个电子的自旋，我们会有 $|\\alpha|^2$ 的概率观测到自旋向上并且观测后量子态塌缩成 $ \\lvert {0}\\rangle$。同样的，我们也有 $|\\beta|^2$ 的概率测量得到自旋向下$\\lvert {1}\\rangle$。那么想要精确的得到 $\\alpha$ 的数值，一次实验显然是不够的。我们需要拜托物理学家朋友准备了好多好多处于叠加态 $\\alpha \\lvert {0}\\rangle + \\beta \\lvert {1}\\rangle$ 的电子，把每一个电子的自旋都测量了一下再统计频率。测量在量子力学中地位比较特殊，如果读者觉得难理解。请参阅 [维基百科-量子力学中的测量](https://en.wikipedia.org/wiki/Measurement_in_quantum_mechanics#:~:text=In%20quantum%20physics%2C%20a%20measurement,makes%20are%20in%20general%20probabilistic.) 获取更多知识。\n",
"\n",
"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 示例以及练习\n", "\n", "### 示例: 用Paddle Quantum创建 $X$ 门\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", "$$\n", "\n", "因此，我们不难看出 $X$ 门可以表示为$R_x(\\pi)$。以下是代码展示：" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "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" ] } ], "source": [ "# 设置角度参数 theta = pi\n", "theta = np.array([np.pi])\n", "\n", "# 启动 Paddle 动态图模式\n", "with fluid.dygraph.guard():\n", " \n", " # 我们需要将 Numpy array 转换成 Paddle 动态图模式中支持的 variable\n", " theta = fluid.dygraph.to_variable(theta)\n", " \n", " # 设置计算所需的量子比特数量\n", " num_qubits = 1\n", " \n", " # 初始化我们的单比特量子电路\n", " cir = UAnsatz(num_qubits)\n", " \n", " # 在第一个量子比特(第0号量子比特)的位置上施加一个 Rx 旋转门， 角度为 pi\n", " which_qubit = 0\n", " cir.rx(theta, which_qubit)\n", " \n", " # 打印出这个量子门\n", " # 转换成 numpy \n", " print('量子门的矩阵表达式为：')\n", " print(cir.U.numpy())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "结果和$X (NOT)$门只相差一个全局相位$-i$\n", "\n", "\n", "$$ \\text{output} = \\begin{bmatrix} 0 &-i \\\\ -i &0 \\end{bmatrix}\n", "= -i\\begin{bmatrix} 0 &1 \\\\ 1 &0 \\end{bmatrix} = -i X\n", "$$\n", "\n", "有兴趣的话，你可以仔细思考一下为什么在量子计算中，全局相位并不重要。\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 练习: 创建 $Y$ 门\n", "\n", "那么按照以上的例子依葫芦画瓢，你是否可以试着自己创建一个 $Y$ 门？试着补全下面的代码" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "theta = \"your code\"\n", "with fluid.dygraph.guard():\n", " \n", " theta = fluid.dygraph.to_variable(theta)\n", " num_qubits = 1\n", " cir = UAnsatz(\"your code\")\n", " cir.ry(\"your code\")\n", " print(cir.U.numpy())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "和原来一样，我们还是多了一个全局相位\n", "\n", "\n", "$$ \\text{output} = \\begin{bmatrix} 0 &-1 \\\\ 1 &0 \\end{bmatrix}\n", "= -i\\begin{bmatrix} 0 &-i \\\\ i &0 \\end{bmatrix} = -i Y\n", "$$\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
[回到 目录]
\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 量子电路模板/量子神经网络" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "经过上面的准备，你现在有一定的知识基础可以了解量子机器学习了。简单来说我们要做的就是利用量子电路来替代传统的神经网络来完成机器学习的任务。我们一般会准备一个可调节参数的量子电路（量子神经网络 QNN），很多时候也被称为模板 (Ansatz)，里面的参数是人为可调节的（这些参数其实就是旋转门的角度$\\theta$）。如果再加上一个精心设计的损失函数，就可以将一个量子计算问题转化为经典的寻找损失函数最小值问题。然后不断调节电路中的参数直到损失函数下降至收敛 (此时损失函数达到最优值或次优值)， 我们就完成优化了。\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 示例: 如何创建量子神经网络 QNN?\n", "\n", "所谓的QNN就是通常可以表示为一些单比特量子旋转门和双比特门的组合。其中一个可以高效利用硬件的架构是只包含 $\\{R_x, R_y, R_z, \\text{CNOT} \\}$这四种量子门的模板。它们很容易在NISQ设备（通常是超导量子比特）上实现，因为CNOT只需要实施在相邻量子比特上。一个例子可见下图：\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
![](\"figures/gate1.png\")
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"通常来说，每条线代表一个量子比特。我们把图最上端的认为是第一个量子比特，依次往下。从左到右代表我们施加门的时间顺序，先施加最左边的量子门。接下来，我们来看看如何在量桨上建造这个简单的两比特量子神经网络\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"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"
]
}
],
"source": [
"# 设置角度参数 theta \n",
"theta = np.full([4], np.pi)\n",
"\n",
"# 启动 Paddle 动态图模式\n",
"with fluid.dygraph.guard():\n",
" \n",
" # 我们需要将 Numpy array 转换成 Paddle 动态图模式中支持的 variable\n",
" theta = fluid.dygraph.to_variable(theta)\n",
" \n",
" # 初始化量子电路\n",
" num_qubits = 2\n",
" cir = UAnsatz(num_qubits)\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",
" print('图中量子神经网络 U(theta=pi) 的矩阵表达式是:')\n",
" print(cir.U.numpy().real)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$$ \\text{output} = \n",
"\\begin{bmatrix} \n",
"0 &-1 &0 &0 \\\\ \n",
"-1 &0 &0 &0 \\\\\n",
"0 &0 &1 &0 \\\\\n",
"0 &0 &0 &1 \n",
"\\end{bmatrix}\n",
"$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 练习:\n",
"\n",
"给你如下代码，你能想象出对应的电路吗?"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"theta = np.full([6], np.pi)\n",
"with fluid.dygraph.guard():\n",
" \n",
" theta = fluid.dygraph.to_variable(theta)\n",
" \n",
" num_qubits = 3\n",
" cir = UAnsatz(num_qubits) \n",
" \n",
" cir.ry(theta[0], 0)\n",
" cir.ry(theta[1], 1)\n",
" cir.ry(theta[2], 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)\n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"答案如下:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"![](\"figures/gate2.png\")
\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### 内置的电路模板"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"在最新版本的 Paddle Quantum中，我们提供了一些内置的电路模板方便场景部署。"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"![](\"figures/complex_entangled_layer.png\")
\n",
"\n",
"特别地，当我们处理的任务不涉及虚数时，使用电路模板 `real_entangled_layer(theta, DEPTH)` 会更加高效 ($R_y$旋转门替代$U_3$)。"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEPCAYAAABV6CMBAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAAghklEQVR4nO3df5hdVX3v8feHAIEKKD9GS5NAUok/QGqUgNz2Sv0FhkeFWEECKGDR2Iu08thaw1WhRnoLtVVLDUosP60SEH+QlmC0It7bKpgBIiFgyhACJGIdCb+UAkY+94+9J5ycnJnZZzL7nAPzeT3Pfmbvtfba53vy5Jnv7LX2Xku2iYiIqGq7bgcQERHPLkkcERHRliSOiIhoSxJHRES0JYkjIiLasn23A+iEvfbay9OnT+92GBERzyo333zzL2z3NZdPiMQxffp0+vv7ux1GRMSziqR7W5WnqyoiItqSxBEREW1J4oiIiLYkcURERFuSOCIioi1JHBER0ZYkjoiIaEsSR0REtCWJIyIi2jIh3hzfFtMXXNu1z1537lu69tkREcPJHUdERLSl1sQhaY6kNZIGJC1oUf8hSXdIuk3SdyXt21B3sqS7yu3khvKDJK0qr3m+JNX5HSIiYku1JQ5Jk4BFwJHA/sDxkvZvOu1WYLbt3wOuBv62bLsHcDbwGuAQ4GxJu5dtPg+8D5hZbnPq+g4REbG1Ou84DgEGbK+1/RSwBDi68QTb37P9eHl4IzC13H8z8B3bG20/BHwHmCNpb2A32zfaNnA5MLfG7xAREU3qTBxTgPsbjteXZcM5FbhulLZTyv1RrylpvqR+Sf2Dg4Nthh4REcPpicFxSe8CZgOfGq9r2l5se7bt2X19W61DEhERY1Rn4tgATGs4nlqWbUHSm4CPAkfZfnKUtht4pjtr2GtGRER96kwcK4CZkmZI2hGYByxtPEHSq4ALKZLGzxuqlgNHSNq9HBQ/Alhu+wHgUUmHlk9TnQRcU+N3iIiIJrW9AGh7k6TTKZLAJOBi26slLQT6bS+l6JraBfhq+VTtfbaPsr1R0icpkg/AQtsby/3TgEuBnSnGRK4jIiI6ptY3x20vA5Y1lZ3VsP+mEdpeDFzcorwfeMU4hhkREW3oicHxiIh49kjiiIiItiRxREREW5I4IiKiLUkcERHRliSOiIhoSxJHRES0JYkjIiLaksQRERFtSeKIiIi2JHFERERbkjgiIqItSRwREdGWJI6IiGhLEkdERLQliSMiItpSa+KQNEfSGkkDkha0qD9M0i2SNkk6pqH89ZJWNmxPSJpb1l0q6Z6Gull1foeIiNhSbSsASpoELAIOB9YDKyQttX1Hw2n3AacAf9HY1vb3gFnldfYABoBvN5zyYdtX1xV7REQMr86lYw8BBmyvBZC0BDga2Jw4bK8r654e4TrHANfZfry+UCMioqo6u6qmAPc3HK8vy9o1D7iiqeyvJd0m6TOSJrdqJGm+pH5J/YODg2P42IiIaKWnB8cl7Q0cCCxvKD4TeBlwMLAH8JFWbW0vtj3b9uy+vr7aY42ImCjqTBwbgGkNx1PLsna8E/iG7V8PFdh+wIUngUsousQiIqJD6kwcK4CZkmZI2pGiy2lpm9c4nqZuqvIuBEkC5gK3b3uoERFRVW2Jw/Ym4HSKbqY7gatsr5a0UNJRAJIOlrQeOBa4UNLqofaSplPcsXy/6dJflrQKWAXsBZxT13eIiIit1flUFbaXAcuays5q2F9B0YXVqu06Wgym237D+EYZERHt6OnB8YiI6D1JHBER0ZYkjoiIaEsSR0REtCWJIyIi2pLEERERbUniiIiItoyaOCT9gaTnlfvvkvRpSfvWH1pERPSiKnccnwcel/RK4M+Bu4HLa40qIiJ6VpXEscm2KdbS+JztRcCu9YYVERG9qsqUI49JOhN4N/BaSdsBO9QbVkRE9KoqdxzHAU8Cf2z7ZxRzS32q1qgiIqJnjZo4ymTxNWBopb1fAN+oM6iIiOhdVZ6qeh9wNXBhWTQF+GaNMUVERA+rMsbxAYpV9m4CsH2XpBfWGlU8601fcG3XPnvduW/p2mdHTARVxjietP3U0IGk7QHXF1JERPSyKonj+5L+N7CzpMOBrwL/Um9YERHRq6okjgXAIMVSre+nWNHvY1UuLmmOpDWSBiQtaFF/mKRbJG2SdExT3W8krSy3pQ3lMyTdVF7zynI984iI6JBRxzhsPw18sdwqkzQJWAQcDqwHVkhaavuOhtPuA04B/qLFJf7b9qwW5ecBn7G9RNIXgFMp3m6PiIgOGPaOQ9JV5c9Vkm5r3ipc+xBgwPbacoxkCcXb55vZXmf7NuDpKsFKEvAGiqe8AC4D5lZpGxER42OkO44Plj/fOsZrTwHubzheD7ymjfY7SeoHNgHn2v4msCfwsO1NDdec0qqxpPnAfIB99tmnvcgjImJYw95x2H6g3D3N9r2NG3BaB2Lb1/Zs4ATgs5Je3E5j24ttz7Y9u6+vr54IIyImoCqD44e3KDuyQrsNwLSG46llWSW2N5Q/1wI3AK8CHgReUD4S3PY1IyJi2400xvG/JK0CXto0vnEPUGWMYwUws3wKakdgHrB0lDZDn727pMnl/l7AHwB3lLP0fg8YegLrZOCaKteMiIjxMdIYx1eA64C/oXgkd8hjtjeOdmHbmySdDiwHJgEX214taSHQb3uppIMp5r3aHXibpE/YPgB4OXChpKcpktu5DU9jfQRYIukc4Fbgona+cEREbJuREodtr5P0geYKSXtUTB7LKN77aCw7q2F/BUV3U3O7HwAHDnPNtRRPbEVERBeMdsfxVuBmiilG1FBn4HdrjCsiInrUsInD9lvLnzM6F05ERPS6YROHpFeP1ND2LeMfTkRE9LqRuqr+foQ6U7zBHRERE8xIXVWv72QgERHx7DBSV9UbbF8v6Y9a1dv+en1hRURErxqpq+oPgeuBt7WoM5DEERExAY3UVXV2+fM9nQsnInpVlgOOIaPOVSVpT0nnlwsu3SzpHyTt2YngIiKi91SZ5HAJxQqA76CYI2oQuLLOoCIioneNugIgsLftTzYcnyPpuLoCioiI3lbljuPbkuZJ2q7c3kkxcWFERExAIz2O+xjPzFF1BvDPZdV2wC9pvU54REQ8x430VNWunQwkIiKeHaqMcSBpd2AmsNNQme3/W1dQERHRu0ZNHJLeC3yQYt2MlcChwA/JXFURERNSlcHxDwIHA/eW81e9Cni4ysUlzZG0RtKApAUt6g8r3w/ZJOmYhvJZkn4oaXW5XO1xDXWXSrpH0spym1UlloiIGB9VuqqesP2EJCRNtv0TSS8drZGkScAi4HBgPbBC0tKGJWAB7gNOYeuB9seBk2zfJel3gJslLbf9cFn/YdtXV4g9IiLGWZXEsV7SC4BvAt+R9BBwb4V2hwAD5VKvSFoCHA1sThy215V1Tzc2tP2fDfs/lfRzoI+KdzoREVGfUbuqbL/d9sO2/wr4OHARMLfCtacA9zccry/L2iLpEGBH4O6G4r8uu7A+I2nyMO3mS+qX1D84ONjux0ZExDCqjHEg6dWS/gz4PWC97afqDWvz5+4NfAl4j+2hu5IzgZdRjLvsAXykVVvbi23Ptj27r6+vE+FGREwIVSY5PAu4DNgT2Au4RNLHKlx7AzCt4XhqWVaJpN2Aa4GP2r5xqNz2Ay48CVxC0SUWEREdUmWM40TglbafAJB0LsVjueeM0m4FMFPSDIqEMQ84oUpQknYEvgFc3jwILmlv2w9IEkWX2e1VrhkREeOjSlfVT2l48Q+YTIU7B9ubgNMp5rW6E7jK9mpJCyUdBSDpYEnrgWOBCyWtLpu/EzgMOKXFY7dflrQKWEVxBzRaAouIiHE00lxV/0gxV9UjwGpJ3ymPDwd+VOXitpcBy5rKzmrYX0HRhdXc7p95Zm6s5rq8eBgR0UUjdVX1lz9vpug2GnJDbdFERDzHPBdXThxpksPLhvbLMYeXlIdrbP+6lmiiLc/F/5AR0fuqzFX1OoqnqtZRTLE+TdLJmeQwYvzlj4F4NqjyVNXfA0fYXgMg6SXAFcBBdQYWERG9qcpTVTsMJQ3YPB3IDvWFFBERvazKHcfNkv6JZ55yOpFnBs4jImKCqZI4/gT4APBn5fH/Ay6oLaKIiOhpIyaOcmr0H9t+GfDpzoQUERG9bMQxDtu/AdZI2qdD8URERI+r0lW1O8Wb4z8CfjVUaPuo2qKKiIieVSVxfLz2KCIi4lljpLmqdqIYGN+PYkLBi8qJCyMiYgIbaYzjMmA2RdI4kuJFwIiImOBG6qra3/aBAJIuouKMuBER8dw20h3H5okM00UVERFDRrrjeKWkR8t9ATuXxwJse7fao4uIqCCTQ3bWsHcctifZ3q3cdrW9fcN+paQhaY6kNZIGJC1oUX+YpFskbZJ0TFPdyZLuKreTG8oPkrSqvOb55RKyERHRIVUmORyT8q3zRRQD6/sDx0vav+m0+4BTgK80td0DOBt4DXAIcLak3cvqzwPvA2aW25yavkJERLRQW+Kg+IU/YHut7aeAJcDRjSfYXmf7NuDpprZvBr5je6Pth4DvAHMk7Q3sZvtG2wYuB+bW+B0iIqJJnYljCnB/w/H6smxb2k4p90e9pqT5kvol9Q8ODlYOOiIiRlZn4ugq24ttz7Y9u6+vr9vhREQ8Z4z05vhjgIerrzBAvgGY1nA8tSyrYgPwuqa2N5TlU8d4zYiIGAcjPVU19PTUPwALKLqEpgIfAT5b4dorgJmSZkjaEZgHLK0Y13LgCEm7l4PiRwDLbT8APCrp0PJpqpOAaypeMyIixkGVrqqjbF9g+zHbj9r+PE2D3K2ULw2eTpEE7gSusr1a0kJJRwFIOljSeuBY4EJJq8u2G4FPUiSfFcDCsgzgNOCfgAHgbuC6Nr5vRERsoyqz4/5K0okUT0UZOJ6G6dVHYnsZsKyp7KyG/RVs2fXUeN7FwMUtyvuBV1T5/IiIGH9V7jhOAN4J/Fe5HVuWRUTEBDTqHYftdVTomoqIiIlh1DsOSS+R9F1Jt5fHvyfpY/WHFhERvahKV9UXgTMpZ8st3/SeV2dQERHRu6okjt+y3bwWR6ZZj4iYoKokjl9IejHly4DlLLYP1BpVRET0rCqP434AWAy8TNIG4B7gxFqjioiInjVi4iinRj/N9pskPQ/YzvZjnQktIiJ60YiJw/ZvJP3Pcr/SS38REfHcVqWr6lZJS4Gv0vDGuO2v1xZVRET0rCqJYyfgQeANDWUGkjgiIiagKm+Ov6cTgURExLPDqIlD0iW0WJfD9h/XElFERPS0Kl1V/9qwvxPwduCn9YQTERG9rkpX1dcajyVdAfx7bRFFRERPG8ua4zOBF453IBER8exQZXbcxyQ9OrQB/0KxfOyoJM2RtEbSgKQFLeonS7qyrL9J0vSy/ERJKxu2pyXNKutuKK85VJckFhHRQVW6qnYdy4XLt84XAYcD64EVkpbavqPhtFOBh2zvJ2kecB5wnO0vA18ur3Mg8E3bKxvanViuBBgRER1W5Y7jD8rpRpD0LkmflrRvhWsfAgzYXmv7KYqlZ5sXhDoauKzcvxp4oyQ1nXN82TYiInpAlTGOzwOPS3ol8OfA3cDlFdpNAe5vOF5flrU8x/Ym4BFgz6ZzjgOuaCq7pOym+niLRAOApPmS+iX1Dw4OVgg3IiKqqJI4Ntk2xd3B52wvAsbUfdUuSa8BHrd9e0PxibYPBF5bbu9u1db2Ytuzbc/u6+vrQLQRERNDlcTxmKQzgXcB10raDtihQrsNwLSG46llWctzJG0PPJ9iepMh82i627C9ofz5GPAVii6xiIjokCqJ4zjgSeBU2z+jSACfqtBuBTBT0gxJO1IkgaVN5ywFTi73jwGuL+9uKBPUO2kY35C0vaS9yv0dgLcCtxMRER1T5amqnwGfbji+jwpjHLY3STodWA5MAi62vVrSQqDf9lLgIuBLkgaAjWy5lvlhwP221zaUTQaWl0ljEvBvFGuiR0REh1SZq+pQ4B+BlwM7UvzC/qXt54/W1vYyYFlT2VkN+08Axw7T9gbg0KayXwEHjfa5ERFRnypdVZ+jeCT2LmBn4L3ABXUGFRERvavSlCO2B4BJtn9j+xJgTr1hRUREr6oyO+7j5eD2Skl/CzzA2Oa4ioiI54AqCeDd5XmnUywdOw14R51BRURE76ryVNW9knYG9rb9iQ7EFBERPazKXFVvA1YC3yqPZ0lqfh8jIiImiCpdVX9F8Xb2wwDlLLUzaosoIiJ6WpXE8WvbjzSVbbUGeURETAxVnqpaLekEYJKkmcCfAT+oN6yIiOhVVe44/hQ4gGK+qiuAR4EzaowpIiJ6WJWnqh4HPlpuERExwQ2bOEZ7csr2UeMfTkRE9LqR7jj+B8XqfFcANwEtV9qLiIiJZaTE8dvA4RQTHJ4AXAtcYXt1JwKLiIjeNOzgeDmh4bdsn0wxvfkAcEO5xkZERExQIw6OS5oMvIXirmM6cD7wjfrDioiIXjXsHYeky4EfAq8GPmH7YNufHFrzuwpJcyStkTQgaUGL+smSrizrb5I0vSyfLum/Ja0sty80tDlI0qqyzfmSMvYSEdFBI73H8S5gJvBB4AeSHi23xyQ9OtqFJU0CFgFHAvsDx0vav+m0U4GHbO8HfAY4r6Hubtuzyu1PGso/D7yvjG0mWRskIqKjRhrj2M72ruW2W8O2q+3dKlz7EGDA9lrbTwFLgKObzjkauKzcvxp440h3EJL2BnazfaNtU6x9PrdCLBERMU7qXJBpCsXjvEPWl2Utz7G9CXgE2LOsmyHpVknfl/TahvPXj3JNACTNl9QvqX9wcHDbvklERGzWqyv5PQDsY/tVwIeAr0iqcpezme3Ftmfbnt3X11dLkBERE1GdiWMDxWqBQ6aWZS3PkbQ98HzgQdtP2n4QwPbNwN3AS8rzp45yzYiIqFGdiWMFMFPSjHLN8nlA8zQmS4GTy/1jgOttW1JfObiOpN+lGARfa/sB4FFJh5ZjIScB19T4HSIiokmVadXHxPam8mXB5cAk4GLbqyUtBPptLwUuAr4kaQDYSJFcAA4DFkr6NfA08Ce2N5Z1pwGXAjsD15VbRER0SG2JA8D2MmBZU9lZDftPAMe2aPc14GvDXLMfeMX4RhoREVXVmjgietH0Bdd27bPXnfuWrn12xHjp1aeqIiKiRyVxREREW5I4IiKiLUkcERHRliSOiIhoSxJHRES0JYkjIiLaksQRERFtSeKIiIi2JHFERERbkjgiIqItSRwREdGWJI6IiGhLEkdERLQliSMiItpSa+KQNEfSGkkDkha0qJ8s6cqy/iZJ08vywyXdLGlV+fMNDW1uKK+5stxeWOd3iIiILdW2kFO5Zvgi4HBgPbBC0lLbdzScdirwkO39JM0DzgOOA34BvM32TyW9gmL52SkN7U4sVwKMiIgOq/OO4xBgwPZa208BS4Cjm845Gris3L8aeKMk2b7V9k/L8tXAzpIm1xhrRERUVGfimALc33C8ni3vGrY4x/Ym4BFgz6Zz3gHcYvvJhrJLym6qj0tSqw+XNF9Sv6T+wcHBbfkeERHRoKcHxyUdQNF99f6G4hNtHwi8ttze3aqt7cW2Z9ue3dfXV3+wERETRJ2JYwMwreF4alnW8hxJ2wPPBx4sj6cC3wBOsn33UAPbG8qfjwFfoegSi4iIDqkzcawAZkqaIWlHYB6wtOmcpcDJ5f4xwPW2LekFwLXAAtv/MXSypO0l7VXu7wC8Fbi9xu8QERFNaksc5ZjF6RRPRN0JXGV7taSFko4qT7sI2FPSAPAhYOiR3dOB/YCzmh67nQwsl3QbsJLijuWLdX2HiIjYWm2P4wLYXgYsayo7q2H/CeDYFu3OAc4Z5rIHjWeMERHRnp4eHI+IiN6TxBEREW1J4oiIiLYkcURERFuSOCIioi1JHBER0ZYkjoiIaEsSR0REtCWJIyIi2pLEERERbUniiIiItiRxREREW5I4IiKiLUkcERHRliSOiIhoSxJHRES0JYkjIiLaUmvikDRH0hpJA5IWtKifLOnKsv4mSdMb6s4sy9dIenPVa0ZERL1qSxySJgGLgCOB/YHjJe3fdNqpwEO29wM+A5xXtt0fmAccAMwBLpA0qeI1IyKiRnXecRwCDNhea/spYAlwdNM5RwOXlftXA2+UpLJ8ie0nbd8DDJTXq3LNiIio0fY1XnsKcH/D8XrgNcOdY3uTpEeAPcvyG5vaTin3R7smAJLmA/PLw19KWjOG7zAe9gJ+MZaGOm+cI9laYhubxDY2iW1suhnbvq0K60wcXWV7MbC423FI6rc9u9txtJLYxiaxjU1iG5tejK3OrqoNwLSG46llWctzJG0PPB94cIS2Va4ZERE1qjNxrABmSpohaUeKwe6lTecsBU4u948Brrftsnxe+dTVDGAm8KOK14yIiBrV1lVVjlmcDiwHJgEX214taSHQb3spcBHwJUkDwEaKREB53lXAHcAm4AO2fwPQ6pp1fYdx0vXushEktrFJbGOT2Mam52JT8Qd+RERENXlzPCIi2pLEERERbUniiIiItiRx1EDSHpL26HYcERF1SOIYJ5L2kbRE0iBwE/AjST8vy6Z3ObyeJ+lFkl5dbi/qdjyjkbRLt2OI6JY8VTVOJP0Q+CxwdcOjw5OAY4EzbB/axfCGJWmV7QO7+PmzgC9QvPw59DLnVOBh4DTbt3QnspFJus/2Pt2OA4qkyzNT8myw/V/djGc0knax/csuxyCKue82/7sBP3IP/0KU9DLbP+l2HJDEMW4k3WV7Zrt1nSDpj4arAr5gu6+T8WwRgLQSeL/tm5rKDwUutP3KrgRWxPCh4aqAj9ruandkku6YP/8I4ALgLrb8d9uP4t/t292KbSTd/ndr9Jydq6oLbpZ0AcVsv0MTMU6jeDP+1q5FVbgS+DLQ6q+EnTocS7PnNScNANs3SnpeNwJq8H+AT1G8hNqsF7p5L2X4pHsJ0KtJt9vdfP8AvMn2usbCcpaKZcDLuxFUGcP5w1UBL+hgKCNK4hg/J1GsL/IJtrz9HXpDvptuA/7O9u3NFZLe1IV4Gl0n6VrgcrZMuCcB3+paVIVbgG/avrm5QtJ7uxBPsyTdsdmeYmbtZhuAHTocS7P3AH8OPNmi7vgOxzKsdFVNAJJeC9xr+74WdbNt93chrMYYjqRYV2WLhGt7WfeiAkkvBR60vdWU1pJe1O2xhPKv0xfTOuneY/v0Lsb2A+BPh0m699ue1qJZR0g6E3gnxXo+jf9u84CrbP9NF2O7HviY7R+0qLvH9owuhLWVJI5xUs7ueyowly1/AV4DXGT7110KLZ7DejzpbrQ92KKuF5Luy2n973ZH96IqHuUHnrD9eDfjGE0SxziRdAXFoORlPHMbPJVijGMP28d1KbTGpPZ24HfK4p5PapIW254/+pmd18uxRdQtiWOcSPpP2y9pt64TejypDfdkkoAf257ayXi2CKCHYwOQ9HzgTIq/nF9E8fDDzyn+IDjX9sM9ENtc4IW9FNtIJF1n+8hux9FKL8WWwfHxs1HSscDXbD8NIGk7ivc4HupqZHBQi8S1HrhR0n92I6AGg8C9FL+Mh7g8fmFXInpGL8cGcBVwPfB62z8DkPTbwCll3RHdC21zbK9riu3kbscm6dXDVQGzOhjK1gH0cGyNcscxTsq3w88DXk/x1z0Uj899D1hg+56uBAZIuhH4e1ontQ/Zbrlue4diuwt44zAD990eRO3Z2MoY1th+abt1ndDjsf0G+D5b/kEw5FDbO3c4pM16ObZGueMYJ7bXSforinc2thgc72bSKM2jSGqLJD1clr2AIqnN61JMQz4L7A5s9csZ+NvOhrKVz9K7sQHcK+kvgcuGBpvLt8hP4Zmnhbqll2O7k+L9l7uaKyQltgpyxzFOJH2E4pfwErZ8G3UesMT2ud2KDYZ9iuQa23d2L6qCpJfR+gmXxDYCSbsDCyjiG+o6+y+Kd4fOtd21LtIej+0YYJXtNS3q5tr+Zuej2vz5PRtboySOcVKOFRzQ/IRSuTb66i5POdKzSa38q/SEMrbGgfvEtg0kvcf2Jd2Oo5XENja9FFsSxziR9BPgzbbvbSrfF/h2l/t0ezmpJbYa9NK8Rs0S29j0UmwZ4xg/ZwDfLQdUh/oi96GYOK1rb/CWnqZ4f+PepvK9y7puSmxjJOm24aooHs/tmsQ2Nr0cW6MkjnFi+1uSXsLWUzWvGJpmvYvOoHeT2hkktrF6EfBmtn7cW8BWU1Z0WGIbm16ObbMkjnFUPup6Y7fjaNbLSS2xbZN/BXaxvbK5QtINHY9mS4ltbHo5ts0yxhEREW3p9vTGERHxLJPEERERbUniiGgiaaqkayTdJWmtpM9JmlyhXct1tCUtHFowS9IZkn5rmPPeKulWST+WdIek95flcyXtX+HzK50Xsa2SOCIaSBLwdYqV/2YCM4Gd2YYpRmyfZfvfysMzgK0Sh6QdgMXA28p11l8F3FBWzwWqJISq50VskwyORzSQ9EbgbNuHNZTtRvEuxzTgGGD20Op6kv6VYlneG8o7ji9SzPz6M2Ce7UFJl1I8LfM7wN8Ba4Bf2H59w2fsAfwE2Nf2fzeU/37Z9pFyewfwBmA+sCMwALybYubU5vMAFgF9wOPA+2z/ZFz+oWJCyx1HxJYOALZY7tT2o8A6ivc3RvI8oN/2ARQznJ7ddJ3zgZ9STIP++qa6jRTzON0r6QpJJ0rarlxCdCnwYduzbN8NfN32weWdyZ3AqcOct5hi+daDgL8ALmj7XyOihbzHETF+ngauLPf/maLLqzLb75V0IPAmil/0h1PMJtvsFZLOoZjheBdgefMJknYBfh/4atH7BsCo4zQRVSRxRGzpDoruqM3KrqrfpuhiegVb3qnvNMK12u4Htr0KWCXpS8A9tE4clwJzbf9Y0inA61qcsx3wsO1Z7cYQMZp0VUVs6bvAb0k6CUDSJIpFsD5Xjj2sA2ZJ2k7SNIq3yodsxzNJ5wTg31tc/zFg1+ZCSbtIel1D0SyemSOruc2uwAPlgPqJra5ddq/dU65KiQqvHOmLR1SVxBHRwMXTIm8HjinnqHoQeNr2X5en/AfFncAdwPnALQ3NfwUcIul2igHshS0+YjHwLUnfayoX8JeS1khaCXyCZ+42lgAfLh/VfTHwceCmMpbGwe7m804ETpX0Y2A1xdoYEdssT1VFjKB8qukK4O22bxnt/IiJIIkjIiLakq6qiIhoSxJHRES0JYkjIiLaksQRERFtSeKIiIi2JHFERERb/j8hucHmoOf2AwAAAABJRU5ErkJggg==\n",
"text/plain": [
"[回到 目录]
\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 量桨的运行模式说明" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 波函数向量模式 \n", "\n", "所谓的波函数模式也就是用复数向量表示和储存量子态。向量模式只能处理纯态，但这种模式在家用电脑硬件高效支持**20+量子比特**的运算。用户可以测试下自己电脑的极限在哪里。在这种表示下，量子门 (酉矩阵)作用在量子比特 (一个复向量)上本质上的运算是**矩阵乘以向量**：\n", "\n", "$$\\lvert {\\psi}\\rangle = U \\lvert {\\psi_0}\\rangle$$\n", "\n", "代码中，具体体现在 UAnsatz的调用 `cir.run_state_vector(input_state = None)`。如果我们不输入任何初始量子态，就会默认所有的量子比特都处于$\\lvert {0}\\rangle$态。接着来看个具体的例子：" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[ 0.00042441+0.j 0.00029816+0.j 0.00019942+0.j ... 0.00039183+0.j\n", " -0.00052556+0.j 0.00061023+0.j]]\n" ] } ], "source": [ "from paddle_quantum.state import vec, vec_random\n", "\n", "N = 20 # 设置量子比特数\n", "DEPTH = 6 # 设置量子电路深度\n", "theta = np.random.randn(DEPTH, N, 1)\n", "\n", "# 调用内置的 |00..0> 初始态\n", "initial_state1 = vec(N)\n", "# 调用内置的随机量子态 |psi>\n", "initial_state2 = vec_random(N)\n", "\n", "# 启动 Paddle 动态图模式\n", "with fluid.dygraph.guard():\n", " \n", " # 我们需要将 Numpy array 转换成 Paddle 动态图模式中支持的 variable\n", " theta = fluid.dygraph.to_variable(theta)\n", " initial_state = fluid.dygraph.to_variable(initial_state1)\n", " \n", " # 初始化量子电路\n", " cir = UAnsatz(N)\n", " \n", " # 添加深度为 Depth 的实数强纠缠结构QNN {Ry+CNOT's}\n", " cir.real_entangled_layer(theta, DEPTH)\n", " \n", " # 制备输出态\n", " # 如果用户不输入初始量子态，默认初始为|00..0>\n", " final_state = cir.run_state_vector(initial_state)\n", " print(final_state.numpy())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 密度矩阵模式 \n", "\n", "同时 Paddle quantum也支持了密度矩阵运算模式，也就是用一个密度矩阵 $\\rho = \\sum_i P_i \\lvert {\\psi_i}\\rangle\\langle{\\psi_i} \\lvert$表示和储存量子态。该模式下可以根据算法需要支持**混合态模拟**。但是在密度矩阵模式下，家用电脑硬件只能运行10个左右的量子比特。请用户注意这方面的限制，我们也在不断优化这个模式下的模拟器性能。在这种表示下，量子门 (酉矩阵)作用在量子态(一个迹为1的厄尔米特矩阵)上本质上的运算是**矩阵乘法**：\n", "\n", "$$\\rho = U \\rho_0 U^\\dagger$$\n", "\n", "代码中，具体体现在 UAnsatz的调用 `cir.run_density_matrix()`。接着来看个具体的例子：" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[ 0.11259972+0.j -0.28258005+0.j 0.03785432+0.j -0.13651589+0.j]\n", " [-0.28258005+0.j 0.70916239+0.j -0.09499913+0.j 0.34260002+0.j]\n", " [ 0.03785432+0.j -0.09499913+0.j 0.01272605+0.j -0.04589457+0.j]\n", " [-0.13651589+0.j 0.34260002+0.j -0.04589457+0.j 0.16551185+0.j]]\n" ] } ], "source": [ "from paddle_quantum.state import density_op, density_op_random, completely_mixed_computational\n", "\n", "N = 2 # 设置量子比特数\n", "DEPTH = 6 # 设置量子电路深度\n", "theta = np.random.randn(DEPTH, N, 1)\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", "# 调用内置的计算基下的完全混合态 \n", "initial_state3 = completely_mixed_computational(N)\n", "\n", "# 启动 Paddle 动态图模式\n", "with fluid.dygraph.guard():\n", " \n", " # 我们需要将 Numpy array 转换成 Paddle 动态图模式中支持的 variable\n", " theta = fluid.dygraph.to_variable(theta)\n", " initial_state = fluid.dygraph.to_variable(initial_state1)\n", " \n", " # 初始化量子电路\n", " cir = UAnsatz(N)\n", " \n", " # 添加深度为 Depth 的实数强纠缠结构QNN {Ry+CNOT's}\n", " cir.real_entangled_layer(theta, DEPTH)\n", " \n", " # 制备输出态\n", " # 如果用户不输入初始量子态，默认初始为|00..0><00..0|\n", " final_state = cir.run_density_matrix(initial_state)\n", " print(final_state.numpy())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "如果你对源代码有兴趣，可以利用如下 magic command即时查看。或者关注我们的 [[Github]](https://github.com/PaddlePaddle/Quantum)！" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "%psource density_op_random" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 练习：如何从计算基制备贝尔态\n", "\n", "贝尔态是一种很常用的量子纠缠态， 可以表示为\n", "\n", "$$\n", "\\lvert {\\Phi^+}\\rangle = \\frac{1}{\\sqrt{2}} \\big(\\lvert {00}\\rangle + \\lvert {11}\\rangle\\big)\n", "= \\frac{1}{\\sqrt{2}} \\,\n", "\\begin{bmatrix}\n", "1 \\\\\n", "0 \\\\\n", "0 \\\\\n", "1\n", "\\end{bmatrix}\n", "$$\n", "\n", "那么我们如何用量桨来制备一个贝尔态呢? 只需要如下的量子电路：\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
![](\"figures/bell2.png\")
"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
"[回到 目录]
\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 飞桨 Paddlepaddle 优化器使用教程" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 示例: 利用飞桨的梯度下降来优化多元函数\n", "\n", "\n", "在这一节，我们学习如何用飞桨动态图机制找到一个多元函数的极小值\n", "\n", "$$\n", "\\min_{\\boldsymbol{\\theta}}\\mathcal{L}(\\theta_1, \\theta_2, \\theta_3)\n", "= (\\theta_1)^2 + (\\theta_2)^2 + (\\theta_3)^2 + 10\n", "$$\n", "\n", "可以看出，只有当 $\\theta_1 = \\theta_2 = \\theta_3 = 0$ 的时候，$\\mathcal{L}$ 取最小值10。\n" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "损失函数的最小值是: 10.000000153748474\n" ] } ], "source": [ "# 超参数设置\n", "theta_size = 3 \n", "ITR = 200 # 设置迭代次数\n", "LR = 0.5 # 设置学习速率\n", "SEED = 1 # 固定随机数种子\n", "\n", "class Optimization_ex1(fluid.dygraph.Layer):\n", " \n", "\n", " def __init__(self, shape, param_attr=fluid.initializer.Uniform(low=-5., high=5., seed=SEED), dtype='float64'):\n", " super(Optimization_ex1, self).__init__()\n", " \n", " # 初始化一个长度为 theta_size的可学习参数列表，并用 [-5, 5] 的均匀分布来填充初始值\n", " self.theta = self.create_parameter(shape=shape, attr=param_attr, dtype=dtype, is_bias=False)\n", "\n", " # 定义损失函数和前向传播机制\n", " def forward(self):\n", " loss = self.theta[0] ** 2 + self.theta[1] ** 2 + self.theta[2] ** 2 + 10\n", " return loss\n", " \n", "# 记录中间优化结果\n", "loss_list = []\n", "parameter_list = []\n", "\n", "# 初始化 paddle 动态图机制\n", "with fluid.dygraph.guard():\n", " \n", " # 定义网络维度\n", " myLayer = Optimization_ex1([theta_size])\n", " \n", " # 一般来说，我们利用Adam优化器来获得相对好的收敛，当然你可以改成SGD或者是RMSprop.\n", " optimizer = fluid.optimizer.AdagradOptimizer(learning_rate = LR, parameter_list = myLayer.parameters()) \n", " \n", " # 优化循环\n", " for itr in range(ITR):\n", " \n", " # 向前传播计算损失函数\n", " loss = myLayer()[0]\n", " \n", " # 在动态图机制下，反向传播优化损失函数\n", " loss.backward()\n", " optimizer.minimize(loss)\n", " myLayer.clear_gradients()\n", " \n", " # 记录学习曲线\n", " loss_list.append(loss.numpy()[0])\n", " parameter_list.append(myLayer.parameters()[0].numpy())\n", " \n", " print('损失函数的最小值是: ', loss_list[-1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "\n", "### 练习: 特征值寻找\n", "\n", "接下来，我们试一个更复杂的损失函数。 首先我们介绍一个随机的埃尔米特矩阵 $H$ 其**特征值**为矩阵 $D$ 的对角元素。 \n", "\n", "$$ D = \\begin{bmatrix} 0.2 &0 \\\\ 0 &0.8 \\end{bmatrix} $$\n", "\n", "不用担心，我们会帮你生成这个埃尔米特矩阵$H$. \n", "\n", "然后我们初始化参数向量$\\boldsymbol{\\theta}$，构造出一个简单的线性运算 $U(\\boldsymbol{\\theta}) = R_z(\\theta_1)*R_y(\\theta_2)*R_z(\\theta_3)$\n", "\n", "\n", "$$ \n", "U(\\theta_1, \\theta_2, \\theta_3) = \n", "\\begin{bmatrix}\n", "e^{-i\\frac{\\theta_1}{2}} & 0 \\\\ \n", "0 & e^{i\\frac{\\theta_1}{2}}\n", "\\end{bmatrix}\n", "\\begin{bmatrix}\n", "\\cos \\frac{\\theta_2}{2} &-\\sin \\frac{\\theta_2}{2} \\\\ \n", "\\sin \\frac{\\theta_2}{2} &\\cos \\frac{\\theta_2}{2} \n", "\\end{bmatrix}\n", "\\begin{bmatrix}\n", "e^{-i\\frac{\\theta_3}{2}} & 0 \\\\ \n", "0 & e^{i\\frac{\\theta_3}{2}}\n", "\\end{bmatrix}\n", "$$\n", "\n", "我们让这个矩阵（模板）乘以 $\\lvert {0}\\rangle$，得到一个新的2维复向量$\\lvert {\\phi}\\rangle$\n", "\n", "\n", "$$ \n", "\\lvert {\\phi}\\rangle = U(\\theta_1, \\theta_2, \\theta_3)\\lvert {0}\\rangle\n", "$$\n", "\n", "然后，我们定义损失函数为：\n", "\n", "$$\n", "\\min_{\\boldsymbol{\\theta}}\\mathcal{L}(\\theta_1, \\theta_2, \\theta_3) \n", "= \\langle{\\phi} \\lvert H \\lvert {\\phi}\\rangle \n", "= \\langle{0} \\lvert U^{\\dagger}H U \\lvert {0}\\rangle\n", "$$\n", "\n", "来看看优化后我们得到了什么！" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "随机生成的矩阵 H 是:\n", "[[ 0.73879472-2.77555756e-17j -0.12692858+1.29870005e-01j]\n", " [-0.12692858-1.29870005e-01j 0.26120528+0.00000000e+00j]] \n", "\n", "不出所料，H 的特征值是:\n", "[0.2 0.8]\n" ] } ], "source": [ "from scipy.stats import unitary_group\n", "\n", "# V 是一个 2x2 的随机酉矩阵\n", "V = unitary_group.rvs(2)\n", "\n", "# D 的对角元是H的特征值\n", "# 你可以任意改变这里的对角元数值\n", "D = np.diag([0.2, 0.8])\n", "\n", "# V_dagger 是 V 的埃尔米特转置\n", "V_dagger = V.conj().T\n", "\n", "# @：代表矩阵乘积运算\n", "H = (V @ D @ V_dagger)\n", "print('随机生成的矩阵 H 是:')\n", "print(H, '\\n')\n", "print('不出所料，H 的特征值是:')\n", "print(np.linalg.eigh(H)[0])" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# 超参数设置\n", "theta_size = 3 # 设置 theta 维度\n", "num_qubits = 1 # 设置量子比特数\n", "ITR = 10 # 设置迭代次数\n", "LR = 0.8 # 设置学习速率\n", "SEED = 1 # 固定theta参数的随机数种子\n", "\n", "\n", "# 单独设置电路模块\n", "def U_theta(theta):\n", " \n", " # 初始化电路然后添加量子门\n", " cir = UAnsatz(num_qubits)\n", " cir.rz(theta[0], 0)\n", " cir.ry(theta[1], 0)\n", " cir.rz(theta[2], 0)\n", " \n", " # 返回参数化矩阵\n", " return cir.U" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "class Optimization_ex2(fluid.dygraph.Layer):\n", " \n", "\n", " def __init__(self, shape, param_attr=fluid.initializer.Uniform(low=0., high=2*np.pi, seed=SEED), dtype='float64'):\n", " super(Optimization_ex2, self).__init__()\n", " \n", " # 初始化一个长度为 theta_size的可学习参数列表，并用 [0, 2*pi] 的均匀分布来填充初始值\n", " self.theta = self.create_parameter(shape=shape, attr=param_attr, dtype=dtype, is_bias=False)\n", " self.H = fluid.dygraph.to_variable(H)\n", " \n", " # 定义损失函数和前向传播机制\n", " def forward(self):\n", " \n", " # 获取量子神经网络的酉矩阵表示\n", " U = U_theta(self.theta)\n", " \n", " # 埃尔米特转置运算\n", " U_dagger = hermitian(U)\n", " \n", " # 计算损失函数函数\n", " loss = matmul(U_dagger, matmul(self.H, U)).real[0][0]\n", " \n", " return loss" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "iter: 0 loss: 0.7911\n", "iter: 1 loss: 0.5878\n", "iter: 2 loss: 0.2913\n", "iter: 3 loss: 0.2244\n", "iter: 4 loss: 0.2142\n", "iter: 5 loss: 0.2071\n", "iter: 6 loss: 0.2031\n", "iter: 7 loss: 0.2013\n", "iter: 8 loss: 0.2005\n", "iter: 9 loss: 0.2002\n", "损失函数的最小值是: 0.20019311438922205\n" ] } ], "source": [ "loss_list = []\n", "parameter_list = []\n", "\n", "\n", "# 初始化paddle动态图机制\n", "with fluid.dygraph.guard():\n", " \n", " myLayer = Optimization_ex2([theta_size])\n", " \n", " # 一般来说，我们利用Adam优化器来获得相对好的收敛，当然你可以改成SGD或者是RMS prop.\n", " optimizer = fluid.optimizer.AdagradOptimizer(learning_rate = LR, parameter_list = myLayer.parameters()) \n", " \n", " # 优化循环\n", " for itr in range(ITR):\n", " \n", " # 前向传播计算损失函数\n", " loss = myLayer()[0]\n", " \n", " # 在动态图机制下，反向传播极小化损失函数\n", " loss.backward()\n", " optimizer.minimize(loss)\n", " myLayer.clear_gradients()\n", " \n", " # 记录学习曲线\n", " loss_list.append(loss.numpy()[0])\n", " parameter_list.append(myLayer.parameters()[0].numpy())\n", " print('iter:', itr, ' loss: %.4f' % loss.numpy())\n", " \n", " print('损失函数的最小值是: ', loss_list[-1])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "我们可以改变一下$H$的特征值。如果将它对角化后的的对角矩阵改变为\n", "\n", "$$ D = \\begin{bmatrix} 0.8 &0 \\\\ 0 &1.2 \\end{bmatrix} $$\n", "\n", "你会发现我们仍然得到了$H$的最小特征值0.8, 你能找到背后的原因吗？还是说这背后隐藏着什么理论？\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
[回到 目录]
\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 量子机器学习案例" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 变分量子特征求解器 (VQE) -- 无监督学习\n", "\n", "正如大名鼎鼎的John Preskill 所言，目前阶段理想的可容错的量子计算机还是遥遥无期。我们目前只能造出有噪音的，中等规模量子计算系统（NISQ）。现在一个利用 NISQ 的量子设备很有希望的算法种类就是量子-经典混合算法。人们期望这套方法也许可以在某些应用中超越经典计算机的表现。变分量子特征求解器（VQE）就是里面的一个杰出代表。它利用参数化的电路搜寻广阔的希尔伯特空间，并利用经典机器学习中的梯度下降来找到最优参数，并接近一个哈密顿量的基态（也就是找到一个埃尔米特矩阵的最小特征值）。这个电路其实你之前见过。为了确保你能理解, 我们来一起过一遍以下两量子比特 (2-qubit)的例子。\n", "\n", "假设我们想找到如下哈密顿量的基态：\n", "\n", "$$ H = 0.4 \\, Z \\otimes I + 0.4 \\, I \\otimes Z + 0.2 \\, X \\otimes X$$\n", "\n", "给定一种常见的量子神经网络架构" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
![](\"figures/vqeAnsatz.png\")
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"我们已经学会如何建造这个电路了。如果你忘了, 请转到 这里。 有关VQE的更多信息, 请参见 [[博客]](https://www.mustythoughts.com/post/variational-quantum-eigensolver-explained)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [],
"source": [
"from paddle_quantum.utils import pauli_str_to_matrix\n",
"\n",
"# 首先生成泡利字符串表示下的哈密顿量\n",
"# 相当于0.4*kron(I, Z) + 0.4*kron(Z, I) + 0.2*kron(X, X)\n",
"# 其中， X，Y, Z是泡利矩阵， I是单位矩阵\n",
"H_info = [[0.4, 'z0'], [0.4, 'z1'], [0.2, 'x0,x1']]\n",
"\n",
"# 超参数设置\n",
"num_qubits = 2\n",
"theta_size = 4\n",
"ITR = 10\n",
"LR = 0.5\n",
"SEED = 1 \n",
"\n",
"# 把记录的关于哈密顿量的信息转化为矩阵表示\n",
"H_matrix = pauli_str_to_matrix(H_info, num_qubits)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [],
"source": [
"class vqe_demo(fluid.dygraph.Layer):\n",
" \n",
"\n",
" def __init__(self, shape, param_attr=fluid.initializer.Uniform(low=0., high=2*np.pi, seed=SEED), dtype='float64'):\n",
" super(vqe_demo, self).__init__()\n",
" \n",
" # 初始化一个长度为theta_size的可学习参数列表，并用[0, 2*pi]的均匀分布来填充初始值\n",
" self.theta = self.create_parameter(shape=shape, attr=param_attr, dtype=dtype, is_bias=False)\n",
" self.H = fluid.dygraph.to_variable(H)\n",
" \n",
" # 定义损失函数和前向传播机制\n",
" def forward(self):\n",
" \n",
" # 初始量子电路\n",
" cir = UAnsatz(num_qubits)\n",
" \n",
" # 添加量子门\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",
" \n",
" # 选择用量子态的向量表示\n",
" cir.run_state_vector()\n",
" \n",
" # 计算当前量子态下关于观测量H_info的期望值\n",
" # 也就是 [回到 目录]
\n", "\n", "" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 参考文献\n", "\n", "[1] [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", "[2] [McClean, J. R., Romero, J., Babbush, R. & Aspuru-Guzik, A. The theory of variational hybrid quantum-classical algorithms. New J. Phys. 18, 023023 (2016).](https://iopscience.iop.org/article/10.1088/1367-2630/18/2/023023)\n", "\n", "[3] [Kandala, A. et al. Hardware-efficient variational quantum eigensolver for small molecules and quantum magnets. Nature 549, 242–246 (2017).](https://www.nature.com/articles/nature23879)\n", "\n", "[4] [Mitarai, K., Negoro, M., Kitagawa, M. & Fujii, K. Quantum circuit learning. Phys. Rev. A 98, 032309 (2018).](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.98.032309)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
[回到 目录]
\n", "\n", "" ] } ], "metadata": { "colab": { "name": "QSD-Paddle.ipynb", "provenance": [] }, "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.9" } }, "nbformat": 4, "nbformat_minor": 1 }