def get_initial_weights(self, examples: Task) -> dict: example_weights = {} for examples in examples.get_examples(): for example in examples: example_weights[example] = 1 return example_weights
def _execute_program(self, examples: Task, clause: Clause) -> typing.Sequence[Atom]: """ Evaluates a clause using the Prolog engine and background knowledge Returns a set of atoms that the clause covers """ if len(clause.get_body().get_literals()) == 0: return [] else: self._solver.asserta(clause) covered_examples = [] pos, neg = examples.get_examples() total_examples = pos.union(neg) for example in total_examples: if self._solver.has_solution(example): covered_examples.append(example) self._solver.retract(clause) # head_predicate = clause.get_head().get_predicate() # head_variables = clause.get_head_variables() # # sols = self._solver.query(*clause.get_body().get_literals()) # # sols = [head_predicate(*[s[v] for v in head_variables]) for s in sols] return covered_examples
def evaluate( self, examples: Task, clause: Clause, hypothesis_space: HypothesisSpace) -> typing.Union[int, float]: """ Evaluates a clause by calling the Learner's eval_fn. Returns a number (the higher the better) """ # add_to_cache(node,key,val) # retrieve_from_cache(node,key) -> val or None # remove_from_cache(node,key) -> None # Cache holds sets of examples that were covered before covered = hypothesis_space.retrieve_from_cache(clause, "covered") # We have executed this clause before if covered is not None: # Note that _eval.fn.evaluate() will ignore clauses in `covered` # that are not in the current Task result = self._eval_fn.evaluate(clause, examples, covered) # print("No query here.") return result else: covered = self._execute_program(clause) # if 'None', i.e. trivial hypothesis, all clauses are covered if covered is None: pos, neg = examples.get_examples() covered = pos.union(neg) result = self._eval_fn.evaluate(clause, examples, covered) hypothesis_space.add_to_cache(clause, "covered", covered) return result
def evaluate_distinct(self, examples: Task, clause: Clause) -> typing.Tuple[int, int]: covered = self._execute_program(examples, clause) pos, neg = examples.get_examples() covered_pos = pos.intersection(covered) covered_neg = neg.intersection(covered) return len(covered_pos), len(covered_neg)
def evaluate(self, clause: Clause, examples: Task, covered: Sequence[Atom]): self._clauses_evaluated += 1 pos, neg = examples.get_examples() covered_pos = len(pos.intersection(covered)) covered_neg = len(neg.intersection(covered)) if self._return_upperbound: return (covered_pos - covered_neg), covered_pos return covered_pos - covered_neg
def evaluate(self, examples: Task, clause: Clause) -> typing.Union[int, float]: covered = self._execute_program(clause) pos, neg = examples.get_examples() covered_pos = pos.intersection(covered) covered_neg = neg.intersection(covered) if len(covered_neg) > 0: return 0 else: return len(covered_pos)
def _execute_program(self, examples: Task, clause: Clause) -> typing.Sequence[Atom]: """ Evaluates a clause using the Prolog engine and background knowledge Returns a set of atoms that the clause covers """ pos, neg = examples.get_examples() self._solver.assertz(clause) coverage = [] for example in pos: if self._solver.has_solution(example): coverage.append(example) self._solver.retract(clause) return coverage
def evaluate(self, clause: Clause, examples: Task, covered: Sequence[Atom]): self._clauses_evaluated += 1 pos, neg = examples.get_examples() covered_pos = len(pos.intersection(covered)) covered_neg = len(neg.intersection(covered)) if covered_pos + covered_neg == 0: return 0 if not self._return_upperbound else 0, 0 return ( covered_pos / (covered_pos + covered_neg) if not self._return_upperbound else covered_pos / (covered_pos + covered_neg), 1, )
def evaluate(self, clause: Clause, examples: Task, covered: Sequence[Atom]): self._clauses_evaluated += 1 pos, neg = examples.get_examples() covered_pos = len(pos.intersection(covered)) covered_neg = len(neg.intersection(covered)) if covered_pos + covered_neg == 0: return 0 p = covered_pos / (covered_pos + covered_neg) # Perfect split, no entropy if p == 1 or p == 0: return 0 return -(p * math.log10(p) + (1 - p) * math.log10(1 - p))
def get_best_primitives( self, examples: Task, current_cand: typing.Union[Clause, Recursion, Body] ) -> typing.Sequence[typing.Union[Clause, Body, Procedure]]: scores = [0] * 22 # Filter examples (e.g. only use positive/negative examples) # examples = self.filter_examples(examples) pos, neg = examples.get_examples() # Calculate nn output for each example for example in pos: # Update output nn_output = self.model.predict( get_nn_input_data(current_cand, example, self.current_primitives.tolist()))[0] nn_output = self.process_output(nn_output) # Update score vector scores = self.update_score(current_cand, example, scores, nn_output) for example in neg: # Update output nn_output = self.model.predict( get_nn_input_data(current_cand, example, self.current_primitives.tolist()))[0] nn_output = self.process_output(nn_output) # Update score vector scores = self.update_score(current_cand, example, scores, -0.2 * nn_output) # Return x best primitives indices = numpy.argpartition( scores, -self.amount_chosen_from_nn)[-self.amount_chosen_from_nn:] # TODO now a random order but could be replaced to the ordering via the score print("PRIMITIVES CHOSEN BY NN: ") print(self.current_primitives[indices], "\n") return self.current_primitives[indices]
def evaluate(self, examples: Task, clause: Clause) -> typing.Union[int, float]: covered = self._execute_program(examples, clause) pos, neg = examples.get_examples() covered_pos = pos.intersection(covered) covered_neg = neg.intersection(covered) print("\t covered neg: ", len(covered_neg)) print("\t covered pos: ", len(covered_pos)) if (len(covered_pos) + len(covered_neg)) == 0: print("\t score: ", 0) else: print("\t score: ", len(covered_pos) / (len(covered_pos) + len(covered_neg))) if len(covered_neg) > 0: return 0 else: return len(covered_pos)
def evaluate(self, examples: Task, clause: Clause): pos, neg = examples.get_examples() numberofpositivecoverance = 0 self._solver.assertz(clause) for example in pos: if self._solver.has_solution(example): numberofpositivecoverance += 1 numberofnegativecoverance = 0 for example in neg: if self._solver.has_solution(example): numberofnegativecoverance += 1 # print(example) self._solver.retract(clause) if numberofnegativecoverance + numberofpositivecoverance == 0: return [0, 0] else: return [ numberofpositivecoverance / (numberofpositivecoverance + numberofnegativecoverance) * (numberofpositivecoverance) / len(pos), numberofnegativecoverance ]
def filter_examples(self, examples: Task) -> Task: pos, _ = examples.get_examples() return pos