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
