from py_plan.base import Operator
buy = Operator('buy', [('Book', '?b'), ('Cost', '?b', '?c'), ('Money', '?m'),
(ge, '?m', '?c')], [('Own', '?b'),
('not', ('Money', '?m')),
('Money', (sub, '?m', '?c'))])
start = [('Money', 30)]
for i in range(30):
book = "book%s" % i
start += [('Book', book), ('Cost', book, 10)]
goal = [('Own', 'book2')]
p = StateSpacePlanningProblem(start, goal, [buy])
def progression(problem):
return partial(depth_first_search, forward=True, backward=False)(problem)
def regression(problem):
return partial(depth_first_search, forward=False, backward=True)(problem)
def bidirectional(problem):
return partial(depth_first_search, forward=True, backward=True)(problem)
compare_searches([p], [progression, regression, bidirectional])
# ('block', 'A'),
# ('block', 'B'),
# ('block', 'C'),
# ('clear', 'A'),
# ('clear', 'B'),
# ('clear', 'C')]
def progression(x):
return breadth_first_search(x, forward=True, backward=False)
def regression(x):
return breadth_first_search(x, forward=False, backward=True)
def bidirectional(x):
return breadth_first_search(x, forward=True, backward=True)
p = StateSpacePlanningProblem(start, goal,
[move_from_table, move_to_table])
# print(next(best_first_search(p)).state)
compare_searches(
[p],
[
progression,
regression,
bidirectional,
# iterative_deepening_search
])
if __name__ == "__main__":
print("###################")
print("BACKTRACKING SEARCH")
print("###################")
initial = nQueens(6)
print("Empty %i-Queens Problem" % initial.n)
print(initial)
print()
compare_searches(problems=[nQueensProblem(initial)],
searches=[
depth_first_search, breadth_first_search,
best_first_search,
iterative_deepening_best_first_search, beam_search
])
print()
print("##########################")
print("LOCAL SEARCH / OPTIMZATION")
print("##########################")
initial = nQueens(10)
initial.randomize()
cost = initial.num_conflicts()
print("Random %i-Queens Problem" % initial.n)
print(initial)
print(cost)
print()
buy = Operator('buy', [('Book', '?b'), ('Cost', '?b', '?c'), ('Money', '?m'),
(ge, '?m', '?c')], [('Own', '?b'),
('not', ('Money', '?m')),
('Money', (sub, '?m', '?c'))])
start = [('Money', 30)]
for i in range(30):
book = "book%s" % i
start += [('Book', book), ('Cost', book, 10)]
goal = [('Own', 'book2')]
p = StateSpacePlanningProblem(start, goal, [buy])
def progression(problem):
return partial(depth_first_search, forward=True, backward=False)(problem)
def regression(problem):
return partial(depth_first_search, forward=False, backward=True)(problem)
compare_searches(
[p],
[
progression,
# regression
])
#op_problem2 = OptimizationProblem((um, uunmapped), initial_cost=uc, extra=rewards)
op_problem3 = StructureMappingOptimizationProblem(
(gm, gunmapped), initial_cost=gc, extra=(instance, concept))
def annealing(problem):
n = (num_objs * num_objs) // 2
return simulated_annealing(problem, temp_length=n)
def greedy_annealing(problem):
n = (num_objs * num_objs) // 2
return simulated_annealing(problem, initial_temp=0, temp_length=n)
def hill(problem):
return hill_climbing(problem)
def beam1(problem):
return local_beam_search(problem, beam_width=1)
compare_searches(
[
#op_problem1,
#op_problem2,
op_problem3
],
[hill, beam1, annealing, greedy_annealing])
#s = next(annealing(op_problem))
#pprint(dict(s.state[0]))
#print(mapping_cost(s.state[0], rewards))
#print(s.cost())
def local_beam_width2(problem):
return local_beam_search(problem, beam_width=2)
def greedy_annealing(problem):
num_neighbors = (n * (n-1)) // 2
return simulated_annealing(problem, initial_temp=0,
temp_length=num_neighbors)
def annealing(problem):
num_neighbors = (n * (n-1)) // 2
return simulated_annealing(problem, initial_temp=1.5,
temp_length=num_neighbors)
compare_searches(problems=[problem],
searches=[hill_climbing,
local_beam_width2,
greedy_annealing,
annealing])
print()
print("###########################")
print("Informed Search Techniques")
print("###########################")
# TREE SEARCH APPROACH
empty = tuple([None for i in range(len(costs))])
unassigned = [i for i in range(len(costs))]
new_costs = [[c - min(row) for c in row] for row in costs]
min_c = [min([row[c] for row in costs]) for c,v in enumerate(costs[0])]
new_costs = [[v - min_c[c] for c, v in enumerate(row)] for row in costs]
def test_compare_problems():
ep = EasyProblem(0, 5)
ip = ImpossibleProblem(0, 5)
compare_searches([ep, ip], [depth_first_search, breadth_first_search])
print("######################################")
print("Local Search / Optimization Techniques")
print("######################################")
problem = LocalGraphPartitionProblem(initial,
initial_cost=cost,
extra=(V, E))
print("Initial Assignment Cost:")
print(cutsize(E, initial))
print("Number of successors:")
print(len(list(problem.successors(problem.initial))))
print()
def annealing(problem):
size = (n * (n // 2)) // 2
return simulated_annealing(problem, initial_temp=5.5, temp_length=size)
def greedy_annealing(problem):
size = (n * (n // 2)) // 2
return simulated_annealing(problem, initial_temp=0, temp_length=size)
def depth_limited_branch_and_bound(problem):
return branch_and_bound(problem, depth_limit=100)
compare_searches(problems=[problem],
searches=[
hill_climbing, annealing, greedy_annealing,
branch_and_bound
])
if __name__ == "__main__":
print("###################")
print("BACKTRACKING SEARCH")
print("###################")
initial = nQueens(5)
print("Empty %i-Queens Problem" % initial.n)
print(initial)
print()
compare_searches(
problems=[nQueensProblem(initial)],
searches=[
depth_first_search,
breadth_first_search,
best_first_search,
iterative_deepening_best_first_search,
beam_search,
],
)
print()
print("##########################")
print("LOCAL SEARCH / OPTIMZATION")
print("##########################")
initial = nQueens(10)
initial.randomize()
print("Random %i-Queens Problem" % initial.n)
print(initial)
print(initial.num_conflicts())
return simulated_annealing(problem,
initial_temp=0,
temp_length=num_neighbors)
def annealing(problem):
num_neighbors = (n * (n - 1)) // 2
return simulated_annealing(problem,
initial_temp=1.5,
temp_length=num_neighbors)
def depth_limited_branch_and_bound(problem):
return branch_and_bound(problem, depth_limit=4)
compare_searches(problems=[problem],
searches=[
depth_limited_branch_and_bound, hill_climbing,
local_beam_width2, greedy_annealing, annealing
])
print()
print("###########################")
print("Informed Search Techniques")
print("###########################")
# TREE SEARCH APPROACH
empty = tuple([None for i in range(len(costs))])
unassigned = [i for i in range(len(costs))]
new_costs = [[c - min(row) for c in row] for row in costs]
min_c = [min([row[c] for row in costs]) for c, v in enumerate(costs[0])]
new_costs = [[v - min_c[c] for c, v in enumerate(row)] for row in costs]
# print("HURRAY!I AM HAPPY")
# print(math_actions_temp)
# print("I AM MORE HAPPY")
#sys.path = os.path.dirnamr(__file__)
#updating ends
if __name__ == "__main__":
actions = {'add': add,
'subtract': subtract,
'multiply': multiply,
'divide': divide }
act_params={'epsilon':0.85}
ap = ActionPlanner(actions,act_params)
s = {('value', 'v1'): -1.03}
explain = -2.05
extra = {}
extra['actions'] = actions
extra['epsilon'] = act_params['epsilon']
extra['tested'] = set()
problem = ActionPlannerProblem((tuple(s.items()), None, explain), extra=extra)
problem2 = NoHeuristic((tuple(s.items()), None, explain), extra=extra)
#print(s)
def cost_limited(problem):
return best_first_search(problem, cost_limit=4)
compare_searches([problem, problem2], [cost_limited])
def annealing(problem):
n = (num_objs * num_objs) // 2
return simulated_annealing(problem, temp_length=n)
def greedy_annealing(problem):
n = (num_objs * num_objs) // 2
return simulated_annealing(problem, initial_temp=0, temp_length=n)
def hill(problem):
return hill_climbing(problem)
def beam1(problem):
return local_beam_search(problem, beam_width=1)
compare_searches([
# op_problem1,
# op_problem2,
op_problem3
], [
hill,
beam1,
annealing,
greedy_annealing
])
# s = next(annealing(op_problem))
# pprint(dict(s.state[0]))
# print(mapping_cost(s.state[0], rewards))
# print(s.cost())
putdown = Operator('putdown', [('holding', '?x')],
[('not', ('holding', '?x')), ('on', '?x', 'table'),
('clear', '?x'), ('hand-empty')])
stack = Operator('stack', [('holding', '?x'), ('clear', '?y')],
[('not', ('holding', '?x')), ('not', ('clear', '?y')),
('on', '?x', '?y'), ('clear', '?x'), ('hand-empty')])
unstack = Operator('unstack', [('on', '?x', '?y'), ('clear', '?x'),
(operator.ne, '?y', 'table'),
('hand-empty')],
[('not', ('on', '?x', '?y')), ('not', ('clear', '?x')),
('holding', '?x'), ('clear', '?y'),
('not', ('hand-empty'))])
successor = Operator('successor', [('number', '?x')],
[('number', ('S', '?x'))])
state = [('on', 'C', 'A'), ('on', 'A', 'table'), ('on', 'B', 'table'),
('clear', 'B'), ('clear', 'C'), ('hand-empty')]
# state = [('on', 'B', 'A'), ('on', 'A', 'table'), ('clear', 'B'),
# ('hand-empty'), ('on', 'C', 'table'), ('clear', 'C')]
goals = [('on', 'A', 'B'), ('on', 'B', 'C')]
p = StateSpacePlanningProblem(state, goals,
[pickup, putdown, stack, unstack])
compare_searches(
[p], [depth_first_search, breadth_first_search, best_first_search])
print("######################################")
print("Local Search / Optimization Techniques")
print("######################################")
problem = LocalGraphPartitionProblem(initial, extra=(V,E))
print("Initial Assignment Cost:")
print(cutsize(E, initial))
print("Number of successors:")
print(len(list(problem.successors(problem.initial))))
print()
def annealing(problem):
size = (n * (n//2)) // 2
return simulated_annealing(problem, initial_temp=5.5,
temp_length=size)
def greedy_annealing(problem):
size = (n * (n//2)) // 2
return simulated_annealing(problem, initial_temp=0,
temp_length=size)
compare_searches(problems=[problem],
searches=[
hill_climbing,
annealing,
greedy_annealing
])
