在量子化学计算中应用量子变分求解器

概述

量子化学，指的是运用量子力学的基本理论及方法，求解含时或定态薛定谔方程的数值解。在高性能计算机上进行量子化学模拟已成为研究材料的物理、化学性质的重要手段。然而，精确求解薛定谔方程具有指数级的复杂度，可模拟的化学体系规模严重受制于此。近年量子计算的发展为解决这个问题提供了一条可行的路，有望在量子计算机上实现多项式复杂度下对薛定谔方程的高精度求解。

Peruzzo等人在2014年首次将量子变分求解器(Variational quantum eigensolver, VQE)结合幺正耦合簇理论用于量子化学的模拟中，实现了He-H+基态能量的求解。量子变分求解器是一个量子–经典混合算法，在基于量子算法的化学模拟中应用广泛，本教程将介绍使用量子变分求解器求解分子体系基态能量的方法。

本教程的主要内容包括如下几个部分：

量子化学原理简介。
量子变分求解器的应用。
使用MindQuantum实现高效自动求导的VQE模拟。

本文档适用于CPU环境。

你可以在这里找到完整的可运行的样例代码：https://gitee.com/mindspore/mindquantum/blob/r0.3/tutorials/source/vqe_for_quantum_chemistry.py。

环境准备

本教程需要安装以下环境：

NumPy
SciPy
mindquantum
mindspore
PySCF
openfermion
openfermionpyscf

以上依赖都可通过pip命令来安装。

如果没有安装MindQuantum，可通过如下命令安装MindQuantum。

[ ]:

!pip install https://ms-release.obs.cn-north-4.myhuaweicloud.com/1.4.0/MindQuantum/any/mindquantum-0.3.0-py3-none-any.whl -i https://pypi.tuna.tsinghua.edu.cn/simple

导入依赖

导入本教程所依赖模块

[1]:

import numpy as np
from openfermion.chem import MolecularData
from openfermionpyscf import run_pyscf
import mindquantum as mq
from mindquantum.circuit import Circuit
from mindquantum.gate import X, RX, Hamiltonian
from mindquantum.circuit import generate_uccsd
from mindquantum.nn import generate_pqc_operator
import mindspore as ms
import mindspore.context as context
from mindspore import Parameter
from mindspore.common.initializer import initializer

context.set_context(mode=context.GRAPH_MODE, device_target="CPU")

量子化学计算方法

量子化学的核心问题在于求解薛定谔方程（Schrödinger Equation）。一般来说，求解含时薛定谔方程（Time-dependent Schrödinger Equation)较为复杂，故引入玻恩-奥本海默近似（Born-Oppenheimer approximation, BO approximation）。BO近似认为，原子核质量远大于电子、运动速度远低于电子，故可以将两者进行分离变量，单独讨论原子核或电子的运动，于是可得到如下不含时的电子运动方程，也称为定态薛定谔方程：

\[\hat{H} |\Psi\rangle = E |\Psi\rangle\]

其中\(\hat{H}\)包含以下三项：

\[\hat{H} = \hat{K} _{e} + \hat{V} _{ee} + \hat{V} _{Ne}\]

分别为电子动能、电子-电子势能和电子-核势能。

有多种数值算法可以求解定态薛定谔方程。本教程将介绍其中的一类：波函数方法。波函数方法直接求解给定分子哈密顿量的本征函数和本征能量，目前有大量的开源软件包可实现，如PySCF等。此处从一个简单的例子：氢化锂分子开始，使用openfermion结合openfermionpyscf插件进行。首先定义分子结构：

[2]:

dist = 1.5
geometry = [
    ["Li", [0.0, 0.0, 0.0 * dist]],
    ["H",  [0.0, 0.0, 1.0 * dist]],
]
basis = "sto3g"
spin = 0
print("Geometry: \n", geometry)

Geometry:
 [['Li', [0.0, 0.0, 0.0]], ['H', [0.0, 0.0, 1.5]]]

上面的代码定义了一个Li-H键长为1.5Å分子。使用STO-3G基组进行计算。接下来使用openfermionpyscf，调用PySCF进行HF、CCSD和FCI计算。这三种方法属于波函数方法，开始计算之前，先对这些方法作一个简单的介绍。

波函数方法

求解定态薛定谔方程的方法之一是Hartree-Fock（HF）方法，该方法在二十世纪三十年代左右由Hartree等人提出，是量子化学计算中的基本方法。HF方法引入了单行列式近似，即\(N\)-电子体系的波函数由一个行列式形式的波函数表示：

\[| \Psi \rangle = | \psi_{1} \psi_{2} \psi_{3} \dots \psi_{N} \rangle\]

其中\(| \psi_{1} \psi_{2} \psi_{3} \dots \rangle\)代表由一组自旋轨道波函数\(\{ \pi_{i} \}\)构成的N阶行列式。自旋轨道波函数\(\psi_{i}\)可进一步用一组形式已知的基函数展开：

\[\psi_{i} = \phi_{i} \eta_{i}\]

\[\phi_{i} = \sum_{\mu}{C_{\mu i} \chi_{\mu}}\]

其中\(\{\chi_{\mu}\}\)被称为基函数，可以是高斯函数等。该近似考虑了电子间的交换作用，但是忽略了电子间的关联作用，故无法正确计算如解离能等性质。

HF方法的改进可以从波函数展开定理出发。波函数展开定理可以表述为，若\(\{ \psi_{i} \}\)是一组完备的自旋轨道波函数，则\(N\)-电子体系波函数可以由\(\{ \psi_{i} \}\)构成的行列式波函数精确展开：

\[| \Psi \rangle = \sum^{\infty} _ {i_{1} < i_{2} < \dots < i_{N}} {C_{i_{1} i_{2} \dots i_{N}} | \psi_{i_{1}} \psi_{i_{2}} \dots \psi_{i_{N}} \rangle}\]

由此可得到Configuration Interaction（CI）方法：

\[\begin{split}| \Psi_{CI} \rangle = C_{0} | \Psi_{HF} \rangle + \sum^{a\rightarrow\infty} _{i\in occ\\\\a\not\in occ}{C^{a} _{i} | \Psi^{a} _{i} \rangle } + \sum^{ab\rightarrow\infty} _{ij\in occ\\\\ab\not\in occ}{C^{ab} _{ij} | \Psi^{ab} _{ij} \rangle }\end{split}\]

上式中的\(| \Psi^{a}_{i} \rangle + \dots\)代表电子由轨道\(i\)激发到轨道\(a\)的单激发波函数，以此类推。只考虑单激发和双激发的CI被称为CISD，即Configuration Interaction with singles and doubles。将基态HF波函数一直到N激发波函数全部考虑在内的Configuration Interaction被称为Full Configuration Interaction（FCI），FCI波函数是定态薛定谔方程在给定基函数下的精确解。

二次量子化

在二次量子化表述下，体系的哈密顿量具有如下形式：

\[\hat{H} = \sum_{p, q}{h^{p} _ {q} E^{p} _ {q}} + \sum_{p, q, r, s}{\frac{1}{2} g^{pq} _ {rs} E^{pq} _ {rs} }\]

其中\(E^{p} _ {q}\)和\(E^{pq} _ {rs}\)分别为：

\[E^{p} _ {q} = a^{\dagger} _ {p} a_{q}\]

\[E^{pq} _ {rs} = a^{\dagger} _ {p} a^{\dagger} _ {q} a_{r} a_{s}\]

\(a^{\dagger} _ {p}\)和\(a _ {q}\)分别为产生算符（Creation Operator）和湮灭算符（Annihilation Operator）。

使用二次量子化的表述方法，可以非常方便地表示激发态波函数：

\[| \Psi^{abc\dots} _ {ijk\dots} \rangle = a^{\dagger} _ {a} a^{\dagger} _ {b} a^{\dagger} _ {c} \dots a_{i} a_{j} a_{k} \dots | \Psi \rangle\]

CI方法的一个改进是耦合簇理论（Coupled-Cluster theory, CC）。CC引入指数化算符：

\[| \Psi_{CC} \rangle = \exp{(\hat{T})} | \Psi_{HF} \rangle\]

其中耦合簇算符\(\hat{T}\)为对激发算符的求和：

\[\begin{split}\hat{T} = \sum_{p\not\in occ\\\\q\in occ}{\theta^{p} _ {q} E^{p} _ {q}} + \sum_{pq\not\in occ\\\\rs\in occ}{\theta^{pq} _ {rs} E^{pq} _ {rs}} + \dots\end{split}\]

其中\(\theta\)和CI方法中的\(C\)类似，是待求解的参数。由指数的泰勒展开易知，即使耦合簇算符\(\hat{T}\)中只包含低阶激发项，\(\exp{(\hat{T})}\)也可以隐含部分高阶激发，这也使得CC方法向FCI波函数收敛的速度要远快于CI，同样截断到K激发，如K=2，CCSD的精度会超过CISD。

电子关联作用的效果是使得总能量降低，故HF得到的基态能量会略高于CCSD和FCI。另外，从上述理论不难发现，FCI的计算量远大于CCSD和HF。我们使用openfermion封装的MolecularData和openfermionpyscf封装的run_pyscf函数来进行演示：

[3]:

molecule_of = MolecularData(
    geometry,
    basis,
    multiplicity=2 * spin + 1
)
molecule_of = run_pyscf(
    molecule_of,
    run_scf=1,
    run_ccsd=1,
    run_fci=1
)

print("Hartree-Fock energy: %20.16f Ha" % (molecule_of.hf_energy))
print("CCSD energy: %20.16f Ha" % (molecule_of.ccsd_energy))
print("FCI energy: %20.16f Ha" % (molecule_of.fci_energy))

Hartree-Fock energy:  -7.8633576215351200 Ha
CCSD energy:  -7.8823529091527051 Ha
FCI energy:  -7.8823622867987249 Ha

在上面的例子中，我们运行了Hartree-Fock（HF）、CCSD、FCI进行总能量的计算。若对运行时间进行统计，会发现\(T_{HF}<T_{CCSD}\ll T_{FCI}\)，换成计算量更大的体系如乙烯分子等会更明显一些。此外，对于计算得到的总能量，有\(E_{HF}>E_{CCSD}>E_{FCI}\)。计算完成后，我们将结果保存到molecule_file文件（即molecule_of.filename）中：

[4]:

molecule_of.save()
molecule_file = molecule_of.filename
print(molecule_file)

/home/xuxs/anaconda3/envs/p37/lib/python3.7/site-packages/openfermion/testing/data/H1-Li1_sto3g_singlet

量子化学计算的一大阻碍是计算量。随着体系大小（电子数、原子数）的增加，求解FCI波函数和基态能量的时间消耗大约以\(2^{N}\)增长，即使是较小的分子如乙烯分子等，进行FCI计算也并不容易。量子计算机的出现为此提供了一条可能的解决途径，已有的研究表明，量子计算机可以多项式的时间复杂度模拟哈密顿量的含时演化，在量子处理器上进行化学模拟相较于经典计算机有指数级的加速。本教程将介绍其中一类量子算法：量子变分求解器。

量子变分求解器

量子变分求解器（Variational Quantum Eigensolver, VQE）是一类量子-经典混合（Hybrid quantum-classical）算法，应用变分原理实现对基态波函数的求解。其中，变分参数的优化步在经典计算机上进行。

变分原理

变分原理可使用如下形式表述：

\[E_{0} \le \frac{\langle \Psi_{t} | \hat{H} | \Psi_{t} \rangle}{\langle \Psi_{t} | \Psi_{t} \rangle}\]

上式中的\(| \Psi_{t} \rangle\)代表试探波函数。变分原理表明，在满足一定的条件下，任意试探波函数得到的基态能量总是大于等于真实的基态能量。变分原理为求解分子基态薛定谔方程提供了一种方法：使用一个参数化的函数\(f(\theta)\)作为精确基态波函数的近似，通过优化参数\(\theta\)来逼近精确的基态能量。

初态制备

在二次量子化表述下，\(N\)-电子HF波函数也具有非常简洁的形式：

\[| \Psi_{HF} \rangle = \prod^{i=0} _{N-1}{a^{\dagger} _{i}| 0 \rangle}\]

上式搭建了一个由量子化学波函数到量子计算的桥梁：用\(|0\rangle\)代表非占据轨道，用\(|1\rangle\)代表电子占据的轨道，由此可以将\(N\)-电子HF波函数映射为由一串\(M+N\)个量子比特\(| 00\dots 11\dots \rangle\)，\(M\)代表非占据轨道的数量。

以下代码构造了对应于LiH分子的HF初态波函数。在Jordan-Wigner变换下，相当于将\(N\)个\(\text{X}\)门作用于\(|000\dots\rangle\)上。

[5]:

hartreefock_wfn_circuit = Circuit([X.on(i) for i in range(molecule_of.n_electrons)])
print(hartreefock_wfn_circuit)

X(0)
X(1)
X(2)
X(3)

基于此，我们可以构造如下形式的试探波函数：

\[| \Psi_{t} \rangle = U(\theta) | \Psi_{HF} \rangle\]

其中\(U(\theta)\)代表一个可通过量子线路模拟的幺正变换，\(| \Psi_{HF} \rangle\)作为初态，可通过多个单比特\(\text{X}\)门来方便地制备。\(U(\theta) | \Psi_{HF} \rangle\)的具体形式也被称为波函数拟设。

波函数拟设

前文提到的耦合簇理论是一个非常高效的波函数拟设。在量子计算机上使用，需要作一些修改：

\[| \Psi_{UCC} \rangle = \exp{(\hat{T} - \hat{T}^{\dagger})} | \Psi_{HF} \rangle\]

UCC即幺正耦合簇(Unitary Coupled-Cluster theory)，\(\hat{T}^{\dagger}\)代表\(\hat{T}\)的厄米共轭。如此，\(\exp{(\hat{T} - \hat{T}^{\dagger})}\)即为幺正算符。Peruzzo等人在2014年首次使用VQE结合UCCSD(Unitary coupled-cluster with singles and doubles)拟设进行了量子计算机上的化学模拟实验。值得注意的是幺正耦合簇默认了耦合簇算符中的参数\(\{\theta\}\)是实数。在分子体系中该假设不会有问题；在周期性体系中，刘杰等人的研究表明幺正耦合簇会因为忽略复数部分而造成误差。本教程暂时不讨论幺正耦合簇在周期性体系中的应用。

使用mindquantum的circuit模块中的generate_uccsd函数可读取先前保存在molecule_file的计算结果，“一键”构造UCCSD波函数拟设，以及其对应的量子线路：

[6]:

ansatz_circuit, \
init_amplitudes, \
ansatz_parameter_names, \
hamiltonian_QubitOp, \
n_qubits, n_electrons = generate_uccsd(molecule_file, th=-1)

ccsd:-7.882352909152705.
fci:-7.882362286798725.

generate_uccsd将幺正耦合簇相关的函数打包了起来，包括导出分子哈密顿量、构造幺正耦合簇拟设算符、提取CCSD计算的耦合簇系数等多个步骤。该函数通过输入分子的文件路径来读取该分子，参数th是表示量子线路中哪些参数需要更新梯度的阈值。在分步构造幺正耦合簇拟设章节，我们会演示如何使用mindquantum的相关接口分步完成其中包含的步骤。完整的量子线路包含HF初态+UCCSD拟设，如下代码所示：

[7]:

total_circuit = hartreefock_wfn_circuit + ansatz_circuit
total_circuit.summary()
print("Number of parameters: %d" % (len(ansatz_parameter_names)))

==============================Circuit Summary==============================
|Total number of gates  : 12612.                                          |
|Parameter gates        : 640.                                            |
|with 44 parameters are : p40, p9, p8, p3, p32, p28, p15, p4, p18, p22... |
|Number qubit of circuit: 12                                              |
===========================================================================
Number of parameters: 44

对于LiH分子而言，其UCCSD波函数拟设中包含44个变分参数。该线路总共的量子比特门数量为12612，总共需要12个量子比特进行模拟。

VQE的一般流程

使用VQE进行分子基态求解的一般流程如下：

制备HF初态：\(| 00\dots11\dots \rangle\)；
定义波函数拟设，如UCCSD等；
将波函数拟设转化为参数化的量子线路；
初始化变分参数，如全设为0等；
在量子计算机上多次测量得到分子哈密顿量在该套变分参数下的能量\(E(\theta)\)以及能量关于参数的导数\(\{ {\partial E} / {\partial \theta_{i}} \}\)
在经典计算机上使用优化算法，如梯度下降、BFGS等更新变分参数；
将新的变分参数传入量子线路中进行更新；
重复步骤(5)到(7)，直到满足收敛标准；
结束

在第5步中，求取能量关于参数的导数\(\{ {\partial E} / {\partial \theta_{i}} \}\)在量子计算机上可通过parameter-shift rule来进行，在模拟器中也可通过模拟parameter-shift rule或者有限差分法来计算，是个较为耗时的过程。mindquantum基于mindspore框架，提供了类似于机器学习的自动求导功能，可以在模拟中可以高效计算参数化量子线路的导数。以下使用mindquantum构造带自动求导功能的参数化UCCSD量子线路：

[8]:

molecule_pqc = generate_pqc_operator(
    ["null"], ansatz_parameter_names,
    RX("null").on(0) + total_circuit,
    Hamiltonian(hamiltonian_QubitOp))

由于mindquantum需要提供两套线路（以及参数）分别作为Encoding circuit和Ansatz circuit，此处我们使用RX("null")作为一个Encoding circuit，在之后令参数null等于0将其无效化。通过将参数的具体数值传入molecule_pqc，即可得到对应于此变分参数的能量\(E(\theta)=\langle \Psi_{UCC}(\theta) | \hat{H} | \Psi_{UCC}(\theta) \rangle\)以及关于每个变分参数的导数。

接下来需要进行VQE优化的(5)~(7)步，即对参数化量子线路进行优化。我们可以借助MindSpore框架，使用参数化量子线路算子molecule_pqc构造一个神经网络模型，然后通过类似于训练神经网络的方法来优化变分参数：

[9]:

class PQCNet(ms.nn.Cell):
    def __init__(self, pqc):
        super(PQCNet, self).__init__()
        self.pqc = pqc
        self.weight =  Parameter(initializer("Zeros",
            len(self.pqc.ansatz_params_names)),
            name="weight")
        self.encoder_data_dummy = ms.Tensor([[0]],
            self.weight.dtype)

    def construct(self):
        energy, _, grads = self.pqc(self.encoder_data_dummy, self.weight)
        return energy

molecule_pqcnet = PQCNet(molecule_pqc)

此处我们手动构造了一个基本的PQCNet作为模型示例，该模型可以和常规的机器学习模型类似使用，比如优化权重、计算导数等。更好的选择是使用mindquantum中封装的MindQuantumAnsatzOnlyLayer，将会在后文中进行演示。

构造的PQCNet使用"Zeros"关键字，将所有的变分参数初始化为0。使用CCSD（耦合簇理论）或者MP2（二阶多体微扰论）的计算结果也可以作为幺正耦合簇变分参数的初始值。此时有\(E(\vec{0})=\langle \Psi_{UCC}(\vec{0}) | \hat{H} | \Psi_{UCC}(\vec{0}) \rangle = E_{HF}\)：

[10]:

initial_energy = molecule_pqcnet()
print("Initial energy: %20.16f" % (initial_energy.asnumpy()))

Initial energy:  -7.8633575439453125

最后使用mindspore的Adam优化器进行优化，学习率设置为\(1\times 10^{-2}\)，优化终止标准设置为\(\left.|\epsilon|\right. = \left.|E^{k+1} - E^{k}|\right. \le 1\times 10^{-8}\)

[11]:

optimizer = ms.nn.Adagrad(molecule_pqcnet.trainable_params(), learning_rate=4e-2)
train_pqcnet = ms.nn.TrainOneStepCell(molecule_pqcnet, optimizer)

eps = 1.e-8
energy_diff = eps * 1000
energy_last = initial_energy.asnumpy() + energy_diff
iter_idx = 0
while (abs(energy_diff) > eps):
    energy_i = train_pqcnet().asnumpy()
    if iter_idx % 5 == 0:
        print("Step %3d energy %20.16f" % (iter_idx, float(energy_i)))
    energy_diff = energy_last - energy_i
    energy_last = energy_i
    iter_idx += 1

print("Optimization completed at step %3d" % (iter_idx - 1))
print("Optimized energy: %20.16f" % (energy_i))
print("Optimized amplitudes: \n", molecule_pqcnet.weight.asnumpy())

Step   0 energy  -7.8633575439453125
Step   5 energy  -7.8726239204406738
Step  10 energy  -7.8821778297424316
Step  15 energy  -7.8822836875915527
Step  20 energy  -7.8823199272155762
Step  25 energy  -7.8823370933532715
Step  30 energy  -7.8823437690734863
Step  35 energy  -7.8618836402893066
Step  40 energy  -7.8671770095825195
Step  45 energy  -7.8751692771911621
Step  50 energy  -7.8822755813598633
Step  55 energy  -7.8812966346740723
Step  60 energy  -7.8823189735412598
Step  65 energy  -7.8823523521423340
Optimization completed at step  67
Optimized energy:  -7.8823528289794922
Optimized amplitudes:
 [ 2.3980068e-04  1.8912849e-03  3.5044324e-02  1.6005965e-02
 -1.9985158e-07  9.0940151e-04  1.6222824e-05  1.4160988e-02
 -1.1072063e-07  9.0867787e-04  1.3825165e-05  1.4166672e-02
 -5.4699212e-04  4.2679289e-04  2.8641545e-03  5.3817011e-02
  2.3320253e-04  1.7034533e-07  6.6684343e-08 -2.7686235e-07
  7.2332718e-08  1.2834757e-05 -1.0439425e-04  7.1826143e-08
  3.6483241e-06  6.1677817e-08  3.1003920e-06  7.9770159e-04
 -5.4951470e-02  3.0904056e-03 -4.4321241e-05  8.5840838e-07
 -1.9589644e-08 -4.9430941e-08  8.6163556e-07 -2.5008637e-07
  2.1493735e-08 -4.6331229e-06  3.0904033e-03  9.5311613e-08
 -4.8755901e-08  2.0483398e-08 -3.9453280e-06  3.7235476e-04]

可以看到，幺正耦合簇给出的计算结果和FCI非常接近，具有良好的精度。

分步构造幺正耦合簇拟设

在上文中，我们使用了generate_uccsd一步构造出了幺正耦合簇拟设所需要的所有内容，此处我们将步骤拆分，分别得到我们需要的耦合簇算符、对应的量子线路以及取自于经典CCSD计算结果的变分参数初猜值。首先，导入部分额外依赖，主要包含mindquantum中hiqfermion模块的相关函数：

[12]:

from mindquantum.hiqfermion.transforms import Transform
from mindquantum.hiqfermion.ucc import get_qubit_hamiltonian
from mindquantum.hiqfermion.ucc import uccsd_singlet_generator, uccsd_singlet_get_packed_amplitudes
from mindquantum.circuit import TimeEvolution
from mindquantum.nn import MindQuantumAnsatzOnlyLayer

分子哈密顿量使用get_qubit_hamiltonian，读取之前的计算结果得到：

[13]:

hamiltonian_QubitOp = get_qubit_hamiltonian(molecule_of)

对于幺正耦合簇算符\(\hat{T} - \hat{T}^{\dagger}\)，可以使用uccsd_singlet_generator进行构造。提供总量子比特数（总自旋轨道数）和总电子数，并设置参数anti_hermitian=True：

[14]:

ucc_fermion_ops = uccsd_singlet_generator(
    molecule_of.n_qubits, molecule_of.n_electrons, anti_hermitian=True)

上一步构造的ucc_fermion_ops是参数化的。使用Jordan-Wigner变换将费米子激发算符映射为Pauli算符：

[15]:

ucc_qubit_ops = Transform(ucc_fermion_ops).jordan_wigner()

接下来，我们需要得到幺正算符\(\exp{(\hat{T} - \hat{T}^{\dagger})}\)所对应的量子线路。TimeEvolution可生成\(\exp{(-i\hat{H}t)}\)所对应的线路，其中\(\hat{H}\)是一个厄米算符，\(t\)是实数。需要注意的是，使用TimeEvolution时，ucc_qubit_ops中已经包含了复数因子\(i\)，所以我们需要将ucc_qubit_ops除以\(i\)，或者提取其虚部：

[16]:

ansatz_circuit = TimeEvolution(ucc_qubit_ops.imag, 1.0).circuit
ansatz_parameter_names = ansatz_circuit.para_name

我们使用ansatz_parameter_names记录该线路中的参数名。到目前为止，我们已经得到了VQE量子线路所需要内容，包括哈密顿量hamiltonian_QubitOp、参数化的波函数拟设线路ansatz_circuit，故可仿照前文，得到完整的态制备线路。其中Hartree-Fock参考态复用之前的hartreefock_wfn_circuit：

[17]:

total_circuit = hartreefock_wfn_circuit + ansatz_circuit
total_circuit.summary()

======================================Circuit Summary======================================
|Total number of gates  : 12612.                                                          |
|Parameter gates        : 640.                                                            |
|with 44 parameters are : d1_3, d2_26, d2_6, d2_1, d2_2, d2_14, d1_1, s_1, d2_16, d2_11...|
|Number qubit of circuit: 12                                                              |
===========================================================================================

下一步，需要为变分参数提供一个合理的初始值。前文构造的PQCNet默认使用0作为初猜，在大多数情况下是可行的。不过，使用CCSD的计算数据作为UCC的出发点，可能会有更好的结果。使用uccsd_singlet_get_packed_amplitudes函数从molecule_of提取CCSD的参数：

[18]:

init_amplitudes_ccsd = uccsd_singlet_get_packed_amplitudes(
    molecule_of.ccsd_single_amps, molecule_of.ccsd_double_amps, molecule_of.n_qubits, molecule_of.n_electrons)
init_amplitudes_ccsd = [init_amplitudes_ccsd[param_i] for param_i in ansatz_parameter_names]

使用MindQuantumAnsatzOnlyLayer可以方便地由参数、量子线路获得以参数化量子线路为基础的机器学习模型：

[19]:

molecule_pqcnet = MindQuantumAnsatzOnlyLayer(
    ansatz_parameter_names, total_circuit, Hamiltonian(hamiltonian_QubitOp.real))

使用init_amplitudes_ccsd（即CCSD计算的耦合簇系数）作为初始变分参数：

[20]:

molecule_pqcnet.weight = Parameter(ms.Tensor(init_amplitudes_ccsd, molecule_pqcnet.weight.dtype))
initial_energy = molecule_pqcnet()
print("Initial energy: %20.16f" % (initial_energy.asnumpy()))

Initial energy:  -7.8173098564147949

在这个例子中，CCSD初猜并没有提供一个更好的起点。读者可以对更多的分子、更多种类的初始值（如随机数初猜）等进行测试和探究。最后进行VQE的优化步骤，优化器依然使用Adam，收敛标准不变。优化所用的代码与前文基本一致，注意更新相应的变量即可：

[21]:

optimizer = ms.nn.Adagrad(molecule_pqcnet.trainable_params(), learning_rate=4e-2)
train_pqcnet = ms.nn.TrainOneStepCell(molecule_pqcnet, optimizer)

print("eps: ", eps)
energy_diff = eps * 1000
energy_last = initial_energy.asnumpy() + energy_diff
iter_idx = 0
while (abs(energy_diff) > eps):
    energy_i = train_pqcnet().asnumpy()
    if iter_idx % 5 == 0:
        print("Step %3d energy %20.16f" % (iter_idx, float(energy_i)))
    energy_diff = energy_last - energy_i
    energy_last = energy_i
    iter_idx += 1

print("Optimization completed at step %3d" % (iter_idx - 1))
print("Optimized energy: %20.16f" % (energy_i))
print("Optimized amplitudes: \n", molecule_pqcnet.weight.asnumpy())

eps:  1e-08
Step   0 energy  -7.8173098564147949
Step   5 energy  -7.8740763664245605
Step  10 energy  -7.8818783760070801
Step  15 energy  -7.8821649551391602
Step  20 energy  -7.8822622299194336
Step  25 energy  -7.8823084831237793
Step  30 energy  -7.8823180198669434
Step  35 energy  -7.8737111091613770
Step  40 energy  -7.8724455833435059
Step  45 energy  -7.8801403045654297
Step  50 energy  -7.8821926116943359
Step  55 energy  -7.8818311691284180
Step  60 energy  -7.8823456764221191
Optimization completed at step  64
Optimized energy:  -7.8823523521423340
Optimized amplitudes:
 [-2.4216002e-04  1.8924323e-03 -3.4653045e-02  1.5943546e-02
  3.6362690e-07  9.0936717e-04 -1.7181528e-05  1.4154296e-02
 -4.4650793e-08  9.0864423e-04 -2.6399141e-06  1.4159971e-02
  5.4558384e-04  4.2672374e-04 -2.8494308e-03  5.3833455e-02
  2.3033506e-04  1.2578158e-06  3.3855862e-08  7.3955505e-08
 -5.2005623e-07  2.9746575e-08  1.2325607e-08  1.1919828e-05
 -1.0492613e-04  7.9503102e-04  3.8478893e-06  5.9738107e-07
 -5.4855812e-02  3.0889052e-03  7.9252044e-05 -1.5384763e-06
 -1.5373821e-06 -3.0784176e-07 -3.5303248e-08  1.7360321e-08
  4.4359115e-07 -4.9067144e-06  3.0889027e-03  1.3888703e-07
 -1.6715177e-08  6.3234533e-09 -7.5149819e-07  3.7140178e-04]

总结

在本案例中，我们通过两种方法，利用量子神经网络得到了LiH分子的基态能量。在第一种方法中，我们利用MindQuantum打包好的generate_uccsd函数生成了能够解决该问题的量子神经网络，而在第二种方法中，我们一步一步的构造出了类似的量子神经网络。最终得到的结果是一致的。