docs/source/tutorials/vqe_h2o_cn.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# 分子上的变分量子本征求解器 (VQE)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 概述\n",
    "\n",
    "VQE 是一种变分算法，用于计算满足 $H \\left|\\psi_g\\right> =E_g\\left|\\psi_g\\right>$ 的给定哈密顿 H 的基态，我们称之为 $\\psi_g$。对于任意归一化波函数 $\\psi_f$，期望值 $\\left<\\psi_f|H|\\psi_f \\right>$ 总是不低于基态能量，除非 $\\psi_f = \\psi_g$  (这里我们假设基态没有简并）。基于这个事实，如果我们使用参数化波函数 $\\psi_\\theta$，例如由具有参数 $\\theta$ 的参数化量子电路 (PQC) 给出，我们可以通过最小化 $H$ 的期望值来给出基态能量和波函数的近似值。在实际的量子硬件中，该算法可以在量子-经典混合范式中实现，在量子硬件中使用有限差分或参数移位计算梯度，在经典计算机中使用梯度下降法进行优化。在数值模拟中，我们可以使用自动微分计算梯度。\n",
    "\n",
    "\n",
    "计算分子的基态能量对于量子化学任务通常很重要，因为它可以用来找出分子的原子结构。在分子的模拟中，我们不考虑原子核的运动，这意味着我们固定了其组成原子的原子核坐标。我们只考虑分子中的电子，因为原子核比电子重得多，因此声子携带的能量可以忽略不计，或者可以使用 Born-Oppenheimer 近似重新考虑。严格来说，电子存在于连续空间中，因此希尔伯特空间是无限维的。为了进行实际计算，我们只保留一些重要的单粒子基，例如低能原子轨道。在二次量子化形式中，我们可以将这些原子轨道表示为 $c_i^\\dagger|0>$。通过考虑原子核和电子的相互作用作为背景以及电子 - 电子相互作用，分子哈密顿量通常可以表示为 $H = \\sum_{i, j} h_{i,j} c_i^\\dagger c_j + \\sum_{i, j, k, l} \\alpha_{i, j, k, l} c_i^\\dagger c_j^\\dagger c_k c_l$。请注意，自旋指数也被吸收到轨道指数中。有很多软件可以在 H 中给出这些参数，例如我们将在本教程后面使用的 pyscf。现在我们有了对分子的费米子描述。通过使用从费米子算子到自旋算子的映射，例如 Jordan-Wigner 变换或 Bravyi-Kitaev 变换，我们可以将费米子哈密顿算子映射到与量子计算机更兼容的自旋哈密顿算子。对于自旋哈密顿算子，我们可以很容易地使用 PQC 来构造轨迹波函数并进行 VQE 算法。在本教程的以下部分，我们将演示如何使用 TensorCircuit 在分子上模拟 VQE 算法的完整示例。"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 设置\n",
    "\n",
    "我们应该首先 ``pip install openfermion openfermionpyscf`` 根据 openfermion 和 pyscf 提供的量子化学计算生成H2O分子的费米子和量子比特哈密顿量。"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "import numpy as np\n",
    "from openfermion.chem import MolecularData\n",
    "from openfermion.transforms import (\n",
    "    get_fermion_operator,\n",
    "    jordan_wigner,\n",
    "    binary_code_transform,\n",
    "    checksum_code,\n",
    "    reorder,\n",
    ")\n",
    "from openfermion.chem import geometry_from_pubchem\n",
    "from openfermion.utils import up_then_down\n",
    "from openfermion.linalg import LinearQubitOperator\n",
    "from openfermionpyscf import run_pyscf\n",
    "import tensorflow as tf\n",
    "\n",
    "import tensorcircuit as tc\n",
    "\n",
    "K = tc.set_backend(\"tensorflow\")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## 生成哈密顿量"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "* 获取分子能量信息和分子轨道\n"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "multiplicity = 1\n",
    "basis = \"sto-3g\"\n",
    "# H2O 的 14 个自旋轨道\n",
    "geometry = geometry_from_pubchem(\"h2o\")\n",
    "description = \"h2o\"\n",
    "molecule = MolecularData(geometry, basis, multiplicity, description=description)\n",
    "molecule = run_pyscf(molecule, run_mp2=True, run_cisd=True, run_ccsd=True, run_fci=True)\n",
    "print(molecule.fci_energy, molecule.ccsd_energy, molecule.hf_energy)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "-75.0155301894916 -75.01540899923558 -74.96444758276998\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "* 获取费米子哈密顿量"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "mh = molecule.get_molecular_hamiltonian()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "fh = get_fermion_operator(mh)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "print(fh.terms[((0, 1), (0, 0))])  # 获取费米子哈密顿量"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "-32.68991541360029\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "* 转换为量子比特哈密顿量"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "# 对于 H2O 的 14 个轨道，诸如 JW 或 BK 之类的正常变换需要 14 个量子位\n",
    "\n",
    "a = jordan_wigner(fh)\n",
    "LinearQubitOperator(a).n_qubits"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "14"
      ]
     },
     "metadata": {},
     "execution_count": 6
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "我们可以使用二进制编码来保存另外两个量子位，因为自旋向上和自旋向下填充的数量都是 5（5/7 个轨道中的奇数电子）"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "b = binary_code_transform(reorder(fh, up_then_down), 2 * checksum_code(7, 1))\n",
    "# 7 是 7 个自旋极化轨道，1 是奇数占用\n",
    "LinearQubitOperator(b).n_qubits"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "metadata": {},
     "execution_count": 7
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "print(b.terms[((0, \"Z\"),)])  # Z_0 泡利字符串的系数"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "12.412562749393349\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "* 将 openfermion 中的量子比特哈密顿量转换为 TensorCircuit 中的格式"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "lsb, wb = tc.templates.chems.get_ps(b, 12)\n",
    "lsa, wa = tc.templates.chems.get_ps(a, 14)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "* 以矩阵形式检查哈密顿量"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "ma = tc.quantum.PauliStringSum2COO_numpy(lsa, wa)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "source": [
    "mb = tc.quantum.PauliStringSum2COO_numpy(lsb, wb)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "source": [
    "mad, mbd = ma.todense(), mb.todense()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "这两种哈密顿量对应的 Hartree Fock 乘积状态"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "source": [
    "bin(np.argmin(np.diag(mad)))"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'0b11111111110000'"
      ]
     },
     "metadata": {},
     "execution_count": 13
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "source": [
    "bin(np.argmin(np.diag(mbd)))"
   ],
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "'0b111110111110'"
      ]
     },
     "metadata": {},
     "execution_count": 14
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## VQE 设置\n",
    "\n",
    "原则上，我们可以将哈密顿量的每个泡利串评估为期望测量，但它会花费大量模拟时间，相反，我们将它们融合为如上所示的哈密顿矩阵来运行 VQE。"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "* 使用密集矩阵期望"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "source": [
    "n = 12\n",
    "depth = 4\n",
    "mbd_tf = tc.array_to_tensor(mbd)\n",
    "\n",
    "\n",
    "def vqe(param):\n",
    "    c = tc.Circuit(n)\n",
    "    for i in [0, 1, 2, 3, 4, 6, 7, 8, 9, 10]:\n",
    "        c.X(i)\n",
    "    for j in range(depth):\n",
    "        for i in range(n - 1):\n",
    "            c.exp1(i, i + 1, unitary=tc.gates._xx_matrix, theta=param[j, i, 0])\n",
    "        for i in range(n):\n",
    "            c.rx(i, theta=param[j, i, 1])\n",
    "        for i in range(n):\n",
    "            c.ry(i, theta=param[j, i, 2])\n",
    "        for i in range(n):\n",
    "            c.rx(i, theta=param[j, i, 3])\n",
    "    return tc.templates.measurements.operator_expectation(c, mbd_tf)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "source": [
    "vags = tc.backend.jit(tc.backend.value_and_grad(vqe))\n",
    "lr = tf.keras.optimizers.schedules.ExponentialDecay(\n",
    "    decay_rate=0.5, decay_steps=300, initial_learning_rate=0.5e-2\n",
    ")\n",
    "opt = tc.backend.optimizer(tf.keras.optimizers.Adam(lr))\n",
    "\n",
    "param = tc.backend.implicit_randn(shape=[depth, n, 4], stddev=0.02, dtype=\"float32\")\n",
    "for i in range(600):\n",
    "    e, g = vags(param)\n",
    "    param = opt.update(g, param)\n",
    "    if i % 100 == 0:\n",
    "        print(e)"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "tf.Tensor(-74.76671, shape=(), dtype=float32)\n",
      "tf.Tensor(-74.95493, shape=(), dtype=float32)\n",
      "tf.Tensor(-74.95319, shape=(), dtype=float32)\n",
      "tf.Tensor(-74.954315, shape=(), dtype=float32)\n",
      "tf.Tensor(-74.956116, shape=(), dtype=float32)\n",
      "tf.Tensor(-74.95809, shape=(), dtype=float32)\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "* 使用稀疏矩阵期望\n",
    "\n",
    "我们还可以使用稀疏哈密顿矩阵进行电路期望评估，唯一的区别是将 ``mbd_tf`` 替换为 ``mb_tf``"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "source": [
    "mb_tf = tc.backend.coo_sparse_matrix(\n",
    "    np.transpose(np.stack([mb.row, mb.col])), mb.data, shape=(2**n, 2**n)\n",
    ")"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "稀疏矩阵评估和密集矩阵评估之间的一个微基准，用于比较计算期望的时间，当然，稀疏总是在空间方面获胜。"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "source": [
    "def dense_expt(param):\n",
    "    c = tc.Circuit(n)\n",
    "    for i in range(n):\n",
    "        c.H(i)\n",
    "        c.rx(i, theta=param[i])\n",
    "    return tc.templates.measurements.operator_expectation(c, mbd_tf)\n",
    "\n",
    "\n",
    "def sparse_expt(param):\n",
    "    c = tc.Circuit(n)\n",
    "    for i in range(n):\n",
    "        c.H(i)\n",
    "        c.rx(i, theta=param[i])\n",
    "    return tc.templates.measurements.operator_expectation(c, mb_tf)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "source": [
    "dense_vag = tc.backend.jit(tc.backend.value_and_grad(dense_expt))\n",
    "sparse_vag = tc.backend.jit(tc.backend.value_and_grad(sparse_expt))\n",
    "\n",
    "v0, g0 = dense_vag(tc.backend.ones([n]))\n",
    "v1, g1 = sparse_vag(tc.backend.ones([n]))\n",
    "\n",
    "# 一致性检查\n",
    "\n",
    "np.testing.assert_allclose(v0, v1, atol=1e-5)\n",
    "np.testing.assert_allclose(g0, g1, atol=1e-5)"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "source": [
    "%timeit dense_vag(tc.backend.ones([n]))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "30.7 ms ± 1.45 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "source": [
    "%timeit sparse_vag(tc.backend.ones([n]))"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "3.6 ms ± 63 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "因此，稀疏矩阵求值除了节省空间外，还可以节省时间，这总是被推荐的。"
   ],
   "metadata": {}
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}