AI框架分析与介绍

 pip3 install -U tensorflow-quantum

  sudo apt update
  sudo apt-get install pkg-config zip g++ zlib1g-dev unzip python3.8
  sudo apt install python3.8 python3.8-dev python3.8-venv python3-pip
  python3.8 -m pip install --upgrade pip

  python3.8 -m venv quantum_env
  source quantum_env/bin/activate

pip install -U pip six numpy wheel setuptools mock 'future>=0.17.1'
  pip install -U keras_applications --no-deps
  pip install -U keras_preprocessing --no-deps
  pip install numpy==1.19.5

 ./configure.sh
  bazel build -c opt --cxxopt="-O3" --cxxopt="-march=native" --cxxopt="-D_GLIBCXX_USE_CXX11_ABI=0" release:build_pip_package
  bazel-bin/release/build_pip_package /tmp/tfquantum/
  python3 -m pip install /tmp/tfquantum/<var>name_of_generated_wheel</var>.whl

  ./scripts/test_all.sh

import cirq , random , sympy 
import numpy as np 
import tensorflow as tf 
import tensorflow_quantum as tfq

def generate_dataset ( 
    qubit , theta_a , theta_b , num_samples ): 
  q_data = [] 
  labels = [] 
  blob_size = abs( theta_a - theta_b ) / 5 
  for _ in range ( num_samples ): 
    coin = random . random () spread_x , 
    spread_y = np . random . uniform ( 
    - blob_size , blob_size , 2) 
  if coin < 0.5: 
     label = [1 , 0] 
     angle = theta_a + spread_y 
  else : 
     label = [0 , 1] 
     angle = theta_b + spread_y 
   labels . append ( label ) 
   q_data . append ( cirq . Circuit ( 
     cirq . Ry (- angle )( qubit ) , 
     cirq . Rx (- spread_x ) ( qubit )) ) 
return ( tfq . convert_to_tensor ( q_data ) , 
         np . array ( labels ))

qubit = cirq . GridQubit (0 , 0) 
theta_a = 1 
theta_b = 4 
num_samples = 200 
q_data , labels = generate_dataset ( 
    qubit , theta_a , theta_b , num_samples )

theta = sympy . Symbol (’theta ’) 
q_model = cirq . Circuit ( cirq . Ry ( theta ) ( qubit )) 
q_data_input = tf . keras . Input ( 
    shape =() , dtype = tf . dtypes . string ) 
expectation = tfq . layers . PQC ( 
    q_model , cirq .Z( qubit )) 
expectation_output = expectation ( q_data_input )

classifier = tf . keras . layers . Dense ( 
    2, activation = tf . keras . activations . softmax ) 
classifier_output = classifier ( 
    expectation_output ) model = tf . keras . Model ( inputs = q_data_input , 
    outputs = classifier_output )

optimizer = tf . keras . optimizers . Adam ( 
    learning_rate =0.1) 
loss = tf . keras . losses . CategoricalCrossentropy () 
model . compile ( optimizer = optimizer , loss = loss ) 
history = model . fit ( 
    x= q_data , y= labels , epochs =50)

test_data , _ = generate_dataset ( 
    qubit , theta_a , theta_b , 1) 
    p = model . predict ( test_data ) [0] 
print (f" prob (a)={p [0]:.4 f}, prob (b)={p [1]:.4 f}")

pip install paddle-quantum

git clone http://github.com/PaddlePaddle/quantum
cd quantum
pip install -e .

conda install psi4 -c psi4 -c conda-forge

cd paddle_quantum/QAOA/example
python main.py

import paddle
import paddle_quantum.qchem as qchem
from paddle_quantum.loss import ExpecVal
from paddle_quantum import Hamiltonian
from paddle_quantum.state import zero_state, State
from paddle_quantum.ansatz import Circuit
from paddle_quantum.linalg import dagger
from paddle_quantum import Backend
import os
import matplotlib.pyplot as plt
import numpy
from numpy import pi as PI
from numpy import savez, zeros
# 无视警告
import warnings
warnings.filterwarnings("ignore")

geo = qchem.geometry(structure=[['H', [-0., 0., 0.0]], ['H', [-0., 0., 0.74]]])
# geo = qchem.geometry(file='h2.xyz')
# 将分子信息存储在 molecule 里，包括单体积分（one-body integrations），双体积分（two-body integrations），分子的哈密顿量等
molecule = qchem.get_molecular_data(
    geometry=geo,
    basis='sto-3g',
    charge=0,
    multiplicity=1,
    method="fci",
    if_save=True,
    if_print=True
)
# 提取哈密顿量
molecular_hamiltonian = qchem.spin_hamiltonian(molecule=molecule,
                                               filename=None, 
                                               multiplicity=1, 
                                               mapping_method='jordan_wigner',)
# 打印结果
print("\nThe generated h2 Hamiltonian is \n", molecular_hamiltonian)

FCI energy for H2_sto-3g_singlet (2 electrons) is -1.137283834485513.
The generated h2 Hamiltonian is 
-0.09706626861762556 I
-0.04530261550868938 X0, X1, Y2, Y3
0.04530261550868938 X0, Y1, Y2, X3
0.04530261550868938 Y0, X1, X2, Y3
-0.04530261550868938 Y0, Y1, X2, X3
0.1714128263940239 Z0
0.16868898168693286 Z0, Z1
0.12062523481381837 Z0, Z2
0.16592785032250773 Z0, Z3
0.17141282639402394 Z1
0.16592785032250773 Z1, Z2
0.12062523481381837 Z1, Z3
-0.2234315367466399 Z2
0.17441287610651626 Z2, Z3
-0.2234315367466399 Z3

def U_theta(num_qubits: int, depth: int) -> Circuit:
    """
    Quantum Neural Network
    """

    # 按照量子比特数量/网络宽度初始化量子神经网络
    cir = Circuit(num_qubits)

    # 内置的 {R_y + CNOT} 电路模板
    cir.real_entangled_layer(depth = depth)

    # 铺上最后一列 R_y 旋转门
    cir.ry()

    return cir

\min_{θ}{L(θ)}=\min_{θ}〈\Psi(θ)|H|\Psi(θ)〉=\min_{θ}\sum_{k}{c_k}〈\Psi(\theta)|⨂_{j}{\sigma_j}^{(k)}|\Psi(\theta)〉

class StateNet(paddle.nn.Layer):
    """
    Construct the model net
    """
    def __init__(self, num_qubits: int, depth: int):
        super(StateNet, self).__init__()

        self.depth = depth
        self.num_qubits = num_qubits
        self.cir = U_theta(self.num_qubits, self.depth)

    # 定义损失函数和前向传播机制
    def forward(self):

        # 运行电路
        state = self.cir(init_state)
        # 计算损失函数
        loss = loss_func(state)     
        return loss, self.cir

ITR = 80  # 设置训练的总迭代次数
LR = 0.4   # 设置学习速率
D = 2      # 设置量子神经网络中重复计算模块的深度 Depth
N = molecular_hamiltonian.n_qubits # 设置参与计算的量子比特数

# 确定网络的参数维度
net = StateNet(N, D)
# 一般来说，我们利用Adam优化器来获得相对好的收敛，
# 当然你可以改成SGD或者是RMS prop.
opt = paddle.optimizer.Adam(learning_rate=LR, parameters=net.parameters())
# 定义初始态
init_state = zero_state(N)
# 定义损失函数
loss_func = ExpecVal(molecular_hamiltonian)
# 记录优化结果
summary_iter, summary_loss = [], []
# 优化循环
for itr in range(1, ITR + 1):
    # 前向传播计算损失函数
    loss, cir = net()
    # 在动态图机制下，反向传播极小化损失函数
    loss.backward()
    opt.minimize(loss)
    opt.clear_grad()
    # 更新优化结果
    summary_loss.append(loss.numpy())
    summary_iter.append(itr)
    # 打印结果
    if itr % 20 == 0:
        print("iter:", itr, "loss:", "%.4f" % loss.numpy())
        print("iter:", itr, "Ground state energy:", "%.4f Ha" 
                                            % loss.numpy())
    if itr == ITR:
        print("\n训练后的电路：") 
        print(cir)
# 储存训练结果到 output 文件夹
os.makedirs("output", exist_ok=True)
savez("./output/summary_data", iter = summary_iter, 
                               energy=summary_loss)

iter: 20 loss: -1.0700
iter: 20 Ground state energy: -1.0700 Ha
iter: 40 loss: -1.1309
iter: 40 Ground state energy: -1.1309 Ha
iter: 60 loss: -1.1362
iter: 60 Ground state energy: -1.1362 Ha
iter: 80 loss: -1.1372
iter: 80 Ground state energy: -1.1372 Ha
训练后的电路：
--Ry(7.856)----*--------------x----Ry(4.698)----*--------------x----Ry(6.277)--
               |              |                 |              |               
--Ry(1.548)----x----*---------|----Ry(-1.56)----x----*---------|----Ry(5.041)--
                    |         |                      |         |               
--Ry(3.441)---------x----*----|----Ry(4.474)---------x----*----|----Ry(1.745)--
                         |    |                           |    |               
--Ry(-0.17)--------------x----*----Ry(1.646)--------------x----*----Ry(3.152)--

result = numpy.load('./output/summary_data.npz')
eig_val, eig_state = numpy.linalg.eig(
                     molecular_hamiltonian.construct_h_matrix())
min_eig_H = numpy.min(eig_val.real)
min_loss = numpy.ones([len(result['iter'])]) * min_eig_H
plt.figure(1)
func1, = plt.plot(result['iter'], result['energy'], 
                  alpha=0.7, marker='', linestyle="-", color='r')
func_min, = plt.plot(result['iter'], min_loss, 
                  alpha=0.7, marker='', linestyle=":", color='b')
plt.xlabel('Number of iteration')
plt.ylabel('Energy (Ha)')
plt.legend(handles=[
    func1,
    func_min
],
    labels=[
        r'$\left\langle {\psi \left( {\theta } \right)} '
        r'\right|H\left| {\psi \left( {\theta } \right)} \right\rangle $',
        'Ground-state energy',
    ], loc='best')
plt.text(-15.5, -1.145, f'{min_eig_H:.5f}', fontsize=10, color='b')
#plt.savefig("vqe.png", bbox_inches='tight', dpi=300)
plt.show()