import context
from zincbase import KB
kb = KB()
kb.store('a(b,c)')
kb.node('b')['is_letter'] = 1.0
assert kb.node('b').attrs == {'is_letter': 1.0}
assert 'is_letter' in kb.node('b')
kb.node('b')['is_letter'] = 2.0
del kb.node('b')['is_letter']
assert 'is_letter' not in kb.node('b').attrs
kb.node('b')['is_letter'] = 2.0
assert kb.node('b').attrs == {'is_letter': 2.0}
kb.edge('b', 'a', 'c').both_alpha = 1.0
assert kb.edge('b', 'a', 'c').attrs == {'both_alpha': 1.0}
kb.edge('b', 'a', 'c')['both_alpha'] = 2.0
assert kb.edge('b', 'a', 'c').attrs == {'both_alpha': 2.0}
assert kb.to_triples() == [('b', 'a', 'c')]
triples = kb.to_triples(data=True)
assert triples == [('b', 'a', 'c', {
'is_letter': 2.0
}, {
'both_alpha': 2.0
}, {}, False)]
kb.node('c').is_letter = 0.9
triples = kb.to_triples(data=True)
assert triples == [('b', 'a', 'c', {
'is_letter': 2.0
}, {
'both_alpha': 2.0
}, {
import context
from zincbase import KB
kb = KB()
kb.store('a(b,c)')
kb.attr('b', {'is_letter': 1.0})
assert kb.node('b') == {'is_letter': 1.0}
kb.edge_attr('b', 'a', 'c', {'both_alpha': 1.0})
assert kb.edge('b', 'a', 'c') == {'both_alpha': 1.0}
assert kb.to_triples() == [('b', 'a', 'c')]
triples = kb.to_triples(data=True)
assert triples == [('b', 'a', 'c', {'is_letter': 1.0}, {'both_alpha': 1.0}, {}, False)]
kb.attr('c', {'is_letter': 0.9})
triples = kb.to_triples(data=True)
assert triples == [('b', 'a', 'c', {'is_letter': 1.0}, {'both_alpha': 1.0}, {'is_letter': 0.9}, False)]
neg_rule_idx = kb.store('~a(b,c)')
triples = kb.to_triples(data=True)
assert triples == [('b', 'a', 'c', {'is_letter': 1.0}, {'both_alpha': 1.0}, {'is_letter': 0.9}, True)]
kb.delete_rule(neg_rule_idx)
triples = kb.to_triples(data=True)
assert triples == [('b', 'a', 'c', {'is_letter': 1.0}, {'both_alpha': 1.0}, {'is_letter': 0.9}, False)]
kb.edge_attr('b', 'a', 'c', {'truthiness':-1})
triples = kb.to_triples(data=True)
assert triples == [('b', 'a', 'c', {'is_letter': 1.0}, {'both_alpha': 1.0, 'truthiness': -1}, {'is_letter': 0.9}, True)]
kb.delete_edge_attr('b', 'a', 'c', ['truthiness'])
triples = kb.to_triples(data=True)
assert triples == [('b', 'a', 'c', {'is_letter': 1.0}, {'both_alpha': 1.0}, {'is_letter': 0.9}, False)]
print('All graph tests passed.')
kb.node(n).value += 1
kb.node('node1').watch('value', watch_fn)
kb.node('node2').watch('value', watch_fn)
kb.node('node1').value += 1
assert kb.node('node1').value == 1
assert kb.node('node2').value == 1
assert kb.node('node3').value == 1
kb.set_propagation_limit(1)
kb.node('node1').value += 1
assert kb.node('node1').value == 2
kb.node('node2').value == 2
kb.node('node3').value == 1
kb = KB()
kb.store('is_linked(a,b)', edge_attributes={'zig': 1})
edge = kb.edge('a', 'is_linked', 'b')
node_a = kb.node('a')
node_b = kb.node('b')
node_a.node_zig = 1
node_b.node_zig = 2
assert edge.zig == 1
was_called = False
def nights_watch(edge, prev_val):
global was_called
assert prev_val == 1
assert edge.nodes[0] == 'a'
assert edge.nodes[1] == 'b'
for node in edge.nodes:
node.node_zig += 1
was_called = True
edge.watch('zig', nights_watch)
assert new_node.foo == 'bar'
new_node.foo = 'baz'
new_node = kb.node('i_am_node')
assert new_node.foo == 'baz'
kb.store('connected_nodes(3, 4)',
node_attributes=[{
'x': 3
}, {
'x': 4
}],
edge_attributes={'power_level': 3})
_3 = kb.node(3)
_4 = kb.node(4)
assert _3.x == 3
assert _4.x == 4
assert kb.edge(3, 'connected_nodes', 4).power_level == 3
kb.edge(3, 'connected_nodes', 4).power_level = 'high'
assert kb.edge(3, 'connected_nodes', 4).power_level == 'high'
kb = KB()
kb.from_csv('./assets/countries_s1_train.csv', delimiter='\t')
kb.node('mali').zig = 123
called = False
for node in kb.nodes():
if node == 'mali':
called = True
assert called == True
assert node.attrs['zig'] == 123
assert called
mali = list(kb.nodes(lambda x: x == 'mali'))
assert len(mali) == 1
kb.store('edge(2, 4)', edge_attributes={'edge_attr': 3})
g.from_kb(kb)
g.render(node_color='node => node.color',
arrow_size=2,
node_opacity=1,
node_label='color',
label_node=True,
edge_label='edge_attr',
label_edge=True,
label_edge_offset=1,
bg_color='rgba(255,255,255,1)')
while True:
time.sleep(1)
node_to_update = kb.node(random.choice([1, 2, 3, 4]))
node_to_update.color = random.randint(0, 0xffffff)
g.update_node(node_to_update, defer=True)
from_node = random.choice([1, 2])
to_node = random.choice([2, 3, 4])
if from_node == 1 and to_node != 2:
pass
elif from_node == to_node:
pass
else:
from_node = str(from_node)
to_node = str(to_node)
edge = kb.edge(from_node, 'edge', to_node)
edge.edge_attr = random.randint(0, 100)
g.update_edge(edge, defer=True)
g.batch_update()
assert bay_prob > 2 * sea_prob
sea_prob = kb.estimate_triple_prob('other1', 'lives_in', 'seattle')
bay_prob = kb.estimate_triple_prob('other1', 'lives_in', 'bay_area')
assert sea_prob > 2 * bay_prob
sea_prob = kb.estimate_triple_prob('other2', 'lives_in', 'seattle')
bay_prob = kb.estimate_triple_prob('other2', 'lives_in', 'bay_area')
assert sea_prob > 2 * bay_prob
print('First suite of neural network tests passed.')
# # # # # # # # # # # # # # # # # # # # # # # #
# Test predicate attributes
# # # # # # # # # # # # # # # # # # # # # # # #
kb.store('lives_in(tom, seattle)') ## TODO seems weird to have to add this fact then stick 'formerly' on it
# on the next line.
kb.edge('tom', 'lives_in', 'seattle')['formerly'] = 1.0
kb.seed(555)
kb.build_kg_model(cuda=False, embedding_size=50, node_attributes=['owns_a_raincoat', 'doesnt_own_raincoat'],
pred_attributes=['formerly'], attr_loss_to_graph_loss=0.9, pred_loss_to_graph_loss=5.0)
kb.train_kg_model(steps=8001, batch_size=2, neg_to_pos=4)
# # # # # # # # # # # # # # # # # # # # # # # #
# People from Seattle should be more likely to
# own an umbrella (attribute prediction test)
# # # # # # # # # # # # # # # # # # # # # # # #
x = kb._kg_model.run_embedding(kb.get_embedding('other1'), 'owns_a_raincoat')
y = kb._kg_model.run_embedding(kb.get_embedding('other1'), 'doesnt_own_raincoat')
assert round(x) == 1; assert round(y) == 0
x = kb._kg_model.run_embedding(kb.get_embedding('other2'), 'owns_a_raincoat')
y = kb._kg_model.run_embedding(kb.get_embedding('other2'), 'doesnt_own_raincoat')
assert round(x) == 1; assert round(y) == 0