def testSimplePredicateOptimization(self): nr_samples=100 ltnw.variable("?data_A",numpy.random.uniform([0.,0.],[.1,1.],(nr_samples,2)).astype("float32")) ltnw.variable("?data_not_A",numpy.random.uniform([2.,0],[3.,1.],(nr_samples,2)).astype("float32")) ltnw.predicate("A",2) ltnw.axiom("forall ?data_A: A(?data_A)") ltnw.axiom("forall ?data_not_A: ~A(?data_not_A)") ltnw.initialize_knowledgebase(initial_sat_level_threshold=.1) sat_level=ltnw.train(track_sat_levels=10000,sat_level_epsilon=.99) self.assertGreater(sat_level,.8) ltnw.constant("a",[0.5,0.5]) ltnw.constant("b",[2.5,0.5]) self.assertGreater(ltnw.ask("A(a)")[0],.8) self.assertGreater(ltnw.ask("~A(b)")[0],.8) result=ltnw.ask_m(["A(a)","~A(b)"]) for r in result: self.assertGreater(r[0],.8) self.assertGreater(r[0],.8)
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 testSimplePredicate(self): import tensorflow nr_samples=100 ltnw.constant("a",[2.,3.]) ltnw.variable("?data_A",numpy.random.uniform([0.,0.],[.1,1.],(nr_samples,2)).astype("float32")) mu=tensorflow.constant([2.,3.]) ltnw.predicate("A",2,pred_definition=lambda x: tensorflow.exp(-tensorflow.norm(tensorflow.subtract(x,mu),axis=1))); self.assertEqual(ltnw.ask("A(a)"),1.) self.assertGreater(ltnw.ask("forall ?data_A: A(?data_A)"),0.)
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
# 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 ltnw.variable("?x", 1) prediction = ltnw.ask("f(?x)", feed_dict={"?x": train_X.reshape(len(train_X), 1)}) plt.figure(figsize=(12, 5)) plt.subplot(1, 2, 1) plt.plot(train_X, train_Y, 'bo', label='Training data', color="black") plt.plot(train_X, ltnw.SESSION.run(W) * train_X + ltnw.SESSION.run(b), label='Fitted line') plt.plot(train_X, prediction, 'bo', label='prediction', color="red") plt.legend() # generate test data and visualize regressor results test_X = np.random.uniform(start, end, (testing_size)).astype("float32") prediction = ltnw.ask("f(?x)", feed_dict={"?x": test_X.reshape(len(test_X), 1)})
data = np.concatenate(clusters) close_data = np.array([ np.concatenate([data[i], data[j]]) for i in range(len(data)) for j in range(i, len(data)) if np.sum(np.square(data[i] - data[j])) < np.square(.5) ]) 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))"
names_of_classes=cat_materials, device=device) cat_horizontal = ['Right', 'Left'] Category_Horizontal = ltnw.class_category(class_label='Horizontal', number_of_features=2 * num_of_features, names_of_classes=cat_horizontal, device=device) cat_vertical = ['Front', 'Behind'] Category_Vertical = ltnw.class_category(class_label='Vertical', number_of_features=2 * num_of_features, names_of_classes=cat_vertical, device=device) # Object Variables Placeholders ltnw.variable('?obj', torch.zeros(1, num_of_features)) ltnw.variable('?obj_2', torch.zeros(1, num_of_features)) for i, feat in enumerate(obj_colors): ltnw.mlp_predicate(label=feat.capitalize(), class_category=Category_Color) ltnw.variable('?is_' + feat, torch.zeros(1, num_of_features, device=device)) ltnw.axiom('forall ?is_' + feat + ' : ' + feat.capitalize() + '(?is_' + feat + ')') ltnw.variable('?isnot_' + feat, torch.zeros(1, num_of_features, device=device)) ltnw.axiom('forall ?isnot_' + feat + ' : ~' + feat.capitalize() + '(?isnot_' + feat + ')') for i, feat in enumerate(obj_sizes): ltnw.mlp_predicate(label=feat.capitalize(), class_category=Category_Size) ltnw.variable('?is_' + feat, torch.zeros(1, num_of_features, device=device))
# generate data nr_of_clusters = 2 nr_of_points_x_cluster = 50 clusters = [] for i in range(nr_of_clusters): mean = np.random.uniform([-1, -1], [1, 1], 2).astype(np.float32) cov = np.array([[.001, 0], [0, .001]]) clusters.append( np.random.multivariate_normal(mean=mean, cov=cov, size=nr_of_points_x_cluster).astype( np.float32)) data = np.concatenate(clusters) # define the language ltnw.variable("?x", data) ltnw.variable("?y", data) ltnw.predicate("close", 2, ltnl.equal_euclidian) [ltnw.predicate("C_" + str(i), 2) for i in range(nr_of_clusters)] ## define the theory 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 ?x,?y: (C_%s(?x) & close(?x,?y)) -> C_%s(?y)" % (i, i)) ltnw.axiom( "forall ?x,?y: (C_%s(?x) & ~close(?x,?y)) -> (%s)" % (i, "|".join(["C_%s(?y)" % j for j in range(nr_of_clusters) if i != j])))
# -*- coding: utf-8 -*- import logging; logging.basicConfig(level=logging.INFO) import numpy as np import matplotlib.pyplot as plt import logictensornetworks_wrapper as ltnw nr_samples=500 data=np.random.uniform([0,0],[1.,1.],(nr_samples,2)).astype(np.float32) data_A=data[np.where(np.sum(np.square(data-[.5,.5]),axis=1)<.09)] data_not_A=data[np.where(np.sum(np.square(data-[.5,.5]),axis=1)>=.09)] ltnw.variable("?data_A",data_A) ltnw.variable("?data_not_A",data_not_A) ltnw.variable("?data",data) ltnw.predicate("A",2) ltnw.axiom("forall ?data_A: A(?data_A)") ltnw.axiom("forall ?data_not_A: ~A(?data_not_A)") ltnw.initialize_knowledgebase(initial_sat_level_threshold=.1) sat_level=ltnw.train(track_sat_levels=1000,sat_level_epsilon=.99) plt.figure(figsize=(12,8)) result=ltnw.ask("A(?data)") plt.subplot(2,2,1) plt.scatter(data[:,0],data[:,1],c=result.squeeze()) plt.colorbar()
import tensorflow as tf import matplotlib.pyplot as plt import numpy as np import logictensornetworks_wrapper as ltnw import spatial_relations_data # generate artificial data nr_examples = 50 # positive and negative examples for each predicate nr_test_examples=400 # 1) define the language and examples ltnw.predicate("Left",8) ltnw.variable("?left_xy",8) ltnw.variable("?not_left_xy", 8) ltnw.axiom("forall ?left_xy: Left(?left_xy)") ltnw.axiom("forall ?not_left_xy: ~Left(?not_left_xy)") ltnw.predicate("Right",8) ltnw.variable("?right_xy",8) ltnw.variable("?not_right_xy",8) ltnw.axiom("forall ?right_xy: Right(?right_xy)") ltnw.axiom("forall ?not_right_xy: ~Right(?not_right_xy)") ltnw.predicate("Below",8) ltnw.variable("?below_xy",8) ltnw.variable("?not_below_xy",8) ltnw.axiom("forall ?below_xy: Below(?below_xy)")
not_obj_attr[feat] = [x for x in full_obj_set if x[i] == 0] not_obj_attr[feat] = random.sample( not_obj_attr[feat], min(len(obj_attr[feat]), len(not_obj_attr[feat]))) ################## ### Set Up LTN ### ################## time_diff = time.time() - start_time print('Time to complete : ', time_diff) start_time = time.time() print('******* Setting up LTN ******') # Object Constants/Variables #for i in range(len(full_obj_set)): # ltnw.constant('object'+str(i),full_obj_set[i]) ltnw.variable('?obj', full_obj_set) ltnw.variable('?obj_2', full_obj_set) for i, feat in enumerate(obj_feat): ltnw.variable('?is_' + feat, obj_attr[feat]) ltnw.variable('?isnot_' + feat, not_obj_attr[feat]) ltnw.variable('?right_pair', [full_obj_set[p[0]] + full_obj_set[p[1]] for p in right_pairs]) ltnw.variable('?left_pair', [full_obj_set[p[0]] + full_obj_set[p[1]] for p in left_pairs]) ltnw.variable('?front_pair', [full_obj_set[p[0]] + full_obj_set[p[1]] for p in front_pairs]) ltnw.variable('?behind_pair', [full_obj_set[p[0]] + full_obj_set[p[1]] for p in behind_pairs]) time_diff = time.time() - start_time print('Time to complete : ', time_diff)
import logging logger = logging.getLogger() logger.basicConfig = logging.basicConfig(level=logging.DEBUG) import numpy as np import matplotlib.pyplot as plt import torch import logictensornetworks_wrapper as ltnw nr_samples=500 data=np.random.uniform([0,0],[1.,1.],(nr_samples,2)).astype(np.float32) data_A=data[np.where(np.sum(np.square(data-[.5,.5]),axis=1)<.09)] data_B=data[np.where(np.sum(np.square(data-[.5,.5]),axis=1)>=.09)] ltnw.variable("?data",data) ltnw.variable("?data_A",data_A) ltnw.variable("?data_B",data_B) ltnw.predicate("A",2) ltnw.predicate("B",2) ltnw.axiom("forall ?data_A: A(?data_A)") ltnw.axiom("forall ?data_B: ~A(?data_B)") ltnw.axiom("forall ?data_B: B(?data_B)") ltnw.axiom("forall ?data_A: ~B(?data_A)") ltnw.axiom("forall ?data: A(?data) -> ~B(?data)") ltnw.axiom("forall ?data: B(?data) -> ~A(?data)")
ltn.BIAS_factor = -1e-8 ltn.set_universal_aggreg("mean") # The truth value of forall x p(x) is # interpretable as the percentage of # element in the range of x that satisties p embedding_size = 10 # each constant is interperted in a vector of this size # create on constant for each individual a,b,... i,j, ... for l in 'abcdefghijklmn': ltnw.constant(l, min_value=[0.] * embedding_size, max_value=[1.] * embedding_size) # create variables that ranges on all the individuals, and the individuals of group 1 and group 2. ltnw.variable("p", tf.concat(list(ltnw.CONSTANTS.values()), axis=0)) ltnw.variable("q", ltnw.VARIABLES["p"]) ltnw.variable("p1", tf.concat([ltnw.CONSTANTS[l] for l in "abcdefgh"], axis=0)) ltnw.variable("q1", ltnw.VARIABLES["p1"]) ltnw.variable("p2", tf.concat([ltnw.CONSTANTS[l] for l in "ijklmn"], axis=0)) ltnw.variable("q2", ltnw.VARIABLES["p2"]) # declare the predicates ltnw.predicate('Friends', embedding_size * 2) ltnw.predicate('Smokes', embedding_size) ltnw.predicate('Cancer', embedding_size) # add the assertional knowledge in our posses ltnw.axiom("Friends(a,b)") ltnw.axiom("~Friends(a,c)")
import logging logger = logging.getLogger() logger.basicConfig = logging.basicConfig(level=logging.DEBUG) import numpy as np import matplotlib.pyplot as plt import logictensornetworks_wrapper as ltnw nr_samples=5 epochs=10000 data_A=np.random.uniform([0,0],[.25,1.],(nr_samples,2)).astype(np.float32) data_B=np.random.uniform([.75,0],[1.,1.],(nr_samples,2)).astype(np.float32) data=np.concatenate([data_A,data_B]) ltnw.variable("?data_A",data_A) ltnw.variable("?data_A_2",data_A) ltnw.variable("?data_B",data_B) ltnw.variable("?data_B_2",data_B) ltnw.variable("?data",data) ltnw.variable("?data_1",data) ltnw.variable("?data_2",data) ltnw.predicate("A",2) ltnw.predicate("B",2) ltnw.axiom("forall ?data_A: A(?data_A)") ltnw.axiom("forall ?data_B: ~A(?data_B)") ltnw.axiom("forall ?data_B: B(?data_B)") ltnw.axiom("forall ?data_A: ~B(?data_A)")
################## # time_diff = time.time()-start_time # print('Time to complete : ', time_diff) # start_time = time.time() # print('******* Setting up LTN ******') num_of_features = len( full_obj_set[0] ) # =512 (output of resnet-32 layer3 for whole image (256) + object (256)) # Object Constants/Variables #for i in range(len(full_obj_set)): # ltnw.constant('object'+str(i),full_obj_set[i]) # 'verbose' argument is used to bypass the variable redeclare warning message ltnw.variable('?obj', torch.stack(full_obj_set).to(device), verbose=False) ltnw.variable('?obj_2', torch.stack(full_obj_set).to(device), verbose=False) for i, feat in enumerate(obj_feat): ltnw.variable('?is_' + feat, torch.stack(obj_attr[feat]).to(device), verbose=False) ltnw.variable('?isnot_' + feat, torch.stack(not_obj_attr[feat]).to(device), verbose=False) ltnw.variable('?right_pair', torch.stack([ torch.cat([full_obj_set[p[0]], full_obj_set[p[1]]]) for p in right_pairs ]).to(device),
def testVariable(self): v1=ltnw.variable("?var1",[1,2,3]) v2=ltnw.variable("?var2",2) self.assertEqual(ltnw.variable("?var1"),v1) self.assertEqual(ltnw.variable("?var2"),v2)