def get_correction(self, user_input, action, args, test=False): # visible = {} # since this action is incorrect, ensure it is not done again not_on_xy = pddl_functions.create_formula('on', args[:2], op='not') self.tmp_goal = goals.update_goal(self.tmp_goal, not_on_xy) if not test: for test in self.active_tests: if (test.objects[0] == args[0] and test.objects[1] == args[1]) or test.failed: correct_rule = test.rule1 self.active_tests.remove(test) else: continue self.goal = goals.update_goal(self.goal, correct_rule.to_formula()) # get the relevant parts of the message message = read_sentence(user_input, use_dmrs=False) # build the rule model self.build_model(message, args) self.update_goal() # logger.debug(self.goal.asPDDL()) self.world.back_track()
def to_goal(self, goal): out_rules = [self.rules[i][d] for i, d in enumerate(self.decision)] out_goal = None for rule in out_rules: out_goal = goals.update_goal(out_goal, rule) g = goals.update_goal(goal, out_goal) return g
def evaluate_current_state(self, default_plan=False): if default_plan: #print('Doing default plan') self.current_state.state = [] self.current_state.colour_counts = { c: 0 for c in self.current_state.colour_counts.keys() } success, increase, decrease = self.constraints.evaluate( self.current_state) if success: self.problem.goal = goals.update_goal(self.goal, self.tmp_goal) # print(self.problem.goal.asPDDL()) self.problem.initialstate = self.current_state.asPDDL() # for formula in self.current_state.asPDDL(): # print(formula.asPDDL()) # print(self.problem.goal.asPDDL()) with open(self.search_file, 'w') as f: f.write(self.problem.asPDDL()) try: # print("trying to plan") # print(self.domain_file, self.use_metric_ff) plan = ff.run(self.domain_file, self.search_file, use_metric_ff=self.use_metric_ff) # print('Plan successful') return plan except (NoPlanError, IDontKnowWhatIsGoingOnError, ImpossibleGoalError) as e: # print(e) # for p in self.problem.initialstate: # print(p.asPDDL()) # print(self.problem.goal.asPDDL()) # n = len(os.listdir('errors/domain')) # with open('errors/domain/error{}.domain'.format(n), 'w') as f: # f.write(self.problem.asPDDL()) try: score, self.current_state = self._pop() return False except IndexError: self.generate_candidates(increase, decrease) else: self.generate_candidates(increase, decrease) try: score, self.current_state = self._pop() return False except IndexError: print("Goal", self.goal.asPDDL()) print("tmp goal", self.tmp_goal.asPDDL()) print("state") for f in self.current_state.initialstate.predicates: print(f.asPDDL()) raise NoPlanError('Search could not find a possible plan')
def get_correction(self, user_input, action, args, test=False): # since this action is incorrect, ensure it is not done again args = args[:2] not_on_xy = pddl_functions.create_formula('on', args, op='not') self.tmp_goal = goals.update_goal(self.tmp_goal, not_on_xy) tower = args[2] if len(args) == 3 else None self.world.back_track(tower) self.sense()
def __init__(self, colour_choices, obs, tests, goal, tmp_goal, problem, domain_file='blocks-domain.pddl', **kwargs): super().__init__(colour_choices, obs, goal, tmp_goal, problem, domain_file=domain_file, **kwargs) self.initial_state = self.current_state self.initial_goal = self.goal self.tests = tests tmp_goal = goals.update_goal(self.goal, tmp_goal) for test in tests: test_goal = goals.update_goal(tmp_goal, test.test_formula) self.problem.goal = test_goal self.problem.initialstate = self.current_state.asPDDL() # print(test_goal.asPDDL()) with open(self.search_file, 'w') as f: f.write(self.problem.asPDDL()) try: plan = ff.run(self.domain_file, self.search_file, use_metric_ff=self.use_metric_ff) except (ImpossibleGoalError, IDontKnowWhatIsGoingOnError, NoPlanError): test.failed = True continue else: self.goal = goals.update_goal(self.goal, test.test_formula) tmp_goal = goals.update_goal(tmp_goal, test.test_formula)
def no_correction(self, action, args): for test in self.active_tests: if (test.objects[0] == args[0] and test.objects[1] == args[1]): correct_rule = test.rule2 self.active_tests.remove(test) elif test.failed: correct_rule = test.rule1 self.active_tests.remove(test) else: continue self.goal = goals.update_goal(self.goal, correct_rule.to_formula())
def __init__(self, name='blocks-problem', domainname='blocks-domain', objects=None, n=10, m=1, colours=[], rules=None, metric=None): self.domainname = domainname if objects is not None: objects = pddl_functions.make_variable_list(objects) else: objects = BlocksWorldProblem.create_objects(n, m) if isinstance(rules[0], Ruledef): rules = [generate_rule(rule) for rule in rules] elif isinstance(rules[0], correctingagent.world.rules.Rule): rules = [rule.to_formula() for rule in rules] initialstate = self.generate_default_position(objects) initialstate = BlocksWorldProblem.add_colours(initialstate, objects, colours) goal = self.create_default_goal() for rule in rules: goal = goals.update_goal(goal, rule) super(BlocksWorldProblem, self).__init__(name, domainname, objects, initialstate, goal, metric)
def get_correction(self, user_input, action, args, test=False): visible = {} # since this action is incorrect, ensure it is not done again not_on_xy = pddl_functions.create_formula('on', args, op='not') self.tmp_goal = goals.update_goal(self.tmp_goal, not_on_xy) if not test: # get the relevant parts of the message message = read_sentence(user_input, use_dmrs=False) # build the rule model rule_model, rules = self.build_model(message) # if isinstance(self, CorrectingAgent): # log_cm(rule_model.c1) # log_cm(rule_model.c2) # if message.T.lower() == 'table': # log_cm(rule_model.c3) logger.debug('rule priors' + str(rule_model.rule_prior)) # gets F(o1), F(o2), and optionally F(o3) data = self.get_data(message, args) priors = self.priors.get_priors(message, args) logger.debug('object priors: ' + str(priors)) r1, r2 = rule_model.get_message_probs(data, priors=priors) logger.debug('predictions: ' + str((r1, r2))) #print(r1, r2) colour1 = message.o1[0] colour2 = message.o2[0] _, results = self.sense() try: result_c1 = results[args[0]][colour1] except KeyError: result_c1 = 0. try: result_c2 = results[args[1]][colour2] except KeyError: result_c2 = 0. # if there is no confidence in the update then ask for help if max(r1, r2) < self.threshold or (result_c1 == 0.5 or result_c2 == 0.5): # logger.debug('asking question') question = 'Is the top object {}?'.format(message.o1[0]) dialogue.info("R: " + question) if len(args) == 2: tower = None else: tower = args[-1] answer = self.teacher.answer_question(question, self.world, tower) dialogue.info("T: " + answer) bin_answer = int(answer.lower() == 'yes') visible[message.o1[0]] = bin_answer message_probs = rule_model.get_message_probs(data, visible=copy.copy(visible), priors=priors) r1, r2 = message_probs objs = [args[0], args[1], message.o3] prior_updates = rule_model.updated_object_priors(data, objs, priors, visible=copy.copy(visible)) # update the goal belief #logger.debug(prior_updates) rule_model.update_belief_r(r1, r2) # print(r1, r2) # print(rule_model, rule_model.rule_belief.belief) # print(args) # print(self.sense()[1]) which_to_update = [1,1,1] if self.update_once: for i, o in enumerate(objs): if o in self.objects_used_for_update: which_to_update[i] = 0 self.objects_used_for_update.add(o) rule_model.update_c(data, priors=self.priors.get_priors(message, args), visible=visible, update_negative=self.update_negative, which_to_update=which_to_update) self.rule_models[(rule_model.rule_names, message.T)] = rule_model self.priors.update(prior_updates) self.update_goal() logger.debug(self.goal.asPDDL()) self.world.back_track()
def get_correction(self, user_input, actions, args, test=False, ask_question=None): self.time += 1 self.last_correction = self.time violations, data, message = self.update_model(user_input, args) tmp_goal = None mark_block = True ignore_correction = False print(user_input) if "sorry" not in user_input: tmp_goal = pddl_functions.create_formula('on', args[:2], op='not') #self.tmp_goal = goals.update_goal(self.tmp_goal, not_on_xy) else: on_xy = pddl_functions.create_formula('on', message.o3) self.tmp_goal = goals.update_goal(self.tmp_goal, on_xy) time = self.pgm_model.observe(data) self.inference_times.append(time) try: q = self.pgm_model.query(list(violations)) except InferenceFailedError: self.world.back_track() return # print(q) if ask_question is not None and ask_question: if message.T in ['table', 'tower']: self.ask_question(message, args) try: q = self.pgm_model.query(list(violations)) except InferenceFailedError: self.world.back_track() return elif all([v < 1 - self.threshold for v in q.values()]): # and "sorry" not in user_input: print("ignoring correction") tmp_goal = None mark_block = False ignore_correction = True elif ask_question is None and max(q.values( )) < self.threshold: #min(q.values()) > 1-self.threshold: if message.T in ['table', 'tower']: self.ask_question(message, args) try: q = self.pgm_model.query(list(violations)) except InferenceFailedError: self.world.back_track() return if tmp_goal is not None: self.tmp_goal = goals.update_goal(self.tmp_goal, tmp_goal) if mark_block is True: most_likely_violation = max(q, key=q.get) self.mark_block(most_likely_violation, message, args) self.update_cms() self.update_goal() if ignore_correction is not True: self.world.back_track()