量子卷积神经网络
卷积和池化：卷积神经网络的必备成分
卷积神经网络被广泛应用于图像和音频的识别当中，关键在于“卷积”操作赋予神经网络统筹学习数据的能力。
执行卷积操作需要输入数据与卷积核，卷积核首先与输入数据左上角对齐，随后逐个计算对应位置处两个数字之积。当对卷积核中所有的元素均执行该乘积操作后，将结果全部加起来作为新的输出。在下图中，我们可以看到卷积核最多只能输出9个数据（就像游戏2048一样）。
下面的动态图能更直观的展现这一过程
每一次池化操作都需要输入数据和池化核，池化核会根据某一要求挑选出符合条件的元素作为代表。
如果我们执行最大池化，那么池化核会首先与输入数据左上角对齐，挑选出范围内最大的元素作为输出。如果我们执行平均池化，那么池化核会首先与输入数据左上角对齐，挑选出范围内所有元素的平均值作为输出。
一般而言，一个卷积神经网络会间隔包含卷积层和池化层，多次重复后，再加上一个全连接层(Fully Connected)，就能得到最终数据了。我们一般使用经过卷积神经网络处理后的图片或音频进行机器学习，这样学习的参数更少，速度更快，同时保留了原先数据的特点。
量子卷积与量子池化
在量子电路中，我们不能随心所欲的创建和使用数据。在经典卷积神经网络中，输出和输入或许是分离存储的，但是在量子电路中，我们只能一直使用若干条量子电路，不能在执行过程中将其切开。
根据相关论文结果，量子中的卷积操作如下
最一般的量子卷积包含了15个参数，但是过多的参数会严重延长训练时间，出于教学目的，我们使用这一简化的卷积操作。
根据相关论文结果，量子中的池化操作如下
我们像经典池化操作一样抛弃一些数据，这里我们抛弃位于上方的量子比特，保留下方的量子比特。
使用Qiskit将卷积和池化写成代码形式
def conv_circuit(params):
target = QuantumCircuit(2)
target.rz(-np.pi / 2, 1)
target.cx(1, 0)
target.rz(params[0], 0)
target.ry(params[1], 1)
target.cx(0, 1)
target.ry(params[2], 1)
target.cx(1, 0)
target.rz(np.pi / 2, 0)
return target
def pool_circuit(params):
target = QuantumCircuit(2)
target.rz(-np.pi / 2, 1)
target.cx(1, 0)
target.rz(params[0], 0)
target.ry(params[1], 1)
target.cx(0, 1)
target.ry(params[2], 1)
return target
而在一个大型量子电路中，我们不能只在某两个量子比特上使用卷积和池化，所以我们需要编写一套适用于大型量子电路的卷积和池化函数
def conv_layer(num_qubits, param_prefix):
qc = QuantumCircuit(num_qubits, name="Convolutional Layer")
qubits = list(range(num_qubits))
param_index = 0
params = ParameterVector(param_prefix, length=num_qubits * 3)
for q1, q2 in zip(qubits[0::2], qubits[1::2]):
qc = qc.compose(conv_circuit(params[param_index : (param_index + 3)]), [q1, q2])
qc.barrier()
param_index += 3
for q1, q2 in zip(qubits[1::2], qubits[2::2] + [0]):
qc = qc.compose(conv_circuit(params[param_index : (param_index + 3)]), [q1, q2])
qc.barrier()
param_index += 3
qc_inst = qc.to_instruction()
qc = QuantumCircuit(num_qubits)
qc.append(qc_inst, qubits)
return qc
对于四个量子比特的电路，结果 如下
容易看出该函数的意义即对电路中任意两个不同量子比特施加卷积操作。
同样地，我们也可以定义适用于大型量子电路的池化函数
def pool_layer(sources, sinks, param_prefix):
num_qubits = len(sources) + len(sinks)
qc = QuantumCircuit(num_qubits, name="Pooling Layer")
param_index = 0
params = ParameterVector(param_prefix, length=num_qubits // 2 * 3)
for source, sink in zip(sources, sinks):
qc = qc.compose(pool_circuit(params[param_index : (param_index + 3)]), [source, sink])
qc.barrier()
param_index += 3
qc_inst = qc.to_instruction()
qc = QuantumCircuit(num_qubits)
qc.append(qc_inst, range(num_qubits))
return qc
可以看出，池化操作先把整个电路分成若干个量子比特对，对与对之间相互不干扰，每个对内再执行池化操作。
实战演练：水平线与竖直线的分类
首先我们导入本次用到的所有库
import json
import matplotlib.pyplot as plt
import numpy as np
from IPython.display import clear_output
from qiskit import QuantumCircuit
from qiskit.circuit import ParameterVector
from qiskit.circuit.library import ZFeatureMap
from qiskit.quantum_info import SparsePauliOp
from qiskit_algorithms.optimizers import COBYLA
from qiskit_algorithms.utils import algorithm_globals
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier
from qiskit_machine_learning.neural_networks import EstimatorQNN
from sklearn.model_selection import train_test_split
algorithm_globals.random_seed = 12345
进一步，手动生成数据。我们会编写函数生成大量包含水平线或竖直线的图片。
def generate_dataset(num_images):
images = []
labels = []
hor_array = np.zeros((6, 8))
ver_array = np.zeros((4, 8))
j = 0
for i in range(0, 7):
if i != 3:
hor_array[j][i] = np.pi / 2
hor_array[j][i + 1] = np.pi / 2
j += 1
j = 0
for i in range(0, 4):
ver_array[j][i] = np.pi / 2
ver_array[j][i + 4] = np.pi / 2
j += 1
for n in range(num_images):
rng = algorithm_globals.random.integers(0, 2)
if rng == 0:
labels.append(-1)
random_image = algorithm_globals.random.integers(0, 6)
images.append(np.array(hor_array[random_image]))
elif rng == 1:
labels.append(1)
random_image = algorithm_globals.random.integers(0, 4)
images.append(np.array(ver_array[random_image]))
# Create noise
for i in range(8):
if images[-1][i] == 0:
images[-1][i] = algorithm_globals.random.uniform(0, np.pi / 4)
return images, labels
进行训练集和测试集分割
images, labels = generate_dataset(50)
train_images, test_images, train_labels, test_labels = train_test_split(
images, labels, test_size=0.3
)
为了将经典数据编码到量子电路中，我们还是需要一个特征映射。这里我们使用ZFeatureMao而不是ZZFeatureMap。
feature_map = ZFeatureMap(8)
feature_map.decompose().draw("mpl")
组合卷积层和池化层，创建量子卷积神经网络
feature_map = ZFeatureMap(8)
ansatz = QuantumCircuit(8, name="Ansatz")
# First Convolutional Layer
ansatz.compose(conv_layer(8, "с1"), list(range(8)), inplace=True)
# First Pooling Layer
ansatz.compose(pool_layer([0, 1, 2, 3], [4, 5, 6, 7], "p1"), list(range(8)), inplace=True)
# Second Convolutional Layer
ansatz.compose(conv_layer(4, "c2"), list(range(4, 8)), inplace=True)
# Second Pooling Layer
ansatz.compose(pool_layer([0, 1], [2, 3], "p2"), list(range(4, 8)), inplace=True)
# Third Convolutional Layer
ansatz.compose(conv_layer(2, "c3"), list(range(6, 8)), inplace=True)
# Third Pooling Layer
ansatz.compose(pool_layer([0], [1], "p3"), list(range(6, 8)), inplace=True)
# Combining the feature map and ansatz
circuit = QuantumCircuit(8)
circuit.compose(feature_map, range(8), inplace=True)
circuit.compose(ansatz, range(8), inplace=True)
observable = SparsePauliOp.from_list([("Z" + "I" * 7, 1)])
# we decompose the circuit for the QNN to avoid additional data copying
qnn = EstimatorQNN(
circuit=circuit.decompose(),
observables=observable,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
)
根据量子卷积神经网络创建分类器
classifier = NeuralNetworkClassifier(
qnn,
optimizer=COBYLA(maxiter=200), # Set max iterations here
)
拟合数据，测试结果
x = np.asarray(train_images)
y = np.asarray(train_labels)
classifier.fit(x, y)
y_predict = classifier.predict(test_images)
x = np.asarray(test_images)
y = np.asarray(test_labels)
print(f"Accuracy from the test data : {np.round(100 * classifier.score(x, y), 2)}%")
如果将结果可视化的话(详见Qiskit量子卷积神经网络)，应如下图
![[AutoSar]一种ECU间CAN通信的优化方法](https://img-blog.csdnimg.cn/direct/1b0d9998b63d4850b87a183f0f017978.png)
