{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 利用量桨训练参数化量子电路\n",
    "\n",
    "_Copyright (c) 2023 Institute for Quantum Computing, Baidu Inc. All Rights Reserved._"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "变分量子算法（Variational Quantum Algorithms, VQA）是指通过用一个经典优化器来训练一个含参量子电路（Parameterized Quantum Circuit, PQC）来求解特定问题的算法。它可以看作是机器学习在量子计算中的自然类比。因此含参量子线路一般也被称作量子神经网络（Quantum Neural Network, QNN）。\n",
    "\n",
    "量桨提供了完善易用的工具集来实现对含参量子电路的训练。这里我们以量子态制备为例，介绍如何利用量桨便捷地构建参数化量子电路，设定参数，并通过经典优化器来训练参数化量子电路。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 快速构建量子神经网络"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "利用量桨中的 Circuit 类，我们可以通过复合各种量子门来构建一个量子神经网络。下面我们来看一个具体的例子。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 首先导入所需的程序包\n",
    "import numpy as np\n",
    "import paddle\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "from paddle_quantum.state import ghz_state\n",
    "from paddle_quantum.loss import StateFidelity\n",
    "import matplotlib.pyplot as plt\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(1.835)----Rx(5.255)----*--------------x--\n",
      "                            |              |  \n",
      "--Ry(4.561)----Rx(2.712)----x----*---------|--\n",
      "                                 |         |  \n",
      "--Ry(3.485)----Rx(1.283)---------x----*----|--\n",
      "                                      |    |  \n",
      "--Ry(0.988)----Rx(4.441)--------------x----*--\n",
      "                                              \n"
     ]
    }
   ],
   "source": [
    "# 创建一个空的量子电路，量子比特数为 4\n",
    "cir_1 = Circuit(4)\n",
    "\n",
    "# 添加一层 Ry 门、一层 Rx 门和一层 CNOT 门\n",
    "cir_1.ry()    # 默认参数：qubits_idx='full'，意为在所有量子比特上都添加这样一个单比特量子门。参数默认是随机初始化的\n",
    "cir_1.rx()\n",
    "cir_1.cnot()  # 默认参数：qubits_idx='cycle'，意为在所有两两近邻的量子比特对上都添加这样一个双比特量子门\n",
    "\n",
    "# 输出量子电路图示\n",
    "print(cir_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在上面这个例子中，量子门默认是以逐层的方式添加到所有量子比特上的，这是量子神经网络常见的构造方式。仿照经典神经网络，每一层量子门可称为一个训练层。如果我们想指定某个量子门作用的量子比特，只需更改 qubits_idx 参数即可。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(2.957)----*-------\n",
      "               |       \n",
      "--Rx(2.106)----x----x--\n",
      "                    |  \n",
      "--Ry(0.354)---------*--\n",
      "                       \n"
     ]
    }
   ],
   "source": [
    "# 创建一个空的量子电路\n",
    "cir_2 = Circuit(3)\n",
    "\n",
    "# 按特定方式添加量子门\n",
    "cir_2.ry(qubits_idx='even')           # 在编号为偶数的量子比特上都添加这样一个单比特量子门\n",
    "cir_2.rx(qubits_idx=1)                # 通过指定量子比特编号的方式添加量子门\n",
    "cir_2.cnot(qubits_idx=[[0,1],[2,1]])  # 通过指定量子比特编号的方式添加量子门，其中前者为控制位，后者为受控位\n",
    "\n",
    "# 输出量子电路图示\n",
    "print(cir_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "量桨还内置了一些常见训练层的模板，方便使用者更快速地构建量子神经网络。其他模板可参见[量桨 API](https://qml.baidu.com/api/paddle_quantum.ansatz.circuit.html)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(4.225)----*--------------x----Ry(2.909)----*--------------x----U----*--------------x--\n",
      "               |              |                 |              |         |              |  \n",
      "--Ry(4.139)----x----*---------|----Ry(5.014)----x----*---------|----U----x----*---------|--\n",
      "                    |         |                      |         |              |         |  \n",
      "--Ry(5.998)---------x----*----|----Ry(0.292)---------x----*----|----U---------x----*----|--\n",
      "                         |    |                           |    |                   |    |  \n",
      "--Ry(1.065)--------------x----*----Ry(4.375)--------------x----*----U--------------x----*--\n",
      "                                                                                           \n"
     ]
    }
   ],
   "source": [
    "# 创建一个空的量子电路\n",
    "cir_3 = Circuit(4)\n",
    "\n",
    "# 添加两层内置模板 real_entangled_layer：每层包括一层 Ry 门，一层 CNOT 门\n",
    "cir_3.real_entangled_layer(depth=2)\n",
    "# 添加一层内置模板 complex_entangled_layer：每层包括一层 U3 门（Rz*Ry*Rz），一层 CNOT 门\n",
    "cir_3.complex_entangled_layer(depth=1)\n",
    "\n",
    "# 输出量子电路\n",
    "print(cir_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 设定量子神经网络中的参数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在以上的例子中，量子神经网络中的参数都是默认随机初始化的。我们可以通过访问 param 属性来获取电路中现存的参数数值并保存到一个数组里。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(5.308)--\n",
      "             \n",
      "--Ry(0.278)--\n",
      "             \n",
      "Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=False,\n",
      "       [5.30772972, 0.27760327])\n"
     ]
    }
   ],
   "source": [
    "# 创建一个空的量子电路\n",
    "cir_4 = Circuit(2)\n",
    "# 添加一层 Ry 门\n",
    "cir_4.ry()\n",
    "# 输出量子电路\n",
    "print(cir_4)\n",
    "# 输出量子电路内可训练参数的取值\n",
    "print(cir_4.param)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "此外，我们可以通过执行 update_param() 方法来手动设定一组参数的值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(0.100)--\n",
      "             \n",
      "--Ry(0.200)--\n",
      "             \n",
      "Tensor(shape=[2], dtype=float32, place=Place(cpu), stop_gradient=False,\n",
      "       [0.10000000, 0.20000000])\n"
     ]
    }
   ],
   "source": [
    "# 创建新的参数数组\n",
    "theta_new = paddle.to_tensor([0.1, 0.2], dtype='float32')\n",
    "# 更新电路中的参数\n",
    "cir_4.update_param(theta_new)\n",
    "# 输出量子电路图示\n",
    "print(cir_4)\n",
    "# 输出量子电路内可训练参数的取值\n",
    "print(cir_4.param)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 用经典优化器训练量子神经网络"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "完成量子神经网络的构建后，我们就可以根据需要定义一个损失函数，并调用经典优化器来训练这个量子神经网络了。这里我们用量子神经网络去学习一个 GHZ 态，损失函数采用保真度距离。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 0,   loss: 0.1734\n",
      "iter: 5,   loss: 0.1296\n",
      "iter: 10,   loss: 0.0896\n",
      "iter: 15,   loss: 0.0548\n",
      "iter: 20,   loss: 0.0264\n",
      "iter: 25,   loss: 0.0087\n",
      "iter: 30,   loss: 0.0084\n",
      "iter: 35,   loss: 0.0094\n",
      "iter: 40,   loss: 0.0064\n",
      "iter: 45,   loss: 0.0008\n",
      "iter: 50,   loss: 0.0035\n",
      "iter: 55,   loss: 0.0006\n",
      "iter: 60,   loss: 0.0016\n",
      "iter: 65,   loss: 0.0006\n",
      "iter: 70,   loss: 0.0004\n",
      "iter: 75,   loss: 0.0001\n",
      "iter: 80,   loss: 0.0001\n",
      "iter: 85,   loss: 0.0004\n",
      "iter: 90,   loss: 0.0002\n",
      "iter: 95,   loss: 0.0003\n"
     ]
    }
   ],
   "source": [
    "# 定义训练的超参数\n",
    "ITR = 100    # 训练迭代次数\n",
    "LR = 0.02    # 学习率\n",
    "\n",
    "# 定义电路\n",
    "cir = Circuit(4)\n",
    "cir.ry()\n",
    "cir.rx()\n",
    "cir.cnot()\n",
    "\n",
    "# 定义损失函数的形式，这里选用了量子电路的输出态和 GHZ 态的保真度\n",
    "loss_func = StateFidelity(ghz_state(4))\n",
    "# 选择经典优化器，通常选用 Adam 优化器\n",
    "opt = paddle.optimizer.Adam(learning_rate=LR, parameters=cir.parameters())\n",
    "# 创建一个列表记录训练过程\n",
    "loss_list = []\n",
    "# 开始迭代优化\n",
    "for itr in range(ITR):\n",
    "    # 运行电路，得到输出态，计算损失函数的值\n",
    "    loss = loss_func(cir())\n",
    "    # 反向传播，计算梯度\n",
    "    loss.backward()\n",
    "    # 最小化损失函数，更新参数\n",
    "    opt.minimize(loss)\n",
    "    opt.clear_grad()\n",
    "    # 记录损失函数的值\n",
    "    loss_list.append(loss.numpy().item())\n",
    "    if itr % 5 == 0:\n",
    "        print(f'iter: {itr},   loss: {loss.numpy().item():.4f}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(1.177)----Rx(3.797)----*--------------x--\n",
      "                            |              |  \n",
      "--Ry(2.529)----Rx(5.456)----x----*---------|--\n",
      "                                 |         |  \n",
      "--Ry(0.002)----Rx(3.140)---------x----*----|--\n",
      "                                      |    |  \n",
      "--Ry(0.221)----Rx(3.953)--------------x----*--\n",
      "                                              \n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 输出训练结束后的参数化量子线路\n",
    "print(cir)\n",
    "\n",
    "# 绘制损失函数随迭代次数的变化曲线\n",
    "func = plt.plot(loss_list)\n",
    "plt.xlabel('Iterations')\n",
    "plt.ylabel('Loss')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "我们可以发现随着训练的进行保真度距离收敛于零附近，这意味着参数化量子电路的输出态已经非常接近目标态，说明我们成功训练出了一个可以制备目标态的量子电路。"
   ]
  }
 ],
 "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.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}