def reschedule_stream_plan(evaluations,
target_facts,
domain,
stream_results,
unique_binding=False,
unsatisfiable=False,
max_effort=INF,
planner=RESCHEDULE_PLANNER,
debug=False):
# TODO: search in space of partially ordered plans
# TODO: constrain selection order to be alphabetical?
domain.actions[:], stream_result_from_name = get_stream_actions(
stream_results, unique_binding=unique_binding)
goal_expression = And(*target_facts)
if unsatisfiable: # TODO: ensure that the copy hasn't harmed anything
goal_expression = add_unsatisfiable_to_goal(domain, goal_expression)
reschedule_problem = get_problem(evaluations,
goal_expression,
domain,
unit_costs=False)
reschedule_task = task_from_domain_problem(domain, reschedule_problem)
#reschedule_task.axioms = [] # TODO: ensure that the constants are added in the event that axioms are needed?
sas_task = sas_from_pddl(reschedule_task)
stream_names, effort = solve_from_task(sas_task,
planner=planner,
max_planner_time=10,
max_cost=max_effort,
debug=debug)
if stream_names is None:
return None
stream_plan = [stream_result_from_name[name] for name, _ in stream_names]
return stream_plan
def reschedule_stream_plan(evaluations,
target_facts,
domain,
stream_results,
unique_binding=False,
unit_efforts=True):
# TODO: search in space of partially ordered plans
# TODO: constrain selection order to be alphabetical?
goal_expression = And(*target_facts)
reschedule_problem = get_problem(evaluations,
goal_expression,
domain,
unit_costs=unit_efforts)
reschedule_task = task_from_domain_problem(domain, reschedule_problem)
reschedule_task.actions, stream_result_from_name = get_stream_actions(
stream_results,
unique_binding=unique_binding,
unit_efforts=unit_efforts)
#reschedule_task.axioms = [] # TODO: ensure that the constants are added in the event that axioms are needed?
sas_task = sas_from_pddl(reschedule_task)
stream_names, effort = solve_from_task(sas_task,
planner=RESCHEDULE_PLANNER,
max_planner_time=10,
debug=False)
if stream_names is None:
return None
stream_plan = [stream_result_from_name[name] for name, _ in stream_names]
return stream_plan
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 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 reschedule_stream_plan(evaluations,
preimage_facts,
domain,
stream_results,
unique_binding=False,
unit_costs=True):
# TODO: search in space of partially ordered plans
# TODO: constrain selection order to be alphabetical?
reschedule_problem = get_problem(evaluations,
And(*preimage_facts),
domain,
unit_costs=unit_costs)
reschedule_task = task_from_domain_problem(domain, reschedule_problem)
reschedule_task.actions, stream_result_from_name = get_stream_actions(
stream_results, unique_binding=unique_binding)
#reschedule_task.axioms = [] # TODO: ensure that the constants are added in the even that axioms are needed?
new_plan, _ = solve_from_task(reschedule_task,
planner=RESCHEDULE_PLANNER,
max_planner_time=10,
debug=False)
return [stream_result_from_name[name] for name, _ in new_plan]
def sequential_stream_plan(evaluations, goal_expression, domain, stream_results,
negated, effort_weight, unit_costs=True, debug=False, **kwargs):
# Intuitively, actions have infinitely more weight than streams
if negated:
raise NotImplementedError(negated)
for result in stream_results:
if isinstance(result.external, Stream) and result.external.is_fluent():
raise NotImplementedError('Fluents are not supported')
# 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 = abstrips_solve_from_task(sas_from_pddl(opt_task, debug=debug), debug=debug, **kwargs)
if action_plan is None:
return None, action_cost
actions = domain.actions[:]
domain.actions[:] = []
stream_domain, stream_result_from_name = add_stream_actions(domain, stream_results) # TODO: effort_weight
domain.actions.extend(actions)
stream_task = task_from_domain_problem(stream_domain, get_problem(evaluations, goal_expression, stream_domain, unit_costs))
action_from_name, function_plan = simplify_actions(opt_evaluations, action_plan, stream_task, actions, unit_costs)
# TODO: lmcut?
combined_plan, _ = solve_from_task(sas_from_pddl(opt_task, debug=debug),
planner=kwargs.get('planner', 'ff-astar'),
debug=debug, **kwargs)
if combined_plan is None:
return None, 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])
combined_plan = stream_plan + function_plan + action_plan
return combined_plan, action_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 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