量子机器学习教程-四-

量子机器学习教程（四）

原文：Quantum Machine Learning

协议：CC BY-NC-SA 4.0

八、深度量子学习

头脑无所畏惧的地方

并且头被抬得高高的

知识是免费的。

—罗宾德拉纳特·泰戈尔

通过学习来拓展我们的知识是人类的天性。通过不断学习来培养和发展优化我们生活中每一个小角落的艺术，是人类文明史上进步的支柱。我们受益于改善日常生活各个方面的努力。第七章讲述了量子退火，虽然最优化理论来源于数学概念，但它们也可以被转化并构建到物理学中。比如物理学有最小作用量原理，最小熵产生原理，变分原理*。物理学提供物理退火，它先于计算模拟退火。物理学还提供了绝热原理，从量子形式来看，就是量子退火。因此，物理机器可以解决优化的数学问题，包括约束——这种属性可以扩展到使用量子系统来处理经典和量子数据。*

*Note

第章 7 解决了最大割 NP 难问题。本章着眼于利用 D-Wave 的 qbsolve 解决一个更复杂的 NP-hard 问题:旅行推销员问题。我们还从第 2 和 3 章中从经典神经网络获得的见解中收集信息，并在 Xanadu 的 PennyLane 和谷歌的 TensorFlow Quantum 提供的库的帮助下，发展成为量子深度学习的选项。

为了解决今天的现实问题，量子计算机需要读取、解释和分析输入数据集。量子系统的输入数据可以是自然或人工量子系统中的任何数据源。

图 5-6 显示了经典数据驱动量子计算过程的三个一般执行阶段，此处再次显示以供参考。

转载图 5-6 。量子计算机执行的三个阶段

将经典数据加载到量子态以供量子计算机处理的量子电路公式是当前研究的活跃焦点。由于不同的量子算法对如何加载经典输入数据并将其格式化成相应的量子状态具有不同的限制，因此目前在该领域中使用了几种数据加载电路(例如，基本编码、幅度编码等。).随着本章的深入，你会看到经典数据是如何通过量子系统进行编码和处理的。

作为第七章的延续，我们来看看如何使用 D-Wave 的 qbsolve 来解决一个众所周知的 NP 难题:旅行销售人员。

通过 D-Wave 优化学习

在第七章中，我们从 D-Wave 探索了一些基于量子退火的系统可以解决的功能和问题。经典的最优化问题，由方程式 7 给出。27 (为便于阅读在此转载)，给了我们以下数学表达式，可以用来在 D-Wave 平台上建立编程模型。

方程式 7。27 通过伊辛模型哈密顿量量化，并用于通过在退火驱动平台上映射来实现量子增强优化。为此，方程式 7。4 ， 7。5 和 7。27 制定以下哈密顿量(D-Wave 文档[144])。

(8.1)

其中 A ( s )和 B ( s )为拉格朗日乘数。 ¹ 在编程术语中， A ( s )也被称为gamma参数(后面解释)。

在这种背景下，熟悉 D-Wave 的 QB solve(https://github.com/dwavesystems/qbsolv)【161】是有帮助的。qbsolve 是一个分解，混合量子/经典求解器。它通过将一个大型二次无约束二元优化(曲波)问题分解成多个部分来寻找其最小值，通过 D-Wave 系统或经典的禁忌求解器来求解。这是一个开源软件工具，专为太大和/或太密集的问题而设计，无法在 D-Wave 量子计算机上运行，该计算机将问题分成块，并迭代成子量子。qbsolve 过程可以在经典计算机上运行。

qbsolve 采用曲波文件格式或 Q 矩阵作为模拟退火或 QPU 的输入，并给出位串作为输出(见图 8-1 )。

图 8-1

免除混合算法工作流

图 8-1 显示了 qbsolve 算法的工作流程，包括以下步骤。

• 读取曲波实例

• 划分成更小的子量子

• 求解子量子(这可以在 CPU 或 QPU 上完成)

• 合并结果

qbsolve 的一个很好的例子是旅行推销员问题。

旅行推销员问题(qbsolve)

旅行推销员问题(TSP)²【162】是一个众所周知且臭名昭著的 NP-hard 问题，它让数学家们兴奋了几个世纪，也让计算机科学家们兴奋了几十年。从应用程序的上下文来看，TSP 类型的问题在金融和营销行业中很重要。TSP 由于其硬度以及与实践中出现的一些其他相关组合优化问题的相似性而被认为是重要的。

基于早期分析的数学公式是由爱尔兰数学家 W. R .汉密尔顿和英国数学家托马斯·柯克曼在 19 世纪早期提出的。从数学上来说，这个问题可以用图来抽象(例如，最大割)。图的节点上的 TSP 要求可以通过每个节点的最短哈密顿圈。哈密尔顿圈是一个封闭的路径，它使用图的每个顶点一次。一般的解决方案是*未知的，*并且有效地找到它的算法，例如，不期望在多项式时间内存在。

TSP 的公式如下:一个旅行推销员从一个城市到另一个城市去推销商品。给定一个城市列表和每对城市之间的距离，最短的可能路线是什么，可以访问每个城市一次，然后返回出发城市？这种优化的路线使销售人员能够在最短的时间内实现最大的潜在销售额。

在我们的例子中，我们考虑一个九个城市的 TSP，其中销售人员必须访问九个城市来进行销售。这个问题对于任何数量的城市都可以解决。我们选择了以下九个美国首都城市，并用它们的位置参数(纬度和经度)定义了一个数据文件(data_9cities.txt)，并为它们编制了索引，以便于编程(该文件可在本书的网站上找到)。

0,Colorado,Denver,39.7391667,-104.984167
1,Connecticut,Hartford,41.767,-72.677
2,Delaware,Dover,39.161921,-75.526755
3,Illinois,Springfield,39.783250,-89.650373
4,Indiana,Indianapolis,39.790942,-86.147685
5,Massachusetts,Boston,42.2352,-71.0275
6,Michigan,Lansing,42.7335,-84.5467
7,New Hampshire,Concord,43.220093,-71.549127
8,New Jersey,Trenton,40.221741,-74.756138

我们定义了另一个数据文件(data_distance9.txt)，其中每对首都城市之间的距离总共为 9 × 8 = 72 个距离(这个文件可以在本书的网站上找到)。下面是一个问题路径的例子。

或者

如果路径和行进时间对于销售人员来说是优化的，则可以使用任何其他组合来最大化他们的销售。当制定 QUBU 时，在我们的问题中考虑以下两个约束。

• 销售人员在他开始的地方结束。

• 他每个城市只去一次。

最初，我们需要考虑用数学方法来建模这个问题。为此，我们首先定义我们的二进制变量。

这些约束允许我们用数学公式来最小化我们的距离算子

记住我们的限制，每个城市在曲波出现两次——一次到达，一次离开。举个例子，

对于城市 0(丹佛)，我们有

对于城市 1(哈特福德)，我们有

如此类推，直到第八个城市，也就是特伦顿。

既然我们已经定义了预备工作，我们必须制定约束和目标(方程式)7。27 。

其中， min 代表最小化。最小化的动作寻找边之间的最短距离，这发生在相等时。使用正方形是为了消除负距离。约束由下式给出

接下来，我们结合目标和约束来制定我们的曲波。

其中， γ 是一个拉格朗日参数，可以对其进行调整以获得最佳结果。

有了这个，我们开始练习 Jupyter 笔记本文件TSP_9City_Dwave.ipynb,可以从该书的网站下载。第一个代码片段是库和可视化工具。

## Libraries & visualization tools for us to use.
import networkx as nx
import pylab
import matplotlib.pyplot as plt
from matplotlib.pyplot import pause
import sys
from bokeh.sampledata import us_states
from bokeh.plotting import *
from bokeh.models import Plot, Range1d, MultiLine, Circle, HoverTool, TapTool, BoxSelectTool
from bokeh.io import output_notebook
from bokeh.palettes import Spectral4
from bokeh.models.graphs import from_networkx, NodesAndLinkedEdges, EdgesAndLinkedNodes
output_notebook()
%matplotlib inline
import argparse
import re

Listing 8-1aLibraries and Pauli 

Matrices for TSP_9City_Dwave.ipynb

这里的bokeh指的是为现代网络浏览器创建交互式可视化的 Python 库。在我们的练习中，我们用它来创建一张美国地图和旅行过的城市的地图。

下一个任务是设置问题中城市的数量和一个索引函数。二元变量是x_{I， j} = 1 当且仅当在停靠点 j 访问城市 i 时。曲波字典/矩阵是N2×N2，因此，这些变量必须被赋予行和列索引。函数 x ( a ， b )给 x _{a ， b} 变量分配一个曲波矩阵索引。

# Number of cities in our problem
N = 9
# Function to compute index in Q for variable x_(a,b)
def x(a, b):
    return (a)*N+(b)

Listing 8-1bMatrix for TSP_9City_Dwave.ipynb

在这个例子中，有两个拉格朗日参数。

• A 或gamma是标准的拉格朗日参数，表示我们的约束在我们的解决方案的质量中有多重要。这可以微调以获得最佳结果。这决定了是满足约束条件更重要还是找到最短距离更重要。对于这个问题，至关重要的是我们要访问路线上的每个城市，所以我们应该将这个参数设置为大于两个城市之间的最大距离。

• 𝐵指出了目标函数在我们的曲波中的重要性。一般我们定义 B = 1，修改 A 中的值。

也可以调整以下参数。

• 链强度 ( chainstrength):这告诉嵌入函数将物理量子位的链捆绑在一起形成一个逻辑量子位的强度。这应该大于曲波中的任何其他值。

• 运行次数 ( numruns):这告诉系统我们的问题要运行多少次。由于 D 波 QPU 的概率性质，我们应该多次运行该问题，并寻找找到的最佳解决方案。

这段代码不会在物理 QPU 上运行，而是离线或传统地使用qbsolv。numruns经常运行qbsolv，但是链强度不会影响样本，除非我们修改代码使用 QPU。

# Gamma = A
A = 6500
B = 1
chainstrength = 3000
# Number of runs
numruns = 100

Listing 8-1cTunable Parameters TSP_9City_Dwave.ipynb

接下来，利用城市位置data_9cities.txt, the第一个数据文件，我们生成美国地图。销售人员去过的城市用红色标出。

us_states = us_states.data.copy()
# Delete states Hawaii and Alaska from mainland map
del us_states["HI"]
del us_states["AK"]
# separate latitude and longitude points for the borders
#   of the states.
state_xs = [us_states[code]["lons"] for code in us_states]
state_ys = [us_states[code]["lats"] for code in us_states]
with open('data_9cities.txt', "r") as myfile:
    city_text = myfile.readlines()
    myfile.close()
cities = [',']*N
states = [',']*N
lats=[]
longs=[]
for i in city_text:
    index, state, city,lat,lon = i.split(',')
    cities[int(index)] = city.rstrip()
    states[int(index)] = state
    lats.append(float(lat))
    longs.append(float(lon))

# init figure
p = figure(title="Find shortest route that visits each city",
           toolbar_location="left", plot_width=550, plot_height=350)
# Draw state lines
p.patches(state_xs, state_ys, fill_alpha=0.0,
    line_color='blue', line_width=1.5)
# The scatter markers
p.circle(longs, lats, size=10, color='red', alpha=1)
show(p)

Listing 8-1dMap

of the cities TSP_9City_Dwave.ipynb

这段代码生成了如图 8-2 所示的美国地图，突出显示了 bokeh 提供的九个城市。

图 8-2

参观过的九个城市的地图

现在我们有了基础地图，我们通过文件data_distance9.txt上传城市间的距离。

# Input file containing inter-city distances
fn = "data_distance9.txt"

# check that the user has provided input file
try:
  with open(fn, "r") as myfile:
    distance_text = myfile.readlines()
    myfile.close()
except IOError:
  print("Input distance file missing")
  exit(1)

Listing 8-1eInter-City Distances TSP_9City_Dwave.ipynb

距离存储在一个 N × N 矩阵中。矩阵在对角线上有零点。从一个城市(例如 0)到下一个城市(例如 1)的距离在条目中，因为当在两个城市之间的任一方向旅行时，距离是相同的。矩阵是对称的。

# Initialize matrix of correct size with all 0's
D = [[0 for z in range(N)] for y in range(N)]
# Read in distance values and enter in matrix
for i in distance_text:
  if re.search("^between", i):
    m = re.search("^between_(\d+)_(\d+) = (\d+)", i)
    citya = int(m.group(1))
    cityb = int(m.group(2))
    D[citya][cityb] = D[cityb][citya] = int(m.group(3))

Listing 8-1fCreate the Matrix TSP_9City_Dwave.ipynb

在下一步中，我们通过创建一个所有值都初始化为 0 的空 Q 矩阵，开始开发这个问题的曲波。

Q = {}
for i in range(N*N):
    for j in range(N*N):
        Q.update({(i,j): 0})

Listing 8-1gQ-matrix TSP_9City_Dwave.ipynb

下一个代码块定义了在置换矩阵中每行恰好有个 1 的约束。对于第 1 行，此约束条件为

for v in range(N):
    for j in range(N):
        Q[(x(v,j), x(v,j))] += -1*A
        for k in range(j+1, N):
            Q[(x(v,j), x(v,k))] += 2*A

Listing 8-1hPermutation Matrix TSP_9City_Dwave.ipynb

下一步是开发曲波。主要目标是最小化行进的距离。

考虑这样的情况，旅行的销售人员在第 3 站访问城市 u ，在第 4 站访问城市 v 。然后，他在这一段旅行的距离是。如果他在第 3 站访问城市 u 并在第 4 站访问城市 v ，则总距离增加，否则总距离增加 0。因此，对于每一对城市， u 和 v ，我们添加这将添加从城市 u 和 v 到总路线的直接行驶距离。双向中的每个 u 和 v 选项都需要添加。

for u in range(N):
    for v in range(N):
        if u!=v:
            for j in range(N):
                Q[(x(u,j), x(v,(j+1)%N))] += B*D[u][v]

Listing 8-1iAdd Distance objective TSP_9City_Dwave.ipynb

运行问题

现在我们离线运行 qbsolv。qbsolv ³ 是一个问题分解工具，它既可以经典的离线运行(例如在我们的笔记本电脑上)，也可以以经典和 QPU 的混合方式运行。

from dwave_qbsolv import QBSolv
resp = QBSolv().sample_qubo(Q)

Listing 8-1jRun qbsolve TSP_9City_Dwave.ipynb

下一步，我们做后处理。一旦qbsolv运行，我们收集结果并报告找到的最佳答案。这里，我们列出了找到的最低能耗解决方案、销售人员路线中城市的访问顺序，以及这条路线所需的总里程。我们在此输出中包含了一些有效性检查，指示某个站点是否被分配给多个城市，以及某个站点是否没有分配城市。

# First solution is the lowest energy solution found
sample = next(iter(resp))
# Display energy for best solution found
print('Energy: ', next(iter(resp.data())).energy)
# Print route for solution found
route = [-1]*N
for node in sample:
    if sample[node]>0:
        j = node%N
        v = (node-j)/N
        if route[j]!=-1:
            print('Stop '+str(i)+' used more than once.\n')
        route[j] = int(v)
# Compute and display total mileage
mileage = 0
for i in range(N):
    mileage+=D[route[i]][route[(i+1)%N]]
print('Mileage: ', mileage)
print('\nRoute:\n')
for i in range(N):
    if route[i]!=-1:
        print(str(i) + ':  ' +cities[route[i]]+ ',' + states[route[i]] + '\n')
    else:
        print(str(i) + ':  No city assigned.\n')

Listing 8-1kAdd Distance Objective TSP_9City_Dwave.ipynb

这个运行在 qbsolve 上的代码片段以最低的能耗、总里程和路线给出了我们想要的输出。

请注意，由于计算的概率性质，所访问城市的顺序可能会因运行而异。鼓励你将拉格朗日值从低变高，并观察计算出的最低能量的变化。通常，参数 A 的值被设置为大于两个城市之间的最大距离。

让我们运行一些检查来验证我们的结果是有效的。

• 如果每个城市在我们的列表中恰好出现一次，那么我们的路线列表由数字 0、1、2……(N-1)按照一定的顺序组成，总计为N(N-1)/2。如果这个总数不正确，我们的路线就无效。

• 验证是否每个城市都有指定的站点，反之亦然。如果没有，我们打印一条消息给用户，让他们知道。

alert = 0
if sum(route)!=N*(N-1)/2:
    print('Route invalid.\n')

for i in range(N):
    if route[i]==-1:
        print('Stop '+str(i)+' has no city assigned.')

if alert==0:
    print("Route valid.")

Listing 8-1lVerify If Route Is Valid TSP_9City_Dwave.ipynb

在我们的例子中，代码块验证路由是有效的。

最后的代码块将找到的路线可视化。

Path = nx.Graph()
coord={}
coord[route[0]]=(longs[route[0]],lats[route[0]])
Path.add_node(cities[route[0]],pos=coord[route[0]],label=cities[route[0]])

for i in range(N-1):
    e=(cities[route[i]],cities[route[i+1]])
    Path.add_edge(*e)
    coord[route[i+1]]=(longs[route[i+1]],lats[route[i+1]])
    Path.add_node(cities[route[i+1]],pos=coord[route[i+1]],label=cities[route[i+1]])

e=(cities[route[N-1]],cities[route[0]])
Path.add_edge(*e)

fig, ax = plt.subplots(figsize=(120,60))
margin=0.15
fig.subplots_adjust(margin, margin, 1.-margin, 1.-margin)
ax.axis('equal')
nx.draw(Path, nx.get_node_attributes(Path, 'pos'), with_labels=True, width=10, edge_color='b', node_size=200,font_size=72,font_weight='bold', ax=ax)
plt.show()

Listing 8-1mVisualization of the Route TSP_9City_Dwave.ipynb

最后一个代码块给出了地图上路径的可视化输出。

我们鼓励您将数据文件(data_9cities.txt和data_distance9.txt)修改为更多的城市及其坐标、额外的城市间距离，并多次尝试可视化。随着城市数量的增加，每次跑步的视觉效果可能会有所不同。

如果你有兴趣体验真正的量子位计算代码，D-Wave 在 Leap ( https://cloud.dwavesys.com/leap/ )上提供有限的免费用户配额——基于云的硬件平台访问。如第 1 和 7 章所述，来自 38 个国家(目前)的用户可以在 Leap 注册免费账户，并利用大量的培训材料、文档、开发者资源等等。一旦您登录到 Leap 平台，他们需要在第一个登录屏幕上向下滚动。左下角有一个带有 API 信息的框，可以复制并用于进行 API 调用，以利用 D-Wave 的实际 QPU。

要使用 qbsolve 调用 QPU 来解决本节中的 TSP 问题，可以使用下面的代码块。

from dwave.system.composites import EmbeddingComposite
from dwave.system.samplers import DWaveSampler

sampler = DWaveSampler(solver={'qpu': True})  # Some accounts need to replace this line with the next:
sampler = EmbeddingComposite(DWaveSampler(token = 'my_token', solver=dict(name='solver_name')))
print("Connected to QPU.")

蓝色的两个代码行在非此即彼的基础上使用。对于大多数用户来说，需要 API 令牌的第二行是有效的。API 令牌从 Leap 接口复制并输入到<my_token>中，以保护到实际 QPU 的连接。使用 qbsolve 时，名称的值由name='qbsolve'.给出

让我们前进到量子领域的深度学习方法论。量子深度学习今天有几个实现；除了 D-Wave，还有 Google 的 TensorFlow Quantum 和 Xanadu 的 PennyLane。

量子深度神经网络

经典深度神经网络是机器学习的有效工具，也是发展深度量子学习方法的基础。最简单的用于量化的深度神经网络是玻尔兹曼机器[139]。经典玻尔兹曼机器(阿克利等人 1985 年[168]；Du 和 Swamy 2019 [169])为概率分布建模提供了一个强大的框架。这些类型的神经网络使用无向图结构来编码相关信息。相应的信息存储在网络节点的偏置系数和连接权重中，这些网络节点通常与二进制自旋系统相关，并被分组为确定输出的那些:可见节点；还有那些作为潜在变量的:隐藏节点。网络结构链接到能量函数，其通过使用来自统计力学的概念(即吉布斯状态)来促进在可能的节点配置上概率分布的定义(Boltzmann 1877【170】；吉布斯 1902 [171])。

经典玻尔兹曼机 ⁴ 由相互作用可调的部件组成。通过调整这些相互作用来训练玻尔兹曼机器，以便由玻尔兹曼–吉布斯分布(见图 7-11b )描述的比特的热统计再现数据的统计。为了量子化玻尔兹曼机器，神经网络被表示为对应于可调谐伊辛模型的一组相互作用的量子自旋。用作玻尔兹曼机器输入的神经元被初始化为固定状态；在此之后，系统可以热化，并且输出量子位作为结果被读取。深度量子学习的一个吸引人的特点是，它不需要大型通用量子计算机。

之前我们讨论了专用量子信息处理器，如量子退火器，它们非常适合构建深度量子学习网络[164，165，166]。本章还着眼于基于可编程光子电路的量子系统，因为它们对于创建高效的量子深度学习网络也是有用的。

经典神经网络涉及神经元的处理、神经元执行的转换、神经元之间的互连、神经网络动力学和学习规则。神经网络学习规则控制神经网络连接强度的变化。神经网络通过监督或无监督方式的训练来区分。神经网络可以使用单个系统来保存不同类别的数据，并以分布式方式对刺激进行分类。因此，神经网络在创建分类系统方面非常有用。

量子态中的相干性被称为叠加，被认为类似于经典神经网络中的神经元。量子计算中的测量功能类似于经典神经网络中的互连。神经网络中的增益函数类似于量子计算中的纠缠特性。

量子神经网络(QNN)类似于大脑功能，有助于创建新的信息系统。qnn 用于解决需要指数级容量和内存的经典挑战性问题。简而言之，qnn 被认为是神经计算系统进化的自然下一步。

量子计算和机器学习之间的联系在过去几年里一直在发展。然而，许多定义明确的“教科书”QML 算法是在考虑容错量子计算机的情况下设计的。在当前的高噪声中尺度量子(NISQ)器件时代，需要一套不同的算法、工具和策略。有必要介绍一下 NISQ 时代机器学习的关键思想，并调查一下当前的发展状况。

用 Xanadu 进行量子学习

Xanadu 是一家位于加拿大多伦多的全栈量子初创公司，该公司正在推进一种量子光子处理器，该处理器采用开源的全栈量子软件平台，名为 Strawberry Fields。该公司还开发了一个用于量子计算机可微分编程的跨平台 Python 库[146]，名为 PennyLane ( https://pennylane.readthedocs.io/en/stable/introduction/pennylane.html )。PennyLane 和 Strawberry 字段是用 Python 实现的。Xanadu 还开始发布他们在不同领域的硬件和软件成果，如量子化学、图论、量子机器学习等。

PennyLane⁵【145】是一个围绕量子可微编程构建的开源软件框架，用量子计算机实现机器学习任务。它将经典的机器学习库与量子模拟器和硬件无缝集成，使用户能够训练量子电路。PennyLane 虽然有 QML 的能力，但也有多种多样的能力。

• 支持混合量子和经典模型，允许用户将量子硬件与 PyTorch、TensorFlow 和 NumPy 连接，从而增强量子机器学习能力

• 允许量子电路的内置自动微分

• 提供优化和机器学习工具

• 硬件不可知——相同的量子电路模型可以在不同的后端运行——并允许插件访问不同的设备，包括 Strawberry Fields、Amazon Braket、IBM Q、Google Cirq、Rigetti Forest、Microsoft QDK 和 ProjectQ

安装 PennyLane 非常简单。它需要 Python 3.6 或更高版本。推荐的 Python 安装是 Anaconda Python 3 ( www.anaconda.com/download/ )。因为这本书从一开始就承认了 Anaconda，所以我们在这方面应该没问题。剩下的很简单:通过下面的命令安装最新版本的 PennyLane。

pip install pennylane --upgrade

这个命令应该可以在 Python 3.6+环境上成功而轻松地安装 PennyLane。PennyLane 有一些依赖项，比如 NumPy、SciPy、network，它会在安装时检查这些依赖项(如果需要，会自动安装它们)，如图 8-3 所示。

图 8-3

PennyLane 安装过程

Xanadu 正在开发一种光子量子计算机:一种处理以光的量子状态存储的信息的设备。光子量子计算机使用连续的自由度——如光的振幅和相位——来编码信息。这种连续或模拟结构使得光子器件成为神经网络量子版本的一个有吸引力的平台。

qnn 是量子电路或算法，非常类似于经典神经元和神经网络的结构(见第三章)，同时用强大的量子属性扩展和概括它们。已经发表了利用光子学的 qnn 研究[84]，并且在文献中还有几个其他的提议。

用光子学模拟量子阱的提议让一些研究团体兴奋不已。基洛兰等人在 2018 年发表了一篇论文[84]，其中他们提出了一种由一系列重复的构建块或层组成的光子电路。这些层可以用一层的输出作为下一层的输入来构建。这些光子层类似于经典神经网络中出现的层(见第三章)。经典网络采用一个输入 x ，乘以一个权重矩阵 W ，加上一个偏差 b ，并将结果通过一个非线性激活函数，如 sigmoid、tanh 和 ReLU。

图 8-4

经典神经网络的基本单元

图 8-4 显示了经典神经网络(NN)的基本结构，它执行以下转换。

(8.2)

典型地，在等式 8.2 中，权重 w 由两个正交矩阵和一个对角矩阵表示。

通过使用光子量子门，量子神经网络层类似于图 8-4 中所示的经典神经网络的功能，光子量子门包括由移相器和分束器制成的干涉仪、压缩和位移门以及固定的非线性变换。这些是建造光子量子计算机的相同的门；因此，QNN 架构被解释为具有量子计算机的计算能力。

图 8-5

光子量子神经网络的基本单元

图 8-5 显示了光子量子系统定义的基本 QNN 单位。它有彩色的门来指示它们与图 8-4 中的哪个古典部件相关。干涉仪和压缩门类似于权重矩阵。位移门映射到偏压，量子非线性激活函数映射到经典非线性。神经网络的量子版本与经典神经网络非常相似，可以用来运行经典版本。通过以一种抛弃任何量子“怪异”的方式控制量子网络，比如叠加和纠缠。PennyLane 可以结合现有的经典节点来创建和探索混合模型，如图 8-6 (来自 PennyLane 文档【145】)。

图 8-6

含 PennyLane 的混合经典量子模型的示例结构

当我们讨论量子深度学习时，我们需要记住，我们仍然没有处于一个可以在量子 NN 模型上训练和测试大量量子数据的时代。今天现实生活中的许多数据本质上都是经典的。因此，我们需要问自己如何编码这些经典数据并将其输入量子机器？

有很多方法可以将经典数据嵌入到量子电路中:量子计算平台的不同供应商已经提供了可用的模板来实现这一点。比如 PennyLane 就有qml.templates模块。PennyLane 通过一系列插件支持各种量子框架和量子硬件。例如，光子层需要草莓地的pennylane-sf插件。

为了构建量子节点层(或者 PennyLane 术语中称为 QNodes ),除了手动放置单个门之外，还可以使用预先构建的量子位层的模板。以下是一些预构建的层。

• RandomLayers

• StronglyEntanglingLayers

• BasicEntanglerLayers

• SimplifiedTwoDesign

• CVNeuralNetLayers

类似经典神经网络的重复层提供了以下优点。

• 它提供对电路深度的控制。

• 层可以被设计成硬件友好的。

• 这是一个通用量子计算的模型。

用于神经网络的戊炔

现在我们已经探索了量子 NNs (QNNs)和 PennyLane 的理论方面，是时候进行编码了。

用 QNN 拟合余弦函数

以下示例改编自 PennyLane 文献[172]。这个例子构成了学习一维函数的拟合的变分电路。为了实现这一点，我们以带有噪声的cosine函数的形式生成合成数据，并训练量子神经网络(QNode)来应用它们。

下面解释了如何做到这一点。

1. 用default.qubit.创建一个device

2. 创建一个 QNode，它接受一个输入^′x^′和可训练权重，并输出一个^′y^′。

3. 定义 x 的训练范围( π 到 π )并计算 y = cos x 。

4. 选择 PennyLane 优化器。

5. 运行优化循环。

以下示例中使用的变分电路是基洛兰等人(2018) [84]中描述的连续变量量子神经网络模型。

第一步，我们import PennyLane(安装好之后)，PennyLane 提供的 NumPy 的包装版本，以及一个名为AdamOptimizer ( https://pennylane.readthedocs.io/en/stable/code/api/pennylane.AdamOptimizer.html 的优化器。用于此的device是草莓地模拟器，可以通过 PennyLane 的草莓地插件安装，如下所示。

$ pip install pennylane-sf

从这个练习开始，我们打开名为qnn_cosine_pl.ipynb的 Jupyter 笔记本，它可以从本书网站的下载链接中获得。

# Import PennyLane, the wrapped version of NumPy provided by PennyLane, and an optimizer.
import pennylane as qml
from pennylane import numpy as np
from pennylane.optimize import AdamOptimizer
import matplotlib.pyplot as plt
import pylab
import pickle

Listing 8-2aLibraries and Optimizer qnn_cosine_pl.ipynb

AdamOptimizer是随机优化的一种方法。它基于具有自适应学习速率的梯度下降优化器[84]的原理，使用依赖于步长的学习速率提供自适应力矩估计。第三章 ?? 讲述了经典神经网络的梯度下降，这是前馈网络最常见的训练算法之一。梯度下降优化器使用斜率(或梯度)来引导参数空间。数学上，梯度下降，由方程 3 给出。5 ，此处转载。

(8.3)

其中，当前权重是更新后的权重，是朝着最陡梯度方向向下的前一步的权重， η 是对应于学习速率或步长的用户定义的超参数， E 是成本函数， C 是相对于wij具有导数的 E 的数学等价形式

pickle模块实现了二进制协议，用于序列化和反序列化 Python 对象结构。酸洗是将 Python 对象层次结构转换成字节流的过程。拆包是相反的操作，一个字节流(来自二进制文件或类似字节的对象)被转换回一个对象层次。Pickle可用于稍后将数据加载到另一个 Python 脚本中。

下一步，我们创建一个噪声余弦函数进行采样。

Xlim = 5
noise = np.random.normal(0,0.1,100) # generate noise to add to the function values (Y-values)
# define functions
X = np.arange(-Xlim, Xlim, 0.1)
Y = np.cos(X)+noise

Listing 8-2bNoisy Cosine Function Definition qnn_cosine_pl.ipynb

这个代码块用 X 轴和 Y 轴数据生成两个列表 X 和 Y。现在让我们将 Y 轴数据写入一个文件，以备将来使用。

# write the data out to a file
cosdata = open('cosdata.md', 'wb')
pickle.dump(Y, cosdata)
cosdata.close()
plt.plot(X[0:200], Y[0:200])

Listing 8-2cWrite Noisy Cosine Data 

to a File qnn_cosine_pl.ipynb

这段代码将 y 的数据写入一个名为cosdata.md的文件中。有了这个，我们用plt.plot()函数绘制一些数据，以生成下面的噪声余弦函数图。

现在我们有一些噪声余弦数据来训练我们的 QNN。使用的设备是只有一个量子模式(或线)的草莓场模拟器。为了完成这个练习，我们需要按照之前的指定安装 PennyLane 的草莓地插件。

Note

如果 PennyLane 的 Strawberry Fields 插件是而不是安装的，您会得到以下错误:DeviceError:设备不存在。确保安装了所需的插件。

dev = qml.device("strawberryfields.fock", wires=1, cutoff_dim=10)

Listing 8-2dStrawberry Fields plugin qnn_cosine_pl.ipynb

PennyLane 的草莓地插件访问一个 Fock ⁶ 州模拟器后端。这个模拟器代表了∣0⟩、∣1⟩、∣2⟩,…、∣d1⟩的 Fock 基量子态，其中 D 是用户给定的cutoff_dim值，该值限制了希尔伯特空间的维度。这种表示法的优点是可以表示任何连续变量的运算。请注意以下事项。

• 模拟是近似值，其精确度随着截止尺寸cutoff_dim.的增加而增加

• 对于 M 模式或线以及 D 的截止尺寸，Fock 状态[288]模拟器需要至少跟踪 M ^D 值。因此，与基于量子位的模拟器相比，模拟时间和所需内存随着模式数量的增加而增长得更快。

• 在优化过程中跟踪量子状态的归一化通常是有用的，以确保电路不会“学会”将其参数推入模拟非常不准确的状态。

下一步，我们利用我们在第七章中对变分电路的探索来定义 QNode。对于单量子模式，变分电路的每一层都定义有一个输入层，一个偏置，一个非线性变换。

def layer(v):
    # Matrix multiplication of input layer
    qml.Rotation(v[0], wires=0)
    qml.Squeezing(v[1], 0.0, wires=0)
    qml.Rotation(v[2], wires=0)

    # Bias
    qml.Displacement(v[3], 0.0, wires=0)

    # Element-wise nonlinear transformation
    qml.Kerr(v[4], wires=0)

Listing 8-2eDefine the QNN Layer qnn_cosine_pl.ipynb

量子节点中的变分电路首先将输入编码成模式的位移，然后执行各层。输出是x-正交[288]的期望值。

@qml.qnode(dev)
def quantum_neural_net(var, x=None):
    # Encode input x into quantum state
    qml.Displacement(x, 0.0, wires=0)
    # "layer" subcircuits
    for v in var:
        layer(v)
    return qml.expval(qml.X(0))

Listing 8-2fEncode Input qnn_cosine_pl.ipynb

作为目标，我们取目标标签和模型预测之间的损失的平方。

def square_loss(labels, predictions):
    loss = 0
    for l, p in zip(labels, predictions):
        loss = loss + (l - p) ** 2
    loss = loss / len(labels)
    return loss

Listing 8-2gPrediction Modeling qnn_cosine_pl.ipynb

接下来，我们定义成本函数。在成本函数中计算来自变分电路的输出。函数拟合是一个回归问题，我们将来自量子节点的预期解释为预测，而不应用诸如阈值处理的后处理。

def cost(var, features, labels):
    preds = [quantum_neural_net(var, x=x) for x in features]
    return square_loss(labels, preds)

Listing 8-2hCost Function qnn_cosine_pl.ipynb

下一步，我们将噪声数据加载到成本函数中。在训练模型之前，让我们检查一下数据(参见清单 8-2i )。

plt.figure()
plt.scatter(X, Y)
plt.xlabel("x", fontsize=18)
plt.ylabel("f(x)", fontsize=18)
plt.tick_params(axis="both", which="major", labelsize=16)
plt.tick_params(axis="both", which="minor", labelsize=16)
plt.show()

Listing 8-2iCost Function qnn_cosine_pl.ipynb

清单 8-2i 给出了下面的输出图。

网络的权重(这里称为var)用从正态分布中采样的值初始化。我们使用四层。已经发现性能在大约六层时达到稳定。

np.random.seed(0)
num_layers = 4
var_init = 0.05 * np.random.randn(num_layers, 5)
print(var_init)

Listing 8-2jDefine the Number of Layers qnn_cosine_pl.ipynb

这个代码片段给出了层的如下输出。

最后，我们使用 AdamOptimizer。我们运行优化器，并更新本练习中仅50 步的权重。这运行了一段时间。

opt = AdamOptimizer(0.01, beta1=0.9, beta2=0.999)
var = var_init
for it in range(50):
    var = opt.step(lambda v: cost(v, X, Y), var)
    print("Iter: {:5d} | Cost: {:0.7f} ".format(it + 1, cost(var, X, Y)))

Listing 8-2kRun the Optimizer qnn_cosine_pl.ipynb

运行这个代码块开始 50 步的迭代输出。以下是输出的截断示例。

代码块中的步骤越多，效果越好，但运行时间也越长。我们鼓励您运行此功能；例如，通过调整for it in range(<number_of_steps>).中的步长值，可以达到 500 或 700 步

接下来，我们收集训练模型在[0，30]范围内的 50 个值的预测，并绘制模型从噪声数据(褐红色点)中“学习”的函数。

x_pred = np.linspace(-3, 3, 50)
predictions = [quantum_neural_net(var, x=x_) for x_ in x_pred]
# plot the function
plt.figure()
plt.scatter(X, Y)
plt.scatter(x_pred, predictions, color="maroon")
plt.xlabel("x")
plt.ylabel("f(x)")
plt.tick_params(axis="both", which="major")
plt.tick_params(axis="both", which="minor")
plt.show()

Listing 8-2lCollect Predictions and Plot Function qnn_cosine_pl.ipynb

这会产生以下输出。

该模型已经学会平滑噪声数据。我们可以使用 PennyLane 来查看模型在完全没有经过训练的情况下产生的典型函数。清单 8-2k 中更高的步数导致更好的拟合，但是运行时间更长。

最后一步，我们用方差超参数绘制函数。

variance = 1.0
plt.figure()
x_pred = np.linspace(-5, 5, 50)
for i in range(7):
    rnd_var = variance * np.random.randn(num_layers, 7)
    predictions = [quantum_neural_net(rnd_var, x=x_) for x_ in x_pred]
    plt.plot(x_pred, predictions, color="black")
plt.xlabel("x")
plt.ylabel("f(x)")
plt.tick_params(axis="both", which="major")
plt.tick_params(axis="both", which="minor")
plt.show()

Listing 8-2mFunctions Against Hyperparameter qnn_cosine_pl.ipynb

这将产生本练习的最后一个输出，绘制超参数方差的函数行为。

这些函数的形状随着权重初始化的方差超参数而显著变化。将这个超参数设置为一个小值会产生几乎线性的函数，因为变分电路中的所有量子门都执行恒等变换。较大的值产生平滑振荡的函数，其周期取决于所用的层数，通常层数越多，周期越小。

PennyLane 二元分类器

第二章介绍了使用 Iris 数据集的分类器(用于经典数据分析)。我们在svmIris.ipynb中运行了一个支持向量分类器，在 10000 次迭代之后，我们获得了一个混淆矩阵和大约 98%的准确率。第三章在DNNIris.ipynb中针对经典深度神经网络分类器查看了相同的虹膜数据集，我们运行了 100 个时期以获得 100%的准确率。

观察量子神经网络算法如何不同于相同数据集的经典经验将是有趣的。这里使用的数据在第 2 和 3 章中使用:一个公开可用的数据集，名为 Iris ，可从 Python 的sklearn获得。标题为qml_iris_pl.ipynb的 Jupyter 笔记本可从该书的网站上获得。首先，我们从 Python 和 PennyLane 导入所有必要的库，以及 PennyLane 的GradientDescentOptimizer来执行优化。我们还使用StronglyEntanglingLayers模板来构建 NN 层。

from itertools import chain
from sklearn import datasets
from sklearn.utils import shuffle
from sklearn.preprocessing import minmax_scale
from sklearn.model_selection import train_test_split
import sklearn.metrics as metrics

import pennylane as qml
from pennylane import numpy as np
from pennylane.templates.embeddings import AngleEmbedding
from pennylane.templates.layers import StronglyEntanglingLayers
from pennylane.init import strong_ent_layers_uniform
from pennylane.optimize import GradientDescentOptimizer
from pennylane.devices.default_qubit import DefaultQubit

Listing 8-3aFunctions Against Hyperparameter qml_iris_pl.ipynb

GradientDescentOptimizer是一个基本的优化器，它是其他基于梯度下降的优化器的基类。梯度下降优化器的一个步骤通过等式 8.3 中定义的规则计算新值。

StronglyEntanglingLayers是由单量子位旋转和纠缠组成的层的模板，其灵感来自 Schuld 等人在 2020 年[59]的论文中提出的以电路为中心的分类器设计。

在下一步中，我们导入数据，对其执行预处理(混洗、选择类并将其规范化)，并将数据分为 80%–20%，分别用于训练数据集和测试数据集。

# Import data, pre-processing, data splitting
# load the dataset
iris = datasets.load_iris ()

# shuffle the data
X, y = shuffle (iris.data , iris.target , random_state = 0)

# select only 2 first classes from the data
X = X[y <=1]
y = y[y <=1]

# normalize data
X = minmax_scale (X, feature_range =(0 , np.pi ))

# split data into train + validation and test
X_train_val , X_test , y_train_val , y_test = train_test_split (X, y, test_size =0.2)

Listing 8-3bLoad Data, Preprocess and Split qml_iris_pl.ipynb

下一步是构建量子分类器。为了实现这一点，我们定义量子位的数量以匹配特征的数量，用DefaultQubit()函数定义一个设备，为变分分类器和成本函数设置一个函数。

# Building the Quantum Classifier
# number of qubits is equal to the number of features
n_qubits = X.shape [1]

# quantum device handle
dev = DefaultQubit(n_qubits)

# quantum circuit
@qml.qnode (dev )
def circuit (weights , x= None ):
    AngleEmbedding (x, wires = range (n_qubits ))
    StronglyEntanglingLayers (weights , wires = range ( n_qubits ))
    return qml.expval ( qml.PauliZ (0))

# variational quantum classifier
def variational_classifier (theta, x= None ):
    weights = theta [0]
    bias = theta [1]
    return circuit ( weights , x=x) + bias

def cost (theta , X, expectations ):
    e_predicted = \
      np.array ([ variational_classifier (theta , x=x) for x in X])
    loss = np.mean (( e_predicted - expectations )**2)
    return loss

Listing 8-3cBuilding the Quantum Classifier qml_iris_pl.ipynb

StronglyEntanglingLayers()的参数weights,包含每层的权重。 ⁷ 层数来源于weights的第一维度。

# number of quantum layers
n_layers = 3

# split into train and validation
X_train , X_validation , y_train , y_validation = \
train_test_split ( X_train_val , y_train_val , test_size =0.20)

# convert classes to expectations : 0 to -1, 1 to +1
e_train = np. empty_like ( y_train )
e_train [ y_train == 0] = -1
e_train [ y_train == 1] = +1

# select learning batch size
batch_size = 5

# calculate numbe of batches
batches = len ( X_train ) // batch_size

# select number of epochs
n_epochs = 10

Listing 8-3dPrepare to Training the Data qml_iris_pl.ipynb

这段代码片段运行了十个时期。我建议你先通过设置n_epochs = 5,运行五个纪元，然后再运行十个纪元。历元运行的差异反映在最终精度计算中。

在下一步中，我们对数据施加随机权重，训练变分分类器，让优化器开始学习过程，并将训练数据分成批次，就像我们在第 2 和 3 章中对经典系统所做的那样。

# draw random quantum node weights
theta_weights = strong_ent_layers_uniform ( n_layers , n_qubits , seed =42)
theta_bias = 0.0
theta_init = ( theta_weights , theta_bias ) # initial weights

# train the variational classifier
theta = theta_init
# start of main learning loop
# build the optimizer object
pennylane_opt = GradientDescentOptimizer ()

# split training data into batches
X_batches = np.array_split (np.arange (len ( X_train )), batches )
for it , batch_index in enumerate ( chain (*( n_epochs * [ X_batches ]))):
    # Update the weights by one optimizer step
    batch_cost = \
        lambda theta : cost (theta , X_train [ batch_index ], e_train [ batch_index ])
    theta = pennylane_opt.step ( batch_cost , theta )
    # use X_validation and y_validation to decide whether to stop
# end of learning loop

Listing 8-3eTrain the Data! qml_iris_pl.ipynb

最后，既然我们已经定义并准备好了所有的工具，我们就可以探索推论了。

# Inference
# convert expectations to classes
expectations = np. array ([ variational_classifier (theta , x=x) for x in X_test ])
prob_class_one = ( expectations + 1.0) / 2.0
y_pred = ( prob_class_one >= 0.5)

print ( metrics . accuracy_score ( y_test , y_pred ))
print ("Accuracy: {:.2f} %".format(metrics.accuracy_score ( y_test , y_pred )*100))
print ( metrics.confusion_matrix ( y_test , y_pred ))

Listing 8-3fInference qml_iris_pl.ipynb

此代码块在n_epochs值为 10 时输出以下内容。

然而，如果我们通过设置n_epochs = 5将历元减少到值 5，我们会得到下面的输出。

正如在经典案例中所预期的那样，对于更多的历元，我们会得到更准确的结果。

张量流量子 QNN

QNN 被解释为任何具有可训练连续参数的量子电路。QNN 是一种机器学习模型，允许量子计算机对各种数据集进行分类，其中包括图像数据。使用的图像数据是经典数据，但经典数据无法达到叠加状态。因此，要在量子系统上实现这个协议，数据必须能够被一个提供叠加的量子设备读取。QNN 领域相对较新，因为该领域的研究和工作持续增长。我们之前已经看到了一些解决特定 QNN 问题的 PennyLane 代码的例子。本节着眼于 QNN 的图像分类。

QNN 使用监督学习方法来预测图像数据，如 Benedetti，Lloyd 等人(2019) [186]所示。Farhi 和 Neven 在 2019 年提出了[185]一种 QNN，可以表示经典或量子的标记数据，并通过监督学习进行训练。量子电路由一系列依赖于参数的幺正变换组成，它作用于一个输入量子态。对于二进制分类，在指定的读出量子位上测量单个泡利算符。测量输出是输入状态二进制标签的 QNN 预测器。论文的作者[185]写道，“我们继续使用单词 neural 来描述我们的网络，因为该术语已被机器学习社区采用，并认识到与神经科学的联系现在只是历史。”对于类 MNIST 图像分类，作者在电路中随机分配两个量子比特的单位。用于子集宇称的 Reed-Muller 表示[187]是考虑两量子位单位的另一种方式。

图 8-7

量子处理器上 QNN 的示意图(来源 Farhi 和 Neven，2019 [185])

图 8-7 展示了 Farhi 和 Neven【185】在量子处理器上提出的 QNN 的示意图。∣ ψ ，…，1⟩是准备好的输入状态，然后馈入 QNN。这些输入状态经历由u_I(θ_I)依赖于参数 θ _i 给出的一系列少数量子位单位，这些量子位单位又在学习过程中得到调整，使得y_n

*TensorFlow Quantum (TFQ)由布劳顿等人在 2020 年提出[191]，是一个用于混合量子-经典机器学习的 Python 框架，主要专注于对量子数据进行建模。TFQ 是一个应用程序框架，旨在允许量子算法研究人员和机器学习应用研究人员探索利用谷歌量子计算产品的计算工作流，所有这些都来自 TensorFlow。谷歌人工智能于 2020 年 3 月发布了 TFQ，作为量子机器学习模型快速原型的开源库。TFQ 依赖于 Cirq，这是一个在近期计算机上实现量子电路的开源平台。Cirq 包括定义量子计算所需的基本结构，如量子位、门、电路和计算运算符。Cirq 背后的概念是提供一个简单的编程模型，抽象出量子应用的基本构件。

现在，我们将亲身体验 TensorFlow quantum。 ⁸ 本练习⁹【188】构建一个 QNN 对 MNIST 的简化版本进行分类，类似于 Farhi 和 Neven (2019) [185]中使用的方法。将 QNN 在这个经典数据问题上的性能与经典神经网络进行比较。

首先，我们利用谷歌在谷歌实验室的免费计算资源，如第 1 、 2 和 3 章所述。第一步，我们下载并安装 TFQ，这是 TensorFlow 的先决条件。

!pip install tensorflow==2.3.1

Listing 8-4aInstall

TensorFlow qnn_mnist_tfq.ipynb

输出(截断)。

此步骤可能会显示以下有关重新启动 TensorFlow 运行时的消息。

在这种情况下，点击Restart Runtime按钮。

接下来，安装 TFQ。

!pip install tensorflow-quantum

Listing 8-4bInstall TensorFlow Quantum qnn_mnist_tfq.ipynb

输出(截断)。

接下来，我们导入 TensorFlow 和模块依赖项。

import tensorflow as tf
import tensorflow_quantum as tfq
import cirq
import sympy
import numpy as np
import seaborn as sns
import collections

# visualization tools
%matplotlib inline
import matplotlib.pyplot as plt
from cirq.contrib.svg import SVGCircuit

Listing 8-4cImport Libraries qnn_mnist_tfq.ipynb

现在，我们准备加载数据。在本练习中，我们按照 Farhi 和 Neven [185]的方法，构建了一个二元分类器来区分数字 1 和 7。本节介绍数据处理。

1. 从 Keras 加载原始数据。

2. 仅将数据集过滤为 1 和 7。

3. 缩小图像的尺寸，以便它们可以放入量子计算机。

4. 删除任何矛盾的例子。

5. 将二进制镜像转换为 Cirq 电路。

6. 将 Cirq 电路转换为 TFQ 电路。

在下一步中，我们加载随 Keras 一起分发的原始 MNIST 数据集。

(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()

# Rescale the images from [0,255] to the [0.0,1.0] range.
x_train, x_test = x_train[..., np.newaxis]/255.0, x_test[..., np.newaxis]/255.0

print("Number of original training examples:", len(x_train))
print("Number of original test examples:", len(x_test))

Listing 8-4dLoad the Data qnn_mnist_tfq.ipynb

输出。

接下来，我们过滤数据集，只保留 1 和 7，删除其他类。同时，将标签 y 转换为boolean:1 为真，7 为假。

def filter_17(x, y):
    keep = (y == 1) | (y == 7)
    x, y = x[keep], y[keep]
    y = y == 1
    return x,y

x_train, y_train = filter_17(x_train, y_train)
x_test, y_test = filter_17(x_test, y_test)

print("Number of filtered training examples:", len(x_train))
print("Number of filtered test examples:", len(x_test))

Listing 8-4eFilter the Data qnn_mnist_tfq.ipynb

过滤过程的输出读出用于训练和测试分割的数字。

我们尝试了一个例子，看看数据是什么样的。

print(y_train[0])
plt.imshow(x_train[0, :, :, 0])
plt.colorbar()

Listing 8-4fExample qnn_mnist_tfq.ipynb

这个代码块给出了下面的输出。

接下来，我们将图像缩小到 4 × 4，因为 28 × 28 的图像尺寸对于当前的量子计算机来说太大了，并在调整大小后显示它。

x_train_small = tf.image.resize(x_train, (4,4)).numpy()
x_test_small = tf.image.resize(x_test, (4,4)).numpy()
print(y_train[0])
plt.imshow(x_train_small[0,:,:,0], vmin=0, vmax=1)
plt.colorbar()

Listing 8-4gExample qnn_mnist_tfq.ipynb

以下是输出。

下一步是通过用量子位表示每个像素，将数据编码为量子电路，其中量子位状态取决于像素的值。第一步是转换成二进制编码。

THRESHOLD = 0.5
x_train_bin = np.array(x_train_nocon > THRESHOLD, dtype=np.float32)
x_test_bin = np.array(x_test_small > THRESHOLD, dtype=np.float32)

Listing 8-4hBinary Encoding qnn_mnist_tfq.ipynb

现在，我们通过一个 X 门旋转量子位，像素索引值超过一个阈值，形成一个电路。

def convert_to_circuit(image):
    """Encode truncated classical image into quantum datapoint."""
    values = np.ndarray.flatten(image)
    qubits = cirq.GridQubit.rect(4, 4)
    circuit = cirq.Circuit()
    for i, value in enumerate(values):
        if value:
            circuit.append(cirq.X(qubits[i]))
    return circuit
x_train_circ = [convert_to_circuit(x) for x in x_train_bin]
x_test_circ = [convert_to_circuit(x) for x in x_test_bin]
SVGCircuit(x_train_circ[0])

Listing 8-4iRotate Qubits Through X Gate qnn_mnist_tfq.ipynb

下面是为第一个例子创建的电路(电路图没有显示零门量子位)。

现在，我们可以将该电路与图像值超过阈值的指数进行比较。

bin_img = x_train_bin[0,:,:,0]
indices = np.array(np.where(bin_img)).T
indices

Listing 8-4jComparison qnn_mnist_tfq.ipynb

以下输出。

量子数据以张量的形式加载，定义为用 Cirq 编写的量子电路。TensorFlow 在量子计算机上执行这个张量，生成一个量子数据集。因此，我们现在将这些 Cirq 电路转换为 TensorFlow Quantum ( tfq)的张量，如清单 8-4k 所示。

x_train_tfcirc = tfq.convert_to_tensor(x_train_circ)
x_test_tfcirc = tfq.convert_to_tensor(x_test_circ)

Listing 8-4kComparison qnn_mnist_tfq.ipynb

现在我们准备建造 QNN。然而，对图像分类的量子电路结构的指导是稀疏的。由于分类是基于对读出量子位的期望，Farhi 等人提出使用双量子位门，读出量子位总是起作用。这在某些方面类似于 Arjovsky 等人[190]提出的跨像素运行小型酉 RNN。

为了实现这一点，我们从构建模型电路开始。下面的代码块显示了一种分层的方法。每一层使用同一个门的 n 个实例，每个数据量子位作用于读出量子位。我们从一个简单的类开始，在电路中增加一层这样的门。

class CircuitLayerBuilder():
    def __init__(self, data_qubits, readout):
        self.data_qubits = data_qubits
        self.readout = readout

    def add_layer(self, circuit, gate, prefix):
        for i, qubit in enumerate(self.data_qubits):
            symbol = sympy.Symbol(prefix + '-' + str(i))
            circuit.append(gate(qubit, self.readout)**symbol)
demo_builder = CircuitLayerBuilder(data_qubits = cirq.GridQubit.rect(4,1),
                                   readout=cirq.GridQubit(-1,-1))
circuit = cirq.Circuit()
demo_builder.add_layer(circuit, gate = cirq.XX, prefix='xx')
SVGCircuit(circuit)

Listing 8-4lBuild the QNN Model Circuit qnn_mnist_tfq.ipynb

输出显示了电路。

接下来，我们建立一个两层模型，匹配数据电路的大小，并包括准备和读出操作。

def create_quantum_model():
    """Create a QNN model circuit and readout operation to go along with it."""
    data_qubits = cirq.GridQubit.rect(4, 4)  # a 4x4 grid
    readout = cirq.GridQubit(-1, -1)         # a single qubit at [-1,-1]
    circuit = cirq.Circuit()

    # Prepare the readout qubit.
    circuit.append(cirq.X(readout))
    circuit.append(cirq.H(readout))
    builder = CircuitLayerBuilder(
        data_qubits = data_qubits,
        readout=readout)
    # Then add layers (experiment by adding more).
    builder.add_layer(circuit, cirq.XX, "xx1")
    builder.add_layer(circuit, cirq.ZZ, "zz1")
    # Finally, prepare the readout qubit.
    circuit.append(cirq.H(readout))
    return circuit, cirq.Z(readout)
model_circuit, model_readout = create_quantum_model()

Listing 8-4mBuild a Two-Layer Model qnn_mnist_tfq.ipynb

下一个任务是用量子组件将模型电路包装在 tfq-keras 模型中，以便训练它。这个模型被输入来自x_train_circ的量子数据，它对经典数据进行编码。它使用一个参数化量子电路层tfq.layers.PQC，根据量子数据训练模型电路。Farhi 等人提出在参数化电路中采用读出量子位的期望值来对这些图像进行分类。期望值返回一个介于 1 和–1 之间的值。

# Build the Keras model.
model = tf.keras.Sequential([
    # The input is the data-circuit, encoded as a tf.string
    tf.keras.layers.Input(shape=(), dtype=tf.string),
    # The PQC layer returns the expected value of the readout gate, range [-1,1].
    tfq.layers.PQC(model_circuit, model_readout),
])

Listing 8-4nBuild Keras Wrapper qnn_mnist_tfq.ipynb

由于预期读数在[–1,1]范围内，优化铰链损耗是一个自然的选择。

Note

另一种有效的方法是将输出范围移动到[0，1]，并将其视为模型分配给类 1 的概率。这可以与标准的 a TF . loss . binary cross entropy loss 一起使用。

为了使用这里的铰链损耗，我们需要做两个小的调整。首先，我们将标签y_train_nocon从布尔转换为[-1,1]，正如铰链损耗所预期的。

y_train_hinge = 2.0*y_train_nocon-1.0
y_test_hinge = 2.0*y_test-1.0

我们使用一个定制的hinge_accuracy度量，它正确地将[–1, 1]作为y_true标签参数。

def hinge_accuracy(y_true, y_pred):
    y_true = tf.squeeze(y_true) > 0.0
    y_pred = tf.squeeze(y_pred) > 0.0
    result = tf.cast(y_true == y_pred, tf.float32)
    return tf.reduce_mean(result)

model.compile(
    loss=tf.keras.losses.Hinge(),
    optimizer=tf.keras.optimizers.Adam(),
    metrics=[hinge_accuracy])

print(model.summary())

Listing 8-4oLabel Argument qnn_mnist_tfq.ipynb

这将打印出模型摘要。

我们现在训练 QNN 模型，大约需要 30 到 45 分钟——取决于您的系统。如果你不想等那么久，使用数据的一个小的子集(下面的 set NUM_EXAMPLES=500)。这不会影响模型在训练过程中的进度，因为它只有 32 个参数，因此，约束这些参数所需的数据并不多。使用较少的例子可以更早地结束训练(大约 5 分钟)，但是运行时间足够长，可以显示它在验证日志中取得了进展。

EPOCHS = 3
BATCH_SIZE = 32
NUM_EXAMPLES = len(x_train_tfcirc)
x_train_tfcirc_sub = x_train_tfcirc[:NUM_EXAMPLES]
y_train_hinge_sub = y_train_hinge[:NUM_EXAMPLES]
qnn_history = model.fit(
      x_train_tfcirc_sub, y_train_hinge_sub,
      batch_size=32,
      epochs=EPOCHS,
      verbose=1,

      validation_data=(x_test_tfcirc, y_test_hinge))
qnn_results = model.evaluate(x_test_tfcirc, y_test)

Listing 8-4pTrain the Quantum Model qnn_mnist_tfq.ipynb

这给出了铰链精度、运行时间和损耗的以下输出。

训练精度报告了整个时期的平均值。在每个时期结束时评估验证准确性。

既然我们已经看了事物的量子方面，我们可能希望找出一个经典网络如何在相同的数据集上运行。尽管 QNN 可以解决这个简化的 MNIST 问题，但基本的经典神经网络在这个任务上可以胜过 QNN。在单个时期之后，传统的神经网络可以在维持集上实现> 98%的准确度。

在下面的示例中，经典的神经网络用于 1–7 分类问题，使用整个 28 × 28 图像，而不是对图像进行二次采样。这很容易收敛到接近 100%的测试集的准确性。

def create_classical_model():
    # A simple model based off LeNet from https://keras.io/examples/mnist_cnn/
    model = tf.keras.Sequential()
    model.add(tf.keras.layers.Conv2D(32, [3, 3], activation='relu', input_shape=(28,28,1)))
    model.add(tf.keras.layers.Conv2D(64, [3, 3], activation='relu'))
    model.add(tf.keras.layers.MaxPooling2D(pool_size=(2, 2)))
    model.add(tf.keras.layers.Dropout(0.25))
    model.add(tf.keras.layers.Flatten())
    model.add(tf.keras.layers.Dense(128, activation='relu'))
    model.add(tf.keras.layers.Dropout(0.5))
    model.add(tf.keras.layers.Dense(1))
    return model
model = create_classical_model()
model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
              optimizer=tf.keras.optimizers.Adam(),
              metrics=['accuracy'])
model.summary()

Listing 8-4qBuild the Classical Model qnn_mnist_tfq.ipynb

这将生成如下的模型摘要。

这个模型有将近 120 万个参数。接下来，我们按如下方式训练经典模型。

model.fit(x_train,
          y_train,
          batch_size=128,
          epochs=1,
          verbose=1,
          validation_data=(x_test, y_test))

cnn_results = model.evaluate(x_test, y_test)

Listing 8-4rTrain the Classical Model qnn_mnist_tfq.ipynb

这个代码块为具有 120 万个参数的经典模型生成精度、损耗等方面的输出。为了更公平的比较，我们在二次抽样图像上尝试 37 参数模型。

def create_fair_classical_model():
    # A simple model based off LeNet from https://keras.io/examples/mnist_cnn/
    model = tf.keras.Sequential()
    model.add(tf.keras.layers.Flatten(input_shape=(4,4,1)))
    model.add(tf.keras.layers.Dense(2, activation='relu'))
    model.add(tf.keras.layers.Dense(1))
    return model
model = create_fair_classical_model()
model.compile(loss=tf.keras.losses.BinaryCrossentropy(from_logits=True),
              optimizer=tf.keras.optimizers.Adam(),
              metrics=['accuracy'])

model.summary()

Listing 8-4s37-Parameter 

Model qnn_mnist_tfq.ipynb

这就产生了我们想要的 37 参数模型。

现在，我们用 37 个参数的新范围来训练这个模型。

model.fit(x_train_bin,
          y_train_nocon,
          batch_size=128,
          epochs=20,
          verbose=2,
          validation_data=(x_test_bin, y_test))

fair_nn_results = model.evaluate(x_test_bin, y_test)

Listing 8-4tTrain the 37-Parameter Model qnn_mnist_tfq.ipynb

这给出了以下(截断的)输出。

最后，我们比较了量子神经网络和经典神经网络。

qnn_accuracy = qnn_results[1]
cnn_accuracy = cnn_results[1]
fair_nn_accuracy = fair_nn_results[1]
sns.barplot(["Quantum", "Classical, full", "Classical, fair"],
            [qnn_accuracy, cnn_accuracy, fair_nn_accuracy])

Listing 8-4uComparison of Quantum and Classical qnn_mnist_tfq.ipynb

此代码块给出以下输出作为比较。

更高分辨率的输入和更强大的模型使得这个问题对 CNN 来说很容易。虽然相似功率(约 32 个参数)的经典模型在一小部分时间内训练到相似的精度，但经典神经网络优于量子神经网络。

在经典数据集中，鉴于近期量子系统的状态，量子系统很难击败经典神经网络。然而，在具有经典输入数据的量子系统上的练习确实承诺利用希尔伯特空间的多维度和某些特定问题的叠加能力。从经典数据中获得的见解也为我们在下一代量子计算系统上实现算法做好了准备，我们希望这将带来前所未有的计算能力。

量子卷积神经网络

如第三章所见，经典卷积神经网络(CNN)是图像处理和计算机视觉相关领域的流行模型。CNN 的结构包括将交替的卷积层(加上一个激活函数)和汇集层应用于输入阵列，通常在输出之前跟随一些完全连接的层。卷积层的工作原理是扫描整个输入阵列，并逐块应用不同的滤波器(通常是 2 × 2 或 3 × 3 矩阵)。它们检测图像中可能出现的特定特征。然后，使用池层对这些卷积的结果进行下采样，以提取最相关的特征并减少数据的大小，从而更容易在后续层中进行处理。常见的池化方法包括用最大值或平均值替换数据块。

CNN 具有便于有效利用数据的相关性信息的属性。然而，如果数据或模型的给定维度变得太大(这在大数据时代很可能发生)，与 CNN 相关的计算费用可能会很快成为一个挑战。量子卷积神经网络(QCNN)使用量子计算环境为 CNN 提供了一种新的解决方案，以提高现有学习模型的性能。

图 8-8

QCNN 示意图(来源丛等 2018 [193])

qcn 首先由丛等人(2018) [193]提出。QCNNs 的结构受 CNN 结构的启发，如图 8-8 所示。在 QCNN 中，卷积是在相邻量子位对上执行的操作(参数化酉旋转)，类似于常规的变分电路。这些卷积之后是池层，池层通过测量量子位的子集并使用测量结果来控制后续操作而受到影响。完全连接层的模拟是在最终测量之前对剩余量子位的多量子位操作。所有这些操作的参数都是在训练期间学习的。

在 Oh，Choi 和 Kim 在 2020 年完成的研究中[192]提出了一种模型，通过将 CNN 的结构应用于量子计算环境来有效地解决量子物理和化学中的分类问题。该研究还提出了一个可以用 O(log(n))深度计算的模型，使用多尺度纠缠重整化 ansatz (MERA)。

该研究介绍了一种方法，通过在现有计算机视觉中使用的 CNN 学习模型中添加一个使用量子系统的层来提高模型的性能。该模型也可用于小型量子计算机。混合学习模型可以通过在 CNN 模型中增加一个量子卷积层或者用卷积层代替来设计。本文还通过 TensorFlow 量子平台使用 MNIST 数据集进行训练，验证了 QCNN 模型相对于 CNN 是否能够高效学习。

关于丛等人[193]关于 QCNN 的另一篇论文的完整实践教程可在 www.tensorflow.org/quantum/tutorials/qcnn 的 Google AI 上获得。如果你对量子深度学习感兴趣，请按照自己的节奏浏览教程。

量子 CNN 的一个自然应用是对量子态进行分类。丛等人[193]的原始工作使用它们来区分不同的拓扑相位。QCNNs 也可以用来分类图像，就像它们的经典对应物一样。

摘要

量子数据是自然或人工量子系统中出现的任何数据源。这可以是从量子力学实验中得到的经典数据，也可以是由量子设备直接生成的数据，然后作为输入输入到算法中。有证据表明，由于量子力学特性，对量子数据的混合量子-经典机器学习应用可以提供优于仅经典机器学习的量子优势。量子数据表现出叠加和纠缠，导致联合概率分布，这可能需要指数数量的经典计算资源来表示或存储。

也许量子机器学习最直接的应用是量子数据——量子系统和过程产生的实际状态。许多量子机器学习算法通过将数据映射到量子力学状态，然后使用基本的量子线性代数子例程操纵这些状态，来找到经典数据中的模式。这些量子机器学习算法可以直接应用于光和物质的量子态，以揭示它们的潜在特征和模式。由此产生的量子分析模式通常比从量子系统中提取的数据的经典分析更有效和更有启发性。

本章探讨了 D-Wave、Xanadu 的 PennyLane 的 QNN 和 Google 的 TensorFlow Quantum 上的旅行销售员问题和解决方案，并探讨了量子卷积神经网络。我们还探讨了 QCNN 领域的最新研究和进展。

第九章探索先进的领域，如量子化学、量子行走和层析成像，量子机器学习在这些领域正变得活跃并有望发展。

Footnotes 1

湖泊乘数: https://en.wikipedia.org/wiki/Lagrange_multiplier#:~:text=In%20mathematical%20optimization%2C%20the%20method,chosen%20values%20of%20the%20variables

  2

出差销售人员问题: https://en.wikipedia.org/wiki/Travelling_salesman_problem#cite_note-6

  3

qbsolv 基于 Wang，Lu，Glover 和 Hao (2012)的论文“大型无约束二元二次优化的多级算法”。[163]

  4

经典玻尔兹曼机:https://en.wikipedia.org/wiki/Boltzmann_machine【167】

  5

pennylanae/pennylane 根据 Apache 许可证 2.0 获得许可。

  6

福克状态: https://en.wikipedia.org/wiki/Fock_state#:~:text=In%20quantum%20mechanics%2C%20a%20Fock,the%20Soviet%20physicist%20Vladimir%20Fock 。

  7

strong 纠缠层文档: https://pennylane.readthedocs.io/en/stable/code/api/pennylane.templates.layers.StronglyEntanglingLayers.html

  8

对于这个练习，代码改编自 TensorFlow Quantum 文档: https://www.tensorflow.org/quantum/tutorials/mnist

  9

根据 Apache 许可证 2.0 版许可(“许可证”)

 **

九、QML：前方的路

预测未来的最好方法是创造未来。

—亚伯拉罕·林肯

量子机器学习(QML)是一个交叉学科，由两个最令人兴奋的研究领域组成:量子计算和经典机器学习。

到目前为止，我们已经探索了几种算法、概念和见解。我们可以用经典的计算机解决问题，无论是笔记本电脑还是 GPU 集群。用目前非常非常昂贵(几千万美元)的量子计算机来解决它没有什么价值。量子机器学习中有趣的问题是，机器学习和 AI 中是否存在与量子计算机天然契合但在经典硬件上具有挑战性的问题。这需要对机器学习和当代量子计算机都有很好的理解。

Note

本章重点讨论与量子机器学习相关的过程和应用的正在进行的研究领域，如量子行走、哈密顿模拟、量子 Boost、量子金融、量子化学和张量网络，包括两个动手练习。

量子计算和量子信息是出现在计算机科学各个领域的学科，如信息论、密码学、情感表示和图像处理，因为在经典计算机上看起来效率低下的任务可以通过利用量子计算的力量来实现[3] [233]、[234]、[235]、[236]。加速某些任务的新方法以及计算机科学和其他几个科学领域之间的跨学科研究已经吸引了对这个新兴领域的浓厚科学兴趣。

人们对量子计算和机器学习领域的承诺越来越有信心，这催生了许多受量子承诺推动的初创企业。除了众所周知的机构，如谷歌，IBM，Rigetti，世外桃源，D-Wave，不一而足。以下是最近量子科技初创企业生态系统中一些年轻有为的成员的例子。

• TQuT Inc. ( http://tqut.co/ ):由 Ritaban Chowdhury 创办，在美国注册，TQuT 是一家令人兴奋的量子初创公司。量子技术的新时代开启了材料发现的新可能性。需要一个现代的、基于云的、API 驱动的、可扩展的材料发现平台来有效地探索这些领域。它正在开发一个基于网络的材料发现平台，该平台利用云中的高性能计算和量子计算硬件，使材料发现管道开发变得可扩展、可重复使用和更容易。

• 夸库恩 ( https://quacoon.com ):一个基于量子人工智能的平台，为建立和管理弹性和可持续的供应链提供协作供应链智能，以及解决产品短缺、拥堵和其他因意外事件造成的中断。Quacoon 于 2020 年由蒂娜·安妮·塞巴斯蒂安领导的团队成立。

• Quantropi 的技术为用户提供了实现无条件安全的选择，同时具有成本效益、可伸缩性和高效性。他们发表的工作包括解决保密[286]和量子公钥分配[287]的研究(和相关专利)。最近，他们被选为 2020 年科学初创企业类别柏林倒塌墙突破的决赛入围者之一，并获得了 2020 年 BOBs 最佳新(渥太华)商业奖。

• Quantropi(www.quantropi.com):2018 年成立于加拿大渥太华，是量子通信领域的后起之秀。它利用量子物理的数学定律来加密传输中的数据，而不需要量子计算机的处理能力。他们的解决方案在当前的互联网上提供了真正安全的量子密钥分发(QKD)，允许今天的用户用自己的计算机发送量子加密的数据。他们拥有三项独特的专利技术，形成了完整的端到端解决方案。

  • 量子熵扩展协议

  • 伽罗瓦公钥(GPK)

  • 量子公钥信封(QPKE)(专利申请中)

今天，在量子计算的所有应用中，大规模吸引注意力的是与原子、分子和其他生物化学系统的模拟相关的应用，这些应用独特地适合于量子计算。这是因为大型系统的基态能量、分子整体的动态行为或复杂的分子行为(如蛋白质折叠)通常很难计算，或者完全不可能通过经典计算或实验来确定[151][182]。

化学量子计算

对有用的量子计算机将很快实现的预期，激发了人们对开发量子算法的深入研究，这些算法可能会在经典的棘手计算问题上取得进展。虽然许多研究领域希望看到这种量子设备的发展带来变革，但计算化学将成为首批从这种新技术中受益的领域之一。由于随着轨道的增加，希尔伯特空间的大小呈指数增长，具有数十个量子位的量子计算机可能会超越经典算法[182]、[183]、[184]。实现这样的能力不仅取决于量子位的质量，还取决于算法的效率。

对于量子化学领域，根据精确的参考计算训练非线性回归模型(如高斯过程或神经网络)可以直接预测化学性质[174]、[175]、[176]。原子力的 ML 预测可以驱动分子动力学模拟，而不确定性估计和主动学习可以指导更多参考计算的获取，以改善之前训练的模型[179] [180]。直接获得这种化学性质的精确预测允许进行广泛、大规模的研究，这在传统的量子化学模拟中是不可行的。

具有所需性质的分子和材料的合理设计既需要计算精确微观性质的能力，例如能量、力和特定构型的静电多极，又需要对势能表面进行有效采样以获得相应的宏观性质。提供这一点的工具是分别植根于量子力学和统计力学的精确的第一性原理计算。所有这些都伴随着高计算成本，这阻碍了大型系统或采样密集型应用的计算，例如长时间尺度的分子动力学模拟，从而为搜索广阔的化学化合物空间带来了严重的瓶颈。为了克服这一挑战，人们越来越努力地用机器学习来加速量子计算。

在多电子系统中，用目前的数学方法不可能得到薛定谔方程的精确解。Hartree-Fock 方法，已经有广泛的 QML 算法，被开发用于近似求解与时间无关的薛定谔方程。多电子系统的总能量可以用单电子和双电子算符来表示。通过最小化总能量，薛定谔方程可以在数学上转化为单电子 Hartree-Fock 方程。本征值和波函数表示轨道能量和分子、原子轨道。

随着我们对量子计算机的理解不断成熟，有利于化学和分子模拟的新方法和新技术的发展也将不断成熟。就目前的情况而言，我们有信心量子计算机能够帮助那些需要明确表示波函数的量子化学计算，要么是因为对模拟性质的高精度要求，要么是因为系统中的高度纠缠。在这些情况下，波函数维数的指数增长使得在经典计算机上的操作和存储效率非常低。事实上，即使是中等大小的系统，也很难明确保持全波函数。

举个例子，一个包含 42 个原子的青霉素分子需要 10 个 86 个经典比特。电子组态的指数大参数空间的模拟将需要比宇宙中的原子更多的状态！与经典计算机所需的比特数相反，量子计算机需要大约 286 个量子比特。一个咖啡因分子需要大约 10 个 ?? 48 个经典比特，而在量子计算平台上大约需要 160 个量子比特。

随着量子硬件和软件社区继续取得快速进展，量子计算对量子化学的直接作用已经出现。量子化学量子算法的进步需要量子信息论和经典量子化学技术。

开放费米子

化学和材料的量子模拟预计将是近期和容错量子器件的重要应用。然而，开发和研究这些问题的算法可能是困难的，因为在化学和量子算法领域都需要大量的领域知识。为了帮助弥合这一差距，并向更多的研究人员开放这一领域，谷歌开发了 OpenFermion 软件包( www.openfermion.org )。OpenFermion 是一个开源软件库，主要是在 Apache 2.0 许可下用 Python 编写的，用于在量子硬件上模拟费米子和玻色子模型以及量子化学问题。通用电子结构软件包的接口简化了分子规范和量子电路之间的转换，用于在量子计算机上解决或研究电子结构问题，最大限度地减少了进入该领域所需的领域专业知识的数量。

OpenFermion 可以在用户模式下安装，如下所示。

$ python -m pip install --user openfermion

Note

谷歌人工智能研究团队在 https://quantumai.google/openfermion/tutorials/intro_to_openfermion 有关于 OpenFermion 的全面在线教程。我们强烈建议您浏览它们，以获得更深入的见解。

化学系统的量子模拟是量子计算机最有前途的近期应用之一。最有前途的量子计算应用之一是能够有效地模拟自然界中经典计算机难以处理的量子系统。自从上个世纪电子计算机出现以来，计算在化学发展中发挥了重要作用。多年来，计算化学物质静态和动态性质的数值方法已经彻底改变了化学学科。随着量子计算的出现，类似的突破性进展已经被证明是有潜力的。

量子行走

量子行走[223]是众所周知的经典随机行走的量子力学模拟。在研究中已经确立了一段时间，量子行走在量子信息处理的各个领域中具有重要作用[198]、[199]、[200]。它们是管理数据库搜索[201]、图形同构[202]、[203]、[204]、网络分析和导航[205]、[206]、量子模拟[207]、[208]、[209]以及生物过程建模[210] [211]的量子算法的核心。量子行走的物理性质已经在各种系统中得到证明，如核磁共振[212] [213]，体[214]和光纤[215] [216]光学，囚禁离子[216]、[217]、[218]，囚禁中性原子[219]和光子学[221]、[222]。量子行走是最重要的哈密顿模拟方法之一。

传统上，随机游动的数学概念已经存在了一段时间，可以描述如下。这是一个随机的过程，涉及一个被放置在某个 n 维介质中的“步行者”(可能某人喝醉了，以至于事先不知道他/她下一步要去哪里)。然后，我们重复查询一些随机变量，并基于我们的测量结果，更新行走者的位置向量(即，图形或网格上的位置)。^{?? 1}

让我们看一个非常基本的随机漫步的例子。我们从一个图的某个特定顶点 v 开始，重复下面的序列几次:验证 v 是否被标记，如果没有，那么随机选择它的一个邻居，并将 v 设为那个邻居。这表明随机漫步是一个具有随机演化时间系统的动态路径。这个过程也可以用一维图形来解释，我们可以考虑在一条数轴的原点上放置一个标记，在每个整数上做标记。

图 9-1 说明了一个经典的随机漫步，其中在时间 t = 0 时处于 v 的漫步有可能在时间 t = 1 时结束于( v + 1)或(v-1)。

图 9-1

经典随机漫步例子

看看经典的随机游走，乍一看可能会觉得是一个多余的算法。毕竟，它只需要一个空间复杂度为 O (log N )的空间，因为我们需要跟踪当前顶点 v ，也许还需要一个计数器来跟踪步行者已经走了多少步。但是，一点也不多余！相反，例如，该算法可以使用 O (log N )空间来决定是否存在从特定顶点 v 到特定顶点 u 的路径，这在处理统计学习和概率规则的非常低维度的实际量子物理时变得更加清晰和非常有用。行走将从 v 开始，只有 u 会被标记；可以看出，如果在 G 中存在一条从 v 到 u 的路径，那么在多项式 ( N )步中，行走器到达 u 。随机游走类似于格罗弗搜索和伊辛模型，在某种意义上，无论它们出现在哪里，你都可以尝试用它们的量子版本替换它们，并希望有所改进。

量子行走类似于经典的随机行走，除了决定随机行走的步数的函数和行走者的位置向量是使用量子位和酉变换编码的。换句话说，构造规则随机行走背后的思想被转化为量子模拟。

让我们在 pyQuil 中进行一次动手练习，以演示基于 Qiang，Lok 等人在 2016 年发表的题为“量子处理器上的高效量子行走”的论文的连续时间量子行走* (CTQW)。*【197】。

在经典的随机漫步中，具有边 E 和顶点 V 的图 G 的邻接矩阵 A 由下式给出

(9.1)

拉普拉斯 L 是二阶空间导数的二维各向同性度量，突出显示快速强度变化的区域，并用于边缘检测。方程 9.1 的图 G 的拉普拉斯由下式给出

(9.2)

拉普拉斯算子的定义有时不同于等式 9.2 中的定义。这里使用这个定义是因为它允许 L 是连续统中拉普拉斯算子∇ ² 的离散近似。

经典连续随机行走的行为由拉普拉斯算子确定，并由概率 p ( t )的长度向量| V 描述，其中 p ( t )是在时间 t 处于顶点 i 的概率，并由微分方程【200】、【201】给出。

(9.3)

方程 9.3 有如下解:p(t)=e^Ltp(0)。这可以被视为扩散方程的离散模拟，这在量子行走算法中是有帮助的，量子行走算法在物理系统中是重要的，例如俘获离子和光子学。

让事情回到原点:薛定谔方程，由给出，可以用来获得拉普拉斯。 ² 我们之前遇到过拉普拉斯算子，尤其是在第八章中解决 NP 难的旅行售货员问题时。薛定谔方程左边的指数算符通常用中对应的幂级数来定义。通过泛函微积分的性质，下面的算子描述了我们广为使用的著名酉算子:。从数学和物理学的角度来看，这意味着拉普拉斯算子保持了系统状态的规范化。

因此，等式 9.3 可以用拉普拉斯项表示如下。

(9.4)

微分方程 9.4 决定了连续随机游走的量子模拟的行为。该解决方案由下式给出

我们不一定需要拉普拉斯算子来定义量子行走。它可以在任何遵守图 G 的结构的算子的帮助下被定义(即，仅允许过渡到图中的相邻顶点或保持静止[222，223])。

为了掌握量子行走的行为，我们首先来看一个在直线上连续时间量子行走的例子。在这种情况下，对于动量p∈[π， π ]来说，表示无限直线的图的拉普拉斯算子的本征态是本征值为 2(cosp—1)的动量态。动量状态根据位置状态∣ x ⟩给出。应用后，拉普拉斯算子由下式给出

拉普拉斯算子由下式给出

(9.5)

从方程 9.5 ，我们找到时间 t 的概率分布。

(9.6)

其中初始位置∣ ψ (0)⟩ = ∣ 0⟩)由下式给出

(9.7)

在这种情况下，经典量子行为类似于图 9-2 中的图解。

图 9-2

量子到经典随机漫步

经典连续时间随机游走的概率分布在高斯宽度为的 x = 0 处接近其峰值，而量子游走在极值处具有其最大峰值，随着接近开始位置的 x = 0 处，两者之间的振荡幅度减小。

Note

随机漫步可以有几种类型。经典随机游走的二项分布在 Cirq 教程 https://colab.research.google.com/github/quantumlib/Cirq/blob/master/docs/tutorials/quantum_walks.ipynb#scrollTo=yaKGvbmieSIL 中有说明。我们强烈建议您访问该网站，并通过 Cirq 版本的量子行走来更好地了解这个问题的多样性。

由于在经典情况下不会发生的不同相态之间的相消干涉，量子行走的行为是不同的。相反，经典行走的概率分布没有振荡，而是以 x = 0 为中心的单个峰值，其随着时间 t 的增加而变宽和变平。因此，以量子振幅取代机率，我们看到量子领域的干涉可以产生完全不同的结果。

类似图形的数值或矩阵表示如图 9-3 所示。

图 9-3

经典随机到量子行走

编码量子行走

在了解了 CTQW 的基本行为之后，我们根据 Qiang，Lok 等人的论文[197]，从 Rigetti 的 QVM 和 pyQuil 开始动手练习。

从该书的网站打开名为quantum_walk_pyquil.ipynb的 Jupyter 笔记本文件，启动三个不同的终端:用qvm -S命令启动 QVM，另一个用quilc -S命令启动 Quilc，第三个启动 Jupyter notebook。

import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
from scipy.linalg import expm
%matplotlib inline
from pyquil import Program
from pyquil.gates import H, X, CPHASE00
from pyquil.api import WavefunctionSimulator
from pyquil.api import ForestConnection
from pyquil.api import QVMConnection

qvm = QVMConnection()
wfn_sim = WavefunctionSimulator()

Listing 9-1aLibraries and QVM Connection quantum_walk_pyquil.ipynb

在下一步中，我们开始查看如何利用 NetworkX 图形库为四个节点的连续时间经典行走编码图形 G 。

G = nx.complete_graph(4)
nx.draw_networkx(G)

Listing 9-1bClassical Walk with Four Nodes quantum_walk_pyquil.ipynb

这个代码块产生一个四节点 K ₄ 图 G 图 9-4 用于经典行走。

图 9-4

具有四个节点的经典随机游走图(K4

完整图形的频谱需要一个等于(n-1)的特征值，其中𝑁是节点数，其余特征值等于 1。下一步，我们定义邻接矩阵 A 和相应的特征值。

A = nx.adjacency_matrix(G).toarray()
eigvals, _ = np.linalg.eigh(A)
print(eigvals)

Listing 9-1cAdjacency Matrices quantum_walk_pyquil.ipynb

这将给出以下矩阵作为输出。

对于 CTQW，通常的哈密顿量是邻接矩阵 A 。这在这里通过添加单位矩阵而被稍微修改；也就是我们取(请注意，这里我们改变了哈密顿量的字体，以区分哈密顿量的和哈达玛门的 H )。这种修改减少了我们需要应用的门的数量，因为具有 0 个特征值的特征向量不获取相位。因此，接下来，我们使用矩阵 A 来计算哈密顿量，为此我们使用NumPy kron函数来生成两个数组的克罗内克乘积。

hamil = A + np.eye(4)
had = np.sqrt(1/2) * np.array([[1, 1], [1, -1]])
Q = np.kron(had, had)
Q.conj().T.dot(hamil).dot(Q)

Listing 9-1dHamiltonian and Adjacency Matrices quantum_walk_pyquil.ipynb

此代码块生成以下矩阵作为乘积。

这个输出表明 K _n 图是哈达玛可对角化的。这允许我们写，其中 Q = * H * ⊗ H ，并且 H 表示哈达玛门。我们还看到，时间演化算符也通过相同的变换对角化。

现在，是计算连续时间量子行走的时候了。为了实现这一点，我们首先定义一个函数，将矩阵改变为对角基，然后计算其时间演化，并最终将其改变回计算基。从参考文献[197]可知，我们的情况下 γ = 1。因此，模拟这些的电路如清单 9-1e 所示。

def k_4_ctqw(t):
    #   Change to diagonal basis
    p = Program(H(0), H(1), X(0), X(1))

    #    Time evolve
    p += CPHASE00(-4*t, 0, 1)

    #   Change back to computational basis
    p += Program(X(0), X(1), H(0), H(1))
         return p

Listing 9-1eFunctions for Matrices and Time Evolution quantum_walk_pyquil.ipynb

我们现在将量子漫步与经典的随机漫步进行比较。经典的时间演化算子是e??(τI)t，其中τ是图的转移矩阵。作为初始条件，我们选择∣ ψ (0)⟩ = ∣ 0⟩与等式 8 中相同。6 和 8。7 。这意味着 walker 从第一个节点开始。之后，由于对称性，除了∣0⟩，所有节点被占据的概率是相同的。

图 9-5

量子与经典随机漫步

T = A / np.sum(A, axis=0)
time = np.linspace(0, 4, 40)
quantum_probs = np.zeros((len(time), 4))
classical_probs = np.zeros((len(time), 4))
for i, t in enumerate(time):
    p = k_4_ctqw(t)
    wvf = wfn_sim.wavefunction(p)
    vec = wvf.amplitudes
    quantum_probs[i] = np.abs(vec)**2
    classical_ev = expm((T-np.eye(4))*t)
    classical_probs[i] = classical_ev[:, 0]
f, (ax1, ax2) = plt.subplots(2, sharex=True, sharey=True)
ax1.set_title("Quantum evolution")
ax1.set_ylabel('p')
ax1.plot(time, quantum_probs[:, 0], label='Initial node')
ax1.plot(time, quantum_probs[:, 1], label='Remaining nodes')
ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5))
ax2.set_title("Classical evolution")
ax2.set_xlabel('t')
ax2.set_ylabel('p')
ax2.plot(time, classical_probs[:, 0], label='Initial node')
ax2.plot(time, classical_probs[:, 1], label='Remaining nodes')

Listing 9-1fTime Evolution quantum_walk_pyquil.ipynb

列表 9-1f 产生图 9-5 中的图，以比较 CTQW 和经典行走的时间相关概率演变。

正如预期的那样，量子行走表现出相干振荡，而经典行走收敛于的稳态分布

对于一个 K ₄ 图，CTQW 和经典行走之间的这种比较可以容易地推广到如下的任何图。

def k_2n_ctqw(n, t):
    p = Program()
    #    Change to diagonal basis
    for i in range(n):
        p += Program(H(i), X(i))
    #   Create and apply CPHASE00
    big_cphase00 = np.diag(np.ones(2**n)) + 0j
    big_cphase00[0, 0] = np.exp(-1j*4*t)
    p.defgate("BIG-CPHASE00", big_cphase00)
    args = tuple(["BIG-CPHASE00"] + list(range(n)))
    p.inst(args)
    #   Change back to computational basis
    for i in range(n):
        p += Program(X(i), H(i))
    return p

def k_2n_crw(n, t):
    G = nx.complete_graph(2**n)
    A = nx.adjacency_matrix(G)
    T = A / A.sum(axis=0)
    classical_ev = expm((T-np.eye(2**n))*t)
    return classical_ev[:, 0]

time = np.linspace(0, 4, 40)
quantum_probs = np.zeros((len(time), 8))
classical_probs = np.zeros((len(time), 8))

for i, t in enumerate(time):
    p = k_2n_ctqw(3, t)
    wvf = wfn_sim.wavefunction(p)
    vec = wvf.amplitudes
    quantum_probs[i] = np.abs(vec)**2
    classical_probs[i] = k_2n_crw(3, t)

f, (ax1, ax2) = plt.subplots(2, sharex=True, sharey=True)
ax1.set_title("Quantum evolution")
ax1.set_ylabel('p')
ax1.plot(time, quantum_probs[:, 0], label='Initial node')
ax1.plot(time, quantum_probs[:, 1], label='Remaining nodes')
ax1.legend(loc='center left', bbox_to_anchor=(1, 0.5))
ax2.set_title("Classical evolution")
ax2.set_xlabel('t')
ax2.set_ylabel('p')
ax2.plot(time, classical_probs[:, 0], label='Initial node')
ax2.plot(time, classical_probs[:, 1], label='Remaining nodes')

Listing 9-1gTime Evolution quantum_walk_pyquil.ipynb

最后一个代码块产生了一个比较图，如下所示，这与图 9-5 非常相似，其中较大的分布导致了经典部分的较高平滑度，正如预期的那样。

多项式时间哈密顿模拟

在本书的整个旅程中，当处理量子系统的动力学时，我们已经健康地使用了酉变换。除了测量之外，振幅向量所描述的量子状态，可以藉由与酉矩阵相乘而改变:例如，一个两个量子位元的闸张量，与其他量子位元上的单位系在一起。然而，这种数学范式并没有阐明哪一种幺正出现在一个物理系统中。这个问题的答案由哈密顿系统决定，哈密顿系统是系统中总能量 E 对应的可观测量。这里是含时态∣ * ψ * ( * t * )⟩.的能量 E 的期望值

我们可以将哈密顿量解释为描述系统的物理特性。这些特征并不决定系统的初始状态∣ψ_I(t)⟩)，但它们确实决定了状态随时间的演化(即状态∣ψ_f(t)⟩)作为时间参数 t 的函数，给定初始状态，例如∣ 这是由量子力学中最重要的方程决定的:薛定谔方程。

主要的哈密顿模拟方法之一是量子行走。我们已经探讨了哈密顿量，并在各种编码练习和计算中引用了它们的性质。

当一个量子态随着时间从∣的初始n-量子位态ψ_It)⟩演化到最终态∣ψ_f(t)⟩，我们可能希望知道哈密顿量最终态所包含的信息。反过来，我们也可能希望强加一个已知的哈密顿量这个实现给定哈密顿演化的过程被称为哈密顿模拟。哈密尔顿模拟的研究有两大类:模拟模拟和数字模拟，模拟模拟与模拟处于自然状态的哈密尔顿的量子系统有关，数字模拟将时间演化分解为量子门。

哈密顿量模拟的问题定义如下。给定一个哈密顿量，一个时间 t ，和一个误差容限 ϵ (例如，轨迹距离)，找到一个量子电路，对一个未知量子态执行幺正运算，误差至多为 ϵ 。作为一般结果，哈密顿量可以是依赖于时间的。哈密顿模拟的常见应用包括连续时间量子算法，如量子行走、绝热优化和线性方程。

如果我们有一个由几个其他哈密顿量之和组成的与时间无关的哈密顿量，使得那么这些“成员”哈密顿量中的每一个应该相对更容易模拟。至于不可交换的，因式分解规则不适用。Seth Lloyd 在其 1996 年的论文[207]中使用了以下公式来实现这一点。

(9.8)

现在，如果我们将这个方程进行三重化(见第七章，方程 7)。24 ，其陈述了对于小的 t ，因式分解规则近似有效，我们可以将对于时间 t 的演变写成长度为δt的小时间步长的序列，如

(9.9)

图 7-9 显示了为便于阅读而复制的 t 灭菌。方程 9.9 左侧的表达式显示了每个时间步长δt的非平凡误差。然而，在这种情况下，等式 9.8 中的误差变得可以忽略不计。注意，随着时间步长δt的长度减小，序列必须重复的次数增加。考虑到序列数量和时间步长大小之间的权衡，这种方法允许我们通过操纵项来模拟哈密顿量。这种多项式时间哈密顿量模拟的方法表明，如果将哈密顿量分解为初等哈密顿量之和的方法是已知的，并且如果我们知道如何模拟这些初等哈密顿量，那么我们可以按照我们期望的方式近似地演化一个量子系统。

在离散变量量子位模型中，哈密尔顿模拟的有效方法已在文献中广泛讨论，提供了几种依赖于哈密尔顿性质的实现，并导致线性模拟时间[224，225]。哈密顿模拟的有效实现也存在于连续变量(CV)公式[226]中，具体应用于玻色-哈伯德哈密顿量，其描述了正交位置状态的晶格上的相互作用玻色子粒子系统[227]。这种方法非常适合光子量子计算和通信，这两者都是活跃研究的主题。

系综和 qboost

QBoost 由 Google 和 D-Wave 的研究人员在 2008 年和 2009 年提出[228]、[229]、[230]，作为一种迭代训练算法，在每次迭代中通过解决一个硬优化问题来选择弱分类器的子集。通过连接弱分类器的子集来递增地构建强分类器。它作为一种新的离散优化方法被引入到大规模二元分类器的 boosting 框架中进行训练。主要目标是将机器学习训练问题转换为现有绝热量子硬件所需的格式。

单一的机器学习模型不太可能适合所有可能的场景，因为任何学习算法都有优点和缺点。集成将多个模型结合起来，以实现比任何组成模型更高的泛化性能。

基于使用多个学习器的机器学习算法属于更广泛的集成学习算法类别[231]、[232]。集成方法通过考虑一组训练模型来构造更好的分类器。训练模型(或分类器)的集合一起决定新的预测，这有助于组合其成员模型的个体优势。

集成中的组成模型也被称为基分类器或弱学习器，复合模型被称为强学习器。当基本分类器之间存在相当大的差异时，集成通常会产生更好的结果。当策略组合可以减少总误差时，基本分类器在存在足够多样性的情况下产生各种类型的误差，从而理想地提高性能。

集合方法的程序有两个主要步骤。

1. 从训练数据开发一组基本分类器。

2. 将它们组合起来形成合奏。

最简单的组合，基础学习者投票，标签预测基于多数。更复杂的方法衡量基础学习者的投票。

然而，这就给我们带来了一个挑战，那就是集合弱学习者以产生最大可能的效率。有几种方法可以实现这一点。例如，给定当前的模型集合，我们可以根据该模型表现良好的地方再添加一个。或者，我们可以查看所有模型之间预测的所有相关性，并优化最不相关的预测值。由于后一种方法是全局的，它默认映射到量子计算机。

直觉上，我们意识到，在用集成弄脏我们的手之前，我们需要洞察损失函数和正则化——机器学习中的两个关键概念——在我们能够足够自信地对各种模型的误差函数的集体性能做出判断之前。

这就是一些实践经验是有益的地方。因此，我们通过动手编码来研究集成方法和 QBoost。

全体

首先，我们从书的网站下载并打开名为qboost_ensemble.ipynb的 Jupyter 笔记本文件。既然我们已经讨论了系综的基础，让我们导入一些包，并将我们的品质因数定义为平衡数据集中的精度。

import matplotlib.pyplot as plt
import numpy as np
import sklearn
import sklearn.datasets
import sklearn.metrics
%matplotlib inline
metric = sklearn.metrics.accuracy_score

Listing 9-2aLibraries qboost_ensemble.ipynb

接下来，我们生成一个由两个形成同心圆的类组成的随机数据集。

np.random.seed(0)
data, labels = sklearn.datasets.make_circles()
idx = np.arange(len(labels))
np.random.shuffle(idx)
# train on a random 2/3 and test on the remaining 1/3
idx_train = idx[:2*len(idx)//3]
idx_test = idx[2*len(idx)//3:]
X_train = data[idx_train]
X_test = data[idx_test]

y_train = 2 * labels[idx_train] - 1  # binary -> spin
y_test = 2 * labels[idx_test] - 1

scaler = sklearn.preprocessing.StandardScaler()
normalizer = sklearn.preprocessing.Normalizer()

X_train = scaler.fit_transform(X_train)
X_train = normalizer.fit_transform(X_train)

X_test = scaler.fit_transform(X_test)
X_test = normalizer.fit_transform(X_test)
plt.figure(figsize=(6, 6))
plt.subplot(111, xticks=[], yticks=[])
plt.scatter(data[labels == 0, 0], data[labels == 0, 1], color='navy')
plt.scatter(data[labels == 1, 0], data[labels == 1, 1], color='red');

Listing 9-2bGenerate Dataset qboost_ensemble.ipynb

此代码块生成以下循环数据集作为输出。

可以回忆一下，我们在第三章中讨论过经典感知器。

Note

如果你对*量子感知机，*在 https://qml.entropicalabs.io/ 浏览教程。

在这个实验室里，让我们再次训练一个感知机。

from sklearn.linear_model import Perceptron
model_1 = Perceptron()
model_1.fit(X_train, y_train)
print('accuracy (train): %5.2f'%(metric(y_train, model_1.predict(X_train))))
print('accuracy (test): %5.2f'%(metric(y_test, model_1.predict(X_test))))

Listing 9-2cTrain a Perceptron qboost_ensemble.ipynb

这给出了下面的准确性。

感知器的决策表面是线性的，因此，我们得到的准确性很差。也许值得尝试一种具有非线性核的支持向量机(SVM ),看看会发生什么。

from sklearn.svm import SVC
model_2 = SVC(kernel='rbf')
model_2.fit(X_train, y_train)
print('accuracy (train): %5.2f'%(metric(y_train, model_2.predict(X_train))))
print('accuracy (test): %5.2f'%(metric(y_test, model_2.predict(X_test))))

Listing 9-2d

Apply SVM qboost_ensemble.ipynb

这一次我们得到了以下精度结果。

输出表明，SVM 在训练集上表现较好，但在测试数据上表现较差，因此不适合推广。

Boosting 是一种集成方法，它明确地寻找相互补充的模型。boosting 算法之间的差异在于它们如何组合弱学习者。

自适应增强(AdaBoost)是一种流行的方法，它基于弱学习者各自的准确度顺序组合弱学习者。它有一个凸的目标函数，不会因为复杂而受到惩罚。AdaBoost很可能包括最终集成中所有可用的弱学习者。清单 9-2e 是AdaBoost与几个学习能力差的学员一起进行的训练练习。

from sklearn.ensemble import AdaBoostClassifier
model_3 = AdaBoostClassifier(n_estimators=3)
model_3.fit(X_train, y_train)
print('accuracy (train): %5.2f'%(metric(y_train, model_3.predict(X_train))))
print('accuracy (test): %5.2f'%(metric(y_test, model_3.predict(X_test))))

Listing 9-2eAdaBoost qboost_ensemble.ipynb

AdaBoost 产生以下输出，其精度也大致相同(与 SVM 相比只有非常微小的改进)。

QBoost

QBoost [230]的思想是量子计算机上的优化不限于凸目标函数。这允许我们添加任意的惩罚条款，并重新表述我们的目标[230]。QBoost 问题可以定义如下。

其中h_k(x_I)为训练实例 k 对弱学习者的预测。这个公式中的权重是二进制的。因此，这个目标函数默认映射到伊辛模型。正则化确保了稀疏性。它不是经典的正则化；在数字计算机上很难优化这一项。

扩展目标的二次部分，我们有

其中，y_I²为常数。因此，优化简化为

这种形式告诉我们，我们将弱学习者的预测之间的所有相关性视为有一个总和h_k(x_I)h_l(x_I)。因为这一项有一个正号，我们惩罚相关性。另一方面，与真标签的相关性，h_k(x_I)y_I)有负号，表示正则项不变。

让我们将前一节中的三个模型都视为弱学习者，计算它们的预测，并将其设置为 1。预测被缩放以反映目标中的平均值。

models = [model_1, model_2, model_3]
n_models = len(models)
predictions = np.array([h.predict(X_train) for h in models], dtype=np.float64)
# scale hij to [-1/N, 1/N]
predictions *= 1/n_models
λ = 1

Listing 9-2fModel Definition qboost_ensemble.ipynb

我们创建目标函数的二次二元优化(曲波)。

w = np.dot(predictions, predictions.T)
wii = len(X_train) / (n_models ** 2) + λ - 2 * np.dot(predictions, y_train)
w[np.diag_indices_from(w)] = wii
W = {}
for i in range(n_models):
    for j in range(i, n_models):
        W[(i, j)] = w[i, j]

Listing 9-2gDefine QUBO qboost_ensemble.ipynb

我们用模拟退火法求解二次二进制优化问题，并读出最优权重。

import dimod
sampler = dimod.SimulatedAnnealingSampler()
response = sampler.sample_qubo(W, num_reads=10)
weights = list(response.first.sample.values())

Listing 9-2hSolve QUBO qboost_ensemble.ipynb

我们定义了一个预测函数来帮助测量精度。

def predict(models, weights, X):
    n_data = len(X)
    T = 0
    y = np.zeros(n_data)
    for i, h in enumerate(models):
        y0 = weights[i] * h.predict(X)  # prediction of weak classifier
        y += y0

        T += np.sum(y0)
    y = np.sign(y - T / (n_data*len(models)))
    return y
print('accuracy (train): %5.2f'%(metric(y_train, predict(models, weights, X_train))))
print('accuracy (test): %5.2f'%(metric(y_test, predict(models, weights, X_test))))

Listing 9-2iPrediction Function qboost_ensemble.ipynb

这给出了以下输出精度。

精确度与我们最强的弱学习器一致:AdaBoost 模型。看看最优权重，这在weights命令的输出中是显而易见的。

只有 AdaBoost 进入了最后的合奏。前两个模型表现不佳，它们的预测是相关的。然而，如果我们通过设置 λ = 0 来移除正则化，第二个模型也会进入集合，从而降低整体性能。这证明了正规化的重要性。

量子图像处理(QIMP)

量子图像处理是量子信息处理的一个子领域[3]，[237]，它利用量子并行性的特性来加速许多处理任务。量子图像处理的第一步是提出在量子计算机上捕捉和存储图像的方法。已经提出了量子计算机上图像的各种表示，例如量子位晶格，其中图像是量子位的二维阵列[239]；真实 Ket，其中图像是具有灰度级作为状态系数的量子状态[239]；网格量子位；其中几何形状以量子态编码[240]；量子晶格，其中彩色像素通过量子位存储在量子系统量子位中[241]；量子图像(FRQI)的灵活表示，其中图像是捕捉关于图像中每个点的基本信息的归一化状态(即，它的颜色和位置[237]、[242]、[243])；多通道量子图像(MCQI) [244]，它是 FRQI 表示的扩展，包含用于处理颜色信息的 R、G 和 B 通道，以及数字图像的新型增强量子表示(NEQR)，它与 QPU 中图像的内部表示一起工作[250]。

量子计算和量子信息是渗透到人类活动各个方面的学科，并出现在计算机科学的各个领域，如信息论、密码学、情感表达和图像处理，因为经典计算机上的低效任务可以通过利用量子计算的能力来克服[3]、[233]、[234]、[235]、[236]。加速某些任务的新方法以及计算机科学和其他几个科学领域之间的跨学科研究吸引了浓厚的科学兴趣。

从技术上讲，量子相关的图像处理工作可以分为三大类[63]。

• 量子辅助数字图像处理(QDIP) :这些应用旨在通过利用量子计算算法的一些有用属性来改善一些众所周知的数字或经典图像处理任务和应用【245】。

• 基于光学的量子成像(OQI) :这些应用通过利用光的量子性质和光信号的内在并行性，专注于量子水平的光学成像和并行信息处理技术[247]，[248]。

• 量子图像处理(QIMP) :受即将实现的量子计算硬件的启发，这些应用专注于将经典图像处理任务和应用扩展到量子计算框架[245]，[249]。

研究表明，量子计算机可以利用最大纠缠量子位来重建图像，而无需额外的信息[240]，从而改善存储和检索。已经研究并建立了量子位阵列中的图像存储，但是检索和重建是量子计算改进的另一个重要方面。使用量子测量来探测顶点量子位之间共享的纠缠可以确定它们的位置。此外，量子系统固有的并行性已用于快速图像搜索[42]和图像重建。FRQI 和真实的 ket 图像模型可以同时处理图像的所有像素，展示了它们内在的并行性。

图像分割也是量子计算中图像处理的一个重要方面。图像分割是将图像划分成单独区域的过程，例如，在图片中查找人脸。当自动检测该区域时，这个概念对于机器学习尤其重要。

在传统的图像分割中，与图像中对象的亮度和空间位置相关联的复杂性使得这项任务具有挑战性。换句话说，图像分割在传统的计算机图像识别中失败，通常是因为缺少形成图像期望的先验信息。Venegas-Andraca 等人[240]进一步扩展了他们的技术，并相对于传统系统改进了图像分割。他们继续使用最大纠缠态来存储对应于图像中物体的点。然后，他们可以检测量子纠缠，通过了解哪些顶点对应于哪些对象来确定哪些像素属于哪些对象。然后，使用检测到的角来构建对应于对象形状的地理形状，然后使用数学形态学算子(用于分析几何结构的技术)来填充由这些形状界定的空间。结果是知道哪些像素属于哪些对象。

在所有领域中，研究最多的是[243]和 NEQR [250]。

FRQI，量子图像 FRQI【243】的柔性表示，试图通过角度对经典图像的颜色进行编码，类似于传统计算机上图像的像素表示。它捕捉了图像中每个点的颜色和位置的基本信息，并用公式将它们集成到一个量子态中。

其中，∣q_j⟩= cosθ_j∣ 0⟩+辛θ_j∣ 1⟩、∣0⟩和∣1⟩为二维计算基态，∣ j ⟩为 2 ^{2 n} 维计算基态，为矢量图像的 FRQI 表示中的两部分，∣q_j⟩和∣ * j * ⟩分别对图像中颜色和相应位置的信息进行编码。

FRQI 主要通过 Identity 和 Hadamard 门实现。在量子计算中，计算机通常在准备充分的状态下初始化。因此，需要一个准备过程来将量子计算机从初始状态转换到所需的量子图像状态。

在[244]中提出了一种用于量子图像(MCQI)[243]的多通道表示法，其使用 R、G 和 B 通道来表示关于图像的颜色信息，同时保持其归一化状态。MCQI 提案是通过将编码在 FRQI 图像中的灰度信息扩展到允许设计一些低复杂度颜色信息算子的颜色表示而创建的。MCQI 建议意味着相关算子的计算复杂度与图像大小无关。MCQI 和相关操作似乎还通过在量子电路的设计中隐藏秘密信息，为基于彩色图像的量子水印算法提供了有效的工具[252]。

针对数字图像的新型增强量子表示(NEQR)【250】在 FRQI 和 MCQI 的基础上有所改进。在 FRQI 和 MCQI 表示中，颜色信息通过一个和三个量子位的叠加分别编码。因此，这些量子图像可能需要多次测量来检索信息。新模型或 NEQR 使用量子位序列的基态来存储每个像素的灰度值。因此，在 NEQR 表示中使用代表所有像素的灰度和位置信息的两量子位序列来存储整个图像。

准备 NEQR 图像的计算复杂度显示出二次减少(即， O ( qn )。2 ⁿ ))，对比 FRQI 和 MCQI 图像[250]。然而，要注意的是，NEQR 表示使用多个量子位来编码量子图像。从它的表示来看，需要( q + 2 n )个量子比特来构建一个灰度范围为 2 ^q 的 2n×2^×2n图像的量子图像模型。然而，用于位置信息的 2 个 n 量子位与用于 FRQI 和 MCQI 表示的相同。NEQR 使用 q 量子位获取颜色信息，而 FRQI 和 MCQI 分别使用一个量子位和三个量子位。研究人员设计了改进的 NEQR (INEQR)和广义 QIR (GQIR)，通过将量子图像调整到任意大小，以实现更广泛的应用【253】。

Note

在撰写本书时，一个合作研究团队刚刚更新了 Qiskit 文档网站，其中包含了一些针对 FRQI 和 NEQR 的优秀教程[254]。您可以在 https://qiskit.org/textbook/ch-applications/image-processing-frqi-neqr.html?utm_source=Medium&utm_medium=Social&utm_campaign=Community&utm_content=Textbook-CTA 获得更深入的见解。

张量网络

张量网络最初是为模拟量子物理而设计的，尤其是在低维情况下。它们现在越来越多地应用于解决图像识别等机器学习任务。一些最困难的科学问题，如理解空间和时间的真实性质或开发高温超导体，都涉及到处理量子系统的复杂性。在这些系统中，量子态的数量是指数级的大，否定了蛮力计算作为解决方案的可能途径。为了解决这个问题，使用了张量网络，它是一种数据结构。张量网络由于其灵活性而越来越受到机器学习研究者的关注。

尽管张量网络有明显的吸引力，但传统上，一些困难阻止了它在 ML 社区的广泛使用。

• 用于加速硬件的生产级张量网络库还不能大规模运行张量网络算法。

• 大多数张量网络文献都是面向物理应用的，并造成了一种错误的印象，即理解算法需要量子力学的专业知识。

牢记这一点，Google、周界理论物理研究所( www.perimeterinstitute.ca )和 X ( https://x.company )创建了 TensorNetwork 库，并于 2019 年在两个出版物的背面开源[257][258]。

对于感兴趣的人，建议他们在 https://github.com/google/TensorNetwork 访问 TensorNetwork 的 GitHub 网站。如果你对张量网络模拟感兴趣，一个叫做 TensorTrace(www.tensortrace.com)【259】的工具可以让用户轻松设计和模拟张量网络。如图 9-6 所示。

图 9-6

TensorTrace(来源 www。tensortrace。com

量子金融

量子金融是金融工程与量子场论、经典金融理论、计算机科学和人工智能技术的交叉学科[260]。随着量子计算技术的最新进展和 QML 承诺的量子优势，研究人员已经考虑如何在工业中利用它们。一个主要的重点领域是金融方面(见[260]中的评述)。

由于金融机构在日常工作中执行大量的数值计算任务，量子计算机加速任务的前景太诱人了，不容忽视。其中一项任务就是金融衍生品的定价。 ^{3 因此，衍生品的定价对他们来说是一个重要的问题。}

量子金融的另一个重要方面是期权定价，与金融衍生品密切相关[261]。通过利用量子计算机和算法的概率性质，将量子机器学习与股票市场动态结合的努力一直在进行预测和风险分析；已经为此创建了网站；例如，参见 QFFC at http://qffc.uic.edu.hk/ 。

诸如芝加哥量子交易所( https://quantum.uchicago.edu/about )的合作已经形成，以研究和发展这一令人兴奋的跨学科课题。研究工作包括以下大学。

• 芝加哥大学

• 阿贡国家实验室

• 费米国家加速器实验室

• 伊利诺伊大学香槟分校

• 威斯康星大学麦迪逊分校

• 西北大学

多家创业公司发表了使用 QML 算法对股市投资组合建模和金融预测的研究论文，包括 Chicago Quantum(www.chicagoquantum.com)【262】。瑞穗-DL 金融科技( www.mizuhobank.co.jp )在日本提出将量子蒙特卡罗模拟的增强应用到金融衍生品的定价中[263]。量子有望成为一个令人兴奋的领域，为金融行业带来无限可能，无论是风险分析、投资组合优化、股价预测还是供应链，不一而足。使用的工具以软件库的形式存在(例如，D-Wave、Qiskit、TensorFlow Quantum、PennyLane、pyQuil 等。)、量子模拟器以及硬件(如果需要的话)。

量子通信

目前有一种萌芽但稳定的努力，要建立一个世界范围的量子网际网路，除了经典资料之外，还可以产生、发布和处理量子资讯。美国、英国、中国、欧盟等都在积极投资相关技术和相关研究。例如，2020 年 2 月，美国能源部(DOE)联合布鲁克海文国家实验室(Brookhaven National Laboratories)举办了关于构建世界范围量子互联网的研讨会，并于 2020 年 7 月发布了他们的报告(www.osti.gov/servlets/purl/1638794)【264】。

量子通信研究人员正试图利用量子物理定律来连接用户和大规模保护数据。这些定律允许粒子——通常是光子——利用叠加原理沿着光缆传输数据。目前正在研究的技术解决了量子通信的一些最重要的方面，如 Guha 等人的安全私人投标拍卖[271]、多方共享秘密的生成[34]、[266]、分布式量子计算[267]、改进的传感[268]、[269]以及加密数据的量子计算(盲量子计算)[270]。

量子网络(相对于现有的经典网络)的一个根本区别在于，纠缠本质上存在于网络的物理层，其长距离生成是一个基本的网络功能。这与传统网络不同，在传统网络中，共享状态通常只在较高层建立。在这种情况下，必须找到解决方案，以保证网络设备的保真度能够支持纠缠分发和确定性隐形传态，以及能够补偿损耗并允许操作错误纠正的量子中继器方案。

当能够纠错的设备和级联的量子中继器可用时，量子通信网络的发展就到了最后一步。量子纠错(QEC)一直是量子计算通信领域的一个主要挑战。世界范围内的研究和行业机构正在广泛合作，努力应对 QEC 的挑战。一个重点领域是使用机器学习来优化近期量子系统中的误差；例如，见 Nautrup 等人[284]和 Colomer 等人[285]。

一个长期的挑战是超导量子计算机的联网。迄今为止，典型的方法是通过在发射器处转换成光学频率并在接收器处转换成微波频率来级联换能器。然而，小的微波-光耦合和增加的噪声已经被证明是难以克服的障碍。Krastanov 等人在 2020 年提出了一种绕过这一挑战的方法[276]，其中他们通过预示一个检测到的光子的端到端纠缠和隐形传态来采用光学联网。该方案将低光-微波耦合效率吸收到预示步骤中，打破了速率-保真度的权衡，简化了量子网络中超导和其他物理设备之间的纠缠产生。

量子通信网络的一些最重要的方面是资源管理、可见性、测试网络的模拟和分析。与此相关，2020 年发表了一篇关于评估量子网络性能的最先进工具的伟大综述[277]，重点关注信息论基准、分析工具和模拟。

没有安全协议的通信网络是不完整的。已经提出了某些安全解决方案，例如 QKD 协议、纠缠和基于隐形传态的安全，并且目前正在研究中。然而，在光学平台上实现这些协议以应对通信挑战，例如物理量子位噪声、距离相关的相干性、保真度、记忆和(距离挑战缓解)中继器的密钥再生[282]等等。2020 年 7 月在布鲁克海文国家实验室举行的美国能源部(DOE)量子互联网蓝图研讨会[264]的一些成员建议，在不久的将来，通过利用软件定义的网络 (SDN ) [281]，绕过量子网络的内存要求。

在量子系统研究社区解决量子位噪声、内存和资源分配挑战的几种不同方法中，机器学习是最受欢迎的方法之一。随着时间、研究、资金和精力投入到持续的努力中。通过机器学习和物理之间的联盟，未来有望实现前所未有的技术优势。

摘要

机器学习方法已经有效地用于各种量子信息处理问题，包括量子计量、哈密顿量估计、量子信号处理、使用量子行走算法的量子位映射、量子控制问题以及许多其他问题。包括量子计算机在内的先进量子设备的构建，使用了量子机器学习和人工智能技术。自动化机器可以控制复杂的过程，例如量子计算中使用的一系列简单门的执行。

可靠地训练经典计算模型所需的数据量不断增长，并达到普通计算设备能够处理的极限。在这种情况下，量子计算可以帮助用大量数据进行持续训练。量子机器学习旨在设计比经典算法更有效的学习算法。经典的机器学习是在数据中寻找模式，并使用这些模式来预测未来的事件。另一方面，量子系统产生经典系统无法产生的非典型模式，从而假设量子计算机可以在机器学习任务上超越经典计算机。

当我们更深入地探索二十一世纪时，一个激动人心的未来正等待着我们，它将在金融、科学、生物、化学、物理以及很有可能在我们今天想都想不到的应用领域取得前所未有的进步。

Footnotes 1

通过查看其邻接矩阵的特征值来分析图被称为代数图论或谱图论。

  2

比如 en。维基百科。org/ wiki/ Hamiltonian_(量子力学)

  3

金融衍生工具，或简称为衍生工具，是一种在某些固定时间参考基础资产价格确定收益的合同。