tutorials/qnn_research/Expressibility_CN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "9479f1e0",
   "metadata": {},
   "source": [
    "# 量子神经网络的表达能力\n",
    "\n",
    "<em>Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved.</em>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c352b2aa",
   "metadata": {},
   "source": [
    "## 概览"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a195bcc",
   "metadata": {},
   "source": [
    "在量子机器学习中，量子神经网络的**表达能力**是决定量子机器学习任务能否成功的关键因素。一般来说，量子神经网络拟设的表达能力越强，量子机器学习能够搜索到全局最优解的可能性就越大。本教程首先介绍量子神经网络表达能力的基本概念，随后将在量桨中展示如何通过布洛赫球感受不同拟设表达能力的差别。最后介绍一种定量分析量子神经网络表达能力的方法，并评估量桨提供的量子神经网络模板在不同深度下的表达能力。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0f4583d7",
   "metadata": {},
   "source": [
    "## 基本概念"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c03d7dcf",
   "metadata": {},
   "source": [
    "我们先来回顾一下量子机器学习算法的基本流程。在量子机器学习中，我们往往设计一个损失函数 $\\mathcal{L}$，并通过优化一个酉变换 $U$ 使得损失函数最小化：\n",
    "\n",
    "$$\n",
    "\\min_U\\mathcal{L}(U)=\\min_U \\text{tr}[HU\\rho_{in}U^\\dagger],\\tag{1}\n",
    "$$\n",
    "\n",
    "算法背后的数学原理保证当我们遍历完所有可能的酉变换后，损失函数能取到的最小值就对应于我们问题的解。而在实际操作中，我们采用量子神经网络将酉变换参数化：\n",
    "\n",
    "$$\n",
    "U=U(\\vec{\\theta})=U_D(\\vec{\\theta}_D)\\dots U_1(\\vec{\\theta}_1),\\tag{2}\n",
    "$$\n",
    "\n",
    "其中每个 $U_j(\\vec{\\theta}_j),j\\in[1,D]$ 代表一层量子神经网络，$\\vec{\\theta}_j$ 代表该层对应的参数。此时，通过调整量子神经网络中的参数 $\\vec{\\theta}$，我们就可以进行对酉变换 $U$ 的优化，进而最小化损失函数 $\\mathcal{L}$：\n",
    "\n",
    "$$\n",
    "\\min_{\\vec{\\theta}}\\mathcal{L}(\\vec{\\theta})=\\min_{\\vec{\\theta}} \\text{tr}[HU(\\vec{\\theta})\\rho_{in}U(\\vec{\\theta})^\\dagger].\\tag{3}\n",
    "$$\n",
    "\n",
    "然而，细心的读者此时可能已经发现了量子神经网络的一个不足：对于一个给定的神经网络拟设，**遍历所有的参数并不一定可以保证遍历所有的酉变换**。作为一个简单的例子，如果我们只允许使用一个 $R_Y$ 旋转门作为单比特量子神经网络 $U(\\theta)=R_Y(\\theta)$，显然（除去全局相位）$U(\\theta)$ 不能表示任何矩阵元含虚部的复酉矩阵。而当允许使用 $R_Y$ 和 $R_Z$ 旋转门时，如果我们搭建量子神经网络为 $U(\\vec{\\theta})=R_Z(\\theta_1)R_Y(\\theta_2)R_Z(\\theta_3)$，$U(\\vec{\\theta})$ （除去全局相位）将能够表示所有的单比特酉矩阵 [1]。\n",
    "\n",
    "如果我们将神经网络的表达能力定义为**在遍历电路参数 $\\vec{\\theta}$ 时电路能够表达的酉变换的多少**，那么，一个表达能力强的量子神经网络将更有可能包含那些使得损失函数 $\\mathcal{L}$ 取到全局最小值的酉变换；相反地，如果一个量子神经网络 $U_{weak}$ 的表达能力太弱以至于不包含任何能将损失函数最小化的酉变换，那么基于优化 $U_{weak}$ 的量子机器学习任务就很可能会失败。\n",
    "\n",
    "接下来我们基于量桨，通过观察单量子比特酉门遍历布洛赫球的能力直观地感受量子神经网络的表达能力。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3412d8c6",
   "metadata": {},
   "source": [
    "## 直观感受表达能力：遍历布洛赫球"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bd49ecf",
   "metadata": {},
   "source": [
    "对于单量子比特的简单情况，我们可以直接观察量子神经网络如何将固定输入遍历布洛赫球表面。对于一个给定的神经网络拟设 $U(\\vec{\\theta})$，由于网络的输入往往是固定的（不妨设为 $|0\\rangle$），通过均匀地采样神经网络参数 $\\vec{\\theta}$，神经网络的输出态 $U(\\vec{\\theta})|0\\rangle$ 将散落在布洛赫球表面。显然，如果输出态在球面分布地越广越均匀，那么神经网络拟设 $U$ 的表达能力也就越强，包含损失函数全局最优的可能性也就越大。\n",
    "\n",
    "为在量桨实现这一功能，首先引入必要的包："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e05a5803",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zl/miniconda3/envs/pq/lib/python3.8/site-packages/openfermion/hamiltonians/hartree_fock.py:11: DeprecationWarning: Please use `OptimizeResult` from the `scipy.optimize` namespace, the `scipy.optimize.optimize` namespace is deprecated.\n",
      "  from scipy.optimize.optimize import OptimizeResult\n",
      "/home/zl/miniconda3/envs/pq/lib/python3.8/site-packages/paddle/tensor/creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n",
      "/home/zl/miniconda3/envs/pq/lib/python3.8/site-packages/paddle/tensor/creation.py:125: DeprecationWarning: `np.object` is a deprecated alias for the builtin `object`. To silence this warning, use `object` by itself. Doing this will not modify any behavior and is safe. \n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  if data.dtype == np.object:\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import paddle\n",
    "import paddle_quantum as pq\n",
    "from paddle_quantum.ansatz.circuit import Circuit\n",
    "from paddle_quantum.visual import plot_state_in_bloch_sphere"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14f70b6b",
   "metadata": {},
   "source": [
    "首先，我们只允许使用一个 $R_Y$ 旋转门作为单比特量子神经网络 $U(\\theta)=R_Y(\\theta)$。通过在 $[0,2\\pi]$ 均匀采样参数 $\\theta$ 并将 $U(\\theta)$ 作用在固定输入 $|0\\rangle$ 上，我们便得到量子神经网络 $U(\\theta)$ 的输出分布。通过量桨内置的 plot_bloch_sphere_from_input 函数，我们可以直接观察 $U(\\theta)|0\\rangle$ 在布洛赫球面上的分布："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "04344561",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/zl/miniconda3/envs/pq/lib/python3.8/site-packages/paddle/fluid/framework.py:1104: DeprecationWarning: `np.bool` is a deprecated alias for the builtin `bool`. To silence this warning, use `bool` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.bool_` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  elif dtype == np.bool:\n"
     ]
    }
   ],
   "source": [
    "num_qubit = 1      # 设定量子比特数\n",
    "num_sample = 2000  # 设定采样次数\n",
    "outputs_y = list()   # 储存采样电路输出\n",
    "\n",
    "for _ in range(num_sample):\n",
    "    # 初始化量子神经网络\n",
    "    pq.set_backend('density_matrix')\n",
    "    cir = Circuit(num_qubit)\n",
    "    # 作用 Ry 旋转门，旋转角度随机\n",
    "    cir.ry(0)\n",
    "    # 输出态的密度矩阵\n",
    "    rho = cir(pq.state.zero_state(num_qubit))\n",
    "    outputs_y.append(rho)\n",
    "    \n",
    "# 量桨内置的 plot_bloch_sphere_from_input 函数\n",
    "# plot_state_in_bloch_sphere(outputs_y, save_gif=True, filename='figures/bloch_y.gif')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "97e80f54",
   "metadata": {},
   "source": [
    "![bloch_y.gif](./figures/expressibility-fig-bloch_y.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7198779e",
   "metadata": {},
   "source": [
    "可见，量子神经网络 $U(\\theta)=R_Y(\\theta)$ 的输出只能分布于布洛赫球面上的一个圆环（尽管在圆环上的分布是均匀的）。类似地，我们考虑包含两个参数的神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ 和 三个参数的神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 的输出分布："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "0530af37",
   "metadata": {},
   "outputs": [],
   "source": [
    "outputs_yz = list()   # 储存采样电路输出\n",
    "for _ in range(num_sample):\n",
    "    # 初始化量子神经网络\n",
    "    cir = Circuit(num_qubit)\n",
    "    # 作用 Ry 和 Rz 旋转门，旋转角度随机\n",
    "    cir.ry(0)\n",
    "    cir.rz(0)\n",
    "    # 输出态的密度矩阵\n",
    "    rho = cir(pq.state.zero_state(num_qubit))\n",
    "    outputs_yz.append(rho)\n",
    "\n",
    "# plot_state_in_bloch_sphere(outputs_yz, save_gif=True, filename='figures/bloch_yz.gif')\n",
    "\n",
    "\n",
    "outputs_yzy = list()   # 储存采样电路输出\n",
    "for _ in range(num_sample):\n",
    "    # 初始化量子神经网络\n",
    "    cir = Circuit(num_qubit)\n",
    "    # 作用 Ry,Rz,Ry 旋转门，旋转角度随机\n",
    "    cir.ry(0)\n",
    "    cir.rz(0)\n",
    "    cir.ry(0)\n",
    "    # 输出态的密度矩阵\n",
    "    rho = cir(pq.state.zero_state(num_qubit))\n",
    "    outputs_yzy.append(rho)\n",
    "    \n",
    "# plot_state_in_bloch_sphere(outputs_yzy, save_gif=True, filename='figures/bloch_yzy.gif')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8dbde635",
   "metadata": {},
   "source": [
    "![bloch_yz.gif](./figures/expressibility-fig-bloch_yz.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58b0d055",
   "metadata": {},
   "source": [
    "![bloch_yzy.gif](./figures/expressibility-fig-bloch_yzy.gif)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e195d35",
   "metadata": {},
   "source": [
    "可见，神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)$ 的输出可以分布在整个布洛赫球表面了，虽然在两级（$|0\\rangle$ 和 $|1\\rangle$）附近的分布会更加密集；而神经网络 $U(\\vec{\\theta})=R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 的输出在球面的分布是比较均匀的。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7972ed41",
   "metadata": {},
   "source": [
    "在单量子比特的低维情形下我们可以借助布洛赫球定性观察量子神经网络的表达能力。而在一般的多量子比特应用中，我们必须借助统计数学的工具对表达能力定量分析。接下来我们将引入量子态之间保真度分布的 K-L 散度作为量化神经网络的表达能力的指标，并计算一种常见拟设的表达能力。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "11ca0aeb",
   "metadata": {},
   "source": [
    "## 定量分析表达能力：K-L 散度"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1275e46a",
   "metadata": {},
   "source": [
    "### 保真度分布与 K-L 散度"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54ae96a6",
   "metadata": {},
   "source": [
    "在文献 [2] 中，作者提出了基于神经网络输出态之间的保真度概率分布的表达能力量化方法。对任意量子神经网络 $U(\\vec{\\theta})$，采样两次神经网络参数（设为 $\\vec{\\phi}$ 和 $\\vec{\\psi}$），则两个量子电路输出态之间的保真度 $F=|\\langle0|U(\\vec{\\phi})^\\dagger U(\\vec{\\psi})|0\\rangle|^2$ 服从某个概率分布：\n",
    "$$\n",
    "F\\sim{P}(f).\\tag{4}\n",
    "$$\n",
    "文献 [2] 指出，量子神经网络 $U$ 能够均匀地分布在所有酉矩阵上时（此时称 $U$ 服从哈尔分布），保真度的概率分布 $P_\\text{Haar}(f)$ 满足\n",
    "$$\n",
    "P_\\text{Haar}(f)=(2^{n}-1)(1-f)^{2^n-2}.\\tag{5}\n",
    "$$\n",
    "\n",
    "量桨提供了直接从哈尔分布采样酉矩阵的函数。观察哈尔分布酉矩阵输出的量子态保真度服从的概率分布："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b9dbeb68",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEWCAYAAACXGLsWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAbQElEQVR4nO3de7ReVXnv8e9PbpqCoiaKJoR4QU6xxwumKHqK2FaLVOBUUaGI1aEHi3jUHqxFBemwxTO01YqXI0ZFBYHSo6jRYr0VS/WINSCiEJWYRkBQkDvGSoDn/LFW6Otm773eJHu9+/J+P2O8Y7xrrrnWemZ2dp7MOdeaK1WFJEnTuc9sByBJmvtMFpKkTiYLSVInk4UkqZPJQpLUyWQhSepkstC8lWRDkt+f7ThGbbp2J/mdJD8Y4hxfT/LEjjoPTbI2yU5bG6sWDpOFNAOSPCPJ+UluSbJhtuKoqn+tqr0G4rpXYklyMHBbVX2741w/A84Hju4lWM0rJgupQ5Lth6j2C+A04M97Dmcm/ClwxpB1zwRe0WMsmidMFprvnpDk0vZ/9OckuS9Akgcm+VyS65Pc1H5ftvmgJC9th1huS7I+ySsG9h2Q5Ookf5Hkp8BHuoKoqn+rqjOA9cMEneSoJD9OckOSNw32AJJ8NMlfT4xnwil+O8nlbds+MtDue+omOQNYDnw2ye1JXp9kR+B3gX8ZOP++SdYkuTXJz5K8c+A63wQemWSPYdqlhctkofnuBcCBwCOAxwEvacvvQ/OP/B40/2D+EnjvwHHXAc8B7g+8FPi7JPsM7N8NeFB7/IwOwyTZG3g/cBTwcODBwLJpD7q3I4E/AB4FPAY4YWKFqjoKuBI4uKp2rqq3A3sCd1fVYPI5BTilqu7fnu8fBs5xJ7AOePwWxqcFxmSh+e7dVXVNVd0IfBZ4AkBV3VBVn6yqjVV1G3Ay8PTNB1XVP1bVj6rxL8AXgd8ZOO/dwElV9auq+uUMx3wY8LmquqCqfgWc2F5vS7y3qq5q230ycMSQx+0K3DahbBPw6CSLq+r2qrpwwv7b2uM0xkwWmu9+OvB9I7AzQJJFST7QDvXcClwA7Jpku3b/s5NcmOTGJDcDBwGLB851fVX9R08xPxy4avNGVf0CuGELz3HVwPcft+ccxk3ALhPKXkbTO/l+km8lec6E/bsAN29hfFpgTBZaqI4D9gKe3A6v7N+Wp70V9JPA3wIPrapdgfOADBzf53LM1wK7b95IsohmKGqzXwCLBrZ3m+Qcuw98Xw5cM8W1JrZjXXPJLL2nQtUVVXUE8BDgbcAnkvxGG9v2wKOB70zXIC18JgstVLvQzFPcnORBwEkD+3YEdgKuB+5M8mzgWV0nTFJJDphi333aSeYdms3ct51MnswngOck+W9tnbfw67+LlwAHJXlQkt2A105yjmOTLGvb9ibgnCmu9TPgkZs3quoO4MsMDMkleVGSJVV1N//Zg9g8LLYvsKGqfjzF+TUmTBZaqN4F3A/4OXAh8E+bd7RzGK+mmci9CfhjYPV0J0uyO83Y/XenqLI/TXI6j/+cUP/iZBWr6jLgWOAsml7GTcDghPMZNP+T39CeY7JEcFa7bz3wI+CvJ6kD8L+BE5LcnOR1bdkHaCbXNzsQuCzJ7TST3YcPzNMcCZw6xbk1RuLLj6RuSV4EPLaq3tDT+TcAL6+qL/dx/kmu93XgVdM9mJfkITS32D6xx/kbzRMmC2kOGHWykLaUw1CSpE72LCRJnexZSJI6DbNA2ry0ePHiWrFixWyHIUnzxkUXXfTzqloy2b4FmyxWrFjBmjVrZjsMSZo3kkz5PI3DUJKkTiYLSVInk4UkqZPJQpLUyWQhSepkspAkdTJZSJI6mSwkSZ1MFpKkTgv2Ce5x99znvowNG66bdN+KFQ/h3HM/POKIJM1nJosFasOG61i69LNT7Dt4xNFImu8chpIkdTJZSJI6mSwkSZ1MFpKkTiYLSVInk4UkqZPJQpLUyWQhSepkspAkdTJZSJI6mSwkSZ1MFpKkTiYLSVInk4UkqZPJQpLUyWQhSepkspAkdeotWSTZPcn5SS5PclmS10xS54AktyS5pP28uS1fkuRrSb6X5L8P1P9Mkof3FbMkaXJ9vlb1TuC4qro4yS7ARUm+VFWXT6j3r1X1nAllRwCnAucC5wGfTnIw8O2quqbHmCVJk+gtWVTVtcC17ffbkqwFlgITk8VkNgGLgJ2Au5JsD7wW8OXRkjQL+uxZ3CPJCuCJwDcn2b1fku8A1wCvq6rLgLPaz9HAXwCvBM6oqo0d1zm6PYbly5fPWPxzwXOf+zI2bLjuXuUrVjyEc8/98CxENL6m+lmAPw8tXL0niyQ7A58EXltVt07YfTGwR1XdnuQg4NPAnlV1C/CH7fEPBI4H/ijJB4EHAu+oqm9MvFZVrQJWAaxcubJ6atKs2LDhOpYu/ewk5Xa2Rm2qn0Wzz5+HFqZe74ZKsgNNojizqs6duL+qbq2q29vv5wE7JFk8odqJwMk08xhfA/4E+Ms+45Yk/bo+74YK8GFgbVW9c4o6u7X1SLJvG88NA/v3BJZV1Vdp5jDuBgq4X19xS5Lurc9hqKcBRwHfTXJJW/ZGYDlAVZ0KHAYck+RO4JfA4VU1OHx0MvCm9vvZNMNUxwNv7jHueWX9+h+xzz73HvpYv/7HLF06CwFJ28D5oLmrz7uhvgako857gfdOs/8FA9+vA546YwEuEHfcwaTj59///t6zEI20bZwPmrt8gluS1Gkkt85q/Hirr7SwmCzUC2/1lRYWh6EkSZ1MFpKkTg5DaexNNb/y059ezW67LbtX+Tjfluxc1PgyWWjsTTW/8v3v782TnuRtyYOcixpfDkNJkjqZLCRJnUwWkqROJgtJUieThSSpk3dDSSOwpbecuvrq6PlnPj2ThTQCW3rLqauvjp5/5tNzGEqS1MlkIUnq5DDUDFjoSyAs9PZJW2ucfjdMFjNgoS+BsNDbJ22tcfrdcBhKktTJZCFJ6uQw1CTGaRxSUrf163/EPvvce2hpnJarN1lMYpzGISV1u+MOplzGflw4DCVJ6mTPokdTdV1hfIe0pvoz2dJlL6Z6i91055K09UwWPZqq6wrjO6Q11Z/Jli57MdVb7KY7l6St5zCUJKmTyUKS1MlhqC3g7XPz21TzH+P68/MWcW2J3pJFkt2B04GHAgWsqqpTJtQJcApwELAReElVXZxkL+AsYAfgFVX1jSTbA/8EHFJVG/uKezrePje/TTf/MY68RVxbos9hqDuB46pqb+ApwLFJJv5WPhvYs/0cDby/LX8F8BqaJPK6tuwY4OOzlSgkaZz11rOoqmuBa9vvtyVZCywFLh+odihwelUVcGGSXZM8DNgELGo/m5LsChwMHNhXvJKkqY1kziLJCuCJwDcn7FoKXDWwfXVb9j6aIaydaHoZJwJvraq7O65zNE0PheXLl89E6FKvtmYebEufVdHcMZ9f3dp7skiyM/BJ4LVVdeswx1TVlcAB7fGPBpYBa5OcAewInFhVP5zkuFXAKoCVK1fWjDRA6tHWzINt6bMqmjvm86tbe711NskONInizKo6d5IqPwF2H9he1pYNOhk4AXg18CHg9cBJMx+tJGkqvSWL9k6nDwNrq+qdU1RbDbw4jacAt7RzHZvP8XTgmqq6gmb+4u72s6ivuCVJ99bnMNTTgKOA7ya5pC17I7AcoKpOBc6jueNpHc2tsy/dfHCbbE4AXtgWrQLObGM+pse4F7yFPuY9m8/DzMVrT7WO1ihi8lmO4c3138s+74b6GpCOOgUcO82+Zw5srwX2mckYx9VCH/Oezedh5uq1J1tHaxQx+SzH8Ob676XLfUiSOrnch+7hcibSzBjF79Koh/hMFrqHy5lIM2MUv0ujHuJzGEqS1MlkIUnq5DDUHOMy2pLmIpPFHOMy2pLmIoehJEmdTBaSpE4OQ82ShfBMw1RtaPbNn3ZoYZpq/m82lz+Zz0wWs2QhPNMwVRtgfrVDC9N083+ztfzJfNY5DJXkoiTHJnngKAKSJM09w/QsXkizGuy3kqwBPgJ8sV3oT5oRC2FYTlrIOpNFVa0D3pTkROA5wGnAXUk+ApxSVTf2HKPGwEIYlpMWsqHuhkryOOAdwN/QvPnu+cCtwD/3F5okaa7o7FkkuQi4meatd8dX1a/aXd9M8rQeY5MkzRHDzFk8v6rWT7ajqp47w/FImoe2dM5pa+ao5vqb5Ba6YZLFy5O8vapuBmjvijquqk7oNTJJ88aWzjltzRzVXH+T3EI3zJzFszcnCoCquonmvdmSpDExTLLYLslOmzeS3A/YaZr6kqQFZphhqDOBr7S3ykLzzMXH+gtJkobnMzqjMcxzFm9Lcinwe23RX1XVF/oNS5KG4zM6ozHU2lBV9Xng8z3HIkmao4ZZG+q5Sa5IckuSW5PcluTWUQQnSZobhulZvB04uKrW9h2MJGluGuZuqJ+ZKCRpvA3Ts1iT5Bzg08DmpT6oqnP7CkqSNLcMkyzuD2wEnjVQVoDJQpLGxDC3zr50a06c5DSaJc2vq6rfmmT/AcBngH9vi86tqrckWQJ8CtgVOKGqPt3W/wxwTFVdszXxSJK23jB3Qz0myVeSfK/dflySYdaF+ihwYEedf62qJ7Sft7RlRwCnAvsCr22veTDwbROFJM2OYSa4Pwi8AdgEUFWXAod3HVRVFwBb82KkTcAimiVF7kqyPU3SePtWnEuSNAOGSRaLqurfJpTdOUPX3y/Jd5J8Pslj27KzgEOBLwFvBV4JnFFVG7tOluToJGuSrLn++utnKERJ0jDJ4udJHkUzqU2Sw4BrZ+DaFwN7VNXjgffQ3G1FVd1SVX9YVSvbOgcDn0jywSSfSLLfVCesqlVVtbKqVi5ZsmQGQpQkwXDJ4ljgA8B/SfITmiGhY7b1wlV1a1Xd3n4/D9ghyeIJ1U4ETqaZx/ga8CfAX27rtSVJW2aYu6HWA7+f5DeA+1TVbTNx4SS70TzwV0n2pUlcNwzs3xNYVlVfTfJ44D9oejf3m4nrS5KGN8w7uN88YRuAgbuXpjrubOAAYHGSq4GTgB3aY08FDgOOSXIn8Evg8KqqgVOcDLyp/X42zTDV8cCvxSNpZk215Hezz2W/x9UwD+X9YuD7fWmenehc/qOqjujY/17gvdPsf8HA9+uAp3ZGKmmbTbXkN7js9zgbZhjqHYPbSf4W8H0WkjRGhpngnmgRsGymA5EkzV3DzFl8l/a2WWA7YAkw7XyFJGlhGWbO4jkD3++kuYNpph7KkyTNA8Mki4m3yt5/8x1RAFW1NUt6SJLmkWGSxcXA7sBNQGhWg72y3VfAI3uJTJI0Zwwzwf0lmteqLq6qB9MMS32xqh5RVSYKSRoDwySLp7TLcQBQVZ/HZx4kaawMMwx1Tfv+io+320cCvldCksbIMMniCJqlOj5FM0dxQVsmSerZVMuvjHrplWGe4L4ReE2S36iqX3TVlyTNnKmWXxn10ivDvFb1qUkup10PKsnjk/yf3iOTJM0Zw0xw/x3wB7TLh1fVd4D9+wxKkjS3DLU2VFVdNaHorh5ikSTNUcNMcF+V5KlAJdkBeA1DLFEuSVo4hulZ/CnNq1WXAj8BntBuS5LGxLQ9iyTbAadU1ZEjikeSNAdN27OoqruAPZLsOKJ4JElz0DBzFuuBrydZzcArVqvqnb1FJUmaU6bsWSQ5o/16CPC5tu4uAx9J0piYrmfxpCQPp1mO/D0jikeSNAdNlyxOBb4CPAJYM1AefI+FJI2VKYehqurdVfWbwEeq6pEDH99jIUljpvM5i6o6ZhSBSJLmrqGW+5AkjTeThSSpk8lCktTJZCFJ6tRbskhyWpLrknxviv1J8u4k65JcmmSftnyvJBe1Zfu1Zdsn+XKSRX3FK0maWp89i48CB06z/9nAnu3naOD9bfkraJZBPwh4XVt2DPDxqtrYS6SSpGkNszbUVqmqC5KsmKbKocDpVVXAhUl2TfIwYBOwqP1sSrIrcDDTJx5JUo96SxZDWAoMvoHv6rbsfcDpwE40vYwTgbdW1d1dJ0xyNE0vheXLl890vJI0tubcBHdVXVlVB1TVfsBGYBmwNskZSc5J8phpjl1VVSurauWSJUtGFrMkLXSzmSx+Auw+sL2sLRt0MnAC8GrgQ8DrgZNGEp0k6R6zmSxWAy9u74p6CnBLVV27eWeSpwPXVNUVNPMXd7cf74iSpBHrbc4iydnAAcDiJFfT9Ah2AKiqU4HzaO54Wkcz3PTSgWND06N4YVu0Cjizjde1qiRpxPq8G+qIjv0FHDvNvmcObK8F9pnRACVJQ5tzE9ySpLnHZCFJ6mSykCR1MllIkjqZLCRJnUwWkqROJgtJUieThSSpk8lCktTJZCFJ6mSykCR1MllIkjqZLCRJnUwWkqROJgtJUieThSSpk8lCktTJZCFJ6mSykCR1MllIkjqZLCRJnUwWkqROJgtJUieThSSpk8lCktTJZCFJ6mSykCR1MllIkjr1miySHJjkB0nWJTl+kv0vSXJ9kkvaz8vb8r2SXJTk0iT7tWXbJ/lykkV9xixJurft+zpxku2A9wHPBK4GvpVkdVVdPqHqOVX1qgllrwBeA2wATgGeBxwDfLyqNvYVsyRpcn32LPYF1lXV+qq6A/h74NAhj90ELGo/m5LsChwMnN5HoJKk6fXWswCWAlcNbF8NPHmSes9Lsj/wQ+DPquoqmh7J6cBONL2ME4G3VtXd010wydHA0QDLly/f5gZIkhqzPcH9WWBFVT0O+BLwMYCqurKqDqiq/YCNwDJgbZIzkpyT5DGTnayqVlXVyqpauWTJklG1QZIWvD6TxU+A3Qe2l7Vl96iqG6rqV+3mh4AnTXKek4ETgFe3dV4PnDTj0UqSptRnsvgWsGeSRyTZETgcWD1YIcnDBjYPAdZO2P904JqquoJm/uLu9uMdUZI0Qr3NWVTVnUleBXwB2A44raouS/IWYE1VrQZeneQQ4E7gRuAlm49PEpoexQvbolXAmW3Mx/QVtyTp3vqc4KaqzgPOm1D25oHvbwDeMMWxRXPb7ebttcA+/UQqSZrObE9wS5LmAZOFJKmTyUKS1MlkIUnqZLKQJHUyWUiSOpksJEmdTBaSpE4mC0lSJ5OFJKmTyUKS1MlkIUnqZLKQJHUyWUiSOpksJEmdTBaSpE4mC0lSJ5OFJKmTyUKS1MlkIUnqZLKQJHUyWUiSOpksJEmdTBaSpE4mC0lSJ5OFJKmTyUKS1MlkIUnq1GuySHJgkh8kWZfk+En275TknHb/N5OsaMufluTSJGuS7NmW7Zrki0lMcJI0Yr39w5tkO+B9wLOBvYEjkuw9odrLgJuq6tHA3wFva8uPAw4CXgv8aVt2AvDWqrq7r5glSZPr83/p+wLrqmp9Vd0B/D1w6IQ6hwIfa79/Avi9JAE2AYvaz6YkjwJ2r6qv9hivJGkKqap+TpwcBhxYVS9vt48CnlxVrxqo8722ztXt9o+AJwPLgFOBXwJHAX8LnFhVV3Rc82jg6HZzL+AHWxn+YuDnW3nsfGWbF75xay/Y5i21R1UtmWzH9lsfT3+q6hLgKQBJ9geubb7mHJpex3FV9bNJjlsFrNrW6ydZU1Urt/U884ltXvjGrb1gm2dSn8NQPwF2H9he1pZNWifJ9sADgBs272yHpE4A/go4CXg98EHg1b1FLUm6lz6TxbeAPZM8IsmOwOHA6gl1VgN/0n4/DPjn+vVxsRcD51XVjTTzF3e3n0U9xi1JmqC3YaiqujPJq4AvANsBp1XVZUneAqypqtXAh4EzkqwDbqRJKAAkWQS8BHhWW/RO4DzgDuCP+4q7tc1DWfOQbV74xq29YJtnTG8T3JKkhcMH3CRJnUwWkqROY50stnY5kvlqiPb+rySXt0utfCXJHrMR50zqavNAveclqSTz/jbLYdqc5AXtz/qyJGeNOsaZNsTf7eVJzk/y7fbv90GzEedMSXJakuvaZ9Um258k727/PC5Nss82X7SqxvJDM+n+I+CRwI7Ad4C9J9R5JXBq+/1w4JzZjrvn9j4DWNR+P2Y+t3fYNrf1dgEuAC4EVs523CP4Oe8JfBt4YLv9kNmOewRtXgUc037fG9gw23FvY5v3B/YBvjfF/oOAzwOheWbtm9t6zXHuWWzLciTzUWd7q+r8qtrYbl5I82zMfDbMzxia53jeBvzHKIPryTBt/h/A+6rqJoCqum7EMc60YdpcwP3b7w8ArhlhfDOuqi6guYN0KocCp1fjQmDXJA/blmuOc7JYClw1sH11WzZpnaq6E7gFePBIopt5w7R30Mto/mcyn3W2ue2e715V/zjKwHo0zM/5McBjknw9yYVJDhxZdP0Yps1/CbwoydU0t+D/z9GENmu29Pe905xc7kOzK8mLgJXA02c7lj61y92/k+Z5nnGyPc1Q1AE0vccLkvzXqrp5NoPq2RHAR6vqHUn2o3m+67fKVayHNs49i21ejmSeGaa9JPl94E3AIVX1qxHF1peuNu8C/Bbw1SQbaMZ2V8/zSe5hfs5XA6uralNV/TvwQ5rkMV8N0+aXAf8AUFXfAO5Ls+DeQjXU7/uWGOdkMRPLkcwnne1N8kTgAzSJYr6PY0NHm6vqlqpaXFUrqmoFzTzNIVW1ZnbCnRHD/L3+NE2vgiSLaYal1o8wxpk2TJuvBH4PIMlv0iSL60ca5WitBl7c3hX1FOCWqrp2W044tsNQtY3Lkcw3Q7b3b4Cdgf/bzuNfWVWHzFrQ22jINi8oQ7b5C8CzklwO3AX8eVXN1x7zsG0+Dvhgkj+jmex+yTz+jx9JzqZJ+IvbeZiTgB0AqupUmnmZg4B1wEbgpdt8zXn85yVJGpFxHoaSJA3JZCFJ6mSykCR1MllIkjqZLCRJnUwW0hZIcleSSwY+K5L8vynqfjTJYR3nu6dOkg8l2bv9/saZj17aemP7nIW0lX5ZVU+YUPbUmThxVb18YPONwFtn4rzSTDBZSNsoye1VtXO7IvF7gGfSLOJ2x0CdJ9GsQ7Uz8HOah8KunXCerwKvo1kt4H5JLgEuo1l++8aqeldb72Tguqo6pd+WSf/JYShpy9xvYAjqUxP2/RGwF837El5M2+NIsgNNEjmsqp4EnAacPNUFqup42h5MVR3Z1n9xe6770Kwk8PGZbZY0PXsW0paZbBhqs/2Bs6vqLuCaJP/clu9Fs2Dhl9plVLYDhl6np6o2JLmhXbvrocC35/PyHJqfTBZS/wJcVlX7bcM5PkSzlPpuND0NaaQchpJmzgXAC5Ns176V7Blt+Q+AJe17FEiyQ5LHdpxrUzt8tdmngAOB36ZZME8aKXsW0sz5FPC7wOU0S2J/A6Cq7mhvj313kgfQ/N69i2byeiqrgEuTXFxVR7bnOB+4uR3mkkbKVWeleaCd2L4YeH5VXTHb8Wj8OAwlzXHtg3rrgK+YKDRb7FlIkjrZs5AkdTJZSJI6mSwkSZ1MFpKkTiYLSVKn/w/NNNca1foKLAAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from paddle_quantum.linalg import haar_unitary\n",
    "from paddle_quantum.qinfo import state_fidelity\n",
    "from paddle_quantum.state.common import to_state\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.ticker import FuncFormatter\n",
    "from scipy import integrate\n",
    "\n",
    "# 定义绘制直方图的函数\n",
    "def plot_hist(data, num_bin, title_str):\n",
    "    def to_percent(y, position):\n",
    "        return str(np.around(y*100, decimals=2)) + '%'\n",
    "    plt.hist(data, weights=[1./len(data)]*len(data), bins=np.linspace(0, 1, num=num_bin), facecolor=\"blue\", edgecolor=\"black\", alpha=0.7)\n",
    "    plt.xlabel(\"Fidelity\")\n",
    "    plt.ylabel(\"frequency\")\n",
    "    plt.title(title_str)\n",
    "    formatter = FuncFormatter(to_percent)\n",
    "    plt.gca().yaxis.set_major_formatter(formatter)\n",
    "    plt.show()\n",
    "    \n",
    "    \n",
    "# 定义计算哈尔采样输出保真度分布的函数\n",
    "def p_F_haar(n, s, b=50, draw=False):\n",
    "    f_list = list()\n",
    "    # 开始采样\n",
    "    for i in range(s):\n",
    "        # 采样第一个酉变换\n",
    "        u1 = haar_unitary(n)\n",
    "        # 输入 |0> 时酉变换的输出\n",
    "        phi1 = u1[:,0]\n",
    "        rho1 = to_state(np.outer(phi1, phi1.conj()))\n",
    "        # 采样第二个酉变换\n",
    "        u2 = haar_unitary(n)\n",
    "        phi2 = u2[:,0]\n",
    "        # 输入 |0> 时酉变换的输出\n",
    "        rho2 = to_state(np.outer(phi2, phi2.conj()))\n",
    "        # 计算两个采样输出之间的保真度\n",
    "        f_list.append(state_fidelity(rho1, rho2)**2)\n",
    "    f_list = np.array(f_list)\n",
    "    # 绘制概率分布图\n",
    "    if draw:\n",
    "        title_str = \"haar, %d qubit(s)\" % num_qubit\n",
    "        plot_hist(f_list, b, title_str)\n",
    "    sample_distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n",
    "    # 根据公式计算概率分布函数的理论值，用于后期计算 K-L 散度\n",
    "    theory_distribution = np.zeros_like(sample_distribution)\n",
    "    for index in range(len(theory_distribution)):\n",
    "        def p_continues(f):\n",
    "            return (2 ** n - 1) * (1 - f) ** (2 ** n - 2)\n",
    "        lower = 1/b*index\n",
    "        upper = lower + 1/b\n",
    "        theory_distribution[index], _ = integrate.quad(p_continues,lower,upper)\n",
    "    return sample_distribution, theory_distribution\n",
    "\n",
    "\n",
    "num_qubit = 1\n",
    "p_haar_1qubit, theory_haar_1qubit = p_F_haar(num_qubit, num_sample, draw=True)\n",
    "num_qubit = 2\n",
    "p_haar_2qubit, theory_haar_2qubit = p_F_haar(num_qubit, num_sample, draw=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8680f5b2",
   "metadata": {},
   "source": [
    "可见保真度分布大致服从 $P_\\text{Haar}$。类似地，我们也能计算之前定义的单比特量子神经网络 $R_Y(\\theta)$，$R_Y(\\theta_1)R_Z(\\theta_2)$ 和 $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 输出的保真度概率分布："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "2af57d70",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 定义计算量子神经网络输出保真度分布的函数\n",
    "def p_F_qnn(n, s, g, b=50, draw=False):\n",
    "    f_list = list()\n",
    "    rho_sample = outputs_y\n",
    "    title_str = \"Ry\"\n",
    "    if g == 2:\n",
    "        rho_sample = outputs_yz\n",
    "        title_str = \"Ry-Rz\"\n",
    "    elif g == 3:\n",
    "        rho_sample = outputs_yzy\n",
    "        title_str = \"Ry-Rz-Ry\"\n",
    "    # 使用之前采样的数据计算保真度分布\n",
    "    for index in range(int(s / 2)):\n",
    "        rho1 = rho_sample[index]\n",
    "        rho2 = rho_sample[index+int(num_sample / 2)]\n",
    "        f_list.append(state_fidelity(rho1, rho2)**2)\n",
    "    f_list = np.array(f_list)\n",
    "    # 绘制概率分布图\n",
    "    if draw:\n",
    "        plot_hist(f_list, b, title_str)\n",
    "    distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n",
    "    return distribution\n",
    "    \n",
    "    \n",
    "num_qubit = 1\n",
    "p_y = p_F_qnn(num_qubit, num_sample, 1, draw=True)\n",
    "p_yz = p_F_qnn(num_qubit, num_sample, 2, draw=True)\n",
    "p_yzy = p_F_qnn(num_qubit, num_sample, 3, draw=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18e05d9e",
   "metadata": {},
   "source": [
    "可见，$R_Y-R_Z-R_Y$ 门组成的神经网络的输出保真度分布与均匀酉矩阵的表现最为接近。统计数学中的 K-L 散度（也称相对熵）可以衡量两个概率分布之间的差异。两个离散概率分布 $P,Q$ 之间的 K-L 散度定义为\n",
    "$$\n",
    "D_{KL}(P||Q)=\\sum_jP(j)\\ln\\frac{P(j)}{Q(j)}.\\tag{6}\n",
    "$$\n",
    "如果将量子神经网络输出的保真度分布记为 $P_\\text{QNN}(f)$，则量子神经网络的表达能力定义为 $P_\\text{QNN}(f)$ 和 $P_\\text{Haar}(f)$ 之间的 K-L 散度 [2]：\n",
    "$$\n",
    "\\text{Expr}_\\text{QNN}=D_{KL}(P_\\text{QNN}(f)||P_\\text{Haar}(f)).\\tag{7}\n",
    "$$\n",
    "因此，当 $P_\\text{QNN}(f)$ 越接近 $P_\\text{Haar}(f)$ 时，$\\text{Expr}$ 将越小（越趋近于 0），量子神经网络的表达能力也就越强；反之，$\\text{Expr}$ 越大，量子神经网络的表达能力也就越弱。\n",
    "\n",
    "我们可以根据该定义直接计算单比特量子神经网络 $R_Y(\\theta)$，$R_Y(\\theta_1)R_Z(\\theta_2)$ 和 $R_Y(\\theta_1)R_Z(\\theta_2)R_Y(\\theta_3)$ 的表达能力："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "1d73cffe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ry，Ry-Rz，和 Ry-Rz-Rz 神经网络的表达能力分别为 0.19，0.05，和 0.02。\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats import entropy\n",
    "# 使用 scipy 的 entropy 函数计算相对熵（即 K-L 散度）\n",
    "expr_y = entropy(p_y, theory_haar_1qubit)\n",
    "expr_yz = entropy(p_yz, theory_haar_1qubit)\n",
    "expr_yzy = entropy(p_yzy, theory_haar_1qubit)\n",
    "print(\"Ry，Ry-Rz，和 Ry-Rz-Rz 神经网络的表达能力分别为 %.2f，%.2f，和 %.2f。\" %(expr_y, expr_yz, expr_yzy))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e33d696a",
   "metadata": {},
   "source": [
    "###   评估量子神经网络拟设的表达能力"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "763d2532",
   "metadata": {},
   "source": [
    "现在，我们拥有了定量研究任何量子神经网络拟设表达能力的工具——K-L 散度。作为一个实际应用，我们来探究量桨内置拟设 complex_entangled_layer 的表达能力随电路深度的变化。这里我们设置电路的宽度为 4-qubit。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c557d91a",
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "哈尔采样输出的保真度服从分布：\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正在采样深度为 1 的电路...\n",
      "   采样第 0 个样本...\n",
      "   采样第 400 个样本...\n",
      "   采样第 800 个样本...\n",
      "   采样第 1200 个样本...\n",
      "   采样第 1600 个样本...\n",
      "   采样完毕\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZEAAAEWCAYAAACnlKo3AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAAg/klEQVR4nO3deZhcVZ3/8feHJAQiW4CAkAQaB1DRAYGW1XFhC7KFYZBFlqBhGBYVERdwAYQJD6iIMIoYloGgIIhBIoKYYRl+KFtYRNYhhCAJgQQSAopsyff3xzkNN5Wq7tu3u7qp9Of1PPX0Xc6995yq6vrWWe4pRQRmZmZVLNffGTAzs9blIGJmZpU5iJiZWWUOImZmVpmDiJmZVeYgYmZmlTmIWJ+QdKukw/s7H/2lJ+Xv7FhJp0j6ec9y1/8khaQN++naYyT9pkS6syQd1QdZaikOIjYgSfqkpFn9nY9llaQPS7pR0guS3u03o00AziiR7gfANyUt3+T8tBQHETPrFkmDSyR7E7gKGN/k7FQmaZCkjwKrRsSdXaWPiDnAY8BeTc9cC3EQGQAkjZY0WdI8SS9K+nHevpykb0t6WtJcSZMkrZr3teUmhs9JekbSAklHSvqopAclvdRxnpz+MEl/lPRjSQslPSZpx07y9HlJj+bz3ihp/bz9G5Lu6vigknSUpIclrdDgPHtIeiDn50+SNi3smynpqzm/CyVdKWkFSe8BbgDWlfS3/FhX0laS7sjnmpPLsnzhfJGfgydymp9IUt43KDd3vCDpKUlfyOnrfuA2Kn/et3N+/hbm51glXuaOY38l6bl87G2SPpS3f1TS85IGFdLuI+nPeXk5SSdIejK/R66StHre1/FeGC/pr8DNXeUjIh6PiIuAh8vmvZCv3SXdL+nl/N47pbDvd5K+WJP+QUn/mpc/IGmqpPmSHpe0XyHdJZJ+Kul6SX8HPgV8GvjfQhpJOjv/P7ws6S+SPly43K3A7t0t0zItIvxYhh/AIODPwNnAe4AVgI/lfZ8HpgPvA1YCJgOX5X1tQADn52N2AV4DfgOsBYwE5gKfyOkPA94CjgOGAPsDC4HV8/5bgcPz8th83Q8Cg4FvA3/K+5YDbgNOATYCFgCbNyjb5jkPW+dyjgNmAkPz/pnA3cC6wOrAo8CRed8ngVk159sS2CbnqS2n/3JhfwDXAasB6wHzgF3zviOBR4BRwHDgf3L6wd0s/5rAK8C++Xk8Lj+vhzd4Dk4Bfl5Y/zywMjAU+BHwQGHfI8CnC+vXAMfn5WOBO3P+hwI/A66oeS9MIr2HVuzG+29DIEqkC2DDwmvzz/m9sCnwPLB33rcfcFfhuM2AF4Hlc96eAT6Xn9fNgReATXLaS0jvye3zuVcAfgV8rXC+McC9+TVWfo3WKezfB7ivv/+v302Pfs+AH01+gWHb/GE3uM6+m4CjC+vvJzVDdHyIBjCysP9FYP/C+q/JH7KkIPIsoML+u4FD8nLxQ/QGYHwh3XLAq8D6eb0NmE/6ED+xk7L9FDitZtvjvBPYZgIHF/Z9Dzg/L3+SmiBS5/xfBq4prAc5AOf1q4AT8vLNwH8U9u1E4yDSsPzAocCdhX0CZlEyiNTsWy3nYdW8/g3gF3l59XzNdfL6o8COhWPXqfNeeF+F91+3g0idfT8Czs7LK5C+WGyU138AnJeX9wf+X82xPwNOzsuXAJNq9k8lf7HI6zsA/0f6MrFcnbzsDMyo+v+4LD7cnLXsGw08HRFv1dm3LvB0Yf1p0ofG2oVtzxeW/1FnfaXC+uzI/2mF861b57rrA+fkJqGXSAFDpNoNETETuIX04fWTBuXqOM/xHefJ5xpdc83nCsuv1uR3CZI2lnRdbg56GTidVDMoanS+dUnfgjsUl+vlu1H5lzhPfj47O1cx/4MknZGbpF4mBVEKZfg5sGduztuP9IE7p5Cnawp5ehRYxJLvhVL56ClJW0u6Ran5dSGplrcmQES8BlwJHCxpOeBA4LJCGbaueT8cBLy3kzIsINXcyOe/Gfgx6X03V9JESasU0q8MvNQ7JV02OIgs+54B1mvQNv8s6R+vw3qkppPn66QtY2RHH0HhfM82yNN/RMRqhceKEfEnSG3ipBrUTcD3O7neM8CEmvMMi4grSuS13oihn5I6TjeKiFWAb1K+P2IOqSmow+gu8t2o/HOKx+bns7NzFX2W1FS2E7AqKQhDLkNEzAbuIDXJHMI7H74defp0TZ5WyMd06KtRVpcDU4DREbEqqUm1+DpcSgoOOwKvRsQdefszwP/WlGGliCgOy60tw4PAxsUNEXFuRGwJbJL3fa2w+4Ok5mHLHESWfXeTPpjOkPSe3LG8fd53BXCcpA0krUT65n1lg1pLGWsBX5I0RNJnSP9w19dJdz5wYqHTd9WcHklrAhcCh5P6OPaUtFuD610AHJm/uSqXb3dJKzdIX/Q8sIbyQIJsZeBl4G+SPgB0556Aq4BjJY2UtBqp6aiRhuUHfgd8KHd6Dwa+xJLfpDuzMvA6qdlxGOn1rDUJ+Dqpz2FyTZ4m6J0BDiMkje3sYkoDFw5rsE9KgyGWz+srSBrajXLMj4jXJG1FCo5vy0FjMXAWSwbC64CNJR2S34ND8oCCD3ZyreuBTxTy/dH8fhoC/J3UD7i4kP4TpOZIyxxElnERsQjYk9Q2/VdS+/r+effFpH/C24CnSP8wX6xzmrLuInWGv0Aae79vRLxYJ0/XAGcCv8zNLg+RRskATASujYjr87HjgQslrVHnPNOAfyc1PywgdVYfViajEfEYKYjOyE0f6wJfJX1gvUIKUFeWLDc5/R9I32zvJ304vUVqEqq9dsPyR8QLwGdI9y28SHo+/1gyD5NITYizSZ3o9YatXkNuuoqIVwvbzyF9+/+DpFfysVs3upDSqLU1GlyDfI1/8M7orH+Q+qvKOBo4NefjJFKArjWJFAjfvtEyIl4hDQA5gFQDfo70PDcMXhFxH7BQUkdZVyG9lgtIz+WL5NqwpHVItZPflCzHgKAlm7DNqsnfSA+PiI/1d17eDSR9mtSJv36XifuYpCdJzWn/04NzfAw4JiIO7L2cdev6hwJH9Mb7TdIupAEme3eR7izgyYg4r6fXXJaUuWnIzLogaUXSfQd/IHVGn0z61v+uIunfSP0CXd7r0ZmIuB24vVcy1U2ShpFqK73yYR4RfyC9bl2lO743rrescXOWWe8Q8F1SM8j9pNFNJ/VrjmpIupU0eOCYiFjcRfJ3JUljSEPWnyd1wFs/c3OWmZlV5pqImZlV1tQ+EUkzSSNdFgFvRUS70nw8V5LGsM8E9ouIBXWOHUeaDgLgPyPi0jxE8FrSePzzOjq4JE0kdWLe11We1lxzzWhra+thyczMBpZ77733hYgYUbu9LzrWP5WHLXY4AbgpIs6QdEJeX2JMfQ40JwPtpE7AeyVNAf6F1Jl3OmnY43mSNgMGlQkgAG1tbUybNq2nZTIzG1AkPV1ve380Z40l3XFK/rt3nTRjgKkRMT/XUqYCu5Lm8hlGmpiu4w7W04DvNDPDZmZWX7ODSJBuXrpX0hF529qF+XqeY8m5eTqMZMk5bmblbVNJzWB3AudK2os0o2a9qTXeJukISdMkTZs3b1710piZ2RKa3Zz1sYiYLWktYKqkx4o7IyLUjV89y9NxfBYgT0twIzBW0g9J8zRNiogpdY6bSLoTmvb2dg9HMzPrJU2tiXRM3hYRc0k3Xm0FPJ+nD+iYRmBunUNns+Skc6PytqKjSVMfbEP6jYD9Ad8MZGbWh5oWRPJkeCt3LJPmtHmIND/PuJxsHGm0Va0bgV0kDZc0PB97Y+Hcw4E9SEFkGGmCtABWbE5pzMysnmY2Z61N+n2CjutcHhG/l3QPcJWk8aQJzvYDkNRO+nGYwyNivqTTgHvyuU6NiPmFc59EmgJ8saQbgWOAv5BmIjUzsz4y4O5Yb29vDw/xNTPrHkn3RkR77XbfsW5mZpU5iJiZWWWeCr4b9tlnPDNnLj2YrK1tLSZPvqgfcmRm1r8cRLph5sy5jBz52zrb9+yH3JiZ9T83Z5mZWWUOImZmVpmDiJmZVeYgYmZmlTmImJlZZQ4iZmZWmYOImZlV5iBiZmaVOYiYmVllDiJmZlaZg4iZmVXmIGJmZpU5iJiZWWUOImZmVpmDiJmZVeYgYmZmlTmImJlZZQ4iZmZWmYOImZlV5iBiZmaVOYiYmVllDiJmZlaZg4iZmVXmIGJmZpU5iJiZWWUOImZmVpmDiJmZVeYgYmZmlTmImJlZZQ4iZmZWWdODiKRBku6XdF1e30DSXZKmS7pS0vINjjsxp3lc0pi8bYSk2yU9JGnvQtprJa3b7LKYmdmS+qImcizwaGH9TODsiNgQWACMrz1A0ibAAcCHgF2B8yQNAg4Ezge2Ar6c0+4J3B8RzzaxDGZmVkdTg4ikUcDuwIV5XcAOwNU5yaXA3nUOHQv8MiJej4ingOmkwPEmMAwYCiySNJgUTL7XvFKYmVkjza6J/Aj4OrA4r68BvBQRb+X1WcDIOseNBJ4prHeku5wUYKYCpwNHA5dFxKudZULSEZKmSZo2b968ikUxM7NaTQsikvYA5kbEvb11zohYGBG7R0Q7cB+wJ3C1pAskXS1p2wbHTYyI9ohoHzFiRG9lx8xswBvcxHNvD+wlaTdgBWAV4BxgNUmDc21kFDC7zrGzgdGF9XrpvgNMIPWT3E5qIpsMjOnNQpiZWWNNq4lExIkRMSoi2kid5DdHxEHALcC+Odk44No6h08BDpA0VNIGwEbA3R07JW0EjIqIW0l9JIuBAFZsUnHMzKyO/rhP5BvAVyRNJ/WRXAQgaS9JpwJExMPAVcAjwO+BYyJiUeEcE4Bv5eUrgKOAe0g1HTMz6yPNbM56W64x3JqXZ5BGWtWmmUKqgXSsTyAFi3rn26+wPBfYrlczbGZmpfiOdTMzq8xBxMzMKnMQMTOzyhxEzMysMgcRMzOrzEHEzMwqcxAxM7PKHETMzKwyBxEzM6vMQcTMzCpzEDEzs8ocRMzMrDIHETMzq8xBxMzMKnMQMTOzyhxEzMysMgcRMzOrzEHEzMwqcxAxM7PKHETMzKwyBxEzM6vMQcTMzCpzEDEzs8ocRMzMrDIHETMzq8xBxMzMKnMQMTOzyhxEzMysMgcRMzOrzEHEzMwqcxAxM7PKHETMzKwyBxEzM6vMQcTMzCprWhCRtIKkuyX9WdLDkr6bt28g6S5J0yVdKWn5BsefmNM8LmlM3jZC0u2SHpK0dyHttZLWbVZZzMysvi6DiKR7JR0jaXg3z/06sENEbAZ8BNhV0jbAmcDZEbEhsAAYX+eamwAHAB8CdgXOkzQIOBA4H9gK+HJOuydwf0Q82838mZlZD5WpiewPrAvcI+mXksZIUlcHRfK3vDokPwLYAbg6b78U2LvO4WOBX0bE6xHxFDCdFDjeBIYBQ4FFkgaTgsn3SpTDzMx6WZdBJCKmR8S3gI2By4GLgaclfVfS6p0dK2mQpAeAucBU4EngpYh4KyeZBYysc+hI4JnCeke6y0kBZipwOnA0cFlEvNpFPo6QNE3StHnz5nVaXjMzK69Un4ikTYGzgO8DvwY+A7wM3NzZcRGxKCI+Aowi1SQ+0JPMRsTCiNg9ItqB+4A9gaslXSDpaknbNjhuYkS0R0T7iBEjepIFMzMrGNxVAkn3Ai8BFwEnRMTredddkrYvc5GIeEnSLcC2wGqSBufayChgdp1DZgOjC+v10n0HmEDqJ7md1EQ2GRhTJk9mZtZzZWoin4mIHSPi8kIAASAi9ml0UB5JtVpeXhHYGXgUuAXYNycbB1xb5/ApwAGShkraANgIuLtw7o2AURFxK6mPZDGpv2XFEuUxM7NeUiaIHN4RDAAkDZf0nyWOWwe4RdKDwD3A1Ii4DvgG8BVJ04E1SDUcJO0l6VSAiHgYuAp4BPg9cExELCqcewLwrbx8BXBUvsY5JfJlZma9pMvmLODTEfHNjpWIWCBpN+DbnR0UEQ8Cm9fZPoPUP1K7fQqpBtKxPoEULOqde7/C8lxgu66LYWZmva1MTWSQpKEdK7lpamgn6c3MbIAoUxP5BXCTpP/O658j3d9hZmYDXJdBJCLOzP0aO+ZNp0XEjc3NlpmZtYIyNREi4gbghibnxczMWkyZubP2kfSEpIWSXpb0iqSX+yJzZmb27lamJvI9YM+IeLTZmTEzs9ZSZnTW8w4gZmZWT5mayDRJVwK/IU3vDkBETG5WpszMrDWUCSKrAK8CuxS2BWmeKjMzG8DKDPH9XF9kxMzMWk+Z0VkbS7pJ0kN5fVNJnU55YmZmA0OZjvULgBNJvyrYMSfWAc3MlJmZtYYyQWRYRNxds+2tuinNzGxAKRNEXpD0T6TOdCTtC8xpaq7MzKwllBmddQwwEfiApNnAU8DBTc2VmZm1hDKjs2YAO0l6D7BcRLzS/GyZmVkrKPMb6yfVrAMQEac2KU9mZtYiyjRn/b2wvAKwB+m30s3MbIAr05x1VnFd0g8A/56ImZmVGp1VaxgwqrczYmZmradMn8hfyMN7gUHACMD9IWZmVqpPZI/C8lukqeF9s6GZmZUKIrVDelfpGKEFEBHzezVHZmbWMsoEkfuA0cACQMBqwF/zvgDe15ScmZnZu16ZjvWppJ/HXTMi1iA1b/0hIjaICAcQM7MBrEwQ2SYiru9YiYgbgO2alyUzM2sVZZqzns2/H/LzvH4Q8GzzsmRmZq2iTE3kQNKw3mtIP4k7Im8zM7MBrswd6/OBYyW9JyL+3lV6MzMbOMr8PO52kh4hz5claTNJ5zU9Z2Zm9q5XpjnrbGAM8CJARPwZ+HgzM2VmZq2h1NxZEfFMzaZFTciLmZm1mDKjs56RtB0QkoYAx+Kp4M3MjHI1kSNJP5E7EpgNfCSvm5nZANdpEJE0CDgnIg6KiLUjYq2IODgiXuzqxJJGS7pF0iOSHpZ0bN6+uqSpkp7If4c3OH5cTvOEpHF521BJv5f0kKSjC2knStqiWyU3M7Me6zSIRMQiYH1Jy1c491vA8RGxCbANcIykTYATgJsiYiPgpry+BEmrAycDWwNbASfnYDMGuB3YFDgkp90MGBQR91XIo5mZ9UCZPpEZwB8lTaHwU7kR8cPODoqIOcCcvPyKpEdJTWJjgU/mZJcCtwLfqDl8DDC1Y4ZgSVOBXYGXSD+KNYQ0GSTAaaQmNzMz62MNayKSLsuLewHX5bQrFx6lSWoDNgfuAtbOAQbgOWDtOoeMBIojwmblbVOBNuBO4FxJewH3RUSn07BIOkLSNEnT5s2b152sm5lZJzqriWwpaV3StO//VfUCklYCfg18OSJervktkpAUDQ+ukX8M67P5vENIv/U+VtIPgfWASRExpc5xE4GJAO3t7aWvZ2ZmnessiJxP6rPYAJhW2C5K/o5I/qD/NfCLiJicNz8vaZ2ImCNpHWBunUNn806TF6TfdL+1Js3RwCRSf8tCYH/gZmCpIGJmZs3RsDkrIs6NiA8C/x0R7ys8Sv2OiFKV4yLg0Zr+kynAuLw8Dri2zuE3ArtIGp471HfJ2zrOPZz0uyaTSH0ki0mBbcWu8mVmZr2ny/tEIuKoiufenjSCagdJD+THbsAZwM6SngB2yutIapd0Yb7mfFKH+T35cWrNz/CeBEyIiMWk4PIvwF+AyzAzsz5TZnRWJRFxO++MoKq1Y53004DDC+sXAxc3OPdxheXXSDUVMzPrY6XmzjIzM6vHQcTMzCpzEDEzs8ocRMzMrDIHETMzq8xBxMzMKnMQMTOzyhxEzMysMgcRMzOrzEHEzMwqcxAxM7PKmjZ31kAyY8aTbLHFnkttb2tbi8mTL+qHHJmZ9Q0HkV7wxhswcuRvl9o+c+bSgcXMbFni5iwzM6vMQcTMzCpzEDEzs8ocRMzMrDIHETMzq8xBxMzMKnMQMTOzyhxEzMysMgcRMzOrzEHEzMwqcxAxM7PKHETMzKwyBxEzM6vMQcTMzCpzEDEzs8ocRMzMrDIHETMzq8xBxMzMKnMQMTOzyhxEzMysMgcRMzOrrGlBRNLFkuZKeqiwbXVJUyU9kf8Ob3DsuJzmCUnj8rahkn4v6SFJRxfSTpS0RbPKYWZmjTWzJnIJsGvNthOAmyJiI+CmvL4ESasDJwNbA1sBJ+dgMwa4HdgUOCSn3QwYFBH3NakMZmbWiaYFkYi4DZhfs3kscGlevhTYu86hY4CpETE/IhYAU0nB6E1gGDAEUE57GvCd3s25mZmV1dd9ImtHxJy8/Bywdp00I4FnCuuz8rapQBtwJ3CupL2A+yLi2a4uKukISdMkTZs3b15P8m9mZgWD++vCERGSohvp3wI+CyBpCHAjMFbSD4H1gEkRMaXBsROBiQDt7e2lr2lmZp3r65rI85LWAch/59ZJMxsYXVgflbcVHQ1MArYBFgL7A8f3em7NzKxTfR1EpgDj8vI44No6aW4EdpE0PHeo75K3AZC37UEKIsOAxUAAKzYx32ZmVkczh/heAdwBvF/SLEnjgTOAnSU9AeyU15HULulCgIiYT+owvyc/Ts3bOpwETIiIxaTg8i/AX4DLmlUWMzOrr2l9IhFxYINdO9ZJOw04vLB+MXBxg/MeV1h+jVRTMTOzftBvHesDwYwZT7LFFnvW3dfWthaTJ1/UxzkyM+tdDiJN9MYbMHLkb+vumzmzfnAxM2slnjvLzMwqcxAxM7PKHETMzKwyBxEzM6vMQcTMzCpzEDEzs8ocRMzMrDIHETMzq8xBxMzMKnMQMTOzyjztST9pNK+W59Qys1biINJPGs2r5Tm1zKyVuDnLzMwqcxAxM7PKHETMzKwyBxEzM6vMQcTMzCpzEDEzs8ocRMzMrDIHETMzq8w3G77L+E52M2slDiLvMr6T3cxaiZuzzMysMgcRMzOrzM1ZLcJ9JWb2buQg0iIa9ZXcfPMmDi5m1m8cRFqcO+LNrD85iCyjGjV/ATz33Cze+95RS2137cXMustBZBnVqIYC8Nhjm7Dllq69mFnPOYhYZfvsM56ZM+cutd01GrOBw0HE3tbdEWAzZ851f4zZAOcgYm/r7giwGTOeZuTIpc/TWX+Maylmy5Z+CSKSdgXOAQYBF0bEGTX7hwKTgC2BF4H9I2KmpO2BnwJvAAdGxBOSVgOuAnaNiMV9WIwBo1FweeyxTbqVHhoHJHf2m7WmPg8ikgYBPwF2BmYB90iaEhGPFJKNBxZExIaSDgDOBPYHjgd2A9qAI/P6t4HTHUBaQ2cBqV5nf3eDTmf7eisgNeoL6s1rmLWK/qiJbAVMj4gZAJJ+CYwFikFkLHBKXr4a+LEkAW8Cw/LjTUn/BIyOiFv7JuvW17obdDrb11u1oEZ9QZ1do9G5GgWkRnnqi+DZ3TxVuYYtOxQRfXtBaV9S09Phef0QYOuI+EIhzUM5zay8/iSwNTAKOB/4B3AI8APgOxHxRBfXPAI4Iq++H3i8YvbXBF6oeGyrcpkHhoFW5oFWXuh5mdePiBG1G1uqYz0iHgC2AZD0cWBOWtSVpFrK8RHxfJ3jJgITe3p9SdMior2n52klLvPAMNDKPNDKC80rc3/M4jsbGF1YH5W31U0jaTCwKqmDnbxNpL6Q04CTga8DFwBfalquzcxsKf0RRO4BNpK0gaTlgQOAKTVppgDj8vK+wM2xZLvbocD1ETGf1D+yOD+GNTXnZma2hD5vzoqItyR9AbiRNMT34oh4WNKpwLSImAJcBFwmaTownxRoAJA0DDgM2CVv+iFwPWnY72ebnP0eN4m1IJd5YBhoZR5o5YUmlbnPO9bNzGzZ4V82NDOzyhxEzMysMgeROiTtKulxSdMlnVBn/1BJV+b9d0lq64ds9poS5f2KpEckPSjpJknr90c+e1NXZS6k+zdJIanlh4OWKbOk/fJr/bCky/s6j72txHt7PUm3SLo/v79364989hZJF0uam++1q7dfks7Nz8eDkrbo8UUjwo/Cg9TZ/yTwPmB54M/AJjVpjgbOz8sHAFf2d76bXN5PAcPy8lGtXN6yZc7pVgZuA+4E2vs7333wOm8E3A8Mz+tr9Xe++6DME4Gj8vImwMz+zncPy/xxYAvgoQb7dwNuAES65+6unl7TNZGlvT0tS0S8AXRMy1I0Frg0L18N7JjvXWlFXZY3Im6JiFfz6p2ke3taWZnXGNJ9SGcCr/Vl5pqkTJn/HfhJRCwAiIj6E4S1jjJlDmCVvLwq8Gwf5q/XRcRtpBGtjYwFJkVyJ7CapHV6ck0HkaWNBJ4prM/K2+qmiYi3gIXAGn2Su95XprxF40nfZFpZl2XO1fzREfG7vsxYE5V5nTcGNpb0R0l35tm2W1mZMp8CHCxpFulWgS/2Tdb6TXf/37vUUtOeWP+SdDDQDnyiv/PSTJKWI91/dFg/Z6WvDSY1aX2SVNu8TdI/R8RL/ZmpJjsQuCQizpK0Len+tA+HZwUvzTWRpfV4WpYWU6a8SNoJ+BawV0S83kd5a5auyrwy8GHgVkkzSW3HU1q8c73M6zwLmBIRb0bEU8D/kYJKqypT5vGk3yMiIu4AViBNVLisKvX/3h0OIkvrjWlZWkmX5ZW0OfAzUgBp9XZy6KLMEbEwItaMiLaIaCP1A+0VEdP6J7u9osz7+jekWgiS1iQ1b83owzz2tjJl/iuwI4CkD5KCyLw+zWXfmgIcmkdpbQMsjIg5PTmhm7NqRA+nZWk1Jcv7fWAl4Fd5/MBfI2Kvfst0D5Us8zKlZJlvBHaR9AiwCPhaRLRqDbtsmY8HLpB0HKmT/bAW/kKIpCtIXwTWzP08JwNDACLifFK/z27AdOBV4HM9vmYLP19mZtbP3JxlZmaVOYiYmVllDiJmZlaZg4iZmVXmIGJmZpU5iJj1AkmLJD1QeLRJ+lODtJdI2reL872dRtKFkjbJy9/s/dybVef7RMx6xz8i4iM127brjRNHxOGF1W8Cp/fGec16g4OIWZNI+ltErJRneP4vYGfS5HdvFNJsSZqnayXgBdLNbnNqznMr8FXS7AgrSnoAeJg0zfn8iPhRTjcBmBsR5zS3ZGbvcHOWWe9YsdCUdU3Nvn8F3k/6vYpDyTUUSUNIwWXfiNgSuBiY0OgCEXECucYTEQfl9Ifmcy1Hmjnh571bLLPOuSZi1jvqNWd1+DhwRUQsAp6VdHPe/n7SRI9T83Qyg4DS8xhFxExJL+a5zdYG7m/laUqsNTmImPUfAQ9HxLY9OMeFpCnr30uqmZj1KTdnmTXfbcD+kgblX5H7VN7+ODAi/44FkoZI+lAX53ozN4N1uAbYFfgoaaJBsz7lmohZ810D7AA8Qpp6/A6AiHgjD+M9V9KqpP/HH5E6zRuZCDwo6b6IOCif4xbgpdxcZtanPIuvWQvLHer3AZ+JiCf6Oz828Lg5y6xF5RsQpwM3OYBYf3FNxMzMKnNNxMzMKnMQMTOzyhxEzMysMgcRMzOrzEHEzMwq+/+HDuSL3jrwZQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正在采样深度为 2 的电路...\n",
      "   采样第 0 个样本...\n",
      "   采样第 400 个样本...\n",
      "   采样第 800 个样本...\n",
      "   采样第 1200 个样本...\n",
      "   采样第 1600 个样本...\n",
      "   采样完毕\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "正在采样深度为 3 的电路...\n",
      "   采样第 0 个样本...\n",
      "   采样第 400 个样本...\n",
      "   采样第 800 个样本...\n",
      "   采样第 1200 个样本...\n",
      "   采样第 1600 个样本...\n",
      "   采样完毕\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "深度为 1,2,3 的神经网络的表达能力分别为 [0.2429 0.011  0.01  ]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 定义计算保真度分布的函数\n",
    "def p_F_cel(n, d, s, b=50, draw=False):\n",
    "    pq.set_backend('state_vector')\n",
    "    f_list = list()\n",
    "    for index in range(int(s / 2)):\n",
    "        if 2 * index % 400 == 0:\n",
    "            print(\"   采样第 %d 个样本...\" % (2 * index))\n",
    "        cir1 = Circuit(n)\n",
    "        # 作用 complex_entangled_layer 层\n",
    "        cir1.complex_entangled_layer('full', d)\n",
    "        # 输出态的态矢量\n",
    "        rho1 = cir1(pq.state.zero_state(n))\n",
    "        \n",
    "        cir2 = Circuit(n)\n",
    "        # 作用 complex_entangled_layer 层\n",
    "        cir2.complex_entangled_layer('full', d)\n",
    "        # 输出态的态矢量\n",
    "        rho2 = cir2(pq.state.zero_state(n))\n",
    "        \n",
    "        # 计算保真度\n",
    "        f_list.append(abs(np.inner(rho1.data.numpy(), rho2.data.numpy().conj())**2))\n",
    "                      \n",
    "    print(\"   采样完毕\")\n",
    "    f_list = np.array(f_list)\n",
    "    # 绘制概率分布图\n",
    "    if draw:\n",
    "        title_str = \"complex entangled layer, %d layer(s)\" % d\n",
    "        plot_hist(f_list, b, title_str)\n",
    "    distribution, _ = np.histogram(f_list, bins=np.linspace(0, 1, num=b), density=True)\n",
    "    return distribution\n",
    "\n",
    "\n",
    "# 设置电路宽度和最大深度\n",
    "num_qubit = 4\n",
    "max_depth = 3\n",
    "# 计算哈尔采样对应的保真度分布\n",
    "print(\"哈尔采样输出的保真度服从分布：\")\n",
    "p_haar_4qubit, theory_haar_4qubit = p_F_haar(num_qubit, num_sample, draw=True)\n",
    "Expr_cel = list()\n",
    "# 计算不同深度的神经网络的表达能力\n",
    "for DEPTH in range(1, max_depth + 1):\n",
    "    print(\"正在采样深度为 %d 的电路...\" % DEPTH)\n",
    "    p_cel = p_F_cel(num_qubit, DEPTH, num_sample, draw=True)\n",
    "    expr = entropy(p_cel, theory_haar_4qubit)\n",
    "    Expr_cel.append(expr)\n",
    "# 比较不同深度的神经网络的表达能力\n",
    "print(\"深度为 1,2,3 的神经网络的表达能力分别为\", np.around(Expr_cel, decimals=4))\n",
    "plt.plot(range(1, max_depth + 1), Expr_cel, marker='>')\n",
    "plt.xlabel(\"depth\")\n",
    "plt.yscale('log')\n",
    "plt.ylabel(\"Expr.\")\n",
    "plt.xticks(range(1, max_depth + 1))\n",
    "plt.title(\"Expressibility vs Circuit Depth\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2f1b3485",
   "metadata": {},
   "source": [
    "可见随着电路深度的增加，量子神经网络的表达能力也在逐渐增强。感兴趣的读者不妨自己动手尝试一下其他量桨内置拟设的表达能力计算，以及比较不同拟设之间表达能力的差别。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e5dd645",
   "metadata": {},
   "source": [
    "_______\n",
    "\n",
    "## 参考文献\n",
    "\n",
    "[1] Nielsen, Michael A., and Isaac L. Chuang. \"Quantum Computation and Quantum Information.\" Cambridge University Press, 2010.\n",
    "\n",
    "[2] Sim, Sukin, Peter D. Johnson, and Alán Aspuru‐Guzik. \"Expressibility and entangling capability of parameterized quantum circuits for hybrid quantum‐classical algorithms.\" [Advanced Quantum Technologies 2.12 (2019): 1900070](https://onlinelibrary.wiley.com/doi/abs/10.1002/qute.201900070)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}