Decoupled Data Based Approach for Learning to Control Nonlinear Dynamical Systems

TL;DR

This paper introduces a decoupled data-based control method for nonlinear stochastic systems that combines open-loop trajectory optimization with linearized closed-loop control, reducing computational complexity and training time.

Contribution

The paper presents a novel decoupled control algorithm that separates trajectory optimization from control design, improving efficiency over traditional dynamic programming approaches.

Findings

Significant reduction in training time compared to existing algorithms.

Performance of the D2C algorithm is approximately optimal.

Effective control of nonlinear stochastic systems demonstrated through simulations.

Abstract

This paper addresses the problem of learning the optimal control policy for a nonlinear stochastic dynamical system with continuous state space, continuous action space and unknown dynamics. This class of problems are typically addressed in stochastic adaptive control and reinforcement learning literature using model-based and model-free approaches respectively. Both methods rely on solving a dynamic programming problem, either directly or indirectly, for finding the optimal closed loop control policy. The inherent `curse of dimensionality' associated with dynamic programming method makes these approaches also computationally difficult. This paper proposes a novel decoupled data-based control (D2C) algorithm that addresses this problem using a decoupled, `open loop - closed loop', approach. First, an open-loop deterministic trajectory optimization problem is solved using a black-box simulation model of the dynamical system. Then, a closed loop control is developed around this open loop trajectory by linearization of the dynamics about this nominal trajectory. By virtue of linearization, a linear quadratic regulator based algorithm can be used for this closed loop control. We show that the performance of D2C algorithm is approximately optimal. Moreover, simulation performance suggests significant reduction in training time compared to other state of the art algorithms.

Figures

Tables

Table 1. TABLE I: Simulation parameters and training outcomes

System	Steps per	Time-	Training time (in sec.)
	episode	step	D2C
		(in sec.)	Open-	Closed-	DDPG
			loop	loop
Inverted	30	0.1	12.9		2261.15
Pendulum
Cart pole	30	0.1	15.0	1.33	6306.7
3-link	1600	0.005	7861.0	13.1	38833.64
Swimmer	800	0.01	4001.0	4.6	13280.7*
6-link	1500	0.006	9489.3	26.5	88160
Swimmer	900	0.01	3585.4	16.4	15797.2*

Equations

$$x_{t+1}=h(x_t,u_t,w_t),$$

$${\pi }^o$$

$${\tilde{J}}^{\pi }(x)$$

$$x_{t+1}=f(x_t)+B_t(u_t+ϵw_t),$$

$$c(x,u)=l(x)+\frac{1}{2}{u}^{\prime }Ru.$$

$$\delta x_{t+1}$$

$$\delta u_t$$

$$c(x_t,u_t)$$

$$\frac{1}{2}{\bar{u}}_t^{\prime }R{\bar{u}}_t+\delta u_t^{\prime }R{\bar{u}}_t+\delta u_t^{\prime }R\delta u_t,$$

$$c_T(x_T)$$

$$\delta x_{t+1}=\underset{{\bar{A}}_t}{\underbrace{(A_t+B_t{K}_t)}}\delta x_t+\underset{{\bar{S}}_t(\delta x_t)}{\underbrace{\{B_t{\tilde{S}}_t(\delta x_t)+S_t(\delta x_t)\}}}+ϵw_t,$$

$$c(x_t,u_t)=\underset{{\bar{c}}_t}{\underbrace{\{l({\bar{x}}_t)+\frac{1}{2}{\bar{u}}_t^{\prime }R{\bar{u}}_t\}}}+\underset{{\bar{C}}_t}{\underbrace{[L_t+{\bar{u}}_t^{\prime }R{K}_t]}}\delta x_t$$

$$+\underset{{\bar{H}}_t(\delta x_t)}{\underbrace{(K_t\delta x_t+{\tilde{S}}_t(\delta x_t){)}^{\prime }R(K_t\delta x_t+{\tilde{S}}_t(\delta x_t))}}.$$

$$J^{\pi }$$

$$=\sum _{t=1}^T{\bar{c}}_t+\sum _{t=1}^T{\bar{C}}_t\delta x_t+\sum _{t=1}^T{\bar{H}}_t(\delta x_t),$$

$$\delta x_{t+1}={\bar{A}}_t\delta x_t+{\bar{S}}_t(\delta x_t)+ϵw_t$$

$$\delta x_t=\delta x_t^l+\overline{\stackrel{ˉ}{S_t}},\delta x_{t+1}^l={\bar{A}}_t\delta x_t^l+ϵw_t$$

$$J^{\pi }=\underset{{\bar{J}}^{\pi }}{\underbrace{\sum _{t=1}^T{\bar{c}}_t}}+\underset{\delta J_1^{\pi }}{\underbrace{\sum _{t=1}^T{\bar{C}}_t\delta x_t^l}}+\underset{\delta J_2^{\pi }}{\underbrace{\sum _{t=1}^T{\bar{H}}_t(\delta x_t)+{\bar{C}}_t{\overline{\stackrel{ˉ}{S}}}_t}}.$$

$${\tilde{J}}^{\pi }$$

$$\text{Var}(J^{\pi })$$

$${\tilde{J}}^{\pi }=\mathbb{E}[J^{\pi }]=\mathbb{E}[{\bar{J}}^{\pi }+\delta J_1^{\pi }+\delta J_2^{\pi }],$$

$$={\bar{J}}^{\pi }+\mathbb{E}[\delta J_2^{\pi }]={\bar{J}}^{\pi }+O({ϵ}^2),$$

$$\text{Var}(J^{\pi })=\mathbb{E}[J^{\pi }-{\tilde{J}}^{\pi }{]}^2$$

$$=\mathbb{E}[{\bar{J}}_0^{\pi }+\delta J_1^{\pi }+\delta J_2^{\pi }-{\bar{J}}_0^{\pi }-\delta {\tilde{J}}_2^{\pi }{]}^2$$

$$=\text{Var}(\delta J_1^{\pi })+\text{Var}(\delta J_2^{\pi })+2\mathbb{E}[\delta J_1^{\pi }\delta J_2^{\pi }].$$

$$({\bar{u}}_t^{\ast }{)}_{t=1}^{T-1}$$

$${\bar{x}}_{t+1}$$

$$(K_t^{\ast }{)}_{t=1}^{T-1}$$

$$\delta J_1^{\pi }=\sum _{t=1}^T{\bar{C}}_t{x}_t^l,$$

$$\delta x_{t+1}^l=(A_t+B_t{K}_t)\delta x_t^l+ϵw_t.$$

$${\pi }_t^{\ast }(x_t)={\bar{u}}_t^{\ast }+K_t^{\ast }\delta x_t,$$

$$|{\tilde{J}}^{\pi \ast }-{\tilde{J}}^{{\pi }^o}|=O({ϵ}^2).$$

$${\tilde{J}}^{{\pi }^{\ast }}-{\tilde{J}}^{{\pi }^o}$$

$$\le {\tilde{J}}^{{\pi }^{\ast }}-{\bar{J}}^{{\pi }^{\ast }}+{\bar{J}}^{{\pi }^o}-{\tilde{J}}^{{\pi }^o}$$

$$|{\tilde{J}}^{{\pi }^{\ast }}-{\tilde{J}}^{{\pi }^o}|\le |{\tilde{J}}^{{\pi }^{\ast }}-{\bar{J}}^{{\pi }^{\ast }}|+|{\bar{J}}^{{\pi }^o}-{\tilde{J}}^{{\pi }^o}|=O({ϵ}^2)$$

$$\underset{(\delta u_t{)}_{t=1}^T}{\min }$$

$$\delta x_{t+1}=A_t\delta x_t+B_t\delta u_t+ϵw_t.$$

$$U^{(n+1)}=U^{(n)}-\alpha {\nabla }_U\bar{J}{|}_{{\mathcal{X}}^{(n)},U^{(n)}},$$

Full text

This paper proposes a novel decoupled data-based control (D2C) algorithm that addresses this problem using a decoupled, ‘open loop - closed loop’, approach. First, an open-loop deterministic trajectory optimization problem is solved using a black-box simulation model of the dynamical system. Then, a closed loop control is developed around this open loop trajectory by linearization of the dynamics about this nominal trajectory. By virtue of linearization, a linear quadratic regulator based algorithm can be used for this closed loop control. We show that the performance of D2C algorithm is approximately optimal. Moreover, simulation performance suggests significant reduction in training time compared to other state of the art algorithms.

I Introduction

Controlling an unknown dynamical system adaptively has a rich history in control literature [1] [2]. These classical literature provides rigorous analysis about the asymptotic performance and stability of the closed loop system. Classical adaptive control literature mainly focuses on non-stochastic systems [3] [4]. Stochastic adaptive control literature mostly addresses tractable models like linear quadratic regulator (LQR) where Riccati equation based closed form expressions are available for the optimal control law. Optimal control of an unknown nonlinear dynamical system with continuous state space and continuous action space is a significantly more challenging problem. Even with a known model, computing an optimal control law requires solving a dynamic programming problem. The ‘curse of dimensionality’ associated with dynamic programming makes solving such problems computationally intractable, except under special structural assumptions on the underlying system. Learning to control problems where the model of the system is unknown also suffer from this computational complexity issues, in addition to the usual identifiability problems in adaptive control.

Last few years have seen significant progresses in deep neural netwoks based reinforcement learning approaches for controlling unknown dynamical systems, with applications in many areas like playing games [5], locomotion [6] and robotic hand manipulation [7]. A number of new algorithms that show promising performance are proposed [8] [9] [10] and various improvements and innovations have been continuously developed. However, despite excellent performance on a number of tasks, reinforcement learning (RL) is still considered very data intensive. The training time for such algorithms are typically really large. Moreover, high variance and reproducibility issues on the performance are also reported [11]. While there have been some attempts to improve the sample efficiency [12], a systematic approach is still lacking.

In this work, we propose a novel decoupled data based control (D2C) algorithm for learning to control an unknown nonlinear dynamical system. Our approach introduces a rigorous decoupling of the open loop (planning) problem from the closed loop (feedback control) problem. This decoupling allows us to come up with a highly sample efficient approach to solve the problem in a completely data based fashion. Our approach proceeds in two steps: (i) first, we optimize the nominal open loop trajectory of the system using a blackbox simulation model, (ii) then we identify the linear system governing perturbations from the nominal trajectory using random input-output perturbation data, and design an LQR controller for this linearized system. We show that the performance of D2C algorithm is approximately optimal, in the sense that the decoupled design is near optimal to second order in a suitably defined noise parameter. Moreover, simulation performance suggests significant reduction in training time compared to other state of the art algorithms.

Related works: The solution approaches to the problem of controlling an unknown dynamical systems can be divided into two broad classes, model-based methods and model-free methods.

In the model-based methods, many techniques [13] rely on a discretization of the underlying state and action space, and hence, run into the curse of dimensionality, the fact that the computational complexity grows exponentially with the dimension of the state space of the problem. The most computationally efficient among these techniques are trajectory-based methods such as differential dynamic programming (DDP) [14] [15] which linearizes the dynamics and the cost-to-go function around a given nominal trajectory, and designs a local feedback controller using DP. The iterative linear quadratic Gaussian (ILQG) [16] [17], which is closely related to DDP, considers the first order expansion of the dynamics (in DDP, a second order expansion is considered), and designs the feedback controller using Riccati-like equations, and is shown to be computationally more efficient. In both approaches, the control policy is executed to compute a new nominal trajectory, and the procedure is repeated until convergence.

Model-free methods, more popularly known as approximate dynamic programming [18] [19] or reinforcement learning (RL) methods [20], seek to improve the control policy by repeated interactions with the environment, while observing the system’s responses. The repeated interactions, or learning trials, allow these algorithms to compute the solution of the dynamic programming problem (optimal value/Q-value function or optimal policy) without explicitly constructing the model of the unknown dynamical system. Standard RL algorithms are broadly divided into value-based methods, like Q-learning, and policy-based methods, like policy gradient algorithms. Recently, function approximation using deep neural networks has significantly improved the performance of reinforcement learning algorithm, leading to a growing class of literature on ‘deep reinforcement learning’. Despite the success, the amount of samples and training time required still seem prohibitive.

Our Contributions: Rather than directly finding the closed loop control law which requires solving a dynamic programming problem, our approach addresses the original stochastic control problem in a ’decoupled open loop - closed loop’ fashion. In this approach: i) we solve an open loop deterministic optimization problem to obtain an optimal nominal trajectory in a model-free fashion, and then ii) we design a closed loop controller for the resulting linearized time-varying system around the optimal nominal trajectory, in a model-based fashion. This ‘divide and conquer’ strategy can be shown to be extremely effective. In this context, our major contributions are: 1) we show a near optimal parametrization of the feedback policy in terms of an open loop control sequence, and a linear feedback control law, 2) we show rigorously that the open loop and closed loop learning can be decoupled, which 3) results in the D2C algorithm that is highly data efficient when compared to state of the art RL techniques. This paper is a rigorous extension of our preliminary work [21, 22], in particular, it includes a stronger decoupling result, and an extensive empirical evaluation of the D2C algorithm with state of the art RL implementations on standard benchmark problems.

The rest of the paper is organized as follows. In Section II, the basic problem formulation is outlined. In Section III, a decoupling result which solves the MDP in a “decoupled open loop-closed loop ” fashion is briefly summarized. In Section IV, we propose a decoupled data based control algorithm, with discussions of implementation problems. In Section V, we test the proposed approach using four typical benchmarking examples with comparisons to a state of the art RL technique.

II PROBLEM FORMULATION

Consider the following discrete time nonlinear stochastic dynamical system:

[TABLE]

where $x_{t}\in\mathbb{R}^{n_{x}}$, $u_{t}\in\mathbb{R}^{n_{u}}$ are the state measurement and control vector at time $k$, respectively. The process noise $w_{t}$ is assumed as zero-mean, uncorrelated Gaussian white noise, with covariance $W$.

The optimal stochastic control problem is to find the the control policy $\pi^{o}=\{\pi^{o}_{1},\pi^{o}_{2},\cdots,\pi^{o}_{T-1}\}$ such that the expected cumulative cost is minimized, i.e.,

[TABLE]

$u_{t}=\pi_{t}(x_{t})$, $c(\cdot,\cdot)$ is the instantaneous cost function, and $c_{T}(\cdot)$ is the terminal cost function. In the following, we assume that the initial state $x_{1}$ is fixed, and denote $\tilde{J}^{\pi}(x)$ simply as $\tilde{J}^{\pi}$.

If the function $h(\cdot,\cdot,\cdot)$ is known exactly, then the optimal control law $\pi^{o}$ can be computed using dynamic programming method. However, as noted before, this can be often computationally intractable. Moreover, when $h$ is unknown, designing an optimal closed loop control law is a much more challenging problem. In the following, we propose a data based decoupled approach for solving (II) when $h$ is unknown.

III A NEAR OPTIMAL DECOUPLING PRINCIPLE

We first outline a near-optimal decoupling principle in stochastic optimal control that paves the way for the D2C algorithm described in Section IV.

We make the following assumptions for the simplicity of illustration. We assume that the dynamics given in (1) can be written in the form

[TABLE]

where $\epsilon<1$ is a small parameter. We also assume that the instantaneous cost $c(\cdot,\cdot)$ has the following simple form,

[TABLE]

We emphasis that these assumptions, quadratic control cost and affine in control dynamics, are purely for the simplicity of treatment. These assumptions can be omitted at the cost of increased notational complexity.

III-A Linearization w.r.t. Nominal Trajectory

Consider a noiseless version of the system dynamics given by (3). We denote the “nominal” state trajectory as $\bar{x}_{t}$ and the “nominal” control as $\bar{u}_{t}$ where $u_{t}=\pi_{t}(x_{t})$, where $\pi=(\pi_{t})^{T-1}_{t=1}$ is a given control policy. The resulting dynamics without noise is given by $\bar{x}_{t+1}=f(\bar{x}_{t})+B_{t}\bar{u}_{t}$.

Assuming that $f(\cdot)$ and $\pi_{t}(\cdot)$ are sufficiently smooth, we can linearize the dynamics about the nominal trajectory. Denoting $\delta x_{t}=x_{t}-\bar{x}_{t},\delta u_{t}=u_{t}-\bar{u}_{t}$, we can express,

[TABLE]

where $A_{t}=\frac{\partial f}{\partial x}|_{\bar{x}_{t}}$, $K_{t}=\frac{\partial\pi_{t}}{\partial x}|_{\bar{x}_{t}}$, and $S_{t}(\cdot),\tilde{S}_{t}(\cdot)$ are second and higher order terms in the respective expansions. Similarly, we can linearize the instantaneous cost $c(x_{t},u_{t})$ about the nominal values $(\bar{x}_{t},\bar{u}_{t})$ as,

[TABLE]

where $L_{t}=\frac{\partial l}{\partial x}|_{\bar{x}_{t}}$, $C_{T}=\frac{\partial c_{T}}{\partial x}|_{\bar{x}_{t}}$, and $H_{t}(\cdot)$ and $H_{T}(\cdot)$ are second and higher order terms in the respective expansions.

Using (5) and (6), we can write the closed loop dynamics of the trajectory $(\delta x_{t})^{T}_{t=1}$ as,

[TABLE]

where $\bar{A}_{t}$ represents the linear part of the closed loop systems and the term $\bar{S}_{t}(.)$ represents the second and higher order terms in the closed loop system. Similarly, the closed loop incremental cost given in (7) can be expressed as

[TABLE]

Therefore, the cumulative cost of any given closed loop trajectory $(x_{t},u_{t})^{T}_{t=1}$ can be expressed as,

[TABLE]

where $\bar{c}_{T}=c_{T}(\bar{x}_{T}),\bar{C}_{T}=C_{T}$.

We first show the following result.

Lemma 1

The state perturbation equation

[TABLE]

given in (9) can be equivalently characterized as

[TABLE]

where $\bar{\bar{S}}_{t}$ is an $O(\epsilon^{2})$ function that depends on the entire noise history $\{w_{0},w_{1},\cdots w_{t}\}$ and $\delta x_{t}^{l}$ evolves according to the linear closed loop system.

Proof is omitted due to page limits. Detailed proof is given in [23].

Using (12) in (III-A), we can obtain the cumulative cost of any given closed loop trajectory as,

[TABLE]

Now, we show the following important result.

Proposition 1

[TABLE]

Proof:

From (13), we get,

[TABLE]

The first equality in the last line of the equations before follows from the fact that $\mathbb{E}[\delta x_{t}^{l}]=0$, since its the linear part of the state perturbation driven by white noise and by definition $\delta x_{1}^{l}=0$.The second equality follows form the fact that $\delta J_{2}^{\pi}$ is an $O(\epsilon^{2})$ function. Now,

[TABLE]

Since $\delta J_{2}^{\pi}$ is $O(\epsilon^{2})$, $\text{Var}(\delta J_{2}^{\pi})$ is an $O(\epsilon^{4})$ function. It can be shown that $\mathbb{E}[\delta J_{1}^{\pi}\delta J_{2}^{\pi}]$ is $O(\epsilon^{4})$ as well (proof is given [23]). Finally $\text{Var}(\delta J_{1}^{\pi})$ is an $O(\epsilon^{2})$ function because $\delta x^{l}$ is an $O(\epsilon)$ function. Combining these, we will get the desired result. ∎

The following observations can now be made from Proposition 1.

Remark 1** (Expected cost-to-go)**

Recall that $u_{t}=\pi_{t}(x_{t})$ $=\bar{u}_{t}+K_{t}\delta x_{t}+\tilde{S}_{t}(\delta x_{t})$. However, note that due to Proposition 1, the expected cost-to-go, $\tilde{J}^{\pi}$, is determined almost solely (within $O(\epsilon^{2})$) by the nominal control action sequence $\bar{u}_{t}$. In other words, the linear and higher order feedback terms have only $O(\epsilon^{2})$ effect on the expected cost-to-go function.

Remark 2** (Variance of cost-to-go)**

Given the nominal control action $\bar{u}_{t}$, the variance of the cost-to-go, which is $O(\epsilon^{2})$, is determined overwhelmingly (within $O(\epsilon^{4})$) by the linear feedback term $K_{t}\delta x_{t}$, i.e., by the variance of the linear perturbation of the cost-to-go, $\delta J_{1}^{\pi}$, under the linear closed loop system $\delta x_{t+1}^{l}=(A_{t}+B_{t}K_{t})\delta x_{t}^{l}+\epsilon w_{t}$.

III-B Decoupled Approach for Closed Loop Control

Proposition 1 and the remarks above suggest that an open loop control super imposed with a closed loop control for the perturbed linear system may be approximately optimal. We delineate this idea below.

Open Loop Design. First, we design an optimal (open loop) control sequence $\bar{u}^{*}_{t}$ for the noiseless system. More precisely,

[TABLE]

We will discuss the details of this open loop design in Section IV.

Closed Loop Design. We find the optimal feedback gain $K^{*}_{t}$ such that the variance of the linear closed loop system around the nominal path, $(\bar{x}_{t},\bar{u}^{*}_{t})$, from the open loop design above, is minimized.

[TABLE]

We now characterize the approximate closed loop policy below.

Proposition 2

Construct a closed loop policy

[TABLE]

where $\bar{u}_{t}^{*}$ is the solution of the open loop problem (16), and $K_{t}^{*}$ is the solution of the closed loop problem (17). Let $\pi^{o}$ be the optimal closed loop policy. Then,

[TABLE]

Furthermore, among all policies with nominal control action $\bar{u}_{t}^{*}$, the variance of the cost-to-go under policy $\pi_{t}^{*}$, is within $O(\epsilon^{4})$ of the variance of the policy with the minimum variance.

Proof:

We have

[TABLE]

The inequality above is due the fact that $\bar{J}^{\pi^{*}}\leq\bar{J}^{\pi^{o}}$, by definition of $\pi^{*}$. Now, using Proposition 1, we have that $|\tilde{J}^{\pi^{*}}-\bar{J}^{\pi^{*}}|=O(\epsilon^{2})$, and $|\tilde{J}^{\pi^{o}}-\bar{J}^{\pi^{o}}|=O(\epsilon^{2})$. Also, by definition, we have $\tilde{J}^{\pi^{o}}\leq\tilde{J}^{\pi^{*}}$. Then, from the above inequality, we get

[TABLE]

A similar argument holds for the variance as well. ∎

Unfortunately, there is no standard solution to the closed loop problem (17) due to the non additive nature of the cost function $\text{Var}(\delta J_{1}^{\pi})$. Therefore, we solve a standard LQR problem as a surrogate, and the effect is again one of reducing the variance of the cost-to-go by reducing the variance of the closed loop trajectories.

Approximate Closed Loop Problem. We solve the following LQR problem for suitably defined cost function weighting factors $Q_{t}$, $R_{t}$:

[TABLE]

The solution to the above problem furnishes us a feedback gan $\hat{K}_{t}^{*}$ which we can use in the place of the true variance minimizing gain $K_{t}^{*}$.

Remark 3

Proposition 1 states that the expected cost-to-go of the problem is dominated by the nominal cost-to-go. Therefore, even an open loop policy consisting of simply the nominal control action is within $O(\epsilon^{2})$ of the optimal expected cost-to-go. However, the plan with the optimal feedback gain $K_{t}^{*}$ is strictly better than the open loop plan in that it has a lower variance in terms of the cost to go. Furthermore, solving the approximate closed loop problem using the surrogate LQR problem, we can expect a lower variance of the cost-to-go function as well.

IV Decoupled Data Based Control (D2C) Algorithm

In this section, we propose a novel decoupled data based control (D2C) algorithm formalizing the ideas proposed in Section III. First, a noiseless open-loop optimization problem is solved to find a nominal optimal trajectory. Then a linearized closed-loop controller is designed around this nominal trajectory, such that, with existence of stochastic perturbations, the state stays close to the optimal open-loop trajectory. The three-step framework to solve the stochastic feedback control problem may be summarized as follows.

• •

Solve the open loop optimization problem using gradient decent with a black box simulation model of the dynamics.

• •

Linearize the system around the nominal open loop optimal trajectory, and identify the linearized time-varying system from input-output experiment data using a suitable system identification algorithm.

• •

Design an LQR controller which results in an optimal linear control policy around the nominal trajectory.

In the following section, we discuss each of the above steps.

IV-A Open Loop Trajectory Optimization

A first order gradient descent based algorithm is proposed here for solving the open loop optimization problem given in (16), where the underlying dynamic model is used as a blackbox, and the necessary gradients are found from a sequence of input perturbation experiment data using standard least square.

Denote the initial guess of the control sequence as $U^{(0)}=\{\bar{u}_{t}^{(0)}\}_{t=1}^{T}$, and the corresponding states $\mathcal{X}^{(0)}=\{\bar{x}_{t}^{(0)}\}_{t=1}^{T}$. The control policy is updated iteratively via

[TABLE]

where $U^{(n)}=\{\bar{u}_{t}^{(n)}\}_{t=1}^{T}$ denotes the control sequence in the $n^{th}$ iteration, $\mathcal{X}^{(n)}=\{\bar{x}_{t}^{(n)}\}_{t=1}^{T}$ denotes the corresponding states, and $\alpha$ is the step size parameter. As $\bar{J}|_{\mathcal{X}^{(n)},U^{(n)}}$ is the expected cumulative cost under control sequence $U^{(n)}$ and corresponding states $\mathcal{X}^{(n)}$, the gradient vector is defined as

[TABLE]

which is the gradient of the expected cumulative cost w.r.t the control sequence after $n$ iterations. The following paragraph elaborates on how to estimate the above gradient.

Let us define a rollout to be an episode in the simulation that starts from the initial settings to the end of the horizon with a control sequence. For each iteration, multiple rollouts are conducted sequentially with both the expected cumulative cost and the gradient vector updated iteratively after each rollout. During one iteration for the control sequence, the expected cumulative cost is calculated as

[TABLE]

where $j$ denotes the $j^{th}$ rollout within the current iteration process of control sequence. $\bar{J}|_{\mathcal{X}^{(n)},U^{(n)}}^{j}$ is the expected cumulative cost after $j$ rollouts while $J|_{\mathcal{X}^{j,(n)},U^{j,(n)}}$ denotes the cost of the $j^{th}$ rollout under control sequence $U^{j,(n)}$ and corresponding states $\mathcal{X}^{j,(n)}$. Note that $U^{j,(n)}=\{\bar{u}_{t}^{(n)}+\delta u^{j,(n)}_{t}\}_{t=1}^{T}$ where $\{\delta u^{j,(n)}_{t}\}^{T}_{t=1}$ is the zero-mean, i.i.d Gaussian noise added as perturbation to the control sequence $U^{(n)}$.

Then the gradient vector is calculated in a similar sequential manner as

[TABLE]

where $\sigma_{\delta u}$ is the variance of the control perturbation and $\nabla_{U}\bar{J}|_{\mathcal{X}^{(n)},U^{(n)}}^{j+1}$ denotes the gradient vector after $j$ rollouts. Note that after each rollout, both the expected cumulative cost and the gradient vector are updated. The rollout number $m$ in one iteration for the control sequence is decided by the convergence of both the expected cumulative cost and the gradient vector. After $m$ rollouts, the control sequence is updated by equation (20) in which $\nabla_{U}\bar{J}|_{\mathcal{X}^{(n)},U^{(n)}}$ is estimated by $\nabla_{U}\bar{J}|_{\mathcal{X}^{(n)},U^{(n)}}^{m}$. Keep doing this until the cost converges and the optimized nominal control sequence is $\{\bar{u}^{*}_{t}\}_{t=1}^{T}=\{\bar{u}^{(N-1)}_{t}\}_{t=1}^{T}$.

Higher order approaches other than gradient descent are possible. However, for a general system, the gradient descent approach is easy to implement. Also it is memory efficient and highly amenable to parallelization as a result of our sequential approach.

IV-B Linear Time-Varying System Identification

Closed loop control design specified in (17) or the approximate closed loop control design specified in (III-B) requires the knowledge of the parameters $A_{t},B_{t},1\leq t\leq T,$ of the perturbed linear system. We propose a linear time variant (LTV) system identification procedure to estimate these parameters.

First start from perturbed linear system given by equation (III-B). Using only first order information and estimate the system parameters $A_{t},B_{t}$ with the following form

[TABLE]

rewrite with augmented matrix

[TABLE]

Now write out their components for each iteration in vector form as,

[TABLE]

where N is the total iteration number. $\delta x_{t+1}^{n}$ denotes the output state deviation , $\delta x_{t}^{n}$ denotes the input state perturbations and $\delta u_{t}^{n}$ denotes the input control perturbations at time $t$ of the $n^{th}$ iteration. All the perturbations are zero-mean, i.i.d, Gaussian random vectors whose covariance matrix is $\sigma I$ where I is the identity matrix and $\sigma$ is a scalar. Note that here one iteration only has one rollout.

The next step is to apply the perturbed control $\{\bar{u}^{*}_{t}+\delta u_{t}^{n}\}_{t=1}^{T}$ to the system and collect input-output experiment data in a blackbox simulation manner.

Using the least square method $\hat{A_{t}}$ and $\hat{B_{t}}$ can be calculated in the following procedure

[TABLE]

As the perturbations are zero-mean, i.i.d, Gaussian random noise, $XX^{\prime}=\sigma I$. Then

[TABLE]

The calculation procedure can also be done in a sequential way similar to the update of the gradient vector in the open-loop optimization algorithm. Therefore it is highly amenable to parallelization and memory efficient.

IV-C Closed Loop Control Design

Given the parameter estimate of the perturbed linear system, we solve the closed loop control problem given in (III-B). This is a standard LQR problem. By solving the Riccati equation, we can get the closed-loop optimal feedback gain $K^{*}_{t}$. The details of the design is standard and is omitted here.

IV-D D2C Algorithm: Summary

The Decoupled Data Based Control (D2C) Algorithm is summarized in Algorithm 1.

V Simulation Results

In this section, we compare the D2C approach with the well-known deep reinforcement learning algorithm - Deep Deterministic Policy Gradient (DDPG) [24]. For the comparison, we evaluate both the methods in the following three aspects:

• •

Data efficiency in training - the amount of data sampling and storage required to achieve a desired task.

• •

Robustness to noise - the deviation from the predefined task due to random noise in process in the testing stage.

• •

Ease of training - the challenges involved in training with either of the data-based approaches.

V-A Tasks and Implementation

We tested our method with four benchmark tasks, all implemented in MuJoCo simulator [25]: Inverted pendulum, Cart-pole, 3-link swimmer and 6-link swimmer [26]. Each of the systems and their tasks are briefly defined as follows:

Inverted pendulum

A swing-up task of this 2D system from its downright initial position is considered.

Cart-pole

The state of a 4D under-actuated cart-pole comprises of the angle of the pole, cart’s horizontal position and their rates. Within a given horizon, the task is to swing-up the pole and balance it at the middle of the rail by applying a horizontal force on the cart.

3-link Swimmer

The 3-link swimmer model has 5 degrees of freedom and together with their rates, the system is described by 10 state variables. The task is to solve the planning and control problem from a given initial state to the goal position located at the center of the ball. Controls can only be applied in the form of torques to two joints. Hence, it is under-actuated by 3 DOF.

6-link Swimmer

The task with a 6-link swimmer model is similar to that defined in the 3-link case. However, with 6 links, it has 8 degrees of freedom and hence, 16 state variables, controlled by 5 joint motors.

D2C implementation is done in three stages corresponding to those mentioned in the previous section and ‘MuJoCo Pro 150’ is used as the environment for simulating the blackbox model. An off-the-shelf implementation of DDPG provided by Keras-RL [27] library has been customized for our simulations. It may be noted that the structure of the reward function is formulated to optimize the performance of DDPG and hence, different from that used in D2C. However, the episode length (or horizon) and the time-discretization step is held identical. Although continuous RL algorithms such as DDPG learn the policy and thereby interpolating it to the entire state space, we consider the task-based experiments in a finite limited time-frame window approach. Training is performed until the neural networks’ loss is converged. Hence, though the episodic reward does seem to converge earlier, that itself may not indicate that the policy is converged.

For fair comparison, ‘Episodic reward/cost fraction’ is considered with both methods. It is defined as the fraction of reward obtained in an episode during training w.r.t the nominal episodic reward (converged reward). Note that the words ’reward’ and ’cost’ are being used interchangeably due to their different notions in optimal control and RL literature respectively, though they achieve the same objective. For simplicity, one is considered the negative of the other.

V-B Performance Comparison

Data-efficiency: As mentioned above, an efficient training is one that requires minimal data sampling in order to achieve the same behavior. One way of measuring it is to collate the times taken for the episodic cost (or reward) to converge during training. Plots in Fig. 1 show the training process with both methods on the systems considered. Table I delineates the times taken for training respectively. As the system identification and feedback gain calculation in case of D2C take only a small portion of time, the total time comparison in (Table I) shows that D2C learns the optimal policy substantially faster than DDPG and hence, has a better data efficiency.

Robustness to noise: As with canonical off-policy RL algorithms, DDPG requires that an exploration noise be added to the policy, during training. Given that the training adapts the policy to various levels of noise, combined with hours of intense training and a nonlinear policy output, it is expected that it is more robust towards noise as is evident from Figs. 2 (c) and 2 (d). However, from plots in Figs. 2 (a) and (b), it is evident that in some systems the performance of D2C is on par with or better than DDPG. It may also be noted that the error variance in D2C method increases abruptly when the noise level is higher than a threshold and drives the system too far away from the nominal trajectory that the LQR controller cannot fix it. This could be considered as a drawback for D2C. However, it must be noted that the range of noise levels (up until 100 % of the maximum control signal) that we are considering here is far beyond what is typically encountered in practical scenarios. Hence, even in swimmer examples, the performance of D2C is tolerable to a reasonable extent of noise in the system.

Ease of training: The ease of training is often an ignored topic in analyzing a reinforcement learning (RL) algorithm. By this, we mean the challenges associated with its implementation. As with many RL algorithms that involve neural networks, DDPG has no guarantees for policy convergence. As a result, the implementation often involves tuning a number of hyper-parameters and a careful reward shaping in a trial and error fashion, which is even more time-consuming given that their successful implementation already involves significant time and computational resources. Reproducibility [11] is still a major challenge that RL is yet to overcome. On the other hand, training in our approach is predictable and very reliable.

To elucidate the ease of training from an empirical perspective, the exploration noise that is required for training in DDPG mandates the system to operate with a shorter time-step than a threshold, beyond which the simulation fails due to an unbearable magnitude of control actions into the system. For this, we train both the swimmers in one such case (with $\Delta t=0.01$ sec) till it fails and execute the intermediate policy. Fig. 3 shows the plot in the testing-stage with both methods. It is evident from the terminal state mean-squared error at zero noise level that the nominal trajectory of DDPG is incomplete and its policy failed to reach the goal. The effect is more pronounced in the higher-dimensional 6-link swimmer system (Fig. 3b), where the DDPG’s policy can be deemed to be downright broken. Note, from Table I, that the systems have been trained with DDPG for a time that is more than thrice with the 3-link swimmer and 4 times with the 6-link swimmer. On the other hand, under same conditions, the seamless training of D2C results in a working policy with even greater data-efficiency.

VI CONCLUSIONS

In this paper, we proposed a near-optimal control algorithm under fully observed conditions and showed that our method is able to scale-up to higher dimensional state-space without any knowledge about the system model. Due to sequential calculation used in the open-loop optimization and the system identification, D2C is highly memory efficient and also convenient for parallelization. We tested its performance and juxtaposed them with a state-of-the-art deep RL technique - DDPG. From the results, our method has conspicuous advantages over DDPG in terms of data efficiency and ease of training. The robustness of D2C is also better in some cases, but has scope for further development by employing more sophisticated feedback methods and ensuring that the data efficiency is not compromised. We also believe further drastic reduction in the planning time can be achieved by parallelization and a more sophisticated parametrization of the open loop problem.

It is evident from the simulations that methods such as D2C are able to achieve their goals accurately whereas DDPG consumes inordinate amount of time in ‘fine-tuning’ their behavior towards the goal. However, we also note that, by doing this, DDPG is tentatively exploring over the entire state-space and can result in a better generic policy. Another drawback with D2C over canonical RL algorithms is that the cost could be stuck in a local minimum, whereas DDPG due to the nature of stochastic gradient descent in training neural networks, can potentially reach the globally optimal solution. Nevertheless, we hope that our approach signifies the potential of decoupling based approaches such as D2C in a reinforcement learning paradigm and recognizes the need for more hybrid approaches that complement the merits of each.

APPENDIX

VI-A Proof of Lemma 1

Proof:

We proceed by induction. The first general instance of the recursion occurs at $t=3$. It can be shown that:

[TABLE]

Noting that $\bar{S}_{1}(.)$ and $\bar{S}_{2}(.)$ are second and higher order terms, it follows that $\bar{\bar{S}}_{3}$ is $O(\epsilon^{2})$.

Suppose now that $\delta x_{t}=\delta x_{t}^{l}+\bar{\bar{S}}_{t}$ where $\bar{\bar{S}}_{t}$ is $O(\epsilon^{2})$. Then:

[TABLE]

Noting that $\bar{S}_{t+1}$ is $O(\epsilon^{2})$ and that $\bar{\bar{S}}_{t+1}$ is $O(\epsilon^{2})$ by assumption, the result follows. ∎

VI-B Lemma 2

Lemma 2

Let $\delta J_{1}^{\pi}$, $\delta J_{2}^{\pi}$ be as defined in (13). Then, $\mathbb{E}[\delta J_{1}\delta J_{2}]$ is an $O(\epsilon^{4})$ function.

Proof:

In the following, we suppress the explicit dependence on $\pi$ for $\delta J_{1}^{\pi}$ and $\delta J_{2}^{\pi}$ for notational convenience. Recall that $\delta J_{1}=\sum_{t=0}^{T}c_{t}^{x}\delta x_{t}^{l}$, and $\delta J_{2}=\sum_{t=0}^{T}\bar{H}_{t}(\delta x_{t})+c_{t}^{x}\bar{\bar{S}}_{t}$. For notational convenience, let us consider the scalar case, the vector case follows readily at the expense of more elaborate notation. Let us first consider $\bar{\bar{S}}_{2}$. We have that $\bar{\bar{S}}_{2}=\bar{A}_{2}\bar{S}_{1}(\epsilon w_{0})+\bar{S}_{2}(\bar{A}_{1}(\epsilon w_{0})+\epsilon w_{1}+\bar{S}_{1}(\epsilon w_{0}))$. Then, it follows that:

[TABLE]

where $\bar{S}_{t}^{(2)}$ represents the coefficient of the second order term in the expansion of $\bar{S}_{t}$. A similar observation holds for $H_{2}(\delta x_{2})$ in that:

[TABLE]

where $\bar{H}_{t}^{(2)}$ is the coefficient of the second order term in the expansion of $\bar{H}_{t}$. Note that $\epsilon w_{0}=\delta x_{1}^{l}$ and $\bar{A}_{1}(\epsilon w_{0})+\epsilon w_{1}=\delta x_{2}^{l}$. Therefore, it follows that we may write:

[TABLE]

for suitably defined coefficients $q_{t,\tau}$. Therefore, it follows that

[TABLE]

for suitably defined $\bar{q}_{T,\tau}$. Therefore:

[TABLE]

Taking expectations on both sides:

[TABLE]

Break $\delta x_{t}^{l}=(\delta x_{t}^{l}-\delta x_{\tau}^{l})+\delta x_{\tau}^{l}$, assuming $\tau<t$. Then, it follows that:

[TABLE]

where the first and last terms in the first equality drop out due to the independence of the increment $(\delta x_{t}^{l}-\delta x_{\tau}^{l})$ from $\delta x_{\tau}^{l}$, and the fact that $E[\delta x_{t}^{l}-\delta x_{\tau}^{l}]=0$ and $E[\delta x_{\tau}^{l}]=0$. Since $\delta x_{\tau}^{l}$ is the state of the linear system $\delta x_{t+1}=\bar{A}_{t}\delta x_{t}^{l}+\epsilon w_{t}$, it may again be shown that:

[TABLE]

where $\Phi_{t,\tau}$ represents the state transitions operator between times $\tau$ and $t$, and follows from the closed loop dynamics. Now, due to the independence of the noise terms $w_{t}$, it follows that $E[w_{s_{1}}w_{s_{2}}w_{s_{3}}]=0$ regardless of $s_{1},s_{2},s_{3}$.

An analogous argument as above can be repeated for the case when $\tau>t$. Therefore, it follows that $E[\delta J_{1}\delta J_{2}]=O(\epsilon^{4})$. ∎