Learning robotic navigation from experience: principles, methods and recent results

Abstract

Navigation is one of the most heavily studied problems in robotics and is conventionally approached as a geometric mapping and planning problem. However, real-world navigation presents a complex set of physical challenges that defies simple geometric abstractions. Machine learning offers a promising way to go beyond geometry and conventional planning, allowing for navigational systems that make decisions based on actual prior experience. Such systems can reason about traversability in ways that go beyond geometry, accounting for the physical outcomes of their actions and exploiting patterns in real-world environments. They can also improve as more data is collected, potentially providing a powerful network effect. In this article, we present a general toolkit for experiential learning of robotic navigation skills that unifies several recent approaches, describe the underlying design principles, summarize experimental results from several of our recent papers, and discuss open problems and directions for future work.

This article is part of the theme issue ‘New approaches to 3D vision’.

1. Introduction

Navigation represents one of the most heavily studied topics in robotics [1]. It is often approached in terms of mapping and planning: constructing a geometric representation of the world from observations, then planning through this model using motion planning algorithms [2–4]. However, such geometric approaches abstract away significant physical and semantic aspects of the navigation problem that, in practice, leave a range of real-world situations difficult to handle (see figure 1). These challenges require special handling, resulting in complex systems with many components. Some works have sought to incorporate machine learning techniques to either learn navigational skills from simulation or to learn perception systems for navigation for human-provided labels. In this article, we instead argue that learned navigational models, trained directly on real-world experience rather than human-provided labels or simulators, provide the most promising long-term direction for a general solution to navigation. We refer to such learning approaches as experiential learning, because they learn directly from past experience of performing real-world navigation. As we will discuss in §2, such methods relate closely to reinforcement learning (RL).

Figure 1.

Learning-based methods can handle situations that violate the assumptions of geometric methods: sometimes obstacles that geometrically appear to block the robot’s path, such as tall grass, are actually traversable (a), and sometimes seemingly solid ground is actually not traversable, as in the case of mud or sand traps (b). Unlike geometry-based methods [5], which plan through 3D reconstructions of the environment (c), experiential learning methods [6] learn to determine from raw sensory observations which features are traversable and which are not (d). This, together with their ability to improve as more data is collected, makes such techniques a powerful choice for real-world navigation.

Geometry-based methods for navigation, based on mapping and planning, are appealing in large part because they simplify the navigation problem into a concise geometric abstraction: if the 3D shape of the environment can be inferred from observations, this can be used to construct an accurate geometric model, a path to the destination can be planned within this model, and that path can then be executed in the real world. However, although some idealized environments fit neatly into this geometric abstraction, real-world settings have a tendency to confound it. Obstacles are not always rigid impassable barriers (e.g. tall grass), and areas that appear geometrically passable might not be (e.g. mud, foliage, etc.). Real-world environments also exhibit patterns that are not used by purely geometric approaches: roads often (but not always) intersect at right angles, city blocks tend to be of equal size, and buildings are often rectangular. Such patterns can lead to convenient shortcuts and intuitive behaviours that are often exploited by humans.

Machine learning can offer an appealing toolkit for addressing these complex situations and exploiting such patterns, but the many different ways of utilizing machine learning for navigation come with very different trade-offs. In this article, we will focus specifically on experiential learning, where a robot learns how to navigate directly from real-world navigation data. We can contrast this with four other types of approaches: (1) methods that utilize learning to handle semantic aspects of navigation, typically based on computer vision with human-provided labels [7–10]; (2) methods that utilize learning to assist in 3D mapping, which is then integrated into standard geometric pipelines [11–18]; (3) methods that utilize RL in simulated environments and then employ transfer learning or domain adaptation [19–22]; (4) methods that use human-provided demonstrations to learn navigational policies [23–28].

Methods that utilize learning only for handling semantic (1) or geometric (2) perception do not address the limitations of geometry-based methods in terms of failing to understand the physical meaning of traversability and navigational affordances detailed above, though they can significantly improve the performance of geometric methods and address their limitations in regard to semantics. Such techniques can help to make conventional mapping and planning pipelines more effective by endowing them with semantics or more accurate 3D reconstruction. However, like conventional mapping techniques, they do not attempt to directly predict the physical outcome of a robot’s actions. This stands in contrast to experiential learning methods that directly learn which observations correspond to traversable or untraversable terrains or obstacles, though a number of works in robotic perception have incorporated elements of experiential learning, for example, for learning to classify traversability [29–33].

Methods based on simulation (3) are limited in that they rely on the fidelity of the simulator to learn about the situations a robot might encounter in the real world. Although simulation methods can significantly simplify the engineering of navigational systems; in the end, they kick the can down the road: instead of manually adding special cases (tall grass, mud, etc.) into the standard mapping pipeline, we must instead model all such possible conditions in the simulator. Sometimes it might be easier to simulate some phenomenon and then learn how to handle it than to design a controller for it directly. However, human insight is still needed to identify the phenomena to simulate, and human engineering is needed to build such simulations, in contrast to methods that learn from real data and therefore learn about how the world actually works. Indeed, in other domains where machine learning methods have been successfully deployed in real-world products and applications—computer vision, NLP, speech recognition, etc. [34]—such methods utilize real data precisely because such data provides the best final performance in the real world with the least amount of effort.

Methods based on human-provided demonstrations (4), which have a long history in robotic navigation [23–28,35,36], have the benefit of learning about the world as it really is, but carry a heavy price: the performance of the system is entirely limited by the number of demonstrations that are provided and does not improve with more use. In contrast, experiential learning methods [6,37–40], which may also utilize demonstration data in combination with the robot’s own experience and, crucially, do not make the assumption that all of the provided data is good (i.e. it should not be imitated blindly), offer the most appealing combination of benefits. Such methods handle the world the way it really is, learning traversability and navigational affordances directly from experience, improving as more data is collected and do not require an expert human engineer to model the long tail of scenarios and special conditions that a robot might encounter in the real world.

Algorithms that learn robotic policies from experience often employ ‘end-to-end’ learning methods [41,42]. This can either mean that the robot learns the task directly from final task outcome feedback, or that it learns directly from raw sensory perception. Both have appealing benefits, but particularly the former is a critical strength of experiential learning: only by associating actual real-world trajectories with actual real-world outcomes can a robot acquire navigational skills that are not vulnerable to the ‘leaky abstractions’ that afflict other manually designed techniques. For example, the abstraction of geometry does not capture that tall grass is traversable. The abstraction of a simulator that does not model wheel slip does not capture that wheels can become stuck in mud. By learning about real outcomes from real data, such issues can be eliminated.

At the same time, as we will discuss in §4, learned navigation systems can (and should) still employ modularity and compositionality to solve temporally extended tasks. Indeed, we will argue that effective learning systems, like conventional mapping and planning methods, should still be divided into two parts: a memory or ‘mental map’ of their environment, and a high-level planning algorithm that uses this mental map to choose a route. Conventional methods simply choose specific abstractions, such as meshes or points in Cartesian space, to represent this map, whereas learning-based methods learn a suitable abstraction from data. These learned abstractions are grounded in the things that are actually important for real-world traversability, and they improve as the robot gathers more and more experience in the environment.

The goal of this article is to provide a high-level tutorial on how navigational systems can be trained on real-world data, provide pointers to relevant recent works, and present the overall architecture that a navigational system learned from experience should have. The remainder of this article will focus on providing a high-level summary of navigation via experiential learning, algorithms for learning low-level navigational skills from data, algorithms for composing these skills to solve temporally extended navigation problems, and a brief discussion of several of our recent works that provide experimental evidence for the viability of these approaches.

2. An overview of experiential learning for navigation

The central principle behind experiential learning is to learn from the actual experience of attempting (and succeeding or failing) to perform a given task, as opposed to learning from human-provided labels, such as semantic labels provided by humans (e.g. road vs. not road), or demonstrations. Perhaps the best-known framework for experiential learning is RL [43], which formulates the problem in terms of learning to maximize reward signals through active online exploration. However, we will make a distinction between the principle of experiential learning—learning how to perform a task using experience—and the methodology prescribed by RL. This is because the primary benefits really come from the use of experience rather than the specific choice of algorithm (RL or otherwise). The particular methods in the case studies in §5 use simple supervised learning methods, though they can be seen as a particularly naïve version of offline RL [44] and could likely utilize more advanced and modern offline RL methods as well.

We can use o_t to denote the robot’s observation at time t, a_t to denote its commanded action (e.g. steering and throttle commands), and τ = {o₁, a₁, …, o_H, a_H} to denote a trajectory (i.e. a trial obtained by running the robot). The algorithm is provided with a dataset of trajectories $\mathcal{D}=\{{\tau }_i\}$, which it uses to learn. This can be done either offline, where a static dataset consisting of previously collected data is provided and the algorithm learns entirely from this dataset, or it can be done online, where the policy explores the environment, appends the resulting experience to $\mathcal{D}$, and periodically retrains the policy. The critical ingredient is the use of real trial data, not whether or not this data is collected online. The power of experiential learning comes from using real experience to understand which trajectories are possible, and which are not. For example, if $\mathcal{D}$ contains a trajectory that successfully drives through tall grass, the robot can learn that tall grass is traversable. Traversals that are not seen in the data (e.g. there is no trajectory where the robot drives through a wall) should be assumed to be impossible. Of course, this presumes a high degree of coverage in the dataset, and additional online exploration can be helpful here.

It is likely that ultimately the full benefit of experiential learning will be unlocked by combining offline and online training, as they offer complementary benefits. The central benefit of offline training is the ability to reuse large and diverse navigational datasets. In the same way that state-of-the-art models in computer vision [45] and NLP [46] achieve remarkable generalization by training on huge datasets, effective navigational systems will work best when trained on large previously collected datasets, which would be impractical to recollect online for every experiment. At the same time, a major strength of such methods is to continue to improve as more data is collected, particularly for real-world deployments where such methods can benefit from a network effect: as more robots are deployed, more data is collected, the robots become more capable, and it becomes possible to deploy more of them in more settings.

To define the task, we can assume that something in o_t indicates task completion. For example, the task might be defined by a goal o_g, or by a goal location, where the location is part of o_t. More generally, it can be defined by some reward function r(o_t) or goal set ${\mathbf{o}}_g\in \mathcal{G}$. We will assume for now that it is defined by a single goal o_g, though this requirement can be relaxed. The specific question that the learned model must be able to answer then becomes: given the current observation o_t and some goal o_g, which action a_t should the robot take to eventually reach o_g?

RL [43] and imitation learning [23,35] offer viable solutions to this problem by learning policies of the form π(a_t | o_t, o_g), as we will discuss in the next section. However, it is difficult to directly learn fully reactive policies that can reach very distant goals. Instead, we can decompose the navigation problem hierarchically: the robot should build some sort of ‘mental map’ of its surroundings, plan through this mental map, and utilize low-level navigational skills to execute this plan. Such skills might, for example, know how to navigate around a muddy puddle, cut across a grassy field, or go through a doorway in a building. But they do not reason about the longer-horizon structure of the plan, and therefore do not require memory. The role of π(a_t | o_t, o_g) is to represent such skills and, as we will discuss in the next two sections, also to provide abstractions that can be used to build the higher level ‘mental map’. This higher level, discussed in §4, can either be an explicit search algorithm, or can be defined implicitly as part of a memory-based (e.g. recurrent) neural network model [17,47–52]. This hierarchy is also present in the standard mapping and planning approach, where the geometric map represents the robot’s ‘memory’, but the abstraction (3D points) is chosen manually. Viewed in this way, a central benefit of the experiential learning approach is to learn low-level skills π(a_t | o_t, o_g) that represent navigational affordances, and then build up its higher level mapping and planning mechanisms in terms of the capabilities of these skills.

3. Learning policies from data

Training π(a_t | o_t, o_g) can be framed either as maximizing the probability that π reaches o_g, minimizing the time it takes to reach o_g, or in terms of some other metrics. In practice, methods for π(a_t | o_t, o_g) include goal-conditioned imitation [53–57] and RL [58–68] which, though seemingly different conceptually, can be cast into the same framework. An algorithm for training π(a_t | o_t, o_g) must provide an objective function $J_{\mathcal{D}}(\pi )$, which factorizes over the dataset:

$$J_{\mathcal{D}}(\pi )=\sum _{\tau \in \mathcal{D}}\sum _{t=1}^H{J}_{{\mathbf{o}}_t,{\mathbf{a}}_t,\tau }(\pi ).$$

We slightly abuse notation to index time steps in τ as o_t, a_t. In the case of supervised learning, $J_{{\mathbf{o}}_t,{\mathbf{a}}_t,\tau }$ is given by $J_{{\mathbf{o}}_t,{\mathbf{a}}_t,\tau }^{\mathrm{ML}}$:

$$J_{{\mathbf{o}}_t,{\mathbf{a}}_t,\tau }^{\mathrm{ML}}(\pi )=E_{{\mathbf{o}}_g\sim g(\tau ,t)}[\log \pi ({\mathbf{a}}_t\hspace{0.17em}|\hspace{0.17em}{\mathbf{o}}_t,{\mathbf{o}}_g)],$$

where g(τ, t) is a relabelling distribution that selects future observations in τ as possible goals. For example, g(τ, t) might uniformly sample all o_t′ where t′ > t, or select o_H or o_t+K (see figure 2). The general idea is to train the policy to imitate the actions in the trajectory when conditioned on the current observation and future observations in that same trajectory. RL algorithms typically use either an expected Q-value objective or a weighted likelihood objective given by

$$J_{{\mathbf{o}}_t,{\mathbf{a}}_t,\tau }^{\mathrm{Q}}(\pi )=E_{{\mathbf{o}}_g\sim g(\tau ,t),\mathbf{a}\sim \pi (\mathbf{a}\hspace{0.17em}|\hspace{0.17em}{\mathbf{o}}_t,{\mathbf{o}}_g)}[Q^{\pi }({\mathbf{o}}_t,{\mathbf{a}}_t,{\mathbf{o}}_g)]$$

and

$$J_{{\mathbf{o}}_t,{\mathbf{a}}_t,\tau }^{\mathrm{W}}(\pi )=E_{{\mathbf{o}}_g\sim g(\tau ,t)}[w({\mathbf{o}}_t,{\mathbf{a}}_t,{\mathbf{o}}_g)\log \pi ({\mathbf{a}}_t\hspace{0.17em}|\hspace{0.17em}{\mathbf{o}}_t,{\mathbf{o}}_g)],$$

respectively. In the case of RL, g(τ, t) can select as goals future time steps in τ, as in the case of supervised learning (‘positives’), but can also mix in observations sampled from other trajectories (‘negatives’) that are less likely to be reached, since the Q-function or weight will tell the policy that these ‘negative’ goals have low values. Prior works have discussed a wide range of different relabelling strategies and their tradeoffs [58,59,65,68]. The expected Q objective J^Q is typically used by standard actor-critic methods such as DDPG and SAC [69,70], as well as offline RL methods such as CQL [71]. The Q-function, in this case, is trained via Bellman error minimization on the same data, with offline RL methods typically including some explicit regularization to avoid out-of-distribution actions. The weighted likelihood objective J^W is used by a number of offline RL methods, such as AWR, AWAC and CRR [72–74], which utilize it to avoid out-of-distribution action queries. Typically, the weight w(o_t, a_t, o_g) is chosen to be larger for actions with large Q-values. For example, AWAC uses the weight w(o_t, a_t, o_g) = exp(Q^π(o_t, a_t, o_g) − V^π(o_t, o_g)). Further technical details can be found in prior work on goal-conditioned imitation [53–57], standard online RL [59–63,65,69,70] and offline RL [68,71–74]. For the purpose of this article, note that all three loss functions have a similar structure: they all involve selecting goals o_g using some relabelling function g(τ, t), and they all involve somehow training π(a_t | o_t, o_g) to favour those actions that reach o_g, either directly using the actions that actually led to o_g in the data in the case of J^ML, or actions that have a high value for o_g according to a separate learned Q-function.

Figure 2.

Low-level navigational policies can be trained from data by extracting tuples (o_t, a_t, o_g), where o_t is an observation along a trajectory, a_t is the corresponding action and o_g is an eventual goal that can be reached successfully after taking a_t in o_t. Both supervised learning and RL-based techniques can do this by using some sort of relabelling function g(τ, t) to select o_g during training from the remainder of the trajectory τ from which o_t was taken.

As discussed in the previous section, π(a_t | o_t, o_g) by itself will not necessarily be effective at reaching distant goals, and perhaps more importantly, it does not maintain a memory of the environment, does not attempt to map it and remember the locations of landmarks, and does not perform explicit planning (though the process of training the Q-function arguably performs amortized planning via dynamic programming during training). Therefore, it is generally only effective for short-horizon goals. In the case of navigation tasks studied in prior work with such approaches, this typically means goals that are within line of sight of the robot, or within a few tens of metres of its present location [6,38–40,64,75], though some works have explored extensions to enable significantly longer-range control in some settings, including through the use of memory and recurrence [48,51]. As a side note, o_t in general may not represent a Markovian state of the system, but only an observation. The use of recurrence mitigates this issue [76], but if we only require the policies to represent short-range skills, this issue often does not cause severe problems.

In the next section, we will discuss how planning and memory can be incorporated into a complete navigational method that uses the policies π(a_t | o_t, o_g) as local controllers. This will require an additional object besides the policy itself: an evaluation or distance function D(o_t, o_g) that additionally predicts how long π(a_t | o_t, o_g) will actually take to reach o_g from o_t (and if it will succeed at all). As discussed in prior work [58], this distance function can be extracted from a value function learned with RL. If we choose the reward to be −1 for all time steps when the goal is not reached (i.e. r(o_t, a_t, o_g) = −δ(o_t ≠ o_g)) and γ = 1, we have $D({\mathbf{o}}_t,{\mathbf{o}}_g)=-V^{\pi }({\mathbf{o}}_t,{\mathbf{o}}_g)$, though in practice it is convenient to use γ < 1. With supervised learning, this quantity can be learned by regressing onto the distances in the dataset, using the loss $E_{{\mathbf{o}}_g\sim g(\tau ,t)}[{(D({\mathbf{o}}_t,{\mathbf{o}}_g)-(t^{\prime }-t))}^2]$, where t′ is the time step in τ corresponding to o_g.

4. Planning and high-level decision making

Navigation is not just a reactive process, where a robot observes a snapshot of its environment and chooses an action. While the explicit process of exact geometric reconstruction in classic navigational methods may be obviated by learning from data, any effective navigational method likely must still retain, either explicitly or implicitly, a similar overall structure: it should acquire and remember the overall shape of the environment (though perhaps not in terms of precise geometrical detail), and it must plan through this environment to reach the final destination, while reasoning about parts of the environment that are not currently visible but were observed before and stored in memory. Indeed, it has been extensively verified experimentally that humans and animals maintain ‘mental maps’ of environments that they visit frequently [77], and these mental maps are more likely topological rather than precise geometric reconstructions. Crucially, such mental maps depend on abstractions of the environment. Precise geometric maps use coordinates of vertices or points as abstractions, but these abstractions are more detailed than necessary for high-level navigation, where we would like to make decisions like ‘turn left at the light’, and allow our low-level skills (as described in the previous section) to take care of carrying out such decisions. Thus, the problem of building effective mental maps hinges on acquiring effective abstractions.

A powerful idea in learning-based navigation is that the low-level policies π(a_t | o_t, o_g) and their distance functions D(o_t, o_g) can provide us with such abstractions. The basic principle is that D(o_t, o_g) can describe the connectivity between different observations in the environment. Given input observations of two landmarks, D(o_t, o_g) can tell us if the robot’s low-level policy π(a_t|o_t, o_g) can travel between them, which induces a graph that describes the connectivity of previously observed landmarks, as illustrated in figure 3. Thus, storing a subset of previously seen observations represents the robot’s memory of its environment, and the graph induced by edge weights obtained from D(o_i, o_j) for each pair (o_i, o_j) of stored observations then represents a kind of ‘mental map’—an abstract counterpart to the geometric map constructed by conventional SLAM (simultaneous localisation and mapping) algorithms. Searching through this graph can reveal efficient paths between any pair of landmarks. Critically, this mental map is not based on the geometric shape of the environment, but rather its connectivity according to the robot’s current navigational capabilities, as described by π(a_t | o_t, o_g) and D(o_t, o_g). Particularly in the RL setting, where D(o_t, o_g) corresponds to the value function of π(a_t | o_t, o_g), this makes it clear that the robot’s low-level capabilities effectively inform its high-level abstraction, defining both the representation of its memory (i.e. the graph) and its mechanism for high-level planning (i.e. search on this graph).

Figure 3.

Planning with learned policies. Learned distance functions, which correspond to value functions for a low-level policy, describe the connectivity structure in the environment. This provides an abstraction for high-level planning informed by the capabilities of low-level skills.

Using policies and their value functions as abstractions for search and planning has been explored in a number of prior works, both in the case of RL (where distances are value functions) [64,78] and in the case of supervised learning (where distances are learned with regression) [38,75,79–81], and we refer the reader to these prior works for technical details. However, the important ingredient is not necessarily the use of graph search, but rather the use of low-level skills to form abstractions for high-level skills. For example, it is entirely possible to dispense with the graph entirely and instead optimize over the goals using a high-level model via trajectory optimization or tree search [78,81]. Indeed, it is entirely possible that amortized higher-level planning methods (i.e. higher-level RL or other learned models) might, in the long run, prove more effective than classic graph search, or the two paradigms might be combined, for example, by using differentiable search methods as in the case of (a hierarchical variant of) value iteration networks [47] or other related methods [48,51]. The key point is that the higher-level mapping and planning process, whether learned or not, should operate on abstractions that are informed by the (learned) capabilities of the robot.

The graph described in figure 3 can be utilized for planning in a number of different ways. In the simplest case, the current observation o_t and the final desired goal o_g are simply connected to the graph by using D(o_i, o_j), a graph search algorithm determines the next waypoint along the shortest path o_w, and then π(a_t | o_t, o_w) is used to select the action [64]. However, real-world navigation problems often require more sophisticated approaches because (1) the environment might not have been previously explored, and therefore requires simultaneously constructing the ‘mental map’ and planning paths that move the robot toward the goal; (2) the goal might be specified with other information besides the target observation. In general, observations in a new environment might be added to the robot’s memory (‘mental map’), connecting them to a growing graph, and each time the robot might replan a path toward the goal. When the path to the goal cannot be determined because the environment has not been explored sufficiently, the robot might choose to explore a new location [39], or might use some sort of heuristic informed by side information, such as the spatial coordinate of the target, or even an overhead map [40]. The latter also provides a natural avenue for introducing other goal specification modalities: while the mental map is built in terms of the robot’s observations, the final goal can be specified in terms of any function of this observation, including potentially its GPS coordinates [40].

5. Experimental case studies

In this section, we will discuss selected recent works that develop experiential learning systems for robotic navigation, shown in figures 4 and 5: BADGR [6], which learns short-horizon navigational skills from autonomous exploration data; LaND [37], which extends BADGR to incorporate semantics in order to navigate sidewalks; ViNG [38], which incorporates topological ‘mental maps’ as described in the previous section; and the latter's two extensions: RECON [39] and ViKiNG [40], which incorporate the ability to explore new environments and utilize overhead maps, respectively.

Figure 4.

Learning outdoor navigation. BADGR [6] learns short-horizon skills from randomly collected data to minimize the risk of collision (a) or choose paths with minimum bumpiness (to stay on paved trails) (b). LaND [37] extends this system to also learn from human-provided disengagement commands, thus learning the semantics of driving on sidewalks (c) without explicit labels or rules. ViNG [38] utilizes goal-conditioned skills and combines them into long-horizon plans by building ‘mental maps’ from prior experience in a given environment to reach a series of visually indicated goals for the task of autonomous mail delivery (d).

Figure 5.

Searching a novel environment for a user-specified goal image (inset), RECON [39] incrementally builds a topological ‘mental map’ of landmarks (white) by sampling latent subgoals and navigating to them (blue path). Subsequent traversals use this mental map to reach the goal quickly (red).

(a) . Learning low-level navigational skills

Low-level navigational skills can be learned using model-free RL, model-based RL, or supervised learning. We illustrate a few variations in figure 4. All of these methods only use forward-facing monocular cameras, without depth sensing, GPS or LIDAR. BADGR [6] employs a partially model-based method for training the low-level skill, predicting various task-specific metrics based on an observation and a candidate sequence of actions. Data for this method is collected by using a randomized policy. The model is trained from this autonomously collected data, analogously to the models in §3, and can predict the probability that actions will lead to collision (visualized in figure 4a), the expected bumpiness of the terrain (figure 4b), and the location that the robot will reach, which is used to navigate to goals. LaND [37], shown in figure 4c, further extends this method to also predict disengagements from a human safety monitor, with data collected by attempting to navigate real-world sidewalks. By taking actions that avoid expected future disengagements, the robot implicitly learns social conventions and rules, such as staying on sidewalks and avoiding driveways, which enables the LaND system to effectively navigate real-world sidewalks in the city of Berkeley, California. These case studies illustrate how experiential learning can enable robotic navigation with a variety of objectives that allow accommodating user preferences and semantic or social rules. The training labels for these objective terms are provided during data collection either automatically via on-board sensors (with collision and bumpiness) or from human interventions that happen naturally during execution (in the case of LaND).

The above methods focus on low-level skills. Figure 4d illustrates ViNG [38], which integrates low-level skills, in this case, represented by a goal conditioned policy π(a_t | o_t, o_g) and distance model D(o_t, o_g) that are trained using the supervised learning loss in §3, with a high-level navigation strategy that builds a ‘mental map’ graph over previously seen observations in the current environment, as detailed in §4. Note that this ‘map’ does not use any explicit localization, it is constructed entirely from images previously observed in the environment. The visualization in figure 4d uses GPS tags, but these are not available to the algorithm and only used for illustration. ViNG uses goals specified by the user as images (i.e. photographs of the desired destination), and requires the robot to have previously driven through the environment to collect images that can be used to building the mental map that the system plans over. Note, however, that the low-level model π(a_t | o_t, o_g) is trained on data from many different environments, constituting about 40 h of total experience, while the experience needed to build the map in each environment is comparatively more modest (comprising tens of minutes). In the next two sections, we will describe how this can be extended to also handle novel environments.

(b) . Searching in novel environments

The methods discussed above do not give us a way to reach goals in previously unseen environments—this would require the robot to physically search a novel environment for the desired goal. In conventional navigation systems, this is done by simultaneously mapping the environment and updating the plan on the fly. Experiential learning systems can also do this, building up their ‘mental map’ as they explore the new environment.

As with ViNG, we can first train the low-level policy π(a_t | o_t, o_g) and distance model D(o_t, o_g) on data from many different environments (RECON [39], described here, uses the same dataset). However, exploring a new environment requires being able to propose new feasible goals that have not yet been visited, rather than simply planning over a set of previously observed landmarks. This requires the learned low-level models to support an additional operation: sampling a new feasible subgoal that can be reached from the current observation. Sampling entire images, though feasible with a generative model, is technically complex. Instead, RECON employs a low-dimensional latent representation of feasible subgoals, learned via a variational information bottleneck (VIB) [82]. Specifically, a latent goal embedding is computed according to a conditional encoder q(z_g | o_g, o_t), where conditioning on both o_g and o_t causes z_g to represent a kind (latent) change in state. The VIB formulation provides us with both a trained encoder q(z_g | o_g, o_t), which we can use to then train π(a_t | o_t, z_g) and D(o_t, z_g), and a prior distribution p₀(z_g) that can be used to sample random latent goals. VIB training optimizes for random samples z_g ∼ p₀(z_g) to correspond to feasible random goals—essentially random nearby locations that are reachable from o_t.

The ability to sample random subgoals z_g is used by RECON in combination with a fringe exploration algorithm, which serves as the high-level planner. RECON keeps track of how often the vicinity each landmark in the graph has been visited and, if the robot cannot plan a path directly to the final goal, it plans to reach the ‘fringe’ of the current graph, defined as landmarks with low visitation counts, and from there sample random goals z_g ∼ p₀(z_g). This causes the robot to seek out rarely visited locations and explore further from there, as illustrated in figure 5 (blue path). After searching through the environment once, the robot can then reuse the mental map to reach the same or other goals much more quickly.

(c) . Learning to navigate with side information

Specifying the goal solely using an image can be limiting for more complex navigational tasks, where the robot must drive a considerable distance and simply searching the entire environment is impractical. To extend experiential learning to such settings, ViKiNG [40] further incorporates the ability to use GPS and overhead maps (e.g. satellite images or road schematics) as ‘heuristics’ (in the A* sense) into the high-level planning process. This can be seen as somewhat analogous to how humans navigate new environments by using both geographic knowledge (e.g. from a paper map) and first-person observations, combined with patterns learned from their experience [83].

ViKiNG trains an additional heuristic model that receives as input the image of the overhead map, the approximate goal location (obtained via a noisy GPS measurement), and a query location, and predicts a heuristic estimate of the feasibility of reaching the goal from that location. This estimate is learned from data via a variant of contrastive learning [84]. It is then included in the search process as a heuristic, analogously to how heuristics are used in A* search, though with a modification to account for the fact that the robot is carrying out a physical search of the environment, and therefore should also take into consideration the time it would take for it to travel to the best current graph node from its current location.

In an experimental evaluation, ViKiNG is able to extract useful heuristics from satellite images and road schematics, and can navigate to destinations that are up to 2 km away from the starting location in new, previously unseen environments, using low-level policies and heuristic models trained on data from other environments. Evaluated environments include hiking trails, city roads in Berkeley and Richmond in California, suburban neighbourhoods, and office parks. Figure 6 shows one such experiment, where the robot successfully uses satellite image hints to navigate to a goal 1.2 km away without any human interventions.

Figure 6.

Kilometre-scale navigation using geographic hints. ViKiNG [40] can use a satellite image to perform informed search in large real-world environments (a), involving navigating on paved roads (b), through a dense patch of trees (c), while showing complex behaviour like backtracking on encountering a dead-end (d).

Note that the information from GPS and overhead maps is used merely as heuristics in the high-level planning algorithm, and not directly incorporated in the observation space for the low-level navigational skills. This illustrates an important principle of the low-level versus high-level decomposition for such learning-based methods: both the low-level and high-level components can utilize learning and benefit from patterns in the environment, but they serve inherently different purposes. The low level deals with local traversability, while the high level aims to determine which paths are more likely to lead to the destination. Note also that the approach for learning the heuristic model is fairly general, and could potentially be extended in future work to incorporate other types of hints, such as textual directions.

6. Prospects for the future and concluding remarks

We discussed how experiential learning can be used to address robotic navigation problems by learning how to traverse real-world environments from real-world data. In contrast to conventional methods based on mapping and planning, methods that learn from experience can learn about how the robot actually interacts with the world, directly inferring which terrain features and obstacles are traversable and which ones are not, and developing a grounded representation of the navigational affordances of the current robot in the real world. However, much like how conventional mapping and planning methods build an internal abstract model of the world and then use it for planning, learning-based methods also, implicitly or explicitly, construct such a model out of their experience in each environment. However, as we discuss in §4, in contrast to the hand-designed abstractions in geometric methods (e.g. 3D points or vertices), learning-based methods acquire these abstractions based on the capabilities of the learned skills. Thus, robots with different capabilities will end up using different abstractions, and the representations of the ‘mental maps’ that result from such abstractions are not geometric, but rather describe the connectivity of the environment in terms of the robot’s capabilities.

Such methods for robotic navigation have a number of key advantages. Besides grounding the robot’s inferences about traversability in actual experience, they can benefit from large and diverse datasets collected over the entirety of the robot’s lifetime. In fact, they can, in principle, even incorporate data from other robots to further improve generalization [85]. Furthermore, and perhaps most importantly, such methods can continue to improve as more data is collected. In contrast to learning-based methods that utilize human-provided labels, such as imitation learning [23] and many computer vision approaches [7–10], experiential learning methods do not require any additional manual effort to be able to include more experience in the training process, so every single trajectory executed by the robot can be used for further finetuning its learned models. Therefore, such approaches will benefit richly from scale: the more robots are out there navigating in real-world environments, the more data will be gathered, and the more powerful their navigational capabilities will become. In the long run, this might become one of the largest benefits of such methods.

Of course, such approaches are not without their limitations. A major benefit of hand-designed abstractions, such as those used by geometric methods, is that the designer has a good understanding of what goes on inside the abstracted model. It is easy to examine a geometric reconstruction to determine if it is good, and it is comparatively easy to design an effective planning algorithm if it only needs to plan through geometric maps constructed by a given mapping algorithm (rather than a real and unpredictable environment). But such abstractions suffer considerable error when applied to real-world settings that violate their assumptions. Learning-based methods, in contrast, are much more firmly grounded in the real world, but because of this, their representations are as messy as the real world itself, making the learned representations difficult to interpret and debug. The dependence of these representations on the data also makes the construction and curation of the dataset a critical part of the design process. While workflows for evaluating, debugging, and troubleshooting supervised learning methods are mature and generally quite usable, learning-based control methods are still difficult to troubleshoot. For example, there is no equivalent to a ‘validation set’ in learning-based control, because a learned policy will encounter a different data distribution when it is executed in the environment than it saw during training. While some recent works have sought to develop workflows, for instance, for offline RL methods [86], such research is still in its infancy, and more robust and reliable standards and workflows are needed.

Safety and robustness are also major challenges. In some sense, these challenges follow immediately from the previously mentioned difficulties in regard to interpretability and troubleshooting: ultimately, a method that always works is always safe, but a method that sometimes fails can be unsafe if it is unclear when such failures will occur, which makes it difficult to implement mitigating measures. Therefore, approaches that improve validation of learning-based methods will likely also improve their safety. Non-learning-based methods often have more clearly defined assumptions. This can make enforcing safety constraints easier in environments where those assumptions are not violated, or where it is easy to detect such violations. However, this can present a significant barrier to real-world applications: a SLAM method that assumes static scenes can work well for indoor navigation, but is not viable, for example, for autonomous driving. The most challenging open-world settings could violate all simplifying assumptions, which might simply leave no other choice except for learning-based methods. This makes it all the more important to develop effective techniques for uncertainty estimation, out-of-distribution robustness, and intelligent control under uncertainty, which are all currently active areas of research with many open problems [87–89].

In the end, learning-based methods for robotic navigation offer a set of features that are very difficult to obtain in any other way: they provide for navigational systems that are grounded in the real-world capabilities of the robot, make it possible to utilize raw sensory inputs, improve as more data is gathered, and can accomplish all this with systems that, in terms of overall engineering, are often simpler and more compact than hand-designed mapping and planning approaches, once we account for the additional features and extensions that the latter require to handle all the edge cases that violate their assumptions. Methods based on experiential learning are still in their early days: although the basic techniques are decades old, their real-world applicability has only become feasible in recent years with the advent of effective deep neural network models. However, their benefits may make such approaches the standard for robotic navigation in the future.

Data accessibility

This article has no additional data.

Authors' contributions

S.L.: writing—original draft, writing—review and editing; D.S.: writing—original draft, writing—review and editing.

All authors gave final approval for publication and agreed to be held accountable for the work performed therein.

Conflict of interest declaration

We declare we have no competing interests.

Funding

The research discussed in this article was partially supported by ARL DCIST CRA W911NF-17-2-0181, the DARPA Assured Autonomy Program, and the DARPA RACER Program, as well as Berkeley AI Research and Berkeley DeepDrive.