昇思25天学习打卡营|MQ（mindquantum）编程实践

学AI还能赢奖品？每天30分钟，25天打通AI任督二脉 (qq.com)

安装 Packages

# 安装 mindquantum, networkx
!pip install mindquantum -i https://pypi.mirrors.ustc.edu.cn/simple
!pip install networkx -i https://pypi.mirrors.ustc.edu.cn/simple

安装 mindquantum 和 networkx 库。-i 参数指定了镜像源，这里使用的是中国科学技术大学的镜像源，以加快下载速度。

- MindQuantum：一个量子计算模拟器库，用于模拟和研究量子计算。
- NetworkX：一个图论和网络建模库。

编程实践：量子模拟器

# Numpy 是一个功能强大的Python库，主要用于对多维数组执行计算。
# Simulator 是模拟器，可以模拟量子计算机的计算过程。
import numpy as np                          # 导入numpy库并简写为np
from mindquantum.simulator import Simulator # 导入模拟器

# Simulator 中维护着一个量子态，初始为|0⟩态。
sim = Simulator('mqvector', 1)  # 实例化'mqvector'模拟器,量子比特数为1
print(sim)                      # 打印模拟器信息

/home/nginx/miniconda/envs/jupyter/lib/python3.9/site-packages/mindquantum/simulator/__init__.py:17: UserWarning: Disable mqvector gpu backend due to: Malloc GPU memory failed: cudaErrorInsufficientDriver, CUDA driver version is insufficient for CUDA runtime version
  from .available_simulator import SUPPORTED_SIMULATOR

mqvector simulator with 1 qubit (little endian), dtype: mindquantum.complex128.
Current quantum state:
1¦0〉

导入了 numpy 库用于数值计算，以及 mindquantum 库中的 Simulator 类，用于模拟量子计算。

初始化了一个 mqvector 类型量子模拟器`Simulator`，它有1个量子比特。打印模拟器信息显示当前的量子态，初始状态是|0〉。

# 通过 set_qs() 可以将量子态设置为任意的非零列向量，接口会自动进行归一化。
plus_state = np.array([1, 1])   # 构造¦+⟩态
sim.set_qs(plus_state)          # 将量子态设置为¦+⟩态

quantum_state = sim.get_qs()    # 获取当前量子态
ket = sim.get_qs(ket=True)      # 获取当前量子态的狄拉克符号形式
print('quantum state:', quantum_state)
print('ket:\n', ket)

quantum state: [0.70710678+0.j 0.70710678+0.j]
ket:
 √2/2¦0〉
√2/2¦1〉

将模拟器中的量子态设置为|+〉态（即均匀叠加态），将其设置为模拟器的当前量子态。展示量子态的数值和狄拉克记号形式。

编程实践：量子门

from mindquantum.core.gates import X, Y, H      # 导入量子门
from mindquantum.simulator import Simulator     # 导入模拟器

# 每个量子门都有 matrix() 方法，可以获取该量子门的矩阵形式。
print('Gate name:', X)
gateX = X.matrix()
print(gateX)

Gate name: X
[[0 1]
 [1 0]]

print('Gate name:', Y)
gateY = Y.matrix()
print(gateY)

Gate name: Y
[[ 0.+0.j -0.-1.j]
 [ 0.+1.j  0.+0.j]]

print('Gate name:', H)
gateH = H.matrix()
print(gateH)

Gate name: H
[[ 0.70710678  0.70710678]
 [ 0.70710678 -0.70710678]]

导入 X, Y, H 量子门，打印它们的名称和矩阵形式。X 门是量子比特的翻转门，Y 门是结合了X 和 Z 门的复合旋转，H 门是 Hadamard 门，用于生成叠加态。

# 调用 Simulator 的 apply_gate() 接口可以将量子门作用在量子比特上，使量子态发生演化。
# on() 方法可以指定量子门作用在哪个量子比特上（目标比特），受哪些比特控制（控制比特）。
sim = Simulator('mqvector', 1)          # 实例化一个模拟器
sim.apply_gate(H.on(0))                 # 将H门作用于q0
print(sim)

mqvector simulator with 1 qubit (little endian), dtype: mindquantum.complex128.
Current quantum state:
√2/2¦0〉
√2/2¦1〉

重新实例化了一个模拟器，并将 H 门作用于第一个量子比特 q0，打印模拟器信息(新的量子状态)。

编程实践：量子线路

from mindquantum.core.gates import X, Y, H   # 导入量子门X, Y, H
from mindquantum.core.circuit import Circuit # 导入Circuit模块，用于搭建量子线路
from mindquantum.simulator import Simulator  # 导入模拟器

# 通过“+=”的方式可以轻松地将量子门添加到量子线路中。
circ = Circuit() 			# 实例化一个量子线路
circ += H.on(0)  			# 在线路上的第0个比特添加一个H门
circ += Y.on(0) 			# 在线路上的第0个比特添加一个Y门
circ += X.on(1) 			# 在线路上的第1个比特添加一个X门

print(circ)

      ┏━━━┓ ┏━━━┓   
q0: ──┨ H ┠─┨ Y ┠───
      ┗━━━┛ ┗━━━┛   
      ┏━━━┓         
q1: ──┨╺╋╸┠─────────
      ┗━━━┛         

创建一个量子线路，将H、Y、X门依次作用在不同的量子比特上，然后打印线路信息。

mat = circ.matrix() 		# 获取线路对应的矩阵
print('circuit matrix:\n', mat)

circuit matrix:
 [[0.+0.j         0.+0.j         0.-0.70710678j 0.+0.70710678j]
 [0.+0.j         0.+0.j         0.+0.70710678j 0.+0.70710678j]
 [0.-0.70710678j 0.+0.70710678j 0.+0.j         0.+0.j        ]
 [0.+0.70710678j 0.+0.70710678j 0.+0.j         0.+0.j        ]]

# 调用 Simulator 的 apply_circuit() 接口可以将量子线路作用在量子比特上，使量子态发生演化。
sim = Simulator('mqvector', 2)  	# 实例化一个两比特的模拟器
sim.apply_circuit(circ)          	# 作用量子线路
print(sim)

mqvector simulator with 2 qubits (little endian), dtype: mindquantum.complex128.
Current quantum state:
-√2/2j¦10〉
√2/2j¦11〉

实例化一个包含两个量子比特的模拟器，并将之前构建的量子线路作用于模拟器，然后打印模拟器信息。

编程实践：量子测量

from mindquantum.core.gates import Measure, H, X, Y # 导入量子门X, Y, H和量子测量Measure
from mindquantum.core.circuit import Circuit        # 导入Circuit模块，用于搭建量子线路
from mindquantum.simulator import Simulator         # 导入模拟器

circ = Circuit()                    # 实例化一个量子线路
circ += H.on(0)                     # 在线路上的第0个比特添加一个H门
circ += Y.on(0)                     # 在线路上的第0个比特添加一个Y门
circ += X.on(1)                     # 在线路上的第1个比特添加一个X门

# Measure 与量子门类似，可以用“+=”的方式添加到量子线路中，用 on() 方法指定目标比特。
circ += Measure().on(0)             # 在线路上的第0个比特添加一个测量
circ += Measure().on(1)             # 在线路上的第1个比特添加一个测量

print(circ)

      ┏━━━┓ ┏━━━┓ ┍━━━━━━┑   
q0: ──┨ H ┠─┨ Y ┠─┤ M q0 ├───
      ┗━━━┛ ┗━━━┛ ┕━━━━━━┙   
      ┏━━━┓ ┍━━━━━━┑         
q1: ──┨╺╋╸┠─┤ M q1 ├─────────
      ┗━━━┛ ┕━━━━━━┙         

增加量子测量门到线路中，测量第0和第1个量子比特。

# 调用 Simulator 的 sampling() 接口可以对某一线路的演化结果进行多次采样，获得量子测量的统计结果。
# 这一过程与真实量子计算机的运行方式相似。
sim = Simulator('mqvector', 2)              # 实例化一个两比特的模拟器
result = sim.sampling(circ, shots=1000) 	# 对该线路的演化结果进行1000次采样
print(result)

shots: 1000
Keys: q1 q0│0.00   0.126       0.253       0.379       0.505       0.631
───────────┼───────────┴───────────┴───────────┴───────────┴───────────┴
         10│▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒
           │
         11│▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓
           │
{'10': 495, '11': 505}

对量子线路进行1000次采样，获取测量结果的统计分布。

编程实践：量子近似优化算法

from mindquantum.algorithm import MaxCutAnsatz
from mindquantum.core.operators import Hamiltonian, QubitOperator
from mindquantum.framework import MQAnsatzOnlyLayer
import networkx as nx
import mindspore.nn as nn

# 构造待求解图
graph = nx.Graph([(0, 1), (1, 2), (2, 3), (3, 4), (0, 4), (0, 2)])
nx.draw(graph, with_labels=True)

​

导入必要的QAOA相关模块及其他库。创建并绘制一个图。

# 将图转化为目标哈密顿量
pauli_ops = QubitOperator()
for i in graph.edges:
    pauli_ops += QubitOperator(f'Z{i[0]} Z{i[1]}')
ham = Hamiltonian(pauli_ops)

# 构造线路
circ = MaxCutAnsatz(list(graph.edges), depth=4).circuit
circ.svg()

将图转化为求解MaxCut问题的哈密顿量。构建量子线路用于求解MaxCut问题，并展示线路。

# 创建模拟器，backend使用‘mqvector’，能模拟5个比特（'circ'线路中包含的比特数）
sim = Simulator("mqvector", 5)

# 生成计算变分量子线路的期望值和梯度的算子
grad_ops = sim.get_expectation_with_grad(ham, circ)

# 生成待训练的神经网络
net = MQAnsatzOnlyLayer(grad_ops)

# 设置针对网络中所有可训练参数、学习率为0.05的Adam优化器
opti = nn.Adam(net.trainable_params(), learning_rate=0.05)

# 生成能对神经网络进行一步训练的算子
train_net = nn.TrainOneStepCell(net, opti)

for i in range(200):

    # 将神经网络训练一步并计算得到的结果（切割边数）。注意：每当'train_net()'运行一次，神经网络就训练了一步
    cut = (len(graph.edges) - train_net()) / 2

    # 每训练10步，打印当前训练步数和当前得到的切割边数
    if i % 10 == 0:
        print("train step:", i, ", cut:", cut)

train step: 0 , cut: [3.0004158]
train step: 10 , cut: [4.342516]
train step: 20 , cut: [4.6596413]
train step: 30 , cut: [4.7887754]
train step: 40 , cut: [4.8642898]
train step: 50 , cut: [4.8967166]
train step: 60 , cut: [4.9271173]
train step: 70 , cut: [4.9367566]
train step: 80 , cut: [4.937892]
train step: 90 , cut: [4.93888]
train step: 100 , cut: [4.9390755]
train step: 110 , cut: [4.939164]
train step: 120 , cut: [4.939247]
train step: 130 , cut: [4.939247]
train step: 140 , cut: [4.9392557]
train step: 150 , cut: [4.9392557]
train step: 160 , cut: [4.939257]
train step: 170 , cut: [4.939257]
train step: 180 , cut: [4.939257]
train step: 190 , cut: [4.939257]

1. 创建训练算子`TrainOneStepCell`：
   - TrainOneStepCell是一个MindSpore的类，用于封装神经网络训练的单步操作。它包含了定义的量子神经网络`net`和优化器`opti`。
2. 训练循环：
   - 运行一个200步的循环，每一步都对神经网络进行一次训练。
   - train_net()更新神经网络的参数，并返回当前的期望值。
   - 计算出当前得到的切割边数`cut`，即图的边被切割的数量。
3. 打印结果：
   - 每10步打印一次当前的训练步骤和切割边数，以便观察训练效果。

量子近似优化算法（QAOA）是一种利用量子计算实现组合优化问题的算法，例如最大切割问题（MaxCut）。在过程中：
1. 定义图：
   - 给定一个图，其中每个节点代表一个量子比特，每条边代表一个相互作用。
2. 转换为Hamiltonian形式：
   - 图中的每条边被转换成一个PauliZ算符的乘积。
3. 构建量子线路：
   - 使用QAOA构建深度为4的Ansatz线路，该线路通过一系列参数化的量子门来近似图的最大切割。
4. 训练量子神经网络：
   - 利用MindSpore API，定义了一个量子神经网络并使用Adam优化器来调整参数，以最小化目标Hamiltonian的期望值。
5. 观察输出：
   - 输出显示在训练过程中逐渐找到图的最大切割边数的优化过程。
例子展示了如何使用MindQuantum结合经典优化算法来解决量子计算中的组合优化问题，从量子模拟器的初始化、量子门的应用、量子线路的构建到量子测量的采样，以及使用量子近似优化算法解决实际问题的完整流程。QAOA是一种特别有前景的近似算法，它使用量子线路和经典优化器来针对一类特定问题近似找到最优解。