tutorial/machine_learning/QKernel_CN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "instructional-length",
   "metadata": {},
   "source": [
    "# 量子核方法\n",
    "\n",
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "desirable-compatibility",
   "metadata": {},
   "source": [
    "## 概览\n",
    "\n",
    "在量子机器学习中，参数化量子电路（parameterized quantum circuit）扮演着重要的角色。在很多场景中，为了类比经典机器学习领域中的神经网络方法，我们也经常会把参数化量子电路称为量子神经网络。但是实际上，在量子机器学习的相关应用中，人们发现参数化量子电路的数学原理更类似于经典机器学习中的核方法（kernel methods）[1]。这种通过将量子计算和经典核方法相结合的思路以及研究方法，就被称为量子核方法（quantum kernel methods）。这两种方法的结合对于量子计算如何更好的解决一系列机器学习问题提供了全新的视角，因此在近年来收到了极大的关注 [2-7]。在本教程中，我们将探究如何用量子核方法结合支持向量机来实现数据分类。\n",
    "\n",
    "### 理论背景\n",
    "\n",
    "在经典机器学习中，核方法一般指的是将低维的数据向量通过特征映射（feature map）映射到高维的特征空间（feature space）中，来识别低维数据中难以分辨的模式的方法。如图1的例子所示，通过将一维的线性不可分数据映射到二维，映射后的数据在二维空间中是线性可分的。\n",
    "\n",
    "![feature map](./figures/Qkernel-fig-featuremap.png \"图1：核方法中的特征映射\")\n",
    "<div style=\"text-align:center\">图1：核方法中的特征映射 </div>\n",
    "\n",
    "不过，在实际应用中，由于特征空间的维数可能会十分巨大，我们往往并不希望直接对映射后的特征向量进行分析。相反，通过核方法中的另一个核心概念-核函数（kernel function），我们可以隐式地引入特征映射在模式识别上的优势。核函数的定义为数据向量在特征空间里的内积，其具体形式为\n",
    "\n",
    "$$\n",
    "K(\\mathbf{x}_i, \\mathbf{x}_j) = \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i),\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "其中 $\\phi()$ 就代表着特征映射。需要注意的是，在核方法中我们并不需要显式地写出特征映射，而只需要定义核函数的形式即可。\n",
    "\n",
    "在经典机器学习中，核方法最具代表性的应用就是支持向量机（support vector machine, SVM）。简单的来说，支持向量机解决的是线性分类问题：以一个二分类的问题举例，我们的数据集为 $T = \\{ (\\mathbf{x}_1, y_1), ..., (\\mathbf{x}_m, y_m) \\} \\subset \\mathcal{X}\\times\\mathbb{Z}_2$，通过一个超平面 $(\\mathbf{w}, b)$，支持向量机可以通过如下决策函数的正负来预测每个数据点 $\\mathbf{x}$ 的标签：\n",
    "\n",
    "$$\n",
    "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}, \\mathbf{x} \\rangle + b).\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "但是对于在原始数据空间中线性不可分的数据而言，这样的做法往往并不可行。所以如图1所示，通过引入我们上文中提到的特征映射，我们可以将原始数据空间中的数据向量映射到特征空间中来进行分类，从而得到更好的分类效果。此时，我们标记特征空间中的超平面为 $(\\mathbf{w}', b')$, 我们的决策函数就变成了：\n",
    "\n",
    "$$\n",
    "y_{\\rm pred} = {\\rm sign}(\\langle \\mathbf{w}', \\phi(\\mathbf{x}) \\rangle + b').\n",
    "\\tag{3}\n",
    "$$\n",
    "\n",
    "更进一步的是，我们可以通过对偶化的方法，引入拉格朗日乘子 $\\alpha_i$ 来表示此时的分割超平面 $\\mathbf{w}' = \\sum_i \\alpha_i \\phi(\\mathbf{x_i})$ [8]。此时，我们可以在 $\\alpha_i \\geq 0$，$\\sum_i y_i \\alpha_i=0$ 的约束下，通过最大化\n",
    "\n",
    "$$\n",
    "\\sum_i \\alpha_i - \\frac{1}{2} \\sum_{i, j} \\alpha_i \\alpha_j y_i y_j \\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i)\n",
    "\\tag{4}\n",
    "$$\n",
    "\n",
    "来计算最优参数 $\\alpha_i^*$。不难发现，此时我们只需要计算数据向量在特征空间里的内积 $\\phi(\\mathbf{x}_j)^T \\phi(\\mathbf{x}_i) = K(x_i, x_j)$，正是我们上文中提到的核函数。换言之，在支持向量机中，我们不需要显式地知道特征映射的形式，而只需要计算原始数据在特征空间里的内积，就可以实现在特征空间中对数据进行分类。并且，对于任何新的数据向量 $\\mathbf{x}'$，我们只需要通过核函数 $K(,)$ 计算\n",
    "\n",
    "$$\n",
    "y_{\\rm pred} = {\\rm sign}(\\sum_i \\alpha^*_i  \\langle \\phi(\\mathbf{x_i}), \\phi(\\mathbf{x}' \\rangle + b') = \n",
    "{\\rm sign}(\\sum_i \\alpha^*_i  K(\\mathbf{x}_i, \\mathbf{x}') + b'),\n",
    "\\tag{5}\n",
    "$$\n",
    "\n",
    "就可以对数据的标签进行预测。\n",
    "\n",
    "借助这种思想，我们就可以很简单的理解量子核方法的内涵。首先，我们引入量子特征空间的概念，即我们认为我们通过一个编码电路 $U(\\mathbf{x}) $ 将经典数据向量 $\\mathbf{x} $ 编码到某个量子态 $| \\phi(\\mathbf{x}) \\rangle$ 上：\n",
    "\n",
    "$$\n",
    "U(\\mathbf{x}) | 0^{\\otimes N} \\rangle = | \\phi(\\mathbf{x}) \\rangle.\n",
    "\\tag{6}\n",
    "$$ \n",
    "\n",
    "关于编码电路的具体形式我们这里不做展开，感兴趣的读者可以阅读我们的[编码教程](./DataEncoding_CN.ipynb)来了解不同的量子编码电路形式。此时我们的量子特征映射就是从经典数据空间到量子态所处的希尔伯特空间的一种特殊特征映射。在这个基础上，我们将量子核函数（quantum kernel function）定义为经典数据向量在量子特征空间的内积，其具体形式就为\n",
    "\n",
    "$$\n",
    "K^Q_{ij} = |\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2,\n",
    "\\tag{7}\n",
    "$$\n",
    "\n",
    "上式可以进一步写为\n",
    "\n",
    "$$\n",
    "|\\langle \\phi(\\mathbf{x}_j) | \\phi(\\mathbf{x}_i) \\rangle |^2 =  |\\langle 0^{\\otimes N} | U^\\dagger(\\mathbf{x}_j) U(\\mathbf{x}_i) | 0^{\\otimes N} \\rangle |^2.\n",
    "\\tag{8}\n",
    "$$\n",
    "\n",
    "不难发现，通过运行如图2中所示的量子电路，并在统计其测量结果为 $| 0^{\\otimes N} \\rangle $ 的概率，我们就可以估计式（8）中的量子核函数。这种方法也被称为量子核估计（quantum kernel estimation, QKE）方法。也就是说，如果我们通过量子核估计方法来计算式（4-5) 中的核函数的话，我们就可以利用支持向量机的方法在量子特征空间来完成数据分类。借助量子特征映射的量子性，人们希望这种量子核方法可以更好地分类具有复杂模式的数据。人们已经证明，通过精心设计量子特征映射，量子核方法就可以用来分辨任何经典方法都无法识别的数据模式 [3]。\n",
    "\n",
    "![QKE](./figures/Qkernel-fig-QKE.png \"图2：量子核估计电路\")\n",
    "<div style=\"text-align:center\">图2：量子核估计电路 </div>\n",
    "\n",
    "![illustration](./figures/Qkernel-fig-illustrationCN.png \"图3：经典核方法和量子核方法的对比示意图\")\n",
    "<div style=\"text-align:center\">图3：经典核方法和量子核方法的对比示意图 </div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "willing-shopping",
   "metadata": {},
   "source": [
    "### 拓展：量子机器学习和核方法的联系\n",
    "\n",
    "在量子机器学习中，往往我们量子电路中的一部分需要将经典的数据编码到其对应的量子态上，其数学形式为：\n",
    "\n",
    "$$\n",
    "| \\phi(x) \\rangle = U (x) | 0^{\\otimes N} \\rangle,\n",
    "\\tag{9}\n",
    "$$\n",
    "\n",
    "其中 $U(x)$ 是一个取决于经典数据 $x$ 的参数化电路。正如我们上文中提到的，这种编码的过程可以被考虑成是一种从经典数据空间到量子特征空间的特殊特征映射。同时，考虑一个作用在编码量子态上的量子神经网络电路，其数学形式为：\n",
    "\n",
    "$$\n",
    "| \\psi \\rangle = U_{\\rm QNN}(\\theta)U (\\mathbf{x}) | 0^{\\otimes N} \\rangle,\n",
    "\\tag{10}\n",
    "$$\n",
    "\n",
    "其中 $U_{\\rm QNN}(\\theta)$ 为代表量子神经网络的参数化量子电路，$\\theta$ 为其中的参数。我们在电路的最后进行测量，该测量用 $\\mathcal{M}$ 表示。这时，我们测得的期望值为\n",
    "\n",
    "$$\n",
    "\\langle \\mathcal{M} \\rangle = \\langle \\psi | \\mathcal{M} | \\psi \\rangle = \\langle \\phi(\\mathbf{x}) | U^\\dagger_{\\rm QNN}(\\theta) \\mathcal{M} U_{\\rm QNN}(\\theta)| \\phi(\\mathbf{x}) \\rangle.\n",
    "\\tag{11}\n",
    "$$\n",
    "\n",
    "我们不妨将测量写成算符的形式 $| \\sigma \\rangle \\langle \\sigma |$ ，那么式（11）就可以进一步被写为\n",
    "\n",
    "$$\n",
    "\\langle \\phi(\\mathbf{x}) | \\sigma'(\\theta) \\rangle \\langle \\sigma' (\\theta)  | \\phi(x) \\rangle = \n",
    "|\\langle \\sigma' (\\theta)  | \\phi(\\mathbf{x}) \\rangle|^2,\n",
    "\\tag{12}\n",
    "$$\n",
    "\n",
    "其中 $| \\sigma'(\\theta) \\rangle = U^\\dagger_{\\rm QNN}(\\theta) | \\sigma \\rangle$。这样的话，我们发现我们这种基于量子神经网络的测量结果也可以被认为是量子特征空间中两个量子特征向量的内积：$|\\langle \\sigma' (\\theta)  | \\phi(\\mathbf{x}) \\rangle|^2$。\n",
    "而该内积，正是我们前文中提到的量子核函数，只不过其中一个特征向量是由一个参数化的测量所描述的。这也就是我们在本教程的一开始提到，量子神经网络模型的数学形式实际上更接近于经典机器学习中的核方法的原因。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tutorial-vocabulary",
   "metadata": {},
   "source": [
    "## 示例：利用量子核方法来解决分类问题\n",
    "\n",
    "> 本教程需要使用 [`sklearn`](https://scikit-learn.org/stable/install.html) 中的相关函数来实现支持向量机的功能。需要的读者可以运行下面的代码块来安装相关模块："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "informative-miami",
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import clear_output\n",
    "\n",
    "!pip install scikit-learn\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "emerging-anxiety",
   "metadata": {},
   "source": [
    "下面，我们用一个简单的例子来展示如何在 Paddle Quantum 中模拟量子核估计电路，并将其应用在一个实际的分类任务上。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "acting-nursery",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import paddle\n",
    "from numpy import pi as PI\n",
    "from matplotlib import pyplot as plt\n",
    "\n",
    "from paddle import matmul, transpose\n",
    "from paddle_quantum.circuit import UAnsatz\n",
    "\n",
    "import sklearn\n",
    "from sklearn import svm\n",
    "from sklearn.datasets import fetch_openml, make_moons, make_circles\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "from IPython.display import clear_output\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fluid-rating",
   "metadata": {},
   "source": [
    "首先，我们生成两类线性不可分的二维圆形数据点作为我们的训练集和测试集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "turkish-energy",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "先来看一下我们的训练集和测试集:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAEICAYAAAD80ZhHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAApSUlEQVR4nO3deZwcVb338c93erbs6xCyLxCEALI4gsgVlDVxISiIwYUE4Ylw4eKCPgTxuqO44vWRq0ZE0etlEbeo4SKrXhc0A0RWkRDBJIRkCCEsSSaz/J4/uib0bNm6p2u6+/t+veo1VadO1fwqy+lfnTp1WhGBmZmZmRVfVdoBmJmZmVUqJ2JmZmZmKXEiZmZmZpYSJ2JmZmZmKXEiZmZmZpYSJ2JmZmZmKXEiZiVN0s2S5qcdh5mZ2Z5wImZFJ+nFnKVD0pac7XftzrkiYk5EXNtfsZqZ9aWQbVlyvrskndsfsdrAVZ12AFZ5ImJo57qkJ4BzI+K27vUkVUdEWzFjMzPbVbvalpntiHvEbMCQ9HpJqyVdIulp4HuSRkn6laRmSRuT9Uk5x2y/g5S0QNLvJX05qfsPSXNSuyAzq0iSqiQtkvS4pA2SbpQ0OtlXL+m/kvLnJC2TNE7S5cDrgG8kPWrfSPcqrFiciNlAszcwGpgKLCT7b/R7yfYUYAuwowbqSOBRYCzwReC7ktSfAZuZdfNvwKnAscAEYCNwVbJvPjACmAyMAc4DtkTEZcD/AhdGxNCIuLDYQVs6nIjZQNMBfCIiWiJiS0RsiIifRMTmiHgBuJxs49aXJyPiOxHRDlwLjAfGFSFuM7NO5wGXRcTqiGgBPgmcLqkaaCWbgO0bEe0RcU9EPJ9irJYyjxGzgaY5IrZ2bkgaDFwJzAZGJcXDJGWSZKu7pztXImJz0hk2tJd6Zmb9ZSrwM0kdOWXtZG8Kf0i2N+x6SSOB/yKbtLUWPUobENwjZgNNdNu+GHgFcGREDAeOScr9uNHMBqpVwJyIGJmz1EfEmohojYhPRcQs4LXAm4GzkuO6t39WAZyI2UA3jOy4sOeSwa6fSDkeM7Od+RZwuaSpAJIaJM1N1t8g6WBJGeB5so8qO3vO1gEz0gjY0uNEzAa6rwGDgGeAu4H/STUaM7Od+w9gCfAbSS+QbbuOTPbtDdxENgl7BPgt2ceVncednrz1/fXihmxpUYR7Qs3MzMzS4B4xMzMzs5Q4ETMzMzNLiRMxMzMzs5Q4ETMzMzNLSUlO6Dp27NiYNm1a2mGYWZHcc889z0REQ9pxFILbL7PKs6M2rCCJmKRryE5Ktz4iDuplv8i+lvtGYDOwICLuTfbNBz6WVP1sRFy7s983bdo0mpqaChG6mZUASU+mHUOhuP0yqzw7asMK9Wjy+2S/gqYvc4CZybIQ+GYSWOcEnUcCRwCfkDSqr5OYmZmZlZOCJGIR8Tvg2R1UmQv8ILLuBkZKGg+cDNwaEc9GxEbgVnac0JmZmZmVjWIN1p9I9ru3Oq1Oyvoq70HSQklNkpqam5v7LVAzMzOzYimZtyYjYnFENEZEY0NDWYzZNTMzswpXrLcm1wCTc7YnJWVrgNd3K7+rSDGZ9aqlpZ1HH3+RIYMzzJg6hOy7JmZm6Wtt7eCBvz1PdPT8esLJEwez19i6FKKyfBQrEVsCXCjperID8zdFxFpJtwCfyxmgfxJwaZFiMuvhf+54mq98cwVVVdDeHjSMrePLnziYieMHpR2amRlPrNrMRR/9K0MGZ8i9R9y6tYNTZo/nQ+fNTC842yOFmr7iOrI9W2MlrSb7JmQNQER8C1hKduqKFWSnrzg72fespM8Ay5JTfToidjTo36zfPLbyRb70n4/R0tKxvWz1U1v4wMfu54bvHEFVlXvGzCxdM2cMZf+Zw/jbYy90Ka+treKMUyalFJXlo1BvTZ4ZEeMjoiYiJkXEdyPiW0kSRvK25AURsU9EHBwRTTnHXhMR+ybL9woRj9me+Omv19Da2tGlLAI2vdDKg397PqWorL9JukbSekkP9rFfkr4uaYWk+yUdnrNvvqTHkmV+8aK2SnbB2TOor3v54ztTBf9y5BgmTXDPfSkqmcH6Zv1tw8ZtdHT0LJdg0/OtxQ/IiuX7eB5EKyGHHTySaVOGbN/OVFex8N3TU4zI8uFEzCxx9KvHdLnL7NTa2sFB+w9PISIrBs+DaKWos1fMvWGlz4mYWWL2ceMYP66eutqX/1vU11XxrtOmMGpkbYqRWco8D6INOJ29YhG4N6zEleSXfpv1h7q6DIu/cjg/v/kp7vpDM8OG1nDamydwVOOYtEOzEhcRi4HFAI2NjT3nHTDbAx/+15n85b6N7g0rcU7EzHIMqs9w5lsnc+ZbJ++8slUKz4NoA9L++w5j/32HpR2G5cmPJs3MdmwJcFby9uRrSOZBBG4BTpI0Khmkf1JSZma2y9wjZmYVzfMgmlmanIiZWUWLiDN3sj+AC/rYdw1wTX/EZWaVwY8mzczMzFLiRMzMzMwsJU7EzMzMzFLiRMzMzMwsJU7EzMzMzFLiRMzMzMwsJU7EzMzMzFLiRMzMzMwsJU7EzMzMzFJSkERM0mxJj0paIWlRL/uvlLQ8Wf4u6bmcfe05+5YUIh4zMzOzUpD3VxxJygBXAScCq4FlkpZExMOddSLigzn1/w04LOcUWyLi0HzjMDMzMys1hegROwJYERErI2IbcD0wdwf1zwSuK8DvNTMzMytphUjEJgKrcrZXJ2U9SJoKTAfuyCmul9Qk6W5Jp/b1SyQtTOo1NTc3FyBsMzMzs3QVe7D+POCmiGjPKZsaEY3AO4GvSdqntwMjYnFENEZEY0NDQzFiNTMzM+tXhUjE1gCTc7YnJWW9mUe3x5IRsSb5uRK4i67jx8zMzMzKViESsWXATEnTJdWSTbZ6vP0oaX9gFPCnnLJRkuqS9bHA0cDD3Y81MzMzK0d5J2IR0QZcCNwCPALcGBEPSfq0pFNyqs4Dro+IyCk7AGiS9FfgTuCK3LctzcyKwVPwmFla8p6+AiAilgJLu5V9vNv2J3s57o/AwYWIwcxsT3gKHjNLk2fWN7NK5yl4zCw1TsTMrNL1+xQ8nn7HzPriRMzMbNft0RQ8nn7HzPriRMzMKp2n4DGz1DgRM7NK5yl4zCw1BXlr0sysVEVEm6TOKXgywDWdU/AATRHRmZT1NQXPtyV1kL2x9RQ8ZrZbnIiZWcXzFDxmlhY/mjQzMzNLiRMxMzMzs5SU7aPJtvbgz/c8y/pnWpi13zBese+wtEMyMzMz66IsE7Gnnt7CBYuW89LmdtrbO5DEYQeP5POXHUh1tTsBzczMbGAoy6zkE196hA0bt7F5Szst24KtLR3c+8Bz3Likr6mBzMzMzIqv7BKxZzduY8U/XqSjo2t5S0sHv7xlbTpBmZmZmfWi7BKx1rbso8i+9pmZmZkNFGWXiO01to6GMbU9ymtqxAmv2yuFiMzMzMx6V3aJmCQ++eEDGDwoQ11t9vIG1VcxYe9BvOeMKSlHZ2ZmZvaysnxr8oD9hnPDd47g5tvXsXbdFl45aySvf+1YamrKLu80MzOzElaQzETSbEmPSlohaVEv+xdIapa0PFnOzdk3X9JjyTK/EPEAjBpRyzvfNpmLz9+PE4/dy0mYmZmZDTh594hJygBXAScCq4Flkpb08sW3N0TEhd2OHQ18AmgEArgnOXZjvnGZmZmZDXSFeDR5BLAiIlYCSLoemAt0T8R6czJwa0Q8mxx7KzAbuK4AcZmZlbzf/+UZHv7bCz3KM9XiHXMnMXRIWY4wMasYhfgfPBFYlbO9Gjiyl3qnSToG+DvwwYhY1cexE3v7JZIWAgsBpkzxoHszqwzL7tvIT3/9FBFdyzMZcdqbem0uzayEFGvg1C+BaRHxSuBW4NrdPUFELI6IxohobGhoKHiAZmYD0VlnTO0xxrWmRsydPZ6RI2pSisrMCqUQidgaYHLO9qSkbLuI2BARLcnm1cCrdvVYM7P+NhBfOOo0ZlQtbzphb2qqX56oWhLz3zG10L/KzFJQiERsGTBT0nRJtcA8YEluBUnjczZPAR5J1m8BTpI0StIo4KSkzMysKHJeOJoDzALOlDSrl6o3RMShyXJ1cmznC0dHkh0v+4mkLSuoBfOmoqpsIlZTI9584t6MGdVz4mozKz15J2IR0QZcSDaBegS4MSIekvRpSack1S6S9JCkvwIXAQuSY58FPkM2mVsGfLpz4L6ZWZFsf+EoIrYBnS8c7YrtLxwlb3t3vnBUUJ29YtUZuTfMrMwU5HWbiFgKLO1W9vGc9UuBS/s49hrgmkLEYWa2B/r9haNCvGy0YN5Ultyy1r1hZmXGs5yame1cXi8cFeJlozGjavnSxw/i3HdP26PjzWxgciJmZpWuZF44OuLw0Qwf6jclzcqJEzEzq3R+4cjMUuMpmc2sokVEm6TOF44ywDWdLxwBTRGxhOwLR6cAbcCz5LxwJKnzhSPwC0dmtpuciJlZxfMLR2aWFj+aNDMzM0uJEzEzMzOzlDgRMzMzM0uJEzEzMzOzlDgRMzMzM0uJEzEzMzOzlDgRMzMzM0uJEzEzMzOzlDgRMzMzM0uJEzEzMzOzlDgRMzMzM0uJEzEzMzOzlBQkEZM0W9KjklZIWtTL/g9JeljS/ZJulzQ1Z1+7pOXJsqQQ8ZiZmZmVgup8TyApA1wFnAisBpZJWhIRD+dUuw9ojIjNks4Hvgi8I9m3JSIOzTcOMzMzs1JTiB6xI4AVEbEyIrYB1wNzcytExJ0RsTnZvBuYVIDfa2ZmZlbSCpGITQRW5WyvTsr6cg5wc852vaQmSXdLOrWvgyQtTOo1NTc35xWwlZ6nf3Ebvz/ybdw2+Wia3n4hLzzyeNohmZmZ5a2og/UlvRtoBL6UUzw1IhqBdwJfk7RPb8dGxOKIaIyIxoaGhiJEawPFE9/8EfeddTGb7n2IlqefYd0vbuMPrz2dF//mZMwKw+NczSwthUjE1gCTc7YnJWVdSDoBuAw4JSJaOssjYk3ycyVwF3BYAWKyMtGxbRuPfuyrdGze+nJhBO2bt/L3T309vcCsbOSMc50DzALOlDSrW7XOca6vBG4iO86105aIODRZTilK0GZWNgqRiC0DZkqaLqkWmAd0uSuUdBjwbbJJ2Pqc8lGS6pL1scDRQO4gf6twW/65lmjv6Lmjo4ONdy8vejxWljzO1cxSk3ciFhFtwIXALcAjwI0R8ZCkT0vqvDv8EjAU+HG37vsDgCZJfwXuBK7o9ralVbjavcYQbW297hs0ZUKRo7Ey1e/jXD3G1cz6kvf0FQARsRRY2q3s4znrJ/Rx3B+BgwsRg5WnmuFDmTDvzTx141I6trz8eDIzuJ59P3p+ipFZJcoZ53psTvHUiFgjaQZwh6QHIqLLAMaIWAwsBmhsbIyiBWxmA15BEjGz/nTQVZ9CVWLNdb+CKpGpq+OAL17CXicfk3ZoVh52d5zrsX2Nc5V0F9lxrn6TxMx2iRMxG/AydbW8cvHnmPXVy2h9dhN1E/aiqtr/dK1gto9zJZuAzSP7Fvd2OeNcZ3cf5wpsjoiWnHGuuQP5zbp4acWTtG16oUd5zagRDJ4xuZcjrNz508xKRvXQIVQPHZJ2GFZmIqJNUuc41wxwTec4V6ApIpbQdZwrwD+TNyQPAL4tqYPsmFuPc7Ud+sNrT6d96zaqal7++O1obaV29EiOf+J3KUZmaXEiZmYVz+NcrVimXXgWj3/5atqef3F7WWbIIKZ/4OwUo7I0OREzM7Oy9OLfHmfbhud6lNeMGMawg/YrfkDA9PcvYOVXr+lSpupqpr7vzFTisfQ5ETOef+BRHv7Q5Wz8431khg1m2r++m30/er7HYZlZSfvLm86lpXkDVbW128uitRXV1HDyM02pxFQzYhgzPvReHv/y1XRs2UpmyCBmfuwCMoPqU4nH0lfUrziygWfzE6v547FnsuGuP9OxbRutG57j8S9fzf3nfjTt0MzM8jLjI/8HVVXRtumF7UuQ7ZVK0/T3L0BV2Y9f94aZE7EKt/Jr36Nja0uXso4tW1l7081sfWpdSlGZmeVv8tmnU1VX16VMqko9EevsFQPcG2ZOxCrdpmUPEK09Z66vqq/jxUdXphCRmVlhZOpq2e9T7yczZBAAVYPrmXHxOdQMH5pyZNlesfFvn+PeMHMiVumGH7I/VGd6lHe0bGPIvtOKH5CZWQHl9ooNhN6wTjUjhnH4f3/NvWHmRKzSzfjge8nU1XYpqxpUR8PsYxg0eXxKUZmZFUZnrxgwYHrDzHI5EatwQ2ZO48hbrmX4YbNAIjO4nsnvPYPD/uuraYdmZlYQk88+nUlnvXXA9IaZ5fL8BMaoIw/hdX/5GdHeDlVVJDOHm5mVhUxdLYd894q0wzDrlRMx206ZnmPFzMzMrP/40aSZmZlZSpyImZmZmaXEjybNzMzMduC5Ta0s+uyDbG1p77HvyMNHc/6CGXt87oIkYpJmA/8BZICrI+KKbvvrgB8ArwI2AO+IiCeSfZcC5wDtwEURcUshYjLbFc/+8V5Wf/8ntG3ewoS3v5Fxbzlu+1ePmJmZAQwZnGH12i08t6m1S3l1tTj2qLF5nTvvRExSBrgKOBFYDSyTtCQiHs6pdg6wMSL2lTQP+ALwDkmzgHnAgcAE4DZJ+0VEz5TTrMAe+9x/8vgXFtO+ZStEsP5XdzL2uKN41U3fcDJmZmbb1dRUsfA90/h/Vz/Olq0dL5dXV3HG3El5nbsQnzZHACsiYmVEbAOuB+Z2qzMXuDZZvwk4Xtk5EuYC10dES0T8A1iRnM+sX21Z/TQrPv9N2jdvgQgA2l/azDN3/InmW3+fcnTlr6MjiOTP3cysFMw5bm/q6l6eXaCutop3vm0SQwbn16dViERsIrAqZ3t1UtZrnYhoAzYBY3bxWLOCe+a2P/Q6XUf7S5tZt+T2FCKqDGue3sIH//1+Xv/W3/GGt/4vH//Cw2x6vnXnB/YzSbMlPSpphaRFveyvk3RDsv/Pkqbl7Ls0KX9U0slFDdzMiqazV2xQfTZ1qqpS3r1hUEJvTUpaKKlJUlNzc3Pa4ViJqx46GHp7/FidodpfgdIvNm9u430X38c992+kowPa2oPf/ekZLli0nI6O9HrHcoZXzAFmAWcmwyZybR9eAVxJdngF3YZXzAb+MzmfmZWhzl6x6owK0hsGhUnE1gCTc7YnJWW91pFUDYwgO2h/V44FICIWR0RjRDQ2NDQUIGyrZHu98fW9llfVVDPpPW8tbjAV4je/XcfWlnY6Xh5eQVt7sO6ZFu65/7nU4sLDK6yE/eMbP+DX9Qf0WJbWz2Ldr+5IO7yy09krVlub/9iwToVIxJYBMyVNl1RL9u5wSbc6S4D5yfrpwB2RHSCyBJiXdPtPB2YCfylATGY7lBk8iCOWLKZ6xFCqhw2letgQqurrOPDKjzFs1r5ph1eWVj65ma0tHT3K29uDf67ZnEJE2/X78Ar36Ft/aTjxX6iqrob2ji5LVV0No49+VdrhlaW3nDSe//7WqwvSGwYFeGsyItokXQjcQnb6imsi4iFJnwaaImIJ8F3gh5JWAM+STdZI6t0IPAy0ARf4jUkrltH/0sgJa/7EM7f/kY6tLYw97ihqRg5PO6yytd+MoQyqr+ryxhFApkpMnzIkpaiKIyIWA4sBGhsb/ZaCFczQV8xgrze+nnVLbs9+XzBQVV/HtH87i5pRI1KOrjxJYuzouoKdryDpXEQsBZZ2K/t4zvpW4O19HHs5cHkh4jDbXZm6Wsb18ZjSCuv4Y/biOz96gpZt27Y/nqypFpMmDOKwg1L9wNid4RWr93R4hVl/ecVnPsj6m3+7PRFTVRX7XHxuylHZriqZwfpmVtoG1We4+quHc+xRY6mtqWJQfYY5x4/jG58/hOxwq9R4eIWVtKGvmMFec45FmUzSG/Ye94aVEH/FkZkVTcOYOj6z6MC0w+jCwyvKT0dbG0/99y+zkzV3M3ifKTSccHQKUfWvV3zmg6xfepd7w0qQEzHbbRFB26YXqBpUT6auNu1wzPLm4RXlJVrbeODCT0J7O+TMFxitrYw59siyTMSGvmIGe592MkP2nebesBLjR5O2Wzb89s/cNetkbp1wFL8Z8yqWn30JbS++lHZYZmbbZQbVM/39CyBTRceWrduXqtoa9vvk+9MOr98c+v0vsd+/X5h2GLabnIjZLnvh4RUsO2Uhm1c8SbS20dGyjbU/Xsq977go7dDMzLrY5+JzkHI+4iSGH3Ygo15zaGox9beUx1raHnIiZrvsH1/7Hh0tXb+OpqNlGxv+dxmbV67q4ygzs+KrGTmcaRfNp2pQdpqBzKA6Drji/6YclVlPTsRsl734t8e3vx6dq6q2ls1Prk4hIjOzvuX2ipV7b5iVLiditstGHnUYqq3pUd6xtYWhB3g2ejMbWDp7xQD3htmA5bcmbZfNuGgBq675MW1t7XTOyJkZXM+Ed55C/d7+/k8zG3j2+fC51E/a271hNmC5R8x2Wf3EcfzLH29i3CnHUz1iGIOmTGC/T32Ag6/6VNqhmZn1qmbEMKa978y0wzDrk3vEbLcMmTmNxh9/I7Xf3755C8/ceTdEMOYNr6F6yODUYjEzM8uXEzErGetv/i33vvMDqCrbkRvt7Rz2w68w7i3HpxyZmdmOPXPHn3jxbyt7lFfV1jDxPad6cuwK5kTMSkJL87PcM+8iOjZ3/cqSe9/1Id7w99s8Rs3MBrQnv30d65bchqpf/tiNZKzt+LfPcSJWwTxGzErC2ptu7n1HBGtvXNr7PjOzAWK/f78Q1dTQsbVl+yKJqe87k5oRw9IOz1LkRMxKQvuLLxHb2nqUd2xr9VcsmdmAN+yg/Rj7htdAVc7HbpXYd9F56QVlA4ITMSsJDScdg2p6PknP1Nex18nHpBCRmdnu2f/yi6lKHkFW1dUy5dx3ULfXmJSjsrQ5EbOSMPyQ/Zn0nlPJDBm0vSwzZDDjz3gjI151UIqRmZntmi69Yu4Ns4QH61vJOOgbn2TvuSew+oc/JyKY9O65NLg3zMxKyP6XX8z6pXe5N8y2yysRkzQauAGYBjwBnBERG7vVORT4JjAcaAcuj4gbkn3fB44FNiXVF0TE8nxisvIliYaTXkfDSa9LOxQrE27DrNiGHbQfr7z684x78xvSDsUGiHwfTS4Cbo+ImcDtyXZ3m4GzIuJAYDbwNUkjc/Z/JCIOTZblecZjZrY73IZZ0U2e/zZqx4xKOwwbIPJNxOYC1ybr1wKndq8QEX+PiMeS9aeA9YAnfTKzgcBtmJmlKt9EbFxErE3WnwbG7aiypCOAWuDxnOLLJd0v6UpJdTs4dqGkJklNzc3NeYZtZgYUsQ0zM+vNThMxSbdJerCXZW5uvYgIIHZwnvHAD4GzI6IjKb4U2B94NTAauKSv4yNicUQ0RkRjQ4NvRs1s1wyENsw3kmbWl50O1o+IE/raJ2mdpPERsTZppNb3UW848Gvgsoi4O+fcnXeiLZK+B3x4t6I3M9uJgdCGRcRiYDFAY2Njn8memVWefB9NLgHmJ+vzgV90ryCpFvgZ8IOIuKnbvvHJT5Edm/FgnvGYme0Ot2Fmlqp8E7ErgBMlPQackGwjqVHS1UmdM4BjgAWSlifLocm+H0l6AHgAGAt8Ns94zMx2h9swM0uVssMiSktjY2M0NTWlHYaZFYmkeyKiMe04CsHtl1nl2VEb5q84MjMzM0uJEzEzMzOzlDgRMzMzM0uJEzEzMzOzlDgRMzMzM0uJEzEzMzOzlDgRMzMzM0uJEzEzMzOzlDgRMzMzM0uJEzEzMzOzlDgRMzMzM0uJEzEzMzOzlDgRMzMzM0uJEzEzMzOzlDgRMzMzM0uJEzEzMzOzlDgRM7OKJWm0pFslPZb8HNVHvXZJy5NlSU75dEl/lrRC0g2SaosXvZmVg7wSMTdiZlbiFgG3R8RM4PZkuzdbIuLQZDklp/wLwJURsS+wETinf8M1s3KTb4+YGzEzK2VzgWuT9WuBU3f1QEkCjgNu2pPjzcwg/0TMjZiZlbJxEbE2WX8aGNdHvXpJTZLulnRqUjYGeC4i2pLt1cDE3g6WtDA5vqm5ublQsZtZGajO8/jdasSANuCKiPg5u9GIQbYhAxYCTJkyJc+wzaxSSLoN2LuXXZflbkRESIo+TjM1ItZImgHcIekBYNOuxhARi4HFAI2NjX39DjOrQDtNxAZCI5ac3w2Zme22iDihr32S1kkaHxFrJY0H1vdxjjXJz5WS7gIOA34CjJRUndxQTgLWFPwCzKys7fTRZEScEBEH9bL8AliXNF7saiMG3EW2EdtA0ogl1dyImVmxLQHmJ+vzgV90ryBplKS6ZH0scDTwcEQEcCdw+o6ONzPbkXzHiLkRM7NSdgVwoqTHgBOSbSQ1Sro6qXMA0CTpr2TbrCsi4uFk3yXAhyStIDvc4rtFjd7MSl6+Y8SuAG6UdA7wJHAGZBsx4LyIOJdsI/ZtSR1kE7/ujdj1kj4L3IcbMTMroojYABzfS3kTcG6y/kfg4D6OXwkcUciYrvvpKv6yfGOP8rraKi696BWMGF5TyF9nZinLKxEbiI2YmVkpe+75Vu69/zna27sOhR0yOENdrefgNis3/l9tZjaAvOu0yVRXq0tZfV0VC+ZNpb4+k1JUZtZfnIiZmQ0gw4fVcPqbJ1JX+3IylsmIt86ZkGJUZtZfnIiZmQ0w7zptMiibiLk3zKy8OREzMxtgOnvFqjNyb5hZmXMiZmY2AL3rtMlkMnJvmFmZy3f6CjMz6wfDh9Xw3a8dzqTxg9IOxcz6UUUkYhFBewdUZ7TzymZmA8S0yUPSDsHM+llZJ2JbtrbzH99ZwW/uXEdrW3DAfsP4yAX7MXP60LRDMzMzMyvvMWKXfPoBfnPnOra1BhHw8KMvcMEly1n/TEvaoZmZmZmVbyK28smXeOjvL7Cttevs1K2tHfz01/5ucTMzM0tf2SZiq57a0uuYsNa2YMUTL6UQkZmZmVlXZZuITZ88mLa26FFeWyMOmDkshYjMzMzMuirbRGzKpMG86pCRXb4kV4La2ownRzQzM7MBoWwTMYDPXnogp79lIsOGVlNTI448fDSLv3IYo0fVph2amZmZWXlPX1FbU8X5C2Zw/oIZaYdiZmZm1kNZ94iZme2IpNGSbpX0WPJzVC913iBpec6yVdKpyb7vS/pHzr5Di30NZlbanIiZWSVbBNweETOB25PtLiLizog4NCIOBY4DNgO/yanykc79EbG8CDGbWRnJKxHz3aSZlbi5wLXJ+rXAqTupfzpwc0Rs7s+gzKxy5Nsj5rtJMytl4yJibbL+NDBuJ/XnAdd1K7tc0v2SrpRU19tBkhZKapLU1NzcnGfIZlZO8k3EfDdpZgOapNskPdjLMje3XkQE0HPywZfPMx44GLglp/hSYH/g1cBo4JLejo2IxRHRGBGNDQ0N+V6SmZWRfN+a3JO7ya92K7tc0sdJetQiotcvgpS0EFgIMGXKlD2P2MwqSkSc0Nc+SeskjY+ItUmitX4HpzoD+FlEtOacu7P9a5H0PeDDBQnazCrGTnvEBsLdZHJ+31GaWaEtAeYn6/OBX+yg7pl0eyyZtGtIEtknAg8WPkQzK2c77RHz3aSZlbErgBslnQM8SbadQlIjcF5EnJtsTwMmA7/tdvyPJDUAApYD5xUnbDMrF/k+muy8m7yCXbubvDS3ICeJ892kmRVdRGwAju+lvAk4N2f7CWBiL/WO68/4zKz85TtY/wrgREmPASck20hqlHR1Z6Wd3E0+ADwAjAU+m2c8ZmZmZiUjrx4x302amZmZ7TnPrG9mZmaWEidiZmZmZilxImZmZmaWEidiZmZmZilxImZmZmaWEidiZmZmZilxImZmZmaWEidiZmZmZilxImZmZmaWEidiZmZmZilxImZmZmaWkry+a9KsHLW2dvDbPz3DfQ88x14Ndbzp+L0ZO6Yu7bDMzHbqRz9ZxZOrX+pRPnRwNRe8dx8yGaUQle2IEzGzHJu3tHP+R+7jqXVb2LK1g9qaKn7443/ylU++kkMOHJF2eGZmO3Tv/Rv5870be5SPHV3Lhefsk0JEtjN+NGmW44afr2LV2mwSBrCttYOtWzv41JcfISJSjs4KTdLbJT0kqUNS4w7qzZb0qKQVkhbllE+X9Oek/AZJtcWJ3Kx35y2YQV1t14/2QfUZzl8wg6oq94YNRE7EzHL85rfr2bato0f58y+0suqpLSlEZP3sQeBtwO/6qiApA1wFzAFmAWdKmpXs/gJwZUTsC2wEzunfcM12bOb0oRxy4AiUk3MNGZzh+GP2Si8o2yEnYmY5amt6/y8R0fc+K10R8UhEPLqTakcAKyJiZURsA64H5koScBxwU1LvWuDUfgvWbBedf/aM7e1VZ29YtceGDVj+ZDHLceqc8dTXdf1vIcHkiYPYe6/6lKKylE0EVuVsr07KxgDPRURbt3KzVHX2ioF7w0pBXomYx1dYuTnl5Akc1Tiautoq6mqrGDwow+iRtXx20YFph2Z7SNJtkh7sZZlbxBgWSmqS1NTc3FysX2sV7PyzZ2R/ujdswMv3rcnO8RXf7qtCzviKE8neMS6TtCQiHubl8RXXS/oW2fEV38wzJrM9lsmIzyw6kBX/eJGHHn2esaPrOPLwUVRXu/O4VEXECXmeYg0wOWd7UlK2ARgpqTrpFess7y2GxcBigMbGRr/1Yf1u5vShfP1zh3DILL/tPdDl9eni8RVWrvadPpS5sydw9BFjnITZMmBm0oNfC8wDlkT2Ndo7gdOTevOBX6QUo1kPhx880vOGlYBifMIUZHyFu/bNrNAkvVXSauAo4NeSbknKJ0haCpC0URcCtwCPADdGxEPJKS4BPiRpBdk27bvFvgYzK207fTQp6TZg7152XRYRRbv7c9e+mRVaRPwM+Fkv5U8Bb8zZXgos7aXeSrK9/mZme2SnidhAGF9hZmZmVo6K8WjS4yvMzMzMepHv9BUeX2FmZma2h1SK358nqRl4Mu04+sFY4Jm0g0hBpV43VO617+51T42Ihv4KppjKuP3qzv+2K0clXjPs3nX32YaVZCJWriQ1RUSfE+OWq0q9bqjca6/U664klfp3XInXXYnXDIW7bk+QZGZmZpYSJ2JmZmZmKXEiNrAsTjuAlFTqdUPlXnulXnclqdS/40q87kq8ZijQdXuMmJmZmVlK3CNmZmZmlhInYmZmZmYpcSKWIkmjJd0q6bHk56g+6rVLWp4sS4odZ6FImi3pUUkrJC3qZX+dpBuS/X+WNC2FMPvFLlz7AknNOX/P56YRZyFJukbSekkP9rFfkr6e/JncL+nwYsdohVNJ7VmltmVux3rdn3c75kQsXYuA2yNiJnB7st2bLRFxaLKcUrzwCkdSBrgKmAPMAs6UNKtbtXOAjRGxL3Al8IXiRtk/dvHaAW7I+Xu+uqhB9o/vA7N3sH8OMDNZFgLfLEJM1n8qoj2r1LbM7Vif8m7HnIilay5wbbJ+LXBqeqH0uyOAFRGxMiK2AdeTvf5cuX8eNwHHS1IRY+wvu3LtZScifgc8u4Mqc4EfRNbdwEhJ44sTnfWDSmnPKrUtczvWu7zbMSdi6RoXEWuT9aeBcX3Uq5fUJOluSacWJ7SCmwisytlenZT1Wif5jtJNZL+DtNTtyrUDnJZ0bd8kaXJxQkvVrv65WGmolPasUtsyt2O9y7sdqy5oONaDpNuAvXvZdVnuRkSEpL7mEpkaEWskzQDukPRARDxe6FgtVb8ErouIFknvI3s3fVzKMZl14fbMdsLt2B5wItbPIuKEvvZJWidpfESsTboy1/dxjjXJz5WS7gIOA0qt4VoD5N4dTUrKequzWlI1MALYUJzw+tVOrz0icq/zauCLRYgrbbvyb8IGELdnQOW2ZW7Hepd3O+ZHk+laAsxP1ucDv+heQdIoSXXJ+ljgaODhokVYOMuAmZKmS6oF5pG9/ly5fx6nA3dEecw4vNNr7zam4BTgkSLGl5YlwFnJW0evATblPNqy0lMp7VmltmVux3qXdzvmHrF0XQHcKOkc4EngDABJjcB5EXEucADwbUkdZBPnKyKi1BouIqJN0oXALUAGuCYiHpL0aaApIpYA3wV+KGkF2cGR89KLuHB28dovknQK0Eb22hekFnCBSLoOeD0wVtJq4BNADUBEfAtYCrwRWAFsBs5OJ1IrkIpozyq1LXM71n/tmL/iyMzMzCwlfjRpZmZmlhInYmZmZmYpcSJmZmZmlhInYmZmZmYpcSJmZmZmlhInYmZmZmYpcSJmZmZmlpL/D2VbRo0yw2VHAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 生成训练集和测试集\n",
    "X_train, y_train = make_circles(10, noise=0.05, factor=0.2)\n",
    "X_test, y_test = make_circles(10, noise=0.05, factor=0.2)\n",
    "\n",
    "# 将生成的数据集进行可视化\n",
    "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n",
    "ax[0].scatter(X_train[:,0], X_train[:,1], \n",
    "              marker='o', c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)))\n",
    "ax[0].set_title('Train')\n",
    "ax[1].set_title('Test')\n",
    "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)))\n",
    "\n",
    "print(\"先来看一下我们的训练集和测试集:\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "federal-representation",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 初始化进度条\n",
    "bar_format_string = '{l_bar}{bar}|[{elapsed}<{remaining}, ' '{rate_fmt}{postfix}]'\n",
    "pbar = tqdm(total=100, bar_format=bar_format_string)\n",
    "pbar.close()\n",
    "clear_output()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "educated-permission",
   "metadata": {},
   "source": [
    "下面，我们来用 PaddleQuantum 来搭建量子核函数的计算电路："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "every-competition",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "检查是否满足 K(x, x) = 1？ True\n"
     ]
    }
   ],
   "source": [
    "# 初始化一个用来更新进度条的全局变量\n",
    "N = 1\n",
    "\n",
    "# 通过 paddle quantum 模拟的 QKE 电路\n",
    "def q_kernel_estimator(x1, x2):\n",
    "    \n",
    "    # 将数据类型转换为 tensor\n",
    "    x1 = paddle.to_tensor(x1)\n",
    "    x2 = paddle.to_tensor(x2)\n",
    "    \n",
    "    # 创建电路\n",
    "    cir = UAnsatz(2)\n",
    "    \n",
    "    # 添加对应第一个数据的编码电路\n",
    "    cir.iqp_encoding(x1, pattern=[[0, 1]])\n",
    "    \n",
    "    # 添加对应第二个数据的编码电路的逆电路\n",
    "    cir.iqp_encoding(x2, pattern=[[0, 1]], invert=True)\n",
    "    \n",
    "    # 用态矢量模式运行电路\n",
    "    fin_state = cir.run_state_vector()\n",
    "    \n",
    "    # 更新进度条\n",
    "    global pbar\n",
    "    global N\n",
    "    pbar.update(100/N)\n",
    "    \n",
    "    # 返回测量结果为 0...0 的概率\n",
    "    return (fin_state[0].conj() * fin_state[0]).real().numpy()[0]\n",
    "\n",
    "# 按照规范定义需要传入的 Kernel 矩阵函数\n",
    "# 按照规范，输入应为两个数据列表\n",
    "def q_kernel_matrix(X1, X2):\n",
    "    return np.array([[q_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])\n",
    "\n",
    "# 可视化决策函数（预测值），以及决策边界\n",
    "def visualize_decision_bound(clf):\n",
    "    \n",
    "    # 创建一个 10x10 的网格\n",
    "    x_min, x_max = X_train[:,0].min(), X_train[:,0].max()\n",
    "    y_min, y_max = X_train[:,1].min(), X_train[:,1].max()\n",
    "    XX, YY = np.meshgrid(np.linspace(-1.2, 1.2, 10), \n",
    "                         np.linspace(-1.2, 1.2, 10))\n",
    "    \n",
    "    # 计算分类器该网格上的预测值\n",
    "    Z = clf.decision_function(np.c_[XX.ravel(), YY.ravel()])\n",
    "    Z_qke = Z.reshape(XX.shape)\n",
    "    \n",
    "    # 可视化决策函数，以及决策边界\n",
    "    clear_output()\n",
    "    plt.contourf(XX, YY, Z_qke ,vmin=-1., vmax=1., levels=20,\n",
    "                 cmap=matplotlib.cm.coolwarm, alpha=1)\n",
    "    plt.scatter(X_train[:,0], X_train[:,1], \n",
    "                c = matplotlib.cm.coolwarm(np.array(y_train, dtype=np.float32)),\n",
    "               edgecolor='black')\n",
    "    plt.scatter(X_test[:,0], X_test[:,1], marker='v', \n",
    "                c = matplotlib.cm.coolwarm(np.array(y_test, dtype=np.float32)),\n",
    "               edgecolor='black')\n",
    "    plt.contour(XX, YY, Z_qke, colors=['k', 'k', 'k'], linestyles=['--', '-', '--'],\n",
    "                levels=[-.2, 0, .2])\n",
    "\n",
    "# 作为检查量子核函数是否运行正常，我们可以检查 K(x, x) 是否等于 1\n",
    "# 提示：根据内积的定义 <x, x> = 1\n",
    "print('检查是否满足 K(x, x) = 1？',\n",
    "      bool(abs(q_kernel_estimator(np.array([1. ,1.]), np.array([1., 1.])) - 1) < 1e-8))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "requested-cameroon",
   "metadata": {},
   "source": [
    "接下来，让我们尝试用量子核支持向量机（QKE-SVM）来进行数据分类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "caring-daily",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "让我们看一下量子核支持向量机的分类效果如何:\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建进度条，并设置所需要的量子核函数计算数量 N\n",
    "pbar = tqdm(total=100, \n",
    "            desc='训练 QKE-SVM 并分类中', \n",
    "            bar_format=bar_format_string)\n",
    "N = len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test)\n",
    "\n",
    "# 创建一个具有量子核函数的支持向量机\n",
    "svm_qke = svm.SVC(kernel=q_kernel_matrix)\n",
    "\n",
    "# 根据训练数据计算支持向量机的决策平面\n",
    "svm_qke.fit(X_train, y_train)\n",
    "\n",
    "# 计算支持向量机分别对于训练数据和测试数据的分类预测值\n",
    "predict_svm_qke_train = svm_qke.predict(X_train)\n",
    "predict_svm_qke_test = svm_qke.predict(X_test)\n",
    "\n",
    "# 计算准确率\n",
    "accuracy_train = np.array(predict_svm_qke_train == y_train, dtype=int).sum()/len(y_train)\n",
    "accuracy_test = np.array(predict_svm_qke_test == y_test, dtype=int).sum()/len(y_test)\n",
    "\n",
    "# 可视化分类预测结果\n",
    "pbar.close()\n",
    "clear_output()\n",
    "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n",
    "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n",
    "              c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_train, dtype=np.float32)))\n",
    "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n",
    "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n",
    "              c = matplotlib.cm.coolwarm(np.array(predict_svm_qke_test, dtype=np.float32)))\n",
    "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n",
    "print(\"让我们看一下量子核支持向量机的分类效果如何:\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "distinguished-dependence",
   "metadata": {},
   "source": [
    "更进一步的，我们还可以检查此时的决策函数平面以及决策边界："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "universal-genome",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "计算 QKE-SVM 的决策函数中: 100%|█████████████████████████████████████████████████████████████▉|[01:26<00:00,  1.16it/s]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建进度条，并设置所需要的量子核函数计算数量 N\n",
    "pbar = tqdm(total=100, \n",
    "            desc='计算 QKE-SVM 的决策函数中', \n",
    "            bar_format=bar_format_string)\n",
    "N = 10 ** 2 * len(X_train)\n",
    "    \n",
    "# 可视化决策函数平面\n",
    "visualize_decision_bound(svm_qke)\n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "transsexual-swift",
   "metadata": {},
   "source": [
    "可以看到，量子核函数可以很好的学习到数据中的非线性特征。实际上，量子核方法的表现取决于量子特征映射的设计。并且，对于如何设计更好的量子核函数的探究才刚刚开始：一方面，我们可以尝试不同的数据编码方式；另一方面，我们可以尝试通过训练量子特征映射的方式提升分类效果 [5-6]；最后，我们还可以尝试一些不同的量子核函数形式 [7]。\n",
    "\n",
    "下面，作为拓展，我们也将展示一种特殊的量子核函数:投影量子核函数（projected quantum kernel）。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "scenic-circuit",
   "metadata": {},
   "source": [
    "### 拓展：投影量子核函数\n",
    "\n",
    "上文中已经提到，量子核方法通过将经典信息映射到潜在的高维量子特征空间来分辨在经典空间不可分的信息。但是，当我们的量子特征空间-希尔伯特空间的维度太大的时候，所有映射到希尔伯特空间的量子态都会接近于相互垂直的状态，此时的核矩阵将会近似的变成一个单位矩阵 $K_{ij} = K(\\mathbf{x}_j, \\mathbf{x}_i) \\sim {I}$。为了避免这种维度问题的出现，我们需要首先从高维希尔伯特空间提取出足够的低维信息。投影量子核方法就是遵循了这个思路，即将量子态投影到新的经典空间，再在这个新的经典空间使用核方法。我们可以认为每一个投影是从不同的角度去观测希尔伯特空间的量子态，从足够多的角度测量这个量子态可以使我们获得足够重构这个态的经典信息。但在实际应用中，通常只需要从几个角度测量就能得到比较好的结果 [5]。 由于这个经典空间保留了部分希尔伯特空间中的重要特征，所以信息在这个经典空间的可分性优于原来的经典空间。\n",
    "\n",
    "投影量子核函数有很多不同的形式，这里我们举一个最为代表性的作为例子：\n",
    "\n",
    "$$\n",
    "K^{PQ}(x_i,x_j) = \\exp\\left(-\\gamma\\sum\\limits_{k}\\sum\\limits_{P\\in \\mathcal{M}}( {\\rm Tr} (P\\rho(x_i)_k)-{\\rm Tr}(P\\rho(x_j)_k))^{2}\\right),\n",
    "\\tag{13}\n",
    "$$\n",
    "\n",
    "其中 $k$ 是用来标记多量子比特约化密度矩阵的下标，$\\mathcal{M}$ 是一个作用在多量子比特约化密度矩阵上的测量的集合。在这里，我们取 $k = 0, 1$，即两个单量子比特的约化密度矩阵，$M = \\{X, Y, Z \\}$，即一组 Pauli 测量。\n",
    "\n",
    "我们先尝试用 Paddle Quantum 来实现对应的投影量子核电路："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "artificial-hierarchy",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 因为这次我们的特征映射的特征空间也是经典的，我们不妨先把该映射写出来\n",
    "def projected_q_feature_map(x):\n",
    "    cir = UAnsatz(2)\n",
    "\n",
    "    # 将经典数据转换为 Tensor\n",
    "    x = paddle.to_tensor(x)\n",
    "    \n",
    "    # 编码经典数据到对应的量子态上\n",
    "    cir.iqp_encoding(x, pattern=[[0, 1]])\n",
    "    \n",
    "    # 运行电路\n",
    "    cir.run_state_vector()\n",
    "    \n",
    "    # 更新进度条\n",
    "    global N\n",
    "    pbar.update(100/N)\n",
    "    \n",
    "    # 进行投影测量，返回其期望值作为经典特征向量\n",
    "    return [cir.expecval([[1.0, op_pauli]]).numpy()[0] \n",
    "            for op_pauli in ['z0', 'z1', 'x0', 'x1', 'y0', 'y1']]\n",
    "\n",
    "# 按照上文公式计算投影量子核函数\n",
    "def p_quantum_kernel_estimator(x1, x2):\n",
    "    \n",
    "    # 分别得到特征向量，并计算核函数\n",
    "    p_feature_vector_1 = np.array(projected_q_feature_map(x1))\n",
    "    p_feature_vector_2 = np.array(projected_q_feature_map(x2))\n",
    "    \n",
    "    return np.exp(-((p_feature_vector_1 - p_feature_vector_2) ** 2).sum())\n",
    "\n",
    "# 类似地，按照规范定义传入支持向量机的核函数\n",
    "def p_quantum_kernel_matrix(X1, X2):\n",
    "    return np.array([[p_quantum_kernel_estimator(x1, x2) for x2 in X2] for x1 in X1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "baking-bridges",
   "metadata": {},
   "source": [
    "接下来，让我们看一下如何用投影量子核支持向量机（PQK-SVM）来进行数据分类："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "chronic-terrorist",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "让我们看一下投影量子核支持向量机的分类效果如何:\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmIAAAEICAYAAAD80ZhHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAxCElEQVR4nO3deZwU9Z3/8ddnei7uc0DuQ0BBjddE45qoUVQ0iWg0ijkEV5fo6s9sNFkxhzEeCdkcmmxcI0GiySYeMYckIUu8cxiVUYkHSkQC4RIGBBSBYY7P74+qgZqe7plhuqdruvv9fDz6Md3f+lbNp7p7PvPpb32r2twdEREREcm9krgDEBERESlWKsREREREYqJCTERERCQmKsREREREYqJCTERERCQmKsREREREYqJCrA1mdreZ3Rze/4CZLe/kdn5gZl/ObnTdj5l9wczmZ7uviGRGuSw7lLekK+R9IWZmq8xsl5ntMLONYcLpne3f4+5/cveDOhDPLDP7c9K6l7n7TdmOKZvM7AkzuzSTbbj719y9Q9vYn765YGYnmdnauOPIJ2b2QTN73My2m9mqDvQ/xcxeM7Od4XpjIssqzGyBmb1tZm+a2dVdGnw3pFyWHdnIZeF2WuUE5a381x3zVt4XYqGPuHtv4CigGvhScgczK815VAVEz1/3YoG4/37fBRYAn2+vo5kNBn4JfBkYCNQA90e63ABMBMYAHwT+08ymZTnefKBcJgVLeSsNd8/rG7AKmBp5/E3gt+F9B64AXgf+EbZ9GFgKbAOeAt4TWfdI4HngnfDJvg+4OVx2ErA20ndU+ALVAluA7wOTgd1AI7AD2Bb2vbt5O+HjfwNWAG8BC4HhkWUOXBbGvA24HbA0+14B3AasD2+3ARXReIFrgE3ABuDiNNu5JYx5dxj399t4/r4LrAHeBp4DPhDZzg3A/4b3x4brzwT+CWwGvtjJvj2Ae4CtwKvAf0Zfi6R9MeDWcJ/fBl4CDo08X98Kf8dG4AfhtnsBu4CmcP93RF+TNt57c4A3wvfLMuCcpOX/FsbbvPyodO+d5Ock6XkpDR8/Eb5WfwnjnQBcHPkdK4FPJ8UwneD9/nYY6zTgY8BzSf2uBh7q5N/gVGBVO31mA09FHjc/5weHj9cDp0WW3wTcF3d+yeUN5bLb6LpcdjDwcBjncuD8yDpnEvx9vgOsAz5HmpyA8pbyVhfkrdiTT6Y3IskrfKO8AtwUPnaCP76B4Rv3yPCNfiyQCP+AVoVv9HJgNfBZoAw4D6gnRfIK1/1b+IfTC6gE3h8umwX8OSnGuyPbOZngD/ao8Pf+N/DHSF8Hfgv0B0aHb/ppafb9RuBpYAhQRZCMb4rE2xD2KSNINjuBAWm29QRwaVJbi+cvbPskMAgoJUiMbwKVyX+Q7Ptj/GH43B8O1AGTO9F3LvAkMAAYCbxI+oR2OkGB2J8guU0GhoXLbiX4ZzEQ6AP8Bvh68uu7H++9jxEk5xLgAoJPWsMiy9YB7w3jmEDwqamt987e5yTpeYkmtH8Ch4TPfxnwIeDA8HecGL7GzYnzGGA7cGoY4wiCf0gVBP+QJkd+1wvAueH9OQT/OFPeUjwPHUlo3wXuSGp7GTg3fF0dGBpZdh7wUtz5JZc3lMu6JJeF+7WG4J9/afjcbQamhMs3EH6gDN+LRyU/T5Ft3YDylvJWlvNW7Mkn0xtB8tkRPtmrgf9hX9HgwMmRvncQ/nFH2paHb4QTCKpbiyx7itTJ6ziCpFKaIp5ZtJ287gL+K7KsN0GSHBuJ+f2R5Q8Ac9Ls+xvAmUl/zKsi8e6KxkiQuN+XZltPkLoQOzlV/0ifrcDh4f0baJ2kRkb6PgvM6ETflcDpkWWXkj6hnQz8HXgfUBJpN4KEc2Ck7Tj2jS6clG6b+/FeXApMD+8vBj6Tok9b7529z0nS8xJNaDe2E8Ovm38vcCdwa5p+dwC3hPcPCV/Hik7ud0cS2l3A3KS2vxD8vYwK97MysuzU9rZZaDeUy7oklxEUG39K6nMn8JXw/j+BTwN9k/rsfZ4ibXv/RlHeavWcJD0vylsdvMV9rDZbznb3/u4+xt3/3d13RZatidwfA1xjZtuabwRP5vDwts7DZzO0Os3vGwWsdveGTsQ6PLpdd99BMMw7ItLnzcj9nQQJrt1thfeHRx5vSYqxrW2lE33+MLPPmdmr4UTHbUA/YHAb63d0X9rqOzwpjhYxRbn7YwSHVm4HNpnZPDPrS/ApuyfwXOS1/7+wvVPM7CIzWxrZ3qHsey5GEfxzSZbJewdavx5nmNnTZvZWGMOZHYgBgkMmHzczAz4FPODudZ2MqSN2AH2T2voSHJrYEXmcvKzYKJcFspnLxgDHJj1XnwAOCJefS/B3s9rMnjSz4zq43WbKW+1T3mpDoRRibYkmozUE1XT/yK2nu99LMDw9InyBm41Os801wOg0k2Y9RVvUeoLEAICZ9SI41LeuvR1pb1sE8a7vxHYgfdx7283sAwTzHM4nOCzQn2AI2VKvmjUbCIb2m41qq7O7f8/djwamAJMIJmVuJvhUfUjkte/nwcRoaP91ayE8c+aHwJXAoPC5eJl9z8UagqH3ZG29d94lSLrNDkjRJ/p6VAC/IJg/MjSMYVEHYsDdnwb2AB8APg78JLLdL4Rn7qW8pdpeB7xCcOim+Xf0CmN7xd23ErzGh0f6Hx6uI/sol3VMctxrgCeTnqve7n45gLsvcffpBIdFf00wcpdqO/tLeSuye5EYlLeSFEMhFvVD4DIzOzY8e6OXmX3IzPoAfyWYh3CVmZWZ2UcJjlWn8izBCzA33EalmR0fLtsIjDSz8jTr3gtcbGZHhG/IrwHPuPuqTuzPvcCXzKwqPLvjeuB/O7EdCOIe306fPgTPUS1QambX0/rTQld4ALjOzAaY2QiCJJKSmb03fH3LCBLEbqDJ3ZsIXv9bzWxI2HeEmZ0erroRGGRm/SLbOsnM0iW6XgTJpTbsezHBJ8tm84HPmdnR4XttQpgE23rvLAVOMLPRYRzXtfO8lBPMm6gFGszsDOC0yPK7CN5rp5hZSbi/B0eW/5jgU3i9u++9TIEHp+j3TneLPD8lZlZJMOfDwn1J977/FXComZ0brnM98KK7vxaJ5Uvha3wwwYThu9vZ/2KmXJZeci77LTDJzD4VPh9lYZ6YbGblZvYJM+vn7vUEk8ObIttpkRP2k/JWaspbSYqqEHP3GoIn6vsEx5ZXEBzrxd33AB8NH79FMK/gl2m20wh8hGAi4z8Jzui5IFz8GEFF/KaZbU6x7iMEp8L+guCNfSAwo5O7dDPB6bQvEpxl83zY1hnfBc4zs61m9r00fRYTDIv/neDQwW7aGG7PohsJnuN/AI8ADxJMik2lL0Hi2hrGuIXg7DOAawle86fN7O1wWwcBhH9Y9wIrLRiyH07wCfapVL/E3ZcB3yb4p7cROIxg7kDz8p8TnCn0M4Kh6l8DA9t677j7wwRnuL1IMHH3t209Ke7+DnAVQcLfSvAJcWFk+bMEE5RvJRi5fJKWow4/IUjCnf2HdwLBp/VFBCMYu4A/NC80s1fM7BNhLLUEh4BuCWM9lpbv+68QHI5YHcb5TXf/v07GVfCUy9rUIpeFfyenhbGtJziU+A2CYgCCQ1yrwpxwGcFhy3Q5YX8ob6WOQXkribWcRiDS/ZnZ5QQTYk/s4t8zH/i5uy/uyt8TFzPrQTDp+Sh3fz3ueEQKmfJWdhRi3tKFAaXbM7NhBIca/kpw8bxrCEYCupR3oytod5HLgSWFksxEuhPlrS5TcHlLhZjkg3KCU5rHEZzafx/Bqf3SSRZ8tYcBZ8cbiUjBUt7KskLNWzo0KSIiIhKTopqsLyIiItKd5OWhycGDB/vYsWPjDkNEcuS5557b7O6dvohld6L8JVJ82sphWSnEzGwBwRfQbnL3Q1MsN4JTipu/I2yWuz8fLpsJfCnserO739Pe7xs7diw1NTXZCF1E8oCZpbsyfN5R/hIpPm3lsGwdmryb4NvR0zmD4KyRiQTfZn5HGNhAgutwHEtwwcGvmNmALMUkIiIi0q1lpRBz9z8SXDgwnenAjz3wNNA/PLX3dOBhd38r/LqAh2m7oBMREREpGLmarD+ClldgXxu2pWtvxcxmm1mNmdXU1tZ2WaAiIiIiuZI3Z026+zx3r3b36qqqgpizKyIiIkUuV2dNrqPlN8+PDNvWAScltT+Ro5hEUqqra2T5Gzvo1TPB+DG9CM41ERGJX319Ey+99jbe1PoaoKNG9GTI4IoUa0l3lqtCbCFwpZndRzAxf7u7bzCzxcDXIhP0T6P9b24X6TL/99ibfPuOFZSUQGOjUzW4gm995TBGDOsRd2giIqxas5OrvvA3evVMEP2MuHt3E2dNG8bVl02MLzjplGxdvuJegpGtwWa2luBMyDIAd/8Bwbecn0nwDfI7Cb5ZHXd/y8xuApaEm7rR3dua9C/SZV5fuYNv/s/r1NU17W1bu34X//GlF7n/h8dQUqKRMRGJ18TxvTl4Yh9ee/2dFu3l5SWcf9bImKKSTGTrrMkL3X2Yu5e5+0h3v8vdfxAWYYRnS17h7ge6+2HuXhNZd4G7TwhvP8pGPCKd8cvfraO+vqlFmztsf6eel197O6aopKuZ2QIz22RmL6dZbmb2PTNbYWYvmtlRkWUzzez18DYzd1FLMbvi4vFUVuz7950ogfcfO4iRwzVyn4/yZrK+SFfbsnUPTU2t281g+9v1uQ9IcuVudB1EySNHHtafsaN77X2cKC1h9ifHxRiRZEKFmEjo+PcOavEps1l9fROHHtw3hogkF3QdRMlHzaNiGg3LfyrERELTTh7KsKGVVJTv+7OorCjhE+eOZkD/8hgjk5jpOojS7TSPirmj0bA8l5df+i3SFSoqEsz79lH8+vfreeIvtfTpXca5Hx7OcdWD4g5N8py7zwPmAVRXV7e+7oBIJ3zu3yfy7AtbNRqW51SIiUT0qExw4TmjuPCcUe13lmKh6yBKt3TwhD4cPKFP3GFIhnRoUkSkbQuBi8KzJ99HeB1EYDFwmpkNCCfpnxa2iYh0mEbERKSo6TqIIhInFWIiUtTc/cJ2ljtwRZplC4AFXRGXiBQHHZoUERERiYkKMREREZGYqBATERERiYkKMREREZGYqBATERERiYkKMREREZGYqBATERERiYkKMREREZGYqBATERERiUlWCjEzm2Zmy81shZnNSbH8VjNbGt7+bmbbIssaI8sWZiMeERERkXyQ8VccmVkCuB04FVgLLDGzhe6+rLmPu3820v//AUdGNrHL3Y/INA4RERGRfJONEbFjgBXuvtLd9wD3AdPb6H8hcG8Wfq+IiIhIXstGITYCWBN5vDZsa8XMxgDjgMcizZVmVmNmT5vZ2el+iZnNDvvV1NbWZiFsERERkXjlerL+DOBBd2+MtI1x92rg48BtZnZgqhXdfZ67V7t7dVVVVS5iFREREelS2SjE1gGjIo9Hhm2pzCDpsKS7rwt/rgSeoOX8MREREZGClY1CbAkw0czGmVk5QbHV6uxHMzsYGAD8NdI2wMwqwvuDgeOBZcnrioiIiBSijAsxd28ArgQWA68CD7j7K2Z2o5mdFek6A7jP3T3SNhmoMbO/AY8Dc6NnW4qI5IIuwSMiccn48hUA7r4IWJTUdn3S4xtSrPcUcFg2YhAR6QxdgkdE4qQr64tIsdMleEQkNirERKTYdfkleHT5HRFJR4WYiEjHdeoSPLr8joiko0JMRIqdLsEjIrFRISYixU6X4BGR2GTlrEkRkXzl7g1m1nwJngSwoPkSPECNuzcXZekuwXOnmTURfLDVJXhEZL+oEBORoqdL8IhIXHRoUkRERCQmKsREREREYlKwhyYbGp1nnnuLTZvrmDKpDwdN6BN3SCIiIiItFGQhtv7NXVwxZynv7myksbEJM+PIw/rz9S8eQmmpBgFFRESkeyjIquQr33yVLVv3sHNXI3V7nN11TTz/0jYeWJju0kAiIiIiuVdwhdhbW/ew4h87aGpq2V5X18RvFm+IJygRERGRFAquEKtvCA5FplsmIiIi0l0UXCE2ZHAFVYPKW7WXlRlTPzAkhohEREREUiu4QszMuOFzk+nZI0FFebB7PSpLGH5ADz51/uiYoxMRERHZpyDPmpw8qS/3//AYfv/oRjZs3MV7pvTnpH8ZTFlZwdWdIiIikseyUpmY2TQzW25mK8xsTorls8ys1syWhrdLI8tmmtnr4W1mNuIBGNCvnI9/dBTXXD6JU08coiJMREREup2MR8TMLAHcDpwKrAWWmNnCFF98e7+7X5m07kDgK0A14MBz4bpbM41LREREpLvLxqHJY4AV7r4SwMzuA6YDyYVYKqcDD7v7W+G6DwPTgHuzEJeISN7787ObWfbaO63aE6XGBdNH0rtXQc4wESka2fgLHgGsiTxeCxybot+5ZnYC8Hfgs+6+Js26I1L9EjObDcwGGD1ak+5FpDgseWErv/zdetxbticSxrkfSpkuRSSP5Gri1G+Ase7+HuBh4J793YC7z3P3anevrqqqynqAIiLd0UXnj2k1x7WszJg+bRj9+5XFFJWIZEs2CrF1wKjI45Fh217uvsXd68KH84GjO7quiEhX644nHDUbNKCcD009gLLSfReqNjNmXjAm279KRGKQjUJsCTDRzMaZWTkwA1gY7WBmwyIPzwJeDe8vBk4zswFmNgA4LWwTEcmJyAlHZwBTgAvNbEqKrve7+xHhbX64bvMJR8cSzJf9SpjLsmrWjDFYSVCIlZUZHz71AAYNaH3hahHJPxkXYu7eAFxJUEC9Cjzg7q+Y2Y1mdlbY7Soze8XM/gZcBcwK130LuImgmFsC3Ng8cV9EJEf2nnDk7nuA5hOOOmLvCUfh2d7NJxxlVfOoWGnCNBomUmCycrqNuy8CFiW1XR+5fx1wXZp1FwALshGHiEgndPkJR9k42WjWjDEsXLxBo2EiBUZXORURaV9GJxxl42SjQQPK+eb1h3LpJ8d2an0R6Z5UiIlIscubE46OOWogfXvrTEmRQqJCTESKnU44EpHY6JLMIlLU3L3BzJpPOEoAC5pPOAJq3H0hwQlHZwENwFtETjgys+YTjkAnHInIflIhJiJFTycciUhcdGhSREREJCYqxERERERiokJMREREJCYqxERERERiokJMREREJCYqxERERERiokJMREREJCYqxERERERiokJMREREJCYqxERERERiokJMREREJCYqxERERERikpVCzMymmdlyM1thZnNSLL/azJaZ2Ytm9qiZjYksazSzpeFtYTbiEREREckHpZluwMwSwO3AqcBaYImZLXT3ZZFuLwDV7r7TzC4H/gu4IFy2y92PyDQOERERkXyTjRGxY4AV7r7S3fcA9wHTox3c/XF33xk+fBoYmYXfKyIiIpLXslGIjQDWRB6vDdvSuQT4feRxpZnVmNnTZnZ2upXMbHbYr6a2tjajgCX/vPnQI/z52I/yyKjjqfnYlbzz6htxhyQiIpKxnE7WN7NPAtXANyPNY9y9Gvg4cJuZHZhqXXef5+7V7l5dVVWVg2ilu1h1x0954aJr2P78K9S9uZmNDz3CX/7lPHa8pmJMskPzXEUkLtkoxNYBoyKPR4ZtLZjZVOCLwFnuXtfc7u7rwp8rgSeAI7MQkxSIpj17WP6l79C0c/e+Rncad+7m71/9XnyBScGIzHM9A5gCXGhmU5K6Nc9zfQ/wIME812a73P2I8HZWToIWkYKRjUJsCTDRzMaZWTkwA2jxqdDMjgTuJCjCNkXaB5hZRXh/MHA8EJ3kL0Vu1z834I1NrRc0NbH16aU5j0cKkua5ikhsMi7E3L0BuBJYDLwKPODur5jZjWbW/Onwm0Bv4OdJw/eTgRoz+xvwODA36WxLKXLlQwbhDQ0pl/UYPTzH0UiB6vJ5rprjKiLpZHz5CgB3XwQsSmq7PnJ/apr1ngIOy0YMUpjK+vZm+IwPs/6BRTTt2nd4MtGzkglfuDzGyKQYRea5nhhpHuPu68xsPPCYmb3k7i0mMLr7PGAeQHV1tecsYBHp9rJSiIl0pUNv/ypWYqy797dQYiQqKpj8X9cy5PQT4g5NCsP+znM9Md08VzN7gmCeq84kEZEOUSEm3V6iopz3zPsaU77zRerf2k7F8CGUlOqtK1mzd54rQQE2g+As7r0i81ynJc9zBXa6e11knmt0Ir9IC++uWE3D9ndatZcN6EfP8aNSrCGFTv/NJG+U9u5Fae9ecYchBcbdG8yseZ5rAljQPM8VqHH3hbSc5wrwz/AMycnAnWbWRDDnVvNcpU1/+ZfzaNy9h5Kyff9+m+rrKR/Yn1NW/THGyCQuKsREpOhpnqvkytgrL+KNb82n4e0de9sSvXow7j8ujjEqiZMKMRERKUg7XnuDPVu2tWov69eHPodOyn1AwLjPzGLldxa0aLPSUsZ8+sJY4pH4qRAT3n5pOcuuvoWtT71Aok9Pxv77J5nwhcs1D0tE8tqzH7qUutotlJSX723z+nqsrIzTN9fEElNZvz6Mv/pfeeNb82natZtErx5M/NIVJHpUxhKPxC+nX3Ek3c/OVWt56sQL2fLEMzTt2UP9lm288a35vHjpF+IOTUQkI+M//29YSQkN29/Ze3OCUak4jfvMLKwk+Per0TBRIVbkVt72I5p217Voa9q1mw0P/p7d6zfGFJWISOZGXXweJRUVLdrMSmIvxJpHxQCNhokKsWK3fclLeH3rK9eXVFawY/nKGCISEcmOREU5k776GRK9egBQ0rOS8ddcQlnf3jFHFoyKDfvYGRoNExVixa7v4QdDaaJVe1PdHnpNGJv7gEREsig6KtYdRsOalfXrw1E/u02jYaJCrNiN/+y/kqgob9FW0qOCqmkn0GPUsJiiEhHJjuZRMaDbjIaJRKkQK3K9Jo7l2MX30PfIKWBGomclo/71fI783+/EHZqISFaMuvg8Rl50TrcZDROJ0vUJhAHHHs4Hnv0V3tgIJSWEVw4XESkIiYpyDr9rbtxhiKSkQkz2skTruWIiIiLSdXRoUkRERCQmKsREREREYqJDkyIiIiJt2La9njk3v8zuusZWy449aiCXzxrf6W1npRAzs2nAd4EEMN/d5yYtrwB+DBwNbAEucPdV4bLrgEuARuAqd1+cjZhEOuKtp55n7d2/oGHnLoZ/7EyGfuTkvV89IiIiAtCrZ4K1G3axbXt9i/bSUuPE4wZntO2MCzEzSwC3A6cCa4ElZrbQ3ZdFul0CbHX3CWY2A/gGcIGZTQFmAIcAw4FHzGySu7cuOUWy7PWv/Q9vfGMejbt2gzubfvs4g08+jqMf/L6KMRER2ausrITZnxrLf89/g127m/a1l5Zw/vSRGW07G/9tjgFWuPtKd98D3AdMT+ozHbgnvP8gcIoF10iYDtzn7nXu/g9gRbg9kS61a+2brPj6HTTu3AXuADS+u5PNj/2V2of/HHN0ha+pyfHweRcRyQdnnHwAFRX7ri5QUV7Cxz86kl49MxvTykYhNgJYE3m8NmxL2cfdG4DtwKAOriuSdZsf+UvKy3U0vruTjQsfjSGi4rDuzV189ssvctI5f+SD5/yJ67+xjO1v17e/Yhczs2lmttzMVpjZnBTLK8zs/nD5M2Y2NrLsurB9uZmdntPARSRnmkfFelQGpVNJiWU8GgZ5dNakmc02sxozq6mtrY07HMlzpb17QqrDj6UJSvUVKF1i584GPn3NCzz34laamqCh0fnjXzdzxZylNDXFNzoWmV5xBjAFuDCcNhG1d3oFcCvB9AqSpldMA/4n3J6IFKDmUbHShGVlNAyyU4itA0ZFHo8M21L2MbNSoB/BpP2OrAuAu89z92p3r66qqspC2FLMhpx5Usr2krJSRn7qnNwGUyT+8ORGdtc10rRvegUNjc7GzXU89+K22OJC0yskj/3j+z/md5WTW90WVU5h428fizu8gtM8KlZenvncsGbZKMSWABPNbJyZlRN8OlyY1GchMDO8fx7wmAcTRBYCM8Jh/3HARODZLMQk0qZEzx4cs3Aepf16U9qnN6V9elFSWcEht36JPlMmxB1eQVq5eie765patTc2Ov9ctzOGiPbq8ukVGtGXrlJ16vspKS2FxqYWt5KKMgYef3Tc4RWkj5w2jJ/94L1ZGQ2DLJw16e4NZnYlsJjg8hUL3P0VM7sRqHH3hcBdwE/MbAXwFkGxRtjvAWAZ0ABcoTMmJVcGvr+aqev+yuZHn6Jpdx2DTz6Osv594w6rYE0a35selSUtzjgCSJQY40b3iimq3HD3ecA8gOrqap2lIFnT+6DxDDnzJDYufDT4vmCgpLKCsf/vIsoG9Is5usJkZgweWJG17WWlnHP3RcCipLbrI/d3Ax9Ls+4twC3ZiENkfyUqyhma5jClZNcpJwzhhz9dRd2ePXsPT5aVGiOH9+DIQ2P9h7E/0yvWdnZ6hUhXOeimz7Lp90/uLcSspIQDr7k05qiko/Jmsr6I5LcelQnmf+coTjxuMOVlJfSoTHDGKUP5/tcPJ5huFRtNr5C81vug8Qw540QskQhHwz6l0bA8oq84EpGcqRpUwU1zDok7jBY0vaLwNDU0sP5nvwku1pyk54GjqZp6fAxRda2DbvosmxY9odGwPKRCTPabu9Ow/R1KelSSqCiPOxyRjGl6RWHx+gZeuvIGaGyEyPUCvb6eQSceW5CFWO+DxnPAuafTa8JYjYblGR2alP2y5clneGLK6Tw8/Dj+MOholl58LQ073o07LBGRvRI9Khn3mVmQKKFp1+69t5LyMibd8Jm4w+syR9z9TSZ9+cq4w5D9pEJMOuydZStYctZsdq5Yjdc30FS3hw0/X8TzF1wVd2giIi0ceM0lmEX+xZnR98hDGPC+I2KLqavFPNdSOkmFmHTYP277EU11Lb+OpqluD1v+tISdK9ekWUtEJPfK+vdl7FUzKekRXGYg0aOCyXP/M+aoRFpTISYdtuO1N/aeHh1VUl7OztVrY4hIRCS96KhYoY+GSf5SISYd1v+4I7HyslbtTbvr6D1ZV6MXke6leVQM0GiYdFs6a1I6bPxVs1iz4Oc0NDTSfEXORM9Khn/8LCoP0Pd/ikj3c+DnLqVy5AEaDZNuSyNi0mGVI4by/qceZOhZp1Darw89Rg9n0lf/g8Nu/2rcoYmIpFTWrw9jP31h3GGIpKURMdkvvSaOpfrn34/t9zfu3MXmx58GdwZ98H2U9uoZWywiIiKZUiEmeWPT75/k+Y//B1YSDOR6YyNH/uTbDP3IKTFHJiLSts2P/ZUdr61s1V5SXsaIT52ti2MXMRVikhfqat/iuRlX0bSz5VeWPP+Jq/ng3x/RHDUR6dZW33kvGxc+gpXu+7fr4VzbYR87Q4VYEdMcMckLGx78feoF7mx4YFHqZSIi3cSkL1+JlZXRtLtu783MGPPpCynr1yfu8CRGKsQkLzTueBff09CqvWlPvb5iSUS6vT6HTmLwB98HJZF/uyXGhDmXxReUdAsqxCQvVJ12AlbW+kh6orKCIaefEENEIiL75+BbrqEkPARZUlHO6EsvoGLIoJijkripEJO80Pfwgxn5qbNJ9Oqxty3RqyfDzj+TfkcfGmNkIiId02JUTKNhEtJkfckbh37/Bg6YPpW1P/k17s7IT06nSqNhIpJHDr7lGjYtekKjYbJXRoWYmQ0E7gfGAquA8919a1KfI4A7gL5AI3CLu98fLrsbOBHYHnaf5e5LM4lJCpeZUXXaB6g67QNxhyIFQjlMcq3PoZN4z/yvM/TDH4w7FOkmMj00OQd41N0nAo+Gj5PtBC5y90OAacBtZtY/svzz7n5EeFuaYTwiIvtDOUxybtTMj1I+aEDcYUg3kWkhNh24J7x/D3B2cgd3/7u7vx7eXw9sAnTRJxHpDpTDRCRWmRZiQ919Q3j/TWBoW53N7BigHHgj0nyLmb1oZreaWUUb6842sxozq6mtrc0wbBERIIc5TEQklXYLMTN7xMxeTnGbHu3n7g54G9sZBvwEuNjdm8Lm64CDgfcCA4Fr063v7vPcvdrdq6uq9GFURDqmO+QwfZAUkXTanazv7lPTLTOzjWY2zN03hElqU5p+fYHfAV9096cj227+JFpnZj8CPrdf0YuItKM75DB3nwfMA6iurk5b7IlI8cn00ORCYGZ4fybwUHIHMysHfgX82N0fTFo2LPxpBHMzXs4wHhGR/aEcJiKxyrQQmwucamavA1PDx5hZtZnND/ucD5wAzDKzpeHtiHDZT83sJeAlYDBwc4bxiIjsD+UwEYmVBdMi8kt1dbXX1NTEHYaI5IiZPefu1XHHkQ3KXyLFp60cpq84EhEREYmJCjERERGRmKgQExEREYmJCjERERGRmKgQExEREYmJCjERERGRmKgQExEREYmJCjERERGRmKgQExEREYmJCjERERGRmKgQExEREYmJCjERERGRmKgQExEREYmJCjERERGRmKgQExEREYmJCjERERGRmKgQE5GiZWYDzexhM3s9/DkgTb9GM1sa3hZG2seZ2TNmtsLM7jez8txFLyKFIKNCTElMRPLcHOBRd58IPBo+TmWXux8R3s6KtH8DuNXdJwBbgUu6NlwRKTSZjogpiYlIPpsO3BPevwc4u6MrmpkBJwMPdmZ9ERHIvBBTEhORfDbU3TeE998EhqbpV2lmNWb2tJmdHbYNAra5e0P4eC0wItXKZjY7XL+mtrY2W7GLSAEozXD9/UpiQAMw191/zX4kMQgSGTAbYPTo0RmGLSLFwsweAQ5IseiL0Qfu7mbmaTYzxt3Xmdl44DEzewnY3tEY3H0eMA+guro63e8QkSLUbiHWHZJYuH0lMhHZb+4+Nd0yM9toZsPcfYOZDQM2pdnGuvDnSjN7AjgS+AXQ38xKww+UI4F1Wd8BESlo7R6adPep7n5oittDwMYwedHRJAY8QZDEthAmsbCbkpiI5NpCYGZ4fybwUHIHMxtgZhXh/cHA8cAyd3fgceC8ttYXEWlLpnPElMREJJ/NBU41s9eBqeFjzKzazOaHfSYDNWb2N4KcNdfdl4XLrgWuNrMVBNMt7spp9CKS9zKdIzYXeMDMLgFWA+dDkMSAy9z9UoIkdqeZNREUfslJ7D4zuxl4ASUxEckhd98CnJKivQa4NLz/FHBYmvVXAsdkM6Z7f7mGZ5dubdVeUV7CdVcdRL++Zdn8dSISs4wKse6YxERE8tm2t+t5/sVtNDa2nArbq2eCinJdg1uk0OivWkSkG/nEuaMoLbUWbZUVJcyaMYbKykRMUYlIV1EhJiLSjfTtU8Z5Hx5BRfm+YiyRMM45Y3iMUYlIV1EhJiLSzXzi3FFgQSGm0TCRwqZCTESkm2keFStNmEbDRAqcCjERkW7oE+eOIpEwjYaJFLhML18hIiJdoG+fMu667ShGDusRdygi0oWKohBzdxqboDRh7XcWEekmxo7qFXcIItLFCroQ27W7ke/+cAV/eHwj9Q3O5El9+PwVk5g4rnfcoYmIiIgU9hyxa298iT88vpE99Y47LFv+Dldcu5RNm+viDk1ERESkcAuxlavf5ZW/v8Oe+pZXp66vb+KXv9N3i4uIiEj8CrYQW7N+V8o5YfUNzopV78YQkYiIiEhLBVuIjRvVk4YGb9VeXmZMntgnhohEREREWirYQmz0yJ4cfXj/Fl+Sawbl5QldHFFERES6hYItxABuvu4QzvvICPr0LqWszDj2qIHM+/aRDBxQHndoIiIiIoV9+YryshIunzWey2eNjzsUERERkVYKekRMRKQtZjbQzB42s9fDnwNS9PmgmS2N3Hab2dnhsrvN7B+RZUfkeh9EJL+pEBORYjYHeNTdJwKPho9bcPfH3f0Idz8COBnYCfwh0uXzzcvdfWkOYhaRApJRIaZPkyKS56YD94T37wHObqf/ecDv3X1nVwYlIsUj0xExfZoUkXw21N03hPffBIa2038GcG9S2y1m9qKZ3WpmFalWMrPZZlZjZjW1tbUZhiwihSTTQkyfJkWkWzOzR8zs5RS36dF+7u5A64sP7tvOMOAwYHGk+TrgYOC9wEDg2lTruvs8d6929+qqqqpMd0lECkimZ0125tPkd5LabjGz6wlH1Nw95RdBmtlsYDbA6NGjOx+xiBQVd5+abpmZbTSzYe6+ISy0NrWxqfOBX7l7fWTbzfmvzsx+BHwuK0GLSNFod0SsO3yaDLevT5Qikm0LgZnh/ZnAQ230vZCkw5JhXsPMjOCIwMvZD1FEClm7I2L6NCkiBWwu8ICZXQKsJshTmFk1cJm7Xxo+HguMAp5MWv+nZlYFGLAUuCw3YYtIocj00GTzp8m5dOzT5HXRhkgRp0+TIpJz7r4FOCVFew1waeTxKmBEin4nd2V8IlL4Mp2sPxc41cxeB6aGjzGzajOb39ypnU+TLwEvAYOBmzOMR0RERCRvZDQipk+TIiIiIp2nK+uLiIiIxESFmIiIiEhMVIiJiIiIxESFmIiIiEhMVIiJiIiIxESFmIiIiEhMVIiJiIiIxESFmIiIiEhMVIiJiIiIxESFmIiIiEhMVIiJiIiIxCSj75oUKUT19U08+dfNvPDSNoZUVfChUw5g8KCKuMMSEWnXT3+xhtVr323V3rtnKVf864EkEhZDVNIWFWIiETt3NXL5519g/cZd7NrdRHlZCT/5+T/59g3v4fBD+sUdnohIm55/cSvPPL+1VfvggeVcecmBMUQk7dGhSZGI+3+9hjUbgiIMYE99E7t3N/HVb72Ku8ccnWSbmX3MzF4xsyYzq26j3zQzW25mK8xsTqR9nJk9E7bfb2bluYlcJLXLZo2norzlv/YelQkunzWekhKNhnVHKsREIv7w5Cb27Glq1f72O/WsWb8rhoiki70MfBT4Y7oOZpYAbgfOAKYAF5rZlHDxN4Bb3X0CsBW4pGvDFWnbxHG9OfyQflik5urVM8EpJwyJLyhpkwoxkYjystR/Eu7pl0n+cvdX3X15O92OAVa4+0p33wPcB0w3MwNOBh4M+90DnN1lwYp00OUXj9+br5pHw0o1N6zb0n8WkYizzxhGZUXLPwszGDWiBwcMqYwpKonZCGBN5PHasG0QsM3dG5LaRWLVPCoGGg3LBxkVYppfIYXmrNOHc1z1QCrKS6goL6FnjwQD+5dz85xD4g5NOsnMHjGzl1PcpucwhtlmVmNmNbW1tbn6tVLELr94fPBTo2HdXqZnTTbPr7gzXYfI/IpTCT4xLjGzhe6+jH3zK+4zsx8QzK+4I8OYRDotkTBumnMIK/6xg1eWv83ggRUce9QASks1eJyv3H1qhptYB4yKPB4Ztm0B+ptZaTgq1tyeKoZ5wDyA6upqnfUhXW7iuN5872uHc/gUne3d3WX030XzK6RQTRjXm+nThnP8MYNUhMkSYGI4gl8OzAAWenAa7ePAeWG/mcBDMcUo0spRh/XXdcPyQC7+w2RlfoWG9kUk28zsHDNbCxwH/M7MFoftw81sEUCYo64EFgOvAg+4+yvhJq4FrjazFQQ57a5c74OI5Ld2D02a2SPAASkWfdHdc/bpT0P7IpJt7v4r4Fcp2tcDZ0YeLwIWpei3kmDUX0SkU9otxLrD/AoRERGRQpSLQ5OaXyEiIiKSQqaXr9D8ChEREZFOsnz8/jwzqwVWxx1HFxgMbI47iBgU635D8e77/u73GHev6qpgcqmA81cyvbeLRzHuM+zffqfNYXlZiBUqM6tx97QXxi1UxbrfULz7Xqz7XUyK9TUuxv0uxn2G7O23LpAkIiIiEhMVYiIiIiIxUSHWvcyLO4CYFOt+Q/Hue7HudzEp1te4GPe7GPcZsrTfmiMmIiIiEhONiImIiIjERIWYiIiISExUiMXIzAaa2cNm9nr4c0Cafo1mtjS8Lcx1nNliZtPMbLmZrTCzOSmWV5jZ/eHyZ8xsbAxhdokO7PssM6uNvM6XxhFnNpnZAjPbZGYvp1luZva98Dl50cyOynWMkj3FlM+KNZcpj6VcnnEeUyEWrznAo+4+EXg0fJzKLnc/IrydlbvwssfMEsDtwBnAFOBCM5uS1O0SYKu7TwBuBb6R2yi7Rgf3HeD+yOs8P6dBdo27gWltLD8DmBjeZgN35CAm6TpFkc+KNZcpj6WVcR5TIRav6cA94f17gLPjC6XLHQOscPeV7r4HuI9g/6Oiz8eDwClmZjmMsat0ZN8Ljrv/EXirjS7TgR974Gmgv5kNy0100gWKJZ8Vay5THkst4zymQixeQ919Q3j/TWBomn6VZlZjZk+b2dm5CS3rRgBrIo/Xhm0p+4TfUbqd4DtI811H9h3g3HBo+0EzG5Wb0GLV0edF8kOx5LNizWXKY6llnMdKsxqOtGJmjwAHpFj0xegDd3czS3ctkTHuvs7MxgOPmdlL7v5GtmOVWP0GuNfd68zs0wSfpk+OOSaRFpTPpB3KY52gQqyLufvUdMvMbKOZDXP3DeFQ5qY021gX/lxpZk8ARwL5lrjWAdFPRyPDtlR91ppZKdAP2JKb8LpUu/vu7tH9nA/8Vw7iiltH3hPSjSifAcWby5THUss4j+nQZLwWAjPD+zOBh5I7mNkAM6sI7w8GjgeW5SzC7FkCTDSzcWZWDswg2P+o6PNxHvCYF8YVh9vd96Q5BWcBr+YwvrgsBC4Kzzp6H7A9cmhL8k+x5LNizWXKY6llnMc0IhavucADZnYJsBo4H8DMqoHL3P1SYDJwp5k1ERTOc9093xIX7t5gZlcCi4EEsMDdXzGzG4Ead18I3AX8xMxWEEyOnBFfxNnTwX2/yszOAhoI9n1WbAFniZndC5wEDDaztcBXgDIAd/8BsAg4E1gB7AQujidSyZKiyGfFmsuUx7ouj+krjkRERERiokOTIiIiIjFRISYiIiISExViIiIiIjFRISYiIiISExViIiIiIjFRISYiIiISExViIiIiIjH5/98UIjgo+8/RAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 720x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建进度条，并设置所需要的量子核函数计算数量 N\n",
    "pbar = tqdm(total=100, \n",
    "            desc='训练 PQK-SVM 并分类中', \n",
    "            bar_format=bar_format_string)\n",
    "N = 2 * (len(X_train) ** 2 + len(X_train) ** 2 + len(X_train) * len(X_test))\n",
    "\n",
    "# 创建一个具有投影量子核函数的支持向量机\n",
    "svm_pqk = svm.SVC(kernel=p_quantum_kernel_matrix)\n",
    "\n",
    "# 根据训练数据计算支持向量机的决策平面\n",
    "svm_pqk.fit(X_train, y_train)\n",
    "\n",
    "# 计算支持向量机分别对于训练数据和测试数据的分类预测值\n",
    "predict_svm_pqk_train = svm_pqk.predict(X_train)\n",
    "predict_svm_pqk_test = svm_pqk.predict(X_test)\n",
    "\n",
    "# 计算准确率\n",
    "accuracy_train = np.array(predict_svm_pqk_train == y_train, dtype=int).sum()/len(y_train)\n",
    "accuracy_test = np.array(predict_svm_pqk_test == y_test, dtype=int).sum()/len(y_test)\n",
    "\n",
    "# 可视化分类结果\n",
    "pbar.close()\n",
    "clear_output()\n",
    "fig, ax = plt.subplots(1, 2, figsize=[10, 4])\n",
    "ax[0].scatter(X_train[:,0], X_train[:,1], marker='o', \n",
    "              c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_train, dtype=np.float32)))\n",
    "ax[0].set_title('Prediction on training set, accuracy={:.2f}'.format(accuracy_train))\n",
    "ax[1].scatter(X_test[:,0], X_test[:,1], marker='v', \n",
    "              c = matplotlib.cm.coolwarm(np.array(predict_svm_pqk_test, dtype=np.float32)))\n",
    "ax[1].set_title('Prediction on testing set, accuracy={:.2f}'.format(accuracy_test))\n",
    "print(\"让我们看一下投影量子核支持向量机的分类效果如何:\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "irish-embassy",
   "metadata": {},
   "source": [
    "同样的，我们检查一下此时的决策函数平面以及决策边界："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "chief-beach",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "计算 PQK-SVM 决策函数中: 100%|███████████████████████████████████████████████████████████████▉|[02:49<00:00,  1.69s/it]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建进度条，并设置所需要的量子核函数计算数量 N\n",
    "pbar = tqdm(total=100, \n",
    "            desc='计算 PQK-SVM 决策函数中', \n",
    "            bar_format=bar_format_string)\n",
    "N = 2 * 10 ** 2 * len(X_train)\n",
    "    \n",
    "# 可视化决策函数平面\n",
    "visualize_decision_bound(svm_pqk)\n",
    "pbar.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "continuous-chance",
   "metadata": {},
   "source": [
    "## 总结\n",
    "\n",
    "在量子机器学习的研究中，研究者们希望借助量子力学的特点设计出可以超越经典机器学习方法的模型。随着该领域的研究越发深入，人们发现量子机器学习和传统机器学习可以通过核方法建立起深入的联系。相比“传统”的量子神经网络，量子核方法把研究的重点放在了从经典数据空间到量子希尔伯特空间的特征映射，而不是变分量子电路。这为量子机器学习带来了新的研究思路，并为设计出实用的量子算法带来了新的可能性。因此，我们鼓励读者一起来思考如何设计出更好的量子核函数，并将其应用在更多样的数据集上。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "intimate-bible",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "## 参考资料\n",
    "\n",
    "[1] Schuld, Maria. \"Supervised quantum machine learning models are kernel methods.\" arXiv preprint [arXiv:2101.11020 (2021)](https://arxiv.org/abs/2101.11020).\n",
    "\n",
    "[2] Havlíček, Vojtěch, et al. \"Supervised learning with quantum-enhanced feature spaces.\" [Nature 567.7747 (2019): 209-212](https://arxiv.org/abs/1804.11326).\n",
    "\n",
    "[3] Liu, Yunchao, Srinivasan Arunachalam, and Kristan Temme. \"A rigorous and robust quantum speed-up in supervised machine learning.\" arXiv preprint [arXiv:2010.02174 (2020)](https://arxiv.org/abs/2010.02174).\n",
    "\n",
    "[4] Schuld, Maria, and Nathan Killoran. \"Quantum machine learning in feature Hilbert spaces.\" [Phys. Rev. Lett. 122.4 (2019): 040504](https://arxiv.org/abs/1803.07128).\n",
    "\n",
    "[5] Hubregtsen, Thomas, et al. \"Training Quantum Embedding Kernels on Near-Term Quantum Computers.\" arXiv preprint [arXiv:2105.02276(2021)](https://arxiv.org/abs/2105.02276).\n",
    "\n",
    "[6] Glick, Jennifer R., et al. \"Covariant quantum kernels for data with group structure.\" arXiv preprint [arXiv:2105.03406(2021)](https://arxiv.org/abs/2105.03406).\n",
    "\n",
    "[7] Huang, Hsin-Yuan, et al. \"Power of data in quantum machine learning.\" arXiv preprint [arXiv:2011.01938 (2020)](https://arxiv.org/abs/2011.01938).\n",
    "\n",
    "[8] Schölkopf, Bernhard, and Alexander J. Smola\"Learning with kernels: support vector machines, regularization, optimization, and beyond.\" [MIT Press(2002)](https://mitpress.mit.edu/books/learning-kernels)."
   ]
  }
 ],
 "metadata": {
  "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.10"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}