University of Dhaka

Department of Computer Science and Engineering

CSE – 4111, Artificial Intelligence Lab

Session: 2018 - 19

Project Name: Avoiding Dead Ends in Real-time Heuristic Search

Submitted by:

Name: Sadeen Mahbub Mobin

Roll: 65

Submitted to:

1. Dr. Md. Mosaddek Khan, Lecturer, Dept. of CSE, DU

2. Md. Mofijul Islam, Lecturer, Dept. of CSE, DU

Date: April 23, 2019

1
 Avoiding Dead Ends in Real-time Heuristic
Search
Authors: Bence Cserna, William J.Doyle, Jordan S.Ramsdell and Wheeler Ruml

Published on: 2018, AAAI

Summary:

In this paper, the authors tried to implement a modified Real-time A* (A-Star) algorithm that can
safely avoid dead ends in real world. To do this, they used SafeRTS algorithm to keep the agent
safe from dead ends. Firstly, the assumed that the user supplies some states that is known to be
safe, from where a goal can be reached without encountering dead ends. When these safe states
are found, all of their ancestors are marked comfortable state because they can lead the agent
to safe states. So, when comfortable states are found, the information is cached so that further
computation can be reduced when agent finds a comfortable state.

They introduced a new Heuristic function Dsafe(n), which is the Manhattan Distance form node n
to safe state. Whenever an agent is in comfortable state, it is sure that the agent will eventually
reach the goal. But in a world having dynamic obstacles, comfortable states change their position.
So, the agent must calculate comfortable state in each step to ensure safety.

When a comfortable node is not found, the algorithm then use Dijkstra to update H values and
then go to the next state having lowest F value. If it finds a comfortable state, it tries to achieve
safe state by propagating from that comfortable state to safe state with dynamic calculation

2
Algorithm of SafeRTS:

The algorithm uses bound which determines how many nodes should be expanded to find
comfortable states. From safe nodes, It finds comfortable states using Dsafe, then it propagates
the safety information to their ancestors. The agent moves from state to state using lowest F
values, and if it finds and comfortable state, it tries to remain its comfortable predecessor states
to lead to safe states.

The algorithm is given below:

Figure 1: SafeRTS Algorithm

3
Shortcomings:

To implement the paper, I faced a huge challenge. I was not able to work on the input data the
author used. Rather I built a static search space and applied SafeRTS on it. As the world was static,
the dead ends were fixed. I made a grid where agent starts at (0, 0) and goal is initially set to (7,
7). There were some barriers given that define dead ends. Some safe states were defined before.
I calculated comfortable states from those safe states and lead the agent from comfortable states
the whole time. Using different dead ends, the agent took different path from the start state to
avoid dead-traps. As it was a static world, I couldn’t do much about the comfortable states as
dead ends were fixed. The comfortable states didn’t change during moving of agent so it was
easy for the agent to stay at comfortable state the whole time.

Performance Evaluation Results:

Graphs:

Path Graphs

Figure 2: Path taken by Agent

4
In figure 2, blue line defines path taken by agent and yellow line means the dead ends. Here,
after going on (2, 2), the agent found out that it was going to get inside dead ends, so it simply
avoided the state and rather chose a comfortable state.

Figure 3: Changed dead-ends

In figure 3, after changing the dead-end’s position, the agent avoided the path it took before as
it might lead the agent to dead-end. So, agent took another path which eventually lead to goal.

Performance Graphs

Figure 4: Goal achievement time VS Search Space

5
In figure 4, as the state space is increasing, the time to find the goal is increasing proportionally.

Figure 5: Goal achievement time VS Node expansion

In figure 5, the goal achievement time is increasing with increasing number of expanded nodes.
The more the nodes to be expanded, the more it needs time to search all the nodes.

Conclusion:

As the state space I worked on was static, it couldn’t match with the actual performance measure
the paper calculated. Some facts the paper states weren’t very catchable. It can be stated that
my evaluation may work in a static world with good accuracy. Though, the implementation is not
perfectly correct for a static world, I think there are scopes for my implementation to be further
improved if provided enough time, data sets and environment.