def examine_instantiated(problem, constraints=PlanConstraints(), unit_costs=False, max_time=INF, verbose=False, **search_args): domain_pddl, constant_map, stream_pddl, _, init, goal = problem stream_map = DEBUG problem = PDDLProblem(domain_pddl, constant_map, stream_pddl, stream_map, init, goal) evaluations, goal_exp, domain, externals = parse_problem( problem, constraints=constraints, unit_costs=unit_costs) store = SolutionStore(evaluations, max_time, success_cost=INF, verbose=verbose) #externals = compile_fluents_as_attachments(domain, externals) # instantiator = Instantiator(externals, evaluations) process_stream_queue(instantiator, store, complexity_limit=INF, verbose=verbose) #plan, cost = solve_finite(evaluations, goal_exp, domain, max_cost=max_cost, **search_args) debug = False assert not isinstance(domain, SimplifiedDomain) problem = get_problem(evaluations, goal_exp, domain, unit_costs) task = task_from_domain_problem(domain, problem) with Verbose(debug): instantiated = instantiate_task(task) instantiated = convert_instantiated(instantiated) return instantiated
def instantiate_optimizer_axioms(instantiated, domain, results): # Needed for instantiating axioms before adding stream action effects # Otherwise, FastDownward will prune these unreachable axioms # TODO: compute this first and then apply the eager actions stream_init = { fd_from_fact(result.stream_fact) for result in results if isinstance(result, StreamResult) } evaluations = list( map(evaluation_from_fd, stream_init | instantiated.atoms)) temp_domain = make_domain( predicates=[make_predicate(UNSATISFIABLE, [])], axioms=[ax for ax in domain.axioms if ax.name == UNSATISFIABLE]) temp_problem = get_problem(evaluations, Not((UNSATISFIABLE, )), temp_domain) # TODO: UNSATISFIABLE might be in atoms making the goal always infeasible with Verbose(): # TODO: the FastDownward instantiation prunes static preconditions use_fd = False if using_optimizers(results) else FD_INSTANTIATE new_instantiated = instantiate_task(task_from_domain_problem( temp_domain, temp_problem), use_fd=use_fd, check_infeasible=False, prune_static=False) assert new_instantiated is not None instantiated.axioms.extend(new_instantiated.axioms) instantiated.atoms.update(new_instantiated.atoms)
def solve_optimistic_temporal(domain, stream_domain, applied_results, all_results, opt_evaluations, node_from_atom, goal_expression, effort_weight, debug=False, **kwargs): # TODO: assert that the unused parameters are off assert domain is stream_domain #assert len(applied_results) == len(all_results) problem = get_problem(opt_evaluations, goal_expression, domain) with Verbose(): instantiated = instantiate_task(task_from_domain_problem(domain, problem)) if instantiated is None: return instantiated, None, None, INF problem = get_problem_pddl(opt_evaluations, goal_expression, domain.pddl) pddl_plan, makespan = solve_tfd(domain.pddl, problem, debug=debug, **kwargs) if pddl_plan is None: return instantiated, None, pddl_plan, makespan instance_from_action_args = defaultdict(list) for instance in instantiated.actions: name, args = parse_action(instance) instance_from_action_args[name, args].append(instance) #instance.action, instance.var_mapping action_instances = [] for action in pddl_plan: instances = instance_from_action_args[action.name, action.args] if len(instances) != 1: for action in instances: action.dump() #assert len(instances) == 1 # TODO: support 2 <= case action_instances.append(instances[0]) temporal_plan = obj_from_pddl_plan(pddl_plan) # pddl_plan is sequential return instantiated, action_instances, temporal_plan, makespan
def solve_optimistic_sequential(domain, stream_domain, applied_results, all_results, opt_evaluations, node_from_atom, goal_expression, effort_weight, debug=False, **kwargs): #print(sorted(map(fact_from_evaluation, opt_evaluations))) temporal_plan = None problem = get_problem(opt_evaluations, goal_expression, stream_domain) # begin_metric with Verbose(verbose=False): instantiated = instantiate_task(task_from_domain_problem(stream_domain, problem)) if instantiated is None: return instantiated, None, temporal_plan, INF cost_from_action = {action: action.cost for action in instantiated.actions} add_stream_efforts(node_from_atom, instantiated, effort_weight) if using_optimizers(applied_results): add_optimizer_effects(instantiated, node_from_atom) # TODO: reachieve=False when using optimizers or should add applied facts instantiate_optimizer_axioms(instantiated, domain, all_results) action_from_name = rename_instantiated_actions(instantiated, RENAME_ACTIONS) # TODO: the action unsatisfiable conditions are pruned with Verbose(debug): sas_task = sas_from_instantiated(instantiated) sas_task.metric = True # TODO: apply renaming to hierarchy as well # solve_from_task | serialized_solve_from_task | abstrips_solve_from_task | abstrips_solve_from_task_sequential renamed_plan, _ = solve_from_task(sas_task, debug=debug, **kwargs) if renamed_plan is None: return instantiated, None, temporal_plan, INF action_instances = [action_from_name[name if RENAME_ACTIONS else '({} {})'.format(name, ' '.join(args))] for name, args in renamed_plan] cost = get_plan_cost(action_instances, cost_from_action) return instantiated, action_instances, temporal_plan, cost
def examine_instantiated(problem, constraints=PlanConstraints(), unit_costs=False, unique=False, verbose=False, debug=False): # TODO: refactor to an analysis file domain_pddl, constant_map, stream_pddl, _, init, goal = problem stream_map = DEBUG if unique else SHARED_DEBUG # DEBUG_MODES problem = PDDLProblem(domain_pddl, constant_map, stream_pddl, stream_map, init, goal) evaluations, goal_exp, domain, externals = parse_problem( problem, constraints=constraints, unit_costs=unit_costs) assert not isinstance(domain, SimplifiedDomain) # store = SolutionStore(evaluations, max_time, success_cost=INF, verbose=verbose) # instantiator = Instantiator(externals, evaluations) # process_stream_queue(instantiator, store, complexity_limit=INF, verbose=verbose) # results = [] # TODO: extract from process_stream_queue #set_unique(externals) # domain.actions[:] = [] # TODO: only instantiate axioms # TODO: drop all fluents and instantiate # TODO: relaxed planning version of this results, exhausted = optimistic_process_streams(evaluations, externals, complexity_limit=INF, max_effort=None) evaluations = evaluations_from_stream_plan(evaluations, results, max_effort=None) problem = get_problem(evaluations, goal_exp, domain, unit_costs) task = task_from_domain_problem(domain, problem) with Verbose(debug): instantiated = instantiate_task(task) if instantiated is None: return None # TODO: reinstantiate actions? instantiated.axioms[:] = [reinstantiate_axiom(axiom) for axiom in instantiated.axioms] instantiated = convert_instantiated(instantiated) return results, instantiated
def solve_optimistic_sequential(domain, stream_domain, applied_results, all_results, opt_evaluations, node_from_atom, goal_expression, effort_weight, debug=False, **kwargs): if isinstance(stream_domain, SimplifiedDomain): return solve_optimistic_temporal(domain, stream_domain, applied_results, all_results, opt_evaluations, node_from_atom, goal_expression, effort_weight, debug=debug, **kwargs) problem = get_problem(opt_evaluations, goal_expression, stream_domain) # begin_metric with Verbose(): instantiated = instantiate_task(task_from_domain_problem(stream_domain, problem)) if instantiated is None: return instantiated, None, None, INF cost_from_action = add_stream_efforts(node_from_atom, instantiated, effort_weight) if using_optimizers(applied_results): add_optimizer_effects(instantiated, node_from_atom) # TODO: reachieve=False when using optimizers or should add applied facts instantiate_optimizer_axioms(instantiated, domain, all_results) action_from_name = rename_instantiated_actions(instantiated) with Verbose(debug): sas_task = sas_from_instantiated(instantiated) sas_task.metric = True # TODO: apply renaming to hierarchy as well # solve_from_task | serialized_solve_from_task | abstrips_solve_from_task | abstrips_solve_from_task_sequential renamed_plan, _ = solve_from_task(sas_task, debug=debug, **kwargs) if renamed_plan is None: return instantiated, None, None, INF action_instances = [action_from_name[name] for name, _ in renamed_plan] cost = get_plan_cost(action_instances, cost_from_action) # plan = obj_from_pddl_plan(parse_action(instance.name) for instance in action_instances) plan = obj_from_pddl_plan(map(pddl_from_instance, action_instances)) return instantiated, action_instances, plan, cost
def solve_optimistic_temporal(domain, stream_domain, applied_results, all_results, opt_evaluations, node_from_atom, goal_expression, effort_weight, debug=False, **kwargs): assert domain is stream_domain #assert len(applied_results) == len(all_results) problem = get_problem(opt_evaluations, goal_expression, domain) with Verbose(): instantiated = instantiate_task(task_from_domain_problem(domain, problem)) if instantiated is None: return instantiated, None, None, INF problem = get_problem_pddl(opt_evaluations, goal_expression, domain.pddl) pddl_plan, makespan = solve_tfd(domain.pddl, problem, debug=debug) if pddl_plan is None: return instantiated, None, pddl_plan, makespan instance_from_action_args = defaultdict(list) for instance in instantiated.actions: tokens = instance.name.strip('()').split(' ') name, args = tokens[0], tuple(tokens[1:]) instance_from_action_args[name, args].append(instance) #instance.action, instance.var_mapping action_instances = [] for action in pddl_plan: instances = instance_from_action_args[action.name, action.args] assert len(instances) == 1 # TODO: support 2 <= case action_instances.append(instances[0]) plan = obj_from_pddl_plan(pddl_plan) return instantiated, action_instances, plan, makespan
def solve_sequential(evaluations, goal_exp, domain, unit_costs=False, debug=False, **search_args): problem = get_problem(evaluations, goal_exp, domain, unit_costs) task = task_from_domain_problem(domain, problem) if has_attachments(domain): with Verbose(debug): instantiated = instantiate_task(task) return solve_pyplanners(instantiated, **search_args) sas_task = sas_from_pddl(task, debug=debug) return abstrips_solve_from_task(sas_task, debug=debug, **search_args)
def solve_finite(evaluations, goal_exp, domain, unit_costs=False, debug=False, **search_args): if isinstance(domain, SimplifiedDomain): problem = get_problem_pddl(evaluations, goal_exp, domain.pddl) pddl_plan, cost = solve_tfd(domain.pddl, problem, debug=debug) else: problem = get_problem(evaluations, goal_exp, domain, unit_costs) task = task_from_domain_problem(domain, problem) if has_attachments(domain): with Verbose(debug): instantiated = instantiate_task(task) pddl_plan, cost = solve_pyplanners(instantiated, **search_args) else: sas_task = sas_from_pddl(task, debug=debug) pddl_plan, cost = abstrips_solve_from_task(sas_task, debug=debug, **search_args) plan = obj_from_pddl_plan(pddl_plan) return plan, cost