def return_plan(v, universe): plan = [] for action, args in get_plan(v): if not hasattr(action.original, 'is_internal'): plan.append( (action.original, args[:len(action.original.parameters)])) universe.print_statistics() if plan is not None and universe.verbose: print_plan_stats(plan, universe) return plan, universe
def simultaneous_strips(problem, max_time=INF, max_iterations=INF, frequency=100, verbose=False, debug=False, optimal=False): # TODO - prune any unnecessary cond_streams universe = Universe(problem, use_ground=False, make_action_instances=True, verbose=verbose) stream_queue = deque() add_streams(universe, stream_queue) universe.root = Vertex(universe.initial_fluents()) universe.vertices = {universe.root} universe.goal_vertices = set() universe.vertex_queue = deque() universe.state_map = defaultdict(list) universe.action_map = defaultdict(list) for vertex in universe.vertices: for a in universe.name_to_action.values(): for key in get_vertex_keys(vertex, a, universe): universe.state_map[key].append(vertex) for _ in irange(0, max_iterations): print_helper(universe) if debug: debug_helper(universe) universe.iterations += 1 stream_atoms = universe.initial_stream_atoms( ) # TODO - could always augment the state with the static atoms or just ignore them new_axioms = filter(lambda op: isinstance(op.lifted, Axiom), universe.new_instances) new_actions = filter(lambda op: isinstance(op.lifted, Action), universe.new_instances) axioms = filter(lambda op: isinstance(op.lifted, Axiom), universe.action_instances) actions = filter(lambda op: isinstance(op.lifted, Action), universe.action_instances) #if verbose: print 'New Actions: %d | New Axioms: %s | Total Actions: %s | Total Axioms: %s\n' % ( len(new_actions), len(new_axioms), len(actions), len(axioms)) # TODO - recombine with simultaneous for instance in universe.new_instances: universe.action_map[get_operator_key(instance, universe)].append(instance) t0 = time() success = False for instance in new_actions: for vertex in get_vertices(instance, universe): #print action.lifted.name, map(get_value, action.args), vertex #raw_input('Continue?') if apply_actions(vertex, [instance], stream_atoms, universe, optimal): success = True break if success: break if success: break for vertex in list( universe.vertices): # Process new_axioms and actions if apply_axioms(vertex, new_axioms, stream_atoms, universe) and \ apply_actions(vertex, actions, stream_atoms, universe, optimal): break #elif apply_actions(vertex, new_actions, stream_atoms, universe, optimal): # break universe.new_instances = [] # NOTE - didn't have this before while universe.vertex_queue: # Process new_vertices vertex = universe.vertex_queue.popleft() apply_axioms(vertex, axioms, stream_atoms, universe) #if apply_actions(vertex, actions, stream_atoms, universe, optimal): if apply_actions_strips(vertex, stream_atoms, universe, optimal): #if apply_actions(vertex, get_actions(vertex, universe), stream_atoms, universe, optimal): break universe.search_time += time() - t0 if (not optimal and universe.goal_vertices) or not call_queue( stream_queue, universe, frequency, max_time): break # TODO - call queue waves dijkstra(universe) best_v, best_plan = None, None if universe.goal_vertices: best_v = argmin(lambda v: v.cost, universe.goal_vertices) best_plan = get_plan(best_v) if verbose: universe.print_statistics() if best_plan is not None: print_plan_stats(best_plan, universe) print 'Cost:', best_v.cost return best_plan, universe
def simultaneous(problem, max_time=INF, max_iterations=INF, frequency=100, verbose=False, debug=False, optimal=False): # TODO - prune any unnecessary cond_streams universe = Universe(problem, use_ground=False, make_action_instances=True, verbose=verbose) stream_queue = deque() add_streams(universe, stream_queue) universe.root = Vertex(universe.initial_fluents()) universe.vertices = {universe.root} universe.goal_vertices = set() universe.vertex_queue = deque() for _ in irange(0, max_iterations): print_helper(universe) if debug: debug_helper(universe) universe.iterations += 1 stream_atoms = universe.initial_stream_atoms( ) # TODO - could always augment the state with the static atoms or just ignore them new_axioms = filter(lambda op: isinstance(op.lifted, Axiom), universe.new_instances) new_actions = filter(lambda op: isinstance(op.lifted, Action), universe.new_instances) axioms = filter(lambda op: isinstance(op.lifted, Axiom), universe.action_instances) actions = filter(lambda op: isinstance(op.lifted, Action), universe.action_instances) #if verbose: print 'New Actions: %d | New Axioms: %s | Total Actions: %s | Total Axioms: %s\n' % ( len(new_actions), len(new_axioms), len(actions), len(axioms)) t0 = time() for vertex in list( universe.vertices): # Process new_axioms and actions if apply_axioms(vertex, new_axioms, stream_atoms, universe) and \ apply_actions(vertex, actions, stream_atoms, universe, optimal): break elif apply_actions(vertex, new_actions, stream_atoms, universe, optimal): break universe.new_instances = [] # NOTE - didn't have this before while universe.vertex_queue: # Process new_vertices vertex = universe.vertex_queue.popleft() apply_axioms(vertex, axioms, stream_atoms, universe) if apply_actions(vertex, actions, stream_atoms, universe, optimal): break universe.search_time += time() - t0 if (not optimal and universe.goal_vertices) or not call_queue( stream_queue, universe, frequency, max_time): break # TODO - call queue waves dijkstra(universe) best_v, best_plan = None, None if universe.goal_vertices: best_v = argmin(lambda v: v.cost, universe.goal_vertices) best_plan = get_plan(best_v) if verbose: universe.print_statistics() if best_plan is not None: print_plan_stats(best_plan, universe) print 'Cost:', best_v.cost return best_plan, universe
def incremental_planner(problem, search=DEFAULT_SEARCH, max_time=INF, max_iterations=INF, max_calls=INF, waves=True, frequency=1, optimal=False, verbose=False, debug=False): """ Incremental algorithm. :param problem: :class:`.STRIPStreamProblem` :param search: python function of the search subroutine :param max_time: numeric maximum planning time :param max_iterations: int maximum subroutine calls :param waves: boolean flag when ``True`` considers each stream evaluation iteration to be the current queue rather than a single stream :param frequency: numeric number of evaluation iterations given by ``waves`` (``float('inf')`` implies to evaluate all streams per iteration) :param optimal: boolean flag which saves the best current solution :param verbose: boolean flag which toggles the print output :param debug: boolean flag which prints the objects on each iteration :return: a sequence of :class:`.Action` and tuple of :class:`.Constant` pairs as well as :class:`.Universe` """ universe = Universe(problem, use_ground=False, verbose=verbose) queue = deque() add_streams(universe, queue) best_plan, best_cost = None, INF for _ in irange(0, max_iterations): print 'Iteration: %d | Time: %s | Calls: %s | Search Time: %s | Solved: %s | Cost: %s' % ( universe.iterations, round(time() - universe.start_time, 3), universe.calls, round(universe.search_time, 3), best_plan is not None, best_cost) if debug: for type in universe.type_to_objects: print type, len(universe.type_to_objects[type]), map( get_value, universe.type_to_objects[type])[:10] raw_input('Continue?\n') universe.iterations += 1 t0 = time() plan = search(universe, max_time - (time() - universe.start_time), best_cost) universe.search_time += time() - t0 if plan is not None: cost = plan_cost(universe, plan) if cost < best_cost: best_plan, best_cost = plan, cost if verbose: print best_cost, convert_plan(best_plan) if not optimal: break if waves and not call_queue_wave(queue, universe, frequency, max_time, max_calls): break if not waves and not call_queue(queue, universe, frequency, max_time, max_calls): break if verbose: universe.print_statistics() if best_plan is not None: print_plan_stats(best_plan, universe) print 'Cost:', best_cost print 'Length:', len(best_plan) return best_plan, universe
def print_solved(universe, plan): universe.print_statistics() print_plan_stats(plan, universe)
def incremental_planner( problem, search=DEFAULT_SEARCH, max_time=INF, min_cost=INF, waves=True, frequency=1, optimal=False, # TODO: remove optimal postprocess_time=None, verbose=False, debug=False): """ Incremental algorithm. :param problem: :class:`.STRIPStreamProblem` :param search: python function of the search subroutine :param max_time: numeric maximum planning time :param max_iterations: int maximum subroutine calls :param waves: boolean flag when ``True`` considers each stream evaluation iteration to be the current queue rather than a single stream :param frequency: numeric number of evaluation iterations given by ``waves`` (``float('inf')`` implies to evaluate all streams per iteration) :param optimal: boolean flag which saves the best current solution :param verbose: boolean flag which toggles the print output :param debug: boolean flag which prints the objects on each iteration :return: a sequence of :class:`.Action` and tuple of :class:`.Constant` pairs as well as :class:`.Universe` """ for stream in problem.cond_streams: if not stream.sign and not stream.eager: print 'Warning! Setting stream', stream, 'to eager because used negatively' stream.eager = True #print SEPARATOR universe = Universe(problem, use_ground=False, verbose=verbose) #useful_atoms, useful_types = useful_universe(universe) #stream_pairs = get_streams(useful_atoms, useful_types, universe) # TODO - prune any unnecessary cond_streams queue = deque() add_streams(universe, queue) best_plan, best_cost = None, INF while True: print_status(universe, best_plan, best_cost) if debug: debug_planner(universe) universe.iterations += 1 if (not optimal) or (postprocess_time is None): best_plan, best_cost = update_best_plan( universe, search, best_plan, best_cost, max_time - (time() - universe.start_time)) if (best_plan is not None) and ((not optimal) or (best_cost <= 0)): break if waves and not call_queue_wave(queue, universe, frequency, max_time): break if not waves and not call_queue(queue, universe, frequency, max_time): break add_streams( universe, queue ) # TODO: hack for postprocess_time != None to not give "Could not find instantiation for PNE!" best_plan, best_cost = update_best_plan(universe, search, best_plan, best_cost, postprocess_time) print_status(universe, best_plan, best_cost) if verbose: universe.print_statistics() if best_plan is not None: print_plan_stats(best_plan, universe) print 'Cost: {}\nLength: {}'.format(best_cost, len(best_plan)) return best_plan, universe