def __init_encoding(self): def get_null_pred(variables): nulls = [] for var in variables: pred = var.arguments[0].arguments[0] if (pred.type == clingo.SymbolType.String): nulls.append(pred.string) return nulls with create_solver() as ctl: self._init_solver(ctl) ctl.ground([(Logic.base)]) symbols = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(atoms=True)) assert (len(symbols) == 1) variables = SymbolSet(symbols[0]).get_atoms('variable', 1) #Add predicates of arity 0 ctl.addSymbols([ clingo.Function('arity', [n, 0]) for n in get_null_pred(variables) ]) ctl.ground([('predicates', []), ('const', [])]) symbols = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) assert (len(symbols) == 1) symset = SymbolSet(symbols[0]) self._pred = symset.get_atoms('pred', 1) self._arity = symset.get_atoms('arity', 2) self._const = symset.get_atoms('const', 1)
def get_successors(self, node: Node) -> List[Node]: #print('Generating successors of', node.id) write_symbols( node.symbols.get_all_atoms(), '/home/ivan/Documents/ai/features/res/samples/clear/hard_complete/node.lp' ) with create_solver(args=dict(arguments=['-n 0'])) as ctl: self._init_solver(ctl) ctl.addSymbols(node.symbols.get_all_atoms()) ctl.ground([Logic.base, successor()]) ctl.solve() ctl.cleanup() #print(ctl.getAtoms('validAction', 3)) ctl.ground([evaluate()]) ctl.solve() ctl.cleanup() ctl.ground([show_expanded()]) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) ctl.cleanup() new_nodes = [] for m in models: new_nodes.append(Node(SymbolSet(m), node.depth + 1, node)) #print('Child nodes', [node.symbols.get_atoms('expanded', 2) for node in new_nodes]) return new_nodes
def as_role(self, id): with create_solver() as ctl: ctl.load(Logic.grammarFile) ctl.addSymbols(self.symbols.get_all_atoms()) ctl.ground([Logic.base, ('to_role', [id])]) sym = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) symbols = SymbolSet(sym[0]) return Role(id, self.cost, symbols)
def to_feature(self, id): with create_solver() as ctl: ctl.load(Logic.featureFile) ctl.addSymbols(self._symbols.get_all_atoms()) ctl.ground([Logic.base, ('to_feature', [id])]) sym = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True))[0] symbols = SymbolSet(sym) return FeatureObj(id, symbols)
def roles(sample): with create_solver(args=dict(arguments=['-n 0'])) as ctl: ctl.load([Logic.grammarFile]) ctl.addSymbols(sample.get_sample()) ctl.ground([Logic.base, Logic.roles]) ctl.solve() ctl.ground([('show_role', [])]) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) return [PreRole(SymbolSet(model), 1) for model in models]
def __call__(self) -> List[clingo.Symbol]: logging.debug('Calling Nullary') with create_solver(args=dict(arguments=['-n 0'])) as ctl: ctl.load([Logic.featureFile]) ctl.addSymbols(self.sample.get_sample()) ctl.ground( [Logic.base, Feature.primitiveFeature, Feature.processFeat]) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) return [PreFeature(SymbolSet(model)) for model in models]
def __call__(self) -> List[Expression]: logging.debug('Calling Primitive') with create_solver(args=dict(arguments=['-n 0'])) as ctl: ctl.load([Logic.grammarFile]) ctl.addSymbols(self.sample.get_sample()) ctl.ground([ Logic.base, Concept.primitive(1), ('cardinality', []), ('show_exp', []) ]) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) return [Expression(SymbolSet(model), 1) for model in models]
def initial_state(self) -> Node: with create_solver() as ctl: self._init_solver(ctl) ctl.ground([Logic.base, initial_state(), evaluate()]) ctl.solve() ctl.ground([show_expanded()]) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) assert (len(models) == 1) #print('Models', models) symbols = SymbolSet(models[0]) return Node(symbols, 0, None)
def encode(self, prob): assert (self._encoding == None) with create_solver() as ctl: ctl.load(Logic.problem) ctl.load(Logic.sample_encoding) ctl.addSymbols(self.symbols.get_all_atoms() + prob.predicates + prob.const) ctl.ground([Logic.base, hold(), encode()]) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) #print(ctl.getAtoms('hold', 3), len(models)) assert (len(models) == 1) self._encoding = SymbolSet(models[0])
def make_state(self, id): assert (self.id == None) self._id = id with create_solver() as ctl: ctl.load(Logic.problem) ctl.load(Logic.sample_encoding) ctl.addSymbols(self.symbols.get_all_atoms()) ctl.ground([Logic.base, to_state(id)]) #print(ctl.getAtoms('expanded', 2)) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) assert (len(models) == 1) self._symbols = SymbolSet(models[0])
def __call__(self) -> List[Expression]: logging.debug('Calling EqualRole') sym = [] for r in self.roles: sym += r.symbols.get_all_atoms() with create_solver(args=dict(arguments=['-n 0'])) as ctl: ctl.load([Logic.grammarFile]) ctl.addSymbols(self.sample.get_const() + self.sample.get_states()) ctl.addSymbols(sym) ctl.ground([ Logic.base, Concept.equalRole(3), ('cardinality', []), ('show_exp', []) ]) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) return [Expression(SymbolSet(model), 3) for model in models]
def __call__(self) -> List[FeatureObj]: logging.debug('Calling Distance({})'.format( tuple(([c.id for c in co] for co in (self.conc1, self.conc, self.conc2))))) with create_solver(args=dict(arguments=['-n 0'])) as ctl: possym = [] symbols = [] for i, cs in enumerate((self.conc1, self.conc, self.conc2)): s = [] for c in cs: s += c.concept symbols += c.symbols.get_all_atoms() ctl.load([Logic.featureFile]) ctl.addSymbols(s) ctl.ground([Logic.base, ('dist_pos', [i])]) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) assert (len(models) == 1) possym += models[0] ctl.reset(arguments=['-n 0']) for r in self.roles: symbols += r.symbols.get_all_atoms() #print(possym) ctl.load([Logic.featureFile]) ctl.addSymbols(self.sample.get_states()) ctl.addSymbols(self.sample.get_transitions()) ctl.addSymbols(self.sample.get_const()) ctl.addSymbols(symbols + possym) ctl.ground([Logic.base, Feature.distFeature(self.max_cost)]) count = 1 while True: ctl.ground([('dist_const', [count - 1])]) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) assert (len(models) == 1) model = models[0] #print(model) if len(model) != count: break count += 1 ctl.ground([('value_dist', []), Feature.processFeat]) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) logging.debug('Found {} features'.format(len(models))) return [PreFeature(SymbolSet(model)) for model in models]
def __call__(self) -> List[Expression]: logging.debug('Calling Negation({})'.format( [c.id for c in self.primitive])) sym = [] for c in self.primitive: sym += c.symbols.get_all_atoms() with create_solver(args=dict(arguments=['-n 0'])) as ctl: ctl.load([Logic.grammarFile]) ctl.addSymbols(sym) ctl.addSymbols(self.sample.get_const() + self.sample.get_states()) ctl.ground([ Logic.base, Concept.negation(2), ('cardinality', []), ('show_exp', []) ]) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) return [Expression(SymbolSet(model), 2) for model in models]
def __call__(self) -> List[clingo.Symbol]: logging.debug('Calling ConceptFeat({})'.format( [c.id for c in self.concepts])) sym = [] for c in self.concepts: sym += c.symbols.get_all_atoms() with create_solver(args=dict(arguments=['-n 0'])) as ctl: ctl.load([Logic.featureFile]) ctl.addSymbols(sym) ctl.addSymbols(self.sample.get_states()) ctl.addSymbols(self.sample.get_transitions()) ctl.addSymbols(self.sample.get_const()) #ctl.addSymbols(self.sample.get_sample()) ctl.ground( [Logic.base, Feature.conceptFeature, Feature.processFeat]) models = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True)) return [PreFeature(SymbolSet(model)) for model in models]