Programming multi-level quantum gates in disordered computing reservoirs via machine learning and TensorFlow

TL;DR

This paper demonstrates how TensorFlow can be used to design multi-level quantum gates in disordered optical media, leveraging machine learning to control complex quantum systems.

Contribution

It introduces a novel approach to programming multi-level quantum gates in disordered reservoirs using TensorFlow and machine learning techniques.

Findings

TensorFlow effectively trains quantum gates in disordered media.

The method scales with reservoir size, showing promising results.

Versatile for different optical media and modulation levels.

Abstract

Novel machine learning computational tools open new perspectives for quantum information systems. Here we adopt the open-source programming library TensorFlow to design multi-level quantum gates including a computing reservoir represented by a random unitary matrix. In optics, the reservoir is a disordered medium or a multi-modal fiber. We show that trainable operators at the input and the readout enable one to realize multi-level gates. We study various qudit gates, including the scaling properties of the algorithms with the size of the reservoir. Despite an initial low slop learning stage, TensorFlow turns out to be an extremely versatile resource for designing gates with complex media, including different models that use spatial light modulators with quantized modulation levels.

Equations

$$T_M=S_M^{\text{out}}\cdot U_M\cdot S_M^{\text{in}}.$$

$$P\cdot U_M\cdot S_M=[X_N\text{vline}0]$$

$$T_M=\left[\begin{array}{ccc}{X}_N& \text{vline}& 0\\ & & \\ 0& \text{vline}& O_C\end{array}\right]$$

$$\underset{W_M}{\min }E[G(W_M)]=\underset{W_M}{\min }\sum _{i,j}{e}_{ij}[G(W_M)]\text{.}$$

$$G_P=P\cdot U_M\cdot W_M-X_{N0},$$

$$G_U=U_M\cdot W_M-T_M.$$

$$\frac{d{W}_M}{dt}=-\mu U_M^{†}\cdot F[G(W_M)]$$

$$X_3=\sum _{l=0}^{d-1}|l\oplus 1⟩⟨l|=\left[\begin{array}{ccc}0& 1& 0\\ 0& 0& 1\\ 1& 0& 0\end{array}\right]$$

$$e_i=\frac{1}{N}\sum _N|{\mathbf{y}}_i-U_M\cdot W_M\cdot {\mathbf{x}}_i{|}^2$$

Full text

I Introduction

The development of multi-level quantum information processing systems has steadily grown over the past few years, with experimental realizations of multi-level, or qudit logic gates for several widely used photonic degrees of freedom, such as orbital-angular-momentum and path encoding Huisman et al. (2015); Babazadeh et al. (2017); Malik et al. (2016); Taballione et al. (2019). However, efforts are still needed for increasing the complexity of such systems while still being practical, with the ultimate goal of realizing complex large-scale computing devices that operate in a technologically efficient manner.

A key challenge is the development of design techniques that are scalable and versatile. Recent work outlined the relevance of a large class of devices, commonly denoted as “complex” or “multi-mode” Matthès et al. (2018); Zhao et al. (2018). In these systems, many modes or channels are mixed and controlled at input and readout to realize a target input-output operation. This follows the first experimental demonstrations of assisted light transmission through random media Vellekoop and Mosk (2007); Vellekoop (2015); Horstmeyer et al. (2015); Pierangeli et al. (2018), which demonstrated many applications including arbitrary linear gates Matthès et al. (2018), mode conversion, and sorting Fu et al. (2018); Fontaine et al. (2018).

The use of complex mode-mixing devices is surprisingly connected to leading paradigms in modern machine learning (ML), as the “reservoir computing” (RC) Verstraeten et al. (2007), and the “extreme learning machine” (ELM) Huang et al. (2006); Verstraeten et al. (2007). In standard ML, one trains the parameters (weights) of an artificial neural network (ANN) to fit a given function, which links input and output. In RC, due to the increasing computational effort to train a large number of weights, one internal part of the network is left untrained (“the reservoir”) and the weights are optimized only at input and readout.

ML concepts, such as photonic neuromorphic and reservoir computing Duport et al. (2012); Van et al. (2017), are finding many applications in telecommunications Borhani et al. (2018); Lohani et al. (2018), multiple scattering Sun et al. (2018), image classification Lin et al. (2018), metasurfaces Favraud et al. (2018); Mohammadi Estakhri et al. (2019), biophotonics Pierangeli et al. (2018), Ising machines Pierangeli et al. (2019), integrated and fiber optics Wu et al. (2014); Englund et al. (2017), and topological photonics Pilozzi et al. (2018). Various authors have reported the use of ML for augmenting and assisting quantum experiments Krenn et al. (2016); Fösel et al. (2018); Lumino et al. (2018); Kudyshev et al. (2019); Leedumrongwatthanakun et al. (2019). The field of machine learning is in turn influenced by quantum physics, for example in the orthogonal units Jing et al. (2017); Dangovski et al. (2017).

Here we adopt RC-ML to design complex multi-level gates Babazadeh et al. (2017); Malik et al. (2016); Muthukrishnan and Stroud (2000); Di and Wei (2011), which form a building block for high-dimensional quantum information processing systems. While low-dimensional examples of such gates have been implemented using bulk and integrated optics, efficiently scaling them up to high dimensions remains a challenge.

In quantum key distribution (QKD), one uses at least two orthogonal bases to encode information. High-dimensional QKD offers an increased information capacity as well as an increased robustness to noise over qubit-based protocols Mirhosseini et al. (2015); Ecker et al. (2019). Such protocols may be realized by using the photonic spatial degrees of freedom as the encoding (computational) basis, and suitable unitary operators to switch between bases mutually unbiased with respect to the computational basis. However, the security of the QKD protocol may be compromised by the fidelity of such basis transformations, leading to errors in the key rate. An additional consideration is the experimental complexity of such transformations, which can scale rather poorly using established techniques based on bulk optical systems. By using a random medium and I/O readout operators, one can realize such high-dimensional operations in a controllable and scalable manner, relying only on the existing complexity of the disordered medium and a control operation at the input. Here, we explore methodologies to train a disordered medium to function as a multi-level logic gate by using different implementations of ML concepts.

Figure 1 shows the schematic of a device including the complex medium, represented by the unitary operator $\hat{U}$, and two trainable input $\hat{S}^{\text{in}}$ and readout $\hat{S}^{\text{out}}$ operators. $|h^{(1,2)}\rangle$ are hidden states. The use of an optical gate in this manner is related to the use of a disordered medium as a physically unclonable function (PUF) Goorden et al. (2014); Tentrup et al. (2018); Leonetti et al. (2016).

In our general framework, we have a random system modeled by a unitary random matrix. We want to use the random medium to perform a computation in a Hilbert space containing many qudits. The random medium is not necessarily a disordered system (for example, a dielectric assembly of scattering particles), but may also be a multimode fiber, or an array of waveguides. The input/output relation is represented by a linear unitary matrix operator $U_{M}$ and only forward modes are considered. The $U_{M}$ matrix has dimensions $M\times M$, with $M$ the dimension of the embedding space.

The “reduced” state vector at input has dimensions $N\times 1$, with $N\leq M$. This models the case in which we use a subset of all the available modes. The input to the reservoir is a “rigged” state vector ${\bf x}$ with dimension $M$, where the missing complementing $C$ components are replaced by $C=M-N$ ancillas. Our goal is to use the random medium to perform a given operation denoted by a gate unitary matrix

[TABLE]

$S_{M}^{\text{in}}$ and $S_{M}^{\text{out}}$ are two “training” operators that are applied at input and output (see Fig. 1) and whose elements can be adjusted. We first consider the presence of the input operator $S_{M}^{\text{in}}=S_{M}$, and $S_{M}^{\text{out}}={\bf 1}_{M}$, which can be implemented by spatial-light modulators (we denote as ${\bf 1}_{M}$ the identity matrix with dimension $M$).

We identify two cases: either (i) we know the matrix $U_{M}$, or (ii) we have to infer $U_{M}$ from the input/output relation. We show in the following the way these two problems can be solved by ANNs, where we denote the two families as non-inferencing and inferencing gates.

II Non-inferencing gates

We consider a target gate with complex-valued input state with dimension $N$, and components $x_{1},x_{2},...,x_{N}$. We embed the input vector in a rigged Hilbert space with dimension $M\geq N$, so that the overall input vector is ${\bf x}=\{x_{1},x_{2},...,x_{N},x_{N+1},...,x_{M}\}$. We have a linear propagation through a medium with unitary complex transfer matrix $U_{M}$. The overall transmission matrix is $T_{M}=U_{M}\cdot S_{M}$, such that the output vector is ${\bf y}=T_{M}\cdot{\bf x}=U_{M}\cdot\,S_{M}\cdot{\bf x}$. The observed output vector is written as $P\cdot{\bf y}$, where $P$ is a $N-$projector operator with dimensions $N\times M$ such that $P=[\bm{1}_{N}|{\bf 0}]$, with $\bm{1}_{N}$ the identity matrix with size $N\times N$, and ${\bf 0}$ a null matrix with dimension $N\times C$. The goal is finding the matrix $S_{M}$ such that

[TABLE]

where $X_{N}$ is the $N\times N$ target gate and ${\bf 0}$ is the null complement $N\times C$ at dimension $M$. Eq. (2) is a matrix equation, which guarantees that the overall system behaves as a $X_{N}$ gate on the reduced input.

Solving the matrix Eq. (2) may be demanding and nontrivial when the number of dimensions grows. In the following, we discuss the use of ML techniques.

The transmission matrix $T_{M}$ in the rigged space from ${\bf x}$ to ${\bf y}$ can be written as blocks

[TABLE]

where $O_{C}$ is a unitary matrix with dimensions $C\times C$ to be determined. If $U_{M}$ and $S_{M}$ are unitary, the resulting transmission matrix $T_{M}$ is also unitary. However, if one uses Eq. (2), the problem may also have a nonunitary solution (“projected case”) as some channels are dropped at the output. In other words, solving Eq. (3) is not equivalent to solving Eq. (2), and we adopt two different methodologies: one can look for unitary or nonunitary solutions by ANN.

By following previous work developed for real-valued matrices Wang (1993), we map the complex-valued matrix equation (2) into a recurrent neural network (RNN). In the “non-inferencing” case, the matrix $U_{M}$ is known, and the solution is found by the RNN in Fig. 2. The RNN solves an unconstrained optimization problem, by finding the minimum of the sum of the elements $e_{ij}>0$ of an error matrix $E$. The error depends on a “state matrix” $W_{M}$, and one trains the elements $w_{ij}$ of $W_{M}$ to find the minimum

[TABLE]

In the adopted approach, the sum of the elements $e_{ij}$ is minimal when the hidden layer elements $g_{ij}$ of the matrix $G(W)$ are zero. $E$ and $G$ have to be suitably chosen to solve the considered problem. We found two possible $G$ matrices: (i) the “projected”

[TABLE]

with $X_{N0}=[X_{N}\,\vline\,{\bf 0}]$ as in Eq. (2) and, (ii) the “unitary” [see Eq. (3)]

[TABLE]

These two cases are discussed below.

To find the unknown training matrix $S_{M}$, one starts from an initial guess matrix $W_{M}(0)$. The guess is then recurrently updated, as in Fig. 2, until a stationary state $W_{M}(\infty)$ is reached. Once this optimization converges, the solution is given by $S_{M}=W_{M}(\infty)$. The update equation is determined by a proper choice of the error matrix $E$ as follows.

As the matrices are complex valued, $e_{ij}$ is a function of $g_{ij}$ and $g_{ij}^{*}$. We set $e_{ij}=e_{ij}(|g_{ij}|^{2})$. The corresponding dynamic RNN equation, which for large time gives the solution to the optimization problem, is

[TABLE]

where $\mu$ is the “learning rate”, an optimization coefficient (hyperparameter), which is set to speed-up the convergence. The elements $f_{ij}$ of the matrix $F$ are $f_{ij}=\frac{de_{ij}}{dg_{ij}^{*}}$. Letting $e_{ij}=|g_{ij}|^{2}$, one has $f_{ij}=g_{ij}$.

Eq. (7) implies that the RNN is composed of two bidirectionally connected layers of neurons, the output layer with state matrix $W$, and the hidden layer with state matrix $G$. The training corresponds to sequential updates of $F$ and $W$ when solving the ordinary equations [(7)]. As shown in Wang (1993), this RNN is asymptotically stable and its steady state matrix represents the solution (an example of training dynamics is in Fig. 2b).

We code the RNN by TensorFlowTM and use the ordinary differential equations (ODEs) integrator odeint. In the case $N=M$, as $X_{N}=X_{M}$ is a unitary operator, the solution of the recurrent network furnishes a unitary $S_{M}$ matrix, which solves the problem. For $M>N$ the RNN furnishes a unitary solution $S_{M}$, and a unitary transfer function $T_{M}$, only if we embed the target gate $X_{N}$ in a unitary operator as in $\eqref{eq:2}$ with $O_{C}$ a randomly generated unitary matrix.

II.1 Single non-inferencing qutrit gate X

For the training of a gate $X_{3}$ defined by Babazadeh et al. (2017); Gao et al. (2019)

[TABLE]

The gate $X_{3}$ is obtained by an embedding dimension $M=5$ and unitary transfer function $U_{5}$ as in Fig. 2.

For $G=G_{P}$, the number of ODEs for the training of the network is minimal ($N=3$). However, the solution is not unitary, as some channels are dropped out by the $N-$projector. The overall $M\times M$ transmission matrix $T_{M}$, after the training, is such that $T_{M}^{\dagger}\cdot T_{M}\neq I$ because the solution $S_{M}$ is not unitary. However, the system always reaches a stationary case.

A unitary solution is found by letting $G=G_{U}$ and involving the maximum number of ODEs in (7) with a unitary embedding of $X_{N}$ as in $\eqref{eq:2}$, i.e., adopting a further - randomly generated - unitary matrix $O_{C}$. The key point is that the system finds a solution for any random unitary rigging of the matrix $X_{N}$, that is, for any randomly assigned matrix $O_{C}$. This implies that we can train all these systems to realize different multi-level gates.

III Inferencing gates

In the case that we do not know the transfer matrix of the system, we can still train the overall transmission matrix by using a neural network and infer $U_{M}$. Here we use an ANN to determine the training operators without measuring the transfer matrix. Figure 3 shows the scheme of the ANN, where the unitary matrix $U_{M}$ is represented by its elements $u_{ij}$, and the $w_{ij}$ are the adjustable weights. After training, the resulting ${w}_{ij}$ are the elements of the solution matrix $S_{M}$. For the sake of simplicity, we consider $S^{\text{out}}={\bf 1}_{M}$, as above. For a target $X_{N}$ we build the $T_{M}$ as in (3) by randomly generating the unitary complement $O_{C}$. As $T_{M}$ and $U_{M}$ are unitary, the resulting $S_{M}$ is also unitary. One can use a non unitary $T_{M}$ by choosing, for example, $O_{C}={\bf 0}$. Correspondingly - after the training - $S_{M}$ is not unitary.

We randomly generate a set of input states ${\bf x}_{i}$, with $i=1,...,n_{train}$. Each input state is “labelled” with the target output ${\bf y}_{i}=T_{M}\cdot{\bf x}_{i}$. We remark that ${\bf x}_{i}$ and ${\bf y}_{i}$ are vector with size $M$. A further set of $n_{valid}$ validation rigged vectors is used to validate the training.

For any input ${\bf x}_{i}$ in the training set, we adjust the weights to minimize the error function

[TABLE]

with ${\bf y}_{i}=T_{M}\cdot{\bf x}_{i}$. After this training, we test the accuracy on the validation set. Each cycle of training and validation is denoted as “epoch”.

Figure 3 shows the ANN for $N=3$, and $M=5$. In our model, we build a matrix $W_{M}$ of unknown weights. As we deal with complex quantities, $W_{M}$ is written as $W_{M}=W_{M}^{\prime}+\imath W_{M}^{\prime\prime}$ with $W_{M}^{\prime}$ and $W_{M}^{\prime\prime}$ real-valued matrices, whose elements form the weights of the ANN. Using random matrices as initial states, we end the iteration when the validation cost is below a threshold $\varepsilon_{valid}$.

III.1 Single-qutrit inference X-gate

Figure 3 shows the training of a single qutrit gate $X_{3}$ in (8).

Similar results are obtained with other single qudit gates as $X^{2}$ and $Z$ and for higher dimensions. Training typically needs tens of iterations and scales well with the number of dimensions. Figure 3 shows an example with $N=3$ and $M=5$. Figure 3c shows that the number of training epochs $n_{epochs}$ scales linearly with the embedding space dimension $M$.

IV Spatial light modulator implementation

In the general case, one needs a unitary gate to train the complex medium, and a modulator to test different inputs signals. In practical and simplified implementations, the training gate and the input modulator can be made with a single device. It is possible to realize the ML design with a single spatial light modulator (SLM), as sketched in the inset of Fig. 4a. Ref. Huisman et al. (2015) already gave a recipe for implementing a unitary in a lossy way with a single SLM and a complex medium. However, here we follow the more recent but also lossy technique introduced in Ref. Matthès et al. (2018). We consider an input plane wave represented by a constant vector ${\bf e}_{N}={1,1,...,1}$ with dimension $N$, where $N$ is the number of pixels in the amplitude and phase SLM.

Assuming that we want to design a gate with input ${\bf x}$ and output ${\bf y}$, we generate the input ${\bf x}$ by an operator $\mathrm{Diag}({\bf x})$, which has the first $N$ elements of ${\bf x}$ on the diagonal.

Assuming that the ML algorithm has produced an operator $S_{M}$, the actual operator to be implemented on the SLM is $\tilde{S}_{M}=S_{M}\cdot\mathrm{Diag}({\bf x})$. Note that $\tilde{S}_{M}$ encodes the input and hence changes for different inputs Matthès et al. (2018).

In other words, with a single SLM, after optimization for a given output ${\bf y}$, the training realizes $\tilde{S}_{M}$ for a fixed plane wave input ${\bf e}_{M}={1,1,...,1,0,...0}$ with $N$ ones and $M-N$ zeros.

IV.1 Phase-only modulators

A pure phase modulator is implemented by the elements writing the model matrix for $\tilde{S}_{M}$ as $\cos(\phi_{ij})+\imath\sin(\phi_{ij})$, with $\phi_{ij}$ the phase of the $i,j$ segment of the SLM. In Fig. 4a, we show the performance of the training process, focusing on a single qutrit $X-$gate ($N=3$), and varying the size of the reservoir $M$. If the reservoir is about one order of magnitude larger than the dimension of the gate, the algorithm converges in less than $1000$ epochs, and the error decreases with $M$.

IV.2 Sign modulators and quantized amplitude

A pure amplitude modulator is modeled by a real matrix $\tilde{S}_{M}$. A combination of an amplitude modulator, such as a digital micromirror device (DMD), along with spatial filtering, enables one to realize positive and negative values for $\tilde{S}_{M}$ Matthès et al. (2018). The elements of the real $\tilde{S}_{M}$ are trained to provide the target output with the fixed plane wave at the input. Using typical functions in application program interfaces, such as tensorflow.clip_by_value, one can clip the values of the amplitude modulation (we use the range $[-1.0,1.0]$). In contrast with the phase-modulator case, the performance in the amplitude modulation case is reduced. Our numerical experiments show that convergence (corresponding to a cost-function smaller than $10^{-4}$) is not reached. On the contrary, the error reaches a stable minimal value after about $1000$ epochs. The minimal error decreases with the size of the reservoir (Fig. 4b). In Fig. 4b, we also account for the fact that modulator devices have limited resolution, and accessible modulation levels are quantized with a given number of bits. We can implement the level quantization in TensorFlow by using tensorflow.quantize_and_dequantize, after each iteration. In Fig. 4, we show results for phase-only modulation for the $1$-bit case, corresponding to modulation levels ${-1,0,1}$, as well as for the $8$ and $64$-bit cases.

V Conclusions

We have investigated the use of machine learning paradigms for designing linear multi-level quantum gates by using a complex transmitting multi-modal system. The developed algorithms are versatile and scalable when the unitary operator for the random system is either known or unknown. We show that generalized single-qudit gates can be designed. The overall methodology is easily implemented by the TensorFlow application program interface and can be directly adapted to experimentally retrieved data. The method can be generalized to more complex information protocols, and embedded in real-world multi-modal systems.

Acknowledgments – We acknowledge support from the Sapienza Ateneo, PRIN2015 NEMO project (2015KEZNYM), the H2020 QuantERA project QUOMPLEX (grant number 731473), and the PRIN 2017 PELM project (20177PSCKT), the H2020 grant number 820392.