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): 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_finite(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) 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
def solve_finite(evaluations, goal_exp, domain, **kwargs): if isinstance(domain, SimplifiedDomain): pddl_plan, cost = solve_temporal(evaluations, goal_exp, domain, **kwargs) else: pddl_plan, cost = solve_sequential(evaluations, goal_exp, domain, **kwargs) plan = obj_from_pddl_plan(pddl_plan) return plan, cost
def solve_finite(evaluations, goal_expression, domain, unit_costs=None, **kwargs): if unit_costs is None: unit_costs = not has_costs(domain) problem = get_problem(evaluations, goal_expression, domain, unit_costs) task = task_from_domain_problem(domain, problem) plan_pddl, cost = solve_from_task(task, **kwargs) return obj_from_pddl_plan(plan_pddl), cost
def solve_finite(evaluations, goal_expression, domain, unit_costs=None, debug=False, **kwargs): if unit_costs is None: unit_costs = not has_costs(domain) problem = get_problem(evaluations, goal_expression, domain, unit_costs) task = task_from_domain_problem(domain, problem) sas_task = sas_from_pddl(task, debug=debug) plan_pddl, cost = abstrips_solve_from_task(sas_task, debug=debug, **kwargs) return obj_from_pddl_plan(plan_pddl), cost
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
def relaxed_stream_plan(evaluations, goal_expression, domain, stream_results, negative, unit_costs, **kwargs): # TODO: alternatively could translate with stream actions on real opt_state and just discard them opt_evaluations = evaluations_from_stream_plan(evaluations, stream_results) problem = get_problem(opt_evaluations, goal_expression, domain, unit_costs) task = task_from_domain_problem(domain, problem) action_plan, action_cost = solve_from_task(task, **kwargs) if action_plan is None: return None, action_cost # TODO: just use solve finite? stream_plan = recover_stream_plan(evaluations, goal_expression, domain, stream_results, action_plan, negative, unit_costs) action_plan = obj_from_pddl_plan(action_plan) combined_plan = stream_plan + action_plan return combined_plan, action_cost
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: task = task_from_domain_problem( domain, get_problem(evaluations, goal_exp, domain, unit_costs)) 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
def relaxed_stream_plan(evaluations, goal_expression, domain, stream_results, negative, unit_costs, unit_efforts, effort_weight, 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? applied_results, deferred_results = partition_results(evaluations, stream_results, apply_now=lambda r: not r.external.info.simultaneous) stream_domain, result_from_name = add_stream_actions(domain, deferred_results) node_from_atom = get_achieving_streams(evaluations, applied_results) opt_evaluations = apply_streams(evaluations, applied_results) # if n.effort < INF if any(map(is_optimizer_result, stream_results)): goal_expression = augment_goal(stream_domain, goal_expression) problem = get_problem(opt_evaluations, goal_expression, stream_domain, unit_costs) # begin_metric with Verbose(debug): instantiated = instantiate_task(task_from_domain_problem(stream_domain, problem)) if instantiated is None: return None, INF if (effort_weight is not None) or any(map(is_optimizer_result, applied_results)): add_stream_costs(node_from_atom, instantiated, unit_efforts, effort_weight) add_optimizer_axioms(stream_results, instantiated) with Verbose(debug): sas_task = sas_from_instantiated(instantiated) sas_task.metric = True #sas_task = sas_from_pddl(task) #action_plan, _ = serialized_solve_from_task(sas_task, debug=debug, **kwargs) action_plan, _ = abstrips_solve_from_task(sas_task, debug=debug, **kwargs) #action_plan, _ = abstrips_solve_from_task_sequential(sas_task, debug=debug, **kwargs) if action_plan is None: return None, INF applied_plan, function_plan = partition_external_plan(recover_stream_plan( evaluations, goal_expression, stream_domain, applied_results, action_plan, negative, unit_costs)) deferred_plan, action_plan = partition_plan(action_plan, result_from_name) stream_plan = applied_plan + deferred_plan + function_plan action_plan = obj_from_pddl_plan(action_plan) cost = get_plan_cost(opt_evaluations, action_plan, domain, unit_costs) combined_plan = stream_plan + action_plan return combined_plan, cost
def relaxed_stream_plan(evaluations, goal_expression, domain, all_results, negative, unit_efforts, effort_weight, max_effort, simultaneous=False, reachieve=True, unit_costs=False, 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? applied_results, deferred_results = partition_results( evaluations, all_results, apply_now=lambda r: not (simultaneous or r.external.info.simultaneous)) stream_domain, result_from_name = add_stream_actions( domain, deferred_results) opt_evaluations = apply_streams(evaluations, applied_results) # if n.effort < INF if reachieve: achieved_results = { r for r in evaluations.values() if isinstance(r, Result) } init_evaluations = { e for e, r in evaluations.items() if r 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, unit_efforts=unit_efforts, max_effort=max_effort) if using_optimizers(all_results): goal_expression = add_unsatisfiable_to_goal(stream_domain, goal_expression) problem = get_problem(opt_evaluations, goal_expression, stream_domain, unit_costs) # begin_metric with Verbose(debug): instantiated = instantiate_task( task_from_domain_problem(stream_domain, problem)) if instantiated is None: return None, INF cost_from_action = {action: action.cost for action in instantiated.actions} if (effort_weight is not None) or using_optimizers(applied_results): add_stream_efforts(node_from_atom, instantiated, effort_weight, unit_efforts=unit_efforts) add_optimizer_axioms(all_results, instantiated) 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, _ = solve_from_task(sas_task, debug=debug, **kwargs) if action_plan is None: return None, INF action_instances = [action_from_name[name] for name, _ in action_plan] cost = get_plan_cost(action_instances, cost_from_action, unit_costs) axiom_plans = recover_axioms_plans(instantiated, action_instances) applied_plan, function_plan = partition_external_plan( recover_stream_plan(evaluations, opt_evaluations, goal_expression, stream_domain, node_from_atom, action_instances, axiom_plans, negative, unit_costs)) #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)) deferred_plan, action_plan = partition_plan(action_plan, result_from_name) stream_plan = applied_plan + deferred_plan + function_plan combined_plan = stream_plan + action_plan return combined_plan, cost
def sequential_stream_plan(evaluations, goal_expression, domain, stream_results, negated, unit_costs=True, **kwargs): if negated: raise NotImplementedError() # TODO: compute preimage and make that the goal instead opt_evaluations = evaluations_from_stream_plan(evaluations, stream_results) opt_task = task_from_domain_problem(domain, get_problem(opt_evaluations, goal_expression, domain, unit_costs)) action_plan, action_cost = solve_from_task(opt_task, **kwargs) if action_plan is None: return None, action_cost import instantiate fluent_facts = MockSet() init_facts = set() task = task_from_domain_problem(domain, get_problem(evaluations, goal_expression, domain, unit_costs)) type_to_objects = instantiate.get_objects_by_type(task.objects, task.types) task.actions, stream_result_from_name = get_stream_actions(stream_results) results_from_head = get_results_from_head(opt_evaluations) # TODO: add ordering constraints to simplify the optimization import pddl action_from_name = {} function_plan = set() for i, (name, args) in enumerate(action_plan): action = find_unique(lambda a: a.name == name, domain.actions) assert(len(action.parameters) == len(args)) #parameters = action.parameters[:action.num_external_parameters] var_mapping = {p.name: a for p, a in zip(action.parameters, args)} new_name = '{}-{}'.format(name, i) new_parameters = action.parameters[len(args):] new_preconditions = [] action.precondition.instantiate(var_mapping, init_facts, fluent_facts, new_preconditions) new_effects = [] for eff in action.effects: eff.instantiate(var_mapping, init_facts, fluent_facts, type_to_objects, new_effects) new_effects = [pddl.Effect([], pddl.Conjunction(conditions), effect) for conditions, effect in new_effects] cost = pddl.Increase(fluent=pddl.PrimitiveNumericExpression(symbol=TOTAL_COST, args=[]), expression=pddl.NumericConstant(1)) #cost = None task.actions.append(pddl.Action(new_name, new_parameters, 0, pddl.Conjunction(new_preconditions), new_effects, cost)) action_from_name[new_name] = (name, map(obj_from_pddl, args)) if not unit_costs: function_plan.update(extract_function_results(results_from_head, action, args)) planner = kwargs.get('planner', 'ff-astar') combined_plan, _ = solve_from_task(task, planner=planner, **kwargs) if combined_plan is None: return None, obj_from_pddl_plan(action_plan), INF stream_plan = [] action_plan = [] for name, args in combined_plan: if name in stream_result_from_name: stream_plan.append(stream_result_from_name[name]) else: action_plan.append(action_from_name[name]) stream_plan += list(function_plan) combined_plan = stream_plan + action_plan return combined_plan, action_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