tutorials/qnn_research/Fisher_CN.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 量子费舍信息\n",
    "\n",
    "<em> Copyright (c) 2021 Institute for Quantum Computing, Baidu Inc. All Rights Reserved. </em>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 概览\n",
    "\n",
    "本教程简要介绍经典费舍信息（classical Fisher information, CFI）和量子费舍信息（quantum Fisher information, QFI）的概念及其在量子机器学习中的应用，并展示如何调用量桨来计算它们。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 背景\n",
    "\n",
    "量子费舍信息这一概念源自量子传感领域，现已逐渐成为研究参数化量子系统的通用工具 [[1]](https://arxiv.org/abs/2103.15191)，例如描述过参数化现象 [[2]](https://arxiv.org/abs/2102.01659)，量子自然梯度下降 [[3]](https://arxiv.org/abs/1909.02108) 等。量子费舍信息是经典费舍信息在量子系统中的自然类比。经典费舍信息刻画了一个参数化的『概率分布』对其参数变化的灵敏度，而量子费舍信息刻画了一个参数化的『量子态』对其参数变化的灵敏度。\n",
    "\n",
    "按照传统的介绍方式，经典费舍信息会作为数理统计中参数估计的一部分内容出现，但对于初学者来说可能是复杂且不直观的。本教程将从几何的角度出发来介绍经典费舍信息，这不仅有助于直观理解，且更容易由此看出其与量子费舍信息之间的联系。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 经典费舍信息\n",
    "\n",
    "首先介绍经典费舍信息。对于一个参数化的概率分布 $p(\\boldsymbol{x};\\boldsymbol{\\theta})$，考虑如下问题\n",
    "\n",
    "- 一个轻微的参数改变会在多大程度上造成概率分布的改变？\n",
    "\n",
    "这是个关于微扰的问题，所以自然地想到做类似泰勒展开的操作。但在此之前，我们需要知道展开哪个函数，即我们需要量化『概率分布的改变』。更正式的说法是，我们需要定义任意两个概率分布之间的『距离』，记为 $d(p(\\boldsymbol{x};\\boldsymbol{\\theta}),p(\\boldsymbol{x};\\boldsymbol{\\theta}'))$，或简记为 $d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}')$。\n",
    "\n",
    "一般地，一个合法的距离定义应该是非负的，当且仅当两点重合时为零，即\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "&d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}')\\geq 0,\\\\\n",
    "&d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}')=0~\\Leftrightarrow~\\boldsymbol{\\theta}=\\boldsymbol{\\theta}'.\n",
    "\\end{aligned}\n",
    "\\tag{1}\n",
    "$$\n",
    "\n",
    "考虑一个很短的距离函数的展开 $d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}+\\boldsymbol{\\delta})$，以上条件会导致\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "&d(\\boldsymbol{\\theta},\\boldsymbol{\\theta})=0~\\Rightarrow~\\text{零阶项}=0,\\\\\n",
    "&d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}+\\boldsymbol{\\delta})\\geq 0~\\Rightarrow~\\boldsymbol{\\delta}=0~\\text{取极小值}\n",
    "~\\Rightarrow~\\text{一阶项}=0.\n",
    "\\end{aligned}\n",
    "\\tag{2}\n",
    "$$\n",
    "\n",
    "因此，在这个展开中最低阶的非零贡献来自二阶。因此它可被写为\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}+\\boldsymbol{\\delta})\n",
    "=\\frac{1}{2}\\sum_{ij}\\delta_iM_{ij}\\delta_j+O(\\|\\boldsymbol{\\delta}\\|^3) \n",
    "=\\frac{1}{2} \\boldsymbol{\\delta}^T M \\boldsymbol{\\delta} + O(\\|\\boldsymbol{\\delta}\\|^3),\n",
    "\\end{aligned}\n",
    "\\tag{3}\n",
    "$$\n",
    "\n",
    "此处\n",
    "\n",
    "$$\n",
    "M_{ij}(\\boldsymbol{\\theta})=\\left.\\frac{\\partial^2}{\\partial\\delta_i\\partial\\delta_j}d(\\boldsymbol{\\theta},\\boldsymbol{\\theta}+\\boldsymbol{\\delta})\\right|_{\\boldsymbol{\\delta}=0},\n",
    "\\tag{4}\n",
    "$$\n",
    "\n",
    "正是这个距离函数展开的海森矩阵。在微分几何的框架下，这称作流形的[度规](http://en.wikipedia.org/wiki/Metric_tensor)。以上简单的推导说明，我们总是可以用参数的一个二次型来近似表示一小段距离（如图1）。而二次型的系数矩阵，除了有一个 $1/2$ 因子的差别外，正是距离函数展开的海森矩阵。\n",
    "\n",
    "![feature map](./figures/FIM-fig-Sphere-metric.png \"Figure 1. Approximate a small distance on the 2-sphere as a quadratic form\")\n",
    "<div style=\"text-align:center\">图 1. 将一小段距离近似为二次型，此处以二维球面为例绘制 </div>\n",
    "\n",
    "如果我们定义概率分布之间的距离为相对熵或称 KL 散度\n",
    "\n",
    "$$\n",
    "d_{\\mathrm{KL}}(\\boldsymbol{\\theta}, \\boldsymbol{\\theta}^{\\prime})=\\sum_{\\boldsymbol{x}} p(\\boldsymbol{x};\\boldsymbol{\\theta}) \\log \\frac{p(\\boldsymbol{x};\\boldsymbol{\\theta})}{p(\\boldsymbol{x};\\boldsymbol{\\theta}^{\\prime})}.\n",
    "\\tag{5}\n",
    "$$\n",
    "\n",
    "对应的海森矩阵为\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\mathcal{I}_{ij}(\\boldsymbol{\\theta})&= \\left.\\frac{\\partial^2}{\\partial\\delta_i\\partial\\delta_j}d_{\\mathrm{KL}}(\\boldsymbol{\\theta},\\boldsymbol{\\theta}+\\boldsymbol{\\delta})\\right|_{\\boldsymbol{\\delta}=0}\\\\\n",
    "&=-\\sum_{\\boldsymbol{x}} p(\\boldsymbol{x};\\boldsymbol{\\theta}) \\partial_{i} \\partial_{j} \\log p(\\boldsymbol{x};\\boldsymbol{\\theta})\n",
    "=\\mathbb{E}_{\\boldsymbol{x}}[-\\partial_{i} \\partial_{j} \\log p(\\boldsymbol{x};\\boldsymbol{\\theta})] \\\\\n",
    "&=\\sum_{\\boldsymbol{x}}  \\frac{1}{p(\\boldsymbol{x};\\boldsymbol{\\theta})} \\partial_i p(\\boldsymbol{x};\\boldsymbol{\\theta}) \\cdot \\partial_j p(\\boldsymbol{x};\\boldsymbol{\\theta})\n",
    "=\\mathbb{E}_{\\boldsymbol{x}}[\\partial_i\\log p(\\boldsymbol{x};\\boldsymbol{\\theta})\\cdot \\partial_j \\log p(\\boldsymbol{x};\\boldsymbol{\\theta})].\n",
    "\\end{aligned}\n",
    "\\tag{6}\n",
    "$$\n",
    "\n",
    "这就是所谓的经典费舍信息矩阵（classical Fisher information matrix, CFIM），矩阵元越大说明概率分布对相应的参数变化越灵敏。上式中我们使用了偏导数符号的简记 $\\partial_i=\\partial/\\partial \\theta_i$。\n",
    "\n",
    "为什么 $\\mathcal{I}(\\boldsymbol{\\theta})$ 称为『信息』？这是因为，CFIM 刻画了概率分布在对应参数一个领域内的灵敏度，或称锐度。对参数变化越灵敏，说明我们越容易将其同其它概率分布区分开来，进一步地，说明我们需要越少的样本就可以完成这种区分，那么每个样本中平均所含的信息量就越多。\n",
    "\n",
    "参数化量子电路（parameterized quantum circuit, PQC）的测量结果会形成一个概率分布，因此可以对不同的测量基定义不同的 CFIM。目前在 NISQ 设备上计算 CFIM 的主要挑战是，可能出现的测量结果的数量会随着量子比特数的增加而指数地增加，这意味着可能有很多小概率的测量结果从未出现过，导致 CFIM 的计算出现发散。一些可能的解决方案包括直接忽略小的概率事件，以及贝叶斯更新等 [[1]](https://arxiv.org/abs/2103.15191)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 量子费舍信息\n",
    "\n",
    "量子费舍信息是经典费舍信息的自然类比，只是距离函数不再定义在两个概率分布之间，而是定义在两个量子态之间。我们通常选用保真度距离\n",
    "\n",
    "$$\n",
    "d_f(\\boldsymbol{\\theta},\\boldsymbol{\\theta}')=2-2|\\langle\\psi(\\boldsymbol{\\theta})|\\psi(\\boldsymbol{\\theta}')\\rangle|^2.\n",
    "\\tag{7}\n",
    "$$\n",
    "\n",
    "此处因子 $2$ 是人为乘上去的，为的是让后续的结果与 CFIM 对应上。一个参数化量子纯态 $|\\psi(\\boldsymbol{\\theta})\\rangle, \\boldsymbol{\\theta}\\in\\mathbb{R}^m$ 的量子费舍信息矩阵（quantum Fisher information matrix, QFIM）就是保真度距离展开的海森矩阵，即\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\mathcal{F}_{ij}(\\boldsymbol{\\theta})\n",
    "&= \\left.\\frac{\\partial^2}{\\partial\\delta_i\\partial\\delta_j}d_{f}(\\boldsymbol{\\theta},\\boldsymbol{\\theta}+\\boldsymbol{\\delta})\\right|_{\\boldsymbol{\\delta}=0} \\\\\n",
    "&=4 \\operatorname{Re}\\left[\\left\\langle\\partial_{i} \\psi \\mid \\partial_{j} \\psi\\right\\rangle - \\left\\langle\\partial_{i} \\psi \\mid \\psi\\right\\rangle\\left\\langle\\psi \\mid \\partial_{j} \\psi\\right\\rangle\\right],\n",
    "\\end{aligned}\n",
    "\\tag{8}\n",
    "$$\n",
    "\n",
    "上式中简洁起见我们略写了自变量 $\\boldsymbol{\\theta}$。与 CFIM 类似，QFIM 刻画了参数化量子态对参数微小变化的灵敏度。此外值得一提的是，QFIM 可以被视为另一个被称作量子几何张量的复数矩阵的实部，或称为 Fubini-Study 度规 [[1]](https://arxiv.org/abs/2103.15191)。\n",
    "\n",
    "目前，人们已经提出了一些在 NISQ 设备上计算纯态 QFIM 的方法，其中最直接的两个方法是\n",
    "\n",
    "- 利用二阶参数平移规则计算每个矩阵元 [[4]](https://arxiv.org/abs/2008.06517)\n",
    "$$\n",
    "\\begin{aligned}\n",
    "\\mathcal{F}_{i j}=-\\frac{1}{2} \\Big(&|\\langle\\psi(\\boldsymbol{\\theta}) \\mid \\psi(\\boldsymbol{\\theta}+(\\boldsymbol{e}_{i}+\\boldsymbol{e}_{j}) \\frac{\\pi}{2})\\rangle|^{2}\n",
    "-|\\langle\\psi(\\boldsymbol{\\theta}) \\mid \\psi(\\boldsymbol{\\theta}+(\\boldsymbol{e}_{i}-\\boldsymbol{e}_{j}) \\frac{\\pi}{2})\\rangle|^{2}\\\\\n",
    "-&|\\langle\\psi(\\boldsymbol{\\theta}) \\mid \\psi(\\boldsymbol{\\theta}-(\\boldsymbol{e}_{i}-\\boldsymbol{e}_{j}) \\frac{\\pi}{2})\\rangle|^{2}\n",
    "+|\\langle\\psi(\\boldsymbol{\\theta}) \\mid \\psi(\\boldsymbol{\\theta}-(\\boldsymbol{e}_{i}+\\boldsymbol{e}_{j}) \\frac{\\pi}{2})\\rangle|^{2}\\Big),\n",
    "\\end{aligned}\n",
    "\\tag{9}\n",
    "$$\n",
    "其中 $\\boldsymbol{e}_{i}$ 是 $\\theta_i$ 对应方向的单位向量。值得注意的是，参数平移规则不能直接适用于单比特旋转门的参数间有依赖关系的情况，例如受控旋转门等。\n",
    "\n",
    "- 利用有限差分计算 QFIM 沿一个确定方向的投影 [[1]](https://arxiv.org/abs/2103.15191)\n",
    "$$\n",
    "\\boldsymbol{v}^{T} \\mathcal{F} \\boldsymbol{v} \\approx \\frac{4 d_{f}(\\boldsymbol{\\theta}, \\boldsymbol{\\theta}+\\epsilon \\boldsymbol{v})}{\\epsilon^{2}}.\n",
    "\\tag{10}\n",
    "$$\n",
    "这个量可以被视为著名的 Fisher-Rao 模在量子态空间的类比。\n",
    "\n",
    "对于混态，QFIM 可以类似地通过 Bures 保真度距离的展开来定义\n",
    "\n",
    "$$\n",
    "d_B(\\boldsymbol{\\theta},\\boldsymbol{\\theta}')\\equiv \n",
    "2-2\\left[\\text{Tr}\\left([\\sqrt{\\rho(\\boldsymbol{\\theta})} \\rho(\\boldsymbol{\\theta}')\\sqrt{\\rho(\\boldsymbol{\\theta})}]^{1/2}\\right)\\right]^2,\n",
    "\\tag{11}\n",
    "$$\n",
    "\n",
    "或者等价地（$\\log x\\sim x-1$），通过如下形式的 $\\alpha=1/2$ 的 Rényi 相对熵的展开来定义 [[5]](https://arxiv.org/abs/1308.5961)\n",
    "\n",
    "$$\n",
    "\\begin{aligned}\n",
    "d_R(\\boldsymbol{\\theta},\\boldsymbol{\\theta}') &\\equiv 2\\widetilde{D}_{\\alpha=1/2}(\\rho(\\boldsymbol{\\theta'}) \\| \\rho(\\boldsymbol{\\theta})), \\\\\n",
    "\\widetilde{D}_{\\alpha}(\\rho \\| \\sigma) \n",
    "&\\equiv \n",
    "\\frac{1}{\\alpha-1} \\log \\operatorname{Tr}\\left[\\left(\\sigma^{\\frac{1-\\alpha}{2 \\alpha}} \\rho \\sigma^{\\frac{1-\\alpha}{2 \\alpha}}\\right)^{\\alpha}\\right].\\\\\n",
    "\\end{aligned}\n",
    "\\tag{12}\n",
    "$$\n",
    "\n",
    "更多细节请参考这篇综述 [[1]](https://arxiv.org/abs/2103.15191) 。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 经典与量子费舍信息的关系\n",
    "\n",
    "根据定义，对于一个参数化的量子电路，CFIM 依赖于测量基，而 QFIM 不依赖。事实上可以证明，一个量子态 $\\rho(\\boldsymbol{\\theta})$ 的 QFIM 是其在任意测量基下对应 CFIM 的一个上限，即\n",
    "\n",
    "$$\n",
    "\\mathcal{I}[\\mathcal{E}[\\rho(\\boldsymbol{\\theta})]]\\leq \\mathcal{F}[\\rho(\\boldsymbol{\\theta})],~\\forall\\mathcal{E},\n",
    "\\tag{13}\n",
    "$$\n",
    "\n",
    "此处 $\\mathcal{E}$ 表示测量对应的量子操作。正定矩阵间不等式的含义是，大的减去小的结果仍然是一个正定矩阵。由于对量子态的测量永远无法提取出比量子态本身更多的信息，因此上式的成立是很自然的。数学上这根源于保真度距离对于保迹量子操作的单调性 [[1]](https://arxiv.org/abs/2103.15191)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 应用：有效维数\n",
    "\n",
    "经典/量子费舍信息矩阵的秩在参数空间的最大值可以用来衡量神经网络表达能力，称为经典/量子有效维数\n",
    "\n",
    "$$\n",
    "d_{\\text{eff}}=\\underset{\\boldsymbol{\\theta}\\in\\Theta} {\\max}\n",
    "\\operatorname{rank}{\\mathcal{F}}(\\boldsymbol{\\theta}).\n",
    "\\tag{14}\n",
    "$$\n",
    "\n",
    "秩的大小刻画了参数变化会造成概率分布/量子态变化的方向的数量。非满秩意味着有一些特定方向的参数变化不能实际地导致概率分布/量子态发生变化，或者说有一些参数自由度是冗余的，可以把它们从模型中投影掉，因此这种现象被称作过参数化。另一方面，有效维数越大，对应着更多可以延伸的方向，这意味着模型对应的函数空间更大，即表达能力更强。\n",
    "\n",
    "在机器学习的语境下，『经验费舍信息矩阵』[[6]](https://arxiv.org/abs/2011.00027) 的使用更为广泛，它与 CFIM 的区别是用对样本的求和代替了求期望\n",
    "\n",
    "$$\n",
    "\\tilde{\\mathcal{I}}_{ij}(\\boldsymbol{\\theta})\n",
    "=\\frac{1}{n}\\sum_{k=1}^{n}\n",
    "\\partial_i\\log p(x_k,y_k;\\boldsymbol{\\theta})\n",
    "\\partial_j\\log p(x_k,y_k;\\boldsymbol{\\theta}),\n",
    "\\tag{15}\n",
    "$$\n",
    "\n",
    "此处 $(x_k,y_k)^{n}_{k=1}$ 是独立同分布的样本，分布为 $p(x,y;\\boldsymbol{\\theta})=p(y|x;\\boldsymbol{\\theta})p(x)$。显然，经验费舍信息矩阵在无限样本的极限下可以回到 CFIM，只要满足（1）模型被训练到全局最优；（2）模型拥有足够的表达能力来表达底层的数据分布。使用经验费舍信息矩阵的优势在于，它可以利用现成的样本直接计算，而不是为了计算公式中的积分而生成新的样本。\n",
    "\n",
    "利用经验费舍信息矩阵，我们可以定义有效维数的一个变体 \n",
    "\n",
    "$$\n",
    "d_{\\text{eff}}(\\gamma, n)=\n",
    "2 \\frac{\\log \\left(\\frac{1}{V_{\\Theta}} \\int_{\\Theta} \\sqrt{\\operatorname{det}\\left( 1 + \\frac{\\gamma n}{2 \\pi \\log n} \\hat{\\mathcal{I}}( \\boldsymbol{\\theta})\\right)} \\mathrm{d}  \\boldsymbol{\\theta} \\right)}\n",
    "{\\log \\left(\\frac{\\gamma n}{2 \\pi \\log n}\\right)},\n",
    "\\tag{16}\n",
    "$$\n",
    "\n",
    "其中 $V_{\\Theta}:=\\int_{\\Theta} \\mathrm{d} \\boldsymbol{\\theta} \\in \\mathbb{R}_{+}$ 是参数空间的体积。$\\gamma\\in(0,1]$ 是一个人为可调参数。$\\hat{\\mathcal{I}} (\\boldsymbol{\\theta}) \\in \\mathbb{R}^{d\\times d}$ 是归一化的经验费舍信息矩阵\n",
    "\n",
    "$$\n",
    "\\hat{\\mathcal{I}}_{i j}(\\boldsymbol{\\theta}):= \\frac{V_{\\Theta} d }{\\int_{\\Theta} \\operatorname{Tr}(F( \\boldsymbol{\\theta} ) \\mathrm{d} \\theta} \\tilde{\\mathcal{I}}_{i j}(\\boldsymbol{\\theta}).\n",
    "\\tag{17}\n",
    "$$\n",
    "\n",
    "这个定义乍看起来可能很迷惑，因为它比上文通过秩来定义要复杂得多。然而，它实际上可以在无限样本的极限下 $n\\rightarrow \\infty$  回到 CFIM 最大秩的定义 [[6]](https://arxiv.org/abs/2011.00027)。若忽略定义中的一些系数和取对数的操作，此处定义的有效维数可以粗略地看作归一化 CFIM 加上一个单位矩阵的本征谱的几何平均。依据几何平均与算术平均间的不等式关系，可知本征谱分布越均匀，有效维数越大。这和我们的直觉是一致的。在这个意义上，它可以看作是一个软化版本的有效维数。\n",
    "\n",
    "另外，费舍信息不仅可以用来计算模型的表达能力，还可以用来表征模型的可训练性。如果费舍信息矩阵的矩阵元在参数空间的平均随体系规模的增大而指数地趋于零，即概率分布/量子态对参数变化的灵敏度指数地趋于零，那么我们将无法高效地区分它们，也就意味着贫瘠高原现象的存在 [[6]](https://arxiv.org/abs/2011.00027)。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 调用量桨计算费舍信息"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算量子费舍信息\n",
    "\n",
    "利用量桨工具，通过以下步骤我们就可以方便地算出 QFIM。\n",
    "\n",
    "1. 调用 `Circuit` 类定义一个量子电路。\n",
    "2. 调用 `QuantumFisher` 类定义一个 QFIM 计算器。\n",
    "3. 调用 `get_qfisher_matrix()` 方法计算 QFIM。\n",
    "\n",
    "其中计算器 `QuantumFisher` 会追踪量子电路 `Circuit` 的实时变化。\n",
    "\n",
    "现在来着手写代码。首先导入一些必要的包。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import paddle\n",
    "from paddle_quantum.ansatz import Circuit\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from paddle_quantum.fisher import QuantumFisher, ClassicalFisher\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "然后定义量子电路。作为一个简单的例子，我们采用布洛赫角表示的单个量子比特\n",
    "\n",
    "$$\n",
    "|\\psi(\\theta,\\phi)\\rangle=R_z(\\phi)R_y(\\theta)|0\\rangle=e^{-i\\phi/2}\\cos\\frac{\\theta}{2}|0\\rangle+e^{i\\phi/2}\\sin\\frac{\\theta}{2}|1\\rangle.\n",
    "\\tag{18}\n",
    "$$\n",
    "\n",
    "利用 (8) 式可以计算出对应 QFIM 的解析表达式为\n",
    "\n",
    "$$\n",
    "\\mathcal{F}(\\theta,\\phi)=\\left(\\begin{matrix}\n",
    "1&0\\\\\n",
    "0&\\sin^2\\theta\n",
    "\\end{matrix}\\right).\n",
    "\\tag{19}\n",
    "$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circuit_bloch():\n",
    "    cir = Circuit(1)\n",
    "    cir.ry()\n",
    "    cir.rz()\n",
    "    return cir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(2.574)----Rz(6.022)--\n",
      "                          \n"
     ]
    }
   ],
   "source": [
    "cir = circuit_bloch()\n",
    "print(cir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义 QFIM 计算器然后计算不同 $\\theta$ 对应的 QFIM 矩阵元 $\\mathcal{F}_{\\phi\\phi}$ 。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The QFIM at [0.         6.02232647] is \n",
      " [[1. 0.]\n",
      " [0. 0.]].\n",
      "The QFIM at [0.15707963 6.02232647] is \n",
      " [[1.00000000e+00 3.87542900e-08]\n",
      " [3.87542900e-08 2.44718161e-02]].\n",
      "The QFIM at [0.31415927 6.02232647] is \n",
      " [[ 1.00000024e+00 -1.25257100e-08]\n",
      " [-1.25257100e-08  9.54916961e-02]].\n",
      "The QFIM at [0.4712389  6.02232647] is \n",
      " [[ 1.00000000e+00 -9.98981000e-08]\n",
      " [-9.98981000e-08  2.06107258e-01]].\n",
      "The QFIM at [0.62831853 6.02232647] is \n",
      " [[1.00000024 0.        ]\n",
      " [0.         0.34549158]].\n",
      "The QFIM at [0.78539816 6.02232647] is \n",
      " [[ 1.00000000e+00 -1.03238260e-07]\n",
      " [-1.03238260e-07  5.00000059e-01]].\n",
      "The QFIM at [0.9424778  6.02232647] is \n",
      " [[ 1.00000024e+00 -5.11963400e-08]\n",
      " [-5.11963400e-08  6.54508745e-01]].\n",
      "The QFIM at [1.09955743 6.02232647] is \n",
      " [[ 1.00000000e+00 -8.24729700e-08]\n",
      " [-8.24729700e-08  7.93892649e-01]].\n",
      "The QFIM at [1.25663706 6.02232647] is \n",
      " [[1.00000024e+00 3.54160800e-08]\n",
      " [3.54160800e-08 9.04508740e-01]].\n",
      "The QFIM at [1.41371669 6.02232647] is \n",
      " [[ 1.00000024e+00 -4.52859700e-08]\n",
      " [-4.52859700e-08  9.75528458e-01]].\n",
      "The QFIM at [1.57079633 6.02232647] is \n",
      " [[1.00000e+00 8.42937e-08]\n",
      " [8.42937e-08 1.00000e+00]].\n",
      "The QFIM at [1.72787596 6.02232647] is \n",
      " [[1.         0.        ]\n",
      " [0.         0.97552829]].\n",
      "The QFIM at [1.88495559 6.02232647] is \n",
      " [[1.00000024 0.        ]\n",
      " [0.         0.9045087 ]].\n",
      "The QFIM at [2.04203522 6.02232647] is \n",
      " [[ 1.00000000e+00 -1.74251400e-08]\n",
      " [-1.74251400e-08  7.93892595e-01]].\n",
      "The QFIM at [2.19911486 6.02232647] is \n",
      " [[1.00000024 0.        ]\n",
      " [0.         0.65450875]].\n",
      "The QFIM at [2.35619449 6.02232647] is \n",
      " [[9.99999762e-01 1.18139420e-07]\n",
      " [1.18139420e-07 4.99999863e-01]].\n",
      "The QFIM at [2.51327412 6.02232647] is \n",
      " [[1.00000024 0.        ]\n",
      " [0.         0.34549158]].\n",
      "The QFIM at [2.67035376 6.02232647] is \n",
      " [[1.00000000e+00 4.99490600e-08]\n",
      " [4.99490600e-08 2.06107471e-01]].\n",
      "The QFIM at [2.82743339 6.02232647] is \n",
      " [[1.00000000e+00 3.54160700e-08]\n",
      " [3.54160700e-08 9.54915711e-02]].\n",
      "The QFIM at [2.98451302 6.02232647] is \n",
      " [[9.99999881e-01 4.52859700e-08]\n",
      " [4.52859700e-08 2.44718147e-02]].\n",
      "The QFIM at [3.14159265 6.02232647] is \n",
      " [[1.00000e+00 8.42937e-08]\n",
      " [8.42937e-08 0.00000e+00]].\n"
     ]
    }
   ],
   "source": [
    "qf = QuantumFisher(cir)\n",
    "# 记录 QFIM 的矩阵元 F_{phi,phi}\n",
    "list_qfisher_elements = []\n",
    "num_thetas = 21\n",
    "thetas = np.linspace(0, np.pi, num_thetas)\n",
    "for theta in thetas:\n",
    "    list_param = cir.param.tolist()\n",
    "    list_param[0] = theta\n",
    "    cir.update_param(list_param)\n",
    "    # 计算 QFIM\n",
    "    qfim = qf.get_qfisher_matrix()\n",
    "    print(f'The QFIM at {np.array(list_param)} is \\n {qfim.round(14)}.')\n",
    "    list_qfisher_elements.append(qfim[1][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "画出 $\\mathcal{F}_{\\phi\\phi}$ 随 $\\theta$ 变化的图像。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建图像\n",
    "fig = plt.figure(figsize=(9, 6))\n",
    "ax = fig.add_subplot(111)\n",
    "# 绘制 QFIM\n",
    "ax.plot(thetas, list_qfisher_elements, 's', markersize=11, markerfacecolor='none')\n",
    "# 绘制 sin^2 theta\n",
    "ax.plot(thetas, np.sin(thetas) ** 2, linestyle=(0, (5, 3)))\n",
    "# 设置图例，标签，刻度\n",
    "label_font_size = 18\n",
    "ax.legend(['get_qfisher_matrix()[1][1]', '$\\\\sin^2\\\\theta$'], \n",
    "          prop= {'size': label_font_size}, frameon=False) \n",
    "ax.set_xlabel('$\\\\theta$', fontsize=label_font_size)\n",
    "ax.set_ylabel('QFIM element $\\\\mathcal{F}_{\\\\phi\\\\phi}$', fontsize=label_font_size)\n",
    "ax.tick_params(labelsize=label_font_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到程序输出和解析结果是一致的。\n",
    "\n",
    "此外，我们还可以调用 `get_qfisher_norm()` 方法来计算式 (10) 中的量子费舍信息矩阵在某个方向的投影。\n",
    "\n",
    "举一个和上面不同的例子，两个量子比特上的一个典型的 hardware-efficient 拟设\n",
    "\n",
    "$$\n",
    "|\\psi(\\boldsymbol{\\theta})\\rangle=\\left[R_{y}\\left( \\theta_{3}\\right) \\otimes R_{y}\\left( \\theta_{4}\\right)\\right] \\text{CNOT}_{0,1}\\left[ R_{y}\\left( \\theta_{1}\\right) \\otimes R_{y}\\left( \\theta_{2}\\right)\\right]|00\\rangle.\n",
    "\\tag{20}\n",
    "$$\n",
    "\n",
    "对应的 QFIM 为\n",
    "\n",
    "$$\n",
    "\\mathcal{F}(\\theta_1,\\theta_2,\\theta_3,\\theta_4)=\\left(\\begin{array}{cc|cc}\n",
    "1 & 0 & \\sin  \\theta_{2} & 0 \\\\\n",
    "0 & 1 & 0 & \\cos  \\theta_{1} \\\\\n",
    "\\hline \n",
    "\\sin \\theta_{2} & 0 & 1 & -\\sin\\theta_1\\cos\\theta_2 \\\\\n",
    "0 & \\cos \\theta_{1} & -\\sin\\theta_1\\cos\\theta_2 & 1\n",
    "\\end{array}\\right).\n",
    "\\tag{21}\n",
    "$$\n",
    "\n",
    "定义相应的量子电路。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def circuit_hardeff_2qubit():\n",
    "    cir = Circuit(2)\n",
    "    cir.ry()\n",
    "    cir.cnot([0, 1])\n",
    "    cir.ry()\n",
    "\n",
    "    return cir"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(2.591)----*----Ry(1.165)--\n",
      "               |               \n",
      "--Ry(0.346)----x----Ry(3.989)--\n",
      "                               \n"
     ]
    }
   ],
   "source": [
    "cir = circuit_hardeff_2qubit()\n",
    "print(cir)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "定义 QFIM 计算器并计算不同 $\\theta$ 对应的 QFIM 在 $\\boldsymbol{v}=(1,1,1,1)$ 方向上的投影 $\\boldsymbol{v}^T\\mathcal{F}\\boldsymbol{v}$ （固定 $\\theta_1=\\theta_2=\\theta$）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The QFI norm along [1, 1, 1, 1] at [0.         0.         1.16512394 3.98858905] is 6.00315457.\n",
      "The QFI norm along [1, 1, 1, 1] at [0.31415927 0.31415927 1.16512394 3.98858905] is 5.92209829.\n",
      "The QFI norm along [1, 1, 1, 1] at [0.62831853 0.62831853 1.16512394 3.98858905] is 5.83627391.\n",
      "The QFI norm along [1, 1, 1, 1] at [0.9424778  0.9424778  1.16512394 3.98858905] is 5.84580996.\n",
      "The QFI norm along [1, 1, 1, 1] at [1.25663706 1.25663706 1.16512394 3.98858905] is 5.94117037.\n",
      "The QFI norm along [1, 1, 1, 1] at [1.57079633 1.57079633 1.16512394 3.98858905] is 6.00792258.\n",
      "The QFI norm along [1, 1, 1, 1] at [1.88495559 1.88495559 1.16512394 3.98858905] is 5.86965007.\n",
      "The QFI norm along [1, 1, 1, 1] at [2.19911486 2.19911486 1.16512394 3.98858905] is 5.38807843.\n",
      "The QFI norm along [1, 1, 1, 1] at [2.51327412 2.51327412 1.16512394 3.98858905] is 4.49644803.\n",
      "The QFI norm along [1, 1, 1, 1] at [2.82743339 2.82743339 1.16512394 3.98858905] is 3.27580421.\n",
      "The QFI norm along [1, 1, 1, 1] at [3.14159265 3.14159265 1.16512394 3.98858905] is 1.98838624.\n",
      "The QFI norm along [1, 1, 1, 1] at [3.45575192 3.45575192 1.16512394 3.98858905] is 0.86783892.\n",
      "The QFI norm along [1, 1, 1, 1] at [3.76991118 3.76991118 1.16512394 3.98858905] is 0.25272329.\n",
      "The QFI norm along [1, 1, 1, 1] at [4.08407045 4.08407045 1.16512394 3.98858905] is 0.26702836.\n",
      "The QFI norm along [1, 1, 1, 1] at [4.39822972 4.39822972 1.16512394 3.98858905] is 0.90598547.\n",
      "The QFI norm along [1, 1, 1, 1] at [4.71238898 4.71238898 1.16512394 3.98858905] is 2.02653225.\n",
      "The QFI norm along [1, 1, 1, 1] at [5.02654825 5.02654825 1.16512394 3.98858905] is 3.33302230.\n",
      "The QFI norm along [1, 1, 1, 1] at [5.34070751 5.34070751 1.16512394 3.98858905] is 4.52505665.\n",
      "The QFI norm along [1, 1, 1, 1] at [5.65486678 5.65486678 1.16512394 3.98858905] is 5.40715063.\n",
      "The QFI norm along [1, 1, 1, 1] at [5.96902604 5.96902604 1.16512394 3.98858905] is 5.86965007.\n",
      "The QFI norm along [1, 1, 1, 1] at [6.28318531 6.28318531 1.16512394 3.98858905] is 6.00315457.\n",
      "The QFI norm along [1, 1, 1, 1] at [6.59734457 6.59734457 1.16512394 3.98858905] is 5.92686631.\n",
      "The QFI norm along [1, 1, 1, 1] at [6.91150384 6.91150384 1.16512394 3.98858905] is 5.84580996.\n",
      "The QFI norm along [1, 1, 1, 1] at [7.2256631  7.2256631  1.16512394 3.98858905] is 5.85057798.\n",
      "The QFI norm along [1, 1, 1, 1] at [7.53982237 7.53982237 1.16512394 3.98858905] is 5.93163433.\n",
      "The QFI norm along [1, 1, 1, 1] at [7.85398163 7.85398163 1.16512394 3.98858905] is 6.00315457.\n",
      "The QFI norm along [1, 1, 1, 1] at [8.1681409  8.1681409  1.16512394 3.98858905] is 5.87441809.\n",
      "The QFI norm along [1, 1, 1, 1] at [8.48230016 8.48230016 1.16512394 3.98858905] is 5.37854233.\n",
      "The QFI norm along [1, 1, 1, 1] at [8.79645943 8.79645943 1.16512394 3.98858905] is 4.49167993.\n",
      "The QFI norm along [1, 1, 1, 1] at [9.1106187  9.1106187  1.16512394 3.98858905] is 3.29010873.\n",
      "The QFI norm along [1, 1, 1, 1] at [9.42477796 9.42477796 1.16512394 3.98858905] is 1.98361799.\n",
      "The QFI norm along [1, 1, 1, 1] at [9.73893723 9.73893723 1.16512394 3.98858905] is 0.88691220.\n",
      "The QFI norm along [1, 1, 1, 1] at [10.05309649 10.05309649  1.16512394  3.98858905] is 0.25749165.\n",
      "The QFI norm along [1, 1, 1, 1] at [10.36725576 10.36725576  1.16512394  3.98858905] is 0.27179672.\n",
      "The QFI norm along [1, 1, 1, 1] at [10.68141502 10.68141502  1.16512394  3.98858905] is 0.90598547.\n",
      "The QFI norm along [1, 1, 1, 1] at [10.99557429 10.99557429  1.16512394  3.98858905] is 2.02176400.\n",
      "The QFI norm along [1, 1, 1, 1] at [11.30973355 11.30973355  1.16512394  3.98858905] is 3.32825413.\n",
      "The QFI norm along [1, 1, 1, 1] at [11.62389282 11.62389282  1.16512394  3.98858905] is 4.51552044.\n",
      "The QFI norm along [1, 1, 1, 1] at [11.93805208 11.93805208  1.16512394  3.98858905] is 5.39761453.\n",
      "The QFI norm along [1, 1, 1, 1] at [12.25221135 12.25221135  1.16512394  3.98858905] is 5.87441809.\n",
      "The QFI norm along [1, 1, 1, 1] at [12.56637061 12.56637061  1.16512394  3.98858905] is 6.00315457.\n"
     ]
    }
   ],
   "source": [
    "qf = QuantumFisher(cir)\n",
    "v = [1, 1, 1, 1]\n",
    "# 记录 QFIM 投影\n",
    "list_qfisher_norm = []\n",
    "num_thetas = 41\n",
    "thetas = np.linspace(0, np.pi * 4, num_thetas)\n",
    "for theta in thetas:\n",
    "    list_param = cir.param.tolist()\n",
    "    list_param[0] = theta\n",
    "    list_param[1] = theta\n",
    "    cir.update_param(list_param)\n",
    "    # 计算 QFIM 投影\n",
    "    qfisher_norm = qf.get_qfisher_norm(v)\n",
    "    print(\n",
    "        f'The QFI norm along {v} at {np.array(list_param)} is {qfisher_norm:.8f}.'\n",
    "    )\n",
    "    list_qfisher_norm.append(qfisher_norm)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 创建图像\n",
    "fig = plt.figure(figsize=(9, 6))\n",
    "ax = fig.add_subplot(111)\n",
    "# 绘制 QFIM 投影\n",
    "ax.plot(thetas, list_qfisher_norm, 's', markersize=11, markerfacecolor='none')\n",
    "analytical_qfi_norm = 4 + 2 * np.sin(thetas) + 2 * np.cos(thetas) - 2 * np.cos(thetas) * np.sin(thetas)\n",
    "ax.plot(thetas, analytical_qfi_norm, linestyle=(0, (5, 3)))\n",
    "# 设置图例，标签，刻度\n",
    "ax.legend(\n",
    "    ['get_qfisher_norm()', '$4+2\\\\sin\\\\theta+2\\\\cos\\\\theta-2\\\\sin\\\\theta\\\\cos\\\\theta$'], \n",
    "    loc='best', prop= {'size': label_font_size}, frameon=False,\n",
    ")\n",
    "ax.set_xlabel('$\\\\theta$', fontsize=label_font_size)\n",
    "ax.set_ylabel('QFI norm along $v=(1,1,1,1)$', fontsize=label_font_size)\n",
    "ax.set_ylim([-1, 9])\n",
    "ax.tick_params(labelsize=label_font_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到程序的输出和解析结果是一致的。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算有效量子维数\n",
    "\n",
    "利用量桨，我们可以通过调用 `get_eff_qdim()` 方法方便地计算有效量子维数（effective quantum dimension, EQD）。以下是上面提到的 hardware-efficient 拟设的 EQD 计算示例。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(5.101)----*----Ry(1.234)--\n",
      "               |               \n",
      "--Ry(5.941)----x----Ry(4.639)--\n",
      "                               \n",
      "The number of parameters is 4.\n",
      "The EQD is 3. \n",
      "\n"
     ]
    }
   ],
   "source": [
    "cir = circuit_hardeff_2qubit()\n",
    "qf = QuantumFisher(cir)\n",
    "print(cir)\n",
    "print(f'The number of parameters is {len(cir.param.tolist())}.')\n",
    "print(f'The EQD is {qf.get_eff_qdim()}. \\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在这个例子中，EQD 比参数个数要少，这实际上可以通过控制电路上两个 $R_y$ 可以直接合并这一点上看出来。这可以通过替换其中一个 $R_y$ 门为 $R_x$ 门来修复，这会使得 EQD 增长 1。\n",
    "\n",
    "如果继续在电路上增加门，EQD 会无限增长吗？答案显然是不会，这是因为对于 $n$ 个量子比特，量子态的实数自由度为 $2\\cdot 2^n-2$，其中减 $2$ 是由于归一化和全局相位无关性这两条约束。这说明无论门的数量为多少，EQD 都不会超过 $2\\cdot 2^n-2$。我们可以通过下面的例子做一简单的验证。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--Ry(2.643)----Rx(4.541)----*----Ry(4.525)----Rx(2.093)--\n",
      "                            |                            \n",
      "--Ry(6.033)----Rx(5.897)----x----Ry(3.874)----Rx(5.445)--\n",
      "                                                         \n",
      "The number of parameters is 8.\n",
      "The EQD is 6. \n",
      "\n"
     ]
    }
   ],
   "source": [
    "def circuit_hardeff_overparam():\n",
    "    cir = Circuit(2)\n",
    "    cir.ry()\n",
    "    cir.rx()\n",
    "    cir.cnot([0, 1])\n",
    "    cir.ry()\n",
    "    cir.rx()\n",
    "\n",
    "    return cir\n",
    "\n",
    "\n",
    "cir = circuit_hardeff_overparam()\n",
    "qf = QuantumFisher(cir)\n",
    "print(cir)\n",
    "print(f'The number of parameters is {len(cir.param.tolist())}.')\n",
    "print(f'The EQD is {qf.get_eff_qdim()}. \\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 计算经典费舍信息和有效维数\n",
    "\n",
    "这里我们举一个简单的例子来展示如何利用量桨对于一个量子神经网络计算式 (16) 中的有效维数。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "调用飞桨定义量子神经网络和相应的损失函数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "import paddle.nn as nn\n",
    "from paddle_quantum.ansatz.layer import ComplexEntangledLayer\n",
    "from paddle_quantum.gate import IQPEncoding, RX\n",
    "from paddle_quantum.loss import ExpecVal\n",
    "from paddle_quantum.hamiltonian import Hamiltonian\n",
    "from paddle_quantum.state import zero_state\n",
    "\n",
    "class QuantumNeuralNetwork(nn.Layer):\n",
    "    def __init__(self, num_qubits, depth, encoding):\n",
    "        super().__init__()\n",
    "        self.num_qubits, self.encoding = num_qubits, encoding\n",
    "        self.S = [[i, i + 1] for i in range(num_qubits - 1)]\n",
    "        self.init_state = zero_state(num_qubits)\n",
    "        self.loss_func = ExpecVal(Hamiltonian([[1.0, 'z0']]))\n",
    "        \n",
    "        if encoding == 'IQP':\n",
    "            self.complex_layer = nn.LayerList([ComplexEntangledLayer(num_qubits=num_qubits, depth=depth)])\n",
    "        elif encoding == 're-uploading':\n",
    "            self.complex_layers = nn.LayerList([ComplexEntangledLayer(num_qubits=num_qubits) for _ in range(depth + 1)])\n",
    "        else:\n",
    "            raise RuntimeError('Non-existent encoding method')\n",
    "\n",
    "    def forward(self, x):\n",
    "        if not paddle.is_tensor(x):\n",
    "            x = paddle.to_tensor(x, dtype='float32')\n",
    "\n",
    "        state = self.init_state\n",
    "        if self.encoding == 'IQP':\n",
    "            state = IQPEncoding(x, qubits_idx=self.S)(state)\n",
    "            state = self.complex_layer[0](state)\n",
    "        else:\n",
    "            for i in range(depth):\n",
    "                state = self.complex_layers[i](state)\n",
    "                for j in range(num_qubits):\n",
    "                    state = RX(j, param=x[j].item())(state)\n",
    "            state = self.complex_layers[depth](state)\n",
    "\n",
    "        return self.loss_func(state) * 0.5 + 0.5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "最后，定义 CFIM 计算器并计算不同大小的训练集对应的有效维数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "running in get_gradient: 100%|##################################| 1000/1000 [00:29<00:00, 33.93it/s]\n"
     ]
    }
   ],
   "source": [
    "from paddle_quantum import set_backend\n",
    "\n",
    "# 配置模型参数\n",
    "num_qubits = 4\n",
    "depth = 2\n",
    "num_inputs = 100\n",
    "num_thetas = 10\n",
    "set_backend('state_vector')\n",
    "# 定义 CFIM 计算器\n",
    "cfim = ClassicalFisher(model=QuantumNeuralNetwork,\n",
    "                       num_thetas=num_thetas,\n",
    "                       num_inputs=num_inputs,\n",
    "                       num_qubits=num_qubits,\n",
    "                       depth=depth,\n",
    "                       encoding='IQP')\n",
    "# 计算归一化的 CFIM\n",
    "fim, _ = cfim.get_normalized_cfisher()\n",
    "# 计算不同样本大小对应的有效维数\n",
    "n = [5000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000, 1000000]\n",
    "effdim = cfim.get_eff_dim(fim, n)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "画出有效维数与参数个数之比随训练集大小的变化规律。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "the number of parameters：24\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 900x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(9, 6))\n",
    "ax = fig.add_subplot(111)\n",
    "print('the number of parameters：%s' % cfim.num_params)\n",
    "ax.plot(n, np.array(effdim) / cfim.num_params)\n",
    "label_font_size = 14\n",
    "ax.set_xlabel('sample size', fontsize=label_font_size)\n",
    "ax.set_ylabel('effective dimension / number of parameters', fontsize=label_font_size)\n",
    "ax.tick_params(labelsize=label_font_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 总结\n",
    "\n",
    "本教程从几何的角度简要介绍了经典费舍信息和量子费舍信息的概念及二者之间的关系，并以有效维数为例阐述了它们在量子机器学习中的应用，最后展示了如何调用量桨来具体地计算它们。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_______\n",
    "\n",
    "## 参考文献\n",
    "\n",
    "[1] Meyer, Johannes Jakob. \"Fisher information in noisy intermediate-scale quantum applications.\" [arXiv preprint arXiv:2103.15191 (2021).](https://arxiv.org/abs/2103.15191)\n",
    "\n",
    "[2] Haug, Tobias, Kishor Bharti, and M. S. Kim. \"Capacity and quantum geometry of parametrized quantum circuits.\" [arXiv preprint arXiv:2102.01659 (2021).](https://arxiv.org/abs/2102.01659)\n",
    "\n",
    "[3] Stokes, James, et al. \"Quantum natural gradient.\" [Quantum 4 (2020): 269.](https://quantum-journal.org/papers/q-2020-05-25-269/)\n",
    "\n",
    "[4] Mari, Andrea, Thomas R. Bromley, and Nathan Killoran. \"Estimating the gradient and higher-order derivatives on quantum hardware.\" [Physical Review A 103.1 (2021): 012405.](https://journals.aps.org/pra/abstract/10.1103/PhysRevA.103.012405)\n",
    "\n",
    "[5] Datta, Nilanjana, and Felix Leditzky. \"A limit of the quantum Rényi divergence.\" [Journal of Physics A: Mathematical and Theoretical 47.4 (2014): 045304.](https://iopscience.iop.org/article/10.1088/1751-8113/47/4/045304)\n",
    "\n",
    "[6] Abbas, Amira, et al. \"The power of quantum neural networks.\" [Nature Computational Science 1.6 (2021): 403-409.](https://www.nature.com/articles/s43588-021-00084-1)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "2ab84abaf8d5bbc8765aba8eb82d11e7069f2ff20e8f79b8a9cdeccefd2ac4da"
  },
  "kernelspec": {
   "display_name": "Python 3.8.13 ('pq_new')",
   "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
}