def run(self, problem, task, heuristic):
taskii = str(task).zfill(2)
runname = "{0}-{1}_{2}_{3}_{4}".format(
time.strftime("%Y-%m-%d-%H-%M-%S"), datetime.now().microsecond, problem, task, heuristic
)
logfilename = "log/{}.log".format(runname)
for handler in logging.root.handlers[:]:
logging.root.removeHandler(handler)
logging.basicConfig(filename=logfilename, level=logging.INFO)
if os.path.exists("../benchmarks/{0}/domain.pddl".format(problem)):
domain = ""
else:
domain = taskii
solution = pyperplan.search_plan(
"../benchmarks/{0}/domain{1}.pddl".format(problem, domain),
"../benchmarks/{0}/task{1}.pddl".format(problem, taskii),
pyperplan.SEARCHES["astar"],
pyperplan.HEURISTICS[heuristic],
)
expanded = int(
re.split(":| ", linecache.getline(logfilename, 15))[2]
) # extract number of expanded nodes from log file
elapsed = re.split(" |\n", linecache.getline(logfilename, 17))[3] # extract elepsed time from log file
length = len(solution)
resultfilename = "results/{0}_{1}.res".format(problem, heuristic)
with open(resultfilename, "a") as f:
f.write("{0}\t{1}\t{2}\t{3}\n".format(runname, expanded, elapsed, length))
def run_planner(problem_file):
domain_file = planner.find_domain(problem_file)
print("Searching solution for", domain_file, problem_file)
assert planner.search_plan(domain_file, problem_file, breadth_first_search, None) is not None
def run_planner(problem_file):
domain_file = planner.find_domain(problem_file)
print('Searching solution for', domain_file, problem_file)
assert planner.search_plan(domain_file, problem_file, breadth_first_search,
None) is not None
def generate(self, instance):
total_discarded_actions = 0
total_detected_actions = 0
# Get all recipients and ingredients on instance
actions_list = []
objects_list = []
instance_steps_list = []
goals_str = ""
flatten = lambda l: [item for sublist in l for item in sublist]
for sentence in instance['data']:
doc = self.nlp(sentence)
actions = [action for action in self.actions for v in doc if str(v.lemma_) in action['keywords'] and str(v.dep_) == 'ROOT']
objects = [object for object in self.objects for v in doc if object['name'] == str(v.lemma_)]
total_detected_actions += len(actions)
for obj in objects:
objects_list.append(obj)
for action in actions:
actions_list.append(action)
action_preconditions_str = ""
unsolved_preconditions_list = []
if len(actions) > 0:
action_params_list = []
for precondition in actions[0]['preconditions']:
# Find object in step that fits precondition type
object = [obj for obj in objects if obj['type'] == precondition[1]]
if len(object) > 0:
action_params_list.append(object)
action_preconditions_str += "({} {}) ".format(precondition[0], object[0]['name'])
else:
# No object fits requirements, unsolved precondition
unsolved_preconditions_list.append(precondition)
# Process effect parameters to include into goal
if len(unsolved_preconditions_list) == 0:
params_str = ""
params_list = [p1 for p1 in action_params_list for p2 in actions[0]['effects'][0][1] if p1[0]['type'] == p2]
for p in params_list:
params_str += "{} ".format(p[0]['name'])
goals_str += "({} {}) ".format(actions[0]['effects'][0][0], params_str)
else:
total_discarded_actions += 1
# print("** Action: {}".format(actions))
# print("** Action preconditions: {}".format(action_preconditions_str))
# print("** Unsolved action preconditions: {}".format(unsolved_preconditions_list))
#
actions_list = list({action['name']:action for action in actions_list}.values())
objects_list = list({obj['name']:obj for obj in objects_list}.values())
#
# Generate domain file
domain_str = "(define (domain {})\n".format(instance['name'].lower())
domain_str += " (:requirements :typing)\n"
types_list = [t['type'] for t in objects_list]
types_set = set(types_list)
domain_str += " (:types\n"
domain_str += " ingredient recipient - object"
# for type in types_set:
# domain_str += " {} - object\n".format(type)
domain_str += " )\n"
domain_str += " (:predicates\n"
domain_str += " (have ?param - object)\n"
effects_list = []
for action in actions_list:
for effect in action['effects']:
if effect[0] not in effects_list:
params_str = ""
for idx, param in enumerate(effect[1]):
params_str += "?param{} - {} ".format(idx, param)
domain_str += " ({} {})\n".format(effect[0], params_str)
domain_str += " )\n"
# Actions
for curr_action_idx, action in enumerate(actions_list):
domain_str += " (:action {}\n".format(action['name'])
params_str = ""
params_list = []
for idx, param in enumerate(action['parameters']):
params_list.append(('param{}'.format(idx), param))
params_str += "?param{} - {} ".format(idx, param)
domain_str += " :parameters ({})\n".format(params_str)
preconditions_str = ""
for precondition in action['preconditions']:
param_ef = [p for p in params_list if p[1] == precondition[1]]
if len(param_ef) > 0:
preconditions_str += "({} ?{}) ".format(precondition[0], param_ef[0][0])
# Add previous action effects as preconditions for current action
previous_action_effects_str = ""
for previous_action in actions_list[:curr_action_idx]:
for previous_effect in previous_action['effects']:
previous_params_str = ""
for previous_param in previous_effect[1]:
p = [p for p in params_list if p[1] == previous_param]
if len(p) > 0:
previous_params_str += "?{} ".format(p[0][0])
previous_action_effects_str += "({} {}) ".format(previous_effect[0], previous_params_str)
domain_str += " :precondition (and {} {})\n".format(preconditions_str, previous_action_effects_str)
effects_str = ""
for effect in action['effects']:
# Find parameter of same effects' type
params_str = ""
for param in effect[1]:
p = [p for p in params_list if p[1] == param]
if len(p) > 0:
params_str += "?{} ".format(p[0][0])
effects_str += "({} {}) ".format(effect[0], params_str)
domain_str += " :effect (and {})\n".format(effects_str)
domain_str += " )\n"
domain_str += ")\n"
#
# Generate problem file
problem_str = "(define (problem {})\n".format(instance['name'].lower())
problem_str += "(:domain {})\n".format(instance['name'].lower())
# Objects and type definition
problem_str += " (:objects\n"
init_have_objects_str = ""
for object in objects_list:
problem_str += " {} - {}\n".format(object['name'], object['type'])
# Generate 'have' facts for all objects
init_have_objects_str += "(have {}) ".format(object['name'])
problem_str += " )\n"
# Init parameters
problem_str += " (:init\n"
problem_str += " {}\n".format(init_have_objects_str)
problem_str += " )\n"
problem_str += " (:goal\n"
problem_str += " (and {})\n".format(goals_str)
problem_str += " )\n"
problem_str += ")"
#
# print("---------------------------------------------------")
# print(problem_str)
# print("---------------------------------------------------")
# print(domain_str)
# Write domain and problem PDDL files
domain_file = os.path.join('./pddl', instance['name'].lower() + "-domain.pddl")
problem_file = os.path.join('./pddl', instance['name'].lower() + "-problem.pddl")
solution_file = os.path.join('./pddl', instance['name'].lower() + "-problem-solution.txt")
with open(domain_file, "w") as f:
f.write(domain_str)
with open(problem_file, "w") as f:
f.write(problem_str)
plan = pyperplan.search_plan(domain_file, problem_file, pyperplan.SEARCHES['gbf'], pyperplan.HEURISTICS['blind'])
if plan == None:
plan = []
else:
with open(solution_file, "w") as f:
for line in plan:
f.write(str(line))
return len(instance['data']), total_detected_actions, total_discarded_actions, len(plan)
