def __init__(self, game, ai_information): self.game = game # Capture AI settings that the user specified search_type = ai_information[0] search_strategy = ai_information[1] # Set the strategy to use to search with if search_strategy == "bfs": search_strategy = BFS() elif search_strategy == "dfs": search_strategy = DFS() elif search_strategy == "astar": search_strategy = AStar(ai_information[2]) elif search_strategy == "idastar": self.search_strategy = IDAStar(game.board, ai_information[2]) else: raise Exception('Invalid search stategy') if search_strategy == "idastar": pass elif (search_type == "tree-search"): self.search_strategy = TreeSearch(game.board, search_strategy) elif (search_type == "graph-search"): self.search_strategy = GraphSearch(game.board, search_strategy) else: raise Exception('Invalid search type')
def main(): test_case_1 = ["CDE", "CFG", "EHE", "EIJ", "GHK", "GLC"] test_case_2 = ["CDE", "CFG", "EHI", "GJC", "GKG"] root_node_1 = geography_node(test_case_1, words_added=["ABC"], name="root") print("BFS of Test Case 1:") print("Result of BFS on Test Case 1: %s, nodes visited: %d\n" % (BFS(root_node_1, node_count_max=128))) print("DFS of Test Case 1:") print("Result of DFS on Test Case 1: %s, nodes visited: %d\n" % (DFS(root_node_1, node_count_max=128))) root_node_2 = geography_node(test_case_2, words_added=["ABC"], name="root") print("BFS of Test Case 2:") print("Result of BFS on Test Case 2: %s, nodes visited: %d\n" % (BFS(root_node_2, node_count_max=128))) print("DFS of Test Case 2:") print("Result of DFS on Test Case 2: %s, nodes visited: %d\n" % (DFS(root_node_2, node_count_max=128)))
def get_search(self): print "================================" print "Choose a Search Method:" print "================================" print "1. Depth First Search" print "2. Breadth First Search" print "3. A* Heuristic Search" search_input = int(raw_input("Enter search choice: => ")) if search_input is -1: return elif search_input is 1: self.search = DFS() elif search_input is 2: self.search = BFS() elif search_input is 3: self.search = AS()
import os, sys sys.path.append('search.py') sys.path.append('heuristics.py') from search import DFS, AStar, BestFirst import heuristics as h import numpy as np if __name__ == '__main__': puzzle = np.array([int(val) for val in sys.argv[1:13]]) if(len(puzzle) != 12): print('INVALID PUZZLE - LENGTH MUST BE 12') sys.exit() bfs = DFS(h.h1, max_depth=int(sys.argv[13]) if len(sys.argv) >= 13 else None, iter_deep=int(sys.argv[14]) if len(sys.argv) >= 14 else None, outfile='Data/Results/puzzleDFS.txt') bfs.traversal(puzzle, verbose=0) for heur_str, func in zip(['h1', 'h2'], [h.h1, h.h2]): bf = BestFirst(outfile='Data/Results/puzzleBFS-%s.txt' % heur_str) bf.traversal(puzzle, func, verbose=0) aS = AStar(outfile='Data/Results/puzzleAs-%s.txt' % heur_str) aS.traversal(puzzle, func, verbose=0)
initState = State(initState) puzzle.setInitialState(initState) puzzleValued.setInitialState(initState) start = timeit.default_timer() BFS(puzzle, puzzle.initialState) end = timeit.default_timer() sumBFS += end - start start = timeit.default_timer() UCS(puzzleValued, puzzleValued.initialState) end = timeit.default_timer() sumUCS += end - start start = timeit.default_timer() DFS(puzzle, puzzle.initialState) end = timeit.default_timer() sumDFS += end - start start = timeit.default_timer() DLS(puzzle, puzzle.initialState, DEPTHLIMIT) end = timeit.default_timer() sumDLS += end - start start = timeit.default_timer() IDS(puzzle, puzzle.initialState) end = timeit.default_timer() sumIDS += end - start start = timeit.default_timer() A_star(puzzleValued, puzzleValued.initialState, heuristicPuzzle)
def main(): """Main method that is run. Main method that takes command line arguments and performs given operation/s. """ from argparse import ArgumentParser from data_loader import get_state_space, get_heuristic from search import BFS, UCS, DFS, lDFS, IDS, GBFS, HCS, AStar from heuristic_check import is_optimistic, is_consistent from puzzle_heuristic import manhattan_distance parser = ArgumentParser( 'run specified search algorithm on a given state space') parser.add_argument('ss', type=str, help='path to a state space to use') parser.add_argument( '-a', '--algorithm', type=str, choices=['bfs', 'ucs', 'dfs', 'ldfs', 'ids', 'gbfs', 'hcs', 'astar'], help='state space search algoritm to use') parser.add_argument('-d', '--depth', type=int, help='maximum depth for the limited DFS') parser.add_argument('-e', '--heuristic', type=str, help='heuristic to use: [path, \'l1\']') parser.add_argument('-c', '--check', action='store_true', help="run checks on heuristic") args = parser.parse_args() s0, transitions, goal = get_state_space(args.ss) heuristic = None if args.heuristic: if args.heuristic == 'l1': heuristic = manhattan_distance(goal) else: heuristic = get_heuristic(args.heuristic) if args.algorithm: if args.algorithm == 'bfs': BFS(s0, transitions, goal) elif args.algorithm == 'ucs': UCS(s0, transitions, goal) elif args.algorithm == 'dfs': DFS(s0, transitions, goal) elif args.algorithm == 'ldfs': if args.depth: lDFS(s0, transitions, goal, args.depth) else: print('Maximum depth not provided.') elif args.algorithm == 'ids': IDS(s0, transitions, goal) elif heuristic: if args.algorithm == 'gbfs': GBFS(s0, transitions, goal, heuristic) elif args.algorithm == 'hcs': HCS(s0, transitions, heuristic) elif args.algorithm == 'astar': AStar(s0, transitions, goal, heuristic) else: print('Invalid algorithm.') else: print('No heuristic provided.') if args.check: if heuristic: print('Checking heuristic') is_optimistic(heuristic, transitions, goal) is_consistent(heuristic, transitions) else: print('No heuristic provided.')
def dfs(ex): return search(ex, DFS(ex.add_waypoints, ex.routes_completed))
def heuristicGraph(state): if state == 0: return 5 if state == 1: return 4 if state == 2: return 4 if state == 3: return 2 if state == 4: return 2 if state == 5: return 0 graph = SimpleGraph() graphValued = SimpleValuedGraph() print('---------Graph----------') print('BFS:', BFS(graph, 0)) print('DFS:', DFS(graph, 0)) print('IDS:', IDS(graph, 0)) print('DLS:', DLS(graph, 0, 3)) print('UCS:', UCS(graphValued, 0)) print('Astar:', A_star(graphValued, 0, heuristicGraph)) #MCTS(graphValued,0,100) def heuristicPuzzle(state): heuristic = 0 goalState = [1,2,3,4,5,6,7,8,0] for x in list(range(0,3)):
#Not the end of the txt if x[j] is not "\n": #Fill the board map if x[j] == "X": board[(i, j)] = x[j] goalsPos[(i, j)] = x[j] numGoals += 1 j += 1 else: board[(i, j)] = x[j] j += 1 #Next character else: j += 1 #Not the end of the txt else: if x is not "\n" and boxFlg == False: player.append(int(x[0])) player.append(int(x[2])) boxFlg = True elif x is not "\n" and boxFlg == True: boxesPos.append([int(x[0]), int(x[2])]) #next line i += 1 read_level(sys.argv[1]) print(DFS(board, player, goalsPos, boxesPos)) print(BFS(board, player, goalsPos, boxesPos)) print(IDFS(board, player, goalsPos, boxesPos))
sys.path.append('search.py') from search import DFS, BestFirst, AStar sys.path.append('heuristics.py') import heuristics as h if __name__ == '__main__': if (True): states = np.load('Data/states_bfs.npy') diffs = np.load('Data/diffs_bfs.npy') max_searches = 10000000 for i, state in enumerate(states): ## BFS ## dfs = DFS(max_searches=max_searches, iter_deep=2, max_depth=3) dfs.traversal(state, func=None, verbose=0) df = pd.DataFrame(dfs.iter_deep_stats, columns=['NumNodes', 'Depth', 'Searches']) df['Time'] = [dfs.overall_time] * len(df) df['Searches'] = [dfs.searches] * len(df) df['Difficulty'] = [diffs[i % len(diffs)]] * len(df) df['SolutionLength'] = [dfs.solution_path_length] * len(df) df.to_pickle('Data/Stats/bfs/state_%d.pkl' % i) ## else: states = np.load('Data/states.npy') diffs = np.load('Data/diffs.npy') max_searches = 15000