class DataFile(object): #file where all querying and db extension happens def __init__(self, *sources): self._database = DefaultEngine().prepare(sources[0]) # pdb.set_trace() for source in sources[1:]: for clause in source: # pdb.set_trace() self._database += clause def query(self, predicate_name, arity=None, arguments=None): if arguments is None: assert arity is not None arguments = [None] * arity query = Term(predicate_name, *arguments) # import pdb; pdb.set_trace() return self._database.engine.query(self._database, query) def ground(self, rule, functor=None, arguments=None): if rule is None: db = self._database target = Term(functor) else: db = self._database.extend() target = None import pdb; pdb.set_trace() for clause in to_clauses(rule, functor): #ye dekho target = clause.head db += clause print(db) if arguments is not None: # pdb.set_trace() queries = [target.with_args(*args) for args in arguments] else: queries = [target] return self._database.engine.ground_all(db, queries=queries) def evaluate(self, rule, functor=None, arguments=None, ground_program=None): if ground_program is None: # pdb.set_trace() ground_program = self.ground(rule, functor, arguments) knowledge = get_evaluatable().create_from(ground_program) #ddnnf object of all groundings return knowledge.evaluate() #for each grounding given, finds probability from database and applies it
class DataFile(object): """Represents a data file. This is a wrapper around a ProbLog file that offers direct querying and evaluation functionality. :param source: ProbLog logic program :type source: LogicProgram """ def __init__(self, *sources): self._database = DefaultEngine().prepare(sources[0]) for source in sources[1:]: for clause in source: self._database += clause def query(self, functor, arity=None, arguments=None): """Perform a query on the data. Either arity or arguments have to be provided. :param functor: functor of the query :param arity: number of arguments :type arity: int | None :param arguments: arguments :type arguments: list[Term] :return: list of argument tuples :rtype: list[tuple[Term]] """ if arguments is None: assert arity is not None arguments = [None] * arity query = Term(functor, *arguments) return self._database.engine.query(self._database, query) def ground(self, rule, functor=None, arguments=None): """Generate ground program for the given rule. :param rule: rule to evaluate :type rule: Rule :param functor: override rule functor :type functor: str :param arguments: query arguments (None if non-ground) :type arguments: list[tuple[Term]] | None :return: ground program :rtype: LogicFormula """ if rule is None: db = self._database target = Term(functor) else: db = self._database.extend() target = None for clause in rule.to_clauses(functor): target = clause.head db += clause if arguments is not None: queries = [target.with_args(*args) for args in arguments] else: queries = [target] with Timer("Grounding", logger="probfoil"): return self._database.engine.ground_all(db, queries=queries) def evaluate(self, rule, functor=None, arguments=None, ground_program=None): """Evaluate the given rule. :param rule: rule to evaluate :type rule: Rule :param functor: override rule functor :type functor: str :param arguments: query arguments (None if non-ground) :type arguments: list[tuple[Term]] | None :param ground_program: use pre-existing ground program (perform ground if None) :type ground_program: LogicFormula | None :return: dictionary of results :rtype: dict[Term, float] """ if ground_program is None: ground_program = self.ground(rule, functor, arguments) with Timer("Compiling", logger="probfoil"): knowledge = get_evaluatable().create_from(ground_program) with Timer("Evaluating", logger="probfoil"): result = knowledge.evaluate() return result
# -*- coding: utf-8 -*- """ Created on Fri Jan 31 13:58:16 2020 @author: PasqualeDeMarinis """ from problog.engine import DefaultEngine from problog.logic import Term # ADDING CLAUSES AS AN EXTENSION OF THE DATABASE m1 = """ 0.3::a(1). query(a(X)). """ db = DefaultEngine().prepare(PrologString(m1)) print(get_evaluatable().create_from(db).evaluate()) m2 = """ 0.4::a(2). """ db2 = db.extend() for statement in PrologString(m2): db2 += statement print(get_evaluatable().create_from(db2).evaluate()) print(get_evaluatable().create_from(db).evaluate())
class DataFile(object): """Represents a data file. This is a wrapper around a ProbLog file that offers direct querying and evaluation functionality. :param source: ProbLog logic program :type source: LogicProgram """ def __init__(self, *sources): self._database = DefaultEngine().prepare(sources[0]) self._databaseEn = EnStructure() for source in sources[1:]: for clause in source: self._database += clause for source in sources: for clause in source: predicate = str(clause.functor) args = [str(x) for x in clause.args] if predicate == 'base': base = str(clause.args[0].functor) types = [str(x) for x in clause.args[0].args] self._databaseEn.add_base(base, types) elif predicate not in [ 'option', 'target', 'mode', 'learn', 'example_mode' ]: if clause.probability == None or float( clause.probability) != 0.0: self._databaseEn.add_tuple(predicate, args) def query(self, functor, arity=None, arguments=None): """Perform a query on the data. Either arity or arguments have to be provided. :param functor: functor of the query :param arity: number of arguments :type arity: int | None :param arguments: arguments :type arguments: list[Term] :return: list of argument tuples :rtype: list[tuple[Term]] """ if arguments is None: assert arity is not None arguments = [None] * arity query = Term(functor, *arguments) return self._database.engine.query(self._database, query) def ground(self, rule, functor=None, arguments=None): """Generate ground program for the given rule. :param rule: rule to evaluate :type rule: Rule :param functor: override rule functor :type functor: str :param arguments: query arguments (None if non-ground) :type arguments: list[tuple[Term]] | None :return: ground program :rtype: LogicFormula """ if rule is None: db = self._database target = Term(functor) else: db = self._database.extend() target = None for clause in rule.to_clauses(functor): target = clause.head db += clause if arguments is not None: queries = [target.with_args(*args) for args in arguments] else: queries = [target] return self._database.engine.ground_all(db, queries=queries) def evaluate(self, rule, functor=None, arguments=None, ground_program=None): """Evaluate the given rule. :param rule: rule to evaluate :type rule: Rule :param functor: override rule functor :type functor: str :param arguments: query arguments (None if non-ground) :type arguments: list[tuple[Term]] | None :param ground_program: use pre-existing ground program (perform ground if None) :type ground_program: LogicFormula | None :return: dictionary of results :rtype: dict[Term, float] """ if ground_program is None: ground_program = self.ground(rule, functor, arguments) knowledge = get_evaluatable().create_from(ground_program) return knowledge.evaluate() def evaluateEn(self, clause): n_clause = [] for i in range(len(clause)): a = [EnPredicate(clause[i][0])] for j in range(1, len(clause[i])): a.append(EnAtom(str(clause[i][j]))) n_clause.append(a) return self._databaseEn.satisfy_clause_recursive(n_clause) def evaluateRuleEn(self, rule, example): #with open('log.txt', 'a+') as file: # file.write(str(rule) + '('+str(example)+')') variables = {} head = rule.get_literals()[0] #head_predicate = str(head.functor) #head_args = [] for i in range(len(head.args)): if type(head.args[i]) == Var: v = EnVariable(str(head.args[i])) variables[v] = EnAtom(str(example[i])) #head_args.append(v) #elif type(head.args[i]) == Constant: #head_args.append(EnAtom(str(head.args[i]))) #head_get = [EnPredicate(head_predicate)] #head_get.extend(head_args) body = rule.get_literals()[1:] #rule_get = [head_get] rule_get = [] for clause in body: cl = clause.child if type(clause) == Not else clause clause_predicate = str(cl.functor) clause_args = [] for i in range(len(cl.args)): if type(cl.args[i]) == Var: v = EnVariable(str(cl.args[i])) clause_args.append(v) elif type(cl.args[i]) == Constant: clause_args.append(EnAtom(str(cl.args[i]))) clause_get = [ EnNot(EnPredicate(clause_predicate)) if type(clause) == Not else EnPredicate(clause_predicate) ] #clause_get = [EnPredicate(clause_predicate)] clause_get.extend(clause_args) rule_get.append(clause_get) return self._databaseEn.satisfy_clause_recursive(rule_get, variables)