def materialize(facts, clauses, parser):
logger.info('Asserting facts ..')
for f in facts:
# Each fact is asserted using the index of the subject, predicate and object for avoiding syntax issues
s_idx = parser.entity_to_index[f.argument_names[0]]
p_idx = parser.predicate_to_index[f.predicate_name]
o_idx = parser.entity_to_index[f.argument_names[1]]
# Asserting p(S, P, O)
pyDatalog.assert_fact('p', s_idx, p_idx, o_idx)
rules_str = '\n'.join(
[clause_to_str(clause, parser) for clause in clauses])
pyDatalog.load(rules_str)
# Asking for all P(s, p, o) triples which hold true in the Knowledge Graph
logger.info('Querying triples ..')
_ans = pyDatalog.ask('p(S, P, O)')
index_to_predicate = {
idx: p
for p, idx in parser.predicate_to_index.items()
}
index_to_entity = {idx: e for e, idx in parser.entity_to_index.items()}
# Generating a list of inferred facts by replacing each entity and predicate index with their corresponding symbols
inferred_facts = [
Fact(index_to_predicate[p], [index_to_entity[s], index_to_entity[o]])
for (s, p, o) in sorted(_ans.answers)
]
return inferred_facts
def test_materialize():
initial_facts = [
Fact('q', ['{}'.format(idx), '{}'.format(idx + 1)])
for idx in range(64)
]
parser = KnowledgeBaseParser(initial_facts)
parser.predicate_to_index['p'] = 2
clauses = [
parse_clause('q(X, Z) :- q(X, Y), q(Y, Z)'),
parse_clause('p(X, Y) :- q(X, Y)')
]
inferred_facts = materialize(initial_facts, clauses, parser)
inferred_triples = [(f.argument_names[0], f.predicate_name,
f.argument_names[1]) for f in inferred_facts]
entities = {s
for (s, _, _) in inferred_triples
} | {o
for (_, _, o) in inferred_triples}
for e1 in entities:
for e2 in entities:
if int(e1) < int(e2):
assert (str(e1), 'q', str(e2)) in inferred_triples
assert (str(e1), 'p', str(e2)) in inferred_triples
print('+')
else:
assert (str(e1), 'q', str(e2)) not in inferred_triples
assert (str(e1), 'p', str(e2)) not in inferred_triples
print('-')
def fact(s, p, o):
return Fact(predicate_name=p, argument_names=[s, o])
from inferbeddings.models import similarities
from inferbeddings.knowledgebase import Fact, KnowledgeBaseParser
from inferbeddings.parse import parse_clause
from inferbeddings.models.training import constraints
from inferbeddings.adversarial import Adversarial
from inferbeddings.adversarial.closedform import ClosedForm
import logging
import pytest
logger = logging.getLogger(__name__)
triples = [('a', 'p', 'b'), ('c', 'p', 'd'), ('a', 'q', 'b')]
facts = [Fact(predicate_name=p, argument_names=[s, o]) for s, p, o in triples]
parser = KnowledgeBaseParser(facts)
nb_entities = len(parser.entity_to_index)
nb_predicates = len(parser.predicate_to_index)
# Clauses
clause_str = 'q(X, Y) :- p(X, Y)'
clauses = [parse_clause(clause_str)]
# Instantiating the model parameters
model_class = models.get_function('TransE')
similarity_function = similarities.get_function('l2_sqr')
model_parameters = dict(similarity_function=similarity_function)
