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_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 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