{'fraction_non_alphanumeric': 0.03202846975088968, 'fraction_numerical': 0.010412547779095822, 'mean_word_length': 4.787376048817697, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Learning Object-conditioned Exploration using Distributed Soft Actor Critic

Object navigation is defined as navigating to an object of a given label in a complex, unexplored environment. In its general form, this problem poses several challenges for Robotics: semantic exploration of unknown environments in search of an object and low-level control. In this work we study object-guided exploration and low-level control, and present an end-to-end trained navigation policy achieving a success rate of 0.68 and SPL of 0.58 on unseen, visually complex scans of real homes. We propose a highly scalable implementation of an off-policy Reinforcement Learning algorithm, distributed Soft Actor Critic, which allows the system to utilize 98M experience steps in 24 hours on 8 GPUs. Our system learns to control a differential drive mobile base in simulation from a stack of high dimensional observations commonly used on robotic platforms. The learned policy is capable of object-guided exploratory behaviors and low-level control learned from pure experiences in realistic environments.


Introduction
Visual Navigation is a long-standing problem at the intersection of Robotics and Computer Vision. Much of the existing effort in the field has been focused on safely and efficiently navigating a robot to a geometrically specified goal, commonly known as point goal navigation. However, in many practical settings the goal location is unknown, such as in solving the problem: "Where are my keys?" This class of problems, in which the goal is specified semantically, is known as Semantic Visual Navigation. Tackling this problem involves overcoming numerous challenges, such as generating intelligent plans to efficiently explore the space and controlling the robot in a safe and efficient manner. The vision community has studied visual navigation using high-level discrete control with a known goal in an unknown environment, whereas the robotics community has investigated using low-level continuous control to reach a known goal in a known environment. We seek to combine these, and learn to navigate to a target of unknown location with low-level continuous control in an unknown environment.
In this work we focus on object-conditioned exploration and low-level control, for the purpose of navigating to objects in realistic simulated settings (see Fig. 1). We assume no prior knowledge of the environment and no localization information. Further, we aim towards a simulation setup which mimics many of the challenges present in real world robotics. We use environments based on scans of real homes [1] to provide maximum visual realism and complexity, and simulate the physics of a differential drive robot to address the challenges of low-level control. While we primarily tackle the exploration and control components of this problem, we show results that demonstrate the challenges of learning policies which can perform exploration, recognition, and control in search of an object. We leave real world deployment for future work, as this would require more work in sim-to-real transfer or training in the real, which are challenging due to the sim-to-real gap and limited ability to collect large amounts of data on a robot. However, the more realistic setup we provide in simulation is a step towards better real world performance compared to prior methods.
For the above setup of semantic navigation, we revisit end-to-end learned navigation policies. We introduce a distributed version of the Soft Actor Critic (SAC) algorithm [2] which allows us to train a policy from experience. SAC, as an off-policy reinforcement learning algorithm, is amenable to scalable parallelization, where we parallelize both the model optimization and the experience collection. This allows us to train a conventional Neural Net (ResNet50 + LSTM) as a policy to  Figure 1: Navigating to an object requires object-conditioned exploration (e.g., efficiently exploring a space using contextual cues) and low level control (e.g., controlling a differential drive). We present a scalable distributed SAC system to learn an object navigation policy in realistic environments, addressing all of the above challenges. (2b) The agent learns to "peek" into rooms and backtrack if the object is unlikely to be present. (2c) The agent learns to move directly to the goal once it is seen.
output continuous actions from rich, high dimensional, realistic robot observations. We also note that we specifically choose an off-policy algorithm, since these are more sample efficient than onpolicy alternatives. Sample efficiency is important in the robotics domain, where data collection is expensive and maximal data re-use is highly desired. Using this system, we achieve a success rate of 0.68 and SPL of 0.58 for navigating to 9 different object types by training over 98 million experience steps per 24 hours on 8 GPUs.
We demonstrate that a single end-to-end model can learn several important skills in the realistic and visually rich simulation environments required for object navigation. First the agent learns natural exploration behaviors, such as turning in place when the object is not visible, backtracking when failing to find the goal object, and going straight to the target object when visible (Fig. 2). These behaviors are then conditioned on the type of object, so that the agent performs different exploration behaviors for different types of objects. It is important to note that these emerge from experience without any explicit supervision.
Finally, we demonstrate the challenges of using low-level control, and the utility of having a comprehensive set of sensors, e.g., range sensing, which allows for more collision free object navigation.

Related Work
The proposed work is related to different approaches towards visual navigation. Classical techniques for navigation typically start with map construction, followed by planning and execution of the planned trajectories. The mapping stage uses visual observations to simultaneously localize and construct maps, either topological or semantic and metric (see for an extensive review [3,4] of SLAM).

Learned Navigation System
In the last few years a large body of work on learned navigation policies has emerged [5,6,7,8]. This body of work has laid the groundwork for learning-based navigation, where a sensors-to-control policy is learned from experience or demonstrations. Researchers have studied a wide variety of navigation problems, such as metric navigation [9,10,11,12], targetdriven semantic navigation [7,13,14], and exploration [15,12,16,17,18,19].
Most relevant to our problem setup, Yang et al. [13] train Graph Convolutional Networks for object navigation with discrete commands. Mousavian et al. [14] address a similar problem using learning from demonstrations.
More recently, we have seen two different developments which facilitate learning realistic navigation policies. First, reinforcement learning (RL) algorithms have become more stable and mature, e.g., [20,21]. Second, we have seen the development of navigation simulation environments, which simulate realistic visuals and physics at scale, e.g. [22,23]. In this paper, we leverage these new simulations and learn a navigation policy which tackles both complex visuals and physics.
These advances have already been utilized, to a degree, for point navigation. Chaplot et al. [23] demonstrate a hierarchical learned navigation system for point navigation with very strong results on the Habitat challenge [23]. Sax et al. [10] apply PPO on top of mid-level image representations for strong results on the same benchmark. For the same problem, Wijmans et al. [11] demonstrate even stronger results using a distributed version of PPO.
While point navigation [23,9] has made remarkable progress, its applicability to real-world settings remains limited. In most applications, the precise metric location of the target is unknown, which is the case in object navigation. This important difference introduces serious challenges as the agent has to efficiently plan and explore the unknown environment. Furthermore, real-world robots operate using continuous control rather than the commonly used discrete left/right/forward actions. These important details must be taken into account in the choice and design of the algorithm. In contrast to prior works, which have tackled some of these challenges individually (Table 1), we propose a method to handle them altogether.
Motion Planning and Obstacle Avoidance In this work we emphasize having a realistic setup, meaning continuous control. The main challenge is collision-free movement respecting the geometry of the robot and obstacles. Classical approaches include Artificial Potential Fields [24] or Dynamic Window Approach [25]. These require an explicit model of the environment, which we do not have at test time.
Deep Learning has found traction in Motion Planning research as well. In more detail, control policies have been trained using supervised learning [26] and DDPG [27] for point navigation. However, instead of point navigation, we achieve this in the context of semantic, long-range navigation.

Object-conditioned Exploration
Object Navigation (ObjectNav) is defined as the problem of navigating to an object, specified by a label, in unstructured and unknown environments [9]. In this work, we want to tackle objectconditioned exploration in its most challenging form: Realistic complex visuals: the agent navigates in realistic environments. We propose to use Gibso-nEnv [1] as a set of scans of real homes.
Realistic physics: the agent has realistic embodiment. We suggest using a model of a robotic system -more precisely a differential drive with mounted RGB, depth, and 1-D LiDAR modeled after a Fetch robot.
Semantics: We use 9 object types to navigate to. The starting location can be up to 15m away, and as such the robot explores multiple rooms before getting to the target.
The problem of object navigation brings together a range of skills -visual recognition, objectconditioned exploration of unknown environments, and low-level control. As such, in this study we mostly assume that the goal object detection is given by an oracle.

Learning of General Navigation Policy
Consider the case where the robot starts in the dining room and is looking for an oven. The robot may perform rotational motion to explore the environment, spot the kitchen bar counter in the distance, and use this cue to move towards it, hypothesizing that there is a kitchen area with the goal behind the counter. This type of reasoning process may benefit from end-to-end neural network policies which can tightly integrate these skills. Furthermore, these policies may benefit from learning via Control Realism Realism exploration Zhu et al. [7] Gupta et al. [6] Mousavian et al. [14] Sax et al. [10] Yang et al. [28] Chaplot et al. [12] Wijmans et al. [11] Ours Table 1: Comparison with prior learning-based visual navigation approaches. experience in realistic environments, since explicit supervision for the above reasoning is hard to define.

Distributed Soft Actor-Critic
As commonplace, we model the problem as a Partially Observable Markov Decision Process (POMDP). In particular, we apply Soft Actor-Critic to learn a policy for the MDP (see [21] and Supplement). As SAC is an off-policy RL algorithm, it lends itself well to a distributed application. SAC has been empirically demonstrated to work well with significantly out-of-distribution data, thus this setup is very amenable to parallelization and distribution. In particular, we can distribute several aspects of the process (see Fig. 3).
Collect The data collection can be parallelized over multiple workers, on which we run our policy in the simulation engine. In our implementation we use a simulator that renders GibsonEnv worlds [1] and simulates a LoCoBot differential drive base [29]. Note that most of the running time is spent in stepping through the environment. Many other navigation simulation engines have GPU specific renderers [1,23] to speed up graphic rendering. In our design we opted for running 100 CPUs in parallel.
Training We use a rack of 8 GPUs to perform synchronous SGD. We use the SAC implementation from the Tensorflow Agents library within TensorFlow [30].
Experience Replay To mix experiences from multiple collect workers, we use an Experience Replay Buffer (ERB). The ERB receives experiences generated by all collect jobs and sends them to the training worker. In more detail, each collect worker sends an unroll (of a length of up to 100 steps in our implementation) to the ERB . The ERB sends batches of samples (of length 20 each) to the workers. Each sample is generated as a random crop from an unroll. In this way, the ERB guarantees uniform sampling of the data. Note that we use a distributed implementation of ERB due to its large memory requirements.
Performance Analysis The computational bottleneck in the above setup is the training, as the training time scales approximately logarithmically w. r. t. the number of workers [31], while the collect process scales linearly. Therefore, it is important to reduce additional computational burden on the training workers. We do this by moving experience collect on the separate collect workers. In our experiments we can process 98 million experience steps per 8 GPUs per day.

Reward Definition for Object Navigation
The only aspect specific to object navigation in the above POMDP is the reward definition used at train time. We deliberately opt for a simple reward, which provides clear supervision for clearly desired and undesired behaviors, such as reaching goal or colliding respectively. At the same time, we provide no supervision for behaviors that are hard to quantify, such as efficient exploration behaviors or effective low level controls.
In more detail, the reward consists of four components: where collision(s) = −0.05 if s denotes a state of collision, otherwise 0. step(s) = −0.01 which is used to encourage efficiency (penalizes long episodes). The third term measures the distance progress towards the goal, without taking into account rotations. More precisely, if s denotes the state after taking action a at s and d(s) denotes geodesic distance to goal, then progress(s, a) = 0.1(d(s) − d(s )). The final term, success(s) = 1.0 if state s denotes success of reaching the goal object (see Sec. 5 for detailed definition for object navigation).

Observations, Actions, and Network Architecture
Observations Our agent runs with three different observation modalities: forward facing RGB image, ground level LiDAR, and depth image, as commonly found on robots. The RGB observation is a frontal camera view from the agent's perspective at 0.88m height, perpendicular to the ground plane with a horizontal FOV of 79 degrees. This setup mimics the setup of a LoCoBot with an elevated Intel RealSense Camera. It gives the agent the opportunity to see the world directly and use semantic cues. However, the camera at this height has a blind spot immediately in front of the robot base, which makes obstacle avoidance challenging. In order to perceive geometry, we use a depth image called DEPTH of the same size and extrinsics as RGB.
Lastly, the LiDAR observation is a 1-dimensional array of 222 agent-relative (x, y, z) Cartesian coordinates, which indicate the ray-distance to occupied space in the environment. It is mounted at the base of the robot, has a wider field of view than DEPTH at 220 degrees, and is motivated by the blind spot of RGB. It is used by real world robotic systems such as Fetch, and can be modelled on a LoCoBot by using a base mounted Hokyuo Rangefinder.
Auxiliary Observations In addition to the above observations, we feed into our policy two other auxiliary observations shown to benefit learning: the action from the previous time step, a binary collision bit designating whether the action at the previous step was successful. These observations help the agent learn collision avoidance, and empirically leads to faster convergence.

Oracle Observations
We conduct experiments with auxiliary oracle observation to understand the importance of semantics. This oracle observation is defined as a binary mask of only the goal object, called Det. This observation helps break the problem into two distinct phases: exploration (when the object is not visible) and direct navigation to the object while avoiding obstacles (once it becomes visible).
Action Space The action space of the agent is motivated by commonly used differential drive robots such as LoCoBot or Fetch. We use twist commands, an angular and linear velocity.
Architecture We use a standard NN architecture, whereby the different observations get embedded into vectors. These get concatenated, and subsequently fed into an LSTM, which outputs actions and critic values. Further details regarding the exact architecture and training details can be found in supplementary material.

Setup
We evaluate our system in an environment which simulates both the visuals and physics of the real world. We use the worlds from Gibson [1], which consists of high quality scans of real homes, and simulate a differential drive robot in a custom environment for performance reasons. We use a subset of the worlds for which object segmentations and labels are available, as provided in [32]. This dataset comes with 25 homes for training, 5 for validation, and 5 for testing. Note that many of the homes have multiple floors, which we treat as disjoint spaces. For example, the test set has 12 floors total. We test navigating to 9 objects: 'bed', 'chair', 'microwave', 'refrigerator', 'table', 'toilet', 'oven', 'tv', 'sofa'. LiDAR observations (bottom) from the environment. Note that the camera is at a height of 0.88m with 79 degrees FOV which makes collision detection challenging. Using range sensing close to the base makes the control problem easier, e. g. dark means close and it demonstrates that the robot is quite close to the wall in the left image and the chair in the right image.
We model the kinematics of a commonly used differential drive robot, i.e., LoCoBot or Fetch. Its base is a 0.18m radius circle and its camera height is 0.88m. To evaluate each approach we compute Success weighted by Path Length (SPL) [9].
The success criterion, needed to compute S i , is motivated by the idea that the robot should be able to physically reach the object. In particular, we expect that the agent is looking at the object and that the object is within reaching distance (see Fig. 4, Left). More precisely, S i = 1 if agent is at a navigable pose within 1m from the object 3D bounding box and the object is visible (within the central 20% of the RGB observation), otherwise S i = 0.

Experiments
In this section we present an empirical analysis of the learned policy. To focus on understanding exploration and low-level control, we assume that we are given an oracle goal object detection in most of the analysis below (see Sec. 4.3).
We report results over 120 episodes, 10 episodes for each of the 12 house floors. Each episode runs for up to 500 steps. The starting position is spawned randomly within 15 m of the goal. Given that we use scans of standard homes, this distance is large enough that the goal object is usually not visible from the starting point.
Using modalities RGB+LiDAR+Det our navigation policy achieves an SPL of 0.58 and success rate of 0.68 on Gibson Test environments (see Table 2, left). In order to provide context to this result, we compare with several baselines. Because the environment is only partially observable, it is not reasonable for any agent to achieve 1.0 SPL. Thus, to get a sensible upper bound on performance, we ask 12 human raters to perform navigation using RGB observation by virtually traversing 12 environments (see appendix for details). The average SPL for our raters is 0.80 with a success rate of 0.86. The challenges raters face are: not being able to identify the correct direction, which leads to a suboptimal path; running out of time; getting stuck in narrow spaces, where the head camera view is not allowing for collision free traversals.
We compare against two scripted baselines with varying degrees of exploration intelligence to quantify how much learning exploration helps. For all of these baselines, the agent goes straight and collision-free to the goal whenever the object becomes visible.
Roomba: the policy moves straight until collision. When it collides, it picks a random rotation direction, performs rotations until collision free, and repeats.
Topo Graph Traversal (TGT): the policy follows a topological graph of the environment, defined as the skeleton of the floorplan [33]. We perform a depth-first traversal of this graph. This guarantees an efficient coverage of the space, however the space is explored without taking into account the goal label. This baseline is by definition collision free.
Both scripted baselines achieve similar SPL, however Roomba has a lower success rate as it struggles exploring far-away spaces. TGT can do this, however often times the path taken is not very efficient. Our navigation policy achieves almost double the SPL. Note that humans are not perfect either.
Observation Modalities Oftentimes it is assumed that RGB and Depth are sufficient observation modalities. However, on real world robotic systems a stronger emphasis is put on range sensing or wider field of view as they usually give complementary information. For example, when mounted  Table 2: Success weighted by Path Length (SPL) and object reached Success Rate(SR). Left: comparison of our approach with scripted and human baselines. Right: different combinations of observation modalities. We have two behaviors of the simulator: 'stuck', proper physics dynamics whereby the agents usually gets stuck at collision, and 'sliding', where the agent slides upon collision as used in [23]. on top of a robot, both RGB and Depth have a blind spot right in front of the robot (see Fig. 4, Right). This blind spot makes it harder to maintain a collision free path. Therefore, in this work we mount a LiDAR sensor to the robot base and investigate its utility.
We present results over combinations of modalities in Table 2, right. In all cases we use Det, so that the policy can focus on exploration and continuous control. We see that adding depth sensing leads to a boost, and in particular LiDAR has the larger boost in performance. We conjecture that this is due to the ability to avoid collisions, in which the agent otherwise gets stuck.
Low level continuous control We use a simulator for our differential drive robot model. Empirically, the most challenging aspect in that respect is collisions, especially in narrow passages, which lead to a halt.
In order to assess how much of challenge this presents, we evaluate our policies in a modified version of our simulator where, at collision, the agent is allowed to slide along the obstacle, as used in [23]. The results, shown in Table 2, indicate a 0.10 to 0.20 boost in SPL across all policies in this more forgiving regime. This suggests that properly modeling dynamics, especially in the physically realistic continuous control case, is of high importance.
Starting Distance to Goal As the starting distance to the goal increases, the problems become harder (see Fig. 5). It is noteworthy that LiDAR-based policies tend to perform better over larger distances, which is due to better collision avoidance (usually narrow doorways in our data).
Visual Recognition In most of the experiments we assume that an oracle gives us goal object recognition via Det, in order to focus on exploration. To demonstrate that our system is capable of learning recognition in addition to exploration and continuous control, we train our policy without Det (see Table 3). Det helps across the board, in particular when the object is far away and small as a result.  Table 3: SPL for our model with and without Det, also split per object.

Emergent Behaviors
To solve object navigation, several exploration and navigation behaviors must emerge. Towards exploration, an agent must be able to gather information about the environment efficiently and comprehensively. We note that several of these behaviors naturally emerge through the learning process, as shown in Fig. 6. The agent learns not only to only cover the space, but to leverage the minimal required amount of exploration, e.g., the agent peeks into rooms only the necessary amount to see if the object is present. The agent also learns to efficiently gather information in regions that must be traversed, e.g., by repeatedly moving in straight lines, followed by circling to get a 360 • view. Finally, the agent learns to leverage semantic context of the surrounding scene to make decisions even when the object is not in view, e.g., recognizing that a kitchen likely has an oven or that a bathroom has a toilet. We do however find suboptimal behaviors emerging, such as revisiting regions or heavily exploring single regions. This is likely a result of the limited memory of LSTMs and indicates a need for further research into long-term memory for navigation.
Towards navigation, several challenging problems and emergent behaviors become apparent when considering a formulation of the navigation problem with continuous control and an embodied agent (Fig. 7). To maximize its ability to both cover the space and to reach known goals, the agent learns to move with direct, smooth trajectories. This behavior is particularly visible once the object has been found, in which case, the agent beelines to the goal. The agent also learns to identify and traverse narrow passages, e.g., doors. We find that while the agent is capable of entering doorways, it at times gets trapped in regions either by never deciding to exit a region or getting stuck on objects that are outside its field of view. These challenges exist particularly for domains like robotics, with embodied agents and continuous control, and warrant further research.

Conclusion
In this paper we study object-conditioned exploration and low-level continuous control in the context of object navigation. We present a generic and scalable RL setup which trains navigation policies with emerging natural exploration behaviors. Further, we show challenges with low-level continuous control, and demonstrate how to address them. . P represents the state transition probability of the next state s t+1 ∈ S given the current state s t ∈ S and action a t ∈ A. Lastly, R is the reward, which is discussed in detail in Section 4.2.
We learn a navigation policy π(a t | o t ) using Soft Actor-Critic (SAC) [21,34], an off-policy form of maximum entropy reinforcement learning. The idea behind maximum entropy reinforcement learning is to learn a policy that maximally accomplishes the task while simultaneously being maximally random, with the idea that this randomness aids both exploration and robustness. To accomplish this, SAC learns a policy that maximizes the expected sum of rewards along with the α-temperature weighted entropy H over the policy [21], with τ = (s 0 , o 0 , a 1 , s 1 , o 1 , · · · , a T , s T , o T ) sampled from π. The above policy is learned in an Actor-Critic setting, where the policy is optimized to be consistent with a critic, a state-action function. The latter is learned via a 'soft' Bellman residual optimization.
The optimization iterates between two steps. In the experience collect step, sequences of state transitions and associated actions are sampled from the environment using a recent policy. These transitions are used to perform the aforementioned optimization in the training step.

Implementation Details
NN Architecture We use the same NN architecture for all function approximators used in the SAC implementation, the policy, state action function, and value function. This architecture consists of observation embedders whose outputs are concatenated and fed into a single layer LSTM of dimension 512.
As an observation embedder we use a ResNet50 [35], whose channel number is scaled down by a factor of 4. All image observations, (RGB, DEPTH, DET), are concatenated along their channel dimension and fed into the network. The last observation, LiDAR, is 1-dimensional and is embedded using a 3 layer ConvNet, with a final fully connected layer. All resulting observation embeddings are of dimension 128 and are added together as a final observation embedding.
The auxiliary observations, denoting the previous action and its success, are independently embedded using two 2-layer MLP, both layers of dimension 128.
In addition to the above observation, the policy is conditioned by the label of the target object. This label is represented by a 1-hot vector, which is embedded by a similar 2-layer MLP, both layers of dimension 128.
Training Details We use the Adam optimizer with a learning rate of 0.000316. The LSTM unroll length during training is 20, which is substantially smaller than the maximum step length of 500 during evaluation and of 100 during collection. Finally, SAC uses lagging weights for the target state action function in its Bellman error loss to stabilize training. In our implementation we gradually update these weights every step with a Polyak update of weight 0.005 every 1 step. We use a gamma discount factor of 0.99. We performed a grid search over only the learning rate, in the range [1e-4, 1e-3].

Evaluation Details
Metric Definitions (SPL) [9], defined over N navigation episodes, is the average of the success indicators S i scaled by navigation efficiency, expressed in terms of the optimal path length o i to goal and the length l i of the actual path taken: SPL = 1 N N i=1 S i oi max{li,oi} . We note that a perfect SPL of 1.0 is not realistic to expect because navigation decisions in unexplored environments can be ambiguous.

Human Raters
We provide a virtual setup where a rater can perform 'forward', 'turn left', 'turn right' discrete actions using the keys 'W', 'A', and 'D'. The rater has not seen the environments before, and is allowed a single navigation episode per home. We use the same criteria for starting point and episode length as for the policy evaluation.