Safe Reinforcement Learning with Scene Decomposition for Navigating Complex Urban Environments

TL;DR

This paper introduces a modular safe reinforcement learning approach with scene decomposition and belief updates for autonomous vehicle navigation in complex urban intersections, ensuring safety and robustness.

Contribution

It presents a novel safe RL algorithm with a model-checker, belief update, and scene decomposition to improve urban navigation safety and scalability.

Findings

Outperforms rule-based methods in complex intersection scenarios

Demonstrates robustness to perception errors and occlusions

Scales effectively to environments with multiple traffic participants

Abstract

Navigating urban environments represents a complex task for automated vehicles. They must reach their goal safely and efficiently while considering a multitude of traffic participants. We propose a modular decision making algorithm to autonomously navigate intersections, addressing challenges of existing rule-based and reinforcement learning (RL) approaches. We first present a safe RL algorithm relying on a model-checker to ensure safety guarantees. To make the decision strategy robust to perception errors and occlusions, we introduce a belief update technique using a learning based approach. Finally, we use a scene decomposition approach to scale our algorithm to environments with multiple traffic participants. We empirically demonstrate that our algorithm outperforms rule-based methods and reinforcement learning techniques on a complex intersection scenario.

Figures

Equations

$$Q^{\ast }(s,a)=R(s,a)+\gamma \sum _{s^{\prime }}T(s,a,s^{\prime })\underset{a}{\max }{Q}^{\ast }(s^{\prime },a)$$

$$J(\theta )={\mathbb{E}}_{s^{\prime }}[(r+\gamma \underset{a^{\prime }}{\max }Q(s^{\prime },a^{\prime };\theta )-Q(s,a;\theta ){)}^2]$$

$$\theta \leftarrow \theta +\alpha (r+\gamma \underset{a^{\prime }}{\max }Q(s^{\prime },a^{\prime };\theta )-Q(s,a;\theta )){\nabla }_{\theta }Q(s,a;\theta )$$

$$Q(b,a)=\sum _s{Q}_{\text{MDP}}(s,a)b(s)$$

$$\mathrm{Pr}(s^{\prime }\mid s,a)=P_{\text{ego}}(s_{\text{ego}}^{\prime }\mid s_{\text{ego}},a)P_c(s_c^{\prime }\mid s)P_p(s_p^{\prime }\mid s)$$

$${\pi }_{\text{safe}}(s)=\{\begin{array}{ll}{\mathrm{argmax}}_{a\in {\mathcal{A}}_{\text{safe}}(s)}Q(s,a)& \text{if}{\mathcal{A}}_{\text{safe}}(s)\ne \varnothing \\ {\mathrm{argmax}}_a{P}_S(s,a)& \text{if}{\mathcal{A}}_{\text{safe}}(s)=\varnothing \end{array}$$

$$b=\{(b_{\text{ego}},b_{{\text{c}}_1},b_{{\text{p}}_1},b_{{\text{o}}_1}),\dots ,(b_{\text{ego}},b_{{\text{c}}_1},b_{{\text{p}}_1},b_{{\text{o}}_1})\}$$

$$P_S(b,a)$$

$$Q(b,a)$$

Full text

I INTRODUCTION

Automated driving has the potential to significantly improve safety. Although major progress in enabling this technology has been made in recent years, autonomously navigating urban environments efficiently and reliably remains challenging. At urban intersections, vehicles must navigate among both cars and pedestrians, using on board perception systems that give noisy estimates of the location and velocity of others on the road and are sensitive to occlusions (Fig. 1). Autonomously navigating urban intersections requires algorithms that reason about interactions between traffic participants with limited information.

Engineering a rule-based strategy to navigate such an environment would require anticipating the vast space of possible situations. A common heuristic strategy is to use a threshold on the time to collision [1]. Such an approach performs well in simple scenarios but does not take into account sensor uncertainty and is unlikely to scale to complex environments. Alternatively, previous work suggests modeling the problem as a partially observable Markov decision process (POMDP) [2, 3, 4]. POMDPs provide a principled framework to model uncertainty of other drivers’ intent through latent variables, as well as integrating perception and planning [3, 4]. However, these methods are often difficult to scale in environments with multiple road users.

Reinforcement learning (RL) has been proposed as a way to automatically generate effective behaviors. RL has been applied to autonomous braking strategies at crosswalks [5], lane changing policies [6], and intersection navigation [7, 8]. [7] propose a deep reinforcement learning approach with recurrent neural networks to learn how to navigate intersections with multiple vehicles with changing behaviors [7]. [8] address a scenario with sensor occlusions by representing the state as an occupancy grid and learning a policy through Q-learning [8]. Although both approaches show promising results and efficient policies, they often fail at providing safety guarantees.

To enforce safety in decision making algorithms, different techniques have been proposed [9]. Conservative rule-based strategies based on traffic rules and short term predictions can be used to constrain the action of a reinforcement learning agent [10, 11]. Formal methods can be used to derive shielding mechanisms in a more systematic way [12]. These techniques rely on a model of the environment and provide strong safety guarantees. They often require an abstraction of the environment that might be difficult to design.

In this work, we propose a decision making framework to navigate urban intersections. Our algorithm integrates concepts from the POMDP planning, reinforcement learning, and model checking literature to address some of the challenges of autonomously navigating urban environments pertaining to safety, efficiency, robustness, and scalability. We first present the combination of a model-checker and a reinforcement learning policy to derive efficient policies with probabilistic safety guarantees. Then, we introduce a new belief update approach that uses an ensemble of neural networks. The output of these networks are used as input for the RL algorithm. Finally, a scene decomposition method enables us to scale our approach to a large number of agents and take advantage of local interactions between traffic participants. We provide an ablation study of the different components of our decision making system to illustrate the benefit of each on five evaluation scenarios. Simulation results show that our algorithm outperforms RL policies and an engineered rule-based method.

II BACKGROUND

II-A Reinforcement Learning

Sequential decision making problems can be modeled by a Markov decision process (MDP). MDPs are mathematical frameworks defined by the tuple $(\mathcal{S},\mathcal{A},T,R,\gamma)$, where $\mathcal{S}$ is a state space, $\mathcal{A}$ is an action space, $T$ is a transition model, $R$ is a reward function, and $\gamma$ is a discount factor. The agent takes an action $a$ at a given state $s$, and the environment evolves to a state $s^{\prime}$ with a probability $T(s,a,s^{\prime})=\Pr(s\mid s^{\prime},a)$. After every transition, the agent receives a reward $r=R(s,a)$ for taking action $a$ in state $s$. The action $a$ is chosen according to a policy $\pi:\mathcal{S}\rightarrow\mathcal{A}$. We call the state-action utility of a policy $\pi$ the quantity $Q^{\pi}(s,a)=E[\sum_{t=0}^{\infty}\gamma^{t}r_{t}|s_{0}=s]$. This quantity represents the discounted accumulated reward obtained by the agent when taking action $a$ from state $s$ and then following policy $\pi$. The optimal state-action utility verifies the Bellman equation [13]:

[TABLE]

In MDPs with finite state space and action space, Eq. 1 can be solved using value iteration. However, when the state space is continuous and high dimensional, approximation methods must be used [14]. In recent years, deep reinforcement learning algorithms have been shown to find efficient policies in very large MDPs. In deep reinforcement learning, the state-action value function is represented by a neural network: $Q(s,a;\theta)$ where $\theta$ encodes the weights of the network. The solution to Eq. 1, can be approximated by the network minimizing the following loss function:

[TABLE]

Given an experience sample $(s,a,r,s^{\prime})$, the weights are updated as follows:

[TABLE]

where $\alpha$ is the learning rate, a hyperparameter of the algorithm. [15] proposed several innovations to improve network training, such as the use of a target network and experience replay, which lead to a scalable reinforcement learning solver known as deep Q-learning (DQN) [15].

II-B State Uncertainty

MDP models assume that the agent can observe the true state of the environment perfectly. However, in autonomous driving scenarios, the ego vehicle receives imperfect observations of the environment. Hence, the autonomous driving problem is inherently a partially observable Markov decision process (POMDP). In a POMDP, the agent represents its knowledge of the environment with a belief state $b:\mathcal{S}\rightarrow[0,1]$ such that $b(s)$ is the probability of being in state $s$. At every time step, the agent receives an observation and updates its belief. Algorithms that update a current belief given observations are referred to as belief updaters, or filters in the tracking literature.

Solving decision making problems in the belief space is generally intractable. Instead, one can use the QMDP approximation [16]:

[TABLE]

where $Q_{\text{MDP}}$ is the solution to the problem considered as an MDP. Such approximation assumes that the state will be perfectly observable at the next time step. The QMDP method over approximates the true belief-state value function. As a consequence, an agent following such a policy will not take information gathering actions. We argue that for the problem of interest, information gathering does not need to be incentivized and will occur naturally as the agent moves towards the goal. Experiments show that the QMDP approximation suffices to make our algorithm robust to state uncertainty.

III PROPOSED APPROACH

This section describes the different components of our approach, illustrated in Fig. 2. We first explain how to model the intersection navigation problem. We then present our safe reinforcement learning algorithm and learned belief updater on a canonical scenario involving only the ego vehicle, a single other car, and a pedestrian. Finally, we demonstrate how to use the solution to this canonical scenario to navigate intersections with a multitude of cars and pedestrians. The hyperparameters for each of the methods presented are available in our code base111https://github.com/sisl/AutomotiveSafeRL.

III-A Modeling Intersection Scenarios

The urban intersections scenario is modeled as a Markov decision process. A simulation environment222The implementation is available at https://github.com/sisl/AutomotivePOMDPs.jl is derived from the MDP formulation by sampling the transition model. In addition, we simulate perception error during evaluation, making our model a POMDP.

State

We define the state of a traffic participant $c$ to be $s_{c}=(x,y,\theta,v)$ which is its position, heading, and its longitudinal velocity. We used a Cartesian frame with the origin at the center of the intersection to define the position. Fixed obstacles are defined by their positions and their sizes: $s_{obs}=(x,y,\theta,l,w)$ where $l$ is the length and $w$ the width of the obstacle. The global state ${s=(s_{\text{ego}},s_{\text{c}_{1:n_{c}}},s_{\text{p}_{1:n_{p}}},s_{\text{o}_{1:n_{o}}})}$ can be described as follows:

• •

$s_{\text{ego}}$ represents the physical state of the ego vehicle

• •

$s_{\text{c}_{i}}$ represents the physical state of the $i$-th car in the environment with $i=1\ldots n_{c}$ where $n_{c}$ is the number of cars present in the environment

• •

$s_{\text{p}_{i}}$ represents the physical state of the $i$-th pedestrian in the environment with $i=1\ldots n_{p}$ where $n_{p}$ is the number of pedestrians present in the environment.

• •

$s_{\text{o}_{i}}$ is the pose of the $i$-th obstacle present in the environment with $i=1\ldots n_{o}$ where $n_{o}$ is the number of fixed obstacles present in the environment.

In addition, we add an extra state variable, $s_{\text{absent}}$, to model a potential incoming traffic participant that is not present in the scene. Contrary to previous work, this description of the state takes into account any obstacle configuration and any type of entity (pedestrian or car) in the problem formulation. Other POMDP approaches consider adding a latent variable to each of the traffic participants to describe their behavior [4, 3]. In this paper, uncertainty about other traffic participants’ behavior is captured by the transition model and state uncertainty only takes into account sensor limitations. However, the proposed framework could be extended to model the intentions of drivers and pedestrians.

Action Space

The ego vehicle controls its acceleration along a given path by choosing an acceleration level among the set: $\{$-4\text{,}\mathrm{m}\text{/}{\mathrm{s}}^{2}$,$-2\text{,}\mathrm{m}\text{/}{\mathrm{s}}^{2}$,$0\text{,}\mathrm{m}\text{/}{\mathrm{s}}^{2}$,$2\text{,}\mathrm{m}\text{/}{\mathrm{s}}^{2}$\}$ which corresponds to a comfortable driving.

Transition

The transition model is designed to capture interaction between traffic participants. For a state with a single car $c$ and a single pedestrian $p$, we can factorize the transition model as follows:

[TABLE]

$P_{\text{ego}}$ represents the dynamics of the ego vehicle and is modeled by a deterministic point mass dynamic. $P_{c}$ and $P_{p}$ represent the model of the other car and the pedestrian respectively. The car follows a rule-based policy described in Section IV and the pedestrian follows a time to collision policy to decide whether it is safe to cross the street. Hence, the actions of the car and the pedestrian depend on their respective state as well as the state of the ego vehicle. To describe uncertainty in the behavior of other vehicles, a Gaussian noise with standard deviation $2\text{\,}\mathrm{m}\text{/}{\mathrm{s}}^{2}$ is added to the output of the rule-based policy. $P_{c}$ represents the model of the pedestrian. In addition, new cars and pedestrians can appear in the scene with a constant probability of appearance at each time step. They appear at the beginning of any lane or crosswalk randomly with a random velocity.

Observation

The ego vehicle receives a noisy observation of the state according to the following sensor model:

• •

The position measurement follows a Gaussian distribution centered around the ground truth with standard deviation $\sigma_{p}$ growing linearly with the distance to the target.

• •

The velocity measurement follows the same model with $\sigma_{v}$ growing linearly with the distance to the target.

• •

There is a false negative rate of $0.1$ and a false positive rate of $0.1$ if no targets are visible.

• •

If a target is occluded, it cannot be detected. In the simulated environment we compute occlusion by a ray tracing technique: if the segment connecting the front of the ego vehicle and the target intersects with the obstacle, then the target is occluded.

The observation model is used for simulation purposes. The safe-RL algorithm that we will present in the next section derives a policy in a fully observable environment.

Such mathematical formulation provides a principle framework to model multiple vehicles interacting, uncertain behaviors, and limited perception of the environment. However, solving for the optimal strategy to navigate in such an environment would be intractable due to an exponential increase in the number of states with the number of agents considered. For this reason, we will first focus on a sub-task in a simpler scenario, using offline methods. We consider a canonical scenario involving the ego vehicle, a single other car, and a single other pedestrian. This scenario is sufficient to capture complex interactions such as the other car yielding to a crossing pedestrian. The generalization to environments with multiple agents and obstacles is performed online and is addressed in Section III-D.

III-B Safe Reinforcement Learning

Deep reinforcement learning methods could derive efficient policies for the proposed scenario but do not provide any safety guarantees. For safety critical applications such as autonomous driving, a way to benefit from the flexibility and scalability of deep RL is to constrain the action space to safe actions [17, 9]. In this work, we use a probabilistic model checker to compute the probability of reaching the goal safely for each state-action pair prior to learning a policy. Safe actions are then identified by applying a threshold on the probability of success at a given state-action pair, similar to the method used by [17] [17]. The threshold is a user defined parameter which represents the minimum desired probability of success.

The model checker relies on the value iteration algorithm and requires a discretization of the state space and the full specification of the transition model [18]. To keep the representation tractable, the state space is limited to longitudinal positions and velocities for the three agents, a variable indicating the car’s lane and a variable indicating the pedestrian’s crosswalk. The pedestrian can be on any of the three crosswalks considered and travels in both direction (making it six values for the pedestrian lane). The car can drive in any of the lanes present on Fig. 1. By choosing resolutions of $2\text{\,}\mathrm{m}\text{/}$ for the position and $2\text{\,}\mathrm{m}\text{/}\mathrm{s}$ for the velocity of each agent, the number of states is approximately $23\text{\times}{10}^{6}$. Given this discrete representation, the probability of reaching the goal safely, $P_{S}(s,a)$, can be computed offline using parallel value iteration.

A safety threshold $\lambda$ is used to constrain the agent to take actions inside the set $\mathcal{A}_{\text{safe}}=\{a\mid P_{S}(s,a)>\lambda\}$. In cases where the set is empty, the agent then executes the safest possible action given by the model checker. In cases where $\mathcal{A}(s)$ is not empty, the agent can choose any actions within the set. We train an RL agent to choose the best actions among the possible safe actions as follows:

[TABLE]

This constrained action selection strategy transfers the safety guarantees of the model checker to the RL agent [17].

The probabilistic model checker enables identifying safe actions and bounding the actions of the RL agent. However, the ego vehicle must also reach the goal as fast as possible. To optimize for this objective, we define a simple reward function that assigns a value of $1$ to goal states. Collision states are already avoided thanks to the constrained exploration. The policy is trained using deep Q-learning with a constrained action space to enforce safety. The training environment is a continuous state space, simulated environment, following the model described in Section III-A, with only one other car and one pedestrian and perfect observation. The policy is modeled by a feedforward neural network with four layers of $32$ nodes and ReLU activations. The input to the network is a twelve dimensional vector with the positions (2D), longitudinal velocity, and heading of the ego vehicle, the car, and the pedestrian. Future work could investigate more complex reward design with terms for passenger comfort or social behavior.

The safe RL algorithm provides a policy that is trained on the canonical scenario optimizing for time efficiency under safety constraint imposed by the model checker. Computing the probability of collision and training the policy assumes an MDP model of the environment where the position and velocity of the road users are fully observable.

III-C Ensemble Belief Updater

In this section we present a belief updater capturing state uncertainty. A belief updater is generally an algorithm that updates the new belief given the old belief, and the current observation. Although perception systems already use filtering algorithms, their outputs are still noisy and may result in false positive and false negative. In this work, the belief updater has sole purpose to integrate perception error in the planning algorithm. It is assumed that a perception system is processing raw sensor data beforehand and provides a structured representation of the environment. Our belief updater assumes perfect data association. Each entity is associated to an ID that is consistent through the whole trajectory.

Classic belief updaters, such as particle filters, could be used to track occluded object and smooth perception errors [19]. However, most of these algorithms rely on some model of the environment. In this paper, we experiment with a new learning-based approach to represent belief states. The main motivation is to capture environment specific parameters, such as the probability of an entity appearing in an occluded area, as well as to learn scenario specific dynamics, such as a car yielding to a pedestrian, which cannot be easily modeled.

Our belief update algorithm consists of an ensemble of recurrent neural networks (RNN). The hidden state of each network is responsible for keeping track of the observation history. The input of each network is an observation vector, and the output is the predicted ground truth position of the car and the pedestrian as well as a probability of presence. The input to the RNN is a sixteen dimension vector encoding the observed state of the ego vehicle, pedestrian, other car, and obstacle. The prediction is a ten dimension vector: the predicted state of the car and pedestrian, and their probability of presence. The recurrent neural network is trained using gradient descent on the mean squared error between ground truth trajectories and predicted trajectories.

In order to make the prediction more robust, we used an ensemble method [20]. Instead of training a single network, $k$ different networks are trained on a different portion of the dataset. Those randomly initialized networks will converge to different local optima. As a result, they will each give different predictions for a given input. We use an ensemble of five networks and the five predictions represents the belief of the agent. The use of an ensemble of RNNs emulates the role of a particle filter similarly to the approach presented by [21] [21].

To train the network, we generated a synthetic dataset with the same simulation environment used for training the RL policy. This scenario involves one ego vehicle, one other car, and one pedestrian, as well as one obstacle randomly placed on the side of the road. We generated $3000$ trajectories of $400$ time steps of $0.1\text{\,}\mathrm{s}\text{/}$. The belief updater is trained to handle up to a certain level of perception noise described in Section IV.

In Fig. 3 we can see an example of our belief updater predicting the state of a car behind an occluded area. The blue trace represents the predictions of the five RNNs. We can see that they all give different predictions, enhancing the robustness of the estimation. As the time increases, the probability of presence of a car behind the obstacle increases since our model assumes a constant rate of appearance at every time step. The network is able to infer that cars can appear at the beginning of the road because it has experienced such cases in the training set. Finally, on the last two frames the car is observed (green trace) and the predictions converge to a more accurate estimation.

It is important to realize that standard particle filters could have been used since our environment is simulated and the model is known. However, using a learning based-method could help capture unknown parameters such as the probability of the appearance of a car, or pedestrian, as well as scenario specific dynamics, such as a car braking strongly to yield to a pedestrian. Experiments in Section IV show that our ensemble of RNNs provides robustness to perception errors. Further work is needed to benchmark such approach against standard tracking algorithms and evaluate the number of RNNs to use in the ensemble.

III-D Online Scene Decomposition

Thus far, we presented our approach on a scenario involving only three traffic participants. In this section we will demonstrate how to generalize the safe RL policy, and the belief updater, to situations with multiple cars and pedestrians through the use of scene decomposition. Decomposition methods have been used in the past to approximate the solution of large decision making problems [22, 23]. They consist of combining the utility functions associated with simple tasks to approximate the solution to a more complex task. Previous work proposed an agent-wise decomposition where each target to avoid is considered independently [22].

In our intersection scenario, the simple task consists of navigating the intersection assuming only one car, one pedestrian, and one obstacle can be present. The motivation for using a canonical scenario with three agents is to capture interactions between cars and pedestrians. In the presence of multiple cars and pedestrians, the global belief, $b=(b_{\text{ego}},b_{\text{c}_{1}},\ldots,b_{\text{p}_{1}},\ldots,b_{\text{o}_{1}})$, can be decomposed into multiple instances of the canonical scenario. That is:

[TABLE]

At each time step, we will have $n_{c}\times n_{p}\times n_{obs}$ canonical beliefs. Since $n_{c}$ and $n_{p}$ are not known in practice due to sensor occlusions, the global state variable is augmented with an additional car and pedestrian observed as absent. This allows the agent to always assume that there is at least one agent that might appear from an occluded area.

Once the belief state is decomposed into canonical belief states, we perform the following approximation:

[TABLE]

This operation takes into account the canonical belief with the worst probability of success and the worst utility. Entities that are far from the ego car and present very little risk will be associated to a higher utility and higher probability of success and will be ruled out from the decision.

The computational cost of the scene decomposition method grows linearly with the number of cars or pedestrians considered. Once the belief state decomposed, a policy call requires evaluating $Q$ and $P_{S}$ $n_{c}\times n_{p}\times n_{obs}$ times online. Since $Q$ and $P_{S}$ are computed offline, evaluating them at a given belief point involves a pass forward through a neural network and a table query which is relatively fast, as illustrated in Fig. 4. In our current implementation, we used a decision step of $0.1\text{\,}\mathrm{s}\text{/}$ so the policy call would become slower than real time after $7$ cars and one pedestrian. In practice, the decision step could be reasonably increased up to $0.5\text{\,}\mathrm{s}\text{/}$, and the different calls to $Q$ and $P_{S}$ could be parallelized. Updating the belief using the ensemble of networks stayed below $100\text{\,}\mathrm{ms}\text{/}$.

The use of $\min$ to combine individual utilities could be overly conservative in crowded environments. Increasing the size of the canonical scenario could help taking into account more complex interaction. This fact highlights a computational trade-off between the number of traffic participants considered jointly or separately. Previous work has studied algorithms to bridge the gap between approximated solutions obtained from decomposition methods and the solution to the problem considering every traffic participants [24].

IV EXPERIMENTS

We evaluated our algorithm on a simulated environment following the model described in Section III-A. To measure the performance of our algorithm, we designed five different scenarios and measured the number of time steps to reach the goal as well as the number of collisions. We ran $10\,000$ simulations and measured the average number of steps taken to reach the goal as well as the average number of collisions observed in simulation. The results are presented in Fig. 7.

IV-A Evaluation Scenarios

The first two scenarios, a and b, evaluate the benefit of using a belief updater. Scenarios c and d evaluate the benefit of having a three agent formulation as the canonical scenario. Finally, scenario e evaluates the scalability of our algorithm. Fig. 5 shows a situation from each of those scenarios. Across the scenarios, we varied the sensor performances, the presence of obstacles, and the number of cars and pedestrians present in the scene. For each of them, the ego vehicle starts with no velocity, waiting at a T shape intersection with no stop signs.

In all scenarios but c and d, the perception error is modeled by a Gaussian distribution around the position and velocity measurement with false positive and false negative rates. The standard deviations are $0.5\text{\,}\mathrm{m}\text{/}$ and $0.5\text{\,}\mathrm{m}\text{/}\mathrm{s}$ for the position and velocity measurements. We used a false positive rate of $0.1$ and a false negative rate of $0.1$. The perception system is also sensitive to physical obstacles such as buildings. We used ray tracing to check if a traffic participant is occluded or not. If it is occluded, then no observation is received by the ego vehicle.

Perception Noise

We consider only one other car going straight and coming from the right or the left with equal probability. The car is initialized with a random longitudinal position along its route and a random longitudinal velocity between $0\text{\,}\mathrm{m}\text{/}\mathrm{s}$ and $8\text{\,}\mathrm{m}\text{/}\mathrm{s}$. We can see from Fig. 7 that the five policies take similar times to reach the goal.

Occlusions

This scenario is the same as described above except that a physical obstacle is present on the side of the road, which blocks the sensing capabilities of the vehicle. The initial scene is generated such that the incoming car is always occluded by the obstacle.

The next two scenarios have been designed in order to evaluate the ability of our decision making system to capture interactions between traffic participants. In both scenarios we assume that the ego vehicle has perfect sensing capabilities.

Car and pedestrian interaction

In this scenario, we consider one other car and one other pedestrian interacting with each other. The strategy of the other car is to yield to the pedestrian if it is crossing or preparing to cross. The pedestrian is initialized on one of the three crosswalks randomly, with a random longitudinal position and a random velocity between $0\text{\,}\mathrm{m}\text{/}\mathrm{s}$ and $2\text{\,}\mathrm{m}\text{/}\mathrm{s}$. The other car is initialized with a random route, a random longitudinal position, and a random velocity.

Ego and other car interaction

Only one other car, and no pedestrian is considered. The other vehicle is coming from the right and must perform a left turn. If the ego vehicle starts engaging in the intersection, then the other vehicle should yield to the ego vehicle. This scenario has been designed to evaluate the ability of our policy to exploit this interaction.

Multiple cars and pedestrians

In this scenario, we evaluate the scalability of our approach. A flow of cars and pedestrians is generated with a probability of appearance of $0.1$ at every time step. We also added observation noise and physical obstacles randomly initialized on the left or right of the ego vehicle. An example scene from scenario e is illustrated in Fig. 1.

IV-B Baseline Policies

We compared our algorithm’s performance against a rule-based method as well as an RL policy.

Rule-based policy: This policy is a hand-engineered rule-based strategy. It is the same policy followed by human cars in our simulation environment. The policy relies on a time to collision strategy to decide when to cross and uses an additional set of priority rules:

• •

Cars going straight or turning right on the main street have priority

• •

Pedestrians have priority and the car must yield to pedestrians approaching the crosswalk and wait for them to reach the other side of the road.

• •

Cars follow the intelligent driver model before or after reaching the intersection.

When a car is stopped at an intersection, it measures the time to collision with other vehicles. If this time to collision is above some threshold, the car crosses. The time to collision is measured as the time it takes for the other car to reach the center of the intersection assuming the car would drive with maximum acceleration. Such a design prioritizes safety and ensures that the rule-based policy is collision free under perfect observations. In addition, we analyzed the effect of using the ensemble RNN updater versus directly using the output of the perception system.

Safe rule-based: The safe rule-based policy is a combination of the model checker and the rule-based policy described above. If the action given by the rule-based policy is within the set of safe actions given by the model checker, then the action is executed. Otherwise, it executes the safest action given by the model checker.

RL policy: The reinforcement learning policy is trained using Deep Q Learning on the canonical scenario and is augmented using scene decomposition. The reward function assigns $-1$ to collisions and $1$ for reaching the goal. The same network structure is used as for the safe-RL policy. The exact parameters used for the training are available in our code base.

Finally, we will refer to our approach combining the belief updater, model checker, RL policy, and scene decomposition as the safe-RL policy.

IV-C Results and Discussion

In scenario a, the rule-based policy, not relying on a belief updater, has more collisions than the one using the updater. It receives a noisy observation of the true state which eventually leads to bad decisions. We can see that although the RL policy uses the belief updater, it is more aggressive and results in more collisions than the rule-based policy. In scenario b, the belief updater also reduces the number of collisions since the policy is aware of the potential presence of the car in the occluded area. Our safe-RL algorithm outperforms all the other approaches on this scenario. Our safe-RL algorithm did not cause any collisions for a comparable performance.

In scenario c and d, the RL policy results in the most collisions and is the fastest to cross. Using RL in such an environment allows to take advantage of situations where the other car yields to the pedestrian. The other policies have similar performances. Since the car yielding to the pedestrian slows down, the time to collision decreases and the rule-based policy is also able to perform efficiently.

In scenario e, the most complex, rule-based policies are very inefficient. In contrast, RL based policies perform very efficiently (twice as fast for RL vs rule-based). We can see that our Safe-RL approach performs comparably as the standard RL policy while being much safer. An example of a trajectory resulting from executing our algorithm in this scenario is illustrated in Fig. 6. The vehicle exhibits a safe and intelligent behavior. It positions itself strategically in the middle of the intersection, to leave as soon as the two pedestrian on the left are done crossing.

The simulation results highlight several important points that should be taken into consideration when designing a decision making algorithm for urban intersections. First, the belief updater plays an important role in making the algorithm robust to perception noise and aware of occluded areas. Secondly, using a pure reinforcement learning technique does not enable the agent to act more safely than when using simple rule-based methods. Moreover, we can see from the results on scenarios a, b, c, and d, which involves only one or two other traffic participants, that the efficiency of all the policies are very similar. However, when the scenario becomes more complex, with a flow of cars and pedestrians, the benefits of using reinforcement learning over a rule-based method become clear. As the set of possible situations drastically increases with the number of agents, engineering a set of rule to represent the policy is very challenging. Our safe-RL algorithm is able to find a safe policy that outperforms rule-based approaches. The presence of the model checker makes our algorithm more suitable than pure RL methods by enforcing safety constraints.

V CONCLUSIONS

This paper presented a decision making framework for autonomously navigating urban intersections. We introduced a learned belief updater that uses an ensemble of RNNs to estimate the location of vehicles behind obstacles and is robust to perception errors. We improved upon pure reinforcement learning methods by using a model checker to enforce safety guarantees. Finally, through a scene decomposition method, we demonstrated how to efficiently scale the algorithm to scenarios with multiple cars and pedestrians. We empirically demonstrated that our method provides safe and efficient decisions even in complex scenarios.

Future work includes applying our methodology to different situations such as highway merging and crowded driving environments. Since we demonstrated how to learn the belief updater with a synthetic dataset, a line of future work could be to use real data from the perception system of the ego vehicle. Finally, estimating the intentions of drivers has been investigated in previous works and could be useful for decision making [4, 3].