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 load(symbols, id, children, depth, parent, encoding):
node = Node(SymbolSet.from_pickle(symbols),
depth,
parent,
id=id,
encoding=SymbolSet.from_pickle(encoding))
node._children = children
for child in node.children:
node._transitions.append(
clingo.Function('transition', [node.id, child]))
return node
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 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 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 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 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 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]
def __init__(self,
symbols: SymbolSet,
depth: int,
parent,
id=None,
encoding=None):
self._symbols = symbols
self._id = id
self._children = []
self._transitions = []
self._depth = depth
if parent != None:
if isinstance(parent, Node):
self._parent = parent.id
else:
self._parent = parent
else:
self._parent = None
self._goal = bool(symbols.count_atoms('goal', 1))
self._hash = None
self._sym_hash = {}
self._calc_hash()
self._encoding = encoding
def load(info):
info['symbols'] = SymbolSet.from_pickle(info['symbols'])
return Role(**info)
def load(info):
info['symbols'] = SymbolSet.from_pickle(info['symbols'])
return ConceptObj(**info)
class Node:
def __init__(self,
symbols: SymbolSet,
depth: int,
parent,
id=None,
encoding=None):
self._symbols = symbols
self._id = id
self._children = []
self._transitions = []
self._depth = depth
if parent != None:
if isinstance(parent, Node):
self._parent = parent.id
else:
self._parent = parent
else:
self._parent = None
self._goal = bool(symbols.count_atoms('goal', 1))
self._hash = None
self._sym_hash = {}
self._calc_hash()
self._encoding = encoding
def store(self):
info = {
'symbols': self._symbols.to_pickle(),
'id': self.id,
'children': self.children,
'depth': self.depth,
'parent': self.parent,
'encoding': self._encoding.to_pickle()
}
return info
@staticmethod
def load_state(info):
def load(symbols, id, children, depth, parent, encoding):
node = Node(SymbolSet.from_pickle(symbols),
depth,
parent,
id=id,
encoding=SymbolSet.from_pickle(encoding))
node._children = children
for child in node.children:
node._transitions.append(
clingo.Function('transition', [node.id, child]))
return node
return load(**info)
@property
def id(self) -> Optional[int]:
return self._id
@property
def name(self) -> clingo.Symbol:
return clingo.Number(self.id)
@property
def symbols(self) -> SymbolSet:
return self._symbols
@property
def transitions(self) -> List[clingo.Symbol]:
return self._transitions
@property
def depth(self) -> int:
return self._depth
@property
def parent(self) -> Optional[int]:
return self._parent
@property
def is_goal(self) -> bool:
return self._goal
@property
def state(self):
return self._symbols.get_atoms('state', 2) + self._symbols.get_atoms('stateId', 2) \
+ self._symbols.get_atoms('state', 1)
@property
def goal(self):
return self._symbols.get_atoms('goal', 1)
def add_child(self, child):
self._children.append(child.id)
self._transitions.append(
clingo.Function('transition', [self.id, child.id]))
@property
def children(self):
return self._children
def _calc_hash(self):
if self._hash != None: return
self._hash = 0
for var, val in self.description:
self._hash += hash(str(var) + str(val))
self._sym_hash[(SymbolHash(var), SymbolHash(val))] = True
@property
def description(self):
return [s.arguments[0:2] for s in self._symbols.get_atoms('holds', 3)]
def holds(self, variable: clingo.Symbol, value: clingo.Symbol):
return self._sym_hash.get((SymbolHash(variable), SymbolHash(value)),
False)
def __hash__(self):
return self._hash
def __eq__(self, other):
global time_eq
start = time.time()
if not isinstance(other, Node):
NotImplemented
if hash(self) != hash(other):
return False
holds = self.description
if len(holds) != len(other.description): return False
for var, val in holds:
if not other.holds(var, val):
time_eq += time.time() - start
return False
time_eq += time.time() - start
return True
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])
#print(self.state)
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])
@property
def encoding(self) -> Optional[List[clingo.Symbol]]:
return self._encoding.get_all_atoms()
def load(id, symbols):
return FeatureObj(id, SymbolSet.from_pickle(symbols))