---
abstract: 'We propose a quantum generalisation of a classical neural network. The classical neurons are firstly rendered reversible by adding ancillary bits. Then they are generalised to being quantum reversible, i.e. unitary. (The classical networks we generalise are called feedforward, and have step-function activation functions.) The quantum network can be trained efficiently using gradient descent on a cost function to perform quantum generalisations of classical tasks. We demonstrate numerically that it can: (i) compress quantum states onto a minimal number of qubits, creating a quantum autoencoder, and (ii) discover quantum communication protocols such as teleportation. Our general recipe is theoretical and implementation-independent. The quantum neuron module can naturally be implemented photonically.'
author:
- Kwok Ho Wan
- Oscar Dahlsten
- Hlér Kristjánsson
- Robert Gardner
- 'M.S. Kim'
bibliography:
- 'bibliography\_bibtex.bib'
title: Quantum generalisation of feedforward neural networks
---

Introduction {#introduction .unnumbered}
============

Artificial neural networks mimic biological neural networks to perform information processing tasks. They are highly versatile, applying to vehicle control, trajectory prediction, game-playing, decision making, pattern recognition (such as facial recognition, spam filters), financial time series prediction, automated trading systems, mimicking unpredictable processes, and data mining [@Nielsen15; @Azoff94]. The networks can be trained to perform tasks without the programmer necessarily detailing how to do it. Novel techniques for training networks of many layers (deep networks) is credited with giving impetus to the neural networks approach [@LecunBengioHinton15].

The field of quantum machine learning is rapidly developing though the focus has aruably not been on the connection to neural networks. Quantum machine learning, see e.g. [@LloydMR13; @LloydMR13ii; @Montanaro15; @Aaronson15; @GarneroneZL12; @HarrowHL09; @LloydGZ16; @RebenstrostML13; @WiebeBL12; @Adcock15; @HeimRIT15; @GrossYFBE10; @Dunjko16; @Wittek14] employs quantum information processing (QIP) [@NielsenChuang00]. QIP uses quantum superpositions of states with the aim of faster processing of classical data as well as tractable simulation of quantum systems. In a superposition each bit string is associated with two numbers: the probability of the string and the [*phase*]{} [@GarnerDNMV15], respectively. The phase impacts the future probabilities via a time evolution law. There are certain promising results that concern quantum versions of recurrent neural networks, wherein neurons talk to each other in all directions rather than feeding signals forward to the next layer, e.g. with the purpose of implementing quantum simulated annealing [@Lechnere1500838; @quantum-deep-learning; @HeimRIT15; @GarneroneZL12]. In [@Schuld14] several papers proposing quantum neural network designs are discussed and critically reviewed. A key challenge to overcome is the clash between the nonlinear, dissipative dynamics of neural network computing and the linear, reversible dynamics of quantum computing [@Schuld14]. A key reason for wanting well-functioning quantum neural networks is that these could do for quantum inputs what classical networks can do for classical inputs, e.g. compressing data encoded in quantum superpositions to a minimal number of qubits.

We here accordingly focus on creating quantum generalisations of classical neural networks, which can take quantum inputs and process them coherently. Our networks contribute to a research direction known as [ *quantum learning*]{}  [@Bisio10; @Sasaki02; @Sentis15; @Banchi16; @Palittapongarnpim16] which concerns learning and optimising with truly quantum objects. The networks provide a route to harnessing the powerful neural network paradigm for this purpose. Moreover they are strict generalisations of the classical networks, providing a clear framework for comparing the power of quantum and classical neural networks.

The networks generalise classical neural networks to the quantum case in a similar sense to how quantum computing generalises classical computing. We start with a common classical neural network family: feedforward perceptron networks. We make the invidual neurons reversible and then naturally generalise them to being quantum reversible (unitary). This resolves the classical-quantum clash mentioned above from [@Schuld14]. An efficient training method is identified: global gradient descent for a quantum generalisation of the cost function, a function evaluating how close the outputs are to the desired outputs. To illustrate the ability of the quantum network we apply it to (i) compressing information encoded in superpositions onto fewer qubits (an autoencoder) and (ii) re-discovering the quantum teleportation protocol—this illustrates that the network can work out QIP protocols given only the task. To make the connection to physics clear we describe how to simulate and train the network with quantum photonics.

We proceed as follows. Firstly, we describe the recipe for generalising the classical neural network. Then it is demonstrated how the network can be applied to the tasks mentioned above, followed by a design of a quantum photonic realisation of a neural module. We discuss the results, followed finally by a summary and outlook.

Quantum neural networks {#quantum-neural-networks .unnumbered}
=======================

Classical neural networks are composed of elementary units called neurons. We begin with describing these, before detailing how to generalise them to quantum neurons.

The classical neuron {#the-classical-neuron .unnumbered}
--------------------

A classical neuron is depicted in FIG. \[fig:classical\_neuron\]. In this case, it has two inputs (though there could be more). There is one output, which depends on the inputs (bits in our case) and a set of weights (real numbers): if the weighted sum of inputs is above a set threshold, the output is 1, else it is 0.

![\[fig:classical\_neuron\]A classical neuron taking two inputs $in_{1}$ and $in_{2}$ and giving a corresponding output $out$ [@Nielsen15]. $a_j^{(l)}$ labels the output of the $j^{th}$ neuron in the $l^{th}$ layer of the network. ](classical_neuron1.png){height="2cm"}

We will use the following standard general notation. The $j^{th}$ neuron in the $l^{th}$ layer of a network takes a number of inputs, $a^{(l-1)}_{k}$, where $k$ labels the input. The inputs are each multiplied by a corresponding weight, $w^{(l)}_{jk}$, and an output, $a_{j}^{(l)}$, is fired as a function of the weighted input $z_{j}^{(l)}=\sum_{k=1}^{n} w^{(l)}_{jk} a^{(l-1)}_{k} $, where $n$ is the number of inputs to the neuron (FIG. \[fig:classical\_neuron\]). The function relating the output to the weighted input is called the activation function, which has most commonly been a Heaviside step function or a sigmoid  [@Nielsen15]. For example, the neuron in FIG. \[fig:classical\_neuron\] with a Heaviside activation function gives an output of the form: $$a_{j}^{(l)} = \left\{\begin{matrix}
1, ~$if$~ z_{j}^{(l)} > 0.5\\ 
\!\!\! 0, ~$otherwise.$\\ 
\end{matrix}\right.$$ This paper aims to generalise the classical neuron to a quantum mechanical one. In the absence of measurement, quantum mechanical processes are required to be reversible, and more specifically, unitary, in a closed quantum system [@Feynman86; @NielsenChuang00]. This suggests the following procedure for generalising the neuron first to a reversible gate and finally to a unitary gate:

[*Irreversible $\rightarrow$ reversible:*]{} For an $n$-input classical neuron having $(in_1, in_2, ..., in_n )\rightarrow out$, create a classical reversible gate taking ($in_1, in_2, ..., in_n, 0) \rightarrow (in_1, in_2, ..., in_n, out)$. Such an operation can always be represented by a permutation matrix [@Muthukrishnan99]. This is a clean way of rendering the classical neuron reversible. The extra ‘dummy’ input bit is used to make it reversible [@Feynman86]; in particular, some of the ‘2 bits in – 1 bit out’ functions the neuron can implement require 3 bits to be made reversible in this manner.

[*Reversible $\rightarrow$ unitary:*]{} Generalise the classical reversible gate to a quantum unitary taking input ($\ket{\psi_{in}}_{1,2,...,n}\ket{0}) \rightarrow  \ket{\psi_{out}}_{1,2,...,n,out}$, such that the final output qubit is the output of interest. This is the natural way of making a permutation matrix unitary.

If the input is a mixture of states in the computational basis and the unitary a permutation matrix [@CurtisReiner62], the output qubit will be a mixture of $\ket{0}$ or $\ket{1}$: this we call the [*classical special case*]{}. This way the quantum neuron can simulate any classical neuron as defined above. The generalisation recipe summarised in FIG. \[fig:neuron\_generalisation\] also illustrates how any irreversible classical computation can be recovered as a special case from reversible classical computation (by ignoring the dummy and copied bits), which in turn can be recovered as a special case from quantum computation.

![\[fig:neuron\_generalisation\]Diagram summarising our method of generalising the classical irreversible neuron with Heaviside activation function, first to a reversible neuron represented by a permutation matrix (P), and finally to a quantum reversible computation, represented by a unitary operator (U).](neuron_generalisation_greybox_small.png){width="\linewidth"}

### The network {#the-network .unnumbered}

In order to form a neural network, classical neurons are connected together in various configurations. Here, we consider feedforward classical networks, where neurons are arranged in layers and each neuron in the $l^{th}$ layer is connected to every neuron in the $(l-1)^{th}$ and $(l+1)^{th}$ layers, but with no connections within the same layer. For an example of such a classical network, see FIG. \[fig:cl\_autoencoder\]. Note that in this case the same output of a single neuron is sent to all the neurons in the next layer [@Nielsen15; @Azoff94].

To make the copying reversible, in line with our approach of firstly making the classical neural network reversible, we propose the recipe:\
\
[*Irreversible $\rightarrow$ reversible:*]{} For a classical irreversible copying operation of a bit $b \rightarrow (b, b)$, create a classical reversible gate, which can be represented by a permutation matrix [@Feynman86], taking $(b, 0) \rightarrow (b, b)$.\
\
In the quantum case the no-cloning theorem shows one cannot do this in the most naive way [@NielsenChuang00]. For a 2-qubit case, one can use a CNOT for example to copy in the classical computational basis [@Feynman86]: $\ket{b}\ket{0}\rightarrow \ket{b}\ket{b}$, if $\ket{b}\in \{\ket{0}, \ket{1} \}$. Thus one may consider replacing the copying with a CNOT. However when investigating applications of the network we realised that there are scenarios (the autoencoder in particular) where entanglement between different neurons is needed to perform the task. We have therefore chosen the following definition:\
\
[*Reversible $\rightarrow$ unitary:*]{} The classical CNOT is generalised to a general 2-qubit ‘fan-out’ unitary $U_F$, with one dummy input set to $\ket{0}$, such that $\ket{b}\ket{0}\rightarrow U_F\ket{b}\ket{0}$. As this unitary does not in general copy quantum states that are non-orthogonal we call it a ‘fan-out’ operation rather than a copying operation, as it distributes information about the input state into several output qubits. Note that a quantum network would be *trained* to choose the unitary in question.

![\[fig:cl\_autoencoder\]A classical autoencoder taking two inputs $in_{1}=a^{(0)}_{1}$ and $in_{2}=a^{(0)}_{2}$ and compressing them to one hidden layer output $a^{(l)}_{1}$. The final output layer is used in training and is trained to reconstruct the inputs. The notation here is in accordance with [@Nielsen15]. The blue box represents the data compression device after the training procedure.](cl_autoencoder.png){height="3cm"}

### Efficient training with gradient descent {#efficient-training-with-gradient-descent .unnumbered}

A classical neural network is trained to perform particular tasks. This is done by randomly initialising the weights and then propagating inputs through the network many times, altering the weights after each propagation in such a way as to make the network output closer to the desired output. A cost function, $C$, relating the network output to the desired output is defined by $$\label{eq:cost}
C = \frac{1}{2}\Big|\vec{y}^{\:(L)}-\vec{a}^{\:(L)}\Big|^2,$$ where $\vec{y}^{\:(L)}$ is a vector of the desired outputs from each of the final layer $l=L$ neurons and $\vec{a}^{\:(L)}$ is the vector of actual outputs, which depends on the network weights, and $\Big|(.)\Big|$ is the $l^2$-norm. The cost function is minimised to zero when the weights propagate the input in such a way that the network output vector equals the desired output vector.

Since the weights are continuous variables, the numerical partial derivatives of the cost function w.r.t. each weight can be found by approximating $\frac{\partial C}{\partial w}\approx \frac{ C(w+\epsilon)-C(w)}{ \epsilon}$. After each propagation, these partial derivatives are computed and the weights are altered in the direction of greatest decrease of the cost function. Specifically, each weight $w^{(l)}_{jk}$ is increased by $\mathrm{\delta} w^{(l)}_{jk}$, with $$\label{eq:learningrule}
\mathrm{\delta} w^{(l)}_{jk}=-\eta\frac{\partial C}{\partial w^{(l)}_{jk}},$$ where $\eta$ is an adjustable non-negative parameter. This training procedure is known as gradient descent [@Nielsen15].

Note that gradient descent normally also requires a continuous and differentiable activation function, to allow small changes in the weights to relate to small changes in the cost. For this reason, the Heaviside activation function has traditionally been replaced by a sigmoid function [@Nielsen15; @Azoff94]. Nevertheless, gradient descent has also been achieved using Heaviside activation functions, by taking the weights as Gaussian variables and taking partial derivatives w.r.t. the means and standard deviations of the appropriate Gaussian distributions [@BartlettDowns92; @DownsGaynier95].

In the reversible generalisation, where each neuron is replaced by a permutation matrix, we find that the output is no longer a function of the inputs and *continuous* weights, but rather of the inputs and a *discrete set* of permutation matrices. However, in the generalisation to unitaries, for a gate with $n$ inputs and outputs, there exist an infinite number of unitaries, in contrast with the discrete set of permutation matrices. This means that the unitaries can be parametrised by continuous variables, which once again allows the application of gradient descent.

Given that any unitary matrix $U$ can be expressed as $U=e^{iH}$, where $H$ is a Hermitian matrix [@NielsenChuang00], and that such matrices can be written as linear combinations of tensor products of the Pauli matrices and the identity, it follows that a general $N$-qubit unitary can be expressed as $$\label{eq:u_n}
U_{N} \! = \! \exp \! \Bigg[ \! i \Bigg(\!
\sum_{j_{1},...,j_{N}=0,...,0}^{3,...,3} \! \! \! \! \! \! \! \! \!
\alpha_{j_{1},...,j_{N}} \! \times \! (\sigma_{j_{1}} \!
\otimes ... \otimes \sigma_{j_{N}}) \! \Bigg) \! \Bigg],$$ where $\sigma_{i}$ are the Pauli matrices for $i \in \{1,2,3\}$ and $\sigma_0$ is the $2\times 2$ identity matrix. This parametrisation allows the use of the training rule of Eq. \[eq:learningrule\], but replacing the weight $w^{(l)}_{jk}$ with a general parameter $\alpha_{j_{1},...,j_{N}}$ of the unitary $U_{N}$: $$\label{eq:learningruleq}
\mathrm{\delta} \alpha_{j_{1},...,j_{N}}=-\eta\frac{\partial C}{\partial \alpha_{j_{1},...,j_{N}}}.$$

A simpler and less general form of $U_{N}$ has been sufficient for the tasks discussed in this paper: $$\label{eq:u_nrestr}
U_{3} = \sum_{j=1}^4\ket{\tau_j}{\bra{\tau_j}\otimes T_j},$$ where $\{\ket{\tau_j}\}_{j=1}^4= \{ V\ket{00},V\ket{01}, V\ket{10}, V\ket{11}\}$. $V$ is a general 2-qubit unitary of the form of Eq. \[eq:u\_n\]. Each $T_j$ is similarly a general 1-qubit unitary and one can see, using the methods of [@Rowell04] on Eq. \[eq:u\_n\], that this can be expressed as a linear combination of the Pauli matrices, $\sigma_{j}$: $$U_{1-qubit}=e^{i \alpha_{0}} \Bigg( \cos
\Omega ~\mathbb{1} + i
\frac{\sin{\Omega}}{\Omega} \sum_{j=1}^{3} \alpha_{j} \sigma_{j} \Bigg),$$ where $\Omega = \sqrt{\alpha_{1}^2+\alpha_{2}^2+\alpha_{3}^2}$ [@Rowell04]. To extend this to higher dimensional unitaries, see e.g. [@Hedemann13].

The cost function we use for the quantum neural networks is, with experimental feasibility in mind, determined by the expectation values of local Pauli matrices $ (\sigma_{1}, \sigma_{2}, \sigma_{3})$ on individual output qubits, $j$. It has the form $$C=\sum_{i,j} f_{ij} (\langle \sigma_i^{(j)} \rangle_{\mathrm{actual}} -\langle \sigma_i^{(j)} \rangle_{\mathrm{desired}})^2$$ where $f_{ij}$ is a real non-negative number (in the examples to follow $f_{ij}\in \{0,1\}$). We note in the classical mode of operation, where the total density matrix state is diagonal in the computational basis, only $\sigma_3$ will have non-zero expectation, and the cost function becomes the same as in the classical case (Eq. \[eq:cost\]) up to a simple transformation.

It is important to note that the number of weights grow polynomially in the number of neurons. Each weight shift is determined by evaluating the cost function twice to get the RHS of Eq. \[eq:learningruleq\]. Thus the number of evaluations of the cost function for a given iteration of the gradient descent grows polynomially in the number of neurons. The training procedure is efficient in this sense. We do not here attempt to provide a proof that the convergence to zero cost-function, where possible, will always take a number of iterations that grows polynomially in the number of neurons. Note also that the statements about the efficiency of the training procedure refer to the physical implementation with quantum technology: the simulation of quantum systems with a classical computer is, with the best known methods, in general inefficient.

Example: Autoencoder for data compression {#example-autoencoder-for-data-compression .unnumbered}
-----------------------------------------

We now demonstrate applications of our quantum generalisation of neural networks described in the previous section. We begin with autoencoders. These compress an input signal from a given set of possible inputs onto a smaller number of bits, and are ‘work-horses’ of classical machine learning [@Azoff94].

### Classical autoencoder {#classical-autoencoder .unnumbered}

Autoencoders are commonly achieved by a feedforward neural network with a bottleneck in the form of a layer with fewer neurons than the input layer. The network is trained to recreate the signal at a later layer, which necessitates reversibly compressing it (as well as possible) to a bit size equal to the number of neurons in the bottleneck layer [@Azoff94]. The bottleneck layer size can be varied as part of the training to find the smallest compression size possible, which depends on the data set in question. After the training is complete, the post-bottleneck part of the network can be discarded and the compressed output taken directly from after the bottleneck.

In FIG. \[fig:cl\_autoencoder\] a basic autoencoder designed to compress two bits into a single bit is shown. (Here the number of input bits, $j_{max}=2$.) The basic training procedure consists of creating a cost function: $$C = \sum_{j = 1}^{j_{max}} (in_{j}-out_{j})^{2},$$ with which the network is trained using the learning rule of Eq. \[eq:learningrule\]. If the outputs are identical to the inputs (to within numerical precision), the network is fully trained. The final layer is then removed, revealing the second last layer, which should enclose the compressed data. The number of neurons in a given hidden layer for a classical neuron will not exceed $j_{max}$. Once the network is trained, the removal of the post-bottleneck layer(s) will yield a second last layer of fewer neurons, achieving dimensional reduction [@Azoff94].

### Quantum autoencoder {#quantum-autoencoder .unnumbered}

We now generalise the classical autoencoder as shown in FIG. \[fig:cl\_autoencoder\] to the quantum case. We generalise the neurons labelled 1, 2 and 3 in FIG. \[fig:cl\_autoencoder\] into unitary matrices $U_{1}$, $U_{2}$ and $U_{3}$, respectively, with the addition of a ‘fan-out’ gate, $U_{F}$, as motivated in the previous sections. The result is shown in FIG. \[fig:quantum\_autoencoder\] as a quantum circuit model. (We follow the classical convention that this neural network is drawn with the input neurons as well, but they are identity operators which let the inputs through regardless, and can be ignored in the simulation of the network.) The input state of interest $\ket{in_{12}}$ is on 2 qubits, each fed into a different neuron, generalising the classical autoencoder in FIG. \[fig:cl\_autoencoder\]. From each of these neurons, one output qubit each is led into the bottleneck neuron $U_1$, followed by a fan-out of its output. We add as an extra desideratum that the compressed bit, the output of $U_1$, is diagonal in the computational basis. The final neurons have the task of recreating $\ket{in_{12}}$ on the outputs labelled 6 and 8 respectively. The result is shown in FIG. \[fig:quantum\_autoencoder\].

![\[fig:quantum\_autoencoder\]Neural network implementing a quantum autoencoder that can accomodate two input qubits that are entangled. The blue box represents the quantum compression device after training.](curly_212_autoencoder_u_f.png){height="3.2cm"}

This means that a natural and simple cost function is $$C=\sum_{j=0, k=0}^3 (\mathrm{Tr}(\rho_{6,8}\sigma_{j}\otimes \sigma_{k}) - \mathrm{Tr}(\rho_{in_{1,2}}\sigma_{j}\otimes \sigma_{k}))^{2}.$$ Training is then conducted via global gradient descent of the cost w.r.t. the $\alpha_{j_{1},...,j_{N}}$ parameters, as defined in Eq. \[eq:learningruleq\]. During the training the network was fed states from the given input set, picked independently and identically for each step (i.i.d). Standard speed-up techniques for learning were used, e.g. a momentum term [@Azoff94; @Nielsen15]. In training with a variety of 2 possible orthogonal input states including superposition states, the cost function of the quantum autoencoder converged towards zero through global gradient descent in every case, starting with uniformly randomised weights, $\alpha_{j_{1},...,j_{N}} \in [-1,1]$. For 2 non-orthogonal inputs and a 1-qubit bottleneck the cost-function will not converge to zero as is to be expected, but the training rather results in an approximately compressing unitary. FIG. \[fig:quantum\_autoencoder\] shows the network learning to compress in the case of two possible inputs: $(\ket{00} +\ket{11})/\sqrt{2}$ and $(\ket{00} -
\ket{11})/\sqrt{2}$. One can force the compressed output to be diagonal in a particular basis by adding an extra term to the cost-function (e.g. desiring the expectation value of Pauli X and Y to be zero in the case of a single qubit will push the network to give an output diagonal in the Z-basis).

Example: Neural network discovers teleportation protocol {#example-neural-network-discovers-teleportation-protocol .unnumbered}
--------------------------------------------------------

![\[fig:teleport\_circuit\]A circuit diagram of a quantum neural network that can learn and carry out teleportation of the state $\ket{\psi}$ from Alice to Bob using quantum entanglement. The standard teleportation protocol allows only classical communication of 2 bits [@NielsenChuang00]; this is enforced by only allowing two connections, which are dephased in the Z-basis ($D$). $U_{1}, U_{2}$ and $U_{3}$ are unitaries,. The blue line is the boundary between Alice and Bob.](teleportation_fixed.png){height="3.6cm"}

With quantum neural networks already shown to be able to perform generalisations of classical tasks, we now consider the possibility of quantum networks discovering solutions to existing and potentially undiscovered quantum protocols. We propose a quantum neural network structure that can, on its own, work out the standard protocol for quantum teleportation [@NielsenChuang00].

The design and training of this network is analogous to the autoencoder and the quantum circuit diagram is shown in FIG. \[fig:teleport\_circuit\]. The cost function used was: $$C=\sum_{j=0}^3(\mathrm{Tr}(\ket{\psi}\bra{\psi}\sigma_{j}) - \mathrm{Tr}(\rho_6 \sigma_{j}))^{2}.$$ A fully trained network can teleport the state $\ket{\psi}$ (from Alice) to the output port of qubit 6 (to Bob). Once trained properly, $\rho_{out_{1}}$ will no longer be $\ket{\psi}\bra{\psi}$, as the teleportation has ‘messed up’ Alice’s state [@Wilde13].

In order to train the teleportation for any arbitrary state $\ket{\psi}$ (and to avoid the network simply learning to *copy* $\ket{\psi}$ from Alice to Bob), the training inputs are randomly picked from the axis intersection states on the surface of the Bloch sphere [@NielsenChuang00]. FIG. \[fig:teleportation\_cost\] shows the convergence of the cost function during training, simulated on a classical computer. As can be seen, the training was found to be successful, i.e. the cost function converged towards zero. This held for all tests with randomly initialised weights.

![\[fig:teleportation\_cost\]A plot of the teleportation cost function w.r.t. the number of steps used in the training procedure. The cost function can be seen to converge to zero. The non-monotonic decrease is to be expected as we are varying the input states. The network now teleports any qubit state: picking 1000 states at random from the Haar measure (uniform distribution over the Bloch sphere) gives a cost function distribution with mean $5.0371\times 10^{-4}$ and standard deviation $1.7802\times 10^{-4}$, which is effectively zero.](teleportation_cost.png){height="5cm"}

Discussion {#discussion .unnumbered}
==========

Quantum vs. classical {#quantum-vs.-classical .unnumbered}
---------------------

Can these neural networks show some form of quantum supremacy? The comparison of classical and quantum neural networks is well-defined within our set-up, as the classical networks correspond to a particular parameter regime for the quantum networks. A key type of quantum supremacy is that the quantum network can take and process quantum inputs: it can for example process $\ket{+}$ and $\ket{-}$ differently. Thus, there are numerous quantum tasks it can do that the classical network cannot, including the two examples above. We anticipate that they will moreover, in some cases be able to process classical inputs faster, by turning them into superpositions—investigating this is a natural follow-on from this work.

We also mention that we term our above design a [*quantum*]{} neural network with [*classical learning parameters*]{}, as the parameters in the unitaries are classical. It seems plausible that allowing these parameters to be in superpositions, whilst experimentally more challenging, could give further advantages.

Whilst adding the ancillary qubits ensures that the network is a strict generalisation of the classical network, it can of course be experimentally and numerically simpler to omit these. Then one would sacrifice performance in the classical mode of operation, and the network may not be as good as a classical network with the same number of neurons for all tasks.

Visualising the cost function landscape {#visualising-the-cost-function-landscape .unnumbered}
---------------------------------------

To gain intuitive understanding, one can visualise the gradient descent in 3D by reducing the number of free parameters. We sampled the cost surface and gradient descent path of a one-input neuron ($4 \times4$ unitary matrix). With the second qubit expressed as the dummy-then-output qubit, the task for the neuron was $\ket{+
}\otimes\ket{0}\rightarrow
\ket{+}\otimes\ket{0}$ and $\ket{-}\otimes\ket{0} \rightarrow
\ket{-}\otimes\ket{1}$. We optimised, similarly to Eq. \[eq:u\_nrestr\], over unitaries of the form $$U=\ket{\tau}\bra{\tau}\otimes \mathbb{1} + \ket{\tau^{\perp}}\bra{\tau^{\perp}}\otimes\sigma_{1},$$ where $\ket{\tau} = \cos(\theta/2)\ket{0} +
e^{i\phi}\sin(\theta/2)\ket{1}$ and $\ket{\tau^{\perp}} = \sin(\theta/2)\ket{0} -
e^{i\phi}\cos(\theta/2)\ket{1}$. We performed gradient descent along the variables $\theta$ and $\phi$ as shown by the red path in FIG. \[fig:grad\_des\_path\].

![\[fig:grad\_des\_path\]A 3-D plot of the cost function (vertical axis) of a 2-qubit unitary as a function of $\theta$ and $\phi$ (horizontal axes). The red line represents the path taken when carrying out gradient descent from a particular starting point.](grad_des_path.png){height="5.75cm"}

Scaling to bigger networks {#scaling-to-bigger-networks .unnumbered}
--------------------------

The same scheme can be used to make quantum generalisations of networks whose generalised neurons have more inputs/outputs and connections. FIG. \[fig:general\_neuron\] illustrates an $M$-qubit input quantum neuron with a subsequent $N$-qubit fan-out gate.

![\[fig:general\_neuron\] Diagram of the quantum generalisation of a classical neuron with $M$ inputs and $N$ outputs. The superscripts inside the square brackets of the unitaries represent the number of qubits the respective unitaries act on. $U^{[M+1]}$ is the unitary that represents the quantum neuron with an $N$-qubit input and $U^{[N]}$ is the fan-out gate that fans out the output in the final port of $U^{[M+1]}$ in a particular basis.](general_neuron.png){height="6cm"}

If one wishes the number of free parameters of a neuron to grow no more than polynomially in the number of inputs, one needs to restrict the unitary. It is natural to demand it to be a polynomial length circuit of some elementary universal gates, in particular if the input states are known to be generated by a polynomial length circuit of a given set of gates, it is natural to let the unitary be restricted to that set of gates.

The evaluation of the cost function can be kept to a sensible scaling if we restrict it to be a function of local observables on each qubit, in particular a function of the local Pauli expectation values, as was used in this paper, for which case a vector of $3n$ expectation values suffices for $n$ qubits.

Quantum photonics neuron module {#quantum-photonics-neuron-module .unnumbered}
===============================

To investigate the physical viability of these quantum neural networks we consider quantum photonics. This is an attractive platform for quantum information processing: it has room temperature operation, the possibility of robust miniaturisation through photonic integrated circuits; in general it harnesses the highly developed optical fibre-related technology for QIP purposes [@silicon]. Moreover optical implementations have been viewed as optimal for neural networks, in the classical case, due to the low design cost of adding multiple connections (as light passes through light without interacting) [@Rojas]. A final motivation for choosing this platform is that the tuning can be naturally implemented, as detailed below.

We design a neuron as a module that can then be connected to other neurons. This makes it concrete how experimentally complex the network would be to build and operate, including how it could be trained.

The design employs the Cerf-Adami-Kwiat (C-A-K) protocol [@CAK], where a single photon with polarisation and multiple possible spatial modes encodes the quantum state; the scheme falls into the category of hyper-entangling schemes, which entangle different degrees of freedom. One qubit is the polarisation; digital encodings of the spatial mode labels give rise to the others. With four spatial modes this implements 3 qubits, with basis $\ket{0/1}\ket{H/V}\ket{0/1}$, where $H/V$ are two different polarisation states, and the other bits label the four spatial modes. The first bit says whether it is in the top two or bottom two pairs of modes and the last bit whether it is the upper or lower one in one of those pairs. This scheme and related ones such as [@Reck; @Clements] are experimentally viable, theoretically clean and can implement any unitary on a single photon spread out over spatial modes. In such a single photon scenario they do not scale well however. The number of spatial modes grows exponentially in the number of qubits. Thus for larger networks our design below would need to be modified to something less simple, e.g. accepting probabilistic gates in the spirit of the KLM scheme [@klm], or using measurement-based cluster state quantum computation approaches [@silicon].

Before describing the module we make the simplifying restriction that there is one input qubit to the neuron and one dummy input. We will ensure that the designated output qubit can be fed into another neuron, as in FIG. \[fig:onn\] and FIG. \[fig:ocircuit\].

![\[fig:onn\] The first neuron takes one input and one dummy input and its designated output is fed into the next neuron.](neural_net.png){height="2cm"}

![\[fig:ocircuit\] A circuit diagram of our neural module. Following C-A-K there are three qubits, with basis $\ket{0/1}\ket{H/V}\ket{0/1}$, where $H/V$ label different polarisation states, and the other bits label the four spatial modes. We define the input to the module to be carried by the middle (polarisation) qubit. The neuron $U_1$ has the form of Eq. \[eq:u\_nrestr\], modifying the output conditional on the input state. The swaps ensure that the next neuron module $U_2$ also gets the input via the polarisation.](circuit.png){width="\linewidth"}

![image](optics_circuit.png){width="\linewidth"}

We propose to update the neural network by adjusting both variable polarisation rotators, and spatial phase shifters in a set of Mach-Zehnder interferometers as shown in FIG. \[fig:optics\_circuit\]. In this we are able to change the outputs from each layer of the network. The spatial shift could be induced by varying the strain or temperature on the waveguides at given locations, to change their refractive indices and hence the relative phase; this may have additional difficulties in that silicon waveguides are birefringent  [@strain]. Alternatively we can tune both polarisation and spatial qubits via the electro-optic effect.

This circuit can be made more robust and minitaturised using silicon or silica optical waveguides [@silicon]. They have been extensively used to control spatial modes and recently also polarisation [@polarisationstates]. Several labs can implement the phase shifting via heaters or the electro-optic effect. Conventionally phase shifters built upon the electro-optic effect are known to work in the megahertz region and have extremely low loss [@silicon]. For many applications this would be considered slow, but our tuning only requires (in the region of) a few thousand steps of tuning, meaning learning tasks for neural networks this small could be completed in milliseconds. While it appears that this effect will be the limiting factor in terms of speed, photodetectors are able to reach reset times in the tens of nanoseconds, while the production of single photons through parametric down conversion have megahertz repetion rates [@polarisationshift].

Summary and Outlook {#summary-and-outlook .unnumbered}
===================

We have given a protocol for generalising classical feedforward step-function neural networks to networks that take and process quantum inputs. We have shown that these networks can perform the natural quantum generalisation of the classical network in the case of an autoencoder, being able for example to compress entangled inputs. We have shown that they can be used to work out a quantum information processing protocol: teleportation, without being told how to do it, only the task. Based on these results we think that these networks will be highly versatile tools for quantum information scientists, similar to the classical networks’ role in classical information processing.

Acknowledgments {#acknowledgments .unnumbered}
===============

We acknowledge discussions with Stefanie Baerz, Abbas Edalat, William Clements, Alex Jones, Mio Murao, Maria Schuld, Vlatko Vedral, Alejandro Valido and discussions and detailed comments from Doug Plato, Mihai Vidrighin, Peter Wittek. We are grateful for funding from the the EU Collaborative Project TherMiQ (Grant Agreement 618074), the London Institute for Mathematical Sciences, a Leverhulme Trust Research Grant (No. RPG-2014-055), a programme grant from the UK EPSRC (EP/K034480/1).
