def get_matches(self, x, epsilon=0.0): # print("GETTING MATCHES") # pprint(self.learner.get_hset()) grounded = self.ground_example(x) # grounded = [(ground(a), x[a]) for a in x if (isinstance(a, tuple))] # print("FACTS") # pprint(grounded) index = build_index(grounded) # print("INDEX") # pprint(index) # print("OPERATOR") # pprint(self.operator) # print(self.learner.get_hset()) for h in self.learner.get_hset(): # print('h', h) # Update to include initial args operator = Operator(tuple(('Rule', ) + self.args), h, []) # print("OPERATOR", h) for m in operator.match(index, epsilon=epsilon): # print('match', m, operator.name) result = tuple( [unground(subst(m, ele)) for ele in operator.name[1:]]) # result = tuple(['?' + subst(m, ele) # for ele in self.operator.name[1:]]) # result = tuple(['?' + m[e] for e in self.target_types]) # print('GET MATCHES T', result) yield result
def get_matches(self, x, epsilon=0.0): # print("GETTING MATCHES") # pprint(self.tuples) grounded = self.ground_example(x) # grounded = [(ground(a), x[a]) for a in x if (isinstance(a, tuple))] # print("FACTS") # pprint(grounded) index = build_index(grounded) # print("INDEX") # pprint(index) # print("OPERATOR") # pprint(self.operator) # print(self.learner.get_hset()) for t in self.tuples: mapping = {a: t[i] for i, a in enumerate(self.args)} operator = Operator(tuple(('Rule', ) + self.args), frozenset().union(self.constraints), []) for m in operator.match(index, epsilon=epsilon, initial_mapping=mapping): result = tuple(ele.replace("QM", '?') for ele in t) # print('GET MATCHES T', result) yield result break
def check_match(self, t, x): # print("CHECK MATCHES T", t) t = tuple(ground(ele) for ele in t) # Update to include initial args mapping = {a: t[i] for i, a in enumerate(self.args)} # print("MY MAPPING", mapping) # print("CHECKING MATCHES") if t not in self.tuples: return False grounded = self.ground_example(x) # grounded = [(ground(a), x[a]) for a in x if (isinstance(a, tuple))] # pprint(grounded) # pprint(mapping) index = build_index(grounded) # Update to include initial args operator = Operator(tuple(('Rule', ) + self.args), frozenset().union(self.constraints), []) for m in operator.match(index, initial_mapping=mapping): return True return False
def covers(h, x, initial_mapping): """ Returns true if h covers x """ index = build_index(x) operator = Operator(tuple(['Rule']), h, []) for m in operator.match(index, initial_mapping=initial_mapping): return True return False
def get_matches(self, x, epsilon=0.0): x = x.get_view("flat_ungrounded") grounded = self.ground_example(x) index = build_index(grounded) for t in self.tuples: mapping = {a: t[i] for i, a in enumerate(self.args)} operator = Operator(tuple(('Rule', ) + self.args), frozenset().union(self.constraints), []) for m in operator.match(index, epsilon=epsilon, initial_mapping=mapping): result = tuple(ele.replace("QM", '?') for ele in t) yield result break
def is_specialization(self, s, h): """ Takes two hypotheses s and g and returns True if s is a specialization of h. Note, it returns False if s and h are equal (s is not a specialization in this case). """ if s == h: return False # remove vars, so the unification isn't going in both directions. s = set(remove_vars(l) for l in s) # check if h matches s (then s specializes h) index = build_index(s) operator = Operator(tuple(['Rule']), h, []) for m in operator.match(index): return True return False
def check_match(self, t, x): x = x.get_view("flat_ungrounded") # print("CHECK MATCHES T", t) t = tuple(ground(ele) for ele in t) # Update to include initial args mapping = {a: t[i] for i, a in enumerate(self.args)} if t not in self.tuples: return False grounded = self.ground_example(x) index = build_index(grounded) # Update to include initial args operator = Operator(tuple(('Rule', ) + self.args), frozenset().union(self.constraints), []) for m in operator.match(index, initial_mapping=mapping): return True return False
def check_match(self, t, x): # print("CHECK MATCHES T", t) t = tuple(ele.replace('?', "QM") for ele in t) # Update to include initial args mapping = {a: t[i] for i, a in enumerate(self.args)} # print("MY MAPPING", mapping) # print("CHECKING MATCHES") grounded = self.ground_example(x) # grounded = [(ground(a), x[a]) for a in x if (isinstance(a, tuple))] # pprint(grounded) # pprint(mapping) index = build_index(grounded) for h in self.learner.get_hset(): # Update to include initial args operator = Operator(tuple(('Rule', ) + self.args), h, []) for m in operator.match(index, initial_mapping=mapping): return True return False
def ifit(self, t, x, y): # print("IFIT T", t) # if y == 0: # return x = { a: x[a] for a in x if (isinstance(a, tuple) and a[0] not in self.remove_attrs) or ( not isinstance(a, tuple) and a not in self.remove_attrs) } # x = {a: x[a] for a in x if self.is_structural_feature(a, x[a])} # x = {a: x[a] for a in x} # eles = set([field for field in t]) # prior_count = 0 # while len(eles) - prior_count > 0: # prior_count = len(eles) # for a in x: # if isinstance(a, tuple) and a[0] == 'haselement': # if a[2] in eles: # eles.add(a[1]) # # if self.matches(eles, a): # # names = get_attribute_components(a) # # eles.update(names) # x = {a: x[a] for a in x # if self.matches(eles, a)} # foa_mapping = {field: 'foa%s' % j for j, field in enumerate(t)} foa_mapping = {} for j, field in enumerate(t): if field not in foa_mapping: foa_mapping[field] = 'foa%s' % j # for j,field in enumerate(t): # x[('foa%s' % j, field)] = True x = rename_flat(x, foa_mapping) # pprint(x) # print("adding:") ns = NameStandardizer() sm = StructureMapper(self.concept) x = sm.transform(ns.transform(x)) # pprint(x) self.concept.increment_counts(x) if y == 1: self.pos_concept.increment_counts(x) else: self.neg_concept.increment_counts(x) # print() # print('POSITIVE') # pprint(self.pos_concept.av_counts) # print('NEGATIVE') # pprint(self.neg_concept.av_counts) # pprint(self.concept.av_counts) pos_instance = {} pos_args = set() for attr in self.pos_concept.av_counts: attr_count = 0 for val in self.pos_concept.av_counts[attr]: attr_count += self.pos_concept.av_counts[attr][val] if attr_count == self.pos_concept.count: if len(self.pos_concept.av_counts[attr]) == 1: args = get_vars(attr) pos_args.update(args) pos_instance[attr] = val else: args = get_vars(attr) val_gensym = value_gensym() args.append(val_gensym) pos_instance[attr] = val_gensym # if len(self.pos_concept.av_counts[attr]) == 1: # for val in self.pos_concept.av_counts[attr]: # if ((self.pos_concept.av_counts[attr][val] == # self.pos_concept.count)): # args = get_vars(attr) # pos_args.update(args) # pos_instance[attr] = val # print('POS ARGS', pos_args) neg_instance = {} for attr in self.neg_concept.av_counts: # print("ATTR", attr) args = set(get_vars(attr)) if not args.issubset(pos_args): continue for val in self.neg_concept.av_counts[attr]: # print("VAL", val) if ((attr not in self.pos_concept.av_counts or val not in self.pos_concept.av_counts[attr])): neg_instance[attr] = val foa_mapping = {'foa%s' % j: '?foa%s' % j for j in range(len(t))} pos_instance = rename_flat(pos_instance, foa_mapping) neg_instance = rename_flat(neg_instance, foa_mapping) conditions = ([(a, pos_instance[a]) for a in pos_instance] + [('not', (a, neg_instance[a])) for a in neg_instance]) # print("========CONDITIONS======") # pprint(conditions) # print("========CONDITIONS======") self.target_types = ['?foa%s' % i for i in range(len(t))] self.operator = Operator(tuple(['Rule'] + self.target_types), conditions, [])
def optimize_clause(h, constraints, seed, pset, nset): """ Returns the set of most specific generalization of h that do NOT cover x. """ c_length = clause_length(h) print('# POS', len(pset)) print('# NEG', len(nset)) print('length', c_length) p_covered, n_covered = test_coverage(h, constraints, pset, nset) p_uncovered = [p for p in pset if p not in p_covered] n_uncovered = [n for n in nset if n not in n_covered] print("P COVERED", len(p_covered)) print("N COVERED", len(n_covered)) initial_score = clause_score(clause_accuracy_weight, len(p_covered), len(p_uncovered), len(n_covered), len(n_uncovered), c_length) p, pm = seed pos_partial = list(compute_bottom_clause(p, pm)) # print('POS PARTIAL', pos_partial) # TODO if we wanted we could add the introduction of new variables to the # get_variablizations function. possible_literals = {} for i, l in enumerate(pos_partial): possible_literals[i] = [None, l] + [v for v in get_variablizations(l)] partial_literals = set( [l for i in possible_literals for l in possible_literals[i]]) additional_literals = h - partial_literals if len(additional_literals) > 0: p_index = build_index(p) operator = Operator(tuple(('Rule', )), h.union(constraints), []) for add_m in operator.match(p_index, initial_mapping=pm): break additional_lit_mapping = { rename(add_m, l): l for l in additional_literals } for l in additional_lit_mapping: new_l = additional_lit_mapping[l] reverse_m = {pm[a]: a for a in pm} l = rename(reverse_m, l) print(pos_partial) print(add_m) print(l) print(new_l) print(additional_literals) if l not in pos_partial: print("ERROR l not in pos_partial") import time time.sleep(1000) possible_literals[pos_partial.index(l)].append(new_l) # pprint(possible_literals) reverse_pl = { l: (i, j) for i in possible_literals for j, l in enumerate(possible_literals[i]) } clause_vector = [0 for i in range(len(possible_literals))] for l in h: if l not in reverse_pl: print("MISSING LITERAL!!!") import time time.sleep(1000) i, j = reverse_pl[l] clause_vector[i] = j clause_vector = tuple(clause_vector) # print("INITIAL CLAUSE VECTOR") # print(clause_vector) flip_weights = [(len(possible_literals[i]) - 1, i) for i in possible_literals] size = 1 for w, _ in flip_weights: size *= (w + 1) print("SIZE OF SEARCH SPACE:", size) num_successors = sum([w for w, c in flip_weights]) print("NUM SUCCESSORS", num_successors) temp_length = num_successors temp_length = 10 # initial_temp = 0.15 # initial_temp = 0.0 print("TEMP LENGTH", temp_length) print('INITIAL SCORE', initial_score) problem = ClauseOptimizationProblem(clause_vector, initial_cost=-1 * initial_score, extra=(possible_literals, flip_weights, constraints, pset, nset, len(p_uncovered), len(n_covered))) # for sol in hill_climbing(problem): for sol in simulated_annealing( problem, # initial_temp=initial_temp, temp_length=temp_length): # print("SOLUTION FOUND", sol.state) print('FINAL SCORE', -1 * sol.cost()) return build_clause(sol.state, possible_literals)
(<func>, '?<value_1>', ...) ), ...] example :[(('value', ('Add', ('value', '?x'), ('value', '?y'))), (int_float_add, '?xv', '?yv'))]) Full Example: def int_float_add(x, y): z = float(x) + float(y) if z.is_integer(): z = int(z) return str(z) add_rule = Operator(('Add', '?x', '?y'), [(('value', '?x'), '?xv'), (('value', '?y'), '?yv'), (lambda x, y: x <= y, '?x', '?y') ], [(('value', ('Add', ('value', '?x'), ('value', '?y'))), (int_float_add, '?xv', '?yv'))]) Note: You should explicitly register your operators so you can refer to them in your training.json, otherwise the name will be the same as the local variable example: Operator.register("Add") vvvvvvvvvvvvvvvvvvvv WRITE YOUR OPERATORS BELOW vvvvvvvvvvvvvvvvvvvvvvv ''' # ^^^^^^^^^^^^^^ DEFINE ALL YOUR OPERATORS ABOVE THIS LINE ^^^^^^^^^^^^^^^^ for name, op in locals().copy().items(): if (isinstance(op, Operator)): Operator.register(name, op)
from pprint import pprint from tabulate import tabulate import argparse from planners.fo_planner import Operator from agents.RLAgent import RLAgent from agents.ModularAgent import ModularAgent from agents.Memo import Memo ttt_horizontal_adj = Operator(('horizontal_adj', '?s1', '?s2'), [(('row', '?s1'), '?s1r'), (('row', '?s2'), '?s1r'), (('col', '?s1'), '?s1c'), (('col', '?s2'), '?s2c'), (lambda x, y: abs(x - y) == 1, '?s1c', '?s2c')], [(('horizontal_adj', '?s1', '?s2'), True)]) ttt_vertical_adj = Operator( ('vertical_adj', '?s1', '?s2'), [(('row', '?s1'), '?s1r'), (('row', '?s2'), '?s2r'), (('col', '?s1'), '?s1c'), (('col', '?s2'), '?s1c'), (lambda x, y: abs(x - y) == 1, '?s1r', '?s2r')], [(('vertical_adj', '?s1', '?s2'), True)]) ttt_diag_adj = Operator(('diag_adj', '?s1', '?s2'), [(('row', '?s1'), '?s1r'), (('row', '?s2'), '?s2r'), (('col', '?s1'), '?s1c'), (('col', '?s2'), '?s2c'), (lambda x, y: abs(x - y) == 1, '?s1r', '?s2r'), (lambda x, y: abs(x - y) == 1, '?s1c', '?s2c')], [(('diag_adj', '?s1', '?s2'), True)])
z = z % 10 if z.is_integer(): z = int(z) return str(z) def int3_float_add_then_tens(x, y, w): z = float(x) + float(y) + float(w) z = z // 10 if z.is_integer(): z = int(z) return str(z) add_rule = Operator(('Add', '?x', '?y'), [(('value', '?x'), '?xv'), (('value', '?y'), '?yv'), # (lambda x, y: x <= y, '?x', '?y') ], [(('value', ('Add', ('value', '?x'), ('value', '?y'))), (int_float_add, '?xv', '?yv'))]) Operator.register("add", add_rule) add_then_ones = Operator(('Add_Then_Ones', '?x', '?y'), [(('value', '?x'), '?xv'), (('value', '?y'), '?yv'), # (lambda x, y: x <= y, '?x', '?y') ], [(('value', ('Add_Then_Ones', ('value', '?x'), ('value', '?y'))), (int2_float_add_then_ones, '?xv', '?yv'))]) add_then_tens = Operator(('Add_Then_Tens', '?x', '?y'), [(('value', '?x'), '?xv'),
def successors(self, node): h = node.state # print("EXPANDING H", h) args, constraints, pset, neg, neg_mapping, gensym = node.extra all_args = set(s for x in h.union(constraints) for s in extract_strings(x) if is_variable(s)) if len(pset) == 0: return p, pm = choice(pset) p_index = build_index(p) operator = Operator(tuple(('Rule', ) + tuple(all_args)), h.union(constraints), []) # operator = Operator(tuple(('Rule',) + args), h, []) found = False for m in operator.match(p_index, initial_mapping=pm): reverse_m = {m[a]: a for a in m} pos_partial = set([rename(reverse_m, x) for x in p]) found = True break if not found: return n_index = build_index(neg) found = False for nm in operator.match(n_index, initial_mapping=neg_mapping): # print(nm) reverse_nm = {nm[a]: a for a in nm} neg_partial = set([rename(reverse_nm, x) for x in neg]) found = True break if not found: return unique_pos = pos_partial - neg_partial unique_neg = neg_partial - pos_partial # print("UNIQUE POS", unique_pos) # print("UNIQUE NEG", unique_neg) # Yield all minimum specializations of current vars for a in m: # TODO make sure m[a] is a minimum specialization sub_m = {a: m[a]} new_h = frozenset([subst(sub_m, ele) for ele in h]) # print("SPECIALIZATION", new_h, sub_m) # print() yield Node(new_h, node, ('specializing', (a, m[a])), node.cost() + 1, node.extra) # Add Negations for all neg specializations # for a in nm: # sub_nm = {a: nm[a]} # new_nh = set() # for ele in h: # new = subst(sub_nm, ele) # if new != ele and new not in h: # new_nh.add(('not', new)) # new_h = h.union(new_nh) # print("NEGATION SPECIALIZATION", new_nh) # yield Node(new_h, node, ('negation specialization', (a, nm[a])), # node.cost()+1, node.extra) # if current vars then add all relations that include current vars if len(all_args) > 0: added = set() for literal in unique_pos: if literal in h or literal in constraints: continue args = set(s for s in extract_strings(literal) if is_variable(s)) if len(args.intersection(all_args)) > 0: key = (literal[0], ) + tuple( ele if is_variable(ele) else '?' for ele in literal[1:]) if key in added: continue added.add(key) literal = generalize_literal(literal, gensym) new_h = h.union(frozenset([literal])) # print("ADD CURRENT", new_h) # print() yield Node(new_h, node, ('adding current', literal), node.cost() + 1, node.extra) else: added = set() for literal in unique_pos: if literal in h or literal in constraints: continue if literal[0] in added: continue added.add(literal[0]) literal = generalize_literal(literal, gensym) new_h = h.union(frozenset([literal])) # print("ADD NEW", new_h) # print() yield Node(new_h, node, ('adding', literal), node.cost() + 1, node.extra)
from pprint import pprint from tabulate import tabulate import argparse from planners.fo_planner import Operator from agents.RLAgent import RLAgent from agents.WhereWhenHowNoFoa import WhereWhenHowNoFoa from agents.Memo import Memo ttt_available = Operator(('available', '?s'), [(('value', '?s'), '?sv'), (('row', '?s'), '?sr'), (('col', '?s'), '?sc'), (lambda x: x > 0, '?sr'), (lambda x: x > 0, '?sc')], [(('available', '?s'), (lambda x: x == "", '?sv'))]) ttt_horizontal_adj = Operator(('horizontal_adj', '?s1', '?s2'), [(('row', '?s1'), '?s1r'), (('row', '?s2'), '?s1r'), (('col', '?s1'), '?s1c'), (('col', '?s2'), '?s2c'), (lambda x, y: abs(x-y) == 1, '?s1c', '?s2c')], [(('horizontal_adj', '?s1', '?s2'), True)]) ttt_vertical_adj = Operator(('vertical_adj', '?s1', '?s2'), [(('row', '?s1'), '?s1r'), (('row', '?s2'), '?s2r'), (('col', '?s1'), '?s1c'), (('col', '?s2'), '?s1c'),