def compare_algorithms(test_maze):
algo_comparison_df = pd.DataFrame(columns=column_name_list)
# BFS
maze = copy.deepcopy(test_maze)
result_dict = bfs_traversal(maze, len(maze))
path = maze_runner.get_path(dim - 1, dim - 1, maze)
df_entry = pd.DataFrame(
[(len(path), result_dict["total_steps"],
result_dict["max_fringe_length"], result_dict["avg_fringe_length"])],
columns=column_name_list,
index=['BFS'])
algo_comparison_df = algo_comparison_df.append(df_entry)
# DFS
maze = copy.deepcopy(test_maze)
result_dict = dfs_traversal(maze, len(maze))
path = maze_runner.get_path(dim - 1, dim - 1, maze)
df_entry = pd.DataFrame(
[(len(path), result_dict["total_steps"],
result_dict["max_fringe_length"], result_dict["avg_fringe_length"])],
columns=column_name_list,
index=['DFS'])
algo_comparison_df = algo_comparison_df.append(df_entry)
# BD-BFS
maze = copy.deepcopy(test_maze)
result_dict = bd_bfs(maze, len(maze))
df_entry = pd.DataFrame(
[(result_dict["path_length"], result_dict["total_steps"],
result_dict["max_fringe_length"], result_dict["avg_fringe_length"])],
columns=column_name_list,
index=['BD-BFS'])
algo_comparison_df = algo_comparison_df.append(df_entry)
# a-star with manhattan heuristic
maze = copy.deepcopy(test_maze)
result_dict = a_star_traversal(maze, "manhattan")
path = maze_runner.get_path(dim - 1, dim - 1, maze)
df_entry = pd.DataFrame(
[(len(path), result_dict["total_steps"],
result_dict["max_fringe_length"], result_dict["avg_fringe_length"])],
columns=column_name_list,
index=['astar_manhattan'])
algo_comparison_df = algo_comparison_df.append(df_entry)
# a-star with euclidian heuristic
maze = copy.deepcopy(test_maze)
result_dict = a_star_traversal(maze, "euclidian")
path = maze_runner.get_path(dim - 1, dim - 1, maze)
df_entry = pd.DataFrame(
[(len(path), result_dict["total_steps"],
result_dict["max_fringe_length"], result_dict["avg_fringe_length"])],
columns=column_name_list,
index=['astar_euclidian'])
algo_comparison_df = algo_comparison_df.append(df_entry)
return algo_comparison_df
def test_population(new_maze_population):
print "--------------------"
print "Population Solvability Check"
for curr_maze_count in range(new_maze_population.qsize()):
curr_maze = new_maze_population.queue[curr_maze_count]
curr_maze_result_dict = \
a_star_traversal(copy.deepcopy(curr_maze[1]), "manhattan")
if not curr_maze_result_dict["is_solvable"]:
print "ERROR!!!"
maze_runner.visualize_maze(copy.deepcopy(curr_maze[1]))
print curr_maze_result_dict["is_solvable"]
print "--------------------"
def get_avg_times_and_total_tries(dim, p):
total_time = 0
avg_time = 0.0
success_count = 0
max_avg_time = 0
totaltries = 0
for i in xrange(0, 100):
while (True):
test_maze = get_maze(dim, p)
totaltries = totaltries + 1
startTime = time.time()
result_dict = a_star_traversal(test_maze, "manhattan")
end_time = time.time()
if result_dict["is_solvable"]:
time_taken = end_time - startTime
avg_time = avg_time + (time_taken -
avg_time) / (success_count + 1)
total_time += time_taken
success_count = success_count + 1
# print "Success count: " + str(success_count)
break
return avg_time, total_time, totaltries
import maze_runner
from a_star import a_star_traversal
dim = 50
steps_p = []
p_list = [0, 0.1, 0.15, 0.2, 0.25, 0.3]
for p in p_list:
steps = 0
for i in range(10):
while (True):
test_maze = maze_runner.get_maze(dim, p)
result_dict = a_star_traversal(test_maze, "manhattan")
if result_dict["is_solvable"]:
curr_steps = len(result_dict["closed_set"])
steps += curr_steps
break
steps_p.append(steps / 10)
steps_p = steps_p
pyplot.xlabel("P")
pyplot.ylabel("Exploration Steps")
pyplot.title("Exploration Steps v/s p for dim=50")
pyplot.plot(p_list, steps_p, marker='o')
plt.show()
# priority queue with fitness (i.e. hardness) associated with each maze
maze_population = PriorityQueue()
population_size = 50
total_crossovers = 50
mutation_rate = 0.02
generations = 500
population_fitness_vector = []
column_list = ['best_fitness', 'avg_fitness']
generation_stats_df = pd.DataFrame(columns=column_list)
for i in range(population_size):
while True:
maze = maze_runner.get_maze(dim, p)
# find path using a_star
result_dict = a_star_traversal(copy.deepcopy(maze), "manhattan")
# calculate fitness using the max number of nodes explored
maze_fitness = -result_dict["total_steps"]
if result_dict["is_solvable"]:
break
maze_population.put((maze_fitness, copy.deepcopy(maze)))
population_fitness_vector.append(-maze_fitness)
print "initial population generated"
for generation_count in range(generations):
print "Generation: ", generation_count
for crossover_count in range(total_crossovers):
# keep generating child mazes until we find a solvable one