Learning Navigation Costs from Demonstration in Partially Observable Environments

I Introduction

Practical applications of autonomous robot systems increasingly require operation in unstructured, partially observed, unknown, and changing environments. Achieving safe and robust navigation in such conditions is directly coupled with the quality of the environment representation and the cost function specifying desirable robot behavior. Designing a cost function that accurately encodes safety, liveness, and efficiency requirements of navigation tasks is a major challenge. In contrast, it is significantly easier to obtain demonstrations of desirable behavior. The field of inverse reinforcement learning [Ng_IRL00, IRLSurvey, Neu_Apprenticeship12] (IRL) provides numerous tools for learning cost functions from expert demonstration.

We consider the problem of safe navigation from partial observations in unknown environments. We assume that demonstrations containing expert poses, controls, and sensory observations over time are available. The objective is to infer the cost function, which depends on the observation sequence, and explains the demonstrated behavior. This inference can only be done indirectly by comparing the control inputs, that a robot may take based on its current cost representation, to the expert’s actions in that situation.

Fig. 1: Architecture for learning cost function representations from demonstrations. Our main contribution lies in a non-stationary cost representation, combining a probabilistic occupancy map encoder, with recurrent dependence on observations

z_{1 : t}

, and a cost encoder

, defined over the occupancy features. We also perform efficient (in the size of the state-space) forward non-stationary policy computation and efficient (closed-form subgradient) backpropagation. The bottom-right plot illustrates that motion planning may be used to update and differentiate cost-to-go estimates only in promising areas of the state space rather than using full Bellman backups, which is particularly redundant in partially observable environments.

Learning a cost function requires a differentiable control policy with respect to the stage cost parameters. Computing such derivatives has been addressed by several successful approaches [Ratliff_06, Ziebart_MaxEnt08, Tamar_VIN16, Okada_PIN17]. Ratliff et al. [Ratliff_06] developed algorithms with regret bounds for computing subgradients of planning algorithms (e.g., A* [ARA], RRT [Lavalle_RRT98, Karaman_RRTstar11], etc.) with respect to the cost features. Ziebart et al. [Ziebart_MaxEnt08] developed a dynamic programming algorithm for computing the expected state visitation frequency of a policy extracted from expert demonstrations to enforce that it earns the same reward as the demonstrated policy. Tamar et al. [Tamar_VIN16] showed that the value iteration algorithm could be approximated using a series of convolution (computing value function expectation over stochastic transitions) and maxpooling (choosing the best action) allowing automatic differentiation. Okada et al. [Okada_PIN17] proposed path integral networks in which the control sequence resulting from path integral control may be differentiated with respect to the controller parameters. All of these works, however, assume a known environment and only optimize the parameters of a cost function defined over it.

A series of recent works [ChoiIRLinPOMDPJMLR2011, Shankar_RLviaRCNN2016, Wulfmeier_DeepMaxEnt16, Gupta_CMP17, Karkus_QMDPNet2017, Karkus_DAN19] address IRL under partial observability. Wulfmeier et al. [Wulfmeier_DeepMaxEnt16]

train deep neural network representations for Ziebart et al.’s Maximum Entropy IRL

[Ziebart_MaxEnt08] method and consider streaming lidar scan observations of the environment. Karkus et al. [Karkus_DAN19] formulate the IRL problem as a POMDP [ASTROM_POMDP1965], including the robot pose and environment map in the state. Since a naïve representation of the occupancy distribution may require exponential memory in the map size, the authors assume partial knowledge of the environment (the structure of a building is known but the furniture placement is not). A control policy is obtained via the SARSOP [Kurniawati_SARSOP08] algorithm, which approximates the cost-to-go function only over an optimally reachable space. Gupta et al. [Gupta_CMP17] address visual navigation in partially observed environments while using hierarchical VIN as the planner. Khan et al. [Khan_MACN18] introduce a memory module to VIN to address partial observability.

Many IRL algorithms rely on dynamic programming, including VIN and derivatives [Gupta_CMP17, Khan_MACN18], which requires updating cost-to-go estimates over all possible states. Our insight is that in partially observable environments, the cost-to-go estimates need to be updated and differentiated only over a subset of states. Inspired by [Ratliff_06], we obtain cost-to-go estimates only over promising states using a motion planning algorithm. This helps to obtain a closed-form subgradient of the cost-to-go with respect to the learned cost function from the optimal trajectory. While Ratiff et al. [Ratliff_06] exploit this observation in fully observable environments, none of the works focusing on partial observability take advantage of this. Our work differs from closely related works in Table I. In summary, we offer two contributions illustrated in Fig. 1: Firstly, we develop a non-stationary cost function representation composed of a probabilistic occupancy map encoder, with recurrent dependence on the observation sequence, and a cost encoder, defined over the occupancy features (Sec. III). Secondly, we optimize the cost parameters using a closed-form subgradient of the cost-to-go obtained only over a subset of promising states (Sec. IV).

$↓$ Reference \Feature $\to$	POE	PBB	DNN	CfG
VIN [Tamar_VIN16]	✗	✗	✓	✗
CMP [Gupta_CMP17]	✓	✗	✓	✗
MaxEntIRL [Ziebart_MaxEnt08]	✗	✗	✗	✓
MaxMarginIRL [Ratliff_06]	✗	✓	✗	✓
DAN [Karkus_DAN19]	✓ $^{†}$	✗	✓	✗
Ours	✓	✓	✓	✓

TABLE I: Comparison with closely related work based on the use of Partially Observable Environments (POE), Partial Bellman Backups (PBB), Deep Neural Network (DNN) representation, and Closed-form Gradients (CfG). PBB refers to computing and differentiating values over a subset of promising states as opposed to the whole state space.

^{†}

DAN [Karkus_DAN19] works with uncertainty only on the robot or furniture location, while the main environment structure is known.

Ii Problem Formulation

Consider a robot navigating in an unknown environment with the task of reaching a goal state $x_{g} \in X$ . Let $x_{t} \in X$ be the robot state, capturing its pose, twist, etc., at discrete time $t$ . For a given control input $u_{t} \in U$ where $U$ is assumed finite, the robot state evolves according to known deterministic dynamics: $x_{t + 1} = f (x_{t}, u_{t})$ . Let $m^{*} : X \to {- 1, 1}$ be a function specifying the true occupancy of the environment by labeling states as either feasible ( $- 1$ ) or infeasible ( $1$ ) and let $M$ be the space of possible environment realizations $m^{*}$ . Let $c^{*} : X \times U \times M \to R_{\geq 0}$ be a cost function specifying desirable robot behavior in a given environment, e.g., according to an expert user or an optimal design. We assume that the robot does not have access to either the true occupancy map $m^{*}$ or the true cost function $c^{*}$ . However, the robot is able to make observations $z_{t} \in Z$ (e.g., using a lidar scanner or a depth camera) of the environment in its vicinity, whose distribution depends on the robot state $x_{t}$ and the environment $m^{*}$ . Given a training set $D := {(x_{t, n}, u_{t, n}^{*}, z_{t, n}, x_{g, n})}_{t, n}^{T_{n}, N}$ of $N$ expert trajectories with length $T_{n}$ to demonstrate desirable behavior, our goal is to

learn a cost function estimate $c_{t} : X \times U \times Z^{t} \times Θ \to R_{\geq 0}$ that depends on an observation sequence $z_{1 : t}$ from the true latent environment and is parameterized by $θ$ ,
derive a stochastic policy $π_{t}$ from $c_{t}$ such that the robot behavior under $π_{t}$ matches the prior experience $D$ .

To balance exploration in partially observable environments with exploitation of promising controls, we specify $π_{t}$ as a Boltzmann policy [Ramachandran_BayesianIRL07, Neu_Apprenticeship12] associated with the cost $c_{t}$ :

π_{t} (u_{t} | x_{t}; z_{1 : t}, θ) = \frac{exp (- Q_{t}^{*} (x_{t}, u_{t}; z_{1 : t}, θ))}{\sum_{u \in U} exp (- Q_{t}^{*} (x_{t}, u; z_{1 : t}, θ))},

(1)

where the optimal cost-to-go function $Q_{t}^{*}$ is:

	$Q_{t}^{*} (x_{t}, u_{t}; z_{1 : t}, θ) := min u_{t + 1 : T - 1}$	$T - 1 \sum k = t c_{t} (x_{k}, u_{k}; z_{1 : t}, θ)$		(2)
	s.t.	$x_{k + 1} = f (x_{k}, u_{k}), x_{T} = x_{g} .$

Problem.

Given demonstrations $D$ , optimize the cost function parameters $θ$ so that log-likelihood of the demonstrated controls $u_{t, n}^{*}$ is maximized under the robot policies $π_{t, n}$ :

min θ L (θ) := - N \sum n = 1 T_{n} \sum t = 1 log π_{t, n} (u_{t, n}^{*} | x_{t, n}; z_{1 : t}, θ) .

(3)

The problem setup is illustrated in Fig. 1. While Eqn. (2) is a standard deterministic shortest path (DSP) problem, the challenge is to make it differentiable with respect to $θ$ . This is needed to propagate the loss in (3) back through the DSP problem to update the cost parameters $θ$ . Once the parameters are optimized, the robot can generalize to navigation tasks in new partially observable environments by evaluating the cost $c_{t}$ based on the observations $z_{1 : t}$ iteratively and (re)computing the associated policy $π_{t}$ .

Iii Cost Function Representation

Fig. 2: Neural network model of a cost function representation. A Bayes filter with likelihood function parameterized by

ψ

, takes in sequential observations

z_{1 : t}

and outputs a latent map representation

h_{t}

. A convolutional neural network, parameterized by

ϕ

, extracts features from the map state to specify the cost

c_{t}

at a given robot state-control pair

(x, u)

. The learnable parameters are

θ = {ψ, ϕ}

We propose a cost function representation comprised of two components: a map encoder and a cost encoder.

The map encoder incrementally updates a hidden state $h_{t}$ using the most recent observation $z_{t}$ obtained from robot state $x_{t}$ . For example, a Bayes filter with likelihood function parameterized by $ψ$ can convert the sequential input $(x_{1 : t}, z_{1 : t})$ into a fixed-sized hidden state $h_{t + 1}$ :

h_{t + 1} = BF (h_{t}, x_{t}, z_{t}; ψ) .

(4)

The cost encoder uses the latent environment map $h_{t}$ to define the cost function estimate $c_{t} (x, u)$ at a given state-control pair $(x, u)$ . A convolutional neural network (CNN) [Goodfellow-et-al-2016] with parameters $ϕ$ can extract cost features from the environment map:

c_{t} (x, u) = CNN (h_{t}, x, u; ϕ) .

(5)

This conceptual model, combining recurrent estimation of a hidden environment state, followed by feature extraction to define the cost at

(x, u)

is illustrated in Fig. 2. The model is differentiable by design, allowing its parameters

θ = {ψ, ϕ}

to be optimized. We propose an instantiation of this general model, specific to modeling occupancy costs from depth measurements in robot navigation tasks.

Iii-a Map Encoder

We encode the occupancy probability of different environment areas into a hidden state

h_{t}

. In detail, we discretize

X

into

N

cells and let

m^{*} \in {- 1, 1}^{N}

be the vector of true occupancy values over the cells. Since

m^{*}

is unknown to the robot, we maintain the occupancy likelihood

P (m^{*} = 1 | x_{1 : t}, z_{1 : t})

given the history of states

x_{1 : t}

and observations

z_{1 : t}

. See Fig. 3 for an example of a depth measurement

z_{t}

and associated occupancy likelihood over the map

m^{*}

. The representation complexity may be simplified significantly if one assumes independence among the map cells

m_{j}^{*}

P (m^{*} = 1 | x_{1 : t}, z_{1 : t}) = N \prod j = 1 P (m_{j}^{*} = 1 | x_{1 : t}, z_{1 : t}) .

(6)

We use inspiration from occupancy grid mapping [Thrun_PR05, Hornung_Octomap13] to design recurrent updates for the occupancy probability of each cell $m_{j}^{*}$ . Since $m_{j}^{*}$

is binary, its likelihood update can be simplified by defining the log-odds ratio of occupancy:

ht,j\vcentcolon=logP(m∗j=1|x1:t,z1:t)P(m∗j=−1|x1:t,z1:t).

(7)

The recurrent Bayesian update of $h_{t, j}$ is:

h_{t + 1, j} = h_{t, j} + log \frac{p (z_{t + 1} | m_{j}^{*} = 1, x_{t + 1})}{p (z_{t + 1} | m_{j}^{*} = - 1, x_{t + 1})},

(8)

where the increment is a log-odds observation model. The occupancy posterior can be recovered from the occupancy log-odds ratio $h_{t, j}$

via a sigmoid function:

(9)

The sigmoid function satisfies the following properties:

σ (x) = \frac{1}{1 + e^{- x}}, 1 - σ (x) = σ (- x), log \frac{σ (x)}{σ (- x)} = x

(10)

Fig. 3: A robot (green) navigating in a 2-D grid environment. The true environment (left) is a $16 \times 16$ grid where black regions are obstacles and white regions are free. On the right, the noisy lidar beams with endpoints in red have maximum range $2.5$ . The robot estimates the occupancy probability through an inverse observation model in Eqn (14) (darker means higher probability of occupancy).

To complete the recurrent occupancy model design, we parameterize the log-odds observation model:

log \frac{p (z | m_{j}^{*} = 1, x)}{p (z | m_{j}^{*} = - 1, x)} = log \frac{P (m_{j}^{*} = 1 | z, x)}{P (m_{j}^{*} = - 1 | z, x)}      g_{j} (x, z) - h_{0, j}

(11)

where Bayes rule was used to represent it in terms of an inverse observation model $g_{j} (x, z)$ and a prior occupancy log-odds ratio $h_{0, j}$ , whose value may depend on the environment (e.g., $h_{0, j} = 0$ specifies a uniform prior over occupied and free cells). Note that map cells $m_{j}^{*}$ outside of the sensor field of view at time $t$ are not affected by $z_{t}$ , in which case $g_{j} (x_{t}, z_{t}) = h_{0, j}$ . Now, consider a cell $m_{j}^{*}$ along the direction of the $k$ -th sensor ray, whose depth measurement is $z_{t, k}$ . Let $d (x_{t}, m_{j}^{*})$ be the distance between the robot position and the center of mass of cell $m_{j}^{*}$ . We model the occupancy likelihood of $m_{j}^{*}$ as a truncated sigmoid around the true distance $d (x_{t}, m_{j}^{*})$ :

P (m_{j}^{*} = 1 | x_{t}, z_{t, k}) = {\begin{matrix} σ (ψ_{k} δ z_{t, k}) & if δ z_{t, k} \leq ϵ σ (h_{0, j}) & if δ z_{t, k} > ϵ \end{matrix},

(12)

where $ψ_{k}$ is a learnable parameter, $δ z_{t, k} := d (x_{t}, m_{j}^{*}) - z_{t, k}$ , and $ϵ$ is a distance threshold on the influence of the $k$ -th sensor ray on the occupancy of cells around the point of reflection. Using (10), this implies the following log-odds inverse sensor model for cells $m_{j}^{*}$ along the $k$ -th sensor ray:

g_{j} (x_{t}, z_{t}) = {\begin{matrix} ψ_{k} δ z_{t, k} & if δ z_{t, k} \leq ϵ h_{0, j} & otherwise \end{matrix},

(13)

This model suggests that one may also use a more expressive multi-layer neural network in place of the linear transformation

ψ_{k} δ z_{t, k}

of the distance differential along the

k

-th ray:

g_{j} (x_{t}, z_{t}) = {\begin{matrix} NN (z_{t, k}, d (x_{t}, m_{j}^{*}); ψ_{k}) & if δ z_{t, k} \leq ϵ h_{0, j} & otherwise \end{matrix}

(14)

In summary, the map encoder starts with prior occupancy log-odds $h_{0}$ , updates them recurrently via:

h_{t + 1} = h_{t} + g (x_{t}, z_{t}; ψ) - h_{0},

(15)

where the log-odds inverse sensor model $g_{j} (x_{t}, z_{t}; ψ_{k})$ is specified for the $j$ -th cell along the $k$ -th ray in (14), and provides the cell occupancy likelihood in (9) as output.

Iii-B Cost Encoder

Given a state-control pair $(x, u)$ , the cost encoder uses the output $σ (h_{t})$ of the map encoder to obtain a cost function estimate $c_{t} (x, u)$ . A complex interacting structure over the feature representation $σ (h_{t})$ can be obtained via a deep neural network with parameters $ϕ$ . Wulfmeier et al. [Wulfmeier_DeepMaxEnt16]

proposed several CNN architectures, including pooling and residual connections of fully convolutional networks, to model

c_{t} (x, u)

from

σ (h_{t})

. While complex architecture may provide better performance in practice, we also develop a simpler model for comparison using the inductive bias of obstacle avoidance in robot navigation.

Let $s$ and $l$ be a small and large positive parameter, respectively. The cost of applying control $u$ in robot state $x$ can be modeled as large when the transition $f (x, u)$ encounters an obstacle and as small otherwise:

c (x, u) := {\begin{matrix} s & if m^{*} (x) = - 1 % and m^{*} (f (x, u)) = - 1 l & if m^{*} (x) = 1 or m^{*} (f (x, u)) = 1 \end{matrix}

Since $m^{*}$ is unknown, we use the estimated occupancy probabilities $σ (h_{t})$ to compute the expectation of $c (x, u)$ over $m^{*}$ :

	$c_{t} (x, u) :=$	$E [c (x, u)] = s σ (h_{t} [x]) σ (h_{t} [f (x, u)])$		(16)
		$+ l (1 - σ (h_{t} [x]) σ (h_{t} [f (x, u)])),$		(16)

where $h_{t} [x]$ is the entry of the map encoder state that corresponds to the environment cell containing $x$ . This simple cost encoder has parameters $ϕ := [s, l]^{T}$ and its output $c_{t} (x, u)$ is differentiable with respect to $ϕ$ and $ψ$ through $σ (h_{t})$ .

Iv Cost Learning via Differentiable Planning

We focus on optimizing the parameters $θ$ of the cost representation $c_{t} (x, u; z_{1 : t}, θ)$ developed in Sec. III. Since the true cost $c^{*}$

is not directly observable, we need to differentiate the loss function

L (θ)

in (3), which, in turn, requires differentiating through the DSP problem in (2) with respect to the cost function estimate

c_{t}

Value Iteration Networks (VIN) [Tamar_VIN16] shows that $T$ iterations of the value iteration algorithm can be approximated by a neural network with $T$ convolutional and minpooling layers. This allows VIN to be differentiable with respect to the stage cost. While VIN can be modified to operate with a finite horizon and produce a non-stationary policy, it would still be based on full Bellman backups (convolutions and min-pooling) over the entire state space. As a result, VIN scales poorly with the state-space size, while it might not even be necessary to determine the optimal cost-to-go $Q_{t}^{*} (x, u)$ at every state $x \in X$ and control $u \in U$ in the case of partially observable environments.

Instead of using dynamic programming to solve the DSP (2), any motion planning algorithm (e.g., A* [ARA], RRT [Lavalle_RRT98, Karaman_RRTstar11], etc.) that returns the optimal cost-to-go $Q_{t}^{*} (x, u)$ over a subset of the state-control space provides an accurate enough solution. For example, a backwards A* search applied to problem (2) with start state $x_{g}$ , goal state $x \in X$ , and predecessors expansions according to the motion model $f$ provides an upper bound to the optimal cost-to-go:

	$Q_{t}^{*} (x, u)$	$= c_{t} (x, u) + g (f (x, u))$	$\forall f (x, u)$	$\in CLOSED,$
	$Q_{t}^{*} (x, u)$	$\leq c_{t} (x, u) + g (f (x, u))$	$\forall f (x, u)$	$\notin CLOSED,$

where $g$ are the values computed by A* for expanded nodes in the CLOSED list and visited nodes in the OPEN list. Thus, a Boltzmann policy $π_{t} (u ∣ x)$ can be defined using the $g$ -values returned by A* for all $x \in CLOSED \cup OPEN \subseteq X$

and a uniform distribution over

U

for all other states

x

. A* would significantly improves the efficiency of VIN [Tamar_VIN16] or other full backup Dynamic Programming variants by performing local Bellman backups on promising states (the CLOSED list).

In addition to improving the efficiency of the forward computation of $Q_{t}^{*} (x, u)$ , using a planning algorithm to solve (2) is also more efficient in back-propagating errors with respect to $θ$ . In detail, using the subgradient method [Shor_Subgradient12, Ratliff_06] to optimize $L (θ)$ leads to a closed-form (sub)gradient of $Q_{t}^{*} (x_{t}, u_{t})$ with respect to $c_{t} (x, u)$ , removing the need for back-propagation through multiple convolutional or min-pooling layers. We proceed by rewriting $Q_{t}^{*} (x_{t}, u_{t})$ in a form that makes its subgradient with respect to $c_{t} (x, u)$ obvious. Let $T (x_{t}, u_{t})$ be the set of feasible state-control trajectories $τ := x_{t}, u_{t}, x_{t + 1}, u_{t + 1}, \dots, x_{T - 1}, u_{T - 1}$ starting at $x_{t}$ , $u_{t}$ and satisfying $x_{k + 1} = f (x_{k}, u_{k})$ for $k = t, \dots, T - 1$ with $x_{g} = x_{T}$ . Let $τ^{*} \in T (x_{t}, u_{t})$ be an optimal trajectory corresponding to the optimal cost-to-go function $Q_{t}^{*} (x_{t}, u_{t})$ of a deterministic shortest path problem, i.e., the controls in $τ^{*}$ satisfy the additional constraint $u_{k} = arg {min}_{u \in U} Q_{t}^{*} (x_{k}, u)$ for $k = t + 1, \dots, T - 1$ . Let $μ_{τ} (x, u) := \sum_{k = t}^{T - 1} 1_{(x_{k}, u_{k}) = (x, u)}$ be a state-control visitation function indicating if $(x, u)$ is visited by $τ$ . With these definitions, we can view the optimal cost-to-go function $Q_{t}^{*} (x_{t}, u_{t})$ as minimum over $T (x_{t}, u_{t})$ of the inner product of the cost function $c_{t}$ and the visitation function $μ_{τ}$ :

Q_{t}^{*} (x_{t}, u_{t}) = min τ \in T (x_{t}, u_{t}) \sum x \in X, u \in U c_{t} (x, u) μ_{τ} (x, u)

(17)

where $X$ can be assumed finite because both $T$ and $U$ are finite. This form allows us to (sub)differentiate $Q_{t}^{*} (x_{t}, u_{t})$ with respect to $c_{t} (x, u)$ for any $x \in X$ , $u \in U$ .

Lemma 1.

Let $f (x, y)$ be differentiable and convex in $x$ . Then, $\nabla_{x} f (x, y^{*})$ , where $y^{*} := arg {min}_{y} f (x, y)$ , is a subgradient of the piecewise-differentiable convex function $g (x) := {min}_{y} f (x, y)$ .

Applying Lemma 1 to (17) leads to the following subgradient of the optimal cost-to-go function:

\frac{\partial Q_{t}^{*} (x_{t}, u_{t})}{\partial c_{t} (x, u)} = μ_{τ^{*}} (x, u),

(18)

which can be obtained from the optimal trajectory $τ^{*}$ corresponding to $Q_{t}^{*} (x_{t}, u_{t})$

. This result and the chain rule allow us to obtain the complete (sub)gradient of

L (θ)

Proposition 1.

A subgradient of the loss function $L (θ)$ in (3) with respect to the cost function parameters $θ$ can be obtained as follows:

	$\frac{d L (θ)}{d θ} = - N \sum n = 1 T_{n} \sum t = 1 \frac{d log π_{t, n} (u_{t, n}^{*} ∣ x_{t, n})}{d θ}$		(19)
	$= - N \sum n = 1 T_{n} \sum t = 1 \sum u_{t, n} \in U \frac{\partial log π_{t, n} (u_{t, n}^{} ∣ x_{t, n})}{\partial Q_{t, n}^{} (x_{t, n}, u_{t, n})} \frac{d Q_{t, n}^{*} (x_{t, n}, u_{t, n})}{d θ}$

where the first term has a closed-form, while the second term is available from (18) and the cost representation in Sec. III:

	$\frac{\partial log π_{t, n} (u_{t, n}^{} ∣ x_{t, n})}{\partial Q_{t, n}^{} (x_{t, n}, u_{t, n})} = (1_{{u_{t, n} = u_{t, n}^{*}}} - π_{t, n} (u_{t, n} \| x_{t, n}))$
	$\frac{d Q_{t, n}^{} (x_{t, n}, u_{t, n})}{d θ} = \sum (x, u) \in τ^{} \frac{\partial Q_{t, n}^{*} (x_{t, n}, u_{t, n})}{\partial c_{t} (x, u)} \frac{\partial c_{t} (x, u)}{\partial θ}$		(20)

The computation graph structure implied by Prop. 1 is illustrated in Fig. 1. The graph consists of a cost representation layer and a differentiable planning layer, allowing end-to-end minimization of $L (θ)$ via stochastic (sub)gradient descent. Full algorithms for the training and testing phases (Fig. 1) are shown in Alg. 1 and Alg. 2.

Although the form of the gradient in Prop. 1 is similar to that in Ziebart et al. [Ziebart_MaxEnt08], our contributions are orthogonal. Our contribution is to obtain a non-stationary cost-to-go function and its (sub)gradient for a finite-horizon problem using forward and backward computations that scale efficiently with the size of the state space. On the other hand, the results of Ziebart et al. [Ziebart_MaxEnt08] provide a stationary cost-to-go function and its gradient for an infinite horizon problem. The maximum entropy formulation of the stationary policy is a well grounded property of using a soft version of the Bellman update, which can explicitly model the suboptimality of expert trajectories. However, we can show the benefits of our approach without including the maximum entropy formulation and will leave it as future work.

1:Input: Demonstrations

D = {(x_{t, n}, u_{t, n}^{*}, z_{t, n}, x_{g, n})}_{t, n}^{T_{n}, N}

2:while

θ

not converged do

L (θ) \leftarrow 0

4: for

n = 1, \dots, N

and

t = 1, \dots, T_{n}

5: Update

c_{t, n}

based on

x_{t, n}

and

z_{t, n}

as in Sec. III

6: Obtain

Q_{t, n}^{*} (x, u)

from DSP (2) with stage cost

c_{t, n}

7: Obtain

π_{t, n} (u | x_{t, n})

from

Q_{t, n}^{*} (x_{t, n}, u)

via Eq. (1)

L (θ) \leftarrow L (θ) - log π_{t, n} (u_{t, n}^{*} | x_{t, n})

9: Update

θ \leftarrow θ - α \nabla L (θ)

via Prop. 1

10:Output:

θ

Algorithm 1 Training: learn cost function parameters

θ

1:Input: Start state

x_{s}

, goal state

x_{g}

, optimized

θ

2:Current state

x_{t} \leftarrow x_{s}

3:while

x_{t} \neq x_{g}

4: Make an observation

z_{t}

5: Update

c_{t}

based on

x_{t}

and

z_{t}

as in Sec. III

6: Obtain

Q_{t}^{*} (x_{t}, u)

u \in U

from DSP (2) with stage cost

c_{t}

7: Obtain

π_{t} (u | x_{t})

from

Q_{t}^{*} (x_{t}, u)

via Eq. (1)

8: Update

x_{t} \leftarrow f (x_{t}, u_{t})

via

u_{t} := arg {max}_{u} π_{t} (u | x_{t})

9:Output: Navigation succeeds or fails.

Algorithm 2 Testing: compute control policy for learned

θ

V Experiments

Fig. 4: Validation and test results for the $16 \times 16$ and $100 \times 100$ grid world domains. Cross entropy loss (3) and prediction accuracy for the validation set are reported. Test trajectories are iteratively rolled out from the non-stationary policy $π_{t}$
. A trial is classified as successful if the goal is reached without collisions within twice the number of steps of a shortest path in the groundtruth enviroment.
Ours-CNN is capable of matching the expert demonstrations while generalizing to new robot navigation tasks in test time. Right: Plot showing the effect of noise on the accuracy of Ours-CNN model.

Fig. 5: Examples of occupancy estimation, A* motion planning and subgradient computation during a successful test trajectory. The first figure shows the true occupancy map

m^{*}

with the robot start and goal locations in green and magenta, respectively. The second and third figures show the current lidar observation

z_{t}

in red and robot trajectory thus far

x_{1 : t}

in green. The map occupancy estimate

σ (h_{t})

in grayscale is in the background. The optimal cost-to-go estimate

g

from A* is shown in a blue-yellow colormap in the foreground (brighter means higher cost-to-go). The optimal trajectories

τ^{*}

in cyan corresponding to

Q_{t}^{*} (x_{t}, u_{t})

are obtained during A* planning for subgradient computation in Eqn. (18). The last figure shows the final successful trajectory in green and an optimal shortest path in the fully observable enviroment in blue.

We evaluate our approach in 2D grid world navigation tasks at two scales. Obstacle configurations are generated randomly in maps $m_{n}^{*}$ of sizes $16 \times 16$ or $100 \times 100$ . We use an 8-connected grid so that a control $u_{t}$ causes a transition $x_{t + 1} = f (x_{t}, u_{t})$ from $x_{t}$ to one of the eight neighbor cells $x_{t + 1}$ . At each step, the robot receives a $360^{\circ}$ lidar scan $z_{t}$ at $5^{\circ}$ resolution, resulting in $72$ beams $z_{t, k}$ in each scan (see Fig. 3

). The lidar range readings are corrupted by an additive zero mean Gaussian noise. The standard deviation of the noise is

0.05

and

0.2

(grid cell = 1) and the lidar maximum range is

2.5

and

10

16 \times 16

and

100 \times 100

domains, respectively. Note that the lidar range is smaller than the map size to demonstrate environment partial observability. During test time, the domain size is the maximum size allowed for the observed area along a trajectory. Demonstrations are obtained by running an A* planning algorithm to solve the deterministic shortest path problem on the true map

m_{n}^{*}

. The number of maps and training samples generated are shown in Table II.

	$16 \times 16$		$100 \times 100$
Dataset	#maps	#samples	#maps	#samples
Train	7638	514k	970	460k
Validation	966	66k	122	58k
Test	952	-	122	-

TABLE II: Dataset size. We sample 10 trajectories in each map in training and validation, and each sample takes the form

(x_{1 : t, n}, u_{t, n}^{*}, z_{1 : t, n}, x_{g, n})

. In testing, the robot’s task is to navigate from one randomly sampled start to goal location on each map.

V-a Baseline and model variations

We use DeepMaxEnt [Wulfmeier_DeepMaxEnt16] as a baseline and compare it to three variants of our model. In all variants, we parameterize an inverse observation model and use the log-odds update rule in Eqn. (13) as the map encoder. This map encoder is sufficiently expressive to model occupancy probability from lidar observations in a 2D enviroment. The A* algorithm is used to solve the DSP (2), providing the optimal cost-to-go $Q_{t}^{*} (x, u)$ for $x \in CLOSED \cup OPEN$ and a subgradient of $Q_{t}^{*} (x_{t}, u_{t})$ according to (18

). All the neural networks are implemented in the PyTorch library

[Paszke_Pytorch17] and trained with the Adam optimizer [Kingma_ADAM14] until convergence.

DeepMaxEnt uses a neural network to learn a cost function directly from lidar observations without explicitly having a map representation. The neural network in our experiments is the “Standard FCN” in [Wulfmeier_DeepMaxEnt16] in the $16 \times 16$ domain, and the encoder-decoder architecture in [SegNet] in the $100 \times 100$ domain. Value iteration is approximated by a finite number of Bellman backup iterations, equal to the map size. The experiments in the original DeepMaxEnt paper [Wulfmeier_DeepMaxEnt16]

use the mean and variance of the height of the 3D lidar points in each cell, as well as a binary indicator of cell visibility, as input features to the neural network. Since our synthetic experiments are set up in 2D, the count of lidar beams in each cell is used as replacement of the height mean and variance. This is a fair adaptation because Wulfmeier et. al.

[Wulfmeier_DeepMaxEnt16] argued that obstacles generally represent areas of larger height variance which means more beam counts in our observations.

Ours-HCE stands for hard-coded cost encoder. This simple variant of our model uses Eqn. (16) with $s = 1$ and $l = 100$ set explicitly as constants.

Ours-SCE stands for soft-coded cost encoder and has $s$ and $l$ in Eqn (16) as learnable parameters.

Ours-CNN is our most generic variant using a convolutional neural network as cost encoder. The network architecture is the same as in DeepMaxEnt for fair comparison.

V-B Experiments and Results

Model generalization

Fig 4 shows the comparison of multiple measures of accuracy for different algorithms. Both Ours-HCE and Ours-SCE explicitly incorporate cell traversability through the cost design in (16). Test results show that this explicit cost encoder is successful at obstacle avoidance, regardless of whether the parameters $s$ , $l$ are constants in Ours-HCE or learnable in Ours-SCE. The performance of Ours-HCE also shows that the map encoder is learning a correct map representation from the noisy lidar observations since the only trainable parameters are $ψ$ in the inverse observation model (13). However, both models fail at matching demonstrations in validation because the cost encoder (16) emphasizes obstacle avoidance explicitly, leaving little capacity to learn from demonstrations. Ours-CNN combines the strength of learning from demonstrations and generalization to new navigation tasks while avoiding obstacles. Its validation results are on par with DeepMaxEnt, showing the validity of the closed-form subgradient in (18). Ours-CNN significantly outperforms DeepMaxEnt in new tasks at test time. The performance gap of DeepMaxEnt in the two domains shows that a general CNN architecture applied directly to the lidar scan measurements is not as effective as the map encoder in Ours-CNN at modeling occupancy probability. Fig 5 shows the map occupancy estimation, as well as the optimal trajectories necessary for subgradient computation in Sec IV.

Robustness to noise

The robustness of Ours-CNN to the observation noise is evaluated in the $16 \times 16$ domain. Fig 4 shows that the performance degrades as the noise increases but our inverse observation model (13) still generalizes well considering that noise with standard deviation of $0.5$ is significant when the lidar range is only $2.5$ .

Computational efficiency

Finally, we compare the efficiency of a forward pass through our A* planner and the value iteration algorithm in DeepMaxEnt. The A* algorithm in our models is implemented in C++ and evaluated on a CPU. The VI algorithm is implemented using convolutional and minpooling layers in Pytorch as described in [Tamar_VIN16] and is evaluated on a GPU. We record the time that each models takes to return a policy $π_{t}$ given a cost function $c_{t}$ . Our A* algorithm takes only $0.02$ ms as compared to VI’s $0.2$ ms on the $16 \times 16$ map. In the $100 \times 100$ domain, our A* algorithm takes $0.6$ ms, compared to VI’s $14$ ms, illustrating the scalability of our model in the size of the state space.

Vi Conclusion

We proposed an inverse reinforcement learning approach for infering navigation costs from demonstration in partially observable enviroments. Our model introduces a new cost representation composed of a probabilistic occupancy encoder and a cost encoder defined over the occupancy features. We showed that a motion planning algorithm can compute optimal cost-to-go values over the cost representation, while the cost-to-go (sub)gradient may be obtained in closed-form. Our work offers a promising model for encoding occupancy features in navigation tasks and may enable efficient online learning in challenging operational conditions.

Learning Navigation Costs from Demonstration in Partially Observable Environments

Authors

Learning Navigation Costs from Demonstration with Semantic Observations

Inverse reinforcement learning for autonomous navigation via differentiable semantic mapping and planning

Model Predictive Path Integral Control Framework for Partially Observable Navigation: A Quadrotor Case Study

A genetic algorithm for autonomous navigation in partially observable domain

Decentralized Structural-RNN for Robot Crowd Navigation with Deep Reinforcement Learning

A neurally plausible model learns successor representations in partially observable environments

Multiagent Rollout and Policy Iteration for POMDP with Application to Multi-Robot Repair Problems

I Introduction

Ii Problem Formulation

Problem.

Iii Cost Function Representation

Iii-a Map Encoder

Iii-B Cost Encoder

Iv Cost Learning via Differentiable Planning

Lemma 1.

Proposition 1.

V Experiments

V-a Baseline and model variations

V-B Experiments and Results

Model generalization

Robustness to noise

Computational efficiency

Vi Conclusion

References

Learning Navigation Costs from Demonstration in Partially Observable Environments

Authors

Learning Navigation Costs from Demonstration with Semantic Observations

Inverse reinforcement learning for autonomous navigation via differentiable semantic mapping and planning

Model Predictive Path Integral Control Framework for Partially Observable Navigation: A Quadrotor Case Study

A genetic algorithm for autonomous navigation in partially observable domain

Decentralized Structural-RNN for Robot Crowd Navigation with Deep Reinforcement Learning

A neurally plausible model learns successor representations in partially observable environments

Multiagent Rollout and Policy Iteration for POMDP with Application to Multi-Robot Repair Problems

This week in AI

I Introduction

Ii Problem Formulation

Problem.

Iii Cost Function Representation

Iii-a Map Encoder

Iii-B Cost Encoder

Iv Cost Learning via Differentiable Planning

Lemma 1.

Proposition 1.

V Experiments

V-a Baseline and model variations

V-B Experiments and Results

Model generalization

Robustness to noise

Computational efficiency

Vi Conclusion

References