def get_problem(evaluations, goal_exp, domain, unit_costs=False): objects = objects_from_evaluations(evaluations) typed_objects = list( {make_object(pddl_from_object(obj)) for obj in objects} - set(domain.constants)) # TODO: this doesn't include = init = [ fd_from_evaluation(e) for e in evaluations if not is_negated_atom(e) ] goal = pddl.Truth() if goal_exp is None else parse_goal(goal_exp, domain) problem_pddl = None if USE_FORBID: problem_pddl = get_problem_pddl(evaluations, goal_exp, domain.pddl, temporal=False) write_pddl(domain.pddl, problem_pddl) return Problem(task_name=domain.name, task_domain_name=domain.name, objects=sorted(typed_objects, key=lambda o: o.name), task_requirements=pddl.tasks.Requirements([]), init=init, goal=goal, use_metric=not unit_costs, pddl=problem_pddl)
def get_problem(init_evaluations, goal_expression, domain, unit_costs=False): objects = objects_from_evaluations(init_evaluations) typed_objects = list({pddl.TypedObject(pddl_from_object(obj), OBJECT) for obj in objects} - set(domain.constants)) # TODO: this doesn't include = init = [fd_from_evaluation(e) for e in init_evaluations if not is_negated_atom(e)] goal = parse_goal(goal_expression, domain) return Problem(task_name=domain.name, task_domain_name=domain.name, objects=sorted(typed_objects, key=lambda o: o.name), task_requirements=pddl.tasks.Requirements([]), init=init, goal=goal, use_metric=not unit_costs)
def fd_from_evaluation(evaluation): name = evaluation.head.function args = tuple(map(pddl_from_object, evaluation.head.args)) if is_atom(evaluation): return pddl.Atom(name, args) elif is_negated_atom(evaluation): return pddl.NegatedAtom(name, args) fluent = pddl.f_expression.PrimitiveNumericExpression(symbol=name, args=args) expression = pddl.f_expression.NumericConstant(evaluation.value) return pddl.f_expression.Assign(fluent, expression)
def pddl_from_evaluation(evaluation): #if evaluation.head.function == TOTAL_COST: # return None head = pddl_head(evaluation.head.function, evaluation.head.args) if is_atom(evaluation): return head elif is_negated_atom(evaluation): return '(not {})'.format(head) #value = int(evaluation.value) value = evaluation.value # floats are fine for temporal planners #value = int(math.ceil(evaluation.value)) return '(= {} {})'.format(head, value)
def get_init(init_evaluations, negated=False): # TODO: this doesn't include = init = [] for evaluation in init_evaluations: name = evaluation.head.function args = tuple(map(pddl_from_object, evaluation.head.args)) if is_atom(evaluation): init.append(pddl.Atom(name, args)) elif negated and is_negated_atom(evaluation): init.append(pddl.NegatedAtom(name, args)) else: fluent = pddl.f_expression.PrimitiveNumericExpression(symbol=name, args=args) expression = pddl.f_expression.NumericConstant( evaluation.value) # Integer init.append(pddl.f_expression.Assign(fluent, expression)) return init
def get_achieving_streams(evaluations, stream_results, max_effort=INF, **effort_args): unprocessed_from_atom = defaultdict(list) node_from_atom = {NULL_COND: Node(0, None)} conditions_from_stream = {} remaining_from_stream = {} for result in stream_results: conditions_from_stream[result] = result.instance.get_domain() + ( NULL_COND, ) remaining_from_stream[result] = len(conditions_from_stream[result]) for atom in conditions_from_stream[result]: unprocessed_from_atom[atom].append(result) for atom in evaluations: if not is_negated_atom(atom): node_from_atom[fact_from_evaluation(atom)] = Node(0, None) queue = [ HeapElement(node.effort, atom) for atom, node in node_from_atom.items() ] while queue: atom = heappop(queue).value if atom not in unprocessed_from_atom: continue for result in unprocessed_from_atom[atom]: remaining_from_stream[result] -= 1 if remaining_from_stream[result]: continue effort = result.get_effort(**effort_args) total_effort = effort + EFFORT_OP( node_from_atom[cond].effort for cond in conditions_from_stream[result]) if max_effort <= total_effort: continue for new_atom in result.get_certified(): if (new_atom not in node_from_atom) or ( total_effort < node_from_atom[new_atom].effort): node_from_atom[new_atom] = Node(total_effort, result) heappush(queue, HeapElement(total_effort, new_atom)) del unprocessed_from_atom[atom] del node_from_atom[NULL_COND] return node_from_atom
def fd_from_evaluations(evaluations): return [ fd_from_evaluation(e) for e in evaluations if not is_negated_atom(e) ]