Deep reinforcement learning for robust quantum optimization

TL;DR

This paper demonstrates how deep reinforcement learning combined with quantum optimization techniques can design protocols for quantum Szilard engines, achieving efficiency comparable to adiabatic processes even in asymmetric, non-adiabatic conditions.

Contribution

It introduces a novel application of deep reinforcement learning to optimize quantum Szilard engines, enabling robust, noise-resistant protocols for quantum thermodynamic systems.

Findings

Reinforcement learning achieves equal wave function splitting in asymmetric engines.

Optimized protocols maintain efficiency without information loss.

Reinforcement learning outperforms traditional methods in robustness.

Abstract

Machine learning techniques based on artificial neural networks have been successfully applied to solve many problems in science. One of the most interesting domains of machine learning, reinforcement learning, has natural applicability for optimization problems in physics. In this work we use deep reinforcement learning and Chopped Random Basis optimization, to solve an optimization problem based on the insertion of an off-center barrier in a quantum Szilard engine. We show that using designed protocols for the time dependence of the barrier strength, we can achieve an equal splitting of the wave function (1/2 probability to find the particle on either side of the barrier) even for an asymmetric Szilard engine in such a way that no information is lost when measuring which side the particle is found. This implies that the asymmetric non-adiabatic Szilard engine can operate with the same efficiency as the traditional Szilard engine, with adiabatic insertion of a central barrier. We compare the two optimization methods, and demonstrate the advantage of reinforcement learning when it comes to constructing robust and noise-resistant protocols.

Figures

Equations

$$\hat{H}(t)=-\frac{{\hslash }^2}{2m}\frac{{\partial }^2}{\partial x^2}+\alpha (t)\delta (x-d),$$

$$|\Psi (t)⟩=\sum _n{c}_n(t)|{\psi }_n(t)⟩e^{i{\theta }_n(t)},{\theta }_n=-\frac{1}{\hslash }{\int }_0^t{E}_n(t^{\prime })d{t}^{\prime },$$

$$\alpha (t)={\alpha }_0(t)\left[1+\lambda (t)\sum _{n=1}^{N_c}{A}_n\cos ({\omega }_n)+B_n\sin ({\omega }_n)\right].$$

$$C(\left\{A_n,B_n,{\omega }_n\right\})=1-\sum _{n=1}^2{\left(\text{absolutevalue}{c_n(T)}^2-0.5\right)}^2.$$

$$Q(s_t,a_t)$$

$$Q_{\pi }^{\ast }(s_t,a_t)={\text{E}}_{s_{t+1}}\left[r_t+\gamma \underset{a_{t+1}}{\max }{Q}_{\pi }^{\ast }(s_{t+1},a_{t+1})|s_t,a_t\right]$$

$${\pi }^{\ast }(a_t|s_t)=\underset{a^{\prime }}{\mathrm{argmax}}{Q}_{\pi }^{\ast }(s_t,a^{\prime }).$$

$$L(\theta)=E_{s_{t+1}}\left[\big{(}Q_{\pi}^{*}(s_{t},a_{t},\theta)-y_{t}\big{)}^{2}\right].$$

$$y_t=r_t+\gamma \underset{a_{t+1}}{\max }{Q}_{\pi }^{\ast }(s_{t+1},a_{t+1},\theta )$$

$$A=\{{\dot{\alpha }}_n^{\pm }(t)=\pm 2^n,\text{for}n=1,2,\dots ,10\}.$$

$$r(t)=\{\begin{array}{l}0,\text{ if }t<T\text{ and }\alpha \in [0,{\alpha }_{max}]\\ -10,\text{if }t<T\text{ and }\alpha \notin [0,{\alpha }_{max}]\\ 100\exp (-{\sum }_{n=1}^2\frac{{\left(\text{absolutevalue}{c_n(T)}^2-0.5\right)}^2}{\sigma }),\text{if }t=T\end{array}$$

$$\arg \underset{a^{\prime }}{\max }{Q}_{\pi }^{\ast }(s_t,a^{\prime },\theta )\to Q^{\ast }(s_{t+1},\mu (s_{t+1},\varphi ),\theta ).$$

$$y_t=r_t+\gamma Q^{\ast }(s_{t+1},\mu (s_{t+1},\varphi ),\theta ).$$

$${\varphi }_{k+1}={\varphi }_k+\lambda E_{s\in B}\left[{\text{gradient}}_{\varphi }{Q}^{\ast }(s,\mu (s,\varphi ),\theta )\right],$$

$${\text{gradient}}_{\varphi }{Q}^{\ast }(s,\mu (s,\varphi ),\theta )={\text{gradient}}_{\varphi }\mu (s,\varphi ){\text{gradient}}_a{Q}^{\ast }(s,a,\varphi ){|}_{a=\mu (s,\varphi )}.$$

$${\mu }^{\prime }(s_t)=\mu (s_t,\varphi )+N_t.$$

Full text

I Introduction

Machine Learning is becoming an essential tool for data analysis and optimization in a wide variety of scientific fields, from molecular Butler et al. (2018) and medical science Shen et al. (2017) to astronomy Primack et al. (2018). One of the most exiting development in machine learning, comes from combining reinforcement learning Bellman (1957) with deep neural networks Mnih et al. (2015). Reinforcement Learning (RL) differs from supervised and unsupervised learning and is based on letting an agent learn how to behave in a desired way by taking actions in an environment and observing the effect of the action on the environment. In order to define the optimal behavior of the agent, we give it feedback in the form of a reward based on the effect of its previous action. If the action changes the environment into a more desirable state we give it a positive reward, while if it had negative consequences we give it a negative reward. Recently RL has enjoyed increasing popularity in quantum physics, and have been used to explore the quantum speed limit Bukov et al. (2018); Zhang et al. (2018), protect qubit systems from noise Fösel et al. (2018), design new photonic experiments Melnikov et al. (2018), and many other applications Biamonte et al. (2017); Dong et al. (2008); Lamata (2017). For an excellent review of the application of machine learning in physics, see Mehta et al. (2018).

We use deep reinforcement learning (DRL), specifically Deep-Q Learning (DQL) Mnih et al. (2015) and Deep Deterministic Policy Gradient (DDPG) Lillicrap et al. (2015), to solve an optimization problem based on the barrier insertion of an asymmetric (off-center insertion) quantum Szilard engine, which we will motivate it the following paragraphs. The goal is to find barrier insertion protocols that effectively achieves equal splitting of the wave function of a single-particle-box. We compare the results from DRL with those obtained by using chopped random basis optimization Caneva et al. (2011), a more traditional optimization algorithm. Finally, since it can be difficult to experimentally determine the exact asymmetry, we show that DRL can be used to find robust protocols, which performs well for a range of asymmetries. We do this by simultaneously training on many instances of the single-particle-box (SPB), where each instance has a different asymmetry. This is essentially the same as training in an environment with a noisy Hamiltonian, as in Fösel et al. (2018); Zhang et al. (2018).

The Szilard engine is a classic example of a information processing system, which can convert one bit of Shannon information (obtained by a binary measurement) into an amount $k_{B}T\ln 2$ of useful work Szilard (1929). This is done by inserting a barrier in the center of a SPB, performing a measurement to determine which side of the barrier the particle is found (giving one bit of Shannon information), and then letting the compartment the particle occupies isothermally expand into the empty one resulting in a work-extraction of $k_{B}T\ln 2$. This work is not free however, since the information obtained has to be stored in a memory, which subsequently has to be deleted at an energy cost of $k_{B}T\ln 2$ according to Landauer’s principle Landauer (1961). Both work extraction from a Szilard engine, and Landauer’s principle, have recently been experimentally confirmed Toyabe et al. (2010); Bérut et al. (2012); Koski et al. (2014); Vidrighin et al. (2016).

For the quantum version of the Szilard engine Lloyd (1997), there are some subtle differences in the entropy flow during insertion, expansion, and removal of the barrier Kim et al. (2011). Moreover, the position of the particle is now described by a quantum wave function, which is divided into two parts when inserting the barrier. When adiabatically inserting a barrier in the center of a quantum SPB in its ground state, the wave function is split in half in such a way that each half becomes a new ground state in each compartment, when the barrier strength goes to infinity. The probability to find the particle on either side of the barrier after insertion becomes 1/2. However, as long as there is an asymmetry in the insertion of the barrier, i.e. it is not put exactly in the center, the adiabatic theorem guarantees that the particle will be found in the larger compartment Gea-Banacloche (2002). Since the initial state is the ground state, and the adiabatic theorem implies the time evolved state will stay in its instantaneous eigenstate, the particle always ends up in the global ground state. The global ground state is found in the larger compartment since the energy is proportional to $L_{R(L)}^{-2}$, where $L_{R(L)}$ is the width of the compartment on the right(left) side of the barrier.

If we want to achieve equal probability on both sides of the barrier for asymmetric insertion, we have to insert the barrier non-adiabatically in such a way that we excite higher eigenstates. This will in general decrease the efficiency of the quantum Szilard engine, since the measurement only determines which side the particle is found, not its exact eigenstate. However, there is one special way of obtaining exact splitting of the wave function without losing any information in the measurement, for the asymmetric Szilard engine Sørdal and Bergli (2019): If we insert the barrier in such a way that the total wave function is a superposition of only the first and second eigenstate at the time of measurement, i.e. $\ket{\Psi}=\left(\ket{\psi_{1}}+\ket{\psi_{2}}\right)/\sqrt{2}$, the which-side measurement does not result in any information loss since the second eigenstate becomes the ground state of the smaller compartment. When one now measure which compartment the particle is in, one is certain that it is in the ground state of the respective compartment.

Our goal is to split the wave function of a single-particle-box in the ground state, by inserting a barrier off-center, in such a way that only the second eigenstate is excited, and the probability to find the particle in all higher states are as close to zero as possible. However, finding a protocol for the barrier insertion which will achieve this goal is non-trivial, since it will have to take advantage of complicated interference between the time-dependent eigenstates.

II Single-particle-box

The SPB is defined by the potential $V(x)=0$ for $x\in[-L/2,L/2]$, where $L$ is the total width of the box, and $V(x)=\infty$ elsewhere. The barrier is a $\delta$-function potential inserted at $x=d\geq 0$. An illustration of the SPB is shown in Fig. 1, along with its three first eigenfunctions and eigenenergies before the barrier is inserted. If $\epsilon=0$ the box is split symmetrically, i.e. the width of the left and right compartment is equal. However, for $d>0$, the width of the left compartment becomes $L_{L}=L/2+d$, while the width of the right compartment becomes $L_{R}=L/2-d$. The time-dependent Hamiltonian of the insertion procedure is given by

[TABLE]

where $\alpha(t)$ is the strength of the barrier at time $t$, and $m$ is the mass of the particle. For the rest of this article we set $\hbar=m=1$. The total wave function, $\ket{\Psi(t)}$, can be expressed as a linear combination of the instantaneous eigenfunctions

[TABLE]

where $E_{n}(t)$ are the instantaneous eigenenergies when the barrier strength is $\alpha(t)$, $\ket{\psi_{n}(t)}$ are the instantaneous eigenfunctions, and $c_{n}(t)$ are complex coefficients. The initial state is therefore given by $\absolutevalue{c_{1}(0)}^{2}=1$, and the goal is to construct a protocol $\alpha(t)$, which brings us to a final state where $\absolutevalue{c_{1}(T)}^{2}=\absolutevalue{c_{2}(T)}^{2}=1/2$, where $T$ is the duration of the protocol. More details on how the instantaneous eigenstates are calculated, and how the time evolution of the total wave function is numerically solved, is given in Sørdal and Bergli (2019).

III CRAB optimization

We use chopped random-basis (CRAB) optimization Caneva et al. (2011) to find protocols $\alpha(t)$ that splits the wave function in two equal halves for asymmetric barrier insertion in a quantum box. In CRAB optimization we expand the protocol in a complete basis (the Fourier series in our case), in the following way

[TABLE]

Here $\alpha_{0}(t)$ is an initial guess for the optimal protocol, $\lambda(t)$ is a regularization function used to implement boundary conditions, and $\left\{A_{n},B_{n},\omega_{n}\right\}$ is the set of Fourier coefficients we optimize to maximize the cost function

[TABLE]

We fix the boundary conditions to be $\alpha(0)=0$ and $\alpha(T)=200E_{0}L$ (where $E_{0}=\pi^{2}/2$ is the ground state at $\alpha(0)=0$) , and choose $\lambda(t)=\sin(\pi t/T)$. To minimize Eq. (4) we use a gradient free method, like the Nelder-Mead Nelder and Mead (1965) or Powell’s method Powell (1964). Using the Nelder-Mead method we are able to almost exactly split the wave function in half, and results for $d=0.01$ and $d=0.02$ are shown in Fig. 2. In these examples we obtained $\absolutevalue{c_{1}(T)}^{2}=0.4986$, $\absolutevalue{c_{2}(T)}^{2}=0.4979$, and $\sum_{n>2}\absolutevalue{c_{n}(T)}\simeq 10^{-3}$ for $d=0.01$, while for $d=0.02$ we got $\absolutevalue{c_{1}(T)}^{2}=0.5001$, $\absolutevalue{c_{2}(T)}^{2}=0.4999$, and $\sum_{n>2}\absolutevalue{c_{n}(T)}^{2}\simeq 10^{-5}$. In Fig. 2(a) and Fig. 2(b) we show example protocols for $d=0.01$ and $d=0.02$, respectively, while in Fig. 2(c) and Fig. 2(d) we show the time evolution of the probability to be in a given eigenstate, $\absolutevalue{c_{n}(t)}^{2}$.

The protocols obtained by CRAB are designed to split the wave function in two for a given asymmetry. They work extremely well for the asymmetry they were designed for. However, the protocols generalize poorly to other asymmetries, as shown in Fig. 3. There we plot $\absolutevalue{c_{n}(T)}^{2}$ as a function of the asymmetry $d$, using the protocol designed for $d=0.01$ and $d=0.02$. We see that the performance of a protocol designed for a specific asymmetry dramatically reduces if it is applied to single-particle-boxes of different asymmetries. An interesting feature is seen in Fig. 3(b), where the protocol designed for $d=0.02$ achieves exact splitting for asymmetries other than the one that was used for training. However, even this protocol has bad performance in the regions between these points of exact splitting, so it would not be useful unless one knows the exact asymmetry of the single-particle-box.

IV Deep Q-Learning

We now give a short review of the DQL algorithm introduced in Mnih et al. (2015). In the next section we will show how this general algorithm is adapted to our problem. A schematic of the basic reinforcement learning protocol is shown in Fig. 4. At time $t$ the environment is in a given state $s_{t}$. The agent performs an action $a_{t}$ which induces a state change of the environment from $s_{t}$ to $s_{t+1}$. The agent then receives an observation of the new state of the environment, $s_{t+1}$. After taking an action the agent receives a reward $r_{t}=r(s_{t},a_{t},s_{t+1})$. The reward function $r(s_{t},a_{t},s_{t+1})$ is designed by us, according to what goal we want the agent to achieve.

The behavior of the agent is determined by its policy $\pi(a_{t}|s_{t})$, which is the probability of taking the action $a_{t}$ in given the observation $s_{t}$. If the agent is in state $s_{t}$, the Q-function (quality function) $Q_{\pi}(s_{t},a_{t})$ gives the expected cumulative reward given that the action $a_{t}$ is performed and the policy $\pi$ is followed for all proceeding states.

[TABLE]

Here $\gamma\leq 1$ is a discount parameter, which determines how much the agent values immediate reward compared to future reward. If $\gamma<1$ the agent will value future reward less than immediate reward, which is useful for learning in stochastic environments where the future is more uncertain. The optimal Q-function, $Q_{\pi}^{*}(s_{t},a_{t})$, is the maximum expected cumulative reward obtained by taking the action $a_{t}$ in state $s_{t}$ and then acting optimally thereafter, and it is shown to obey the Bellman optimality equation Bellman (1957)

[TABLE]

If we have $Q^{*}_{\pi}(s,a)$ for all possible state-action pairs, it is clear that we can find the optimal policy, $\pi^{*}$, by choosing $a_{t}=\arg\max_{a^{\prime}}Q_{\pi}^{*}(s_{t},a^{\prime})$, i.e. following the policy

[TABLE]

The key idea introduced in Mnih et al. (2015), is to estimate the optimal Q-function using a neural network $Q_{\pi}^{*}(s,a)\simeq Q_{\pi}^{*}(s,a,\theta)$, where $\theta$ is the weights and biases of the neural network. This neural network is called a Deep-Q network (DQN), and is updated by performing gradient ascent on the mean-squared-error of the current predicted $Q_{\pi}^{*}(s,a,\theta)$, while using the Bellman equation as the target. The loss function for DQN is therefore

[TABLE]

where

[TABLE]

To create the neural network we used tensorflow’s implementation of the Keras API Abadi et al. (2015); Chollet et al. (2015), with Adam Kingma and Ba (2014) as the optimizer. The network consists of three hidden layers, with 24, 48 and 24 neurons, respectively, as well as 2 input neurons and 20 output neurons. When the network is initialized its predictions for the optimal $Q_{\pi}^{*}$-values are of course totally wrong. So if we always chose the actions that maximizes the current predicted $Q_{\pi}^{*}$-values, the agent would not learn anything. We need to let the agent explore the state-action space by randomly performing actions. A typical exploration policy is the $\epsilon$-greedy policy. The agent chooses random actions with probability $\epsilon$, or the ones with the highest $Q_{\pi}^{*}$-value (greedily) with probability $1-\epsilon$. As time goes and the agent explores more of the environment, $\epsilon$ is decreased so that it focuses more on the areas of the state-action space with higher $Q_{\pi}^{*}$-values by taking deterministic actions. Typically we start by taking completely random actions, $\epsilon=1$, and let $\epsilon$ converge to some finite number $\epsilon\sim 0.05$, so that there is always some exploration going on. As seen in Eq. (8) a single update of the network weights requires the following input: the current state $s_{t}$, the action chosen $a_{t}$, the immediate reward $r_{t}$, and the next state $s_{t+1}$. We call this tuple, $e_{t}=(s_{t},a_{t},r_{t},s_{t+1})$, that the network trains on an experience. Instead of training on consecutive experiences we store them all in a memory $M_{N}=\left\{e_{0},e_{1},\dots,e_{N}\right\}$, and then train on randomly drawn batches of samples from the memory. The memory have a finite capacity, and new experiences replace older ones when the memory is full. There are three main advantages of training on the memory: It is data efficient since a single experience can be drawn many times. Only training on consecutive experiences is inefficient, since the network tends to forget previous experiences by overwriting them with new experiences. The time-correlation of consecutive experiences means that the network update due to the current experience determines what the next experience will be, so training can be dominated by experiences from a certain area in the state-action space. Finally we see that in Eq. (8) the current weights of the network determines both the target $Q_{\pi}^{*}$-value and the predicted $Q_{\pi}^{*}$-value from the Bellman equation. Thus every network update changes the target $Q_{\pi}^{*}$-value that we are trying to reach, and makes it hard for the network weights to converge. A simple way to circumvent this problem is to use two neural networks, one for the target $Q_{\pi}^{*}$-value ($\theta^{-}$), and one for the current $Q_{\pi}^{*}$-value ($\theta$). The target network is softly updated during training according to $\theta^{-}\leftarrow\theta^{-}(1-\tau)+\theta\tau$, where $\tau$ is a hyper-parameter that determines how close the two networks are in the network parameter space.

V DQL results

For our system, we defined the state to be a tuple of the strength of the $\delta$-barrier and the time $t$, i.e. $S=\{\alpha(t),t\}$. The available actions is a set of $\dot{\alpha}(t)$, given by

[TABLE]

The initial state is $S=\{\alpha(t)=0,t=0\}$, and the goal is to reach a state where $\absolutevalue{c_{0}}^{2}=\absolutevalue{c_{1}}^{2}=1/2$, at the end of the protocol $t=T$. A sequence of selected actions, from time $t=0$ to $t=T$, defines a protocol $\alpha(t)$. The number of times the agent chooses an action per protocol is given by $N_{t}$, and the time-step is therefore $dt=T/N_{t}$. The environment that the agent acts in is the quantum mechanical SPB, with initial state $\absolutevalue{c_{1}}^{2}=1$ and $\absolutevalue{c_{n>1}}^{2}=0$, and time evolution given by the Schrödinger equation $i\partial_{t}\ket{\psi(t)}=H(t)\ket{\psi(t)}$, which we solve as in Sørdal and Bergli (2019). The sequential process for one episode is then

Initial state is $s_{0}:(\alpha_{0}=0,t=0)$ 2. 2.

Agent chooses action based on $s_{0}$, e.g. $a_{0}=\dot{\alpha}_{3}^{+}$ 3. 3.

The next state is then $s_{1}:(\alpha_{0}+\dot{\alpha}_{3}^{+}dt,t+dt)$ 4. 4.

Repeat 2. $\to$ 3., for $s_{1},s_{2},\dots$ until $t=T$. 5. 5.

Solve the Schrödinger equation for the given protocol (set of all states $\set{s_{n},t_{n}}$) and calculate reward. Repeat from 1. until maximum number of episodes reached.

The reward function we used is defined by

[TABLE]

where $\sigma$ determines how sharp we want the reward distribution to be. If the agent chooses actions such that $\alpha(t)<0$, we give it a punishment of $-10$ and set $\alpha(t)=0$, and for actions that would give $\alpha(t)>\alpha_{max}$ we punish and set $\alpha(t)=\alpha_{max}$. We do this to keep the state space bounded. The space of possible protocols grows exponentially with $dt^{-1}$, so it is impractical to set $dt$ so small that we get approximately continuous $\dot{\alpha}(t)$. The accuracy of our numerical solution of the quantum time evolution decreases if we have discontinuous $\dot{\alpha}(t)$, so to circumvent this problem we use cubic spline to interpolate the final protocol before calculating the reward.

In Fig. 5 we show an example protocol learned by the DQL agent, and the corresponding time evolution of $\absolutevalue{c_{n}(t)}^{2}$, when training on a single asymmetry ($\epsilon=0.02$) for 10 000 episodes. The final distribution was $\absolutevalue{c_{1}(T)}^{2}=0.4996$, $\absolutevalue{c_{2}(T)}^{2}=0.4935$, and with higher excitations $\sum_{n>2}\absolutevalue{c_{n}}^{2}\simeq 10^{-2}$. The results, when training on a single asymmetry, tended to be worse for DQL than for direct CRAB optimization. There are many ways to improve the results obtained by DQL; we can add actions to, or change the action space, train for a longer time or increase the number of actions per episode $N_{t}$. Alternatively, one could implement algorithms similar to DQL that can perform actions in a continuous action space, like deep deterministic policy gradient (DDPG) Lillicrap et al. (2015). However, most of these changes would also increase the necessary training time.

In real experiments one may not know exactly how large the asymmetry of the single-particle-box is. A far more useful protocol would be a robust one, designed to work best for a given range of asymmetries. One of the main benefits of DQL is that it is a model-free algorithm, so this task is easily achieved. One only has to let the agent train on random samples of the set of asymmetries one wants the protocol to be optimized to. Since the agent tries to maximize the expected cumulative reward, this added stochasticity is no hindrance. How much the agent values a given state-action pair is averaged over the random samples from the memory, which is proportionally filled with the number of asymmetries we train on.

As an example, say one could determine the asymmetry with a given accuracy $d=0.05\pm 0.01$. An example protocol that was obtained when training on multiple asymmetries (10 equally spaced samples in the range $d\in\left[0.04,0.06\right]$) is shown in Fig. 6. As seen in Fig. 6(b), this protocol performs better on the full range of asymmetries than the ones designed for a single asymmetry, shown in Fig. 3. The excitation to states higher than the two first eigenstates is largest for small asymmetries. This is due to the fact that when $d\to 0$, the wall is inserted close to the central node of the second eigenstate, and the central anti-node of the third eigenstate, as shown in Fig. 1. Therefore excitations to the second eigenstate becomes less likely, while the opposite is true for excitations to the third eigenstate. Since this is an intrinsic property of the system, it is impossible to find protocols that avoids excitations for $d\to 0$. For $d=0$, the ground state of the left and right compartment constitute a doubly degenerate global ground state, and to achieve an equal splitting of the wave function, one has to insert the barrier adiabatically Sørdal and Bergli (2019).

In Fig. (7) we see the total cumulative reward received per episode in a scatter plot, as well as a running average. We see that in the early episodes, where there agent mostly performs random actions, there are many episodes with negative cumulative reward. This is because there is an equal probability that the agent chooses negative and positive $\dot{\alpha}$, and since the initial state is $\alpha(t=0)=0$ there is a high probability that the agent chooses actions which gives $\alpha(t)<0$, resulting in a punishment of -10 every time. In this early stage the agent explores and learns about its environment. As the probability to take random actions decreases (according to the $\epsilon$-greedy protocol) with each episode, the agent takes more deterministic actions based on its experience, and the reward per episode increases steadily. The stochasticity observed in the rewards for final episodes is due a finite final exploration rate $\epsilon=0.05$. We obtain the final protocol after training by setting $\epsilon=0$, and let the agent act deterministically. The efficiency of the protocol obtained by training on a range of asymmetries can be increased by implementing the same changes as for the one designed for a single asymmetry.

VI Deep Deterministic Policy Gradient

Our set of possible actions for the DQL algorithm is somewhat arbitrarily chosen. For our specific control problem, there are infinitely many protocols that can achieve our goal, so the exact set chosen is not critically important. However, the performance of the algorithm depends on this choice, and the optimal protocols we find can always be defined by some subset of the total action-space. That is, not all actions are used for the optimal protocol, so we could retroactively reduce the action-space after learning which actions was needed. For many control problems in physics, it is more natural to let the action values be drawn from a continuous set, on some interval $A\in[a_{min},a_{max}]$. For DQL, this is not possible, since the optimal policy $\pi^{*}(a_{t}|s_{t})$ comes from taking the maximum argument of a finite dimensional $Q^{*}(s_{t},a_{t})$.

When the action-space is continuous, the optimal Q-function $Q^{*}(s,a)$ is assumed to be differentiable with respect to the action $a$. In Deep Deterministic Policy Gradient Lillicrap et al. (2015), the goal is to find a deterministic policy $\mu(s)$, which gives is the optimal action to take for any state, $a^{*}=\mu(s)$. This deterministic policy is approximated by another neural network $\mu(s)\simeq\mu(s,\phi)$, where $\phi$ are the parameters of the network. The Q-function is, as in DQL, also approximated by a neural network, and the essence of introducing the deterministic policy is to replace the largest Q-value for a state-action pair in the following way:

[TABLE]

The Q-network is updated in the same way as in DQL, by using the Bellman equation, but instead of Eq. (9), the target for the loss function now becomes

[TABLE]

As for the policy network, it was shown in Silver et al. (2014) that its weights can updated in proportion to the gradient of the Q-function

[TABLE]

where $\lambda$ is the learning rate, which determines the step-size of the gradient ascent. Since the gradient will, in general, move the weights in different directions for different states, an average over a batch of experiences is taken. By applying the chain rule to Eq. 13, we can decompose it into a product of the gradient of the policy with respect to its network weight, and the gradient of the Q-function with respect to the actions

[TABLE]

Exploration in DDPG is driven by adding noise to the policy, sampled form some distribution $N_{t}$ suited to the environment, which is annealed over time

[TABLE]

We use a Gaussian white noise process, and annealed its standard deviation from $\sigma_{N}=0.3$ to $\sigma_{N}=10^{-4}$ over the course of the training. DPPG is called an actor-critic model, and the sense is that the policy is an actor, taking actions in an environment, and the Q-function acts as a critic, determining how good the actions where, and feeding the result back to the actor.

For the DPPG algorithm, we used an adapted implementation from Keras-RL Plappert (2016), which includes the same modifications we used for DQL; i.e. experience replay and different networks for the target and current Q-function and policy. The policy network takes as input the same state tuple as for DQL, $S=\set{\alpha(t),t}$, which is connected to three hidden layers, with the same architecture as DQL; 24, 48, and 24 neurons, respectively, and outputs a single value, the action $\dot{\alpha}(t)$. The Q-function network takes as input the action value suggested by the policy, as well as the state $S=\set{\alpha(t),t}$, again connected to three hidden layers with the same architecture as DQL, and outputs a value which is its estimation of the optimal Q-value of the state-action pair. The output actions form the policy network are clipped at $|\dot{\alpha}(t)|\leq 1000~{}E_{0}L/s$, and we use the same reward function as for DQL.

In Fig. 8(a) we show a protocol obtained from DDPG, when training on 10 asymmetries in the range $d\in[0.04,0.06]$, and in Fig. 8(b) the performance of the protocol on a range of asymmetries from $d\in[0,0.1]$. As expected, the best results are obtained for the range of asymmetries we trained on, indicated by a red bar. A rigorous comparison between DQL and DPPG is difficult, partly due to the large amount of hyper-parameter tweaking needed to optimize each algorithm, but largely due to the arbitrary choice of discrete action values for DQL: for our example problem, there is no natural set of available actions to choose. As mentioned earlier, the performance of DQL for our problem, depends on the set of actions chosen, and therefore a fair comparison of the algorithms is complicated. The choice between discrete and continuous-action algorithms, has to be taken based on the specific problem one wants to solve. For our SPB problem, there are infinitely many ”good” solutions, and since we interpolate the protocol at the end of each episode, both DQL and DPPG are well suited.

We used a 3.40 GHz CPU, and the training time for the most resource-intensive computation (the protocol in Fig. (6)) was about 48 hours, so increased training time is something that more advanced computation systems can handle. The most computationally-intensive part of the training, by a large margin, was solving the Schrödinger equation after each episode. As for the hyper-parameters of the neural networks, we used a learning rate $\lambda=10^{-3}$, target network update every $\tau=10^{-3}$ time-step, and a replay memory size between $10\%-50\%$ of the total number of experiences. The $\varepsilon$-greedy exploration policy was a linear decrease from $\varepsilon=1$ to $\varepsilon=0.05$.

VII Discussion and Summary

We have used CRAB optimization and deep reinforcement learning to construct protocols, $\alpha(t)$, for the time-dependent strength of a barrier inserted asymmetrically in a single-particle-box, in such a way that the wave function is split in two equal halves. These results implies that the asymmetric quantum Szilard engine can reach the same efficiency in information-to-work conversion as the symmetric one, since no information is lost in the which-side measurement.

Using CRAB optimization, the protocols we obtain performs very well for the specific asymmetry we optimize for, but the protocol generalize poorly for different asymmetries. Although more time consuming and than CRAB optimization, we can also use DRL to find high performing protocols when training on single asymmetries. However, one of the biggest strengths of reinforcement learning based techniques is the possibility to perform robust and noise-resistant optimization. When training on a range of different asymmetries simultaneously, DRL can be used to find the protocols that performs best on the average of all the asymmetries sampled. Both DQL and DDPG were able to find good protocols for our example SPB problem, but in general, the choice between discrete and continuous-action algorithms has to be made on the basis of what specific problem one wants to solve. The advantage of using reinforcement learning for quantum control, is multifaceted: having model-free algorithms makes it simple to change the optimization criterion to make the agent solve different problems within the same environment, one only have to change the reward function to suit the new goal. Furthermore, since the agent is not tailored to any specific environment, it can easily be adopted to work in entirely different systems (e.g. we can use the agents constructed here to perform state-transfer in qubit systems Bukov et al. (2018)). Finally, the stochastic nature of the agents learning procedure is advantageous when one wants to perform robust optimization which can perform well with noise. These points all suggests that reinforcement learning can become a very useful tool in physics.

Acknowledgements

We thank Y. M. Galperin for reading the manuscript and making valuable comments.