def testBuildFormula(self):
data = numpy.random.uniform([-1,-1],[1,1],(500,2),).astype(numpy.float32)
ltnw.constant("c",[1.,0])
ltnw.variable("?var",data)
ltnw.variable("?var2",data)
ltnw.function("f",2,fun_definition=lambda d:d[:,:2])
ltnw.function("g",4,fun_definition=lambda d:d)
ltnw.predicate("P",2)
ltnw.predicate("B",2)
ltnw.predicate("REL",4)
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("P(c)")))
with self.assertRaises(Exception):
ltnw._build_formula(ltnw._parse_formula("P(d)"))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("P(?var)")))
with self.assertRaises(Exception):
ltnw._build_formula(ltnw._parse_formula("P(?vars)"))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("P(f(?var))")))
with self.assertRaises(Exception):
ltnw._build_formula(ltnw._parse_formula("P(h(?var))")) # h not declared
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("~P(?var)")))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("~P(f(?var))")))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("~REL(?var,?var2)")))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("~REL(?var,f(g(?var2)))")))
with self.assertRaises(Exception):
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("~REL(f(?var))")))
for op in ["&","|","->"]:
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("P(?var) %s ~ P(?var)" % op)))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("P(?var) %s ~ P(?var)" % op)))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("~P(?var) %s P(?var)" % op)))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("~P(?var) %s ~P(?var)" % op)))
for i in range(10):
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("P(?var) %s ~P(?var)%s ~P(?var)%s P(?var)" % tuple(numpy.random.permutation(["&","|","->"])))))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("forall ?var: P(?var) & ~ P(?var)")))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("forall ?var,?var2: P(?var) & ~ P(?var2)")))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("P(c) & (forall ?var,?var2: P(?var) & ~ P(?var2))")))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("exists ?var: P(?var) & ~ P(?var)")))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("exists ?var,?var2: P(?var) & ~ P(?var2)")))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("forall ?var: (exists ?var2: P(?var) & ~ P(?var2))")))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("forall ?var: (exists ?var2: P(?var) & ~ P(?var2))")))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("(forall ?var: (exists ?var2: (P(?var) & P(?var2) & (forall ?var: P(?var)))))")))
self.assertIsNotNone(ltnw._build_formula(ltnw._parse_formula("P(c) | P(?var)")))
def testBuildTerm(self):
data = numpy.random.uniform([-1,-1],[1,1],(500,2),).astype(numpy.float32)
ltnw.constant("c",2)
ltnw.variable("?var",data)
ltnw.function("f",2,fun_definition=lambda d:d)
ltnw.function("g",4,fun_definition=lambda d:d)
self.assertEqual(ltnw.constant("c"), ltnw._build_term('c'))
self.assertEqual(ltnw.variable("?var"), ltnw._build_term('?var'))
self.assertIsNotNone(ltnw._build_term(['f', ['?var']]))
self.assertIsNotNone(ltnw._build_term(['f', [['f', ['?var']]]]))
with self.assertRaises(Exception):
ltnw._build_term(['h', ['?var']]) # h not declared
with self.assertRaises(Exception):
self.assertRaises(ltnw._build_term(['g', ['?vars']])) # vars not declared
slope = 1.
var = 0.1
epochs = 1000
# define data
train_X = np.random.uniform(start, end, (training_size)).astype("float32")
train_Y = slope * train_X + np.random.normal(scale=var, size=len(train_X))
# define the language, we translate every training example into constants
[ltnw.constant("x_%s" % i, [x]) for i, x in enumerate(train_X)]
[ltnw.constant("y_%s" % i, [y]) for i, y in enumerate(train_Y)]
# define the function f as a linear regressor
W = tf.Variable(np.random.randn(), name="weight")
b = tf.Variable(np.random.randn(), name="bias")
ltnw.function("f", 1, 1, fun_definition=lambda X: tf.add(tf.multiply(X, W), b))
# defining an equal predicate based on the euclidian distance of two vectors
ltnw.predicate("eq", 2, ltnl.equal_euclidian)
# defining the theory
for f in ["eq(f(x_%s),y_%s)" % (i, i) for i in range(len(train_X))]:
ltnw.axiom(f)
print("\n".join(sorted(ltnw.AXIOMS.keys())))
# initializing knowledgebase and optimizing
ltnw.initialize_knowledgebase(optimizer=tf.train.GradientDescentOptimizer(
learning_rate=learning_rate))
ltnw.train(max_epochs=epochs)
# visualize results on training data
close_data = close_data[np.random.random_integers(0, len(data), 1000)]
distant_data = np.array([
np.concatenate([data[i], data[j]]) for i in range(len(data))
for j in range(len(data))
if np.sum(np.square(data[i] - data[j])) > np.square(1.)
])
# defining the language
ltnw.variable("?x", data)
ltnw.variable("?y", data)
ltnw.variable("?close_x_y", close_data)
ltnw.variable("?distant_x_y", distant_data)
[ltnw.predicate("C_" + str(i), 2) for i in range(nr_of_clusters)]
ltnw.function("first", 2, fun_definition=lambda d: d[:, :2])
ltnw.function("second", 2, fun_definition=lambda d: d[:, 2:])
print("defining the theory T")
ltnw.axiom("forall ?x: %s" %
"|".join(["C_%s(?x)" % i for i in range(nr_of_clusters)]))
for i in range(nr_of_clusters):
ltnw.axiom("exists ?x: C_%s(?x)" % i)
ltnw.axiom(
"forall ?close_x_y: C_%s(first(?close_x_y)) %% C_%s(second(?close_x_y))"
% (i, i))
ltnw.axiom(
"forall ?distant_x_y: C_%s(first(?distant_x_y)) %% C_%s(second(?distant_x_y))"
% (i, i))
for j in range(i + 1, nr_of_clusters):
ltnw.axiom("forall ?x: ~(C_%s(?x) & C_%s(?x))" % (i, j))
def testFunction(self):
f1=ltnw.function("F1",2)
f2=ltnw.function("F2",2)
self.assertEqual(ltnw.function("F1"),f1)
self.assertEqual(ltnw.function("F2"),f2)