THINKING WHILE MOVING: DEEP REINFORCEMENT LEARNING WITH CONCURRENT CONTROL
Year: 2020

Abstract:
We study reinforcement learning in settings where sampling an action from the policy must be done concurrently with the time evolution of the controlled system, such as when a robot must decide on the next action while still performing the previous action. Much like a person or an animal, the robot must think and move at the same time, deciding on its next action before the previous one has completed. In order to develop an algorithmic framework for such concurrent control problems, we start with a continuous-time formulation of the Bellman equations, and then discretize them in a way that is aware of system delays. We instantiate this new class of approximate dynamic programming methods via a simple architectural extension to existing value-based deep reinforcement learning algorithms. We evaluate our methods on simulated benchmark tasks and a large-scale robotic grasping task where the robot must “think while moving”. Videos are available at https://sites.google.com/view/thinkingwhilemoving.

heading: 1 INTRODUCTION
text: In recent years, Deep Reinforcement Learning (DRL) methods have achieved tremendous success on a variety of diverse environments, including video games (Mnih et al., 2015), zero-sum games (Silver et al., 2016), robotic grasping (Kalashnikov et al., 2018), and in-hand manipulation tasks (OpenAI et al., 2018). While impressive, all of these examples use a blocking observe-think-act paradigm: the agent assumes that the environment will remain static while it thinks, so that its actions will be executed on the same states from which they were computed. This assumption breaks in the concurrent real world, where the environment state evolves substantially as the agent processes observations and plans its next actions. As an example, consider a dynamic task such as catching a ball: it is not possible to pause the ball mid-air while waiting for the agent to decide on the next control to command. In addition to solving dynamic tasks where blocking models would fail, thinking and acting concurrently can provide benefits such as smoother, human-like motions and the ability to seamlessly plan for next actions while executing the current one.
Despite these potential benefits, most DRL approaches are mainly evaluated in blocking simulation environments. Blocking environments make the assumption that the environment state will not change between when the environment state is observed and when the action is executed. This assumption holds true in most simulated environments, which encompass popular domains such as Atari (Mnih et al., 2013) and Gym control benchmarks (Brockman et al., 2016). The system is treated in a sequential manner: the agent observes a state, freezes time while computing an action, and finally applies the action and unfreezes time. However, in dynamic real-time environments such as real-world robotics, the synchronous environment assumption is no longer valid. After observing the state of the environment and computing an action, the agent often finds that when it executes an action, the environment state has evolved from what it had initially observed; we consider this environment a concurrent environment.
In this paper, we introduce an algorithmic framework that can handle concurrent environments in the context of DRL. In particular, we derive a modified Bellman operator for concurrent MDPs and
∗Indicates equal contribution.
present the minimal set of information that we must augment state observations with in order to recover blocking performance with Q-learning. We introduce experiments on different simulated environments that incorporate concurrent actions, ranging from common simple control domains to vision-based robotic grasping tasks. Finally, we show an agent that acts concurrently in a real-world robotic grasping task is able to achieve comparable task success to a blocking baseline while acting 49% faster.

heading: 2 RELATED WORK
text: Minimizing Concurrent Effects Although real-world robotics systems are inherently concurrent, it is sometimes possible to engineer them into approximately blocking systems. For example, using low-latency hardware (Abbeel et al., 2006) and low-footprint controllers (Cruz et al., 2017) minimizes the time spent during state capture and policy inference. Another option is to design actions to be executed to completion via closed-loop feedback controllers and the system velocity is decelerated to zero before a state is recorded (Kalashnikov et al., 2018). In contrast to these works, we tackle the concurrent action execution directly in the learning algorithm. Our approach can be applied to tasks where it is not possible to wait for the system to come to rest between deciding new actions.
Algorithmic Approaches Other works utilize algorithmic modifications to directly overcome the challenges of concurrent control. Previous work in this area can be grouped into five approaches: (1) learning policies that are robust to variable latencies (Tan et al., 2018), (2) including past history such as frame-stacking (Haarnoja et al., 2018), (3) learning dynamics models to predict the future state at which the action will be executed (Firoiu et al., 2018; Amiranashvili et al., 2018), (4) using a time-delayed MDP framework (Walsh et al., 2007; Firoiu et al., 2018; Schuitema et al., 2010), and (5) temporally-aware architectures such as Spiking Neural Networks (Vasilaki et al., 2009; Frémaux et al., 2013), point processes (Upadhyay et al., 2018; Li et al., 2018), and adaptive skip intervals (Neitz et al., 2018). In contrast to these works, our approach is able to (1) optimize for a specific latency regime as opposed to being robust to all of them, (2) consider the properties of the source of latency as opposed to forcing the network to learn them from high-dimensional inputs, (3) avoid learning explicit forward dynamics models in high-dimensional spaces, which can be costly and challenging, (4) consider environments where actions are interrupted as opposed to discrete-time time-delayed environments where multiple actions are queued and each action is executed until completion. The approaches in (5) show promise in enabling asynchronous agents, but are still active areas of research that have not yet been extended to high-dimensional, image-based robotic tasks.
Continuous-time Reinforcement Learning While previously mentioned related works largely operate in discrete-time environments, framing concurrent environments as continuous-time systems is a natural framework to apply. In the realm of continuous-time optimal control, path integral solutions (Kappen, 2005; Theodorou et al., 2010) are linked to different noise levels in system dynamics, which could potentially include latency that results in concurrent properties. Finite differences can approximate the Bellman update in continuous-time stochastic control problems (Munos & Bourgine, 1998) and continuous-time temporal difference learning methods (Doya, 2000) can utilize neural networks as function approximators (Coulom, 2002). The effect of time-discretization (converting continuous-time environments to discrete-time environments) is studied in Tallec et al. (2019), where the advantage update is scaled by the time discretization parameter. While these approaches are promising, it is untested how these methods may apply to image-based DRL problems. Nonetheless, we build on top of many of the theoretical formulations in these works, which motivate our applications of deep reinforcement learning methods to more complex, vision-based robotics tasks.

heading: 3 VALUE-BASED REINFORCEMENT LEARNING IN CONCURRENT ENVIRONMENTS
text: In this section, we first introduce the concept of concurrent environments, and then describe the preliminaries necessary for discrete- and continuous-time RL formulations. We then describe the
MDP modifications sufficient to represent concurrent actions and finally, present value-based RL algorithms that can cope with concurrent environments.
The main idea behind our method is simple and can be implemented using small modifications to standard value-based algorithms. It centers around adding additional information to the learning algorithm (in our case, adding extra information about the previous action to a Q-function) that allows it to cope with concurrent actions. Hereby, we provide theoretical justification on why these modifications are necessary and we specify the details of the algorithm in Alg. 1.
While concurrent environments affect DRL methods beyond model-free value-based RL, we focus our scope on model-free value-based methods due to their attractive sample-efficiency and off-policy properties for real-world vision-based robotic tasks.

heading: 3.1 CONCURRENT ACTION ENVIRONMENTS
text: In blocking environments (Figure 4a in the Appendix), actions are executed in a sequential blocking fashion that assumes the environment state does not change between when state is observed and when actions are executed. This can be understood as state capture and policy inference being viewed as instantaneous from the perspective of the agent. In contrast, concurrent environments (Figure 4b in the Appendix) do not assume a fixed environment during state capture and policy inference, but instead allow the environment to evolve during these time segments.

heading: 3.2 DISCRETE-TIME REINFORCEMENT LEARNING PRELIMINARIES
text: We use standard reinforcement learning formulations in both discrete-time and continuous-time settings (Sutton & Barto, 1998). In the discrete-time case, at each time step i, the agent receives state si from a set of possible states S and selects an action ai from some set of possible actions A according to its policy π, where π is a mapping from S toA. The environment returns the next state si+1 sampled from a transition distribution p(si+1|si, ai) and a reward r(si, ai). The return for a given trajectory of states and actions is the total discounted return from time step i with discount factor γ ∈ (0, 1]: Ri = ∑∞ k=0 γ
kr(si+k, ai+k). The goal of the agent is to maximize the expected return from each state si. The Q-function for a given stationary policy π gives the expected return when selecting action a at state s: Qπ(s, a) = E[Ri|si = s, ai = a]. Similarly, the value function gives expected return from state s: V π(s) = E[Ri|si = s]. The default blocking environment formulation is detailed in Figure 1a.

heading: 3.3 VALUE FUNCTIONS AND POLICIES IN CONTINUOUS TIME
text: For the continuous-time case, we start by formalizing a continuous-time MDP with the differential equation: ds(t) = F (s(t), a(t))dt+G(s(t), a(t))dβ (1) where S = Rd is a set of states, A is a set of actions, F : S × A → S and G : S × A → S describe the stochastic dynamics of the environment, and β is a Wiener process (Ross et al., 1996). In the continuous-time setting, ds(t) is analogous to the discrete-time p, defined in Section 3.2. Continuous-time functions s(t) and ai(t) specify the state and i-th action taken by the agent. The agent interacts with the environment through a state-dependent, deterministic policy function π and the return R of a trajectory τ = (s(t), a(t)) is given by (Doya, 2000):
R(τ) = ∫ ∞ t=0 γtr(s(t), a(t))dt, (2)
which leads to a continuous-time value function (Tallec et al., 2019): V π(s(t)) = Eτ∼π[R(τ)|s(t)]
= Eτ∼π [∫ ∞
t=0
γtr(s(t), a(t))dt ] ,
(3)
and similarly, a continuous Q-function:
Qπ(s(t), a, t,H) = Ep [∫ t′=t+H t′=t γt ′−tr(s(t′), a(t′))dt′ + γHV π(s(t+H)) ] , (4)
where H is the constant sampling period between state captures (i.e. the duration of an action trajectory) and a refers to the continuous action function that is applied between t and t +H . The expectations are computed with respect to stochastic process p defined in Eq. 1.

heading: 3.4 CONCURRENT ACTION MARKOV DECISION PROCESSES
text: We consider Markov Decision Processes (MDPs) with concurrent actions, where actions are not executed to full completion. More specifically, concurrent action environments capture system state while the previous action is still executed. After state capture, the policy selects an action that is executed in the environment regardless of whether the previous action has completed, as shown in Figure 4 in the Appendix. In the continuous-time MDP case, concurrent actions can be considered as horizontally translating the action along the time dimension (Walsh et al., 2007), and the effect of concurrent actions is illustrated in Figure 1b. Although we derive Bellman Equations for handling delays in both continuous and discrete-time RL, our experiments extend existing DRL implementations that are based on discrete time.

heading: 3.5 VALUE-BASED CONCURRENT REINFORCEMENT LEARNING ALGORITHMS IN CONTINUOUS AND DISCRETE-TIME
text: We start our derivation from this continuous-time reinforcement learning standpoint, as it allows us to easily characterize the concurrent nature of the system. We then demonstrate that the conclusions drawn for the continuous case also apply to the more commonly-used discrete setting that we then use in all of our experiments.
Continuous Formulation In order to further analyze the concurrent setting, we introduce the following notation. As shown in Figure 1b, an agent selects N action trajectories during an episode, a1, ..., aN , where each ai(t) is a continuous function generating controls as a function of time t. Let tAS be the time duration of state capture, policy inference and any additional communication latencies. At time t, an agent begins computing the i-th trajectory ai(t) from state s(t), while concurrently executing the previous selected trajectory ai−1(t) over the time interval (t − H + tAS , t+ tAS). At time t+ tAS , where t ≤ t+ tAS ≤ t+H , the agent switches to executing actions from ai(t). The continuous-time Q-function for the concurrent case from Eq. 4 can be expressed as following:
Qπ(s(t), ai−1, ai, t,H) = Ep [∫ t′=t+tAS t′=t γt ′−tr(s(t′), ai−1(t ′))dt′ ] ︸ ︷︷ ︸
Executing action trajectory ai−1(t) until t+ tAS
+ Ep [∫ t′=t+H t′=t+tAS γt ′−tr(s(t′), ai(t ′))dt′ ] ︸ ︷︷ ︸
Executing action trajectory ai(t) until t+H
+Ep [ γHV π(s(t+H)) ]︸ ︷︷ ︸ Value function at t+H (5)
The first two terms correspond to expected discounted returns for executing the action trajectory ai−1(t) from time (t, t + tAS) and the trajectory ai(t) from time (t + tAS , t + tAS + H). We can obtain a single-sample Monte Carlo estimator Q̂ by sampling random functions values p, which simply correspond to policy rollouts:
Q̂π(s(t), ai−1, ai, t,H) = ∫ t′=t+tAS t′=t γt ′−tr(s(t′), ai−1(t ′))dt′+
γtAS [∫ t′=t+H t′=t+tAS γt ′−t−tASr(s(t′), ai(t ′))dt′ + γH−tASV π(s(t+H)) ] (6)
Next, for the continuous-time case, let us define a new concurrent Bellman backup operator: T ∗c Q̂(s(t), ai−1, ai, t, tAS) = ∫ t′=t+tAS t′=t γt ′−tr(s(t′), ai−1(t ′))dt′+
γtAS max ai+1 EpQ̂π(s(t+ tAS), ai, ai+1, t+ tAS , H − tAS). (7)
In addition to expanding the Bellman operator to take into account concurrent actions, we demonstrate that this modified operator maintain its contraction properties that are crucial for Q-learning convergence. Lemma 3.1. The concurrent continuous-time Bellman operator is a contraction.
Proof. See Appendix A.2.
Discrete Formulation In order to simplify the notation for the discrete-time case where the distinction between the action function ai(t) and the value of that function at time step t, ai(t), is not necessary, we refer to the current state, current action, and previous action as st, at, at−1 respectively, replacing subindex i with t. Following this notation, we define the concurrent Q-function for the discrete-time case:
Qπ(st, at−1, at, t, tAS , H) =
r(st, at−1)+γ tAS H Ep(st+tAS |st,at−1)Q π(st+tAS , at, at+1, t+ tAS , tAS′ , H − tAS) (8)
Where tAS′ is the “spillover duration” for action at beginning execution at time t + tAS (see Figure 1b). The concurrent Bellman operator, specified by a subscript c, is as follows:
T ∗c Q(st, at−1, at, t, tAS , H) =
r(st, at−1) + γ tAS H max
at+1 Ep(st+tAS |st,at−1)Q π(st+tAS , at, at+1, t+ tAS , tAS′ , H − tAS).
(9)
Similarly to the continuous-time case, we demonstrate that this Bellman operator is a contraction.
Lemma 3.2. The concurrent discrete-time Bellman operator is a contraction.
Proof. See Appendix A.2.
We refer the reader to Appendix A.1 for more detailed derivations of the Q-functions and Bellman operators. Crucially, Equation 9 implies that we can extend a conventional discrete-time Q-learning framework to handle MDPs with concurrent actions by providing the Q function with values of tAS and at−1, in addition to the standard inputs st, at, t.
3.6 DEEP Q-LEARNING WITH CONCURRENT KNOWLEDGE
While we have shown that knowledge of the concurrent system properties (tAS and at−1, as defined previously for the discrete-time case) is theoretically sufficient, it is often hard to accurately predict tAS during inference on a complex robotics system. In order to allow practical implementation of our algorithm on a wide range of RL agents, we consider three additional features encapsulating concurrent knowledge used to condition the Q-function: (1) Previous action (at−1), (2) Action selection time (tAS), and (3) Vector-to-go (V TG), which we define as the remaining action to be executed at the instant the state is measured. We limit our analysis to environments where at−1, tAS , and V TG are all obtainable and H is held constant. See Appendix A.3 for details.

heading: 4 EXPERIMENTS
text: In our experimental evaluation we aim to study the following questions: (1) Is concurrent knowledge defined in Section 3.6, both necessary and sufficient for a Q-function to recover the performance of a blocking unconditioned Q-function, when acting in a concurrent environment? (2) Which representations of concurrent knowledge are most useful for a Q-function to act in a concurrent environment? (3) Can concurrent models improve smoothness and execution speed of a real-robot policy in a realistic, vision-based manipulation task?

heading: 4.1 TOY FIRST-ORDER CONTROL PROBLEMS
text: First, we illustrate the effects of a concurrent control paradigm on value-based DRL methods through an ablation study on concurrent versions of the standard Cartpole and Pendulum environments. We use 3D MuJoCo based implementations in DeepMind Control Suite (Tassa et al., 2018) for both tasks. For the baseline learning algorithm implementations, we use the TF-Agents (Guadarrama et al., 2018) implementations of a Deep Q-Network agent, which utilizes a Feed-forward Neural Network (FNN), and a DeepQ-Recurrent Neutral Network agent, which utilizes a Long Short-Term Memory (LSTM) network. To approximate different difficulty levels of latency in concurrent environments, we utilize different parameter combinations for action execution steps and action selection steps (tAS). The number of action execution steps is selected from {0ms, 5ms, 25ms, or 50ms} once at environment initialization. tAS is selected from {0ms, 5ms, 10ms, 25ms, or 50ms} either once at environment initialization or repeatedly at every episode reset. In addition to environment parameters, we allow trials to vary across model parameters: number of previous actions to store, number of previous states to store, whether to use VTG, whether to use tAS , Q-network architecture, and number of discretized actions. Further details are described in Appendix A.4.1.
To estimate the relative importance of different concurrent knowledge representations, we conduct an analysis of the sensitivity of each type of concurrent knowledge representations to combinations of the other hyperparameter values, shown in Figure 2a. While all combinations of concurrent knowledge representations increase learning performance over baselines that do not leverage this information, the clearest difference stems from including VTG. In Figure 2b we conduct a similar analysis but on a Pendulum environment where tAS is fixed every environment; thus, we do not focus on tAS for this analysis but instead compare the importance of VTG with frame-stacking previous actions and observations. While frame-stacking helps nominally, the majority of the performance increase results from utilizing information from VTG.

heading: 4.2 CONCURRENT QT-OPT ON LARGE-SCALE ROBOTIC GRASPING
text: Next, we evaluate scalability of our approach to a practical robotic grasping task. We simulate a 7 DoF arm with an over-the-shoulder camera, where a bin in front of the robot is filled with procedurally generated objects to be picked up by the robot. A binary reward is assigned if an object is lifted off a bin at the end of an episode. We train a policy with QT-Opt (Kalashnikov et al., 2018), a deep Q-Learning method that utilizes the cross-entropy method (CEM) to support continuous actions. In the blocking mode, a displacement action is executed until completion: the robot uses a closed-loop controller to fully execute an action, decelerating and coming to rest before observing the next state. In the concurrent mode, an action is triggered and executed without waiting, which means that the next state is observed while the robot remains in motion. Further details of the algorithm and experimental setup are shown in Figure 3 and explained in Appendix A.4.2.
Table 1 summarizes the performance for blocking and concurrent modes comparing unconditioned models against the concurrent knowledge models described in Section 3.6. Our results indicate that the VTG model acting in concurrent mode is able to recover baseline task performance of the blocking execution unconditioned baseline, while the unconditioned baseline acting in concurrent model suffers some performance loss. In addition to the success rate of the grasping policy, we also evaluate the speed and smoothness of the learned policy behavior. Concurrent knowledge models are able to learn faster trajectories: episode duration, which measures the total amount of wall-time used for an episode, is reduced by 31.3% when comparing concurrent knowledge models with blocking unconditioned models, even those that utilize a shaped timestep penalty that reward faster policies. When switching from blocking execution mode to concurrent execution mode, we see a significantly lower action completion, measured as the ratio from executed gripper displacement to commanded displacement, which expectedly indicates a switch to a concurrent environment. The concurrent knowledge models have higher action completions than the unconditioned model in the concurrent environment, which suggests that the concurrent knowledge models are able to utilize more efficient motions, resulting in smoother trajectories. The qualitative benefits of faster, smoother trajectories are drastically apparent when viewing video playback of learned policies1.
Real robot results In addition, we evaluate qualitative policy behaviors of concurrent models compared to blocking models on a real-world robot grasping task, which is shown in Figure 3b. As seen in Table 2, the models achieve comparable grasp success, but the concurrent model is 49% faster than the blocking model in terms of policy duration, which measures the total execution time of the policy (this excludes the infrastructure setup and teardown times accounted for in episode duration, which can not be optimized with concurrent actions). In addition, the concurrent VTG model is able to execute smoother and faster trajectories than the blocking unconditioned baseline, which is clear in video playback1.

heading: 5 DISCUSSION AND FUTURE WORK
text: We presented a theoretical framework to analyze concurrent systems where an agent must “think while moving”.Viewing this formulation through the lens of continuous-time value-based reinforce-
1https://sites.google.com/view/thinkingwhilemoving
ment learning, we showed that by considering concurrent knowledge about the time delay tAS and the previous action, the concurrent continuous-time and discrete-time Bellman operators remained contractions and thus maintained Q-learning convergence guarantees. While more information than tAS and previous action may be helpful, we showed that tAS and previous action (and different representations of this information) are the sole theoretical requirements for good learning performance. In addition, we introduced Vector-to-go (VTG), which incorporates the remaining previous action to be executed, as an alternative representation for information about the concurrent system that previous action and tAS contain.
Our theoretical findings were supported by experimental results on Q-learning models acting in simulated control tasks that were engineered to support concurrent action execution. We conducted large-scale ablation studies on toy task concurrent 3D Cartpole and Pendulum environments, across model parameters as well as concurrent environment parameters. Our results indicated that VTG is the least hyperparameter-sensitive representation, and was able to recover blocking learning performance in concurrent settings. We extended these results to a complex concurrent large-scale sienvironmentmulated robotic grasping task, where we showed that the concurrent models were able to recover blocking execution baseline model success while acting 31.3% faster. We analyzed the qualitative benefits of concurrent models through a real-world robotic grasping task, where we showed that a concurrent model with comparable grasp success as a blocking baseline was able to learn smoother trajectories that were 49% faster.
An interesting topic to explore in future work is the possibility of increased data efficiency when training on off-policy data from various latency regimes. Another natural extension of this work is to evaluate DRL methods beyond value-based algorithms, such as on-policy learning and policy gradient approaches. Finally, concurrent methods may allow robotic control in dynamic environments where it is not possible for the robot to stop the environment before computing the action. In these scenarios, robots must truly think and act at the same time.

heading: A APPENDIX

heading: A.1 DEFINING BLOCKING BELLMAN OPERATORS
text: As introduced in Section 3.5, we define a continuous-time Q-function estimator with concurrent actions.
Q̂(s(t), ai−1, ai, t,H) = ∫ t′=t+tAS t′=t γt ′−tr(s(t′), ai−1(t
′))dt′+ (10)∫ t′′=t+H t′′=t+tAS γt ′′−tr(s(t′′), ai(t ′′))dt′′ + γHV (s(t+H)) (11)
= ∫ t′=t+tAS t′=t γt ′−tr(s(t′), ai−1(t ′))dt′+ (12)
γtAS ∫ t′′=t+H t′′=t+tAS γt ′′−t−tASr(s(t′′), ai(t ′′))dt′′ + γHV (s(t+H)) (13)
= ∫ t′=t+tAS t′=t γt ′−tr(s(t′), ai−1(t ′))dt′+ (14)
γtAS [ ∫ t′′=t+H t′′=t+tAS γt ′′−t−tASr(s(t′′), ai(t ′′))dt′′ + γH−tASV (s(t+H))]
(15)
We observe that the second part of this equation (after γtAS ) is itself a Q-function at time t + tAS . Since the future state, action, and reward values at t + tAS are not known at time t, we take the following expectation:
Q(s(t), ai−1, ai, t,H) = ∫ t′=t+tAS t′=t γt ′−tr(s(t′), ai−1(t ′))dt′+ (16)
γtASEsQ̂(s(t), ai, ai+1, t+ tAS , H − tAS) (17) which indicates that the Q-function in this setting is not just the expected sum of discounted future rewards, but it corresponds to an expected future Q-function.
In order to show the discrete-time version of the problem, we parameterize the discrete-time concurrent Q-function as:
Q̂(st, at−1, at, t, tAS , H) = r(st, at−1) + γ tAS H Ep(st+tAS |st,at−1)r(st+tAS , at)+ (18)
γ H H Ep(st+H |st+tAS ,at)V (st+H) (19)
which with tAS = 0, corresponds to a synchronous environment.
Using this parameterization, we can rewrite the discrete-timeQ-function with concurrent actions as:
Q̂(st, at−1, at, t, tAS , H) = r(st, at−1) + γ tAS H [Ep(st+tAS |st,at−1)r(st+tAS , at)+ (20)
γ H−tAS
H Ep(st+H |st+tAS ,at)V (st+H)] (21)
= r(st, at−1) + γ tAS H Ep(st+tAS |st,at−1)Q̂(st, at, at+1, t+ tAS , tas′ , H − tAS)
(22)

heading: A.2 CONTRACTION PROOFS FOR THE BLOCKING BELLMAN OPERATORS

heading: Proof of the Discrete-time Blocking Bellman Update
text: Lemma A.1. The traditional Bellman operator is a contraction, i.e.: ||T ∗Q∞(s, a)− T ∗Q∈(s, a)|| ≤ c||Q1(s, a)−Q2(s, a)||, (23) where T ∗Q(s, a) = r(s, a) + γmaxa′ EpQ(s′, a′) and 0 ≤ c ≤ 1.
Proof. In the original formulation, we can show that this is the case as following:
T ∗Q1(s, a)− T ∗Q2(s, a) (24) = r(s, a) + γmax
a′ Ep[Q1(s′, a′)]− r(s, a)− γmax a′ Ep[Q2(s′, a′)] (25)
= γmax a′
Ep[Q1(s′, a′)−Q2(s′, a′)] (26)
≤ γ sup s′,a′ [Q1(s ′, a′)−Q2(s′, a′)], (27)
with 0 ≤ γ ≤ 1 and ||f ||∞ = supx[f(x)].
Similarly, we can show that the updated Bellman operators introduced in Section 3.5 are contractions as well.

heading: Proof of Lemma 3.2

heading: Proof.
text: T ∗c Q1(st, ai−1, ai, t, tAS , H)− T ∗c Q2(st, ai−1, ai, t, tAS , H) (28)
= r(st, ai−1) + γ tAS H max
ai+1 Ep(st+tAS |st,at−1)Q1(st, ai, ai+1, t+ tAS , tAS′ , H − tAS) (29)
− r(st, ai−1)− γ tAS H max
ai+1 Ep(st+tAS |st,at−1)Q2(st, ai, ai+1, t+ tAS , tAS′ , H − tAS) (30)
= γ tAS H max
ai+1 Ep(st+tAS |st,ai−1)[Q1(st, ai, ai+1, t+ tAS , tAS′ , H − tAS)−Q2(st, ai, ai+1, t+ tAS , tAS′ , H − tAS)]
(31)
≤ γ tAS H sup
st,ai,ai+1,t+tAS ,tAS′ ,H−tAS [Q1(st, ai, ai+1, t+ tAS , tAS′ , H − tAS)−Q2(st, ai, ai+1, t+ tAS , tAS′ , H − tAS)]
(32)

heading: Proof of Lemma 3.1
text: Proof. To prove that this the continuous-time Bellman operator is a contraction, we can follow the discrete-time proof, from which it follows:
T ∗c Q1(s(t), ai−1, ai, t, tAS)− T ∗c Q2(s(t), ai−1, ai, t, tAS) (33) = γtAS max
ai+1 Ep[Q1(s(t), ai, ai+1, t+ tAS , H − tAS)−Q2(s(t), ai, ai+1, t+ tAS , H − tAS)]
(34)
≤ γtAS sup s(t),ai,ai+1,t+tAS ,H−tAS [Q1(s(t), ai, ai+1, t+ tAS , H − tAS)−Q2(s(t), ai, ai+1, t+ tAS , H − tAS)]
(35)

heading: A.3 CONCURRENT KNOWLEDGE REPRESENTATION
text: We analyze 3 different representations of concurrent knowledge in discrete-time concurrent environments, described in Section 3.6. Previous action at−1 is the action that the agent executed at the previous timestep. Action selection time tAS is a measure of how long action selection takes, which can be represented as either a categorical or continuous variable; in our experiments, which take advantage of a bounded latency regime, we normalize action selection time using these known bounds. Vector-to-go VTG is a feature that combines at−1 and st by encoding the remaining amount of at−1 left to execute. See Figure 5 for a visual comparison.
We note that at−1 is available across the vast majority of environments and it is easy to obtain. Using tAS , which encompasses state capture, communication latency, and policy inference, relies
on having some knowledge of the concurrent properties of the system. Calculating V TG requires having access to some measure of action completion at the exact moment when state is observed. When utilizing a first-order control action space, such as joint angle or desired pose, V TG is easily computable if proprioceptive state is measured and synchronized with state observation. In these cases, VTG is an alternate representation of the same information encapsulated by at−1 and the current state.

heading: A.4 EXPERIMENT IMPLEMENTATION DETAILS

heading: A.4.1 CARTPOLE AND PENDULUM ABLATION STUDIES
text: Here, we describe the implementation details of the toy task Cartpole and Pendulum experiments in Section 4.1.
For the environments, we use the 3D MuJoCo implementations of the Cartpole-Swingup and Pendulum-Swingup tasks in DeepMind Control Suite (Tassa et al., 2018). We use discretized action spaces for first-order control of joint position actuators. For the observation space of both tasks, we use the default state space of ground truth positions and velocities.
For the baseline learning algorithms, we use the TensorFlow Agents (Guadarrama et al., 2018) implementations of a DeepQ-Network agent, which utilizes a Feed-forward Neural Network (FNN), and a DeepQ-Recurrent Neutral Network agent, which utilizes a Long Short-Term Memory (LSTM) network. Learning parameters such as learning rate, lstm size, and fc layer size were selected through hyperparameter sweeps.
To approximate different difficulty levels of latency in concurrent environments, we utilize different parameter combinations for action execution steps and action selection steps (tAS). The number of action execution steps is selected from {0ms, 5ms, 25ms, or 50ms} once at environment initialization. tAS is selected from {0ms, 5ms, 10ms, 25ms, or 50ms} either once at environment initialization or repeatedly at every episode reset. The selected tAS is implemented in the environment as additional physics steps that update the system during simulated action selection.
Frame-stacking parameters affect the observation space by saving previous observations and actions. The number of previous actions to store as well as the number of previous observations to store are independently selected from the range [0, 4]. Concurrent knowledge parameters, as described in Section 4, include whether to use VTG and whether to use tAS . Including the previous action is already a feature implemented in the frame-stacking feature of including previous actions. Finally, the number of actions to discretize the continuous space to is selected from the range [3, 8].

heading: A.4.2 LARGE SCALE ROBOTIC GRASPING
text: Simulated Environment We simulate a 7 DoF arm with an over-the-shoulder camera (see Figure 3a). A bin in front of the robot is filled with procedurally generated objects to be picked up by the robot and a sparse binary reward is assigned if an object is lifted off a bin at the end of an episode. States are represented in form of RGB images and actions are continuous Cartesian displacements of the gripper 3D positions and yaw. In addition, the policy commands discrete gripper open and close actions and may terminate an episode. In blocking mode, a displacement action is executed until completion: the robot uses a closed loop controller to fully execute an action, decelerating and coming to rest before observing the next state. In concurrent mode, an action is triggered and executed without waiting, which means that the next state is observed while the robot remains in motion. It should be noted that in blocking mode, action completion is close to 100% unless the gripper moves are blocked by contact with the environment or objects; this causes average blocking mode action completion to be lower than 100%, as seen in Table 1.
Real Environment Similar to the simulated setup, we use a 7 DoF robotic arm with an overthe-shoulder camera (see Figure 3b). The main difference in the physical setup is that objects are selected from a set of common household objects.
Algorithm We train a policy with QT-Opt (Kalashnikov et al., 2018), a Deep Q-Learning method that utilizes the Cross-Entropy Method (CEM) to support continuous actions. A Convolutional Neural Network (CNN) is trained to learn the Q-function conditioned on an image input along with
a CEM-sampled continuous control action. At policy inference time, the agent sends an image of the environment and batches of CEM-sampled actions to the CNN Q-network. The highest-scoring action is then used as the policy’s selected action. Compared to the formulation in Kalashnikov et al. (2018), we also add a concurrent knowledge feature of VTG and/or previous action at−1 as additional input to the Q-network. Algorithm 1 shows the modified QT-Opt procedure.
Algorithm 1: QT-Opt with Concurrent Knowledge Initialize replay buffer D; Initialize random start state and receive image o0; Initialize concurrent knowledge features c0 = [V TG0 = 0, at−1 = 0, tAS = 0]; Initialize environment state st = [o0, c0]; Initialize action-value function Q(s, a) with random weights θ; Initialize target action-value function Q̂(s, a) with weights θ̂ = θ; while training do
for t = 1, T do Select random action at with probability , else at = CEM(Q, st; θ); Execute action in environment, receive ot+1, ct, rt; Process necessary concurrent knowledge features ct, such as V TGt, at−1, or tAS ; Set st+1 = [ot+1, ct]; Store transition (st, at, st+1, rt) in D; if episode terminates then
Reset st+1 to a random reset initialization state; Reset ct+1 to 0;
end Sample batch of transitions from D; for each transition (si, ai, si+1, ri) in batch do
if terminal transition then yi = ri; else Select âi+1 = CEM(Q̂, si; θ̂); yi = ri + γQ̂(si+1, âi+1); end Perform SGD on (yi −Q(si, ai; θ)2 with respect to θ;
end Update target parameters Q̂ with Q and θ periodically;
end end
For simplicity, the algorithm is described as if run synchronously on a single machine. In practice, episode generation, Bellman updates and Q-fitting are distributed across many machines and done asynchronously; refer to (Kalashnikov et al., 2018) for more details. Standard DRL hyperparameters such as random exploration probability ( ), reward discount (γ), and learning rate are tuned through a hyperparameter sweep. For the time-penalized baselines in Table 1, we manually tune a timestep penalty that returns a fixed negative reward at every timestep. Empirically we find that a timestep penalty of −0.01, relative to a binary sparse reward of 1.0, encourages faster policies. For the non-penalized baselines, we set a timestep penalty of −0.0.

heading: A.5 FIGURES
text: See Figure 6 and Figure 7.

Review summaries:
The paper tackles the problem of making decisions for the next action while still engaged in doing the previous actions. Such a delay could either be part of the design (like a robot deciding the next action before its actors and motors have come to full rest after the current action) or an artefact of the delays inherent in the system (i.e. latency induced by calculations or latency of sensors). The paper shows how to model such delays within the Q-learning framework, show that their modelling preserves desirable contraction property of the Bellman update operator, and put their model into practice by an extensive set of experiments: learning policies for several simulated and a real-world setting.

This paper considers the theoretically interesting and practically important problem of concurrent deep reinforcement learning (DRL), i.e., DRL in which the agent has to decide the next action while performing the previous one. This introduces several significant challenges, including delays/latency and interruption of an on-going action. To address this issue, this paper proposes to consider the continuous time formulation of the concurrent control problem, derive a continuous-time Bellman equation for the concurrent control scenarios, and then derive its discrete-time counterpart. Contraction properties are shown for both the continuous-time and discrete-time concurrent Bellman equations, and a value-based DRL algorithm based on the concurrent Bellman equations is proposed and tested on a few tasks.