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 solve_T_G(sample: Sample, features: Features):
with create_solver(type_= SolverType.PROFILE) as ctl:
ctl.load([Logic.t_g, features.features])
ctl.addSymbols(sample.get_sample() + sample.get_relevant())
ctl.ground([Logic.base])
prof_g = ctl.get_profiling()
sym = ctl.solve(solvekwargs=dict(yield_=True), symbolkwargs=dict(shown=True))
prof_s = ctl.get_profiling()
return sym, prof_g, prof_s
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]
