Task Decomposition for Iterative Learning Model Predictive Control

TL;DR

This paper introduces a task decomposition approach for iterative learning model predictive control, enabling the reuse of data from one task to efficiently solve related subsequent tasks in nonlinear systems.

Contribution

It provides a formal framework for subtask definition and demonstrates feasibility and cost improvement in iterative control for complex tasks.

Findings

Feasibility of the proposed task decomposition method.

Cost improvement over initializations.

Successful application in autonomous racing and robotic manipulation.

Abstract

A task decomposition method for iterative learning model predictive control is presented. We consider a constrained nonlinear dynamical system and assume the availability of state-input pair datasets which solve a task T1. Our objective is to find a feasible model predictive control policy for a second task, T2, using stored data from T1. Our approach applies to tasks T2 which are composed of subtasks contained in T1. In this paper we propose a formal definition of subtasks and the task decomposition problem, and provide proofs of feasibility and iteration cost improvement over simple initializations. We demonstrate the effectiveness of the proposed method on autonomous racing and robotic manipulation experiments.

Figures

Equations

$$x_{k+1}$$

$$x_k\in \mathcal{X},u_k\in \mathcal{U}.$$

$$\mathcal{T}=\left\{\mathcal{X},\mathcal{U},\mathcal{P}\right\}.$$

$$\forall x_k\in \mathcal{P},\exists u_k\in \mathcal{U}:x_{k+1}=f(x_k,u_k)\in \mathcal{P}.$$

$$V_{0\to T}^{\star }(x_0)=$$

$$s.t.x_{k+1}=f(x_k,u_k),$$

$$x_k\in \mathcal{X},u_k\in \mathcal{U}\forall k\ge 0,$$

$$x_T\in \mathcal{P},$$

$$E^j(\mathcal{T})$$

$${\mathbf{x}}^j$$

$$x_{T^j}^j\in \mathcal{P},$$

$${\mathbf{u}}^j$$

$${\mathcal{SS}}^J=\left\{\bigcup _{j=1}^J{\mathbf{x}}^j\right\},{\mathcal{S}\mathcal{U}}^J=\left\{\bigcup _{j=1}^J{\mathbf{u}}^j\right\},$$

$${\mathcal{S}\mathcal{Q}}^J$$

$${\mathbf{q}}^j$$

$$V^j(x_k^j)=\sum _{i=k}^{T^j}h(x_i^j,u_i^j).$$

$$V^{\mathrm{ILMPC},J+1}(x_k^{J+1})=$$

$$\underset{u_{k|k},...,u_{k+N-1|k}}{\min }\sum _{t=k}^{k+N-1}h(x_{t|k},u_{t|k})+V^J(x_{t+N|k})$$

$$s.t.x_{t+1|k}=f(x_{t|k},u_{t|k}),\forall t\in [k,k+N-1],$$

$$x_{t|k}\in \mathcal{X},u_{t|k}\in \mathcal{U},\forall t\in [k,k+N-1],$$

$$x_{k|k}=x_k^j,$$

$$x_{k+N|k}\in {\mathcal{SS}}^J\cup \mathcal{P},$$

$$u(x_k^j)={\pi }^{\mathrm{ILMPC}}(x_k^j)=u_{k|k}^{\star }.$$

$${\mathcal{S}}_i=\{{\mathcal{X}}_i,{\mathcal{U}}_i,{\mathcal{R}}_i\}.$$

$${\mathcal{R}}_i\subseteq {\mathcal{X}}_i=\{x\in {\mathcal{X}}_i:\exists u\in {\mathcal{U}}_i,f(x,u)\in {\mathcal{X}}_{i+1}\}.$$

$$E^j({\mathcal{S}}_i)$$

$${\mathbf{x}}_i^j$$

$$x_{T_i^j}^j\in {\mathcal{R}}_i,$$

$${\mathbf{u}}_i^j$$

$$E^j(\mathcal{T})$$

$${\mathbf{x}}^j$$

$${\mathbf{u}}^j$$

$$\displaystyle f\Big{(}$$

$$x$$

$$\mathcal{T}1$$

$${\mathcal{S}\mathcal{G}}_{l_{M-1}}=\left\{\bigcup _{j=1}^J{x}_{T_{[1\to l_{M-1}]}^j}^j\right\}.$$

$$\forall$$

$$x_{k+N}\in {\mathcal{SS}}_{[l_1\to l_M]}^0\subseteq \mathcal{X}.$$

$${\mathbf{x}}^1$$

$${\mathbf{u}}^1$$

$$\underset{u}{\min }h(x_0,u)+V^j(x_p^j)\le h(x_k,{\pi }^0(x_0))+V^j(x_p^j)$$

Full text

I Introduction

Control design for systems repeatedly performing a single task has been studied extensively. Such problems arise frequently in practical applications [1, 2] and examples range from autonomous cars racing around a track [3, 4, 5] to robotic system manipulators [6, 7, 8, 9]. Iterative Learning Controllers (ILCs) aim to autonomously improve a system’s closed-loop reference tracking performance at each iteration of a repeated task, while rejecting periodic disturbances [1, 10, 11]. In classical ILC, the controller uses tracking error data from previous task iterations to better track a provided reference trajectory during the current iteration. Recent work has also explored reference-free ILC strategies for tasks whose goals are better defined in terms of an economic metric, rather than a reference trajectory. The controller again uses previous iteration data to improve closed-loop performance with respect to the chosen performance metric. Examples include autonomous racing tasks (e.g. “minimize lap time”) [5, 12], or optimizing flight paths for tethered energy-harvesting systems (e.g. “maximize average power generation”) [13].

The aforementioned iterative learning methods require either a reference trajectory to track (classical ILC) or a feasible trajectory with which to initialize the iterative control algorithm (reference-free ILC). If the task changes, a new trajectory needs to be designed to match the new task. This can be challenging for complex tasks.

Many methods exist to use data collected from a task to efficiently solve variations of that task, including model-based and model-free methods. Here, we focus specifically on model-based methods for using stored trajectories from previous tasks in order to find feasible trajectories for new tasks. The authors in [14] propose running a desired planning method in parallel with a retrieve and repair algorithm that adapts reference trajectories from previous tasks to the constraints of a new task. Retrieve and repair was shown to decrease overall planning time, but requires checking for constraint violations at each point along a retrieved trajectory. In [15], environment features are used to divide a task and create a library of local trajectories in relative state space frames. These trajectories are then pieced back together in real-time according to the features of the new task environment. A trajectory library built using differential dynamic programming is used in [16] to design a controller for balance control in a humanoid robot. At each time step, a trajectory is selected from the library based on current task parameter estimates and a k-nearest neighbor selection scheme. A similar method is explored in [17], where differential dynamic programming is combined with receding horizon control. While these methods can decrease planning time, they verify or interpolate saved trajectories at every time step, which can be inefficient and unnecessary.

The authors in [18] propose piecing together stored trajectories corresponding to discrete system dynamics only at states of dynamics transition. However, this method only applies to discontinuities in system dynamics, and does not generalize to other task variations. In [19], a static map is learned between a given reference trajectory and the input sequence required to make a linear time invariant system track that reference trajectory. Once learned, this map can be used to determine an input sequence that lets the linear system track a new reference trajectory.

In this paper, our objective is to find a feasible trajectory to smartly initialize an Iterative Learning Model Predictive Controller (ILMPC) [20] for a new task, using data from previous tasks. ILMPC is a type of reference-free ILC that uses a safe set to design a model predictive control (MPC) policy for an iterative control task. The ILMPC safe set is initialized using a feasible task trajectory.

We consider a constrained nonlinear dynamical system and assume the availability of a dataset containing states and inputs corresponding to multiple iterations of a task $\mathcal{T}1$. This dataset can be stored explicitly (e.g. by human demonstrations [21] or an iterative controller [20]) or generated by roll-out of a given policy (e.g. a hand-tuned controller). We introduce a Task Decomposition for ILMPC algorithm (TDMPC), and show how to use the stored $\mathcal{T}1$ dataset to efficiently construct a non-empty ILMPC safe set for task $\mathcal{T}2$ (a new variation of $\mathcal{T}1$), containing feasible trajectories for $\mathcal{T}2$.

The contributions of this paper are twofold:

We first present how to build the aforementioned $\mathcal{T}2$ safe set using the TDMPC algorithm. TDMPC reduces the complexity to adapt trajectories from $\mathcal{T}1$ to a new task $\mathcal{T}2$ by decomposing task $\mathcal{T}1$ into different modes of operation, called subtasks. The stored $\mathcal{T}1$ trajectories are adapted to $\mathcal{T}2$ only at points of subtask transition, by solving one-step controllability problems. 2. 2.

We prove that the resulting safe set based ILMPC policy is feasible for $\mathcal{T}2$, and the corresponding closed-loop trajectories have lower iteration cost compared to an ILMPC initialized using simple methods.

II Problem Definition

II-A Safe Set Based ILMPC

We consider a system

[TABLE]

where $f(x_{k},u_{k})$ is the dynamical model, subject to the constraints

[TABLE]

The vectors $x_{k}$ and $u_{k}$ collect the states and inputs at time step $k$. We pick a set $\mathcal{P}\subset\mathcal{X}$ to be the target set for an iterative task $\mathcal{T}$, performed repeatedly by system (1) and defined by the tuple

[TABLE]

Assumption 1

$\mathcal{P}$* is a control invariant set [22, Sec 10.9]:*

[TABLE]

Each task execution is referred to as an iteration. The goal of an ILMPC is to solve at each iteration the optimal task completion problem:

[TABLE]

where $V^{\star}_{0\rightarrow T}(x_{0})$ is the optimal cost-to-go from the initial state $x_{0}$, and $h(x_{k},u_{k})$ is a chosen stage cost.

At the $j$-th successful task iteration, the vectors

[TABLE]

collect the inputs applied to system (1) and the corresponding state evolution. In (5), $x_{k}^{j}$ and $u_{k}^{j}$ denote the system state and control input at time $k$ of the $j$-th iteration, and $T^{j}$ is the duration of the $j$-th iteration.

After $J$ number of iterations, we define the sampled safe state set and sampled safe input set as:

[TABLE]

where $\mathcal{SS}^{J}$ contains all states visited by the system in previous task iterations, and $\mathcal{SU}^{J}$ the corresponding inputs applied at each of these states. Hence, by construction of the safe set, for any state in $\mathcal{SS}^{J}$ there exists a feasible input sequence contained in $\mathcal{SU}^{J}$ to reach the goal set $\mathcal{P}$ while satisfying state and input constraints (2).

Similarly, we define the sampled cost set as:

[TABLE]

where $V^{j}(x_{k}^{j})$ is the realized cost-to-go from state $x^{j}_{k}$ at time step $k$ of the $j$-th task execution:

[TABLE]

The safe set based ILMPC policy tries to solve (4) by using state and input data collected during past task iterations, stored in the sampled safe sets. At time $k$ of iteration $J+1$, we solve the optimal control problem:

[TABLE]

which searches for an input sequence over a chosen planning horizon $N$ that controls the system (1) to the state in the sampled safe state set or task target set $\mathcal{P}$ with the lowest cost-to-go (8). We then apply a receding horizon strategy:

[TABLE]

A system (1) in closed-loop with (10) leads to a feasible task execution if $x_{0}\in\mathcal{SS}^{J}$. At each time step, the ILMPC policy searches for the optimal input based on previous task data, leading to performance improvement on the task as the sampled safe sets continue to grow with each subsequent iteration. For details on ILMPC, we refer to [23].

The sampled safe sets used in the ILMPC policy (10) must first be initialized to contain at least one feasible task execution. The aim of TDMPC is to use data collected from a task $\mathcal{T}1$ in order to efficiently find such an execution for a new task $\mathcal{T}2$. This will induce an ILMPC policy (10) that can be used to directly solve or initialize an ILMPC for $\mathcal{T}2$. We approach this using subtasks, formalized in Sec. II-B, and the concept of controllability.

Definition: A system (1) is N-step controllable from an initial state $x_{0}$ to a terminal state $x_{P}$ if there exists an input sequence $[u_{0},u_{1},...,u_{N-1}]\in\mathcal{U}$ such that the corresponding state trajectory satisfies state constraints (2) and $x_{N}=x_{P}$. A system is controllable from $x_{0}$ to $x_{P}$ if there exists an $N>0$ such that the system is $N$-step controllable to $x_{P}$. [22, Sec 10.1]

II-B Subtasks

Consider an iterative task $\mathcal{T}$ (3) and a sequence of $M$ subtasks, where the $i$-th subtask $\mathcal{S}_{i}$ is the tuple

[TABLE]

We take $\mathcal{X}_{i}\subseteq\mathcal{X}$ as the subtask workspace, $\mathcal{U}_{i}\subseteq\mathcal{U}$ the subtask input space, and $\mathcal{R}_{i}$ the set of transition states from the current subtask $\mathcal{S}_{i}$ workspace into the subsequent $\mathcal{S}_{i+1}$ workspace:

[TABLE]

A successful subtask execution E($\mathcal{S}_{i}$) of a subtask $\mathcal{S}_{i}$ is a trajectory of inputs and corresponding states evolving according to (1) while respecting state and input constraints (2), ending in the transition set. We define the $j$-th successful execution of subtask $\mathcal{S}_{i}$ as

[TABLE]

where the vectors ${\bf{u}}_{i}^{j}$ and ${\bf{x}}_{i}^{j}$ collect the inputs applied to the system (1) and the resulting states, respectively, and $x_{k}^{j}$ and $u_{k}^{j}$ denote the system state and the control input at time $k$ of subtask execution $j$. $T_{i}^{j}$ is the duration of the $j$-th execution of subtask $i$. The final state of each successful subtask execution is in the subtask transition set, from which it can evolve into new subtasks. For the sake of notational simplicity, we have written all subtask executions as beginning at time step $k=0$.

We say the task $\mathcal{T}$ is an ordered sequence of the $M$ subtasks ($\mathcal{T}=\{\mathcal{S}_{i}\}_{i=1}^{M}$) if the $j$-th successful task execution (5) is equal to the concatenation of successful subtask executions:

[TABLE]

where $T^{j}_{[1\rightarrow i]}$ is the duration of the first $i$ subtasks during the $j$-th task iteration. When the state reaches a subtask transition set, the system has completed subtask $\mathcal{S}_{i}$, and it transitions into the following subtask $\mathcal{S}_{i+1}$. The task is completed when the system reaches the last subtask’s transition set, $\mathcal{R}_{M}$, which we consider as the task’s control invariant target set (referred to as $\mathcal{P}$ in the previous section).

III Task Decomposition for ILMPC

Here we describe the intuition behind TDMPC, and provide an algorithm for the method. We also prove feasibility and iteration cost reduction of policies output by TDMPC.

III-A TDMPC

Let Task $1$ and Task $2$ be different ordered sequences of the same $M$ subtasks:

[TABLE]

where the sequence $[l_{1},l_{2},...,l_{M}]$ is a reordering of the sequence $[1,2,...,M]$. Assume non-empty sampled safe sets $\mathcal{SS}_{[1\rightarrow M]}^{J}$, $\mathcal{SU}_{[1\rightarrow M]}^{J}$, and $\mathcal{SQ}_{[1\rightarrow M]}^{J}$ (6, 7) containing executions that solve $\mathcal{T}1$.

The goal of TDMPC is to use the executions stored in the sampled safe sets from Task $1$ in order to find a feasible execution for Task $2$, ending in the new target set $\mathcal{R}_{l_{M}}$. The key intuition of the method is that all successful subtask executions from Task $1$ are also successful subtask executions for Task $2$, as this definition only depends on properties (12) of the subtask itself, not the subtask sequence. Therefore, only stored points at subtask transitions need to be analyzed. Based on this intuition, Algorithm 1 proceeds backwards through the new subtask sequence $[l_{1},l_{2},...,l_{M}]$. The key steps are discussed below.

• •

Consider subtask $\mathcal{S}_{l_{M}}$. All states from $\mathcal{S}_{l_{M}}$ stored in the Task $1$ executions are controllable to $\mathcal{R}_{l_{M}}$ using stored inputs, i.e. there exists a stored input sequence that can be applied to the state such that the system evolves to be in $\mathcal{R}_{l_{M}}$. We next look for stored states from the preceding subtask, $\mathcal{S}_{l_{M-1}}$, which are controllable to $\mathcal{R}_{l_{M}}$ via $\mathcal{S}_{l_{M}}$. (Algorithm 1, Lines 4-6)

Define the sampled guard set of $\mathcal{S}_{l_{M-1}}$ as

[TABLE]

The set contains those states in $\mathcal{S}_{l_{M-1}}$ from which the system transitioned into another subtask during one of the previous $J$ executions of $\mathcal{T}1$. Only controllability from the sampled guard set will be important in our approach.

• •

We search for the set of points in $\mathcal{SG}_{l_{M-1}}$ that are controllable to stored states in $\mathcal{S}_{l_{M}}$. This problem can be solved using a variety of numerical approaches. (Algorithm 1, Lines 9-15)

• •

For any stored state $x$ in $\mathcal{SG}_{l_{M-1}}$ for which the controllability analysis failed, we remove the stored $\mathcal{SS}^{J}_{[l_{M-1}]}$ subtask execution ending in $x$ as candidate controllable states for Task $2$. All remaining stored states in $\mathcal{S}_{l_{M-1}}$ are controllable to stored states in $\mathcal{S}_{l_{M}}$, and therefore also to $\mathcal{R}_{l_{M}}$. (Algorithm 1, Lines 15-20)

Algorithm  1 iterates backwards through the remaining subtask sequence, connecting points in sampled guard sets to previously verified trajectories in the next subtask. Fig. 1 depicts this process across three subtasks from an autonomous racing task detailed in Section IV. The algorithm terminates when it has iterated through the new subtask order, or when no states in a subtask’s sampled guard set can be shown to be controllable to $\mathcal{R}_{l_{M}}$. The algorithm returns sampled safe sets for Task $2$ that have been verified through controllability to contain feasible executions of Task $2$.

TDMPC can improve on the computational complexity of existing trajectory transfer methods in two key ways: (i) by verifying stored trajectories only at states in the sampled guard set, rather than at each recorded time step, and (ii) by solving a data-driven, one-step controllability problem to adapt the trajectories, rather than a multi-step or set-based controllability method.

III-B Properties of TDMPC-Derived Policies

We prove feasibility and iteration cost reduction of ILMPC policies (10) initialized using TDMPC.

Assumption 2

Task $1$ and Task $2$ are defined as in (14), where the subtask workspaces and input spaces are given by $\mathcal{X}_{i}=\mathcal{X},~{}\mathcal{U}_{i}=\mathcal{U}$ for all $i\in[1,M]$.

Theorem 1

(Feasibility) Let Assumptions  1-2 hold. Assume non-empty sets $\mathcal{SS}^{J}_{[1\rightarrow M]}$, $\mathcal{SU}^{J}_{[1\rightarrow M]}$, $\mathcal{SQ}^{J}_{[1\rightarrow M]}$ containing trajectories of system (1) for Task $1$. Assume Algorithm  1 outputs non-empty sets $\mathcal{SS}^{0}_{[l_{1}\rightarrow l_{M}]}$, $\mathcal{SU}^{0}_{[l_{1}\rightarrow l_{M}]}$, $\mathcal{SQ}^{0}_{[l_{1}\rightarrow l_{M}]}$ for Task $2$. Then, if $x_{0}\in\mathcal{SS}^{0}_{[l_{1}\rightarrow l_{M}]}$, the policy $\pi^{\mathrm{ILMPC}}_{[l_{1}\rightarrow l_{M}]}$, as defined in (10), produces a feasible execution of Task $2$.

Proof:

At every state $x_{k}$, the ILMPC policy (10) searches for a sequence of inputs $[u_{k},u_{k+1},...,u_{k+N-1}]$ such that, when applied to the system (1), the resulting state $x_{k+N}$ is in $\mathcal{SS}^{0}_{[l_{1}\rightarrow l_{M}]}$ or the target set $\mathcal{R}_{l_{M}}$.

Since all states in $\mathcal{SS}^{0}_{[l_{1}\rightarrow l_{M}]}$ are either stored as part of feasible trajectories to $\mathcal{R}_{l_{M}}$ or are directly in $\mathcal{R}_{l_{M}}$, such a sequence of inputs can always be found, and (9) always has a solution:

[TABLE]

As the terminal constraint set in 9 is itself an invariant set, recursive feasibility follows from standard MPC arguments [22]. It follows that the policy $\pi^{ILMPC}_{[l_{1}\rightarrow l_{M}]}$ produces feasible trajectories for Task $2$.

∎

The above Theorem 1 implies that the safe sets designed by the TDMPC algorithm induce an ILMPC policy that can be used to successfully complete Task $2$ while satisfying all input and state constraints.

Assumption 3

Consider Task $1$ and Task $2$ as defined in (14). The trajectories stored in $\mathcal{SS}^{J}_{[1\rightarrow M]}$ and $\mathcal{SU}^{J}_{[1\rightarrow M]}$ correspond to executions of Task $1$ by a nonlinear system (1). One stored trajectory corresponds to an execution of (1) in closed-loop with a policy $\pi^{0}(\cdot)$ that is feasible for both Task $1$ and Task $2$.

Theorem 2

(Cost Improvement) Let Assumptions  2-3 hold. Then, Algorithm  1 will return non-empty sets $\mathcal{SS}^{0}_{[l_{1}\rightarrow l_{M}]}$, $\mathcal{SU}^{0}_{[l_{1}\rightarrow l_{M}]}$, $\mathcal{SQ}^{0}_{[l_{1}\rightarrow l_{M}]}$ for Task $2$. Furthermore, if $x_{0}\in\mathcal{SS}^{1}_{[1\rightarrow M]}$, an ILMPC initialized using $\mathcal{SS}^{0}_{[l_{1}\rightarrow l_{M}]}$ will incur no higher iteration cost during an execution of Task $2$ than an ILMPC initialized using a trajectory corresponding to (1) in closed-loop with $\pi^{0}(\cdot)$.

Proof:

Define the vectors

[TABLE]

to be the stored state and input trajectory associated with the implemented policy $\pi^{0}(\cdot)$. Since $\pi^{0}(\cdot)$ is also feasible for Task $2$, when Algorithm  1 is applied, the entire task execution can be stored as a successful execution for Task $2$ without adapting the policy. It follows that $\mathcal{SS}_{[1\rightarrow M]}^{1}\subseteq~{}\mathcal{SS}^{0}_{[l_{1}\rightarrow l_{M}]}$ and $\mathcal{SU}_{[1\rightarrow M]}^{1}\subseteq\mathcal{SU}_{[l_{1}\rightarrow l_{M}]}^{0}$, and the returned sample safe sets for Task $2$ are non-empty.

At the initial state $x_{0}$, the ILMPC policy (10) optimizes the chosen input so as to minimize the remaining cost-to-go. Consider an MPC planning horizon of $N=1$ (though this extends directly for any $N\geq 1$). Trivially,

[TABLE]

It follows that the cost incurred by a Task $2$ execution with $\pi^{ILMPC}_{[l_{1}\rightarrow l_{M}]}$ is no higher than an execution with $\pi^{ILMPC}_{\pi^{0}}$. ∎

The proof that the improved closed-loop iteration cost follows from the improved ILMPC cost (9) is not presented here. However, the result shown holds for the examples presented in Sec. IV- V.

III-C Discussion

In the examples presented in this paper, we implement the search for controllable points (Algorithm 1, Line 15) by solving a one-step controllability problem, $(Q^{\star},u^{\star})=\mathrm{Ctrb}(x,\bf{z},\bf{q})$, where

[TABLE]

where z is a previously verified state trajectory through the next Task $2$ subtask, and q the sampled cost vector associated with the trajectory. (17) aims to find an input that connects the sampled guard state $x$ to a state in the convex hull of the trajectory [22, Sec 4.4.2]. If such an input is found, the new cost-to-go (8) for the state $x$ is taken to be the convex combination of the stored cost vector (18). Solving the controllability analysis to the convex hull is an additional method for reducing computational complexity of TDMPC and is exact only for linear systems with convex constraints.

The points of subtask transition should be defined as is most useful, given the two tasks. Subtask transition points simply indicate which segments of the stored trajectories are certain to remain feasible in $\mathcal{T}2$ using the stored policies - but this can change depending on how exactly $\mathcal{T}2$ differs from $\mathcal{T}1$. The TDMPC method is therefore not limited in applicability to a predetermined number of reshuffled tasks.

IV Application 1: Autonomous Racing

IV-A Task Formulation

Consider an autonomous racing task, in which a vehicle is controlled to minimize lap time driving around a race track with piecewise constant curvature (Fig. 2). We model this task as a series of ten subtasks, where the $i$-th subtask corresponds to a section of the track with constant radius of curvature $c_{i}$. Tasks with different subtask order are tracks consisting of the same road segments in a different order.

The vehicle is modeled in the curvilinear abscissa reference frame [24], with states and inputs at time step $k$

[TABLE]

where $v_{x_{k}}$, $v_{y_{k}}$, and $\dot{\psi}_{k}$ are the vehicle’s longitudinal velocity, lateral velocity, and yaw rate, respectively, at time step $k$, $s_{k}$ is the distance travelled along the centerline of the road, and $e_{\psi_{k}}$ and $e_{y_{k}}$ are the heading angle and lateral distance error between the vehicle and the path. The inputs are longitudinal acceleration $a_{k}$ and steering angle $\delta_{k}$. The system dynamics (1) are described using an Euler discretized dynamic bicycle model [5]. Accordingly, the system state and input spaces are

[TABLE]

We formulate each subtask according to (11), with:

IV-A1 Subtask Workspace $\mathcal{X}_{i}$

[TABLE]

where $s_{i-1}$ and $s_{i}$ mark the distances along the centerline to the start and end of the curve, and $l=0.8$ is the lane width in meters. $s_{10}=s_{\mathrm{end}}$ is the total length of the track. These bounds indicate that the vehicle can only drive forwards on the track, up to a maximum velocity, and must stay within the lane.

IV-A2 Subtask Input Space $\mathcal{U}_{i}$

[TABLE]

The input limits are a function of the vehicle, and do not change between subtasks.

IV-A3 Subtask Transition Set, $\mathcal{R}_{i}$

Lastly, we define the subtask transition set to be the states along the subtask border where the track’s radius of curvature changes:

[TABLE]

where $x^{+}=f(x,u)$. The task target set is the race track’s finish line,

[TABLE]

The task goal is to complete a lap and reach the target set as quickly as possible. Therefore we define the stage cost as:

[TABLE]

IV-B Simulation Setup

An ILMPC (10) is used to complete $J=5$ executions of Task $1$, the track depicted in Fig. 2. The vehicle begins each task iteration at standstill on the centerline at the start of the track. The $J$ executions and their costs are stored in $\mathcal{SS}_{[1\rightarrow M]}$, $\mathcal{SU}_{[1\rightarrow M]}$, and $\mathcal{SQ}_{[1\rightarrow M]}$. An initial trajectory for the ILMPC safe sets is executed using a centerline-tracking, low-velocity PID controller, $\Pi_{0}$.

TDMPC then uses these sampled safe sets to design initial policies for a new track composed of the same track segments. Two ILMPCs are designed for the reconfigured track: one initialized with TDMPC, and another initialized with $\Pi_{0}$. Each ILMPC completes $J=10$ laps around the new tracks. In this examples, the reconfigured track is not continuous, and should be considered to be a segments of larger, continuous track.

IV-C Simulation Results

Fig. 3 compares the first and tenth trajectories around the track of the two ILMPCs, plotted as black and red lines. The $\Pi_{0}$-initialized ILMPC (in dashed black) initially stays close to the centerline, taking nearly $18$ seconds to traverse the new track. The TDMPC-initialized ILMPC, however, traverses the new track more efficiently starting with the first lap. The first lap completed using the TDMPC-initialized ILMPC (in solid black) begins closer to the final locally optimal policies (in red) that both ILMPCs eventually converge to. In this example, the TDMPC method is able to leverage experience on another track in order to complete sections of the new track in a locally optimal way, even on the first iteration of a new task.

The lap time of each of the ten ILMPC iterations is plotted in the bottom of Fig. 3. As expected, the TDMPC-initialized ILMPC completes the first several laps faster than the $\Pi_{0}$-initialized ILMPC. The TDMPC-initialized ILMPC requires fewer task iterations and less time per iteration to reach a locally optimal trajectory.

V Application 2: Robotic Path Planning

TDMPC can also be used to combine knowledge gained from solving a variety of previous tasks. For example, if $D$ ILMPCs as in (10) complete $J$ iterations of $D$ different tasks, TDMPC can be used to design a policy for a task $(D+1)$. The algorithm draws on subtask executions collected over $D$ different tasks in order to build safe sets for Task $D+1$. We evaluated this approach in a robotic path planning example.

V-A Task Formulation

Consider a task in which a UR5e 111https://www.universal-robots.com/products/ur5-robot/ robotic arm needs to move an object to a target without colliding with obstacles (Fig. 4). The obstacles are modeled as extruded disks of varying heights above and below the robot, leaving a workspace space between $h_{\mathrm{min},i}$ and $h_{\mathrm{max},i}$. Here, each subtask corresponds to the workspace above a particular obstacle. Different subtask orderings correspond to a rearranging of the obstacle locations.

The end-effector reference tracking accuracy of the UR5e allows us to use a simplified model in robot experiments, in place of a discretized second-order model as in [25]. We solve the task in the reduced state space:

[TABLE]

where $z_{k}$ is the height of the robot end-effector at time step $k$, calculated from the joint angles via forward kinematics, and $\dot{z}_{k}$ the upward velocity. We control $\ddot{q}_{0_{k}}$ and $\ddot{z}_{k}$, the accelerations of $q_{0}$ and $z$, respectively. The system state and input spaces are

[TABLE]

We model the simplified system as a quadruple integrator:

[TABLE]

where $dt=0.01$ seconds is the sampling time. This simplified model holds as long as we operate within the region of high end-effector reference tracking accuracy, characterized in previous experiments.

We formulate each subtask according to (11).

V-A1 Subtask Workspace $\mathcal{X}_{i}$

[TABLE]

where $\theta_{i-1}$ and $\theta_{i}$ mark the cumulative angle to the beginning and end of the $i$-th obstacle, as in Fig. 4. States $\dot{q}_{0k}$ and $\dot{z}_{k}$ are constrained to lie in the experimentally determined region of high end-effector tracking accuracy. The robot end-effector is constrained not to collide with the subtask obstacle.

V-A2 Subtask Input Space $\mathcal{U}_{i}$

[TABLE]

where $\ddot{q}_{0k}$ and $\ddot{z}_{k}$ are constrained to lie in the experimentally determined region of high end-effector tracking accuracy.

V-A3 Subtask Transition Set, $\mathcal{R}_{i}$

We define the subtask transition set to be the states along the subtask border where the next obstacle begins:

[TABLE]

where $x^{+}=f(x,u)$. The task target set is the end of the last mode:

[TABLE]

The task goal is to reach the target set as quickly as possible:

[TABLE]

V-B Experimental Setup

An ILMPC (10) was used to complete $J=10$ executions of five different training tasks, where each training task corresponded to a reordering of the obstacles. In each task, the ILMPC tries to reach the target set as quickly as possible while avoiding the obstacles. Each ILMPC was initialized with a trajectory resulting from executing a policy $\Pi_{0}$ that tracks the center height of each mode with the end-effector, while the robot rotated at a low constant joint velocity $\dot{q}_{0}$. TDMPC was then applied to the combined sampled safe sets of the five training tasks, and used to design an initial policy for a new ILMPC on an unseen ordering of obstacles, shown in Fig. 5. The white space corresponds to environment obstacles, so that the ILMPC task is to reach the end of the last mode as quickly as possible while controlling the end-effector to remain within the safe (green) part of the state space. A second ILMPC was initialized with the center-height tracking $\Pi_{0}$, for comparison. After initialization, the two ILCMPs completed $J=20$ iterations of the new task. These iterations were executed in simulation using the simplified model (23), and the first and last trajectories of each ILMPC were then tracked by a real UR5e robot using end-effector tracking.

V-C Experimental Results

The measured robot trajectories are plotted in Fig. 5. The $\Pi_{0}$-initialized ILMPC follows the center-height of each mode closely during the first task iteration (plotted in dashed black). After ten iterations of the task, the resulting trajectory (plotted in dashed red) has only diverged from the center-height trajectory slightly. Correspondingly, after ten iterations the $\Pi_{0}$-initialized ILMPC still requires more than four seconds to complete the task.

The TDMPC-initialized ILMPC, however, draws on knowledge gathered over many previous tasks in order to solve the task efficiently right away. Already on the first trajectory (plotted in solid black), the TDMPC-initialized ILMPC solves the task in under three seconds. This is a $30\%$ improvement over the $\Pi_{0}$-initialized ILMPC. As in the autonomous driving task, the first trajectory completed by the TDMPC-initialized ILMPC is very close to the ultimate locally optimal trajectory.

Because of the nonconvex obstacles, this task is nonconvex, and there are many locally optimal trajectories. At various iterations of the task, both the TDMPC-initialized and the $\Pi_{0}$-initialized ILMPCs get stuck at such local minima, so that the ILMPCs performance metric remained constant over several iterations before improving again (Fig. 5). At these performance plateaus, the realized trajectories continue to change. We believe that the variability in the mixed integer solver used in the ILMPC led the ILMPC to follow different trajectories with the same iteration cost, as if encouraging exploration. Some of these different trajectories then allowed for performance improvement in the next iteration.

VI Conclusion

A task decomposition method for ILMPC was presented. The TDMPC algorithm uses stored state and input trajectories from executions of a task, and efficiently designs policies for executing variations of that task. TDMPC breaks tasks into subtasks and performs controllability analysis at sampled safe states between subtasks. The algorithm can improve upon other methods by only needing to verify and adapt the original task policy at points of subtask transition, rather than along the entire trajectory. We evaluate the effectiveness of the proposed algorithm on autonomous racing and robotic manipulation tasks. Our results confirm that TDMPC allows an ILMPC to converge to a locally-optimal minimum-time trajectory faster than using simple methods.