def plan_streams(evaluations, goal_expression, domain, all_results, negative, effort_weight, max_effort, simultaneous=False, reachieve=True, replan_actions=set(), **kwargs): # TODO: alternatively could translate with stream actions on real opt_state and just discard them # TODO: only consider axioms that have stream conditions? #reachieve = reachieve and not using_optimizers(all_results) #for i, result in enumerate(all_results): # print(i, result, result.get_effort()) applied_results, deferred_results = partition_results( evaluations, all_results, apply_now=lambda r: not (simultaneous or r.external.info.simultaneous)) stream_domain, deferred_from_name = add_stream_actions(domain, deferred_results) if reachieve and not using_optimizers(all_results): achieved_results = {n.result for n in evaluations.values() if isinstance(n.result, Result)} init_evaluations = {e for e, n in evaluations.items() if n.result not in achieved_results} applied_results = achieved_results | set(applied_results) evaluations = init_evaluations # For clarity # TODO: could iteratively increase max_effort node_from_atom = get_achieving_streams(evaluations, applied_results, # TODO: apply to all_results? max_effort=max_effort) opt_evaluations = {evaluation_from_fact(f): n.result for f, n in node_from_atom.items()} if UNIVERSAL_TO_CONDITIONAL or using_optimizers(all_results): goal_expression = add_unsatisfiable_to_goal(stream_domain, goal_expression) temporal = isinstance(stream_domain, SimplifiedDomain) optimistic_fn = solve_optimistic_temporal if temporal else solve_optimistic_sequential instantiated, action_instances, temporal_plan, cost = optimistic_fn( domain, stream_domain, applied_results, all_results, opt_evaluations, node_from_atom, goal_expression, effort_weight, **kwargs) if action_instances is None: return FAILED, FAILED, cost action_instances, axiom_plans = recover_axioms_plans(instantiated, action_instances) # TODO: extract out the minimum set of conditional effects that are actually required #simplify_conditional_effects(instantiated.task, action_instances) stream_plan, action_instances = recover_simultaneous( applied_results, negative, deferred_from_name, action_instances) action_plan = transform_plan_args(map(pddl_from_instance, action_instances), obj_from_pddl) replan_step = min([step+1 for step, action in enumerate(action_plan) if action.name in replan_actions] or [len(action_plan)+1]) # step after action application stream_plan, opt_plan = recover_stream_plan(evaluations, stream_plan, opt_evaluations, goal_expression, stream_domain, node_from_atom, action_instances, axiom_plans, negative, replan_step) if temporal_plan is not None: # TODO: handle deferred streams assert all(isinstance(action, Action) for action in opt_plan.action_plan) opt_plan.action_plan[:] = temporal_plan return stream_plan, opt_plan, cost
def instantiate_optimizer_axioms(instantiated, evaluations, goal_expression, 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_evaluations = set(map(evaluation_from_fact, get_stream_facts(applied_results))) stream_domain, result_from_name = add_stream_actions(domain, results) # Need unit_costs=True otherwise obtain an instantiation error problem = get_problem(evaluations, goal_expression, stream_domain, unit_costs=True) with Verbose(): new_instantiated = instantiate_task( task_from_domain_problem(stream_domain, problem)) instantiated.axioms[:] = new_instantiated.axioms instantiated.atoms.update(new_instantiated.atoms)
def plan_streams(evaluations, goal_expression, domain, all_results, negative, effort_weight, max_effort, simultaneous=False, reachieve=True, **kwargs): # TODO: alternatively could translate with stream actions on real opt_state and just discard them # TODO: only consider axioms that have stream conditions? #reachieve = reachieve and not using_optimizers(all_results) applied_results, deferred_results = partition_results( evaluations, all_results, apply_now=lambda r: not (simultaneous or r.external.info.simultaneous)) stream_domain, deferred_from_name = add_stream_actions(domain, deferred_results) if reachieve and not using_optimizers(all_results): achieved_results = {n.result for n in evaluations.values() if isinstance(n.result, Result)} init_evaluations = {e for e, n in evaluations.items() if n.result not in achieved_results} applied_results = achieved_results | set(applied_results) evaluations = init_evaluations # For clarity # TODO: could iteratively increase max_effort node_from_atom = get_achieving_streams(evaluations, applied_results, # TODO: apply to all_results? max_effort=max_effort) opt_evaluations = {evaluation_from_fact(f): n.result for f, n in node_from_atom.items()} if UNIVERSAL_TO_CONDITIONAL or using_optimizers(all_results): goal_expression = add_unsatisfiable_to_goal(stream_domain, goal_expression) instantiated, action_instances, action_plan, cost = solve_optimistic_sequential( domain, stream_domain, applied_results, all_results, opt_evaluations, node_from_atom, goal_expression, effort_weight, **kwargs) if action_plan is None: return action_plan, cost axiom_plans = recover_axioms_plans(instantiated, action_instances) # TODO: extract out the minimum set of conditional effects that are actually required #simplify_conditional_effects(instantiated.task, action_instances) stream_plan, action_instances = recover_simultaneous( applied_results, negative, deferred_from_name, action_instances) stream_plan = recover_stream_plan(evaluations, stream_plan, opt_evaluations, goal_expression, stream_domain, node_from_atom, action_instances, axiom_plans, negative) combined_plan = stream_plan + action_plan return combined_plan, cost
def plan_streams(evaluations, goal_expression, domain, all_results, negative, effort_weight, max_effort, simultaneous=False, reachieve=True, debug=False, **kwargs): # TODO: alternatively could translate with stream actions on real opt_state and just discard them # TODO: only consider axioms that have stream conditions? #reachieve = reachieve and not using_optimizers(all_results) applied_results, deferred_results = partition_results( evaluations, all_results, apply_now=lambda r: not (simultaneous or r.external.info.simultaneous)) stream_domain, deferred_from_name = add_stream_actions( domain, deferred_results) if reachieve and not using_optimizers(all_results): achieved_results = { n.result for n in evaluations.values() if isinstance(n.result, Result) } init_evaluations = { e for e, n in evaluations.items() if n.result not in achieved_results } applied_results = achieved_results | set(applied_results) evaluations = init_evaluations # For clarity # TODO: could iteratively increase max_effort node_from_atom = get_achieving_streams( evaluations, applied_results, # TODO: apply to all_results? max_effort=max_effort) opt_evaluations = { evaluation_from_fact(f): n.result for f, n in node_from_atom.items() } if using_optimizers(all_results): goal_expression = add_unsatisfiable_to_goal(stream_domain, goal_expression) problem = get_problem(opt_evaluations, goal_expression, stream_domain) # begin_metric with Verbose(debug): instantiated = instantiate_task( task_from_domain_problem(stream_domain, problem)) if instantiated is None: return None, INF if using_optimizers(all_results): # TODO: reachieve=False when using optimizers or should add applied facts instantiate_optimizer_axioms(instantiated, evaluations, goal_expression, domain, all_results) 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) 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 action_plan, raw_cost = solve_from_task(sas_task, debug=debug, **kwargs) #print(raw_cost) if action_plan is None: return None, INF action_instances = [action_from_name[name] for name, _ in action_plan] simplify_conditional_effects(instantiated.task, action_instances) stream_plan, action_instances = recover_simultaneous( applied_results, negative, deferred_from_name, action_instances) cost = get_plan_cost(action_instances, cost_from_action) axiom_plans = recover_axioms_plans(instantiated, action_instances) stream_plan = recover_stream_plan(evaluations, stream_plan, opt_evaluations, goal_expression, stream_domain, node_from_atom, action_instances, axiom_plans, negative) #action_plan = obj_from_pddl_plan(parse_action(instance.name) for instance in action_instances) action_plan = obj_from_pddl_plan(map(pddl_from_instance, action_instances)) combined_plan = stream_plan + action_plan return combined_plan, cost