def locally_optimize(evaluations, store, goal_expression, domain, functions, negative,
dynamic_streams, visualize, sampling_time=0):
action_plan = store.best_plan
if action_plan is None:
return None
print('\nPostprocessing | Cost: {} | Total Time: {:.3f}'.format(store.best_cost, store.elapsed_time()))
# TODO: postprocess current skeletons as well
task = task_from_domain_problem(domain, get_problem(evaluations, goal_expression, domain, unit_costs=False))
opt_stream_plan, opt_from_obj = recover_opt_stream_plan(evaluations, action_plan, task)
opt_stream_plan += optimistic_process_streams(evaluations_from_stream_plan(evaluations, opt_stream_plan), functions)
opt_action_plan = [(name, tuple(opt_from_obj.get(o, o) for o in args)) for name, args in action_plan]
pddl_plan = [(name, tuple(map(pddl_from_object, args))) for name, args in opt_action_plan]
stream_plan = recover_stream_plan(evaluations, goal_expression, domain,
opt_stream_plan, pddl_plan, negative, unit_costs=False)
stream_plan = get_synthetic_stream_plan(reorder_stream_plan(stream_plan), dynamic_streams)
# TODO: need to make this just streams
opt_evaluations = apply_streams(evaluations, stream_plan)
opt_cost = get_plan_cost(opt_evaluations, opt_action_plan, domain, unit_costs=False)
dump_plans(stream_plan, opt_action_plan, opt_cost)
if visualize:
log_plans(stream_plan, action_plan, None)
create_visualizations(evaluations, stream_plan, None)
store.start_time = time.time()
store.max_cost = store.best_cost
queue = SkeletonQueue(store, evaluations, goal_expression, domain)
queue.new_skeleton(stream_plan, opt_action_plan, opt_cost)
queue.greedily_process()
queue.timed_process(sampling_time)
def solve_focused(problem,
max_time=INF,
stream_info={},
effort_weight=None,
eager_iterations=1,
visualize=False,
verbose=True,
**kwargs):
# TODO: eager, negative, context, costs, bindings
start_time = time.time()
num_iterations = 0
best_plan = None
best_cost = INF
evaluations, goal_expression, domain, externals = parse_problem(problem)
update_stream_info(externals, stream_info)
eager_externals = filter(lambda e: e.info.eager, externals)
constraint_solver = ConstraintSolver(problem[3])
disabled = []
if visualize:
clear_visualizations()
while elapsed_time(start_time) < max_time:
num_iterations += 1
print('\nIteration: {} | Evaluations: {} | Cost: {} | Time: {:.3f}'.
format(num_iterations, len(evaluations), best_cost,
elapsed_time(start_time)))
eagerly_evaluate(evaluations, eager_externals, eager_iterations,
max_time - elapsed_time(start_time), verbose)
# TODO: version that just calls one of the incremental algorithms
instantiator = Instantiator(evaluations, externals)
stream_results = []
while instantiator.stream_queue and (elapsed_time(start_time) <
max_time):
stream_results += optimistic_process_stream_queue(instantiator)
# exhaustive_stream_plan | incremental_stream_plan | simultaneous_stream_plan | sequential_stream_plan | relaxed_stream_plan
solve_stream_plan = sequential_stream_plan if effort_weight is None else simultaneous_stream_plan
#solve_stream_plan = simultaneous_stream_plan
stream_plan, action_plan, cost = solve_stream_plan(
evaluations, goal_expression, domain, stream_results, **kwargs)
print('Stream plan: {}\n'
'Action plan: {}'.format(stream_plan, action_plan))
if stream_plan is None:
if not disabled:
break
reset_disabled(disabled)
elif (len(stream_plan) == 0) and (cost < best_cost):
best_plan = action_plan
best_cost = cost
break
else:
if visualize:
create_visualizations(evaluations, stream_plan, num_iterations)
constraint_facts = constraint_solver.solve(
get_optimistic_constraints(evaluations, stream_plan),
verbose=verbose)
if constraint_facts:
evaluations.update(map(evaluation_from_fact, constraint_facts))
else:
#process_stream_plan(evaluations, stream_plan, disabled, verbose)
process_immediate_stream_plan(evaluations, stream_plan,
disabled, verbose)
return revert_solution(best_plan, best_cost, evaluations)
def solve_abstract(problem,
constraints=PlanConstraints(),
stream_info={},
replan_actions=set(),
unit_costs=False,
success_cost=INF,
max_time=INF,
max_iterations=INF,
max_memory=INF,
initial_complexity=0,
complexity_step=1,
max_complexity=INF,
max_skeletons=INF,
search_sample_ratio=0,
bind=True,
max_failures=0,
unit_efforts=False,
max_effort=INF,
effort_weight=None,
reorder=True,
visualize=False,
verbose=True,
**search_kwargs):
"""
Solves a PDDLStream problem by first planning with optimistic stream outputs and then querying streams
:param problem: a PDDLStream problem
:param constraints: PlanConstraints on the set of legal solutions
:param stream_info: a dictionary from stream name to StreamInfo altering how individual streams are handled
:param replan_actions: the actions declared to induce replanning for the purpose of deferred stream evaluation
:param unit_costs: use unit action costs rather than numeric costs
:param success_cost: the exclusive (strict) upper bound on plan cost to successfully terminate
:param max_time: the maximum runtime
:param max_iterations: the maximum number of search iterations
:param max_memory: the maximum amount of memory
:param initial_complexity: the initial stream complexity limit
:param complexity_step: the increase in the stream complexity limit per iteration
:param max_complexity: the maximum stream complexity limit
:param max_skeletons: the maximum number of plan skeletons (max_skeletons=None indicates not adaptive)
:param search_sample_ratio: the desired ratio of sample time / search time when max_skeletons!=None
:param bind: if True, propagates parameter bindings when max_skeletons=None
:param max_failures: the maximum number of stream failures before switching phases when max_skeletons=None
:param unit_efforts: use unit stream efforts rather than estimated numeric efforts
:param max_effort: the maximum amount of stream effort
:param effort_weight: a multiplier for stream effort compared to action costs
:param reorder: if True, reorder stream plans to minimize the expected sampling overhead
:param visualize: if True, draw the constraint network and stream plan as a graphviz file
:param verbose: if True, print the result of each stream application
:param search_kwargs: keyword args for the search subroutine
:return: a tuple (plan, cost, evaluations) where plan is a sequence of actions
(or None), cost is the cost of the plan (INF if no plan), and evaluations is init expanded
using stream applications
"""
# TODO: select whether to search or sample based on expected success rates
# TODO: no optimizers during search with relaxed_stream_plan
# TODO: locally optimize only after a solution is identified
# TODO: replan with a better search algorithm after feasible
# TODO: change the search algorithm and unit costs based on the best cost
use_skeletons = (max_skeletons is not None)
#assert implies(use_skeletons, search_sample_ratio > 0)
eager_disabled = (effort_weight is None
) # No point if no stream effort biasing
num_iterations = eager_calls = 0
complexity_limit = initial_complexity
evaluations, goal_exp, domain, externals = parse_problem(
problem,
stream_info=stream_info,
constraints=constraints,
unit_costs=unit_costs,
unit_efforts=unit_efforts)
identify_non_producers(externals)
enforce_simultaneous(domain, externals)
compile_fluent_streams(domain, externals)
# TODO: make effort_weight be a function of the current cost
# if (effort_weight is None) and not has_costs(domain):
# effort_weight = 1
load_stream_statistics(externals)
if visualize and not has_pygraphviz():
visualize = False
print(
'Warning, visualize=True requires pygraphviz. Setting visualize=False'
)
if visualize:
reset_visualizations()
streams, functions, negative, optimizers = partition_externals(
externals, verbose=verbose)
eager_externals = list(filter(lambda e: e.info.eager, externals))
positive_externals = streams + functions + optimizers
has_optimizers = bool(optimizers) # TODO: deprecate
assert implies(has_optimizers, use_skeletons)
################
store = SolutionStore(evaluations,
max_time,
success_cost,
verbose,
max_memory=max_memory)
skeleton_queue = SkeletonQueue(store, domain, disable=not has_optimizers)
disabled = set() # Max skeletons after a solution
while (not store.is_terminated()) and (
num_iterations < max_iterations) and (complexity_limit <=
max_complexity):
num_iterations += 1
eager_instantiator = Instantiator(
eager_externals, evaluations) # Only update after an increase?
if eager_disabled:
push_disabled(eager_instantiator, disabled)
if eager_externals:
eager_calls += process_stream_queue(
eager_instantiator,
store,
complexity_limit=complexity_limit,
verbose=verbose)
################
print(
'\nIteration: {} | Complexity: {} | Skeletons: {} | Skeleton Queue: {} | Disabled: {} | Evaluations: {} | '
'Eager Calls: {} | Cost: {:.3f} | Search Time: {:.3f} | Sample Time: {:.3f} | Total Time: {:.3f}'
.format(num_iterations, complexity_limit,
len(skeleton_queue.skeletons), len(skeleton_queue),
len(disabled), len(evaluations), eager_calls,
store.best_cost, store.search_time, store.sample_time,
store.elapsed_time()))
optimistic_solve_fn = get_optimistic_solve_fn(
goal_exp,
domain,
negative,
replan_actions=replan_actions,
reachieve=use_skeletons,
max_cost=min(store.best_cost, constraints.max_cost),
max_effort=max_effort,
effort_weight=effort_weight,
**search_kwargs)
# TODO: just set unit effort for each stream beforehand
if (max_skeletons is None) or (len(skeleton_queue.skeletons) <
max_skeletons):
disabled_axioms = create_disabled_axioms(
skeleton_queue) if has_optimizers else []
if disabled_axioms:
domain.axioms.extend(disabled_axioms)
stream_plan, opt_plan, cost = iterative_plan_streams(
evaluations,
positive_externals,
optimistic_solve_fn,
complexity_limit,
max_effort=max_effort)
for axiom in disabled_axioms:
domain.axioms.remove(axiom)
else:
stream_plan, opt_plan, cost = OptSolution(
INFEASIBLE, INFEASIBLE, INF) # TODO: apply elsewhere
################
#stream_plan = replan_with_optimizers(evaluations, stream_plan, domain, externals) or stream_plan
stream_plan = combine_optimizers(evaluations, stream_plan)
#stream_plan = get_synthetic_stream_plan(stream_plan, # evaluations
# [s for s in synthesizers if not s.post_only])
#stream_plan = recover_optimistic_outputs(stream_plan)
if reorder:
# TODO: this blows up memory wise for long stream plans
stream_plan = reorder_stream_plan(store, stream_plan)
num_optimistic = sum(r.optimistic
for r in stream_plan) if stream_plan else 0
action_plan = opt_plan.action_plan if is_plan(opt_plan) else opt_plan
print('Stream plan ({}, {}, {:.3f}): {}\nAction plan ({}, {:.3f}): {}'.
format(get_length(stream_plan), num_optimistic,
compute_plan_effort(stream_plan), stream_plan,
get_length(action_plan), cost,
str_from_plan(action_plan)))
if is_plan(stream_plan) and visualize:
log_plans(stream_plan, action_plan, num_iterations)
create_visualizations(evaluations, stream_plan, num_iterations)
################
if (stream_plan is INFEASIBLE) and (not eager_instantiator) and (
not skeleton_queue) and (not disabled):
break
if not is_plan(stream_plan):
print('No plan: increasing complexity from {} to {}'.format(
complexity_limit, complexity_limit + complexity_step))
complexity_limit += complexity_step
if not eager_disabled:
reenable_disabled(evaluations, domain, disabled)
#print(stream_plan_complexity(evaluations, stream_plan))
if not use_skeletons:
process_stream_plan(store,
domain,
disabled,
stream_plan,
opt_plan,
cost,
bind=bind,
max_failures=max_failures)
continue
################
#optimizer_plan = replan_with_optimizers(evaluations, stream_plan, domain, optimizers)
optimizer_plan = None
if optimizer_plan is not None:
# TODO: post process a bound plan
print('Optimizer plan ({}, {:.3f}): {}'.format(
get_length(optimizer_plan),
compute_plan_effort(optimizer_plan), optimizer_plan))
skeleton_queue.new_skeleton(optimizer_plan, opt_plan, cost)
allocated_sample_time = (search_sample_ratio * store.search_time) - store.sample_time \
if len(skeleton_queue.skeletons) <= max_skeletons else INF
if skeleton_queue.process(stream_plan, opt_plan, cost,
complexity_limit,
allocated_sample_time) is INFEASIBLE:
break
################
summary = store.export_summary()
summary.update({
'iterations': num_iterations,
'complexity': complexity_limit,
'skeletons': len(skeleton_queue.skeletons),
})
print('Summary: {}'.format(str_from_object(
summary, ndigits=3))) # TODO: return the summary
write_stream_statistics(externals, verbose)
return store.extract_solution()
def solve_focused(problem, stream_info={}, action_info={}, dynamic_streams=[],
max_time=INF, max_cost=INF, unit_costs=False,
commit=True, effort_weight=None, eager_layers=1,
visualize=False, verbose=True, postprocess=False, **search_kwargs):
"""
Solves a PDDLStream problem by first hypothesizing stream outputs and then determining whether they exist
:param problem: a PDDLStream problem
:param action_info: a dictionary from stream name to ActionInfo for planning and execution
:param stream_info: a dictionary from stream name to StreamInfo altering how individual streams are handled
:param max_time: the maximum amount of time to apply streams
:param max_cost: a strict upper bound on plan cost
:param commit: if True, it commits to instantiating a particular partial plan-skeleton.
:param effort_weight: a multiplier for stream effort compared to action costs
:param eager_layers: the number of eager stream application layers per iteration
:param visualize: if True, it draws the constraint network and stream plan as a graphviz file
:param verbose: if True, this prints the result of each stream application
:param search_kwargs: keyword args for the search subroutine
:return: a tuple (plan, cost, evaluations) where plan is a sequence of actions
(or None), cost is the cost of the plan, and evaluations is init but expanded
using stream applications
"""
# TODO: return to just using the highest level samplers at the start
start_time = time.time()
num_iterations = 0
best_plan = None; best_cost = INF
evaluations, goal_expression, domain, stream_name, externals = parse_problem(problem)
action_info = get_action_info(action_info)
update_stream_info(externals, stream_info)
load_stream_statistics(stream_name, externals)
eager_externals = filter(lambda e: e.info.eager, externals)
disabled = []
if visualize:
clear_visualizations()
#functions = filter(lambda s: isinstance(s, Function), externals)
functions = filter(lambda s: type(s) is Function, externals)
negative = filter(lambda s: type(s) is Predicate and s.is_negative(), externals)
streams = filter(lambda s: s not in (functions + negative), externals)
stream_results = []
depth = 1
sampling_queue = []
while elapsed_time(start_time) < max_time:
search_time = time.time() # TODO: allocate more sampling effort to maintain the balance
# TODO: total search time vs most recent search time?
if stream_results is None:
stream_plan, action_plan, cost = None, None, INF
else:
num_iterations += 1
print('\nIteration: {} | Depth: {} | Evaluations: {} | Cost: {} | Time: {:.3f}'.format(
num_iterations, depth, len(evaluations), best_cost, elapsed_time(start_time)))
# TODO: constrain to use previous plan to some degree
eagerly_evaluate(evaluations, eager_externals, eager_layers, max_time - elapsed_time(start_time), verbose)
stream_results += optimistic_process_streams(evaluations_from_stream_plan(evaluations, stream_results), functions)
# TODO: warning check if using simultaneous_stream_plan or relaxed_stream_plan with non-eager functions
solve_stream_plan = relaxed_stream_plan if effort_weight is None else simultaneous_stream_plan
#solve_stream_plan = sequential_stream_plan if effort_weight is None else simultaneous_stream_plan
combined_plan, cost = solve_stream_plan(evaluations, goal_expression, domain, stream_results,
negative, max_cost=best_cost, unit_costs=unit_costs, **search_kwargs)
combined_plan = reorder_combined_plan(evaluations, combined_plan, action_info, domain)
print('Combined plan: {}'.format(combined_plan))
stream_plan, action_plan = separate_plan(combined_plan, action_info)
stream_plan = reorder_stream_plan(stream_plan) # TODO: is this strictly redundant?
stream_plan = get_synthetic_stream_plan(stream_plan, dynamic_streams)
print('Stream plan: {}\n'
'Action plan: {}'.format(stream_plan, action_plan))
if stream_plan is None:
if disabled or (depth != 0):
if depth == 0:
reset_disabled(disabled)
stream_results = optimistic_process_streams(evaluations, streams)
depth = 0 # Recurse on problems
else:
break
elif len(stream_plan) == 0:
if cost < best_cost:
best_plan = action_plan; best_cost = cost
if best_cost < max_cost:
break
stream_results = None
else:
"""
sampling_key = SkeletonKey(0, len(stream_plan))
sampling_problem = Skeleton({}, stream_plan, action_plan, cost)
heappush(sampling_queue, (sampling_key, sampling_problem))
greedily_process_queue(sampling_queue, evaluations, disabled, max_cost, True, 0, verbose)
depth += 1
stream_results = None
"""
if visualize:
create_visualizations(evaluations, stream_plan, num_iterations)
option = True
if option:
# TODO: can instantiate all but subtract stream_results
# TODO: can even pass a subset of the fluent state
# TODO: can just compute the stream plan preimage
# TODO: replan constraining the initial state and plan skeleton
# TODO: reuse subproblems
# TODO: always start from the initial state (i.e. don't update)
old_evaluations = set(evaluations)
stream_results, _ = process_stream_plan(evaluations, stream_plan, disabled, verbose)
new_evaluations = set(evaluations) - old_evaluations
if stream_results is not None:
new_instances = [r.instance for r in stream_results]
stream_results = optimistic_process_streams(new_evaluations, streams, new_instances)
if not commit:
stream_results = None
depth += 1
reset_disabled(disabled)
if postprocess and (not unit_costs) and (best_plan is not None):
best_plan = locally_optimize(evaluations, best_plan, goal_expression, domain,
functions, negative, dynamic_streams, verbose)
write_stream_statistics(stream_name, externals)
return revert_solution(best_plan, best_cost, evaluations)
def solve_focused(problem,
stream_info={},
action_info={},
synthesizers=[],
max_time=INF,
max_cost=INF,
unit_costs=False,
unit_efforts=False,
effort_weight=None,
eager_layers=1,
search_sampling_ratio=1,
use_skeleton=True,
visualize=False,
verbose=True,
postprocess=False,
**search_kwargs):
"""
Solves a PDDLStream problem by first hypothesizing stream outputs and then determining whether they exist
:param problem: a PDDLStream problem
:param action_info: a dictionary from stream name to ActionInfo for planning and execution
:param stream_info: a dictionary from stream name to StreamInfo altering how individual streams are handled
:param synthesizers: a list of StreamSynthesizer objects
:param max_time: the maximum amount of time to apply streams
:param max_cost: a strict upper bound on plan cost
:param unit_costs: use unit costs rather than numeric costs
:param effort_weight: a multiplier for stream effort compared to action costs
:param eager_layers: the number of eager stream application layers per iteration
:param search_sampling_ratio: the desired ratio of search time / sample time
:param visualize: if True, it draws the constraint network and stream plan as a graphviz file
:param verbose: if True, this prints the result of each stream application
:param postprocess: postprocess the stream plan to find a better solution
:param search_kwargs: keyword args for the search subroutine
:return: a tuple (plan, cost, evaluations) where plan is a sequence of actions
(or None), cost is the cost of the plan, and evaluations is init but expanded
using stream applications
"""
# TODO: return to just using the highest level samplers at the start
# TODO: select whether to search or sample based on expected success rates
solve_stream_plan_fn = relaxed_stream_plan
#solve_stream_plan_fn = relaxed_stream_plan if effort_weight is None else simultaneous_stream_plan
#solve_stream_plan_fn = sequential_stream_plan # simultaneous_stream_plan | sequential_stream_plan
#solve_stream_plan_fn = incremental_stream_plan # incremental_stream_plan | exhaustive_stream_plan
# TODO: warning check if using simultaneous_stream_plan or sequential_stream_plan with non-eager functions
# TODO: no optimizers during search with relaxed_stream_plan
num_iterations = 0
search_time = sample_time = 0
store = SolutionStore(max_time, max_cost,
verbose) # TODO: include other info here?
evaluations, goal_expression, domain, externals = parse_problem(
problem, stream_info)
unit_costs |= not has_costs(domain)
full_action_info = get_action_info(action_info)
load_stream_statistics(externals + synthesizers)
if visualize and not has_pygraphviz():
visualize = False
print(
'Warning, visualize=True requires pygraphviz. Setting visualize=False'
)
if visualize:
reset_visualizations()
eager_externals = list(filter(lambda e: e.info.eager, externals))
streams, functions, negative = partition_externals(externals)
if verbose:
print('Streams: {}\nFunctions: {}\nNegated: {}'.format(
streams, functions, negative))
queue = SkeletonQueue(store, evaluations, goal_expression, domain)
disabled = set()
while not store.is_terminated():
start_time = time.time()
num_iterations += 1
print(
'\nIteration: {} | Queue: {} | Evaluations: {} | Cost: {} '
'| Search Time: {:.3f} | Sample Time: {:.3f} | Total Time: {:.3f}'.
format(num_iterations, len(queue), len(evaluations),
store.best_cost, search_time, sample_time,
store.elapsed_time()))
layered_process_stream_queue(
Instantiator(evaluations, eager_externals), evaluations, store,
eager_layers)
solve_stream_plan = lambda sr: solve_stream_plan_fn(
evaluations,
goal_expression,
domain,
sr,
negative,
max_cost=store.
best_cost, #max_cost=min(store.best_cost, max_cost),
unit_costs=unit_costs,
unit_efforts=unit_efforts,
effort_weight=effort_weight,
**search_kwargs)
#combined_plan, cost = solve_stream_plan(optimistic_process_streams(evaluations, streams + functions))
combined_plan, cost = iterative_solve_stream_plan(
evaluations, streams, functions, solve_stream_plan)
if action_info:
combined_plan = reorder_combined_plan(evaluations, combined_plan,
full_action_info, domain)
print('Combined plan: {}'.format(combined_plan))
stream_plan, action_plan = separate_plan(combined_plan,
full_action_info)
#stream_plan = replan_with_optimizers(evaluations, stream_plan, domain, externals)
stream_plan = combine_optimizers(evaluations, stream_plan)
#stream_plan = get_synthetic_stream_plan(stream_plan, # evaluations
# [s for s in synthesizers if not s.post_only])
stream_plan = reorder_stream_plan(
stream_plan) # TODO: is this redundant when combined_plan?
dump_plans(stream_plan, action_plan, cost)
if (stream_plan is not None) and visualize:
log_plans(stream_plan, action_plan, num_iterations)
create_visualizations(evaluations, stream_plan, num_iterations)
search_time += elapsed_time(start_time)
# TODO: more generally just add the original plan skeleton to the plan
# TODO: cutoff search exploration time at a certain point
start_time = time.time()
allocated_sample_time = search_sampling_ratio * search_time - sample_time
if use_skeleton:
terminate = not process_skeleton_queue(store, queue, stream_plan,
action_plan, cost,
allocated_sample_time)
else:
terminate = not process_disabled(
store, evaluations, domain, disabled, stream_plan, action_plan,
cost, allocated_sample_time, effort_weight is not None)
sample_time += elapsed_time(start_time)
if terminate:
break
if postprocess and (not unit_costs): # and synthesizers
locally_optimize(evaluations, store, goal_expression, domain,
functions, negative, synthesizers, visualize)
write_stream_statistics(externals + synthesizers, verbose)
return revert_solution(store.best_plan, store.best_cost, evaluations)
def solve_focused(problem,
stream_info={},
action_info={},
synthesizers=[],
max_time=INF,
max_cost=INF,
unit_costs=None,
effort_weight=None,
eager_layers=1,
visualize=False,
verbose=True,
postprocess=False,
**search_kwargs):
"""
Solves a PDDLStream problem by first hypothesizing stream outputs and then determining whether they exist
:param problem: a PDDLStream problem
:param action_info: a dictionary from stream name to ActionInfo for planning and execution
:param stream_info: a dictionary from stream name to StreamInfo altering how individual streams are handled
:param max_time: the maximum amount of time to apply streams
:param max_cost: a strict upper bound on plan cost
:param effort_weight: a multiplier for stream effort compared to action costs
:param eager_layers: the number of eager stream application layers per iteration
:param visualize: if True, it draws the constraint network and stream plan as a graphviz file
:param verbose: if True, this prints the result of each stream application
:param search_kwargs: keyword args for the search subroutine
:return: a tuple (plan, cost, evaluations) where plan is a sequence of actions
(or None), cost is the cost of the plan, and evaluations is init but expanded
using stream applications
"""
# TODO: return to just using the highest level samplers at the start
search_sampling_ratio = 1
solve_stream_plan_fn = relaxed_stream_plan if effort_weight is None else simultaneous_stream_plan
# TODO: warning check if using simultaneous_stream_plan or sequential_stream_plan with non-eager functions
num_iterations = 0
search_time = sample_time = 0
store = SolutionStore(max_time, max_cost,
verbose) # TODO: include other info here?
evaluations, goal_expression, domain, stream_name, externals = parse_problem(
problem, stream_info)
compile_to_exogenous(evaluations, domain, externals)
if unit_costs is None:
unit_costs = not has_costs(domain)
full_action_info = get_action_info(action_info)
load_stream_statistics(stream_name, externals + synthesizers)
if visualize:
clear_visualizations()
# TODO: somehow Functions became no longer eager?
eager_externals = list(
filter(lambda e: e.info.eager or type(e) == Function, externals))
streams, functions, negative = partition_externals(externals)
queue = SkeletonQueue(store, evaluations)
# TODO: decide max_sampling_time based on total search_time or likelihood estimates
# TODO: switch to searching if believe chance of search better than sampling
while not store.is_terminated():
num_iterations += 1
print(
'\nIteration: {} | Queue: {} | Evaluations: {} | Cost: {} '
'| Search Time: {:.3f} | Sample Time: {:.3f} | Total Time: {:.3f}'.
format(num_iterations, len(queue), len(evaluations),
store.best_cost, search_time, sample_time,
store.elapsed_time()))
start_time = time.time()
layered_process_stream_queue(
Instantiator(evaluations, eager_externals), evaluations, store,
eager_layers)
solve_stream_plan = lambda sr: solve_stream_plan_fn(
evaluations,
goal_expression,
domain,
sr,
negative,
max_cost=store.best_cost,
#max_cost=min(store.best_cost, max_cost),
unit_costs=unit_costs,
**search_kwargs)
#combined_plan, cost = solve_stream_plan(populate_results(evaluations, streams + functions))
combined_plan, cost = iterative_solve_stream_plan(
evaluations, streams, functions, solve_stream_plan)
if action_info:
combined_plan = reorder_combined_plan(evaluations, combined_plan,
full_action_info, domain)
print('Combined plan: {}'.format(combined_plan))
stream_plan, action_plan = separate_plan(combined_plan,
full_action_info)
stream_plan = reorder_stream_plan(
stream_plan) # TODO: is this strictly redundant?
stream_plan = get_synthetic_stream_plan(stream_plan, synthesizers)
print('Stream plan: {}\n'
'Action plan: {}'.format(stream_plan, action_plan))
search_time += elapsed_time(start_time)
start_time = time.time()
if stream_plan is None:
if not queue:
break
queue.process_until_success()
#queue.fairly_process()
else:
if visualize:
create_visualizations(evaluations, stream_plan, num_iterations)
queue.new_skeleton(stream_plan, action_plan, cost)
queue.greedily_process()
sample_time += elapsed_time(start_time)
start_time = time.time()
queue.timed_process(search_sampling_ratio * search_time - sample_time)
sample_time += elapsed_time(start_time)
if postprocess and (not unit_costs):
locally_optimize(evaluations, store, goal_expression, domain,
functions, negative, synthesizers)
write_stream_statistics(stream_name, externals + synthesizers, verbose)
return revert_solution(store.best_plan, store.best_cost, evaluations)
def solve_committed(problem,
max_time=INF,
effort_weight=None,
visualize=False,
verbose=True,
**kwargs):
# TODO: constrain plan skeleton
# TODO: constrain ususable samples
# TODO: recursively consider previously exposed binding levels
# TODO: parameter for how many times to consider a plan skeleton
# TODO: constrain to use previous plan skeleton
# TODO: only use stream instances on plan
# TODO: identify subset of state to include to further constrain (requires inverting axioms)
# TODO: recurse to previous problems
start_time = time.time()
num_iterations = 0
best_plan = None
best_cost = INF
evaluations, goal_expression, domain, streams = parse_problem(problem)
constraint_solver = ConstraintSolver(problem[3])
disabled = []
if visualize:
clear_visualizations()
committed = False
instantiator = Instantiator(evaluations, streams)
#stream_results = []
#while instantiator.stream_queue and (elapsed_time(start_time) < max_time):
# stream_results += optimistic_process_stream_queue(instantiator, prioritized=False)
# TODO: queue to always consider functions
# TODO: can always append functions
# Subproblems are which streams you can use
while elapsed_time(start_time) < max_time:
num_iterations += 1
print('\nIteration: {} | Evaluations: {} | Cost: {} | Time: {:.3f}'.
format(num_iterations, len(evaluations), best_cost,
elapsed_time(start_time)))
stream_results = []
while instantiator.stream_queue and (elapsed_time(start_time) <
max_time):
stream_results += optimistic_process_stream_queue(instantiator)
solve_stream_plan = sequential_stream_plan if effort_weight is None else simultaneous_stream_plan
#solve_stream_plan = relaxed_stream_plan
# TODO: constrain to use previous plan to some degree
stream_plan, action_plan, cost = solve_stream_plan(
evaluations, goal_expression, domain, stream_results, **kwargs)
print('Stream plan: {}\n'
'Action plan: {}'.format(stream_plan, action_plan))
if stream_plan is None:
if committed or disabled:
if not committed:
reset_disabled(disabled)
committed = False
instantiator = Instantiator(evaluations, streams)
else:
break
elif (len(stream_plan) == 0) and (cost < best_cost):
best_plan = action_plan
best_cost = cost
break
else:
if visualize:
create_visualizations(evaluations, stream_plan, num_iterations)
# TODO: use set of intended stream instances here instead
#stream_results = []
committed = True
constraint_facts = constraint_solver.solve(
get_optimistic_constraints(evaluations, stream_plan),
verbose=verbose)
if constraint_facts:
new_evaluations = map(evaluation_from_fact, constraint_facts)
evaluations.update(new_evaluations)
else:
#new_evaluations = process_stream_plan(evaluations, stream_plan, disabled, verbose)
new_evaluations = process_immediate_stream_plan(
evaluations, stream_plan, disabled, verbose)
for evaluation in new_evaluations:
instantiator.add_atom(
evaluation) # TODO: return things to try next
#while instantiator.stream_queue and (elapsed_time(start_time) < max_time):
# stream_results += optimistic_process_stream_queue(instantiator, prioritized=False)
#stream_results = stream_plan # TODO: would need to prune disabled
# TODO: don't include streams that aren't performable?
# TODO: could also only include the previous stream plan
# TODO: need to be careful if I only instantiate one that I am not unable to find a plan
# TODO: need to always propagate this a little
return revert_solution(best_plan, best_cost, evaluations)
def solve_focused(problem, constraints=PlanConstraints(),
stream_info={}, action_info={}, synthesizers=[],
max_time=INF, max_iterations=INF, max_skeletons=INF,
unit_costs=False, success_cost=INF,
complexity_step=1,
unit_efforts=False, max_effort=INF, effort_weight=None,
reorder=True, search_sample_ratio=0,
visualize=False, verbose=True, **search_kwargs):
"""
Solves a PDDLStream problem by first hypothesizing stream outputs and then determining whether they exist
:param problem: a PDDLStream problem
:param constraints: PlanConstraints on the set of legal solutions
:param stream_info: a dictionary from stream name to StreamInfo altering how individual streams are handled
:param action_info: a dictionary from stream name to ActionInfo for planning and execution
:param synthesizers: a list of StreamSynthesizer objects
:param max_time: the maximum amount of time to apply streams
:param max_iterations: the maximum number of search iterations
:param max_iterations: the maximum number of plan skeletons to consider
:param unit_costs: use unit action costs rather than numeric costs
:param success_cost: an exclusive (strict) upper bound on plan cost to terminate
:param unit_efforts: use unit stream efforts rather than estimated numeric efforts
:param complexity_step: the increase in the effort limit after each failure
:param max_effort: the maximum amount of effort to consider for streams
:param effort_weight: a multiplier for stream effort compared to action costs
:param reorder: if True, stream plans are reordered to minimize the expected sampling overhead
:param search_sample_ratio: the desired ratio of search time / sample time
:param visualize: if True, it draws the constraint network and stream plan as a graphviz file
:param verbose: if True, this prints the result of each stream application
:param search_kwargs: keyword args for the search subroutine
:return: a tuple (plan, cost, evaluations) where plan is a sequence of actions
(or None), cost is the cost of the plan, and evaluations is init but expanded
using stream applications
"""
# TODO: select whether to search or sample based on expected success rates
# TODO: no optimizers during search with relaxed_stream_plan
num_iterations = search_time = sample_time = eager_calls = 0
complexity_limit = float(INITIAL_COMPLEXITY)
eager_disabled = effort_weight is None # No point if no stream effort biasing
evaluations, goal_exp, domain, externals = parse_problem(
problem, stream_info=stream_info, constraints=constraints,
unit_costs=unit_costs, unit_efforts=unit_efforts)
store = SolutionStore(evaluations, max_time, success_cost, verbose)
full_action_info = get_action_info(action_info)
load_stream_statistics(externals + synthesizers)
if visualize and not has_pygraphviz():
visualize = False
print('Warning, visualize=True requires pygraphviz. Setting visualize=False')
if visualize:
reset_visualizations()
streams, functions, negative = partition_externals(externals, verbose=verbose)
eager_externals = list(filter(lambda e: e.info.eager, externals))
skeleton_queue = SkeletonQueue(store, goal_exp, domain)
disabled = set()
while (not store.is_terminated()) and (num_iterations < max_iterations):
start_time = time.time()
num_iterations += 1
eager_instantiator = Instantiator(eager_externals, evaluations) # Only update after an increase?
if eager_disabled:
push_disabled(eager_instantiator, disabled)
eager_calls += process_stream_queue(eager_instantiator, store, complexity_limit=complexity_limit, verbose=verbose)
print('\nIteration: {} | Complexity: {} | Skeletons: {} | Skeleton Queue: {} | Disabled: {} | Evaluations: {} | '
'Eager Calls: {} | Cost: {:.3f} | Search Time: {:.3f} | Sample Time: {:.3f} | Total Time: {:.3f}'.format(
num_iterations, complexity_limit, len(skeleton_queue.skeletons), len(skeleton_queue), len(disabled),
len(evaluations), eager_calls, store.best_cost, search_time, sample_time, store.elapsed_time()))
optimistic_solve_fn = get_optimistic_solve_fn(goal_exp, domain, negative,
max_cost=min(store.best_cost, constraints.max_cost),
unit_efforts=unit_efforts, max_effort=max_effort,
effort_weight=effort_weight, **search_kwargs)
if (max_skeletons is not None) and (len(skeleton_queue.skeletons) < max_skeletons):
combined_plan, cost = iterative_plan_streams(evaluations, externals, optimistic_solve_fn, complexity_limit,
unit_efforts=unit_efforts, max_effort=max_effort)
else:
combined_plan, cost = INFEASIBLE, INF
if action_info:
combined_plan = reorder_combined_plan(evaluations, combined_plan, full_action_info, domain)
print('Combined plan: {}'.format(combined_plan))
stream_plan, action_plan = separate_plan(combined_plan, full_action_info)
#stream_plan = replan_with_optimizers(evaluations, stream_plan, domain, externals)
stream_plan = combine_optimizers(evaluations, stream_plan)
#stream_plan = get_synthetic_stream_plan(stream_plan, # evaluations
# [s for s in synthesizers if not s.post_only])
if reorder:
stream_plan = reorder_stream_plan(stream_plan) # This may be redundant when using reorder_combined_plan
print('Stream plan ({}, {:.3f}): {}\nAction plan ({}, {:.3f}): {}'.format(
get_length(stream_plan), compute_plan_effort(stream_plan), stream_plan,
get_length(action_plan), cost, str_from_plan(action_plan)))
if is_plan(stream_plan) and visualize:
log_plans(stream_plan, action_plan, num_iterations)
create_visualizations(evaluations, stream_plan, num_iterations)
search_time += elapsed_time(start_time)
if (stream_plan is INFEASIBLE) and (not eager_instantiator) and (not skeleton_queue) and (not disabled):
break
start_time = time.time()
if not is_plan(stream_plan):
complexity_limit += complexity_step
if not eager_disabled:
reenable_disabled(evaluations, domain, disabled)
elif not stream_plan:
store.add_plan(action_plan, cost)
if max_skeletons is None:
process_stream_plan(store, domain, disabled, stream_plan)
else:
allocated_sample_time = (search_sample_ratio * search_time) - sample_time
skeleton_queue.process(stream_plan, action_plan, cost, complexity_limit, allocated_sample_time)
sample_time += elapsed_time(start_time)
write_stream_statistics(externals + synthesizers, verbose)
return store.extract_solution()
def solve_focused(problem,
constraints=PlanConstraints(),
stream_info={},
replan_actions=set(),
max_time=INF,
max_iterations=INF,
initial_complexity=0,
complexity_step=1,
max_skeletons=INF,
bind=True,
max_failures=0,
unit_costs=False,
success_cost=INF,
unit_efforts=False,
max_effort=INF,
effort_weight=None,
reorder=True,
search_sample_ratio=0,
visualize=False,
verbose=True,
**search_kwargs):
"""
Solves a PDDLStream problem by first hypothesizing stream outputs and then determining whether they exist
:param problem: a PDDLStream problem
:param constraints: PlanConstraints on the set of legal solutions
:param stream_info: a dictionary from stream name to StreamInfo altering how individual streams are handled
:param max_time: the maximum amount of time to apply streams
:param max_iterations: the maximum number of search iterations
:param max_skeletons: the maximum number of plan skeletons to consider
:param unit_costs: use unit action costs rather than numeric costs
:param success_cost: an exclusive (strict) upper bound on plan cost to terminate
:param unit_efforts: use unit stream efforts rather than estimated numeric efforts
:param initial_complexity: the initial effort limit
:param complexity_step: the increase in the effort limit after each failure
:param max_effort: the maximum amount of effort to consider for streams
:param effort_weight: a multiplier for stream effort compared to action costs
:param reorder: if True, stream plans are reordered to minimize the expected sampling overhead
:param search_sample_ratio: the desired ratio of search time / sample time
:param visualize: if True, it draws the constraint network and stream plan as a graphviz file
:param verbose: if True, this prints the result of each stream application
:param search_kwargs: keyword args for the search subroutine
:return: a tuple (plan, cost, evaluations) where plan is a sequence of actions
(or None), cost is the cost of the plan, and evaluations is init but expanded
using stream applications
"""
# TODO: select whether to search or sample based on expected success rates
# TODO: no optimizers during search with relaxed_stream_plan
# TODO: locally optimize only after a solution is identified
# TODO: replan with a better search algorithm after feasible
num_iterations = search_time = sample_time = eager_calls = 0
complexity_limit = initial_complexity
# TODO: make effort_weight be a function of the current cost
# TODO: change the search algorithm and unit costs based on the best cost
eager_disabled = effort_weight is None # No point if no stream effort biasing
evaluations, goal_exp, domain, externals = parse_problem(
problem,
stream_info=stream_info,
constraints=constraints,
unit_costs=unit_costs,
unit_efforts=unit_efforts)
store = SolutionStore(evaluations, max_time, success_cost, verbose)
load_stream_statistics(externals)
if visualize and not has_pygraphviz():
visualize = False
print(
'Warning, visualize=True requires pygraphviz. Setting visualize=False'
)
if visualize:
reset_visualizations()
streams, functions, negative, optimizers = partition_externals(
externals, verbose=verbose)
eager_externals = list(filter(lambda e: e.info.eager, externals))
use_skeletons = max_skeletons is not None
has_optimizers = bool(optimizers)
assert implies(has_optimizers, use_skeletons)
skeleton_queue = SkeletonQueue(store, domain, disable=not has_optimizers)
disabled = set() # Max skeletons after a solution
while (not store.is_terminated()) and (num_iterations < max_iterations):
start_time = time.time()
num_iterations += 1
eager_instantiator = Instantiator(
eager_externals, evaluations) # Only update after an increase?
if eager_disabled:
push_disabled(eager_instantiator, disabled)
eager_calls += process_stream_queue(eager_instantiator,
store,
complexity_limit=complexity_limit,
verbose=verbose)
print(
'\nIteration: {} | Complexity: {} | Skeletons: {} | Skeleton Queue: {} | Disabled: {} | Evaluations: {} | '
'Eager Calls: {} | Cost: {:.3f} | Search Time: {:.3f} | Sample Time: {:.3f} | Total Time: {:.3f}'
.format(num_iterations, complexity_limit,
len(skeleton_queue.skeletons), len(skeleton_queue),
len(disabled), len(evaluations), eager_calls,
store.best_cost, search_time, sample_time,
store.elapsed_time()))
optimistic_solve_fn = get_optimistic_solve_fn(
goal_exp,
domain,
negative,
replan_actions=replan_actions,
reachieve=use_skeletons,
max_cost=min(store.best_cost, constraints.max_cost),
max_effort=max_effort,
effort_weight=effort_weight,
**search_kwargs)
# TODO: just set unit effort for each stream beforehand
if (max_skeletons is None) or (len(skeleton_queue.skeletons) <
max_skeletons):
disabled_axioms = create_disabled_axioms(
skeleton_queue) if has_optimizers else []
if disabled_axioms:
domain.axioms.extend(disabled_axioms)
stream_plan, action_plan, cost = iterative_plan_streams(
evaluations, (streams + functions + optimizers),
optimistic_solve_fn,
complexity_limit,
max_effort=max_effort)
for axiom in disabled_axioms:
domain.axioms.remove(axiom)
else:
stream_plan, action_plan, cost = INFEASIBLE, INFEASIBLE, INF
#stream_plan = replan_with_optimizers(evaluations, stream_plan, domain, externals) or stream_plan
stream_plan = combine_optimizers(evaluations, stream_plan)
#stream_plan = get_synthetic_stream_plan(stream_plan, # evaluations
# [s for s in synthesizers if not s.post_only])
if reorder:
stream_plan = reorder_stream_plan(
stream_plan
) # This may be redundant when using reorder_combined_plan
num_optimistic = sum(r.optimistic
for r in stream_plan) if stream_plan else 0
print('Stream plan ({}, {}, {:.3f}): {}\nAction plan ({}, {:.3f}): {}'.
format(get_length(stream_plan), num_optimistic,
compute_plan_effort(stream_plan), stream_plan,
get_length(action_plan), cost,
str_from_plan(action_plan)))
if is_plan(stream_plan) and visualize:
log_plans(stream_plan, action_plan, num_iterations)
create_visualizations(evaluations, stream_plan, num_iterations)
search_time += elapsed_time(start_time)
if (stream_plan is INFEASIBLE) and (not eager_instantiator) and (
not skeleton_queue) and (not disabled):
break
start_time = time.time()
if not is_plan(stream_plan):
complexity_limit += complexity_step
if not eager_disabled:
reenable_disabled(evaluations, disabled)
#print(stream_plan_complexity(evaluations, stream_plan))
if use_skeletons:
#optimizer_plan = replan_with_optimizers(evaluations, stream_plan, domain, optimizers)
optimizer_plan = None
if optimizer_plan is not None:
# TODO: post process a bound plan
print('Optimizer plan ({}, {:.3f}): {}'.format(
get_length(optimizer_plan),
compute_plan_effort(optimizer_plan), optimizer_plan))
skeleton_queue.new_skeleton(optimizer_plan, action_plan, cost)
allocated_sample_time = (search_sample_ratio * search_time) - sample_time \
if len(skeleton_queue.skeletons) <= max_skeletons else INF
skeleton_queue.process(stream_plan, action_plan, cost,
complexity_limit, allocated_sample_time)
else:
process_stream_plan(store,
domain,
disabled,
stream_plan,
action_plan,
cost,
bind=bind,
max_failures=max_failures)
sample_time += elapsed_time(start_time)
write_stream_statistics(externals, verbose)
return store.extract_solution()