LEADER: Learning Attention over Driving Behaviors for Planning under Uncertainty
Abstract: Uncertainty in human behaviors poses a signiﬁcant challenge to autonomous driving in crowded urban environments.
The partially observable
Markov decision process (POMDP) offers a principled general framework for decision making under uncertainty and achieves real-time performance for complex tasks by leveraging Monte Carlo sampling.
However, sampling may miss rare, but critical events, leading to potential safety concerns.
To tackle this challenge, we propose a new algorithm, LEarning Attention over Driving bEhavioRs (LEADER), which learns to attend to critical human behaviors during planning.
LEADER learns a neural network generator to provide attention over human behaviors; it integrates the attention into a belief-space planner through importance sampling, which biases planning towards critical events.
To train the attention generator, we form a minimax game between the generator and the planner.
By solving this minimax game, LEADER learns to perform risk-aware planning without explicit human effort on data labeling.
Introduction
Robots operating in public spaces often contend with a challenging crowded environment.
A representative is autonomous driving in busy urban trafﬁc, where a robot vehicle must interact with many human trafﬁc participants.
A signiﬁcant challenge is posed by the vast amount of uncertainty in human behaviors, e.g., on their intentions, driving styles, etc..
The partially observable Markov decision processes (POMDPs) [1] offer a principled framework for planning under uncertainty.
However, optimal POMDP planning is computationally expensive.
To achieve real-time performance for complex problems, practical POMDP planners [2, 3] often leverage Monte-Carlo (MC) sampling to make approximate decisions, i e., sampling a subset of representative future scenarios, then condition decision-making on the sampled future.
They have shown success in various robotics applications, including autonomous driving [4], navigation [5, 6] and manipulation [7, 8].
Sampling-based POMDP planning, however, may compromise safety.
It is difﬁcult to sample future events with low probabilities, and some may lead to disastrous outcomes.
In autonomous driving, rare, but critical events often arise from adversarial human behaviors, such as recklessly overtaking the ego-vehicle or making illegal U-turns.
Failing to consider them would lead to hazards.
Earlier work Luo et al. [9] indicates that re-weighting future events using importance sampling leads to improved performance.
The approach requires an importance distribution (IS) for sampling events.
In autonomous driving, an importance distribution re-weights the different intentions of human participants, e.g., routes they intend to take.
A higher weight means an increased probability of sampling an intended route, thus examining its consequence more carefully during planning.
Prior works have used IS to better verify the safety of driving policies and proposed ways to synthesize importance distributions ofﬂine [10, 11, 12, 13].
However, it is difﬁcult to obtain importance distributions for online planning, due to the real-time constraints.
We propose a new algorithm, LEADER, which learns importance distributions both from and for sampling-based POMDP planning.
The algorithm uses a neural network attention generator to obtain importance distributions over human behavioral intentions for real-time situations.
Despite the neural networks’ problem in terms of interpretability [14], they are quite useful in problems that need to be scaled, such as crowd driving.
Next, an online POMDP planner consumes the importance distribution to make risk-aware decisions, applying importance sampling to bias reasoning towards critical human behaviors.
To train the algorithm, we treat the attention generator and the planner as opponents in a minimax game.
The attention generator seeks to minimize the planner’s value or the expected cumulative return.
This maps to highlight the most adversarial human behaviors by learning from experience.
On the other hand, the planner seeks to maximize the value conditioned on the learned attention, which maps to ﬁnd the best conditional policy using look-ahead search.
By solving the minimax game, the algorithm learns to perform risk-aware planning, without human labeling.
In our experiments, we evaluate the performance of LEADER for autonomous driving in dense urban trafﬁc.
Results show that LEADER signiﬁcantly improves driving performance in terms of safety, efﬁciency and smoothness, compared to both risk-aware planning and risk-aware reinforcement learning.
Background and Related Work 2.1 POMDP Planning and Monte Carlo Sampling
The Partially Observable Markov Decision Process (POMDP) [1] models the interaction between a robot and an environment as a discrete-time stochastic process.
A POMDP is written as a tuple (cid:104) S, A, Z, T, R, O, γ, b 0 (cid:105) with S representing the space of all possible states of the world, A denoting the space of all possible actions the robot can take, and Z as the space of observations it can receive.
Function T ( s, a, s (cid:48) )
= p ( s (cid:48) | s, a ) represents the probability of the state transition from s ∈ S to s (cid:48) ∈ S by taking action a ∈ A .
The function R ( s, a ) deﬁnes a real-valued reward specifying the desirability of taking action a ∈ A at state s ∈ S .
The observation function O ( s (cid:48) , a, z ) =
p ( z | s (cid:48) , a ) speciﬁes the probability of observing z ∈ Z by taking action a ∈ A to reach to s (cid:48) ∈ S .
γ ∈ [0 , 1) is the discount factor, i.e., the rate of reward deprecation over time.
Because of the robot’s perception limitations, the world’s full state is unknown to the robot, but can be inferred in the form of beliefs , or probability distributions over S .
The robot starts with an initial belief b 0 at t = 0 , and updates it throughout an interaction trajectory using the Bayes rule [15], according to the actions taken and observations received.
POMDP planning searches for a closed-loop policy, π ∗ :
B → A , prescribing an action for any belief in the belief space B , which maximize the policy value , V π ( b 0 ) = E [ (cid:80) ∞ t {+=
+} γ t R ( s t , π ( b t )) | b 0 , π ] , which computes the cumulative reward to be achieved in the current and future time steps, t ≥ 0 , if the robot chooses actions according to policy π and the updated belief b t , from the initial belief b 0 onwards.
Discounting using γ ∈ [0 , 1) keeps the value bounded.
Online POMDP planning often performs look-ahead search, constructing a belief tree starting from the current belief and branching with future actions and observations.
Enumerating all possible futures, however, is often computationally intractable.
Practical algorithms like DESPOT [2] leverage
Monte-Carlo sampling and heuristic search to break the computational difﬁculty.
DESPOT samples initial states and future trajectories using the POMDP simulative model.
Denote a trajectory as ζ = ( s 0 , a 1 , s 1 , z 1 , a 2 , s 2 , z 2 , ... ) .
The initial state s 0 is sampled from the current belief b .
Given any subsequent state s t and robot action a t , the next state s t +1 and the observation z t +1 are sampled with a probability of p ( s t +1 , z t +1 | s t , a t +1 )
=
O ( s t +1 , a t , z t +1 ) T ( s t , a t , s t +1 ) .
A DESPOT tree collates a set of sampled trajectories to approximately represent the future.
Each node in the tree contains a set of sampled future states, forming an approximate future belief.
The DESPOT tree branches with all possible actions and then sampled observations under each visited belief, effectively considering all candidate policies under the sampled scenarios.
Figure 2(a) shows an example DESPOT tree.
DESPOT evaluates the value of a policy using Monte-Carlo estimation:
[Equation]
where ∆ is a set of trajectories sampled by applying π .
Also,
[Equation]
is the probability of a trajectory ζ being sampled, V ζ = (cid:80)
H − 1 t =
γ t R ( s t , a t +1 ) is the cumulative reward along ζ , and H is maximum look-ahead depth, or the planning horizon .
By incrementally building a belief tree using sampled trajectories, DESPOT searches for the policy that provides the best value estimate, and outputs the optimal action for b when exhausting the given planning time.
2.2 Risk-Aware Planning and Learning Approaches
There are different techniques for risk-aware planning under uncertainty.
Nyberg et al.
[16] and
Gilhuly et al.
[17] proposed two measures for estimating safety risks along driving trajectories, with a focus on open-loop trajectory optimization.
Huang et al.
[18] modeled risk-aware planning as a chance-constrained POMDP to compute closed-loop policies that provide a low chance of violating safety constraints.
Kim et al.
[19] leveraged bi-directional belief-space solvers.
It bridges forward belief tree search with heuristics produced by an ofﬂine backward solver.
Both methods improved the performance of POMDP planning in safety-critical domains, but at the cost of an expensive ofﬂine planning stage.
Thus, it can hardly apply to large-scale problems.
Most relevant to our method,
Luo et al.
[9] offered IS-DESPOT, which improves the performance of online POMDP planning by leveraging importance sampling (IS).
It biases MC sampling towards critical scenarios according to an importance distribution provided by human experts, then computes a risk-aware policy under the re-weighted scenarios.
Manually constructing the importance distribution, however, is difﬁcult for complex problems such as driving in an urban crowd.
In this paper, we propose a principled approach to learn importance distributions from experience and adapt them with real-time situations.
LEADER is also loosely connected to risk-aware reinforcement learning (RL).
Kamran et al.
[20] proposed a risk-aware Q-learning algorithm by punishing risky situations instead of only collision failures.
Mirchevska et al.
[21] proposed to combine DQN with a rule-based safety checker, masking out infeasible actions.
Eysenbach et al.
[22] offered Ensemble-SAC (ESAC) for risk-aware RL, by additionally learning an ensemble of reset policies to assist the robot avoid irreversible states during training.
However, because of low sample efﬁciency, the above model-free approaches were limited to small-scale tasks like lane changing in regulated highway trafﬁc or controlling articulated robots for simple simulated tasks.
Some prior work improved the risk-awareness of model-based RL that plans with learned models.
Thomas et al.
[23] proposed SMBPO, which learns a sufﬁciently-large terminal cost for failure states.
Berkenkamp et al.
[24] focused on ensuring the stability of control.
The model-based methods provided better sample efﬁciency.
However, it is still difﬁcult to learn a model for large-scale, safety-critical problems like driving in an urban crowd [25]. 2.3 Integrating Planning and Learning
LEADER integrates planning and learning to beneﬁt from both explicit reasoning and past experience.
It uses learning to assist explicit POMDP planning, which has been inspired by the following prior works.
The LeTS-Drive algorithm [26, 27] ﬁrst proposed to learn heuristics for solving POMDPs, with planner actors and the learner collaborating in an closed-loop. Later, Lee et al. [28] proposed a generator-critic framework to learn macro-actions for POMDPs. It uses a neural network critic to approximate the planner’s value function and enable end-to-end training.
This work extends the generator-critic framework, applying it to solve a min-max game for learning behavioral attentions.
LEADER learns to attend to the most critical human behaviors for risk-aware planning in urban driving.
We deﬁne attention over the behavioral intentions of human participants.
Assume there are N exo-agents (trafﬁc participants) near the robot.
Each of them may undertake a ﬁnite set of intentions , or future routes such as keeping straight, turning left, merging into the right, etc, extracted from the road context by searching the lane network.
The actual intention of an exo-agent is not directly observable.
At each time step, LEADER maintains a belief b and an importance distribution q over the intention sets of the N exo-agents.
The belief b speciﬁes the natural occurrence probability of exo-agents’ intentions.
It is inferred from the interaction history.
The importance distribution q speciﬁes the attention over exo-agents’ intentions, determining the actual probability of sampling them during planning.
We propose to learn the importance distribution or attention mechanism from the experience of an online POMDP planner.
We will use “importance distribution” and “attention” interchangeably in the remaining.
LEADER has two main components: a learner generating attention for real-time situations, and a planner consuming attention to perform conditional planning.
The generator uses a neural network, q = G ψ ( b, z ) , to generate an importance distribution q , for the real-time situation speciﬁed by the current belief b and observation z .
The planner uses online belief tree search to make risk-aware decisions for given b and z , leveraging the importance distribution q to bias Monte-Carlo sampling towards critical human behaviors.
To train LEADER, generator and planner form a minimax game:
[Equation]
where Π is the space of all policies, and Q is the space of all importance distributions.
In this game, the generator must learn to generate q ’s that lead to the lowest planning value, meaning to increase the probability of sampling the most adversarial intentions of exo-agents; the planner must ﬁnd the best policy with the highest value, conditioned on the generated q .
We further learn a critic function, v = C ϕ ( b, z, q ) , another neural network that approximates the value function of the planner,
C ϕ ( b, z | q ) ≈ max π ∈ Π
ˆ V π ( b, z | q ) , to assist gradient-descent training of the generator.
Figure 1a and 1b demonstrate the training architecture of LEADER.
In the bottom row, the planner plans robot actions using the generated attention and feeds the driving experience to a replay buffer.
In the top row, we train the critic and the generator using sampled data from the replay buffer.
The critic is ﬁtted to the planner’s value estimates using supervised learning; the generator is trained to maximize the planner’s value, using the critic as a differentiable surrogate objective. [Figure]
Risk-Aware Planning using Learned Attention
The LEADER planner performs belief tree search to plan robot actions conditioned on the attention over exo-agents’ behaviors, solving the inner maximization problem in Eq.
A belief tree built by LEADER looks similar to a DESPOT tree (Section 2.1).
It collates many sampled trajectories, each corresponding to a top-down path in the tree.
The tree branches over all actions and all sampled observations under each belief node, effectively considers all possible policies under the sampled scenarios.
The difference is, however, LEADER biases the tree towards higher-risk trajectories using importance sampling.
Figure 2 provides a side-by-side comparison of belief trees in DESPOT and
LEADER.
Appendix A introduces the basics of importance sampling, and a theoretical justiﬁcation on our minimization objective of learning importance distributions.
Concretely, we sample initial states s 0 from the learned importance distribution q ( s 0 ) , instead of from the actual belief b ( s 0 ) .
As a result, the sampling distribution of simulation trajectories is also altered from Eq.
(2), becoming:
[Equation]
where ζ is a hypothetical future trajectory.
The value of a candidate policy π is now evaluated as:
[Equation]
Here, V ζ is the discounted cumulative reward along a trajectory ζ .
Eq.
(5) ﬁrst shows the deﬁnition of the value of policy π , then applies importance sampling, replacing the sampling distribution p ( ·| b, z, π ) in Eq.
(2) with q ( ·| b, z, π ) in Eq.
It also uses the importance weights p ( ζ | b,z,π ) q ( ζ | b,z,π ) to unbias the value estimation and ensure the correctness of planning.
The value is further approximated using Monte Carlo estimates:
[Equation]
Eq.
(6) starts with approximating the value using a set of sampled trajectories, ∆ (cid:48) .
It then simpliﬁes the importance weights to p ( s 0 ) q
( s 0 ) , as p ( ζ | b, z, π ) and q ( ζ | b, z, π ) only differ in the probability of sampling the initial state s 0 .
The LEADER planner is built on top of IS-DESPOT [9], integrating it with learned importance distributions.
Following IS-DESPOT, LEADER performs anytime heuristics search, incrementally building a sparse belief tree when sampling more trajectories.
During the search, it maintains for each belief node a set of approximate value estimates, and uses them as tree search heuristics.
See
Luo et al.
[9] for more details of the anytime algorithm.
Learning Attention over Human Behaviors
We train the critic and generator neural networks using driving experience from the planner, stored in the replay buffer.
The generator is trained to minimize the planner’s value estimates, solving the outer minimization problem in Eq.
It uses the critic as a differentiable surrogate objective, which is supervised by the planner’s value estimates.
Appendix B describes the network architectures of our critic and generator.
Critic Network .
The Critic network’s parameters ϕ are updated by minimizing the L2-norm between the critic’s value estimate and the planner’s value estimate
ˆ V using gradient descent, given a sampled tuple of belief b , observation z , and attention q :
[Equation]
where D is the set of online data stored in the replay buffer.
Attention Generator Network .
The generator network’s parameters ψ are updated by minimizing the planner’s value as estimated by the critic, given a sampled tuple of belief b and observation z :
[Equation]
(8) where D represents online data stored in the replay buffer.
This objective is made differentiable using the reparameterization trick [29], enabling gradient descent training via the chain rule:
[Equation]
The following is the training procedure of LEADER.
In each time step, the current belief b and observation z are fed into G ψ to produce the importance distribution q .
Then, the planner takes b , z and q as inputs to perform risk-aware planning, and outputs the optimal action a to be executed in the environment together with its value estimate ˆ V .
The data point ( b, z, q, ˆ V ) is sent to a ﬁxed-capacity replay buffer.
Next, a batch of data is sampled from the replay buffer, and used to update C ϕ and G ψ according to Eq.
(7) and (8).
The updated G ψ is then used for next planning step.
Training starts from randomly initialized generator and critic networks and an empty replay buffer.
In the warm-up phase, the critic is ﬁrst trained using data collected by LEADER with uniform attention.
This provides meaningful objectives for the attention generator to start with.
Then, both the critic and the generator are trained with online data collected using the latest attention generator.
At execution time, we only deploy the generator and the planner to perform risk-aware planning.
Experiments and Discussions
We evaluate LEADER on autonomous driving in unregulated urban crowds, show the improvements on the real-time driving performance, and analyze the learned attention.
The experiment task is to control the acceleration of a robot ego-vehicle, so that it follows a reference path and drives as fast as possible, while avoiding collision with the trafﬁc crowd under the uncertainty of human intentions.
A human intention indicates which path one intends to take. Candidate paths are extracted from the lane network of the map, according to the current location of the exo-agent.
Attention is thus deﬁned as a joint importance distribution over the intentions of 20 exo-agents near the robot, assuming conditional independence between agents.
See details on the POMDP model in Appendix C.
Our baselines include both risk-aware planning and risk-aware RL methods.
We ﬁrst compare with POMDP planners using handcrafted attention.
DESPOT-Uniform uses DESPOT with uniform attention over human intentions [30].
DESPOT-TTC computes the criticality of exo-agent’s intentions using the estimated Time-To-Collision (TTC) with the ego-vehicle.
The attention score is set proportional to 1 t c , where t c is the TTC if the exo-agent takes the indented path with a constant speed.
For RL baselines, we ﬁrst include a model-free RL method, Ensemble SAC (ESAC)
[22], which learns an ensemble of Q-values for risk-aware training.
Then, we include a model-based RL method, SMBPO [23], which plans with learned dynamics and a risk-aware reward model.
Because of the difﬁculty of real-world data collection and testing for driving in a crowd, we instead used the SUMMIT simulator [30], which simulates high-ﬁdelity massive urban trafﬁc on real-world maps, using a realistic trafﬁc motion model [31].
We evaluate LEADER and all baselines on three different [Figure] [Table] environments: the Meskel square in Addis Ababa, a highway in Singapore, and the magic roundabout in Swindon, using 5 different sets of reference paths and crowd initialization for each map.
Crowd interactions during driving are perturbed with random noise, thus are unique for each episode.
See sample driving videos of LEADER here: https://sites.google.com/view/leader-paper.
6.1 Performance Comparison
Learning Curves.
Figure 3 shows the learning curves of LEADER and the baseline algorithms in terms of the average cumulative reward, the collision rate
[Table]
and the average driving speed.
LEADER starts to outperform the strongest RL baseline from the 8500 th iteration which is 12 hours of training using 12 real-time planner actors.
It starts to outperform the strongest planning baseline from the 12500 th iteration corresponding to 19 hours of training.
At the end of training, LEADER achieves the highest cumulative reward, the lowest collision rate
[Table]
and the highest driving speed among algorithms.
Generalization.
To evaluate the generalization of LEADER, we ran it with 5 unseen reference paths and crowd initialization for each map with randomness on crowd interactions.
Table 1 shows detailed driving performance of the considered algorithms averaged over 400 test runs, equally apportioned among the three maps and map setups. Evaluation criteria include the cumulative reward, collision rate, travelled distance, and smoothness factor.
The collision rate measures the average number of collisions per 1000 time steps.
The smoothness factor is the reverse of the number of decelerations, 1 N dec .
As shown, LEADER outperforms other methods in all metrics, consistent with the learning curves.
It drives much more safely and efﬁciently than RL methods which had a hard time handling the highly dynamic crowd.
It also improves driving safety, efﬁciency and smoothness from the planning baselines which applied sub-optimal attention.
6.2 The Learned Attention
To provide a qualitative analysis on what LEADER has learned, we further provide 2D visualizations of the learned attention in Figure 4.
We provide three scenes from the Singapore Highway, Meskel
Square, and Magic Roundabout, respectively.
In each scene, we highlight a representative exo-agent, show the set of intention paths and visualize the learned attention over the paths using color coding.
For other exo-agents, we only show the most critical intentions with the highest attention scores.
[Figure] In Figure 4 (a), the highlighted exo-agent in blue drives in parallel with the ego-vehicle.
It has several possible intentions, including continuing straight and merging to neighbouring lanes.
The intention of merging right is more likely, as the agent is closer to the right lane.
However, the merging left intention is more critical, as the path will interfere with the ego-vehicle’s.
LEADER learns to put more attention on the more critical possibility.
As a result, the planner decides to slow down the vehicle and prepare for potential hazards.
In Figure 4 (b), the blue agent can either proceed left or turn right.
Both intentions are equality likely.
While the turning right intention gets the agent out of the ego-vehicle’s way, proceeding left, however, causes the agent to continue interacting with the ego-vehicle.
The generator thus assigned more attention to the latter.
The planner subsequently decides to stop the ego-vehicle, since the blue agent in front may need to wait for its own path to be cleared.
In Figure 4 (c), all intention paths of the blue agent intersect with the ego-vehicle’s.
The generator learned to attend to the path closest to the ego-vehicle, which is more hazardous.
Consequently, the planner stops the ego-vehicle to prevent collision.
Summary, Limitations and Future Work
In this paper, we introduced LEADER, which integrates learning and planning to drive in crowded environments.
LEADER forms a minimax game between a learning component that generates attention over potential human behaviors, and a planning component that computes risk-aware policies conditioned on the learned attention.
By solving the minimax game, LEADER learned to attend to the most adversarial behaviors and perform risk-aware planning.
Our results show that
LEADER helps to improve the real-time performance of driving in crowded urban trafﬁc, effectively lowering the collision rate while keeping the efﬁciency and smoothness of driving, compared to risk-aware planning and learning approaches.
Limitations of this work are related to assumptions, model errors and data required for training.
This work makes a few assumptions.
First, we assume there is an available map of the urban environment, providing lane-level information.
However, we believe this requirement can be met for most major cities.
Second, in our POMDP model, we focused on modeling the uncertainty of human intentions, and ignored perception uncertainty such as signiﬁcant observation noises and occluded participants.
These aspects will be addressed in future work through building more comprehensive models.
Third, LEADER will also be affected by model errors, as the approach relies on the planner’s value estimates to provide learning signals.
But since our approach emphasizes the most adversarial future, i.e., relies on conservative predictions, it is more robust to model errors than typical planning approaches.
Lastly, although we have improved tremendously from the sample-efﬁciency of RL algorithms, LEADER still requires hours of online training.
A promising solution is to “warm up” the critic and generator networks using ofﬂine real-world driving datasets, such as the Argoverse Dataset [32] and the Waymo Open Dataset [33], then perform further online training. Appendix A Theoretical Background of Importance Sampling
Importance sampling is a variance-reduction technique for Monte Carlo sampling, often used to obtain more reliable estimations from fewer samples.
Given a random variable x ∼ p ( x ) and a function f ( x ) .
Suppose we want to estimate the expected value of f ( x ) with sampling:
[Equation]
where { x i } i =1 ,...,n are sampled from p ( x ) , and 1 n (cid:80)
ni f ( x i ) is the estimation using the n samples.
Given an importance distribution q ( x ) , importance sampling is performed as:
[Equation]
where { x i } i =1 ,...,n are now sampled from the importance distribution q ( x ) , and p ( x i ) q ( x i ) , often referred to as the importance weights , are used to correct the point-based estimation.
If we deﬁne ˆ µ q = (cid:80) ni f ( x i ) p ( x i ) q ( x i ) , ˆ µ q is an unbiased estimator of µ .
It has also been shown that the variance of ˆ µ q is,
[Equation]
Therefore, the optimal importance distribution q ∗ that offers the lowest variance is:
[Equation]
The above equation suggests increasing the sampling probability of those x with high absolute function values | f ( x ) | .
This theoretical indication supports our core idea of learning to emphasize critical events that lead to hazards and thus large negative values.
B Neural Network Details
Figure 5 demonstrates network architectures of the attention generator and the critic.
The attention generator network ﬁrst concatenates numbers in the current belief b and the observation z into a single vector and feeds it to a feature extractor.
The feature extractor consists of 10 fully-connected layers with ReLU activation.
The extracted features are input to a Gated Recurrent Unit (GRU) cell [34], which keeps track of history inputs in its latent memory.
Based on the latent memory, the network uses two fully-connected layers and a soft-max layer to output the importance distribution q .
The critic network has similar architecture.
The belief b , observation z , and the generated importance distribution q are ﬁrst concatenated into a single vector.
Then, the vector is fed to a feature extractor containing 6 fully-connected layers with ReLU activation, then input to a GRU cell for tracking memory.
Based on the latent memory, the critic network uses another 3 fully-connected layers to ﬁnally output a single decimal number, representing the estimated planner value v .
See detailed representations of b , z , and q in the following section.
C The POMDP Model for Urban Driving
Our POMDP model for driving in an ill-regulated dense urban trafﬁc is deﬁned as follows:
• State Modeling :
A world state s encodes: – the state of the ego-vehicle, s c
= ( p c , v c , α c , P c ) , where p c , v c and α c denote its position, velocity, and heading direction, and P c denotes its reference path.
[Figure]
– observable states of 20 nearest exo-agents, s exo =
{ p i , v i , α i } i =1 ,..., 20 , where p i , v i , α i are the position, velocity, and heading direction of the i th exo-agent.
– hidden states of 20 nearest exo-agents, θ exo =
{ θ i } i =1 ,..., 20 , where θ i is the intention of the ith exo-agent.
Suppose an exo-agent has M potential paths to undertake according to the lane network, the value of its intention θ will be taken from { 0 , . . .
, M − 1 } .
A belief b is thus a discrete probability distribution deﬁned over the hidden states or intentions of exo-agents, assuming probabilistic independence between different participants.
It is represented using (cid:80) 20 i =
1 M i probability values, where M i is the number of intentions for the i th exo-agent.
An importance distribution q is speciﬁed in the same way.
• Action Modeling : An action a of the ego-vehicle is its acceleration discretized to three values, ACC , CUR , and DEC , meaning to accelerate, keep the current speed, and decelerate.
The acceleration and deceleration are 3 m/s 2 and − 3 m/s 2 , respectively.
• Observation Modeling :
An observation z from the environment includes all observable parts of the state s and excludes the hidden intentions.
Namely, z =
( s c , s exo ) .
Due to perceptual uncertainty, these observations often come with noise.
However, in this work, we particularly focused on the uncertainty in human behaviors and ignored perceptual uncertainty, because the latter often has a secondary inﬂuence on decision-making.
• Transition Modeling :
Our transition model assumes the ego-vehicle follows its reference path using a pure-pursuit steering controller and the input acceleration.
Exo-agents are not controlled by the algorithm.
We assume they take one of their hypothetical intended paths, using the GAMMA motion model [31] to interact with surrounding participants.
When simulating an exo-agent, the GAMMA model conditions prediction on a set of factors, including the intended path, collision avoidance with neighbors, and kinematic constraints.
At each time step, all agents are simulated forward by a ﬁxed duration of 1 / 3 s .
Afterward, small Gaussian noises are added to all transitions to model uncertain human control.
So, the transition function of the ego-vehicle and exo-agents can be written as:
[Equation]
where s c is the state of the ego-vehicle, P c is its planed reference path, and
[Equation]
where s exo represents the states of ego-vehicles, and (cid:15) is a sampled Gaussian noise.
• Reward Modeling :
The reward function takes into account driving safety, efﬁciency, and smoothness.
When the ego-vehicle collides with any exo-agent, it imposes a severe penalty of r co = − 20 × ( v 2 + 0 . 5) depending on the driving speed v .
To encourage driving smoother, we also add a small penalty of r sm = − 0 .
1 for the actions ACC and DEC to penalize excessive speed changes.
Finally, to encourage the vehicle to drive at a speed closer to its maximum speed v max , we give it a penalty of r ef = v − v max v max at every time step.
The above rewards are additive.
So,
[Equation]