def test_constraint(self):
model_string = "nn(fc,[X])::a(X).\nb:-a(0.2);a(0.8).\naux:-a(0.2),a(0.8).\naux2:-a(0.2);a(0.8).\nevidence(aux2).\nevidence(aux,false)."
fc = FC(10, 2)
net = Network(fc, 'fc', test)
model = Model(model_string, [net])
query = Term('b')
solution = model.solve(query)
print(solution)
def test_test(self):
model_string = "nn(fc,[X,Y],Z,[0,1]) :: a(X,Y,Z).\nb(X,Y,Z) :- a(X,Y,Z)."
fc = FC(10, 2)
net = Network(fc, 'fc',
lambda a, b, c: Variable(torch.FloatTensor([0.2, 0.8])))
model = Model(model_string, [net])
query = Term('b', Constant("string with 's"), Constant(3), Var('X'))
solution = model.solve(query, test=True)
print(solution)
def test_indirect_evidence(self):
model_string = """nn(fc,[X],Y,[0,1,2,3,4,5,6,7,8,9])::digit(X,Y).
addition(X,Y,Z) :- digit(X,X2),digit(Y,Y2),Z is X2+Y2."""
#evidence(digit(2,2))."""
#model_string = "nn(fc,[X])::a(X).\nb:-a(0.2).\nc:-b.\nevidence(b)."
fc = FC(10, 10)
net = Network(fc, 'fc',
lambda a, b: Variable(torch.FloatTensor([0.1] * 10)))
model = Model(model_string, [net])
query = Term('digit', Constant(2), Constant(2))
#query = Term('addition',Constant(2),Constant(3),Constant(5))
solution = model.solve(query)
print(solution)
def test_save_load(self):
model_string = "nn(fc,[X,Y],Z,[0,1]) :: a(X,Y,Z).\nt(0.5)::b."
fc = FC(10, 2)
net = Network(fc, 'fc',
lambda a, b, c: Variable(torch.FloatTensor([0.2, 0.8])))
model = Model(model_string, [net])
model.save_state('test_save.mdl')
orig_params = dict()
for p in model.parameters:
orig_params[p] = model.parameters[p]
model.parameters[p] = 0
original_net_params = list()
for i, param in enumerate(fc.parameters()):
original_net_params.append(param.data.clone())
param.data.zero_()
model.load_state('test_save.mdl')
for p in model.parameters:
self.assertEqual(model.parameters[p], orig_params[p])
for i, param in enumerate(fc.parameters()):
self.assertTrue(torch.equal(param.data, original_net_params[i]))
def test_fact_instantiate(self):
fc = FC(10, 2)
net = Network(fc, 'fc', None)
in_line = 'nn(fc,[X,Y])::term(X,Y) :- a(Y).'
out_line = 'nn(fc,[X,Y])::term(X,Y) :- a(Y).'
term = parser.parseString(in_line)[0]
expected = parser.parseString(out_line)[0]
net = net.instantiate(term)
self.assertEqual(str(net.term), str(expected))
in_line = 'nn(fc,[X,Y])::term(X,Y).'
out_line = 'nn(fc,[X,Y])::term(X,Y).'
term = parser.parseString(in_line)[0]
expected = parser.parseString(out_line)[0]
net = net.instantiate(term)
self.assertEqual(str(net.term), str(expected))
def test_ad_instantiate(self):
fc = FC(10, 2)
net = Network(fc, 'fc', None)
in_line = 'nn(fc,[X,Y],Z,[0,1])::term(X,Y,Z) :- a(Y).'
out_line = 'nn(fc,[X,Y],0)::term(X,Y,0);nn(fc,[X,Y],1)::term(X,Y,1) :- a(Y).'
test_out_line = 'nn(fc,[X,Y],Z)::term(X,Y,Z) :- fc(X,Y,Z), a(Y).'
term = parser.parseString(in_line)[0]
expected = parser.parseString(out_line)[0]
test_expected = parser.parseString(test_out_line)[0]
net = net.instantiate(term)
self.assertEqual(str(net.term), str(expected))
self.assertEqual(str(net.test_term), str(test_expected))
in_line = 'nn(fc,[X,Y],Z,[0,1])::term(X,Y,Z).'
out_line = 'nn(fc,[X,Y],0)::term(X,Y,0);nn(fc,[X,Y],1)::term(X,Y,1).'
test_out_line = 'nn(fc,[X,Y],Z)::term(X,Y,Z) :- fc(X,Y,Z).'
term = parser.parseString(in_line)[0]
expected = parser.parseString(out_line)[0]
test_expected = parser.parseString(test_out_line)[0]
net = net.instantiate(term)
self.assertEqual(str(net.term), str(expected))
self.assertEqual(str(net.test_term), str(test_expected))
test = 8
train_queries = load('data/train{}_test{}_train.txt'.format(train, test))
test_queries = load('data/train{}_test{}_test.txt'.format(train, test))
def neural_pred(network, i1, i2):
d = torch.zeros(20)
d[int(i1)] = 1.0
d[int(i2) + 10] = 1.0
d = torch.autograd.Variable(d.unsqueeze(0))
output = network.net(d)
return output.squeeze(0)
fc1 = FC(20, 2)
adam = torch.optim.Adam(fc1.parameters(), lr=1.0)
swap_net = Network(fc1, 'swap_net', neural_pred, optimizer=adam)
#with open('compare.pl') as f:
with open('quicksort.pl') as f:
problog_string = f.read()
model = Model(problog_string, [swap_net])
optimizer = Optimizer(model, 32)
train_model(model,
train_queries,
20,
optimizer,
test_iter=len(train_queries),
class RNN(nn.Module):
def __init__(self, vocab_size, hidden_size):
super(RNN, self).__init__()
self.lstm = nn.LSTM(vocab_size, hidden_size, 1, bidirectional=True)
def forward(self, x, n1, n2, n3):
x, _ = self.lstm(x)
x = torch.cat((x[-1, ...], x[n1, ...], x[n2, ...], x[n3, ...]), 1)
x.view(1, -1)
return x
rnn = RNN(len(vocab), 75)
network1 = FC(600, 6)
network2 = FC(600, 4)
network3 = FC(600, 2)
network4 = FC(600, 4)
def np1(net, sentence):
if net.last[0] == str(sentence): #Caching
return net.last[1]
tokenized, numbers, indices = tokenize(str(sentence).strip('"'))
data = torch.zeros(len(tokenized), 1, len(vocab))
for i, t in enumerate(tokenized):
data[i, 0, t] = 1.0
outputs = net.net(Variable(data), *indices)
net.last = (str(sentence), outputs)
return outputs
with open('choose.pl') as f:
problog_string = f.read()
def neural_pred(network, i1, i2, carry):
d = torch.zeros(30)
d[int(i1)] = 1.0
d[int(i2) + 10] = 1.0
d[int(carry) + 20] = 1.0
d = torch.autograd.Variable(d.unsqueeze(0))
outputs = network.net(d)
return outputs.squeeze(0)
net1 = FC(30, 25, 10)
network1 = Network(net1, 'neural1', neural_pred)
network1.optimizer = torch.optim.Adam(net1.parameters(), lr=0.05)
net2 = FC(30, 5, 2)
network2 = Network(net2, 'neural2', neural_pred)
network2.optimizer = torch.optim.Adam(net2.parameters(), lr=0.05)
model = Model(problog_string, [network1, network2], caching=False)
optimizer = Optimizer(model, 32)
logger = train_model(model,
train_queries,
40,
optimizer,
test_iter=len(train_queries) * 4,
test=lambda x: x.accuracy(test_queries, test=True))