機器學(xué)習(xí) 量子

My last articles tackled Bayes nets on quantum computers (read it here!), and k-means clustering, our first steps into the weird and wonderful world of quantum machine learning.

我的最后一篇文章討論了量子計算機上的貝葉斯網(wǎng)絡(luò)( 在這里閱讀！)和k-means聚類，這是我們進入量子機器學(xué)習(xí)的怪異世界的第一步。

This time, we’re going a little deeper into the rabbit hole and looking at how to build a neural network on a quantum computer.

這次，我們將更深入地研究兔子洞，并研究如何在量子計算機上構(gòu)建神經(jīng)網(wǎng)絡(luò)。

In case you aren’t up to speed on neural nets, don’t worry — we’re starting with neural nets 101.

如果您不適應(yīng)神經(jīng)網(wǎng)絡(luò)的速度，請不要擔(dān)心-我們將從神經(jīng)網(wǎng)絡(luò)101開始。

什么是(經(jīng)典的)神經(jīng)網(wǎng)絡(luò)？ (What even is a (classical) neural network?)

Almost everyone has heard of neural networks — they’re used to run some of the coolest tech we have today — self driving cars, voice assistants, and even the software that generates super realistic pictures of famous people doing questionable things.

幾乎每個人都聽說過神經(jīng)網(wǎng)絡(luò)-它們已經(jīng)被用來運行我們今天擁有的一些最酷的技術(shù)-自動駕駛汽車，語音助手，甚至是生成可疑人物做事的超逼真的圖片的軟件。

What makes them different from regular algorithms is that instead of having to write down a set of rules, we need to provide networks with examples of the problem we want it to solve.

它們與常規(guī)算法的不同之處在于，我們不必編寫一組規(guī)則，而需要為網(wǎng)絡(luò)提供我們要解決的問題的示例。

We could feed a network with some data from the IRIS data set, which contains information about three kinds of flowers, and it might guess which kind of flower it is:

我們可以使用IRIS數(shù)據(jù)集中的一些數(shù)據(jù)為網(wǎng)絡(luò)提供數(shù)據(jù)，該數(shù)據(jù)包含有關(guān)三種花的信息，并且可能會猜測它是哪種花：

Image by Author圖片作者

So now we know what neural networks do — but how do they do it?

所以現(xiàn)在我們知道了神經(jīng)網(wǎng)絡(luò)的作用-但是它們是如何做到的？

重量，偏見和基石 (Weight, biases and building blocks)

Neural networks are made up of many small units called neurons, which look like this:

神經(jīng)網(wǎng)絡(luò)由許多稱為神經(jīng)元的小單元組成，如下所示：

Image by Author圖片作者

Most neurons take multiple numeric inputs (the blue circles), and multiply each one of them by a weight (the w?s) that represent how important each input is. The larger the magnitude of a weight, the more important the associated input is.

大多數(shù)神經(jīng)元接受多個數(shù)字輸入(藍(lán)色圓圈)，然后將每個數(shù)字與一個權(quán)重(w?s)相乘，代表每個輸入的重要性。 權(quán)重的大小越大，關(guān)聯(lián)的輸入就越重要。

The bias is treated like another weight, only that the input it multiplies always has a value of 1. When we add up all the weighted inputs, we get the activation value of the neuron, represented by the purple circle in the picture above:

偏差被視為另一個權(quán)重，只是它所乘的輸入始終具有一個值1。當(dāng)我們將所有加權(quán)的輸入相加時，我們得到了神經(jīng)元的激活值，由上圖中的紫色圓圈表示：

The activation value is then passed through a function (the blue rectangle), and the result is the output of the neuron:

激活值然后通過一個函數(shù)(藍(lán)色矩形)傳遞，結(jié)果是神經(jīng)元的輸出：

We can change a neuron’s behavior by changing the function it uses to transform its activation value — for example, we could use a super simple transformation, like this one:

我們可以通過更改神經(jīng)元用來轉(zhuǎn)換其激活值的函數(shù)來更改神經(jīng)元的行為，例如，可以使用如下所示的超簡單轉(zhuǎn)換：

In practice, however, we use more complex ones, like the sigmoid function:

但是，實際上，我們使用更復(fù)雜的函數(shù)，例如Sigmoid函數(shù)：

How are neurons useful?

神經(jīng)元有什么用？

They can make decisions based on the inputs they receive — for example, we could use a neuron to predict whether we’ll eat pizza or pasta the next time we eat out at an Italian place by feeding it the answers to three questions:

他們可以根據(jù)收到的輸入來做出決定-例如，我們可以使用神經(jīng)元來預(yù)測下一次在意大利吃飯的時候是吃披薩還是面食，方法是將三個問題的答案提供給他們：

• Do I like the pasta at this restaurant?
  我喜歡這家餐廳的面食嗎？
• Does the restaurant have pesto sauce?
  該餐廳有香蒜醬嗎？
• Does the restaurant have a triple cheese pizza?
  這家餐廳有三層奶酪披薩嗎？

Putting aside possible health concerns, let’s see what the neuron might look like — we can encode the inputs using 0 to represent no, 1 to represent yes, and do the same with the outputs by mapping 0 and 1 to pasta and pizza respectively:

撇開可能的健康問題，讓我們看看神經(jīng)元可能是什么樣子—我們可以使用0代表否，1代表是對輸入進行編碼，并通過分別將0和1映射到意大利面和披薩來對輸出進行相同的處理：

Image by Author圖片作者

Let’s use the step function to transform the neuron’s activation value:

讓我們使用step函數(shù)來轉(zhuǎn)換神經(jīng)元的激活值：

Just using one neuron, we can capture multiple decision making behaviours:

僅使用一個神經(jīng)元，我們就可以捕獲多種決策行為：

• If we like the pasta at a restaurant, we choose to order pasta unless pesto sauce is out and they serve a triple cheese pizza.
  如果我們喜歡在餐廳吃意大利面，我們選擇點意大利面，除非沒有香蒜醬，并且可以提供三層奶酪比薩。
• If we don’t like the pasta at a restaurant, we order a pizza unless pesto sauce is available, and the triple cheese pizza is not.
  如果我們不喜歡在餐廳吃意大利面，我們會點披薩，除非有香蒜醬可用，而三層奶酪披薩則沒有。

We can also do things the other way — we can program a neuron so that it corresponds to a specific set of preferences.

我們還可以用其他方式來做事情-我們可以對神經(jīng)元進行編程，使其與一組特定的偏好相對應(yīng)。

If all we wanted to do was predict what we would eat the next time we go out, it would probably be easy to figure out a set of weights and biases for one neuron, but what if we had to do the same with a full-sized network?

如果我們要做的只是預(yù)測下次出門吃什么，可能很容易找出一組神經(jīng)元的權(quán)重和偏見，但是如果我們必須對一個神經(jīng)元做同樣的事情，那該怎么辦？規(guī)模的網(wǎng)絡(luò)？

It would probably take a while.

這可能需要一段時間。

Fortunately, instead of guessing the values of the weights we need, we can create algorithms that change the parameters of a network — the weights, biases, and even the structure — so that it can learn a solution for a problem we want to solve.

幸運的是，我們無需猜測所需的權(quán)重值，而是可以創(chuàng)建可更改網(wǎng)絡(luò)參數(shù)(權(quán)重，偏差甚至結(jié)構(gòu))的算法，以便它可以為我們要解決的問題學(xué)習(xí)解決方案。

下降到頂部 (Going down to get to the top)

Ideally, a network’s prediction would be the same as the label associated with the input we feed it — so the smaller the difference between the prediction and actual output, the better the set of weights the network has learned.

理想情況下，網(wǎng)絡(luò)的預(yù)測應(yīng)與與我們?yōu)槠漭斎氲妮斎胂嚓P(guān)聯(lián)的標(biāo)簽相同-因此，預(yù)測與實際輸出之間的差異越小，網(wǎng)絡(luò)所獲權(quán)重集就越好。

We quantify this difference using a loss function, which can take any form we want, like this one, which is called the quadratic loss function:

我們使用損失函數(shù)來量化這種差異，損失函數(shù)可以采用我們想要的任何形式，例如這種形式，稱為二次損失函數(shù)：

y(x) is the desired output and o(x, θ) is the network’s output when fed data x with parameters θ— since the loss is always non negative, once it takes on values close to 0, we know that the network has learned a good parameter set. Of course, there are other problems that can crop up, like over-fitting, but we’ll ignore those for now.

y(x)是期望的輸出，而o(x，θ)是在饋送帶有參數(shù)θ的數(shù)據(jù)x時網(wǎng)絡(luò)的輸出-由于損耗始終為非負(fù)值，一旦取值接近于0，我們就知道網(wǎng)絡(luò)具有學(xué)習(xí)了一個好的參數(shù)集。 當(dāng)然，還會出現(xiàn)其他問題，例如過度擬合，但我們暫時將其忽略。

Using the loss function, we can figure out what the best parameter set for our network is:

使用損失函數(shù)，我們可以找出為我們的網(wǎng)絡(luò)設(shè)置的最佳參數(shù)是：

So instead of guessing weights, all we need to do is minimize C with respect to parameters θ — which we can do using a technique called gradient descent:

因此，除了猜測權(quán)重之外，我們要做的就是相對于參數(shù)θ最小化C ，我們可以使用稱為“梯度下降”的技術(shù)來做到這一點：

All we’re doing here is looking at how the loss changes if we increase the value of θ?, and then updating θ? so that the loss decreases by a little bit. η is a small number which controls by how much we change θ? every time we update it.

我們在這里所做的只是查看如果增加θ?的值后損耗如何變化，然后更新θ?以使損耗稍微降低。 η是一個很小的數(shù)字，它控制著每次更新θ?時會改變多少。

Why do we need η to be small? We could just adjust it so that the loss on the current x is close to zero after just one update— most times this is not a great idea, because while it would reduce the loss on the current x, it often leads to much worse performance on all the other data samples we feed to the network.

為什么我們需要η小？ 我們可以對其進行調(diào)整，以使一次更新后當(dāng)前x的損失接近零-多數(shù)情況下，這不是一個好主意，因為雖然這會減少當(dāng)前x的損失，但通常會導(dǎo)致更差的性能在所有其他數(shù)據(jù)樣本上，我們將其饋送到網(wǎng)絡(luò)。

Awesome!

太棒了！

Now that we’ve got the basics down, let’s figure out how to build a quantum neural network.

現(xiàn)在，我們已經(jīng)掌握了基礎(chǔ)知識，接下來讓我們弄清楚如何構(gòu)建量子神經(jīng)網(wǎng)絡(luò)。

進入量子宇宙 (Into the quantumverse)

The quantum neural net we’ll be building doesn’t work the exact same way as the classical networks we’ve worked on so far—instead of using neurons with weights and biases, we encode the input data into a bunch of qubits, apply a sequence of quantum gates, and change the gate parameters to minimize a loss function:

我們將要建立的量子神經(jīng)網(wǎng)絡(luò)的工作方式與迄今為止我們所研究的經(jīng)典網(wǎng)絡(luò)完全不同-我們不是使用具有權(quán)重和偏差的神經(jīng)元，而是將輸入數(shù)據(jù)編碼為一堆qubit，應(yīng)用一系列量子門，并更改門參數(shù)以最小化損耗函數(shù)：

Image by Author圖片作者

While that might sound new, the idea is still the same — change the parameter set to minimize the difference between the network predictions and input labels.

盡管這聽起來很新，但想法還是一樣的-更改參數(shù)集以最大程度地減少網(wǎng)絡(luò)預(yù)測和輸入標(biāo)簽之間的差異。

To keep things simple, we’ll be building a binary classifier — meaning that every data point fed to the network has to have an associated label of either 0 or 1.

為簡單起見，我們將構(gòu)建一個二進制分類器-這意味著饋入網(wǎng)絡(luò)的每個數(shù)據(jù)點都必須具有0或1的關(guān)聯(lián)標(biāo)簽。

How does it work?

它是如何工作的？

We start by feeding some data x to the network, which is passed through a feature map — a function that transforms the input data into a form we can use to create the input quantum state:

我們首先將一些數(shù)據(jù)x饋入網(wǎng)絡(luò)，然后通過特征圖傳遞給網(wǎng)絡(luò)-該函數(shù)將輸入數(shù)據(jù)轉(zhuǎn)換為可用于創(chuàng)建輸入量子態(tài)的形式：

The feature map we use can look like almost anything — here’s one that takes in a two dimensional vector x, and spits out an angle:

我們使用的特征圖看起來幾乎可以是任何東西-這是一個輸入二維向量x并吐出一個角度的圖：

Once x is encoded as a quantum state, we apply a series of quantum gates:

將x編碼為量子態(tài)后，我們將應(yīng)用一系列量子門：

The network output, which we’ll call π(x, θ), is the probability of the last qubit being measured as in the |1? state, plus a bias term that is added classically:

網(wǎng)絡(luò)輸出，我們稱之為π( x ， θ)是在| 1〉狀態(tài)下測量最后一個qubit的概率，加上經(jīng)典添加的偏置項：

The Z? ? ? stands for a Z gate applied to the last qubit.

Z?代表施加到最后一個量子位的Z門。

Finally, we take the output and the label associated with x, and use them to compute the loss over the sample — we’ll use the same quadratic loss from above. The cost over the entire data set X we feed the network then becomes:

最后，我們獲取與x關(guān)聯(lián)的輸出和標(biāo)簽，并使用它們來計算樣本的損失-我們將從上方使用相同的二次損失。 然后，我們?yōu)榫W(wǎng)絡(luò)提供的整個數(shù)據(jù)集X的成本變?yōu)?#xff1a;

The prediction of the network p can be obtained from the output:

網(wǎng)絡(luò)p的預(yù)測可以從輸出中獲得：

Now all we need to do is to figure out how to compute the gradients of the loss function l(x, θ). While we could do it classically, that would be boring — what we need is a way to compute them on a quantum computer.

現(xiàn)在，我們要做的就是弄清楚如何計算損失函數(shù)l ( x ，θ)的梯度。 盡管我們可以經(jīng)典地做到這一點，但這將很無聊–我們需要的是一種在量子計算機上進行計算的方法。

一種計算梯度的新方法 (A new way to compute gradients)

Let’s start by differentiating the loss function with respect to a parameter θ?:

讓我們從關(guān)于參數(shù)θ?的損耗函數(shù)開始：

Let’s expand the last term:

讓我們擴展最后一個術(shù)語：

We can quickly get rid of the constant terms — and in the case that θ? = b, we know that the gradient is simply 1:

我們可以快速擺脫常數(shù)項-并且在θ?= b的情況下，我們知道梯度只是1：

Now, using the product rule, we can expand further:

現(xiàn)在，使用乘積規(guī)則，我們可以進一步擴展：

That probably looks a little painful to read — but thanks to the Hermitian conjugate (the ?), this has a concise representation:

讀起來可能有點痛苦-但由于使用了Hermitian共軛(?)，因此表示簡潔：

Since U(θ) is made up of multiple gates, each of them controlled by a different parameter (or sets of parameters), finding the partial derivative of U only involves differentiating the gate U?(θ?) that is dependent on θ?:

由于U (θ)由多個門組成，每個門由不同的參數(shù)(或一組參數(shù))控制，因此找到U的偏導(dǎo)數(shù)僅涉及區(qū)分門U? (θ?) 取決于θ?：

This is where the form we choose for each U? becomes important. We’ll use the same form for every U?, which we’ll call a G gate — the choice of form is arbitrary, so you could use any other form you can think of instead:

在這里，我們?yōu)槊總€U?選擇的形式變得很重要。 我們將對每個U?使用相同的形式，我們將其稱為G門-形式的選擇是任意的，因此您可以使用可以想到的任何其他形式來代替：

Now that we know what each U? looks like, we can find its derivative:

現(xiàn)在我們知道每個U?的樣子， 我們可以找到它的派生詞：

Lucky for us, we can express this in terms of the G gate:

對我們來說很幸運，我們可以用G來表示 門：

So all that’s left is to figure out how to create a circuit that gives us the inner product form we need:

因此，剩下的就是弄清楚如何創(chuàng)建一個電路，為我們提供所需的內(nèi)部產(chǎn)品形式：

The easiest way to get a measurable that is proportional to this is to use the Hadamard test — first, we prepare the input quantum state and push an ancilla into superposition:

獲得與之成比例的可測量值的最簡單方法是使用Hadamard檢驗 -首先，我們準(zhǔn)備輸入量子態(tài)并將輔助子項推入疊加狀態(tài)：

Now apply Z? ? ?B onto ψ, conditioned on the ancilla being in the 1 state:

現(xiàn)在，將Z?B?B應(yīng)用于 ψ，條件是附加柱處于1狀態(tài)：

Then flip the ancilla, and do the same with A:

然后翻轉(zhuǎn)ancilla，并使用A進行相同操作：

Finally, apply another Hadamard gate onto the ancilla:

最后，將另一個Hadamard門應(yīng)用到輔助部件上：

Now the probability of measuring the ancilla as 0 is

現(xiàn)在測量輔助線為0的概率為

So if we substitute U(θ) for B, and a copy of U(θ) with U? swapped out for its derivative for A, then the probability of the ancilla qubit will give us the gradient of π(x, θ) with respect to θ?.

因此，如果我們用U (θ)代替B ，并且用U?的U (θ)的副本替換為A的導(dǎo)數(shù)， 那么輔助量子位的概率將給我們π( x ， 相對于θ?。

Great!

大！

We figured out a way to analytically compute gradients on a quantum computer — now all that’s left is to build our quantum neural network.

我們找到了一種在量子計算機上分析計算梯度的方法-現(xiàn)在剩下的就是建立我們的量子神經(jīng)網(wǎng)絡(luò)。

建立量子神經(jīng)網(wǎng)絡(luò) (Building a quantum neural network)

Let’s import all the modules we need to kick things off:

讓我們導(dǎo)入所有需要啟動的模塊：

from qiskit import QuantumRegister, ClassicalRegister from qiskit import Aer, execute, QuantumCircuit from qiskit.extensions import UnitaryGate import numpy as np

Now let’s take a look at some of our data (you can get it right here!) — it’s a processed version of the IRIS data set, with one class removed:

現(xiàn)在，讓我們看一些數(shù)據(jù)(您可以在這里找到它！)—它是IRIS數(shù)據(jù)集的處理后的版本，其中刪除了一個類：

0.803772773,0.5516087658,0.2206435063,0.0315205009,0 0.714141252,0.2664706164,0.6182118301,0.1918588438,1 0.7761140001,0.5497474167,0.3072117917,0.03233808334,0 0.8609385733,0.4400352708,0.2487155878,0.05739590488,0 0.690525124,0.3214513508,0.6071858849,0.2262065061,1

We need to separate the features (the first four columns) from the labels:

我們需要將功能(前四列)與標(biāo)簽分開：

data = np.genfromtxt("processedIRISData.csv", delimiter=",") X = data[:, 0:4] features = np.array([convertDataToAngles(i) for i in X]) Y = data[:, -1]

Now let’s build a function that will do the feature mapping for us.

現(xiàn)在，讓我們構(gòu)建一個為我們進行功能映射的函數(shù)。

Since the input vectors are normalized and 4 dimensional, there is a super simple option for the mapping — use 2 qubits to hold the encoded data, and use a mapping that just recreates the input vector as a quantum state.

由于輸入向量是歸一化的和4維的，因此映射有一個超級簡單的選擇-使用2個量子位來保存編碼數(shù)據(jù)，并使用僅將輸入向量重新創(chuàng)建為量子態(tài)的映射。

For this we need two functions — one to extract angles from the vectors:

為此，我們需要兩個函數(shù)-一個從向量中提取角度：

def convertDataToAngles(data):"""Takes in a normalised 4 dimensional vector and returns three angles such that the encodeData function returns a quantum state with the same amplitudes as the vector passed in. """prob1 = data[2] ** 2 + data[3] ** 2prob0 = 1 - prob1angle1 = 2 * np.arcsin(np.sqrt(prob1))prob1 = data[3] ** 2 / prob1angle2 = 2 * np.arcsin(np.sqrt(prob1))prob1 = data[1] ** 2 / prob0angle3 = 2 * np.arcsin(np.sqrt(prob1))return np.array([angle1, angle2, angle3])

Another to convert the angles we get into a quantum state:

另一種將角度轉(zhuǎn)換為量子態(tài)的方法：

def encodeData(qc, qreg, angles):"""Given a quantum register belonging to a quantumcircuit, performs a series of rotations and controlledrotations characterized by the angles parameter.""" qc.ry(angles[0], qreg[1])qc.cry(angles[1], qreg[1], qreg[0])qc.x(qreg[1])qc.cry(angles[2], qreg[1], qreg[0])qc.x(qreg[1])

This might seem a little confusing, but understanding how it works isn’t essential to building the QNN — you can read up on it here if you like.

這似乎有些令人困惑，但是了解它的工作方式對于構(gòu)建QNN并不是必不可少的-如果愿意，可以在這里閱讀。

Now we can write the functions we need to implement U(θ), which will take the form of alternating layers of RY and CX gates.

現(xiàn)在我們可以編寫實現(xiàn)U (θ)所需的函數(shù)，該函數(shù)將采用RY和CX交替層的形式 蓋茨。

Why do we need the CX layers?

為什么我們需要CX層？

If we didn’t include them, we wouldn’t be able to perform any entanglement operations, which would limit the area within the Hilbert space that our network can reach — using CX gates, the network can capture interactions between qubits that it wouldn't be able to without them.

如果不包括它們，我們將無法執(zhí)行任何糾纏操作，這將限制我們的網(wǎng)絡(luò)在希爾伯特空間內(nèi)可以到達(dá)的區(qū)域-使用CX門，網(wǎng)絡(luò)可以捕獲量子比特之間的相互作用，不能沒有他們。

We’ll start with the G gates:

我們將從G門開始：

def GGate(qc, qreg, params):"""Given a parameter α, return a singlequbit gate of the form[cos(α), sin(α)][-sin(α), cos(α)]""" u00 = np.cos(params[0])u01 = np.sin(params[0])gateLabel = "G({})".format(params[0])GGate = UnitaryGate(np.array([[u00, u01], [-u01, u00]]), label=gateLabel)return GGatedef GLayer(qc, qreg, params):"""Applies a layer of GGates onto the qubits of registerqreg in circuit qc, parametrized by angles params.""" for i in range(2):qc.append(GGate(qc, qreg, params[i]), [qreg[i]])

Next, we’ll do the CX gates:

接下來，我們將進行CX門操作：

def CXLayer(qc, qreg, order):"""Applies a layer of CX gates onto the qubits of registerqreg in circuit qc, with the order of applicationdetermined by the value of the order parameter.""" if order:qc.cx(qreg[0], qreg[1])else:qc.cx(qreg[1], qreg[0])

Now we put them together to get U(θ):

現(xiàn)在我們將它們放在一起以獲得U (θ)：

def generateU(qc, qreg, params):"""Applies the unitary U(θ) to qreg by composing multiple G layers and CX layers. The unitary is parametrized bythe array passed into params.""" for i in range(params.shape[0]):GLayer(qc, qreg, params[i])CXLayer(qc, qreg, i % 2)

Next we create a function that allows us to get the output of the network, and another that converts those outputs into class predictions:

接下來，我們創(chuàng)建一個函數(shù)，該函數(shù)使我們能夠獲取網(wǎng)絡(luò)的輸出，而另一個函數(shù)會將這些輸出轉(zhuǎn)換為類預(yù)測：

def getPrediction(qc, qreg, creg, backend):"""Returns the probability of measuring the last qubitin register qreg as in the |1? state.""" qc.measure(qreg[0], creg[0])job = execute(qc, backend=backend, shots=10000)results = job.result().get_counts()if '1' in results.keys():return results['1'] / 100000else:return 0def convertToClass(predictions):"""Given a set of network outputs, returns class predictionsby thresholding them.""" return (predictions >= 0.5) * 1

Now we can build a function that performs a forward pass on the network — feeds it some data, processes it, and gives us the network output:

現(xiàn)在，我們可以構(gòu)建一個在網(wǎng)絡(luò)上執(zhí)行前向傳遞的功能-向其提供一些數(shù)據(jù)，對其進行處理，并為我們提供網(wǎng)絡(luò)輸出：

def forwardPass(params, bias, angles, backend):"""Given a parameter set params, input data in the formof angles, a bias, and a backend, performs a full forward pass on the network and returns the networkoutput."""qreg = QuantumRegister(2)anc = QuantumRegister(1)creg = ClassicalRegister(1)qc = QuantumCircuit(qreg, anc, creg)encodeData(qc, qreg, angles)generateU(qc, qreg, params)pred = getPrediction(qc, qreg, creg, backend) + biasreturn pred

After that, we can write all the functions we need to measure gradients — first, we need to be able to apply controlled versions of U(θ):

之后，我們可以編寫測量梯度所需的所有功能-首先，我們需要能夠應(yīng)用U (θ)的受控版本：

def CGLayer(qc, qreg, anc, params):"""Applies a controlled layer of GGates, all conditionedon the first qubit of the anc register."""for i in range(2):qc.append(GGate(qc, qreg, params[i]).control(1), [anc[0], qreg[i]])def CCXLayer(qc, qreg, anc, order):"""Applies a layer of Toffoli gates with the firstcontrol qubit always being the first qubit of the ancregister, and the second depending on the valuepassed into the order parameter."""if order:qc.ccx(anc[0], qreg[0], qreg[1])else:qc.ccx(anc[0], qreg[1], qreg[0])def generateCU(qc, qreg, anc, params):"""Applies a controlled version of the unitary U(θ),conditioned on the first qubit of register anc."""for i in range(params.shape[0]):CGLayer(qc, qreg, anc, params[i])CCXLayer(qc, qreg, anc, i % 2)

Using this we can create a function that computes expectation values:

使用這個我們可以創(chuàng)建一個計算期望值的函數(shù)：

def computeRealExpectation(params1, params2, angles, backend):"""Computes the real part of the inner product of thequantum states produced by acting with U(θ)characterised by two sets of parameters, params1 andparams2."""qreg = QuantumRegister(2)anc = QuantumRegister(1)creg = ClassicalRegister(1)qc = QuantumCircuit(qreg, anc, creg)encodeData(qc, qreg, angles)qc.h(anc[0])generateCU(qc, qreg, anc, params1)qc.cz(anc[0], qreg[0])qc.x(anc[0])generateCU(qc, qreg, anc, params2)qc.x(anc[0])qc.h(anc[0])prob = getPrediction(qc, anc, creg, backend)return 2 * (prob - 0.5)

Now we can figure out the gradients of the loss function — the multiplication we do at the end is to account for the π(x, θ) - y(x) term in the gradient:

現(xiàn)在我們可以計算出損失函數(shù)的梯度-最后我們要做的乘法是解決梯度中的π ( x ，θ)-y( x )項：

def computeGradient(params, angles, label, bias, backend):"""Given network parameters params, a bias bias, input dataangles, and a backend, returns a gradient array holdingpartials with respect to every parameter in the arrayparams."""prob = forwardPass(params, bias, angles, backend)gradients = np.zeros_like(params)for i in range(params.shape[0]):for j in range(params.shape[1]):newParams = np.copy(params)newParams[i, j, 0] += np.pi / 2gradients[i, j, 0] = computeRealExpectation(params, newParams, angles, backend)newParams[i, j, 0] -= np.pi / 2biasGrad = (prob + bias - label)return gradients * biasGrad, biasGrad

Once we have the gradients, we can update the network parameters using gradient descent, along with a trick called momentum, which helps speed up training times:

一旦有了梯度，就可以使用梯度下降以及稱為動量的技巧來更新網(wǎng)絡(luò)參數(shù)，這有助于加快訓(xùn)練時間：

def updateParams(params, prevParams, grads, learningRate, momentum):"""Updates the network parameters using gradient descent and momentum."""delta = params - prevParamsparamsNew = np.copy(params)paramsNew = params - grads * learningRate + momentum * deltareturn paramsNew, params

Now we can build our cost and accuracy functions so we can see how our network is responding to training:

現(xiàn)在，我們可以構(gòu)建成本和準(zhǔn)確性功能，以便了解我們的網(wǎng)絡(luò)如何響應(yīng)培訓(xùn)：

def cost(labels, predictions):"""Returns the sum of quadratic losses over the set(labels, predictions)."""loss = 0for label, pred in zip(labels, predictions):loss += (pred - label) ** 2return loss / 2def accuracy(labels, predictions):"""Returns the percentage of correct predictions in theset (labels, predictions)."""acc = 0for label, pred in zip(labels, predictions):if label == pred:acc += 1return acc / labels.shape[0]

Finally, we create the function that trains the network, and call it:

最后，我們創(chuàng)建訓(xùn)練網(wǎng)絡(luò)的函數(shù)，并調(diào)用它：

def trainNetwork(data, labels, backend):"""Train a quantum neural network on inputs data andlabels, using backend backend. Returns the parameterslearned."""np.random.seed(1)numSamples = labels.shape[0]numTrain = int(numSamples * 0.75)ordering = np.random.permutation(range(numSamples))trainingData = data[ordering[:numTrain]]validationData = data[ordering[numTrain:]]trainingLabels = labels[ordering[:numTrain]]validationLabels = labels[ordering[numTrain:]]params = np.random.sample((5, 2, 1))bias = 0.01prevParams = np.copy(params)prevBias = biasbatchSize = 5momentum = 0.9learningRate = 0.02for iteration in range(15):samplePos = iteration * batchSizebatchTrainingData = trainingData[samplePos:samplePos + 5]batchLabels = trainingLabels[samplePos:samplePos + 5]batchGrads = np.zeros_like(params)batchBiasGrad = 0for i in range(batchSize):grads, biasGrad = computeGradient(params, batchTrainingData[i], batchLabels[i], bias, backend)batchGrads += grads / batchSizebatchBiasGrad += biasGrad / batchSizeparams, prevParams = updateParams(params, prevParams, batchGrads, learningRate, momentum)temp = biasbias += -learningRate * batchBiasGrad + momentum * (bias - prevBias)prevBias = temptrainingPreds = np.array([forwardPass(params, bias, angles, backend) for angles in trainingData])print('Iteration {} | Loss: {}'.format(iteration + 1, cost(trainingLabels, trainingPreds)))validationProbs = np.array([forwardPass(params, bias, angles, backend) for angles in validationData])validationClasses = convertToClass(validationProbs)validationAcc = accuracy(validationLabels, validationClasses)print('Validation accuracy:', validationAcc)return paramsbackend = Aer.get_backend('qasm_simulator') learnedParams = trainNetwork(features, Y, backend)

The numbers we pass into the np.random.sample() method determines the size of our parameter set — the first number (5) is the number of G layers we want.

我們傳遞給np.random.sample()方法的數(shù)字確定了參數(shù)集的大小-第一個數(shù)字(5)是所需的G層數(shù)。

This was the output I got after training a network with five layers for fifteen iterations:

這是在訓(xùn)練具有五個層的網(wǎng)絡(luò)進行十五次迭代后得到的輸出：

Iteration 1 | Loss: 17.433085925400004 Iteration 2 | Loss: 16.29878057140824 Iteration 3 | Loss: 14.796300997002378 Iteration 4 | Loss: 13.45048890335602 Iteration 5 | Loss: 12.207399339199581 Iteration 6 | Loss: 11.203202358947257 Iteration 7 | Loss: 9.836832509742251 Iteration 8 | Loss: 8.901883213728054 Iteration 9 | Loss: 8.022787152763158 Iteration 10 | Loss: 7.408032981549452 Iteration 11 | Loss: 6.728295582051598 Iteration 12 | Loss: 6.193162047195093 Iteration 13 | Loss: 5.866241892968018 Iteration 14 | Loss: 5.445387724245562 Iteration 15 | Loss: 5.19377811976361 Validation accuracy: 1.0

Looks pretty good — we’ve achieved 100% accuracy on the validation set, meaning that the network generalised to unseen examples successfully!

看起來不錯-我們已經(jīng)在驗證集上實現(xiàn)了100％的準(zhǔn)確性，這意味著該網(wǎng)絡(luò)成功地推廣到了看不見的示例！

結(jié)語 (Wrapping up)

So we built a quantum neural network —awesome!

因此，我們建立了一個量子神經(jīng)網(wǎng)絡(luò)-太棒了！

There are a couple of ways we can maybe bring the loss further down — train the network for a few more iterations, or play with hyper-parameters like batch size and learning rate.

我們有幾種方法可以使損失進一步降低-對網(wǎng)絡(luò)進行更多的迭代訓(xùn)練，或者使用批處理大小和學(xué)習(xí)率等超參數(shù)。

A cool way to take things forward would be to experiment with different gate selections for U(θ) — you might be able to find one that works a lot better!

一種前進的好方法是嘗試對U (θ)使用不同的門選擇-您可能會找到效果更好的選擇！

You can grab the entire project here. If you have any questions, drop a comment here, or get in touch — I would be happy to help!

您可以在此處獲取整個項目。 如果您有任何疑問，請在此處發(fā)表評論或與我們聯(lián)系-我們將很樂意為您提供幫助！

翻譯自: https://towardsdatascience.com/quantum-machine-learning-learning-on-neural-networks-fdc03681aed3

機器學(xué)習(xí) 量子

總結(jié)

以上是生活随笔為你收集整理的机器学习 量子_量子机器学习：神经网络学习的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網(wǎng)站內(nèi)容還不錯，歡迎將生活随笔推薦給好友。