class Test_Atoms_and_Scheme_shell(unittest.TestCase):
def setUp(self):
#creating atomspace
self.atsp = AtomSpace()
self.TV = TruthValue()
initialize_opencog(self.atsp)
def tearDown(self):
del self.atsp
def test_create_node(self): #params as (self,type) , to test each and every kind of Atoms
#creating a node
self.node_hello = self.atsp.add_node(types.ConceptNode,"HelloWorld")
#testing if node is created
self.test_node_hello =scheme_eval_h(self.atsp, "(ConceptNode \"HelloWorld\")")
self.assertEqual(self.test_node_hello,self.node_hello)
self.assertIsInstance(node,Atom)
def test_create_links(self):
#creating nodes
self.fox = self.atsp.add_node(types.ConceptNode,"Fox")
self.animal = self.atsp.add_node(types.ConceptNode,"Animal")
#creating link between nodes
self.inheritance_link = self.atsp.add_link(types.InheritanceLink,[fox,animal])
#testing if link is created
self.test_inheritance_link=self.atsp.add_link(types.InheritanceLink,[self.fox,self.animal])
self.assertEqual(InheritanceLink(self.fox,self.animal),self.test_inheritance_link)
self.assertIsInstance(inheritance_link,Atom) # In a sense that links are atoms themselves.
class TestSpaceServer:
def setUp(self):
self._atomspace = AtomSpace()
self.space_server = SpaceServer(self._atomspace)
self.time_server = TimeServer(self._atomspace, self.space_server)
self.space_server.set_time_server(self.time_server)
def tearDown(self):
del self.space_server
del self._atomspace
def test_addMap(self):
map_atom = self.space_server.add_map(123456, "testmap", 1)
assert self._atomspace.get_name(map_atom) == "testmap"
def test_getMap(self):
map_atom = self.space_server.add_map(123456, "testmap", 1)
mapinstance = self.space_server.get_map(map_atom)
assert mapinstance.get_map_name() == "testmap"
def test_addAndRemoveMapInfo(self):
map_atom = self.space_server.add_map(123456, "testmap", 1)
object_atom = self._atomspace.add_node(types.StructureNode,"object111")
assert self.space_server.add_map_info(object_atom, map_atom,
False, False, 123456, 4, 5, 6) == True
map_instance = self.space_server.get_map(map_atom)
assert map_instance.get_block_location(object_atom) == (4, 5, 6)
self.space_server.remove_map_info(object_atom, map_atom, 234567)
assert map_instance.get_block_location(object_atom) == None
class TestSpaceServer:
def setUp(self):
self._atomspace = AtomSpace()
self.space_server = SpaceServer(self._atomspace)
self.time_server = TimeServer(self._atomspace, self.space_server)
self.space_server.set_time_server(self.time_server)
def tearDown(self):
del self.space_server
del self._atomspace
def test_addMap(self):
map_atom = self.space_server.add_map(123456, "testmap", 1)
assert map_atom.name == "testmap"
def test_getMap(self):
map_atom = self.space_server.add_map(123456, "testmap", 1)
mapinstance = self.space_server.get_map(map_atom)
assert mapinstance.get_map_name() == "testmap"
def test_addAndRemoveMapInfo(self):
map_atom = self.space_server.add_map(123456, "testmap", 1)
object_atom = self._atomspace.add_node(types.StructureNode,
"object111")
assert self.space_server.add_map_info(object_atom, map_atom, False,
False, 123456, 4, 5, 6) == True
map_instance = self.space_server.get_map(map_atom)
assert map_instance.get_block_location(object_atom) == (4, 5, 6)
self.space_server.remove_map_info(object_atom, map_atom, 234567)
assert map_instance.get_block_location(object_atom) == None
class SimpleAgent():
def __init__(self):
self.a = AtomSpace()
self.nodes = {}
# Initialize Scheme
scheme_preload = [
"opencog/atomspace/core_types.scm",
"opencog/scm/utilities.scm" ]
scheme.__init__(self.a)
for scheme_file in scheme_preload:
load_scm(self.a, scheme_file)
initialize_opencog(self.a)
#add 3 nodes with integer values
self.nodes[0] = self.a.add(types.ConceptNode, "0")
self.nodes[1] = self.a.add(types.ConceptNode, "1")
self.nodes[2] = self.a.add(types.ConceptNode, "2")
def performAction(self):
#randomly select a link from those available and add the nodes
fnode = self.a.add_node(types.GroundedSchemaNode, "py: sendValue")
current_link = self.a.add_link(types.ExecutionOutputLink, [
fnode,
self.a.add_link(types.ListLink, [self.nodes[randint(0,2)]])])
scheme_eval(self.a, '(cog-execute! (cog-atom %d))'%(current_link.handle_uuid()))
def remove(self):
# make sure this is called by the time script exits
finalize_opencog()
del self.a
class UtilitiesTest(TestCase):
def setUp(self):
self.atomspace = AtomSpace()
def tearDown(self):
del self.atomspace
def test_initialize_finalize(self):
initialize_opencog(self.atomspace)
finalize_opencog()
def test_fast_load(self):
gen_atoms(self.atomspace)
with tempfile.TemporaryDirectory() as tmpdirname:
tmp_file = os.path.join(tmpdirname, 'tmp.scm')
write_sorted_file(tmp_file, self.atomspace)
new_space = AtomSpace()
load_file(tmp_file, new_space)
self.assertTrue(len(new_space) == len(self.atomspace))
# files should be binary equal
new_tmp = os.path.join(tmpdirname, 'tmp1.scm')
write_sorted_file(new_tmp, new_space)
self.assertTrue(filecmp.cmp(tmp_file, new_tmp, shallow=False), "files are not equal")
checklist = """(ListLink(ConceptNode "vfjv\\"jnvfé")
(ConceptNode "conceptIR~~gF\\",KV")
(ConceptNode "вверху плыли редкие облачка"))"""
with open(tmp_file, 'wt') as f:
f.write(checklist)
new_space1 = AtomSpace()
load_file(tmp_file, new_space1)
self.assertTrue(len(new_space1) == 4)
def test_is_closed(self):
A = self.atomspace.add_node(types.ConceptNode, 'A')
B = self.atomspace.add_node(types.ConceptNode, 'B')
X = self.atomspace.add_node(types.VariableNode, '$X')
AB = self.atomspace.add_link(types.InheritanceLink, [A, B])
AX = self.atomspace.add_link(types.InheritanceLink, [A, X])
self.assertTrue(is_closed(AB))
self.assertFalse(is_closed(AX))
def test_get_free_variables(self):
A = self.atomspace.add_node(types.ConceptNode, 'A')
X = self.atomspace.add_node(types.VariableNode, '$X')
AX = self.atomspace.add_link(types.InheritanceLink, [A, X])
self.assertEqual(get_free_variables(AX), [X])
class Test_Atoms_and_Scheme_shell(unittest.TestCase):
def setUp(self):
self.atsp = AtomSpace()
def test_create_node(
self
): #params as (self,type) , to test each and every kind of Atoms
node = self.atsp.add_node(types.ConceptNode, "HelloWorld")
self.assertIsInstance(node, Atom)
def test_create_links(self):
fox = self.atsp.add_node(types.ConceptNode, "Fox")
animal = self.atsp.add_node(types.ConceptNode, "Animal")
inheritance_link = self.atsp.add_link(types.InheritanceLink,
[fox, animal])
self.assertIsInstance(
inheritance_link,
Atom) # In a sense that links are atoms themselves.
class TestTimeServer:
def setUp(self):
self._atomspace = AtomSpace()
self._spaceserver = SpaceServer(self._atomspace)
self._timeserver = TimeServer(self._atomspace, self._spaceserver)
self._spaceserver.set_time_server(self._timeserver)
def tearDown(self):
del self._spaceserver
del self._atomspace
def test_addTimeInfo(self):
objnode = self._atomspace.add_node(types.StructureNode, "object111")
at_time_link = self._timeserver.add_time_info(objnode, 123456)
assert objnode in at_time_link.out
class TestTimeServer:
def setUp(self):
self._atomspace = AtomSpace()
self._spaceserver = SpaceServer(self._atomspace)
self._timeserver = TimeServer(self._atomspace, self._spaceserver)
self._spaceserver.set_time_server(self._timeserver)
def tearDown(self):
del self._spaceserver
del self._atomspace
def test_addTimeInfo(self):
objnode = self._atomspace.add_node(types.StructureNode, "object111")
at_time_link = self._timeserver.add_time_info(objnode, 123456)
assert objnode in self._atomspace.get_outgoing(at_time_link)
class AtomSpaceTest(TestCase):
def setUp(self):
self.space = AtomSpace()
initialize_opencog(self.space)
def tearDown(self):
finalize_opencog()
del self.space
def test_add_node(self):
# Test long form atomspace node addition.
# Test node add
self.space.add_node(types.Node, "node" )
# Test with not a proper truthvalue
self.assertRaises(TypeError, self.space.add_node, types.Node, "test",
0, True)
# Test with bad type
self.assertRaises(TypeError, self.space.add_node, "ConceptNode", "test",
TruthValue(0.5, 0.8))
# From here on out we'll use the more compact type constructors
a1 = Node("test")
self.assertTrue(a1)
# duplicates resolve to same atom
a2 = Node("test")
self.assertEquals(a1, a2)
# Should fail when intentionally adding bad type
caught = False
try:
self.space.add_node(types.Link, "test")
except RuntimeError:
caught = True
self.assertEquals(caught, True)
# Test adding with a truthvalue
a3 = Node("test_w_tv").truth_value(0.5, 0.8)
self.assertEquals(self.space.size(), 3)
def test_add_link(self):
n1 = Node("test1")
n2 = Node("test2")
l1 = Link(n1, n2)
self.assertTrue(l1 is not None)
l2 = Link(n1, n2)
self.assertTrue(l2 is not None)
self.assertTrue(l2 == l1)
n3 = Node("test3")
l3 = Link(n1, n3).truth_value(0.5, 0.8)
self.assertTrue(l3 is not None)
# Should fail when adding an intentionally bad type
caught = False
try:
l1 = self.space.add_link(types.Node, [n1, n3])
except RuntimeError:
caught = True
self.assertEquals(caught, True)
def test_is_valid(self):
a1 = Node("test1")
# check with Atom object
self.assertTrue(self.space.is_valid(a1))
# check with bad type
self.assertRaises(TypeError, self.space.is_valid, "test")
def test_truth_value(self):
# check attributes come back as assigned
tv = TruthValue(0.5, 0.8)
self.assertEqual(tv.mean, 0.5)
self.assertAlmostEqual(tv.confidence, 0.8, places=4)
# test string representation
self.assertEqual(str(tv), "(stv 0.500000 0.800000)")
# check equality
tv2 = TruthValue(0.5, 0.8)
tv3 = TruthValue(0.6, 0.8)
self.assertTrue(tv == tv2)
self.assertFalse(tv == tv3)
# check truth_value function of atom
atom = Node("atom with tv")
default_tv = atom.tv
atom.truth_value(0.75, 0.9)
new_tv = atom.tv
self.assertFalse(new_tv == default_tv)
self.assertEqual(new_tv.mean, 0.75)
self.assertAlmostEqual(new_tv.confidence, 0.9, places=4)
def test_get_by_type(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
# test recursive subtypes
result = self.space.get_atoms_by_type(types.Node)
self.assertTrue(a1 in result)
self.assertTrue(a2 in result)
self.assertTrue(a3 in result)
# links
l1 = InheritanceLink(a1, a2)
result = self.space.get_atoms_by_type(types.Link)
self.assertTrue(l1 in result)
# test non-recursive subtype
result = self.space.get_atoms_by_type(types.Node, subtype=False)
self.assertTrue(a1 in result)
self.assertTrue(a2 not in result)
self.assertTrue(a3 not in result)
# test empty
result = self.space.get_atoms_by_type(types.AnchorNode, subtype=False)
self.assertEqual(len(result), 0)
def test_incoming_by_type(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
# test no incoming Node for a1
result = a1.incoming_by_type(types.Node)
self.assertTrue(a1 not in result)
# now check links
l1 = InheritanceLink(a1, a2)
result = a1.incoming_by_type(types.InheritanceLink)
self.assertTrue(l1 in result)
result = a2.incoming_by_type(types.InheritanceLink)
self.assertTrue(l1 in result)
result = a3.incoming_by_type(types.InheritanceLink)
self.assertTrue(l1 not in result)
def test_include_incoming_outgoing(self):
frog = ConceptNode("Frog")
thing = ConceptNode("Thing")
animal = ConceptNode("Animal")
ConceptNode("SeparateThing")
InheritanceLink(frog, animal)
InheritanceLink(animal, thing)
assert len(self.space.include_incoming([ConceptNode("Frog")])) == 2
assert len(self.space.include_outgoing(self.space.include_incoming([ConceptNode("Frog")]))) == 3
assert len(self.space.include_incoming(self.space.get_atoms_by_type(types.ConceptNode))) == 6
assert len(self.space.include_outgoing(self.space.get_atoms_by_type(types.InheritanceLink))) == 5
def test_remove(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
self.assertTrue(a1 in self.space)
self.assertTrue(a2 in self.space)
self.assertTrue(a3 in self.space)
self.space.remove(a1)
self.assertTrue(a1 not in self.space)
self.assertTrue(a2 in self.space)
self.assertTrue(a3 in self.space)
l = SimilarityLink(a2, a3)
self.space.remove(a2, True) # won't remove it unless recursive is True
self.assertTrue(a2 not in self.space)
self.assertTrue(l not in self.space)
def test_clear(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
self.space.clear()
self.assertEquals(self.space.size(), 0)
self.assertEquals(len(self.space), 0)
def test_container_methods(self):
self.assertEquals(len(self.space), 0)
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
self.assertTrue(a1 in self.space)
self.assertTrue(a2 in self.space)
self.assertTrue(a3 in self.space)
self.assertEquals(len(self.space), 3)
def test_context_mgr_tmp(self):
a = ConceptNode('a')
with tmp_atomspace() as tmp_as:
b = ConceptNode('b')
self.assertTrue(a in self.space)
# verify that current default atomspace is tmp_as
self.assertFalse(b in self.space)
c = ConceptNode('c')
# verify that current default atomspace is self.space
self.assertTrue(c in self.space)
class TestMap(unittest.TestCase):
def setUp(self):
self.atomspace = AtomSpace()
resolution = 1
floor_height = -255
agent_height = 1.6
self.testmap = Octree3DMapManager.init_new_map(self.atomspace, "testmap", resolution,
floor_height, agent_height)
def tearDown(self):
del self.testmap
del self.atomspace
def test_GetMapName(self):
self.assertEqual("testmap", self.testmap.get_map_name())
def test_GetBlock_NoBlockAdded_ReturnUndefinedHandle(self):
test_pos = (7, 8, 9)
test_handle = self.testmap.get_block(test_pos)
self.assertTrue(test_handle.is_undefined())
def testBinaryAddandRemove_NormalUnitBlock_AllGetFunctionWork(self):
test_pos1 = (7, 8, 9)
test_handle1 = Handle(100)
self.testmap.add_solid_unit_block(test_handle1, test_pos1)
test_handle2 = self.testmap.get_block(test_pos1)
self.assertEqual(test_handle1, test_handle2)
self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1))
self.testmap.remove_solid_unit_block(test_handle1)
test_handle3 = self.testmap.get_block(test_pos1)
self.assertTrue(test_handle3.is_undefined())
self.assertIsNone(self.testmap.get_block_location(test_handle1))
def testAddSolidUnitBlock__PositionOverBorder__GetBlockFailed(self):
border = 32768
test_pos1 = (border, 8, 9)
test_handle1 = Handle(100)
self.testmap.add_solid_unit_block(test_handle1, test_pos1)
test_handle2 = self.testmap.get_block(test_pos1)
self.assertTrue(test_handle2.is_undefined())
def testSetBlock_AddBlockWithProbabilityControl_GetFunctionsWorkWithProb(self):
test_pos1 = (7, 8, 9)
test_handle1 = Handle(100)
log_odds_threshold = self.testmap.get_log_odds_occupied_threshold()
self.testmap.set_unit_block(test_handle1, test_pos1, log_odds_threshold)
self.assertEqual(test_handle1, self.testmap.get_block(test_pos1))
self.assertEqual(test_handle1, self.testmap.get_block(test_pos1, log_odds_threshold))
self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1))
self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1,
log_odds_threshold))
#change the occupancy so it's small enough to make getter find nothing
self.testmap.set_unit_block(test_handle1, test_pos1, -0.1)
self.assertTrue(self.testmap.get_block(test_pos1).is_undefined())
self.assertTrue(self.testmap.get_block(test_pos1, log_odds_threshold).is_undefined())
self.assertIsNone(self.testmap.get_block_location(test_handle1))
self.assertIsNone(self.testmap.get_block_location(test_handle1,log_odds_threshold))
#change the threshold, so the occupancy is large enough to find it
self.testmap.set_log_odds_occupied_threshold(-0.2)
log_odds_threshold = self.testmap.get_log_odds_occupied_threshold()
self.assertEqual(test_handle1, self.testmap.get_block(test_pos1))
self.assertEqual(test_handle1, self.testmap.get_block(test_pos1, log_odds_threshold))
self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1))
self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1,
log_odds_threshold))
def testStandable_NormalBlock_Standable(self):
#case1: single block
test_pos = (1, 2, 4)
block_pos = (1, 2, 3)
self.assertFalse(self.testmap.check_standable(test_pos))
test_block = self.atomspace.add_node(types.StructureNode, "block1").h
material_node = self.atomspace.add_node(types.ConceptNode, "dirt").h
material_pred_node = self.atomspace.add_node(types.PredicateNode, "material").h
list_link = self.atomspace.add_link(types.ListLink, [test_block,material_node]).h
eval_link = self.atomspace.add_link(types.EvaluationLink,
[material_pred_node,list_link]).h
self.testmap.add_solid_unit_block(test_block, block_pos)
standable = self.testmap.check_standable(test_pos)
self.assertTrue(standable)
def testStandable_WaterBlock_Unstandable(self):
#case2: single block which is water, cannot stand on water
test_pos = (1, 2, 4)
block_pos = (1, 2, 3)
self.assertFalse(self.testmap.check_standable(test_pos))
test_block = self.atomspace.add_node(types.StructureNode, "block1").h
material_node = self.atomspace.add_node(types.ConceptNode, "water").h
material_pred_node = self.atomspace.add_node(types.PredicateNode, "material").h
list_link = self.atomspace.add_link(types.ListLink, [test_block,material_node]).h
eval_link = self.atomspace.add_link(types.EvaluationLink,
[material_pred_node,list_link]).h
self.testmap.add_solid_unit_block(test_block, block_pos)
standable = self.testmap.check_standable(test_pos)
self.assertFalse(standable)
def testStandable_TwoNearBlock_Unstandable(self):
# case3: two block which z coord is close ( ditance < agentHeight)
# so it's not standable
test_pos = (1, 2, 4)
block_pos1 = (1, 2, 3)
self.assertFalse(self.testmap.check_standable(test_pos))
test_block1 = self.atomspace.add_node(types.StructureNode, "block1").h
material_node1 = self.atomspace.add_node(types.ConceptNode, "dirt").h
material_pred_node = self.atomspace.add_node(types.PredicateNode,"material").h
list_link1 = self.atomspace.add_link(types.ListLink, [test_block1,material_node1]).h
eval_link1 = self.atomspace.add_link(types.EvaluationLink,
[material_pred_node,list_link1]).h
self.testmap.add_solid_unit_block(test_block1, block_pos1)
blockpos2 = (1, 2, 5)
testBlock2 = self.atomspace.add_node(types.StructureNode, "block2").h
material_node2 = self.atomspace.add_node(types.ConceptNode, "stone").h
material_pred_node = self.atomspace.add_node(types.PredicateNode, "material").h
list_link2 = self.atomspace.add_link(types.ListLink, [testBlock2, material_node2]).h
eval_link2 = self.atomspace.add_link(types.EvaluationLink,
[material_pred_node,list_link2]).h
self.testmap.add_solid_unit_block(testBlock2, blockpos2)
self.assertFalse(self.testmap.get_block(blockpos2).is_undefined())
self.assertFalse(self.testmap.get_block(block_pos1).is_undefined())
standable = self.testmap.check_standable(test_pos)
self.assertFalse(standable)
def testAddandRemoveNoneBlockEntity_NormalEntity_AllGetFunctionsWork(self):
test_pos = (17, 28, 39)
timestamp = 12345
test_handle1 = self.atomspace.add_node(types.EntityNode, "entity").h
entity_is_self = False
entity_is_avatar = False
self.testmap.add_none_block_entity(test_handle1,test_pos,
entity_is_self, entity_is_avatar,
timestamp)
test_handle2 = self.testmap.get_entity(test_pos)
self.assertEqual(test_handle1, test_handle2)
self.assertEqual(test_pos, self.testmap.get_last_appeared_location(test_handle1))
self.testmap.remove_none_block_entity(test_handle1)
self.assertTrue(self.testmap.get_entity(test_pos).is_undefined())
#preserve record
self.assertEqual(test_pos, self.testmap.get_last_appeared_location(test_handle1))
def testUpdateEntityLocation_MultipleLocation_LastLocationIsPos2(self):
test_pos1 = (17, 28, 39)
timestamp1 = 12345
test_handle1 = self.atomspace.add_node(types.EntityNode, "entity").h
entity_is_self = False
entity_is_avatar = False
self.testmap.add_none_block_entity(test_handle1, test_pos1,
entity_is_self, entity_is_avatar,
timestamp1)
test_pos2 = (17, 28, 40)
timestamp2 = 12346
self.testmap.update_none_block_entity_location(test_handle1, test_pos2, timestamp2)
last_location = self.testmap.get_last_appeared_location(test_handle1)
self.assertEqual(test_pos2, last_location)
def testAddEntity_PressureTest(self):
count = 10000
timestamp = 12345
while count != 0:
print count
count -= 1
test_pos = (count, count, count)
test_handle1 = self.atomspace.add_node(types.EntityNode, "entity"+str(count)).h
entity_is_self = False
entity_is_avatar = False
self.testmap.add_none_block_entity(test_handle1, test_pos,
entity_is_self, entity_is_avatar, timestamp)
test_handle2 = self.testmap.get_entity(test_pos)
self.assertEqual(test_handle1, test_handle2)
self.assertEqual(test_pos,self.testmap.get_last_appeared_location(test_handle1))
self.testmap.remove_none_block_entity(test_handle1)
self.assertTrue(self.testmap.get_entity(test_pos).is_undefined())
#preserve record
self.assertEqual(test_pos,self.testmap.get_last_appeared_location(test_handle1))
class AtomSpaceTest(TestCase):
def setUp(self):
self.space = AtomSpace()
def tearDown(self):
del self.space
def test_add_node(self):
a1 = self.space.add_node(types.Node, "test")
self.assertTrue(a1)
# duplicates resolve to same handle
a2 = self.space.add_node(types.Node, "test")
self.assertEquals(a1, a2)
# Should fail when intentionally adding bad type
# self.assertRaises(RuntimeError, self.space.add_node(types.Link, "test"))
caught = False
try:
self.space.add_node(types.Link, "test")
except RuntimeError:
caught = True
self.assertEquals(caught, True)
# test adding with a truthvalue
a3 = self.space.add_node(types.Node, "test_w_tv", TruthValue(0.5, 100))
self.assertEquals(self.space.size(), 2)
# test adding with prefixed node
a1 = self.space.add_node(types.Node, "test", prefixed=True)
a2 = self.space.add_node(types.Node, "test", prefixed=True)
self.assertNotEqual(a1, a2)
self.assertEquals(self.space.size(), 4)
a3 = self.space.add_node(types.Node,
"test",
TruthValue(0.5, 100),
prefixed=True)
self.assertNotEqual(a1, a3)
self.assertEquals(self.space.size(), 5)
# tests with bad parameters
# test with not a proper truthvalue
self.assertRaises(TypeError, self.space.add_node, types.Node, "test",
0, True)
# test with bad type
self.assertRaises(TypeError, self.space.add_node, "ConceptNode",
"test", TruthValue(0.5, 100))
def test_add_link(self):
n1 = self.space.add_node(types.Node, "test1")
n2 = self.space.add_node(types.Node, "test2")
l1 = self.space.add_link(types.Link, [n1, n2])
self.assertTrue(l1 is not None)
l2 = self.space.add_link(types.Link, [n1, n2])
self.assertTrue(l2 is not None)
self.assertTrue(l2 == l1)
n3 = self.space.add_node(types.Node, "test3")
l3 = self.space.add_link(types.Link, [n1, n3], TruthValue(0.5, 100))
self.assertTrue(l3 is not None)
# Test with a handle instead of atom
l4 = self.space.add_link(types.Link, [n2.h, n3], TruthValue(0.5, 100))
self.assertTrue(l4 is not None)
# Should fail when adding an intentionally bad type
caught = False
try:
l1 = self.space.add_link(types.Node, [n1, n3])
except RuntimeError:
caught = True
self.assertEquals(caught, True)
def test_is_valid(self):
h1 = self.space.add_node(types.Node, "test1")
# check with Handle object
self.assertTrue(self.space.is_valid(h1.h))
# check with raw UUID
self.assertTrue(self.space.is_valid(h1.h.value()))
# check with bad UUID
self.assertFalse(self.space.is_valid(2919))
# check with bad type
self.assertRaises(TypeError, self.space.is_valid, "test")
def test_truth_value(self):
# check attributes come back as assigned
tv = TruthValue(0.5, 100)
self.assertEqual(tv.mean, 0.5)
self.assertEqual(tv.count, 100)
# test confidence
self.assertAlmostEqual(tv.confidence, 0.1111, places=4)
# test string representation
self.assertEqual(str(tv), "(stv 0.500000 0.111111)")
# check equality
tv2 = TruthValue(0.5, 100)
tv3 = TruthValue(0.6, 100)
self.assertTrue(tv == tv2)
self.assertFalse(tv == tv3)
def test_get_by_name_and_type(self):
n1 = self.space.add_node(types.Node, "test")
n2 = self.space.add_node(types.ConceptNode, "test")
n3 = self.space.add_node(types.PredicateNode, "test")
# test recursive subtypes
result = self.space.get_atoms_by_name(types.Node, "test")
self.assertTrue(n1 in result)
self.assertTrue(n2 in result)
self.assertTrue(n3 in result)
# test non-recursive subtype
result = self.space.get_atoms_by_name(types.Node,
"test",
subtype=False)
self.assertTrue(n1 in result)
self.assertTrue(n2 not in result)
self.assertTrue(n3 not in result)
# test empty
result = self.space.get_atoms_by_name(types.AnchorNode,
"test",
subtype=False)
self.assertEqual(len(result), 0)
def test_get_by_type(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
# test recursive subtypes
result = self.space.get_atoms_by_type(types.Node)
self.assertTrue(h1 in result)
self.assertTrue(h2 in result)
self.assertTrue(h3 in result)
# links
l1 = self.space.add_link(types.InheritanceLink, [h1, h2])
result = self.space.get_atoms_by_type(types.Link)
self.assertTrue(l1 in result)
# test non-recursive subtype
result = self.space.get_atoms_by_type(types.Node, subtype=False)
self.assertTrue(h1 in result)
self.assertTrue(h2 not in result)
self.assertTrue(h3 not in result)
# test empty
result = self.space.get_atoms_by_type(types.AnchorNode, subtype=False)
self.assertEqual(len(result), 0)
def test_get_by_target_type(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
# test it doesn't apply to Nodes
result = self.space.get_atoms_by_target_type(types.Node, types.Node)
self.assertTrue(h1 not in result)
# links
l1 = self.space.add_link(types.InheritanceLink, [h1.h, h2.h])
result = self.space.get_atoms_by_target_type(types.Link,
types.ConceptNode,
target_subtype=False)
self.assertTrue(l1 in result)
# test recursive target subtype
result = self.space.get_atoms_by_target_type(types.Link,
types.Node,
target_subtype=True)
self.assertTrue(l1 in result)
def test_get_by_target_atom(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
# test it doesn't apply to Nodes
result = self.space.get_atoms_by_target_atom(types.Node, h1)
self.assertTrue(h1 not in result)
# links
l1 = self.space.add_link(types.InheritanceLink, [h1, h2])
result = self.space.get_atoms_by_target_atom(types.Link, h1)
self.assertTrue(l1 in result)
result = self.space.get_atoms_by_target_atom(types.Link, h3)
self.assertTrue(l1 not in result)
def test_remove(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
self.assertTrue(h1 in self.space)
self.assertTrue(h2 in self.space)
self.assertTrue(h3 in self.space)
self.space.remove(h1)
self.assertTrue(h1 not in self.space)
self.assertTrue(h2 in self.space)
self.assertTrue(h3 in self.space)
l = self.space.add_link(types.SimilarityLink, [h2, h3])
self.space.remove(h2,
False) # won't remove it unless recursive is True
self.assertTrue(h2 in self.space)
self.space.remove(h2, True) # won't remove it unless recursive is True
self.assertTrue(h2 not in self.space)
self.assertTrue(l not in self.space)
def test_clear(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
self.space.clear()
self.assertEquals(self.space.size(), 0)
self.assertEquals(self.space.size(), 0)
self.assertEquals(len(self.space), 0)
def test_container_methods(self):
self.assertEquals(len(self.space), 0)
h = Handle(100)
self.assertRaises(KeyError, self.space.__getitem__, "blah")
self.assertRaises(IndexError, self.space.__getitem__, h)
a1 = self.space.add_node(types.Node, "test1")
a2 = self.space.add_node(types.ConceptNode, "test2")
a3 = self.space.add_node(types.PredicateNode, "test3")
h1 = a1.h
h2 = a2.h
self.assertEquals(a1, self.space[h1])
self.assertTrue(h1 in self.space)
self.assertTrue(a1 in self.space)
self.assertTrue(h2 in self.space)
self.assertTrue(len(self.space), 3)
run the example from the CogServer, for which you should use deduction_agent.py instead. """ from __future__ import print_function from pprint import pprint from pln.examples.deduction import deduction_agent from opencog.atomspace import types, AtomSpace, TruthValue __author__ = 'Cosmo Harrigan' # Create an AtomSpace with some sample information, equivalent to the information in atomspace_contents.scm atomspace = AtomSpace() # Basic concepts frog = atomspace.add_node(types.ConceptNode, 'Frog', TruthValue(0.01, 100)) intelligent = atomspace.add_node(types.ConceptNode, 'Intelligent', TruthValue(0.05, 100)) slimy = atomspace.add_node(types.ConceptNode, 'Slimy', TruthValue(0.01, 100)) animal = atomspace.add_node(types.ConceptNode, 'Animal', TruthValue(0.1, 100)) being = atomspace.add_node(types.ConceptNode, 'Being', TruthValue(0.1, 100)) moves = atomspace.add_node(types.PredicateNode, 'Moves', TruthValue(0.1, 100)) # Attributes of frogs atomspace.add_link(types.InheritanceLink, [frog, intelligent], TruthValue(0.2, 100)) atomspace.add_link(types.InheritanceLink, [frog, slimy], TruthValue(0.5, 100)) atomspace.add_link(types.InheritanceLink, [frog, animal], TruthValue(0.9, 100)) # Attributes of animals atomspace.add_link(types.InheritanceLink, [animal, being], TruthValue(0.9, 100)) atomspace.add_link(types.InheritanceLink, [animal, moves], TruthValue(0.9, 100))
class Index:
def __init__(self, storage: Storage):
self.pattern_space = AtomSpace()
self.semantic_space = AtomSpace()
# storage maps index to atom
self._storage = storage
# index maps subgraph pattern to matching atom ids
self._index = dict()
def add_toplevel_pattern(self, atom):
args = [
self.pattern_space.add_node(types.VariableNode, '$X' + str(i))
for i in range(atom.arity)
]
l = self.pattern_space.add_link(atom.type, args)
bindlink = self.pattern_space.add_link(types.BindLink, [l, l])
self.add_pattern(bindlink)
def add_semantic_pattern(self, atom):
# find all nodes, that inherit from some atom from semantic atomspace
# replace such atoms by variable nodes
result = replace(atom, self.semantic_space, self.pattern_space, dict())
pattern = self.pattern_space.add_link(types.BindLink, [result, result])
self.add_pattern(pattern)
def add_data(self, data):
idx, new = self._storage.add_atom(data)
if not new:
return
assert data.is_link()
# self.add_toplevel_pattern(data)
self.add_semantic_pattern(data)
tmp = create_child_atomspace(self.pattern_space)
content = tmp.add_atom(data)
self.update_index(tmp, content, idx)
def update_index(self, atomspace, data, idx):
for pat in self._index.keys():
match = execute_atom(atomspace, pat)
# patterns can match patterns, so check:
for m in match.out:
if m == data:
self._index[pat].add(idx)
def intersect(self, query):
"""
Extracts relevant patterns to the query and intersects their indices
returns set of atoms ids
"""
# put query in tmp atomspace, check if there are relevant patterns
tmp = create_child_atomspace(self.pattern_space)
q = tmp.add_atom(rename(tmp, self.pattern_space, query))
# check query for exact match:
exact_match = execute_atom(tmp, tmp.add_link(types.BindLink, [q, q]))
for m in exact_match.out:
return self._index[self.pattern_space.add_link(
types.BindLink, [m, m])]
# no exact match: search among all patterns
# todo: search subgraphs
res_set = None
for pat, idx in self._index.items():
# pattern is relevant if it matches query
match = execute_atom(tmp, pat)
for m in match.out:
if hash(m) == hash(q):
if res_set is None:
res_set = idx
else:
res_set = res_set.intersection(idx)
return res_set
def query(self, result_atomspace, query):
res_set = self.intersect(query)
# add all possible results to tmp atomspace and run query
# what is called filter step in graph indexing literature
tmp = AtomSpace()
atom_str = self._storage.get_atoms(res_set)
for item in atom_str:
tmp.add_atom(scheme_eval_h(tmp, item))
# pack query in BindLink
q = tmp.add_link(types.BindLink, [query, query])
results = execute_atom(tmp, q)
result_atoms = set()
for atom in results.out:
result_atoms.add(result_atomspace.add_atom(atom))
return result_atoms
def update_index_dual_link(self, content):
# doesn't work
d = tmp.add_link(types.DualLink, [content])
# result is a set of conditional parts from pattens(GetLinks)
pattern_set = execute_atom(tmp, d)
# todo: create a new pattern
assert len(pattern_set.out)
for pattern in pattern_set.out:
get_link = self.pattern_space.add_link(types.GetLink, pattern)
self._index[get_link].add(data)
def add_pattern(self, pat):
assert pat.type == types.BindLink
atom = self.pattern_space.add_atom(pat)
if atom not in self._index:
self._index[atom] = set()
te = ForestExtractor(atomspace, GephiOutput(atomspace))
te.output()
except KeyError, e:
KeyError
except Exception, e:
import traceback
traceback.print_exc(file=sys.stdout)
self.cycles += 1
print __name__
if __name__ == "__main__":
a = AtomSpace()
t = types
bob = a.add_node(t.ConceptNode, "Bob")
alice = a.add_node(t.ConceptNode, "Alice")
link = a.add_link(t.ListLink, [bob, alice])
link2 = a.add_link(t.ListLink, [alice, bob])
link3 = a.add_link(t.EvaluationLink,
[a.add_node(t.PredicateNode, "likes"), link2])
obj1 = a.add_node(t.AccessoryNode, 'ball1')
obj2 = a.add_node(t.StructureNode, 'tree1')
next = a.add_link(t.EvaluationLink, [
a.add_node(t.PredicateNode, 'next'),
a.add_link(t.ListLink, [obj1, obj2])
])
next.tv = TruthValue(1, 1)
class TestMap(unittest.TestCase):
def setUp(self):
self.atomspace = AtomSpace()
resolution = 1
self.testmap = OctomapOcTree.init_new_map("testmap", resolution)
def tearDown(self):
del self.testmap
del self.atomspace
def test_GetMapName(self):
self.assertEqual("testmap", self.testmap.get_map_name())
def test_GetBlock_NoBlockAdded_ReturnUndefinedHandle(self):
test_pos = (7, 8, 9)
test_handle = self.testmap.get_block(test_pos)
self.assertTrue(test_handle.is_undefined())
def testBinaryAddandRemove_NormalUnitBlock_AllGetFunctionWork(self):
test_pos1 = (7.0, 8.0, 9.0)
test_handle1 = self.atomspace.add_node(types.Node,"bogus").h
self.testmap.add_solid_unit_block(test_handle1, test_pos1)
test_handle2 = self.testmap.get_block(test_pos1)
self.assertEqual(test_handle1, test_handle2)
self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1))
self.testmap.remove_solid_unit_block(test_handle1)
test_handle3 = self.testmap.get_block(test_pos1)
self.assertTrue(test_handle3.is_undefined())
self.assertIsNone(self.testmap.get_block_location(test_handle1))
def testAddSolidUnitBlock__PositionOverBorder__GetBlockFailed(self):
border = 32768
test_pos1 = (border, 8, 9)
test_handle1 = self.atomspace.add_node(types.Node,"bogus").h
self.testmap.add_solid_unit_block(test_handle1, test_pos1)
test_handle2 = self.testmap.get_block(test_pos1)
self.assertTrue(test_handle2.is_undefined())
def testSetBlock_AddBlockWithProbabilityControl_GetFunctionsWorkWithProb(self):
test_pos1 = (7.0, 8.0, 9.0)
test_handle1 = self.atomspace.add_node(types.Node,"bogus").h
log_odds_threshold = self.testmap.get_occupancy_thres_log()
self.testmap.set_unit_block(test_handle1, test_pos1, log_odds_threshold)
self.assertEqual(test_handle1, self.testmap.get_block(test_pos1))
self.assertEqual(test_handle1, self.testmap.get_block(test_pos1, log_odds_threshold))
self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1))
self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1,
log_odds_threshold))
self.assertEqual(log_odds_threshold, self.testmap.search(test_pos1).get_log_odds())
#change the occupancy so it's small enough to make getter find nothing
self.testmap.set_unit_block(test_handle1, test_pos1, -0.1)
self.assertTrue(self.testmap.get_block(test_pos1).is_undefined())
self.assertTrue(self.testmap.get_block(test_pos1, log_odds_threshold).is_undefined())
self.assertIsNone(self.testmap.get_block_location(test_handle1))
self.assertIsNone(self.testmap.get_block_location(test_handle1,log_odds_threshold))
#change the threshold, so the occupancy is large enough to find it
self.testmap.set_occupancy_thres(-0.2)
log_odds_threshold = self.testmap.get_occupancy_thres_log()
self.assertEqual(test_handle1, self.testmap.get_block(test_pos1))
self.assertEqual(test_handle1, self.testmap.get_block(test_pos1, log_odds_threshold))
self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1))
self.assertEqual(test_pos1, self.testmap.get_block_location(test_handle1,
log_odds_threshold))
def testStandable_NormalBlock_Standable(self):
#case1: single block
test_pos = (1, 2, 4)
block_pos = (1, 2, 3)
self.testmap.set_agent_height(1)
self.assertFalse(check_standable(self.atomspace, self.testmap, test_pos))
test_block = self.atomspace.add_node(types.StructureNode, "block1").h
material_node = self.atomspace.add_node(types.ConceptNode, "dirt").h
material_pred_node = self.atomspace.add_node(types.PredicateNode, "material").h
list_link = self.atomspace.add_link(types.ListLink, [test_block,material_node]).h
eval_link = self.atomspace.add_link(types.EvaluationLink,
[material_pred_node,list_link]).h
self.testmap.add_solid_unit_block(test_block, block_pos)
standable = check_standable(self.atomspace, self.testmap, test_pos)
self.assertTrue(standable)
def testStandable_WaterBlock_Unstandable(self):
#case2: single block which is water, cannot stand on water
test_pos = (1, 2, 4)
block_pos = (1, 2, 3)
self.testmap.set_agent_height(1)
self.assertFalse(check_standable(self.atomspace, self.testmap, test_pos))
test_block = self.atomspace.add_node(types.StructureNode, "block1").h
material_node = self.atomspace.add_node(types.ConceptNode, "water").h
material_pred_node = self.atomspace.add_node(types.PredicateNode, "material").h
list_link = self.atomspace.add_link(types.ListLink, [test_block,material_node]).h
eval_link = self.atomspace.add_link(types.EvaluationLink,
[material_pred_node,list_link]).h
self.testmap.add_solid_unit_block(test_block, block_pos)
standable = check_standable(self.atomspace, self.testmap, test_pos)
self.assertFalse(standable)
def testStandable_TwoNearBlock_Unstandable(self):
# case3: two block which z coord is close ( ditance < agentHeight)
# so it's not standable
test_pos = (1, 2, 4)
block_pos1 = (1, 2, 3)
# higher agent hieght
self.testmap.set_agent_height(2)
self.assertFalse(check_standable(self.atomspace, self.testmap, test_pos))
test_block1 = self.atomspace.add_node(types.StructureNode, "block1").h
material_node1 = self.atomspace.add_node(types.ConceptNode, "dirt").h
material_pred_node = self.atomspace.add_node(types.PredicateNode,"material").h
list_link1 = self.atomspace.add_link(types.ListLink, [test_block1,material_node1]).h
eval_link1 = self.atomspace.add_link(types.EvaluationLink,
[material_pred_node,list_link1]).h
self.testmap.add_solid_unit_block(test_block1, block_pos1)
blockpos2 = (1, 2, 5)
testBlock2 = self.atomspace.add_node(types.StructureNode, "block2").h
material_node2 = self.atomspace.add_node(types.ConceptNode, "stone").h
material_pred_node = self.atomspace.add_node(types.PredicateNode, "material").h
list_link2 = self.atomspace.add_link(types.ListLink, [testBlock2, material_node2]).h
eval_link2 = self.atomspace.add_link(types.EvaluationLink,
[material_pred_node,list_link2]).h
self.testmap.add_solid_unit_block(testBlock2, blockpos2)
self.assertFalse(self.testmap.get_block(blockpos2).is_undefined())
self.assertFalse(self.testmap.get_block(block_pos1).is_undefined())
standable = check_standable(self.atomspace, self.testmap, test_pos)
self.assertFalse(standable)
deduction_agent.py instead.
"""
from __future__ import print_function
from pprint import pprint
from pln.examples.deduction import deduction_agent
from opencog.atomspace import types, AtomSpace, TruthValue
__author__ = 'Cosmo Harrigan'
# Create an AtomSpace with some sample information, equivalent to the
# information in atomspace_contents.scm
atomspace = AtomSpace()
# Basic concepts
frog = atomspace.add_node(types.ConceptNode, 'Frog', TruthValue(0.01, 100))
intelligent = atomspace.add_node(types.ConceptNode, 'Intelligent',
TruthValue(0.05, 100))
slimy = atomspace.add_node(types.ConceptNode, 'Slimy', TruthValue(0.01, 100))
animal = atomspace.add_node(types.ConceptNode, 'Animal', TruthValue(0.1, 100))
being = atomspace.add_node(types.ConceptNode, 'Being', TruthValue(0.1, 100))
moves = atomspace.add_node(types.PredicateNode, 'Moves', TruthValue(0.1, 100))
# Attributes of frogs
atomspace.add_link(types.InheritanceLink, [frog, intelligent],
TruthValue(0.2, 100))
atomspace.add_link(types.InheritanceLink, [frog, slimy], TruthValue(0.5, 100))
atomspace.add_link(types.InheritanceLink, [frog, animal], TruthValue(0.9, 100))
# Attributes of animals
atomspace.add_link(types.InheritanceLink, [animal, being],
class AnaphoraUnitTester(TestCase):
def setUp(self):
self.atomspace = AtomSpace()
scheme_eval(self.atomspace,
"(add-to-load-path \"/usr/local/share/opencog/scm\")")
scheme_eval(self.atomspace, "(use-modules (opencog))")
scheme_eval(self.atomspace, "(use-modules (opencog atom-types))")
scheme_eval(self.atomspace, "(use-modules (opencog query))")
data = [
"opencog/scm/config.scm",
"opencog/scm/core_types.scm",
"opencog/scm/apply.scm",
"opencog/scm/file-utils.scm",
"opencog/scm/utilities.scm",
"opencog/scm/av-tv.scm",
"opencog/nlp/scm/type-definitions.scm",
"opencog/nlp/scm/config.scm",
"opencog/nlp/scm/file-utils.scm",
"opencog/nlp/scm/nlp-utils.scm",
"opencog/nlp/scm/disjunct-list.scm",
"opencog/nlp/scm/processing-utils.scm",
]
for item in data:
status = load_scm(self.atomspace, item)
# print "load status=", status, " item=", item
self.hobbsAgent = HobbsAgent()
def tearDown(self):
del self.atomspace
del self.hobbsAgent
def getWord(self, name, type=types.WordInstanceNode):
word = self.atomspace.add_node(type, name)
return word
def compare(self, list_1, list_2):
if len(list_1) == len(list_2):
for i in range(len(list_1)):
if list_1[i] != list_2[i].name:
return False
return True
else:
return False
def test_bfs(self):
'''
Testing the bfs function
'''
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
load_scm(self.atomspace, "tests/nlp/anaphora/data/bfs.scm"))
self.hobbsAgent.run(self.atomspace)
self.assertTrue(
self.compare(['a', 'b', 'c', 'd', 'e', 'f', 'g'],
self.hobbsAgent.bfs(self.getWord('a'))))
self.atomspace.clear()
#@unittest.skip("debugging skipping")
def test_getWords(self):
'''
Testing the getWords function
'''
self.assertTrue(
load_scm(self.atomspace, "tests/nlp/anaphora/data/getWords.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.compare(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'j'],
self.hobbsAgent.getWords()))
self.atomspace.clear()
def test_propose(self):
'''
Testing the propose function
'''
def filter_1():
print("Testing filter #1...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#1/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(
self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#1/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#1/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(
self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#1/data_#4.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(
self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#1/data_#5.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(
self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#1/data_#6.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(
self.getWord('antecedent')))
self.atomspace.clear()
def filter_2():
print("Testing filter #2...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#2/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#2/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(
self.getWord('antecedent')))
self.atomspace.clear()
def filter_3():
print("Testing filter #3...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#3/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 3))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#3/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 3))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#3/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 3))
self.atomspace.clear()
def filter_4():
print("Testing filter #4...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#4/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 4))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#4/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 4))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#4/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 4))
self.atomspace.clear()
def filter_5():
print("Testing filter #5...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#5/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 5))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#5/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 5))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#5/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 5))
self.atomspace.clear()
def filter_6():
print("Testing filter #6...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#6/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 6))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#6/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 6))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#6/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 6))
self.atomspace.clear()
def filter_7():
print("Testing filter #7...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#7/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 7))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#7/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 7))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#7/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 7))
self.atomspace.clear()
def filter_8():
print("Testing filter #8...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#8/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 8))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#8/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 8))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#8/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 8))
self.atomspace.clear()
def filter_9():
print("Testing filter #9...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#9/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 9))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#9/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 9))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#9/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 9))
self.atomspace.clear()
def filter_10():
print("Testing filter #10...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#10/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 10))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#10/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 10))
self.atomspace.clear()
def filter_11():
print("Testing filter #11...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#11/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 11))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#11/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 11))
self.atomspace.clear()
def filter_12():
print("Testing filter #12...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#12/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(
self.getWord('antecedent', types.ParseNode), 12))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#12/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 12))
self.atomspace.clear()
def filter_13():
print("Testing filter #13...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#13/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 13))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#13/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 13))
self.atomspace.clear()
def filter_14():
print("Testing filter #14...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#14/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 14))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#14/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 14))
self.atomspace.clear()
def filter_15():
print("Testing filter #15...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#15/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 15))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#15/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 15))
self.atomspace.clear()
def filter_16():
print("Testing filter #16...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#16/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 16))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#16/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 16))
self.atomspace.clear()
def filter_17():
print("Testing filter #17...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#17/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 17))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#17/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 17))
self.atomspace.clear()
def filter_18():
print("Testing filter #18...")
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#18/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.propose(self.getWord('antecedent'), 18))
self.atomspace.clear()
self.assertTrue(
load_scm(
self.atomspace,
"tests/nlp/anaphora/data/propose/filter-#18/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(
self.hobbsAgent.propose(self.getWord('antecedent'), 18))
self.atomspace.clear()
filter_1()
filter_2()
filter_3()
filter_4()
filter_5()
filter_6()
filter_7()
filter_8()
filter_9()
filter_10()
filter_11()
filter_12()
filter_13()
filter_14()
filter_15()
filter_16()
filter_17()
filter_18()
#@unittest.skip("debugging skipping")
def test_pleonastic_if(self):
self.assertTrue(
load_scm(self.atomspace,
"tests/nlp/anaphora/data/pleonastic_it/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
self.assertTrue(
load_scm(self.atomspace,
"tests/nlp/anaphora/data/pleonastic_it/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
self.assertTrue(
load_scm(self.atomspace,
"tests/nlp/anaphora/data/pleonastic_it/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
self.assertTrue(
load_scm(self.atomspace,
"tests/nlp/anaphora/data/pleonastic_it/data_#4.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
self.assertTrue(
load_scm(self.atomspace,
"tests/nlp/anaphora/data/pleonastic_it/data_#5.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
#@unittest.skip("debugging skipping")
def test_conjunctions(self):
self.assertTrue(
load_scm(self.atomspace,
"tests/nlp/anaphora/data/conjunction.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(
self.hobbsAgent.pleonastic_it(self.getWord('waitresses')))
self.atomspace.clear()
# # create_atoms_by_type.py # """ Simple example of how to create atoms in the AtomSpace. See also create_atomspace_simple.py for an alternate interface. """ from opencog.atomspace import AtomSpace, TruthValue, Atom from opencog.atomspace import types a = AtomSpace() # Create a truth value asserting true and mostly confident. TV = TruthValue(1, 0.8) # Add three nodes concept_type = types.ConceptNode A = a.add_node(concept_type, 'Apple', TV) B = a.add_node(concept_type, 'Berry', TruthValue(0.5, 0.75)) C = a.add_node(concept_type, 'Comestible', TV) # Add three inhertance links, asserting that apples are berries # and that berries are edible. inh_type = types.InheritanceLink AB = a.add_link(inh_type, [A, B], TV) BC = a.add_link(inh_type, [B, C], TV) AC = a.add_link(inh_type, [A, C]) print "The atomspace contains:\n\n", a.get_atoms_by_type(types.Atom)
this relationship.
See:
https://github.com/opencog/opencog/issues/530
Currently, it is represented the same way that Relex2Logic outputs it,
which is not going to work properly.
"""
__author__ = 'Cosmo Harrigan'
from opencog.atomspace import AtomSpace, TruthValue, types
atomspace = AtomSpace()
Socrates = atomspace.add_node(types.ConceptNode, "Socrates")
Man = atomspace.add_node(types.ConceptNode, "man")
Air = atomspace.add_node(types.ConceptNode, "air")
be = atomspace.add_node(types.PredicateNode, "be")
breathe = atomspace.add_node(types.PredicateNode, "breathe")
atomspace.add_link(
types.EvaluationLink,
[be, atomspace.add_link(types.ListLink, [Socrates, Man])],
TruthValue(1,
TruthValue().confidence_to_count(1)))
atomspace.add_link(
types.EvaluationLink,
[breathe, atomspace.add_link(types.ListLink, [Man, Air])],
TruthValue(1,
class AtomTest(TestCase):
def setUp(self):
self.space = AtomSpace()
def test_creation(self):
a = self.space.add_node(types.Node, "test1")
self.assertEqual(a.name, "test1")
self.assertEqual(a.tv, TruthValue(0.0, 0.0))
def test_w_truthvalue(self):
tv = TruthValue(0.5, 100)
a = self.space.add_node(types.Node, "test2", tv)
self.assertEqual(a.tv, tv)
# test set tv
a.tv = TruthValue(0.1, 10)
self.assertEqual(a.tv, TruthValue(0.1, 10))
def test_w_attention_value(self):
a = self.space.add_node(types.Node, "test2")
self.assertEqual(a.av, {'lti': 0, 'sti': 0, 'vlti': False})
# test set av
a.av = {"sti": 10, "lti": 1, "vlti": True}
self.assertEqual(a.av, {'sti': 10, 'lti': 1, 'vlti': True})
def test_out(self):
# test get out
a1 = self.space.add_node(types.Node, "test2")
self.assertEqual(a1.out, [])
tv = TruthValue(0.5, 100)
a2 = self.space.add_node(types.Node, "test3", tv)
l = self.space.add_link(types.Link, [a1, a2])
self.assertEqual(l.out, [a1, a2])
# ensure out is considered immutable
self.assertRaises(AttributeError, setattr, l, "out", [a1])
def test_arity(self):
a1 = self.space.add_node(types.Node, "test2")
self.assertEqual(a1.arity, 0)
tv = TruthValue(0.5, 100)
a2 = self.space.add_node(types.Node, "test3", tv)
l = self.space.add_link(types.Link, [a1, a2])
self.assertEqual(l.arity, 2)
# ensure arity is considered immutable
self.assertRaises(AttributeError, setattr, l, "arity", 4)
def test_is_source(self):
# any out item is a source for unordered links
# only the fist item is a source of ordered links
a1 = self.space.add_node(types.Node, "test1")
a2 = self.space.add_node(types.Node, "test2")
l_ordered = self.space.add_link(types.OrderedLink, [a1, a2])
l_unordered = self.space.add_link(types.UnorderedLink, [a1, a2])
self.assertEqual(l_ordered.is_source(a1), True)
self.assertEqual(l_ordered.is_source(a2), False)
self.assertEqual(l_unordered.is_source(a1), True)
self.assertEqual(l_unordered.is_source(a2), True)
def test_type(self):
# test get out
a = self.space.add_node(types.Node, "test2")
self.assertEqual(a.type, 1)
self.assertEqual(a.t, 1)
a2 = self.space.add_node(types.Node, "test3")
l = self.space.add_link(types.Link, [a, a2])
self.assertEqual(l.type, 2)
self.assertEqual(l.t, 2)
# ensure type is considered immutable
self.assertRaises(AttributeError, setattr, l, "type", 5)
self.assertRaises(AttributeError, setattr, a, "type", 5)
self.assertEqual(l.type_name, "Link")
self.assertEqual(a.type_name, "Node")
def test_strings(self):
# set up a link and atoms
tv = TruthValue(0.5, 100)
a1 = self.space.add_node(types.Node, "test1", tv)
a2 = self.space.add_node(types.Node, "test2")
a2.av = {"sti": 10, "lti": 1, "vlti": True}
a2.tv = TruthValue(0.1, 10)
l = self.space.add_link(types.Link, [a1, a2])
# test string representation
self.assertEqual(str(a2), "node[Node:test2]")
self.assertEqual(
a2.long_string(),
"node[Node:test2] av:(10,1) tv:([0.100000,10.000000=0.012346])")
self.assertEqual(str(l), "[Link <test1,test2> 0.0 0.0]")
self.assertEqual(
l.long_string(),
"link[Link sti:(0,0) tv:([0.000000,0.000000=0.000000]) <[Node test1],[Node test2]>]"
)
class AtomSpaceTest(TestCase):
def setUp(self):
self.space = AtomSpace()
def tearDown(self):
del self.space
def test_add_node(self):
a1 = self.space.add_node(types.Node, "test")
self.assertTrue(a1)
# duplicates resolve to same handle
a2 = self.space.add_node(types.Node, "test")
self.assertEquals(a1, a2)
# Should fail when intentionally adding bad type
# self.assertRaises(RuntimeError, self.space.add_node(types.Link, "test"))
caught = False
try:
self.space.add_node(types.Link, "test")
except RuntimeError:
caught = True
self.assertEquals(caught, True)
# test adding with a truthvalue
a3 = self.space.add_node(types.Node, "test_w_tv", TruthValue(0.5, 100))
self.assertEquals(self.space.size(), 2)
### FIXME TODO -- re-enable this test after the prefixing code is
###
### # test adding with prefixed node
### a1 = self.space.add_node(types.Node, "test", prefixed=True)
### a2 = self.space.add_node(types.Node, "test", prefixed=True)
### self.assertNotEqual(a1, a2)
### self.assertEquals(self.space.size(), 4)
###
### a3 = self.space.add_node(types.Node, "test", TruthValue(0.5, 100), prefixed=True)
### self.assertNotEqual(a1, a3)
### self.assertEquals(self.space.size(), 5)
# tests with bad parameters
# test with not a proper truthvalue
self.assertRaises(TypeError, self.space.add_node, types.Node, "test",
0, True)
# test with bad type
self.assertRaises(TypeError, self.space.add_node, "ConceptNode",
"test", TruthValue(0.5, 100))
def test_add_link(self):
n1 = self.space.add_node(types.Node, "test1")
n2 = self.space.add_node(types.Node, "test2")
l1 = self.space.add_link(types.Link, [n1, n2])
self.assertTrue(l1 is not None)
l2 = self.space.add_link(types.Link, [n1, n2])
self.assertTrue(l2 is not None)
self.assertTrue(l2 == l1)
n3 = self.space.add_node(types.Node, "test3")
l3 = self.space.add_link(types.Link, [n1, n3], TruthValue(0.5, 100))
self.assertTrue(l3 is not None)
# Test with a handle instead of atom
l4 = self.space.add_link(types.Link, [n2.h, n3], TruthValue(0.5, 100))
self.assertTrue(l4 is not None)
# Should fail when adding an intentionally bad type
caught = False
try:
l1 = self.space.add_link(types.Node, [n1, n3])
except RuntimeError:
caught = True
self.assertEquals(caught, True)
def test_is_valid(self):
h1 = self.space.add_node(types.Node, "test1")
# check with Handle object
self.assertTrue(self.space.is_valid(h1.h))
# check with raw UUID
self.assertTrue(self.space.is_valid(h1.h.value()))
# check with bad UUID
self.assertFalse(self.space.is_valid(2919))
# check with bad type
self.assertRaises(TypeError, self.space.is_valid, "test")
def test_truth_value(self):
# check attributes come back as assigned
tv = TruthValue(0.5, 100)
self.assertEqual(tv.mean, 0.5)
self.assertEqual(tv.count, 100)
# test confidence
self.assertAlmostEqual(tv.confidence, 0.1111, places=4)
# test string representation
self.assertEqual(str(tv), "(stv 0.500000 0.111111)")
# check equality
tv2 = TruthValue(0.5, 100)
tv3 = TruthValue(0.6, 100)
self.assertTrue(tv == tv2)
self.assertFalse(tv == tv3)
def test_get_by_name_and_type(self):
n1 = self.space.add_node(types.Node, "test")
n2 = self.space.add_node(types.ConceptNode, "test")
n3 = self.space.add_node(types.PredicateNode, "test")
# test recursive subtypes
result = self.space.get_atoms_by_name(types.Node, "test")
self.assertTrue(n1 in result)
self.assertTrue(n2 in result)
self.assertTrue(n3 in result)
# test non-recursive subtype
result = self.space.get_atoms_by_name(types.Node,
"test",
subtype=False)
self.assertTrue(n1 in result)
self.assertTrue(n2 not in result)
self.assertTrue(n3 not in result)
# test empty
result = self.space.get_atoms_by_name(types.AnchorNode,
"test",
subtype=False)
self.assertEqual(len(result), 0)
def test_get_by_type(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
# test recursive subtypes
result = self.space.get_atoms_by_type(types.Node)
self.assertTrue(h1 in result)
self.assertTrue(h2 in result)
self.assertTrue(h3 in result)
# links
l1 = self.space.add_link(types.InheritanceLink, [h1, h2])
result = self.space.get_atoms_by_type(types.Link)
self.assertTrue(l1 in result)
# test non-recursive subtype
result = self.space.get_atoms_by_type(types.Node, subtype=False)
self.assertTrue(h1 in result)
self.assertTrue(h2 not in result)
self.assertTrue(h3 not in result)
# test empty
result = self.space.get_atoms_by_type(types.AnchorNode, subtype=False)
self.assertEqual(len(result), 0)
def test_get_by_av(self):
h1 = self.space.add_node(types.ConceptNode, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_link(types.InheritanceLink, [h1, h2])
h4 = self.space.add_node(types.ConceptNode, "test4")
h5 = self.space.add_node(types.ConceptNode, "test5")
self.space.set_av(h=h1.h, sti=10)
self.space.set_av(h=h2.h, sti=5)
self.space.set_av(h=h3.h, sti=4)
self.space.set_av(h=h4.h, sti=1)
result = self.space.get_atoms_by_av(4, 10)
assert len(result) == 3
assert set(result) == set([h1, h2, h3])
assert h4 not in result
result = self.space.get_atoms_in_attentional_focus()
assert len(result) == 4
assert set(result) == set([h1, h2, h3, h4])
def test_get_by_target_atom(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
# test it doesn't apply to Nodes
result = self.space.get_atoms_by_target_atom(types.Node, h1)
self.assertTrue(h1 not in result)
# links
l1 = self.space.add_link(types.InheritanceLink, [h1, h2])
result = self.space.get_atoms_by_target_atom(types.Link, h1)
self.assertTrue(l1 in result)
result = self.space.get_atoms_by_target_atom(types.Link, h3)
self.assertTrue(l1 not in result)
def test_include_incoming_outgoing(self):
frog = self.space.add_node(types.ConceptNode, "Frog")
thing = self.space.add_node(types.ConceptNode, "Thing")
animal = self.space.add_node(types.ConceptNode, "Animal")
self.space.add_node(types.ConceptNode, "SeparateThing")
self.space.add_link(types.InheritanceLink, [frog, animal])
self.space.add_link(types.InheritanceLink, [animal, thing])
assert len(
self.space.include_incoming(
self.space.get_atoms_by_name(types.ConceptNode, "Frog"))) == 2
assert len(
self.space.include_incoming(
self.space.get_atoms_by_type(types.ConceptNode))) == 6
assert len(
self.space.include_outgoing(
self.space.get_atoms_by_type(types.InheritanceLink))) == 5
assert len(
self.space.include_outgoing(
self.space.include_incoming(
self.space.get_atoms_by_name(types.ConceptNode,
"Frog")))) == 3
def test_remove(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
self.assertTrue(h1 in self.space)
self.assertTrue(h2 in self.space)
self.assertTrue(h3 in self.space)
self.space.remove(h1)
self.assertTrue(h1 not in self.space)
self.assertTrue(h2 in self.space)
self.assertTrue(h3 in self.space)
l = self.space.add_link(types.SimilarityLink, [h2, h3])
self.space.remove(h2, True) # won't remove it unless recursive is True
self.assertTrue(h2 not in self.space)
self.assertTrue(l not in self.space)
def test_clear(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
self.space.clear()
self.assertEquals(self.space.size(), 0)
self.assertEquals(self.space.size(), 0)
self.assertEquals(len(self.space), 0)
def test_container_methods(self):
self.assertEquals(len(self.space), 0)
h = Handle(100)
self.assertRaises(KeyError, self.space.__getitem__, "blah")
self.assertRaises(IndexError, self.space.__getitem__, h)
a1 = self.space.add_node(types.Node, "test1")
a2 = self.space.add_node(types.ConceptNode, "test2")
a3 = self.space.add_node(types.PredicateNode, "test3")
h1 = a1.h
h2 = a2.h
self.assertEquals(a1, self.space[h1])
self.assertTrue(h1 in self.space)
self.assertTrue(a1 in self.space)
self.assertTrue(h2 in self.space)
self.assertEquals(len(self.space), 3)
def test_get_predicates(self):
dog = self.space.add_node(types.ConceptNode, "dog")
mammal = self.space.add_node(types.ConceptNode, "mammal")
canine = self.space.add_node(types.ConceptNode, "canine")
animal = self.space.add_node(types.ConceptNode, "animal")
dog_mammal = self.space.add_link(types.ListLink, [dog, mammal])
dog_canine = self.space.add_link(types.ListLink, [dog, canine])
dog_animal = self.space.add_link(types.ListLink, [dog, animal])
isA = self.space.add_node(types.PredicateNode, "IsA")
dogIsAMammal = self.space.add_link(types.EvaluationLink,
[isA, dog_mammal])
dogIsACanine = self.space.add_link(types.EvaluationLink,
[isA, dog_canine])
dogIsAAnimal = self.space.add_link(types.EvaluationLink,
[isA, dog_animal])
dog_predicates = self.space.get_predicates(dog)
self.assertEquals(len(dog_predicates), 3)
count = 0
for dogIs in self.space.xget_predicates(dog):
count += 1
self.assertEquals(count, 3)
def test_get_predicates_for(self):
dog = self.space.add_node(types.ConceptNode, "dog")
mammal = self.space.add_node(types.ConceptNode, "mammal")
canine = self.space.add_node(types.ConceptNode, "canine")
animal = self.space.add_node(types.ConceptNode, "animal")
dog_mammal = self.space.add_link(types.ListLink, [dog, mammal])
dog_canine = self.space.add_link(types.ListLink, [dog, canine])
dog_animal = self.space.add_link(types.ListLink, [dog, animal])
isA = self.space.add_node(types.PredicateNode, "IsA")
dogIsAMammal = self.space.add_link(types.EvaluationLink,
[isA, dog_mammal])
dogIsACanine = self.space.add_link(types.EvaluationLink,
[isA, dog_canine])
dogIsAAnimal = self.space.add_link(types.EvaluationLink,
[isA, dog_animal])
human = self.space.add_node(types.ConceptNode, "human")
dog_human = self.space.add_link(types.ListLink, [dog, human])
loves = self.space.add_node(types.PredicateNode, "loves")
dogLovesHumans = self.space.add_link(types.EvaluationLink,
[loves, dog_human])
dog_predicates = self.space.get_predicates_for(dog, isA)
self.assertEquals(len(dog_predicates), 3)
dog_predicates = self.space.get_predicates_for(dog, loves)
self.assertEquals(len(dog_predicates), 1)
count = 0
for dogIsA in self.space.xget_predicates_for(dog, isA):
count += 1
self.assertEquals(count, 3)
count = 0
for dogLoves in self.space.xget_predicates_for(dog, loves):
count += 1
self.assertEquals(count, 1)
ps_a = atom_from_tree(ps, a)
pal_a = atom_from_tree(pal, a)
print ps
print pal
ps_a.tv = TruthValue(1.0, confidence_to_count(1.0))
print ps_a.tv
return result_atoms
if __name__ == '__main__':
a = AtomSpace()
log.use_stdout(True)
atom_from_tree(T('EvaluationLink',a.add_node(t.PredicateNode,'A')), a).tv = TruthValue(1, 1)
#atom_from_tree(T('EvaluationLink',1), a).tv = TruthValue(1, 1)
c = Chainer(a)
#search(T('EvaluationLink',a.add_node(t.PredicateNode,'B')))
#fc(a)
#c.bc(T('EvaluationLink',a.add_node(t.PredicateNode,'A')))
# global rules
# A = T('EvaluationLink',a.add_node(t.PredicateNode,'A'))
# B = T('EvaluationLink',a.add_node(t.PredicateNode,'B'))
# rules.append(Rule(B,
# [ A ]))
while (epoch < n_epochs):
epoch+=1
for minibatch_index in xrange(n_train_batches):
mlp_minibatch_avg_cost = train_sup(minibatch_index)
iteration = (epoch - 1) * n_train_batches + minibatch_index
if (iteration + 1) % n_train_batches == 0:
print 'MLP MODEL'
test_losses = [test_sup(i) for i in xrange(n_test_batches)]
test_record[epoch-1] = np.mean(test_losses)
print((' epoch %i, minibatch %i/%i, test error %f %%') %
(epoch, minibatch_index + 1, n_train_batches, test_record[epoch-1] * 100.))
filters=[]
filters.append(model_sup.layers[0].filters.get_value(borrow=True))
filters.append(model_sup.layers[1].filters.get_value(borrow=True))
filters.append(model_sup.layers[2].filters.get_value(borrow=True))
filters.append(model_sup.layers[3].filters.get_value(borrow=True))
pickle.dump(test_record, open("convae_destin.pkl", "w"))
for i in xrange(n_epochs):
for j in xrange(4):
image_adr="convae_destin/layer_%d_filter_%d.eps" % (j,i)
plt.imshow(filters[j][i, 0, :, :], cmap = plt.get_cmap('gray'), interpolation='nearest')
plt.axis('off')
plt.savefig(image_adr , bbox_inches='tight', pad_inches=0)
return atomspace.add_node(types.ArrayNode, str(test_record))
# SubdueTextOutput(atomspace)))
# g.output()
te = ForestExtractor(atomspace, GephiOutput(atomspace))
te.output()
except KeyError, e:
KeyError
except Exception, e:
import traceback; traceback.print_exc(file=sys.stdout)
self.cycles+=1
print __name__
if __name__ == "__main__":
a = AtomSpace()
t=types
bob = a.add_node(t.ConceptNode, "Bob")
alice = a.add_node(t.ConceptNode, "Alice")
link = a.add_link(t.ListLink, [bob, alice])
link2 = a.add_link(t.ListLink, [alice, bob])
link3 = a.add_link(t.EvaluationLink, [a.add_node(t.PredicateNode, "likes"), link2])
obj1 = a.add_node(t.AccessoryNode, 'ball1')
obj2 = a.add_node(t.StructureNode, 'tree1')
next = a.add_link(t.EvaluationLink,
[a.add_node(t.PredicateNode, 'next'),
a.add_link(t.ListLink, [obj1, obj2])])
next.tv = TruthValue(1, 1)
arity3 = a.add_link(t.AndLink, [bob, alice, obj1])
class AtomSpaceTest(TestCase):
def setUp(self):
self.space = AtomSpace()
def tearDown(self):
del self.space
def test_add_node(self):
a1 = self.space.add_node(types.Node, "test")
self.assertTrue(a1)
# duplicates resolve to same handle
a2 = self.space.add_node(types.Node, "test")
self.assertEquals(a1, a2)
# Should fail when intentionally adding bad type
# self.assertRaises(RuntimeError, self.space.add_node(types.Link, "test"))
caught = False
try:
self.space.add_node(types.Link, "test")
except RuntimeError:
caught = True
self.assertEquals(caught, True)
# test adding with a truthvalue
a3 = self.space.add_node(types.Node, "test_w_tv", TruthValue(0.5, 100))
self.assertEquals(self.space.size(), 2)
# test adding with prefixed node
a1 = self.space.add_node(types.Node, "test", prefixed=True)
a2 = self.space.add_node(types.Node, "test", prefixed=True)
self.assertNotEqual(a1, a2)
self.assertEquals(self.space.size(), 4)
a3 = self.space.add_node(types.Node, "test", TruthValue(0.5, 100), prefixed=True)
self.assertNotEqual(a1, a3)
self.assertEquals(self.space.size(), 5)
# tests with bad parameters
# test with not a proper truthvalue
self.assertRaises(TypeError, self.space.add_node, types.Node, "test", 0, True)
# test with bad type
self.assertRaises(TypeError, self.space.add_node, "ConceptNode", "test", TruthValue(0.5, 100))
def test_add_link(self):
n1 = self.space.add_node(types.Node, "test1")
n2 = self.space.add_node(types.Node, "test2")
l1 = self.space.add_link(types.Link, [n1, n2])
self.assertTrue(l1 is not None)
l2 = self.space.add_link(types.Link, [n1, n2])
self.assertTrue(l2 is not None)
self.assertTrue(l2 == l1)
n3 = self.space.add_node(types.Node, "test3")
l3 = self.space.add_link(types.Link, [n1, n3], TruthValue(0.5, 100))
self.assertTrue(l3 is not None)
# Test with a handle instead of atom
l4 = self.space.add_link(types.Link, [n2.h, n3], TruthValue(0.5, 100))
self.assertTrue(l4 is not None)
# Should fail when adding an intentionally bad type
caught = False
try:
l1 = self.space.add_link(types.Node, [n1, n3])
except RuntimeError:
caught = True
self.assertEquals(caught, True)
def test_is_valid(self):
h1 = self.space.add_node(types.Node, "test1")
# check with Handle object
self.assertTrue(self.space.is_valid(h1.h))
# check with raw UUID
self.assertTrue(self.space.is_valid(h1.h.value()))
# check with bad UUID
self.assertFalse(self.space.is_valid(2919))
# check with bad type
self.assertRaises(TypeError, self.space.is_valid, "test")
def test_truth_value(self):
# check attributes come back as assigned
tv = TruthValue(0.5, 100)
self.assertEqual(tv.mean, 0.5)
self.assertEqual(tv.count, 100)
# test confidence
self.assertAlmostEqual(tv.confidence, 0.1111, places=4)
# test string representation
self.assertEqual(str(tv), "(stv 0.500000 0.111111)")
# check equality
tv2 = TruthValue(0.5, 100)
tv3 = TruthValue(0.6, 100)
self.assertTrue(tv == tv2)
self.assertFalse(tv == tv3)
def test_get_by_name_and_type(self):
n1 = self.space.add_node(types.Node, "test")
n2 = self.space.add_node(types.ConceptNode, "test")
n3 = self.space.add_node(types.PredicateNode, "test")
# test recursive subtypes
result = self.space.get_atoms_by_name(types.Node, "test")
self.assertTrue(n1 in result)
self.assertTrue(n2 in result)
self.assertTrue(n3 in result)
# test non-recursive subtype
result = self.space.get_atoms_by_name(types.Node, "test", subtype=False)
self.assertTrue(n1 in result)
self.assertTrue(n2 not in result)
self.assertTrue(n3 not in result)
# test empty
result = self.space.get_atoms_by_name(types.AnchorNode, "test", subtype=False)
self.assertEqual(len(result), 0)
def test_get_by_type(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
# test recursive subtypes
result = self.space.get_atoms_by_type(types.Node)
self.assertTrue(h1 in result)
self.assertTrue(h2 in result)
self.assertTrue(h3 in result)
# links
l1 = self.space.add_link(types.InheritanceLink, [h1, h2])
result = self.space.get_atoms_by_type(types.Link)
self.assertTrue(l1 in result)
# test non-recursive subtype
result = self.space.get_atoms_by_type(types.Node, subtype=False)
self.assertTrue(h1 in result)
self.assertTrue(h2 not in result)
self.assertTrue(h3 not in result)
# test empty
result = self.space.get_atoms_by_type(types.AnchorNode, subtype=False)
self.assertEqual(len(result), 0)
def test_get_by_av(self):
h1 = self.space.add_node(types.ConceptNode, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_link(types.InheritanceLink, [h1, h2])
h4 = self.space.add_node(types.ConceptNode, "test4")
h5 = self.space.add_node(types.ConceptNode, "test5")
self.space.set_av(h=h1.h, sti=10)
self.space.set_av(h=h2.h, sti=5)
self.space.set_av(h=h3.h, sti=4)
self.space.set_av(h=h4.h, sti=1)
result = self.space.get_atoms_by_av(4, 10)
assert len(result) == 3
assert set(result) == set([h1, h2, h3])
assert h4 not in result
result = self.space.get_atoms_in_attentional_focus()
assert len(result) == 4
assert set(result) == set([h1, h2, h3, h4])
def test_get_by_target_type(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
# test it doesn't apply to Nodes
result = self.space.get_atoms_by_target_type(types.Node, types.Node)
self.assertTrue(h1 not in result)
# links
l1 = self.space.add_link(types.InheritanceLink, [h1.h, h2.h])
result = self.space.get_atoms_by_target_type(types.Link, types.ConceptNode, target_subtype=False)
self.assertTrue(l1 in result)
# test recursive target subtype
result = self.space.get_atoms_by_target_type(types.Link, types.Node, target_subtype=True)
self.assertTrue(l1 in result)
def test_get_by_target_atom(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
# test it doesn't apply to Nodes
result = self.space.get_atoms_by_target_atom(types.Node, h1)
self.assertTrue(h1 not in result)
# links
l1 = self.space.add_link(types.InheritanceLink, [h1, h2])
result = self.space.get_atoms_by_target_atom(types.Link, h1)
self.assertTrue(l1 in result)
result = self.space.get_atoms_by_target_atom(types.Link, h3)
self.assertTrue(l1 not in result)
def test_include_incoming_outgoing(self):
frog = self.space.add_node(types.ConceptNode, "Frog")
thing = self.space.add_node(types.ConceptNode, "Thing")
animal = self.space.add_node(types.ConceptNode, "Animal")
self.space.add_node(types.ConceptNode, "SeparateThing")
self.space.add_link(types.InheritanceLink, [frog, animal])
self.space.add_link(types.InheritanceLink, [animal, thing])
assert len(self.space.include_incoming(self.space.get_atoms_by_name(types.ConceptNode, "Frog"))) == 2
assert len(self.space.include_incoming(self.space.get_atoms_by_type(types.ConceptNode))) == 6
assert len(self.space.include_outgoing(self.space.get_atoms_by_type(types.InheritanceLink))) == 5
assert len(self.space.include_outgoing(
self.space.include_incoming(self.space.get_atoms_by_name(types.ConceptNode, "Frog")))) == 3
def test_remove(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
self.assertTrue(h1 in self.space)
self.assertTrue(h2 in self.space)
self.assertTrue(h3 in self.space)
self.space.remove(h1)
self.assertTrue(h1 not in self.space)
self.assertTrue(h2 in self.space)
self.assertTrue(h3 in self.space)
l = self.space.add_link(types.SimilarityLink, [h2, h3])
self.space.remove(h2, True) # won't remove it unless recursive is True
self.assertTrue(h2 not in self.space)
self.assertTrue(l not in self.space)
def test_clear(self):
h1 = self.space.add_node(types.Node, "test1")
h2 = self.space.add_node(types.ConceptNode, "test2")
h3 = self.space.add_node(types.PredicateNode, "test3")
self.space.clear()
self.assertEquals(self.space.size(), 0)
self.assertEquals(self.space.size(), 0)
self.assertEquals(len(self.space), 0)
def test_container_methods(self):
self.assertEquals(len(self.space), 0)
h = Handle(100)
self.assertRaises(KeyError, self.space.__getitem__, "blah")
self.assertRaises(IndexError, self.space.__getitem__, h)
a1 = self.space.add_node(types.Node, "test1")
a2 = self.space.add_node(types.ConceptNode, "test2")
a3 = self.space.add_node(types.PredicateNode, "test3")
h1 = a1.h
h2 = a2.h
self.assertEquals(a1, self.space[h1])
self.assertTrue(h1 in self.space)
self.assertTrue(a1 in self.space)
self.assertTrue(h2 in self.space)
self.assertTrue(len(self.space), 3)
class AtomSpaceTest(TestCase):
def setUp(self):
self.space = AtomSpace()
def tearDown(self):
del self.space
def test_add_node(self):
a1 = self.space.add_node(types.Node,"test")
self.assertTrue(a1)
# duplicates resolve to same handle
a2 = self.space.add_node(types.Node,"test")
self.assertEquals(a1,a2)
# fails when adding with a link type
a1 = self.space.add_node(types.Link,"test")
self.assertEquals(a1,None)
# test adding with a truthvalue
a3 = self.space.add_node(types.Node,"test_w_tv",TruthValue(0.5,100))
self.assertEquals(self.space.size(),2)
# test adding with prefixed node
a1 = self.space.add_node(types.Node,"test",prefixed=True)
a2 = self.space.add_node(types.Node,"test",prefixed=True)
self.assertNotEqual(a1,a2)
self.assertEquals(self.space.size(),4)
a3 = self.space.add_node(types.Node,"test",TruthValue(0.5,100),prefixed=True)
self.assertNotEqual(a1,a3)
self.assertEquals(self.space.size(),5)
# tests with bad parameters
# test with not a proper truthvalue
self.assertRaises(TypeError,self.space.add_node,types.Node,"test",0,True)
# test with bad type
self.assertRaises(TypeError,self.space.add_node,"ConceptNode","test",TruthValue(0.5,100))
def test_add_link(self):
n1 = self.space.add_node(types.Node,"test1")
n2 = self.space.add_node(types.Node,"test2")
l1 = self.space.add_link(types.Link,[n1,n2])
self.assertTrue(l1 is not None)
l2 = self.space.add_link(types.Link,[n1,n2])
self.assertTrue(l2 is not None)
self.assertTrue(l2 == l1)
n3 = self.space.add_node(types.Node,"test3")
l3 = self.space.add_link(types.Link,[n1,n3],TruthValue(0.5,100))
self.assertTrue(l3 is not None)
# test with a handle instead of atom
l4 = self.space.add_link(types.Link,[n2.h,n3],TruthValue(0.5,100))
self.assertTrue(l4 is not None)
# fails when adding with a node type
l1 = self.space.add_link(1,[n1,n3])
self.assertEquals(l1,None)
def test_is_valid(self):
h1 = self.space.add_node(types.Node,"test1")
# check with Handle object
self.assertTrue(self.space.is_valid(h1.h))
# check with raw UUID
self.assertTrue(self.space.is_valid(h1.h.value()))
# check with bad UUID
self.assertFalse(self.space.is_valid(2919))
# check with bad type
self.assertRaises(TypeError,self.space.is_valid,"test")
def test_truth_value(self):
# check attributes come back as assigned
tv = TruthValue(0.5, 100)
self.assertEqual(tv.mean,0.5)
self.assertEqual(tv.count,100)
# test confidence
self.assertAlmostEqual(tv.confidence,0.1111,places=4)
# test string representation
self.assertEqual(str(tv),"[0.500000,100.000000=0.111111]")
# check equality
tv2 = TruthValue(0.5, 100)
tv3 = TruthValue(0.6, 100)
self.assertTrue(tv == tv2)
self.assertFalse(tv == tv3)
def test_get_by_name_and_type(self):
n1 = self.space.add_node(types.Node,"test")
n2 = self.space.add_node(types.ConceptNode,"test")
n3 = self.space.add_node(types.PredicateNode,"test")
# test recursive subtypes
result = self.space.get_atoms_by_name(types.Node,"test")
self.assertTrue(n1 in result)
self.assertTrue(n2 in result)
self.assertTrue(n3 in result)
# test non-recursive subtype
result = self.space.get_atoms_by_name(types.Node,"test",subtype=False)
self.assertTrue(n1 in result)
self.assertTrue(n2 not in result)
self.assertTrue(n3 not in result)
# test empty
result = self.space.get_atoms_by_name(types.SemeNode,"test",subtype=False)
self.assertEqual(len(result),0)
def test_get_by_type(self):
h1 = self.space.add_node(types.Node,"test1")
h2 = self.space.add_node(types.ConceptNode,"test2")
h3 = self.space.add_node(types.PredicateNode,"test3")
# test recursive subtypes
result = self.space.get_atoms_by_type(types.Node)
self.assertTrue(h1 in result)
self.assertTrue(h2 in result)
self.assertTrue(h3 in result)
# links
l1 = self.space.add_link(types.InheritanceLink,[h1,h2])
result = self.space.get_atoms_by_type(types.Link)
self.assertTrue(l1 in result)
# test non-recursive subtype
result = self.space.get_atoms_by_type(types.Node,subtype=False)
self.assertTrue(h1 in result)
self.assertTrue(h2 not in result)
self.assertTrue(h3 not in result)
# test empty
result = self.space.get_atoms_by_type(types.SemeNode,subtype=False)
self.assertEqual(len(result),0)
def test_get_by_target_type(self):
h1 = self.space.add_node(types.Node,"test1")
h2 = self.space.add_node(types.ConceptNode,"test2")
h3 = self.space.add_node(types.PredicateNode,"test3")
# test it doesn't apply to Nodes
result = self.space.get_atoms_by_target_type(types.Node,types.Node)
self.assertTrue(h1 not in result)
# links
l1 = self.space.add_link(types.InheritanceLink,[h1.h,h2.h])
result = self.space.get_atoms_by_target_type(types.Link,types.ConceptNode,target_subtype=False)
self.assertTrue(l1 in result)
# test recursive target subtype
result = self.space.get_atoms_by_target_type(types.Link,types.Node,target_subtype=True)
self.assertTrue(l1 in result)
def test_get_by_target_atom(self):
h1 = self.space.add_node(types.Node,"test1")
h2 = self.space.add_node(types.ConceptNode,"test2")
h3 = self.space.add_node(types.PredicateNode,"test3")
# test it doesn't apply to Nodes
result = self.space.get_atoms_by_target_atom(types.Node,h1)
self.assertTrue(h1 not in result)
# links
l1 = self.space.add_link(types.InheritanceLink,[h1,h2])
result = self.space.get_atoms_by_target_atom(types.Link,h1)
self.assertTrue(l1 in result)
result = self.space.get_atoms_by_target_atom(types.Link,h3)
self.assertTrue(l1 not in result)
def test_remove(self):
h1 = self.space.add_node(types.Node,"test1")
h2 = self.space.add_node(types.ConceptNode,"test2")
h3 = self.space.add_node(types.PredicateNode,"test3")
self.assertTrue(h1 in self.space)
self.assertTrue(h2 in self.space)
self.assertTrue(h3 in self.space)
self.space.remove(h1)
self.assertTrue(h1 not in self.space)
self.assertTrue(h2 in self.space)
self.assertTrue(h3 in self.space)
l = self.space.add_link(types.SimilarityLink,[h2,h3])
self.space.remove(h2) # won't remove it unless recursive is True
self.assertTrue(h2 in self.space)
self.space.remove(h2,True) # won't remove it unless recursive is True
self.assertTrue(h2 not in self.space)
self.assertTrue(l not in self.space)
def test_clear(self):
h1 = self.space.add_node(types.Node,"test1")
h2 = self.space.add_node(types.ConceptNode,"test2")
h3 = self.space.add_node(types.PredicateNode,"test3")
self.space.clear()
self.assertEquals(self.space.size(),0)
self.assertEquals(self.space.size(),0)
self.assertEquals(len(self.space),0)
def test_container_methods(self):
self.assertEquals(len(self.space),0)
h = Handle(100)
self.assertRaises(KeyError,self.space.__getitem__,"blah")
self.assertRaises(IndexError,self.space.__getitem__,h)
a1 = self.space.add_node(types.Node,"test1")
a2 = self.space.add_node(types.ConceptNode,"test2")
a3 = self.space.add_node(types.PredicateNode,"test3")
h1 = a1.h
h2 = a2.h
self.assertEquals(a1,self.space[h1])
self.assertTrue(h1 in self.space)
self.assertTrue(a1 in self.space)
self.assertTrue(h2 in self.space)
self.assertTrue(len(self.space), 3)
class ForwardChainerTest(TestCase):
def setUp(self):
self.atomspace = AtomSpace()
self.chainer = Chainer(self.atomspace)
def tearDown(self):
del self.atomspace
del self.chainer
def _simple_atoms_1(self):
atoms = []
atoms.append(self.atomspace.add_node(types.ConceptNode, "animal"))
atoms.append(self.atomspace.add_node(types.ConceptNode, "breathe"))
atoms.append(
self.atomspace.add_link(types.InheritanceLink,
[atoms[0], atoms[1]]))
return atoms
def test__selectOne(self):
atoms = self._simple_atoms_1()
atom = self.chainer._selectOne(atoms)
self.assertNotEquals(atom, None)
self.assertEqual(atom, atoms[0])
atom = self.chainer._selectOne(atoms)
self.assertTrue(atom in atoms)
def test_get_attentional_focus(self):
atoms = self._simple_atoms_1()
print atoms[2]
contents = get_attentional_focus(self.atomspace)
print contents
self.assertEqual(len(contents), 1)
def test__select_one_matching(self):
atoms = self._simple_atoms_1()
template = atoms[2]
result = self.chainer._select_one_matching(template)
self.assertEqual(result, atoms[2])
print get_attentional_focus(self.atomspace)
template = self.atomspace.add_node(types.VariableNode, "$v1")
result = self.chainer._select_one_matching(template)
self.assertNotEqual(result, None)
def test__find_inputs_recursive(self):
def apply(generic_inputs, generic_outputs):
inputs = []
outputs = []
empty_substitution = {}
status = self.chainer._find_inputs_recursive(
inputs, outputs, generic_inputs, generic_outputs,
empty_substitution)
return (inputs, outputs)
atoms = self._simple_atoms_1()
# test it on lots of simple made up rules that include the edge cases
# [] => []
generic_inputs = []
generic_outputs = []
(inputs, outputs) = apply(generic_inputs, generic_outputs)
self.assertEquals(inputs, [])
self.assertEquals(outputs, [])
# [animal] => []
generic_inputs = [atoms[0]]
generic_outputs = []
(inputs, outputs) = apply(generic_inputs, generic_outputs)
self.assertEquals(inputs, [atoms[0]])
self.assertEquals(outputs, [])
v1 = self.atomspace.add_node(types.VariableNode, "$v1")
# [v1] => []
generic_inputs = [v1]
generic_outputs = []
(inputs, outputs) = apply(generic_inputs, generic_outputs)
self.assertEquals(len(inputs), 1)
self.assertEquals(outputs, [])
#from nose.tools import set_trace; set_trace()
# [v1] => [v1]
generic_inputs = [v1]
generic_outputs = [v1]
(inputs, outputs) = apply(generic_inputs, generic_outputs)
print str(inputs[0])
print str(outputs[0])
self.assertEquals(len(inputs), 1)
self.assertEquals(len(outputs), 1)
class AtomTest(TestCase):
def setUp(self):
self.space = AtomSpace()
def test_creation(self):
a = self.space.add_node(types.Node, "test1")
self.assertEqual(a.name, "test1")
self.assertEqual(a.tv, TruthValue(0.0, 0.0))
def test_w_truthvalue(self):
tv = TruthValue(0.5, 100)
a = self.space.add_node(types.Node, "test2", tv)
self.assertEqual(a.tv, tv)
# test set tv
a.tv = TruthValue(0.1, 10)
self.assertEqual(a.tv, TruthValue(0.1, 10))
def test_w_attention_value(self):
a = self.space.add_node(types.Node, "test2")
self.assertEqual(a.av, {"lti": 0, "sti": 0, "vlti": False})
# test set av
a.av = {"sti": 10, "lti": 1, "vlti": True}
self.assertEqual(a.av, {"sti": 10, "lti": 1, "vlti": True})
def test_out(self):
# test get out
a1 = self.space.add_node(types.Node, "test2")
self.assertEqual(a1.out, [])
tv = TruthValue(0.5, 100)
a2 = self.space.add_node(types.Node, "test3", tv)
l = self.space.add_link(types.Link, [a1, a2])
self.assertEqual(l.out, [a1, a2])
# ensure out is considered immutable
self.assertRaises(AttributeError, setattr, l, "out", [a1])
def test_arity(self):
a1 = self.space.add_node(types.Node, "test2")
self.assertEqual(a1.arity, 0)
tv = TruthValue(0.5, 100)
a2 = self.space.add_node(types.Node, "test3", tv)
l = self.space.add_link(types.Link, [a1, a2])
self.assertEqual(l.arity, 2)
# ensure arity is considered immutable
self.assertRaises(AttributeError, setattr, l, "arity", 4)
def test_is_source(self):
# any out item is a source for unordered links
# only the fist item is a source of ordered links
a1 = self.space.add_node(types.Node, "test1")
a2 = self.space.add_node(types.Node, "test2")
l_ordered = self.space.add_link(types.OrderedLink, [a1, a2])
l_unordered = self.space.add_link(types.UnorderedLink, [a1, a2])
self.assertEqual(l_ordered.is_source(a1), True)
self.assertEqual(l_ordered.is_source(a2), False)
self.assertEqual(l_unordered.is_source(a1), True)
self.assertEqual(l_unordered.is_source(a2), True)
def test_type(self):
# test get out
a = self.space.add_node(types.Node, "test2")
self.assertEqual(a.type, 1)
self.assertEqual(a.t, 1)
a2 = self.space.add_node(types.Node, "test3")
l = self.space.add_link(types.Link, [a, a2])
self.assertEqual(l.type, 2)
self.assertEqual(l.t, 2)
# ensure type is considered immutable
self.assertRaises(AttributeError, setattr, l, "type", 5)
self.assertRaises(AttributeError, setattr, a, "type", 5)
self.assertEqual(l.type_name, "Link")
self.assertEqual(a.type_name, "Node")
def test_strings(self):
# set up a link and atoms
tv = TruthValue(0.5, 100)
a1 = self.space.add_node(types.Node, "test1", tv)
a2 = self.space.add_node(types.Node, "test2")
a2.av = {"sti": 10, "lti": 1, "vlti": True}
a2.tv = TruthValue(0.1, 10)
l = self.space.add_link(types.Link, [a1, a2])
# test string representation
self.assertEqual(str(a2), '(Node "test2")\n')
self.assertEqual(a2.long_string(), '(Node "test2" (av 10 1 1) (stv 0.100000 0.012346))\n')
self.assertEqual(str(l), '(Link (stv 0.000000 0.000000)\n (Node "test1")\n (Node "test2")\n)\n')
self.assertEqual(
l.long_string(),
"(Link (av 0 0 0) (stv 0.000000 0.000000)\n"
+ ' (Node "test1" (av 0 0 0) (stv 0.500000 0.111111))\n'
+ ' (Node "test2" (av 10 1 1) (stv 0.100000 0.012346))\n)\n',
)
te = ForestExtractor(atomspace, GephiOutput(atomspace))
te.output()
except KeyError, e:
KeyError
except Exception, e:
import traceback
traceback.print_exc(file=sys.stdout)
self.cycles += 1
print __name__
if __name__ == "__main__":
a = AtomSpace()
t = types
bob = a.add_node(t.ConceptNode, "Bob")
alice = a.add_node(t.ConceptNode, "Alice")
link = a.add_link(t.ListLink, [bob, alice])
link2 = a.add_link(t.ListLink, [alice, bob])
link3 = a.add_link(t.EvaluationLink, [a.add_node(t.PredicateNode, "likes"), link2])
obj1 = a.add_node(t.AccessoryNode, "ball1")
obj2 = a.add_node(t.StructureNode, "tree1")
next = a.add_link(t.EvaluationLink, [a.add_node(t.PredicateNode, "next"), a.add_link(t.ListLink, [obj1, obj2])])
next.tv = TruthValue(1, 1)
arity3 = a.add_link(t.AndLink, [bob, alice, obj1])
time = a.add_link(t.AtTimeLink, [a.add_node(t.TimeNode, "t-0"), a.add_node(t.ConceptNode, "blast-off")])
print len(concept_nodes),'concepts'
for A in concept_nodes:
for B in concept_nodes:
target = T('SubsetLink', A, B)
print target
results = chainer.bc(target)
print results
if __name__ == '__main__':
atomspace = AtomSpace()
# jade.ATOMS
ENTITY = atomspace.add_node('VariableNode', '$ENTITY')
BLOCK = atomspace.add_node('VariableNode', '$BLOCK')
COLOR = atomspace.add_node('VariableNode', '$COLOR')
atomspace.add_link('ForAllLink',
[atomspace.add_link('ListLink', [ENTITY, BLOCK, COLOR]),
atomspace.add_link('ImplicationLink',
[atomspace.add_link('AndLink',
[atomspace.add_link('EvaluationLink',
[atomspace.add_node('PredicateNode', 'part-of'),
atomspace.add_link('ListLink', [BLOCK, ENTITY])]),
atomspace.add_link('EvaluationLink',
[atomspace.add_node('PredicateNode', 'color'),
atomspace.add_link('ListLink', [BLOCK, COLOR])])]),
atomspace.add_link('EvaluationLink',
[atomspace.add_node('PredicateNode', 'contains-block-of-color'),
class TestMap(unittest.TestCase):
def setUp(self):
self.atomspace = AtomSpace()
resolution = 1
floor_height = -255
agent_height = 1.6
self.testmap = Octree3DMapManager.init_new_map(self.atomspace,
"testmap", resolution,
floor_height,
agent_height)
def tearDown(self):
del self.testmap
del self.atomspace
def test_GetMapName(self):
self.assertEqual("testmap", self.testmap.get_map_name())
def test_GetBlock_NoBlockAdded_ReturnUndefinedHandle(self):
test_pos = (7, 8, 9)
test_handle = self.testmap.get_block(test_pos)
self.assertTrue(test_handle.is_undefined())
def testBinaryAddandRemove_NormalUnitBlock_AllGetFunctionWork(self):
test_pos1 = (7, 8, 9)
test_handle1 = Handle(100)
self.testmap.add_solid_unit_block(test_handle1, test_pos1)
test_handle2 = self.testmap.get_block(test_pos1)
self.assertEqual(test_handle1, test_handle2)
self.assertEqual(test_pos1,
self.testmap.get_block_location(test_handle1))
self.testmap.remove_solid_unit_block(test_handle1)
test_handle3 = self.testmap.get_block(test_pos1)
self.assertTrue(test_handle3.is_undefined())
self.assertIsNone(self.testmap.get_block_location(test_handle1))
def testAddSolidUnitBlock__PositionOverBorder__GetBlockFailed(self):
border = 32768
test_pos1 = (border, 8, 9)
test_handle1 = Handle(100)
self.testmap.add_solid_unit_block(test_handle1, test_pos1)
test_handle2 = self.testmap.get_block(test_pos1)
self.assertTrue(test_handle2.is_undefined())
def testSetBlock_AddBlockWithProbabilityControl_GetFunctionsWorkWithProb(
self):
test_pos1 = (7, 8, 9)
test_handle1 = Handle(100)
log_odds_threshold = self.testmap.get_log_odds_occupied_threshold()
self.testmap.set_unit_block(test_handle1, test_pos1,
log_odds_threshold)
self.assertEqual(test_handle1, self.testmap.get_block(test_pos1))
self.assertEqual(test_handle1,
self.testmap.get_block(test_pos1, log_odds_threshold))
self.assertEqual(test_pos1,
self.testmap.get_block_location(test_handle1))
self.assertEqual(
test_pos1,
self.testmap.get_block_location(test_handle1, log_odds_threshold))
#change the occupancy so it's small enough to make getter find nothing
self.testmap.set_unit_block(test_handle1, test_pos1, -0.1)
self.assertTrue(self.testmap.get_block(test_pos1).is_undefined())
self.assertTrue(
self.testmap.get_block(test_pos1,
log_odds_threshold).is_undefined())
self.assertIsNone(self.testmap.get_block_location(test_handle1))
self.assertIsNone(
self.testmap.get_block_location(test_handle1, log_odds_threshold))
#change the threshold, so the occupancy is large enough to find it
self.testmap.set_log_odds_occupied_threshold(-0.2)
log_odds_threshold = self.testmap.get_log_odds_occupied_threshold()
self.assertEqual(test_handle1, self.testmap.get_block(test_pos1))
self.assertEqual(test_handle1,
self.testmap.get_block(test_pos1, log_odds_threshold))
self.assertEqual(test_pos1,
self.testmap.get_block_location(test_handle1))
self.assertEqual(
test_pos1,
self.testmap.get_block_location(test_handle1, log_odds_threshold))
def testStandable_NormalBlock_Standable(self):
#case1: single block
test_pos = (1, 2, 4)
block_pos = (1, 2, 3)
self.assertFalse(self.testmap.check_standable(test_pos))
test_block = self.atomspace.add_node(types.StructureNode, "block1").h
material_node = self.atomspace.add_node(types.ConceptNode, "dirt").h
material_pred_node = self.atomspace.add_node(types.PredicateNode,
"material").h
list_link = self.atomspace.add_link(types.ListLink,
[test_block, material_node]).h
eval_link = self.atomspace.add_link(types.EvaluationLink,
[material_pred_node, list_link]).h
self.testmap.add_solid_unit_block(test_block, block_pos)
standable = self.testmap.check_standable(test_pos)
self.assertTrue(standable)
def testStandable_WaterBlock_Unstandable(self):
#case2: single block which is water, cannot stand on water
test_pos = (1, 2, 4)
block_pos = (1, 2, 3)
self.assertFalse(self.testmap.check_standable(test_pos))
test_block = self.atomspace.add_node(types.StructureNode, "block1").h
material_node = self.atomspace.add_node(types.ConceptNode, "water").h
material_pred_node = self.atomspace.add_node(types.PredicateNode,
"material").h
list_link = self.atomspace.add_link(types.ListLink,
[test_block, material_node]).h
eval_link = self.atomspace.add_link(types.EvaluationLink,
[material_pred_node, list_link]).h
self.testmap.add_solid_unit_block(test_block, block_pos)
standable = self.testmap.check_standable(test_pos)
self.assertFalse(standable)
def testStandable_TwoNearBlock_Unstandable(self):
# case3: two block which z coord is close ( ditance < agentHeight)
# so it's not standable
test_pos = (1, 2, 4)
block_pos1 = (1, 2, 3)
self.assertFalse(self.testmap.check_standable(test_pos))
test_block1 = self.atomspace.add_node(types.StructureNode, "block1").h
material_node1 = self.atomspace.add_node(types.ConceptNode, "dirt").h
material_pred_node = self.atomspace.add_node(types.PredicateNode,
"material").h
list_link1 = self.atomspace.add_link(types.ListLink,
[test_block1, material_node1]).h
eval_link1 = self.atomspace.add_link(
types.EvaluationLink, [material_pred_node, list_link1]).h
self.testmap.add_solid_unit_block(test_block1, block_pos1)
blockpos2 = (1, 2, 5)
testBlock2 = self.atomspace.add_node(types.StructureNode, "block2").h
material_node2 = self.atomspace.add_node(types.ConceptNode, "stone").h
material_pred_node = self.atomspace.add_node(types.PredicateNode,
"material").h
list_link2 = self.atomspace.add_link(types.ListLink,
[testBlock2, material_node2]).h
eval_link2 = self.atomspace.add_link(
types.EvaluationLink, [material_pred_node, list_link2]).h
self.testmap.add_solid_unit_block(testBlock2, blockpos2)
self.assertFalse(self.testmap.get_block(blockpos2).is_undefined())
self.assertFalse(self.testmap.get_block(block_pos1).is_undefined())
standable = self.testmap.check_standable(test_pos)
self.assertFalse(standable)
def testAddandRemoveNoneBlockEntity_NormalEntity_AllGetFunctionsWork(self):
test_pos = (17, 28, 39)
timestamp = 12345
test_handle1 = self.atomspace.add_node(types.EntityNode, "entity").h
entity_is_self = False
entity_is_avatar = False
self.testmap.add_none_block_entity(test_handle1, test_pos,
entity_is_self, entity_is_avatar,
timestamp)
test_handle2 = self.testmap.get_entity(test_pos)
self.assertEqual(test_handle1, test_handle2)
self.assertEqual(test_pos,
self.testmap.get_last_appeared_location(test_handle1))
self.testmap.remove_none_block_entity(test_handle1)
self.assertTrue(self.testmap.get_entity(test_pos).is_undefined())
#preserve record
self.assertEqual(test_pos,
self.testmap.get_last_appeared_location(test_handle1))
def testUpdateEntityLocation_MultipleLocation_LastLocationIsPos2(self):
test_pos1 = (17, 28, 39)
timestamp1 = 12345
test_handle1 = self.atomspace.add_node(types.EntityNode, "entity").h
entity_is_self = False
entity_is_avatar = False
self.testmap.add_none_block_entity(test_handle1, test_pos1,
entity_is_self, entity_is_avatar,
timestamp1)
test_pos2 = (17, 28, 40)
timestamp2 = 12346
self.testmap.update_none_block_entity_location(test_handle1, test_pos2,
timestamp2)
last_location = self.testmap.get_last_appeared_location(test_handle1)
self.assertEqual(test_pos2, last_location)
def testAddEntity_PressureTest(self):
count = 10000
timestamp = 12345
while count != 0:
print count
count -= 1
test_pos = (count, count, count)
test_handle1 = self.atomspace.add_node(types.EntityNode,
"entity" + str(count)).h
entity_is_self = False
entity_is_avatar = False
self.testmap.add_none_block_entity(test_handle1, test_pos,
entity_is_self,
entity_is_avatar, timestamp)
test_handle2 = self.testmap.get_entity(test_pos)
self.assertEqual(test_handle1, test_handle2)
self.assertEqual(
test_pos,
self.testmap.get_last_appeared_location(test_handle1))
self.testmap.remove_none_block_entity(test_handle1)
self.assertTrue(self.testmap.get_entity(test_pos).is_undefined())
#preserve record
self.assertEqual(
test_pos,
self.testmap.get_last_appeared_location(test_handle1))
class LogicTest(TestCase):
def setUp(self):
self.atomspace = AtomSpace()
self.logic = Logic(self.atomspace)
def tearDown(self):
del self.atomspace
del self.logic
def _simple_atoms(self):
'''InheritanceLink animal breathe'''
self.animal = self.atomspace.add_node(types.ConceptNode, "animal")
self.breathe = self.atomspace.add_node(types.ConceptNode, "breathe")
self.inh_animal_breathe = self.atomspace.add_link(types.InheritanceLink, [self.animal, self.breathe])
atoms = []
atoms.append( self.animal )
atoms.append( self.breathe )
atoms.append( self.inh_animal_breathe )
return atoms
def _what_breathes(self):
'''InheritanceLink $v1 breathe'''
self.v1 = self.atomspace.add_node(types.VariableNode, "$v1")
template = self.atomspace.add_link(types.InheritanceLink,
[self.v1,
self.breathe])
return template
def test_variable_stuff(self):
var1 = self.logic.new_variable()
self.assertTrue( var1.is_a(types.VariableNode) )
var2 = self.logic.new_variable()
self.assertNotEqual( var1, var2 )
self.assertTrue(self.logic.is_variable(var1))
def test_find(self):
atoms = self._simple_atoms()
template = self.inh_animal_breathe
result = self.logic.find(template, self.atomspace.get_atoms_by_type(types.Atom))
self.assertEquals( type(result), list )
self.assertEquals( result, [self.inh_animal_breathe] )
template = self._what_breathes()
result = self.logic.find(template, self.atomspace.get_atoms_by_type(types.Atom))
# it should give you the inheritancelink and the template link itself!
self.assertEquals( result, [self.inh_animal_breathe, template] )
def test_substitute(self):
atoms = self._simple_atoms()
template = self._what_breathes()
cat = self.atomspace.add_node(types.ConceptNode, "cat")
substitution = {self.v1: cat}
# substitute $v1->cat in (InheritanceLink $v1 breathe)
# producing (InheritanceLink cat breathe)
intended_result = self.atomspace.add_link(types.InheritanceLink, [cat, self.breathe])
result = self.logic.substitute(substitution, template)
self.assertEqual( result, intended_result)
from opencog.atomspace import AtomSpace, TruthValue, Atom from opencog.atomspace import types as t a = AtomSpace() TV = TruthValue(1,1) A = a.add_node(t.ConceptNode, 'A', TV) B = a.add_node(t.ConceptNode, 'B', TruthValue(0.5,1)) C = a.add_node(t.ConceptNode, 'C', TV) AB = a.add_link(t.InheritanceLink, [A, B], TV) BC = a.add_link(t.InheritanceLink, [B, C], TV) AC = a.add_link(t.InheritanceLink, [A, C]) print AB.incoming a.print_list() import logic from tree import * target = tree_from_atom(AC) chainer = logic.Chainer(a) results = chainer.bc(target) print '\n---------------------------\n' print results print AC.tv
class TestEntityRecorder(unittest.TestCase):
def setUp(self):
self.atomspace = AtomSpace()
self.test_entity_recorder = EntityRecorder.init_new_entity_recorder()
def tearDown(self):
del self.test_entity_recorder
del self.atomspace
def testAddandRemoveNoneBlockEntity_NormalEntity_AllGetFunctionsWork(self):
test_pos = (17, 28, 39)
timestamp = 12345
test_handle1 = self.atomspace.add_node(types.EntityNode, "entity").h
entity_is_self = False
entity_is_avatar = False
self.test_entity_recorder.add_none_block_entity(test_handle1,test_pos,
entity_is_self, entity_is_avatar,
timestamp)
test_handle2 = self.test_entity_recorder.get_entity(test_pos)
self.assertEqual(test_handle1, test_handle2)
self.assertEqual(test_pos, self.test_entity_recorder.get_last_appeared_location(test_handle1))
self.test_entity_recorder.remove_none_block_entity(test_handle1)
self.assertTrue(self.test_entity_recorder.get_entity(test_pos).is_undefined())
#preserve record
self.assertEqual(test_pos, self.test_entity_recorder.get_last_appeared_location(test_handle1))
def testUpdateEntityLocation_MultipleLocation_LastLocationIsPos2(self):
test_pos1 = (17, 28, 39)
timestamp1 = 12345
test_handle1 = self.atomspace.add_node(types.EntityNode, "entity").h
entity_is_self = False
entity_is_avatar = False
self.test_entity_recorder.add_none_block_entity(test_handle1, test_pos1,
entity_is_self, entity_is_avatar,
timestamp1)
test_pos2 = (17, 28, 40)
timestamp2 = 12346
self.test_entity_recorder.update_none_block_entity_location(test_handle1, test_pos2, timestamp2)
last_location = self.test_entity_recorder.get_last_appeared_location(test_handle1)
self.assertEqual(test_pos2, last_location)
def testAddEntity_PressureTest(self):
count = 10000
timestamp = 12345
while count != 0:
print count
count -= 1
test_pos = (count, count, count)
test_handle1 = self.atomspace.add_node(types.EntityNode, "entity"+str(count)).h
entity_is_self = False
entity_is_avatar = False
self.test_entity_recorder.add_none_block_entity(test_handle1, test_pos,
entity_is_self, entity_is_avatar, timestamp)
test_handle2 = self.test_entity_recorder.get_entity(test_pos)
self.assertEqual(test_handle1, test_handle2)
self.assertEqual(test_pos,self.test_entity_recorder.get_last_appeared_location(test_handle1))
self.test_entity_recorder.remove_none_block_entity(test_handle1)
self.assertTrue(self.test_entity_recorder.get_entity(test_pos).is_undefined())
#preserve record
self.assertEqual(test_pos,self.test_entity_recorder.get_last_appeared_location(test_handle1))
class RulesTest(TestCase):
def setUp(self):
self.atomspace = AtomSpace()
self.chainer = Chainer(self.atomspace)
def tearDown(self):
del self.atomspace
del self.chainer
def _inh_animal_breathe(self):
'''InheritanceLink animal breathe'''
default_av = {'sti': 1}
self.animal = self.atomspace.add_node(types.ConceptNode, "animal")
self.breathe = self.atomspace.add_node(types.ConceptNode, "breathe")
self.inh_animal_breathe = self.atomspace.add_link(
types.InheritanceLink, [self.animal, self.breathe])
self.animal.tv = TruthValue(0.1, 1)
self.breathe.tv = TruthValue(0.1, 1)
self.inh_animal_breathe.tv = TruthValue(1, 1)
atoms = []
atoms.append(self.animal)
atoms.append(self.breathe)
atoms.append(self.inh_animal_breathe)
for atom in atoms:
atom.av = default_av
return atoms
# def _apply_rule(self, rule,
def test_standardize_apart_input_output(self):
rule = rules.InversionRule(self.chainer, types.InheritanceLink)
(input, output) = rule.standardize_apart_input_output(self.chainer)
def test_InversionRule(self):
rule = rules.InversionRule(self.chainer, types.InheritanceLink)
self._inh_animal_breathe()
result = self.chainer._apply_forward(rule)
print result
def test_InversionRule_backward(self):
rule = rules.InversionRule(self.chainer, types.InheritanceLink)
self._inh_animal_breathe()
self.inh_breathe_animal = self.atomspace.add_link(
types.InheritanceLink, [self.breathe, self.animal])
self.inh_breathe_animal.av = {'sti': 1}
result = self.chainer._apply_backward(rule)
print result
def disabled_test_rules_generically(self):
'''See what happens if you give a rule the generic inputs. This makes sure that the rule and formula don't have any basic code errors, but doesn't check that they do the right thing.'''
def apply_rule(rule):
generic_inputs = rule.inputs
generic_outpus = rule.outputs
# Take the generic required input atoms and give them boring TVs
for atom in generic_inputs:
atom.av = {'sti': 1}
atom.tv = TruthValue(1, 1)
status = self.chainer._apply_forward(rule)
self.assertNotEquals(status, None)
return None
for rule in self.chainer.rules:
apply_rule(rule)
InheritanceLink(programmer, fingered, high_tv)
InheritanceLink(programmer, nocturnal, high_tv)
EvaluationLink(live_in, ancients, cave, high_tv)
InheritanceLink(ancients, two_legged, high_tv)
InheritanceLink(ancients, fingered, high_tv)
InheritanceLink(vegetarian, two_legged, high_tv)
InheritanceLink(vegetarian, fingered, high_tv)
# 5. Make custom config.
InheritanceLink(ConceptNode("my-config"), ConceptNode("BLEND"))
ExecutionLink(SchemaNode("BLEND:blending-decider"), ConceptNode("my-config"),
ConceptNode("DecideNull"))
ExecutionLink(SchemaNode("BLEND:link-connector"), ConceptNode("my-config"),
ConceptNode("ConnectConflictInteractionInformation"))
ExecutionLink(SchemaNode("BLEND:connect-check-type"), ConceptNode("my-config"),
ConceptNode("Link"))
# Start Conceptual Blending.
result = ConceptualBlending(a).run([
a.add_node(types.ConceptNode, "bat"),
a.add_node(types.ConceptNode, "man")
], ConceptNode("my-config"))
print "Newly blended node:"
print str(result[0]) + "\n"
print "Links in new blended node:"
print result[0].incoming
class AtomTest(TestCase):
def setUp(self):
self.space = AtomSpace()
def test_creation(self):
a = self.space.add_node(types.Node, "test1")
self.assertEqual(a.name, "test1")
self.assertEqual(a.tv,
TruthValue(1.0,
0.0)) # default is true, no confidence
def test_w_truthvalue(self):
tv = TruthValue(0.5, 100)
a = self.space.add_node(types.Node, "test2", tv)
self.assertEqual(a.tv, tv)
# test set tv
a.tv = TruthValue(0.1, 10)
self.assertEqual(a.tv, TruthValue(0.1, 10))
def test_w_attention_value(self):
a = self.space.add_node(types.Node, "test2")
self.assertEqual(a.av, {'lti': 0, 'sti': 0, 'vlti': False})
# test set av
a.av = {"sti": 10, "lti": 1, "vlti": True}
self.assertEqual(a.av, {'sti': 10, 'lti': 1, 'vlti': True})
def test_out(self):
# test get out
a1 = self.space.add_node(types.Node, "test2")
self.assertEqual(a1.out, [])
tv = TruthValue(0.5, 100)
a2 = self.space.add_node(types.Node, "test3", tv)
l = self.space.add_link(types.Link, [a1, a2])
self.assertEqual(l.out, [a1, a2])
# ensure out is considered immutable
self.assertRaises(AttributeError, setattr, l, "out", [a1])
def test_arity(self):
a1 = self.space.add_node(types.Node, "test2")
self.assertEqual(a1.arity, 0)
tv = TruthValue(0.5, 100)
a2 = self.space.add_node(types.Node, "test3", tv)
l = self.space.add_link(types.Link, [a1, a2])
self.assertEqual(l.arity, 2)
# ensure arity is considered immutable
self.assertRaises(AttributeError, setattr, l, "arity", 4)
def test_is_source(self):
# any out item is a source for unordered links
# only the fist item is a source of ordered links
a1 = self.space.add_node(types.Node, "test1")
a2 = self.space.add_node(types.Node, "test2")
l_ordered = self.space.add_link(types.OrderedLink, [a1, a2])
l_unordered = self.space.add_link(types.UnorderedLink, [a1, a2])
self.assertEqual(l_ordered.is_source(a1), True)
self.assertEqual(l_ordered.is_source(a2), False)
self.assertEqual(l_unordered.is_source(a1), True)
self.assertEqual(l_unordered.is_source(a2), True)
def test_type(self):
# test get out
a = self.space.add_node(types.Node, "test2")
self.assertEqual(a.type, 1)
self.assertEqual(a.t, 1)
a2 = self.space.add_node(types.Node, "test3")
l = self.space.add_link(types.Link, [a, a2])
self.assertEqual(l.type, 2)
self.assertEqual(l.t, 2)
# ensure type is considered immutable
self.assertRaises(AttributeError, setattr, l, "type", 5)
self.assertRaises(AttributeError, setattr, a, "type", 5)
self.assertEqual(l.type_name, "Link")
self.assertEqual(a.type_name, "Node")
def test_strings(self):
# set up a link and atoms
tv = TruthValue(0.5, 100)
a1 = self.space.add_node(types.Node, "test1", tv)
a2 = self.space.add_node(types.Node, "test2")
a2.av = {"sti": 10, "lti": 1, "vlti": True}
a2.tv = TruthValue(0.1, 10)
l = self.space.add_link(types.Link, [a1, a2])
# test string representation
a1_expected = "(Node \"test1\") ; [{0}]\n".format(str(a1.h.value()))
a1_expected_long = \
"(Node \"test1\" (av 0 0 0) (stv 0.500000 0.111111)) ; [{0}]\n"\
.format(str(a1.h.value()))
a2_expected = "(Node \"test2\") ; [{0}]\n".format(str(a2.h.value()))
a2_expected_long = \
"(Node \"test2\" (av 10 1 1) (stv 0.100000 0.012346)) ; [{0}]\n"\
.format(str(a2.h.value()))
l_expected = \
"(Link (stv 1.000000 0.000000)\n {0} {1}) ; [{2}]\n"\
.format(a1_expected, a2_expected, str(l.h.value()))
l_expected_long = \
"(Link (av 0 0 0) (stv 1.000000 0.000000)\n {0} {1}) ; [{2}]\n"\
.format(a1_expected_long, a2_expected_long, str(l.h.value()))
self.assertEqual(str(a2), a2_expected)
self.assertEqual(a2.long_string(), a2_expected_long)
self.assertEqual(str(l), l_expected)
self.assertEqual(l.long_string(), l_expected_long)
class Manipulating_atoms_in_python(unittest.TestCase):
def setUp(self):
self.atsp = AtomSpace()
self.TV = TruthValue()
def test_making_atoms_cPlusPlus_syntax(self):
cat = self.atsp.add_node(types.ConceptNode, "Cat")
man = self.atsp.add_node(types.ConceptNode, "Man")
animal = self.atsp.add_node(types.ConceptNode, "Animal")
self.assertIsInstance(
cat, Atom, "Not able to create node"
) # checks if the above created nodes are instances of Atom class
print "Printing individual atoms in the atomspace"
for atom in self.atsp:
print atom
def test_add_links_into_atomspace(self):
man = self.atsp.add_node(types.ConceptNode, "Man")
animal = self.atsp.add_node(types.ConceptNode, "Animal")
inheritance_link = self.atsp.add_link(types.InheritanceLink,
[man, animal])
self.assertIsInstance(inheritance_link, Atom,
"Link not added to atomspace")
def test_pattern_matching(self):
#test pattern maching between difetent types of nodes
initialize_opencog(self.atsp)
self.scheme_animals = \
'''
(InheritanceLink (ConceptNode "Red") (ConceptNode "color"))
(InheritanceLink (ConceptNode "Green") (ConceptNode "color"))
(InheritanceLink (ConceptNode "Blue") (ConceptNode "color"))
(InheritanceLink (ConceptNode "Spaceship") (ConceptNode "machine"))
'''
# create amodule or function in scheme
self.scheme_query = \
'''
(define find-colors
(BindLink
;; The variable to be bound
(VariableNode "$xcol")
;; The pattern to be searched for
(InheritanceLink
(VariableNode "$xcol")
(ConceptNode "color")
)
;; The value to be returned.
(VariableNode "$xcol")
)
)
'''
#use scheme module
scheme_eval(self.atsp, "(use-modules (opencog))")
scheme_eval(self.atsp, "(use-modules (opencog query))")
scheme_eval_h(self.atsp, self.scheme_animals)
scheme_eval_h(self.atsp, self.scheme_query)
self.result = scheme_eval_h(self.atsp, '(cog-bind find-colors)')
self.varlink = TypedVariableLink(VariableNode("$xcol"),
TypeNode("ConceptNode"))
self.pattern = InheritanceLink(VariableNode("$xcol"), self.test_color)
self.colornodes = SatisfactionLink(self.varlink, self.pattern)
self.assertEqual(self.result, satisfying_set(self.atsp,
self.colornodes))
def test_making_atoms_scheme_syntax(self):
pass
class AnaphoraUnitTester(TestCase):
def setUp(self):
self.atomspace= AtomSpace()
scheme_eval(self.atomspace, "(add-to-load-path \"/usr/local/share/opencog/scm\")")
scheme_eval(self.atomspace, "(use-modules (opencog))")
scheme_eval(self.atomspace, "(use-modules (opencog atom-types))")
scheme_eval(self.atomspace, "(use-modules (opencog query))")
data=["opencog/scm/config.scm",
"opencog/scm/core_types.scm",
"opencog/scm/apply.scm",
"opencog/scm/file-utils.scm",
"opencog/scm/utilities.scm",
"opencog/scm/av-tv.scm",
"opencog/nlp/scm/type-definitions.scm",
"opencog/nlp/scm/config.scm",
"opencog/nlp/scm/file-utils.scm",
"opencog/nlp/scm/nlp-utils.scm",
"opencog/nlp/scm/disjunct-list.scm",
"opencog/nlp/scm/processing-utils.scm",
]
for item in data:
status=load_scm(self.atomspace, item)
# print "load status=", status, " item=", item
self.hobbsAgent=HobbsAgent()
def tearDown(self):
del self.atomspace
del self.hobbsAgent
def getWord(self,name,type=types.WordInstanceNode):
word = self.atomspace.add_node(type, name)
return word
def compare(self,list_1,list_2):
if len(list_1)==len(list_2):
for i in range(len(list_1)):
if list_1[i]!=list_2[i].name:
return False
return True
else:
return False
def test_bfs(self):
'''
Testing the bfs function
'''
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/bfs.scm"))
self.hobbsAgent.run(self.atomspace)
self.assertTrue(self.compare(['a','b','c','d','e','f','g'],self.hobbsAgent.bfs(self.getWord('a'))))
self.atomspace.clear()
#@unittest.skip("debugging skipping")
def test_getWords(self):
'''
Testing the getWords function
'''
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/getWords.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.compare(['a','b','c','d','e','f','g','h','j'],self.hobbsAgent.getWords()))
self.atomspace.clear()
def test_propose(self):
'''
Testing the propose function
'''
def filter_1():
print("Testing filter #1...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#1/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#1/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#1/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#1/data_#4.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#1/data_#5.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#1/data_#6.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
def filter_2():
print("Testing filter #2...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#2/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#2/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
def filter_3():
print("Testing filter #3...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#3/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),3))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#3/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),3))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#3/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),3))
self.atomspace.clear()
def filter_4():
print("Testing filter #4...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#4/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),4))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#4/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),4))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#4/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),4))
self.atomspace.clear()
def filter_5():
print("Testing filter #5...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#5/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),5))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#5/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),5))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#5/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),5))
self.atomspace.clear()
def filter_6():
print("Testing filter #6...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#6/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),6))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#6/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),6))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#6/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),6))
self.atomspace.clear()
def filter_7():
print("Testing filter #7...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#7/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),7))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#7/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),7))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#7/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),7))
self.atomspace.clear()
def filter_8():
print("Testing filter #8...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#8/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),8))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#8/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),8))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#8/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),8))
self.atomspace.clear()
def filter_9():
print("Testing filter #9...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#9/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),9))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#9/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),9))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#9/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),9))
self.atomspace.clear()
def filter_10():
print("Testing filter #10...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#10/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),10))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#10/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),10))
self.atomspace.clear()
def filter_11():
print("Testing filter #11...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#11/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),11))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#11/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),11))
self.atomspace.clear()
def filter_12():
print("Testing filter #12...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#12/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent',types.ParseNode),12))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#12/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),12))
self.atomspace.clear()
def filter_13():
print("Testing filter #13...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#13/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),13))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#13/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),13))
self.atomspace.clear()
def filter_14():
print("Testing filter #14...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#14/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),14))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#14/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),14))
self.atomspace.clear()
def filter_15():
print("Testing filter #15...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#15/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),15))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#15/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),15))
self.atomspace.clear()
def filter_16():
print("Testing filter #16...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#16/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),16))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#16/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),16))
self.atomspace.clear()
def filter_17():
print("Testing filter #17...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#17/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),17))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#17/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),17))
self.atomspace.clear()
def filter_18():
print("Testing filter #18...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#18/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),18))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#18/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),18))
self.atomspace.clear()
filter_1()
filter_2()
filter_3()
filter_4()
filter_5()
filter_6()
filter_7()
filter_8()
filter_9()
filter_10()
filter_11()
filter_12()
filter_13()
filter_14()
filter_15()
filter_16()
filter_17()
filter_18()
#@unittest.skip("debugging skipping")
def test_pleonastic_if(self):
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/pleonastic_it/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/pleonastic_it/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/pleonastic_it/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/pleonastic_it/data_#4.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/pleonastic_it/data_#5.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
#@unittest.skip("debugging skipping")
def test_conjunctions(self):
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/conjunction.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.pleonastic_it(self.getWord('waitresses')))
self.atomspace.clear()
# create_atoms_by_type.py # """ Simple example of how to create atoms in the AtomSpace. See also create_atomspace_simple.py for an alternate interface. """ from opencog.atomspace import AtomSpace, TruthValue, Atom from opencog.atomspace import types a = AtomSpace() # Create a truth value asserting true and mostly confident. TV = TruthValue(1, 0.8) # Add three nodes concept_type = types.ConceptNode A = a.add_node(concept_type, 'Apple', TV) B = a.add_node(concept_type, 'Berry', TruthValue(0.5, 0.75)) C = a.add_node(concept_type, 'Comestible', TV) # Add three inhertance links, asserting that apples are berries # and that berries are edible. inh_type = types.InheritanceLink AB = a.add_link(inh_type, [A, B], TV) BC = a.add_link(inh_type, [B, C], TV) AC = a.add_link(inh_type, [A, C]) print "The atomspace contains:\n\n", a.get_atoms_by_type(types.Atom)
# Parse: Predicate
concepts = []
line = line.split('(')
predicate = line[0]
# Parse: Concepts
done = False
line = line[1].split(',')
for elem in line:
elem = elem.split(')')
concepts.append(elem[0])
# Construct OpenCog atoms
predicate_node = atomspace.add_node(
types.PredicateNode, predicate)
# ConceptNodes
concept_nodes = []
for concept in concepts:
concept_nodes.append(atomspace.add_node(
types.ConceptNode, concept))
# ListLink
list_link = atomspace.add_link(
types.ListLink, concept_nodes, crisp_true)
# EvaluationLink
eval_link = atomspace.add_link(
types.EvaluationLink, [predicate_node, list_link])
new_link = eval_link
from opencog.atomspace import AtomSpace, TruthValue, Atom from opencog.atomspace import types as t a = AtomSpace() TV = TruthValue(1, 1) A = a.add_node(t.ConceptNode, 'A', TV) B = a.add_node(t.ConceptNode, 'B', TruthValue(0.5, 1)) C = a.add_node(t.ConceptNode, 'C', TV) AB = a.add_link(t.InheritanceLink, [A, B], TV) BC = a.add_link(t.InheritanceLink, [B, C], TV) AC = a.add_link(t.InheritanceLink, [A, C]) a.print_list() import logic from tree import * target = tree_from_atom(AC) chainer = logic.Chainer(a) results = chainer.bc(target) print '\n---------------------------\n' print results print AC
class AtomTest(TestCase):
def setUp(self):
self.space = AtomSpace()
def test_creation(self):
a = self.space.add_node(types.Node, "test1")
self.assertEqual(a.name, "test1")
self.assertEqual(a.tv, TruthValue(1.0, 0.0)) # default is true, no confidence
def test_w_truthvalue(self):
tv = TruthValue(0.5, 100)
a = self.space.add_node(types.Node, "test2", tv)
self.assertEqual(a.tv, tv)
# test set tv
a.tv = TruthValue(0.1, 10)
self.assertEqual(a.tv, TruthValue(0.1, 10))
def test_w_attention_value(self):
a = self.space.add_node(types.Node, "test2")
self.assertEqual(a.av, {'lti': 0, 'sti': 0, 'vlti': False})
# test set av
a.av = { "sti": 10, "lti": 1, "vlti": True }
self.assertEqual(a.av, {'sti': 10, 'lti': 1, 'vlti': True})
def test_out(self):
# test get out
a1 = self.space.add_node(types.Node, "test2")
self.assertEqual(a1.out, [])
tv = TruthValue(0.5, 100)
a2 = self.space.add_node(types.Node, "test3", tv)
l = self.space.add_link(types.Link, [a1, a2])
self.assertEqual(l.out, [a1, a2])
# ensure out is considered immutable
self.assertRaises(AttributeError, setattr, l, "out", [a1])
def test_arity(self):
a1 = self.space.add_node(types.Node, "test2")
self.assertEqual(a1.arity, 0)
tv = TruthValue(0.5, 100)
a2 = self.space.add_node(types.Node, "test3", tv)
l = self.space.add_link(types.Link, [a1, a2])
self.assertEqual(l.arity, 2)
# ensure arity is considered immutable
self.assertRaises(AttributeError, setattr, l, "arity", 4)
def test_is_source(self):
# any out item is a source for unordered links
# only the fist item is a source of ordered links
a1 = self.space.add_node(types.Node, "test1")
a2 = self.space.add_node(types.Node, "test2")
l_ordered = self.space.add_link(types.OrderedLink, [a1, a2])
l_unordered = self.space.add_link(types.UnorderedLink, [a1, a2])
self.assertEqual(l_ordered.is_source(a1), True)
self.assertEqual(l_ordered.is_source(a2), False)
self.assertEqual(l_unordered.is_source(a1), True)
self.assertEqual(l_unordered.is_source(a2), True)
def test_type(self):
# test get out
a = self.space.add_node(types.Node, "test2")
self.assertEqual(a.type, 1)
self.assertEqual(a.t, 1)
a2 = self.space.add_node(types.Node, "test3")
l = self.space.add_link(types.Link, [a, a2])
self.assertEqual(l.type, 2)
self.assertEqual(l.t, 2)
# ensure type is considered immutable
self.assertRaises(AttributeError, setattr, l, "type", 5)
self.assertRaises(AttributeError, setattr, a, "type", 5)
self.assertEqual(l.type_name, "Link")
self.assertEqual(a.type_name, "Node")
def test_strings(self):
# set up a link and atoms
tv = TruthValue(0.5, 100)
a1 = self.space.add_node(types.Node, "test1", tv)
a2 = self.space.add_node(types.Node, "test2")
a2.av = {"sti": 10, "lti": 1, "vlti": True}
a2.tv = TruthValue(0.1, 10)
l = self.space.add_link(types.Link, [a1, a2])
# test string representation
a1_expected = "(Node \"test1\") ; [{0}]\n".format(str(a1.h.value()))
a1_expected_long = \
"(Node \"test1\" (av 0 0 0) (stv 0.500000 0.111111)) ; [{0}]\n"\
.format(str(a1.h.value()))
a2_expected = "(Node \"test2\") ; [{0}]\n".format(str(a2.h.value()))
a2_expected_long = \
"(Node \"test2\" (av 10 1 1) (stv 0.100000 0.012346)) ; [{0}]\n"\
.format(str(a2.h.value()))
l_expected = \
"(Link (stv 1.000000 0.000000)\n {0} {1}) ; [{2}]\n"\
.format(a1_expected, a2_expected, str(l.h.value()))
l_expected_long = \
"(Link (av 0 0 0) (stv 1.000000 0.000000)\n {0} {1}) ; [{2}]\n"\
.format(a1_expected_long, a2_expected_long, str(l.h.value()))
self.assertEqual(str(a2), a2_expected)
self.assertEqual(a2.long_string(), a2_expected_long)
self.assertEqual(str(l), l_expected)
self.assertEqual(l.long_string(), l_expected_long)
pal_a = atom_from_tree(pal, a)
print ps
print pal
ps_a.tv = TruthValue(1.0, confidence_to_count(1.0))
print ps_a.tv
return result_atoms
if __name__ == '__main__':
a = AtomSpace()
log.use_stdout(True)
atom_from_tree(T('EvaluationLink', a.add_node(t.PredicateNode, 'A')),
a).tv = TruthValue(1, 1)
#atom_from_tree(T('EvaluationLink',1), a).tv = TruthValue(1, 1)
c = Chainer(a)
#search(T('EvaluationLink',a.add_node(t.PredicateNode,'B')))
#fc(a)
#c.bc(T('EvaluationLink',a.add_node(t.PredicateNode,'A')))
# global rules
# A = T('EvaluationLink',a.add_node(t.PredicateNode,'A'))
# B = T('EvaluationLink',a.add_node(t.PredicateNode,'B'))
# rules.append(Rule(B,
# [ A ]))
class AtomSpaceTest(TestCase):
def setUp(self):
self.space = AtomSpace()
initialize_opencog(self.space)
def tearDown(self):
finalize_opencog()
del self.space
def test_add_node(self):
# Test long form atomspace node addition.
# Test node add
self.space.add_node(types.Node, "node" )
# Test with not a proper truthvalue
self.assertRaises(TypeError, self.space.add_node, types.Node, "test",
0, True)
# Test with bad type
self.assertRaises(TypeError, self.space.add_node, "ConceptNode", "test",
TruthValue(0.5, 0.8))
# From here on out we'll use the more compact type constructors
a1 = Node("test")
self.assertTrue(a1)
# duplicates resolve to same atom
a2 = Node("test")
self.assertEquals(a1, a2)
# Should fail when intentionally adding bad type
caught = False
try:
self.space.add_node(types.Link, "test")
except RuntimeError:
caught = True
self.assertEquals(caught, True)
# Test adding with a truthvalue
a3 = Node("test_w_tv").truth_value(0.5, 0.8)
self.assertEquals(self.space.size(), 3)
def test_add_link(self):
n1 = Node("test1")
n2 = Node("test2")
l1 = Link(n1, n2)
self.assertTrue(l1 is not None)
l2 = Link(n1, n2)
self.assertTrue(l2 is not None)
self.assertTrue(l2 == l1)
n3 = Node("test3")
l3 = Link(n1, n3).truth_value(0.5, 0.8)
self.assertTrue(l3 is not None)
# Should fail when adding an intentionally bad type
caught = False
try:
l1 = self.space.add_link(types.Node, [n1, n3])
except RuntimeError:
caught = True
self.assertEquals(caught, True)
def test_is_valid(self):
a1 = Node("test1")
# check with Atom object
self.assertTrue(self.space.is_valid(a1))
# check with bad type
self.assertRaises(TypeError, self.space.is_valid, "test")
def test_truth_value(self):
# check attributes come back as assigned
tv = TruthValue(0.5, 0.8)
self.assertEqual(tv.mean, 0.5)
self.assertAlmostEqual(tv.confidence, 0.8, places=4)
# test string representation
self.assertEqual(str(tv), "(stv 0.500000 0.800000)")
# check equality
tv2 = TruthValue(0.5, 0.8)
tv3 = TruthValue(0.6, 0.8)
self.assertTrue(tv == tv2)
self.assertFalse(tv == tv3)
# check truth_value function of atom
atom = Node("atom with tv")
default_tv = atom.tv
atom.truth_value(0.75, 0.9)
new_tv = atom.tv
self.assertFalse(new_tv == default_tv)
self.assertEqual(new_tv.mean, 0.75)
self.assertAlmostEqual(new_tv.confidence, 0.9, places=4)
def test_attention_value(self):
node = Node("test")
# check values come back as assigned
node.sti = 1
node.lti = 2
node.vlti = 3
assert node.sti == 1
assert node.lti == 2
assert node.vlti == 3
# Check increment and decrement for vlti
node.decrement_vlti()
assert node.vlti == 2
node.increment_vlti()
assert node.vlti == 3
# Check dictionary setting and getting of av property.
node.av = {"sti": 4, "lti": 5, "vlti": 6}
assert node.sti == 4
assert node.lti == 5
assert node.vlti == 6
assert node.av == {"sti": 4, "lti": 5, "vlti": 6}
def test_get_by_type(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
# test recursive subtypes
result = self.space.get_atoms_by_type(types.Node)
self.assertTrue(a1 in result)
self.assertTrue(a2 in result)
self.assertTrue(a3 in result)
# links
l1 = InheritanceLink(a1, a2)
result = self.space.get_atoms_by_type(types.Link)
self.assertTrue(l1 in result)
# test non-recursive subtype
result = self.space.get_atoms_by_type(types.Node, subtype=False)
self.assertTrue(a1 in result)
self.assertTrue(a2 not in result)
self.assertTrue(a3 not in result)
# test empty
result = self.space.get_atoms_by_type(types.AnchorNode, subtype=False)
self.assertEqual(len(result), 0)
def test_get_by_av(self):
a1 = ConceptNode("test1")
a2 = ConceptNode("test2")
a3 = InheritanceLink(a1, a2)
a4 = ConceptNode("test4")
a5 = ConceptNode("test5")
a1.sti = 10
a2.sti = 5
a3.sti = 4
a4.sti = 1
#ImportanceIndex is Asynchronus give it some time
sleep(1)
result = self.space.get_atoms_by_av(4, 10)
print "The atoms-by-av result is ", result
assert len(result) == 3
assert set(result) == set([a1, a2, a3])
assert a4 not in result
result = self.space.get_atoms_in_attentional_focus()
assert len(result) == 4
assert set(result) == set([a1, a2, a3, a4])
def test_incoming_by_type(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
# test no incoming Node for a1
result = a1.incoming_by_type(types.Node)
self.assertTrue(a1 not in result)
# now check links
l1 = InheritanceLink(a1, a2)
result = a1.incoming_by_type(types.InheritanceLink)
self.assertTrue(l1 in result)
result = a2.incoming_by_type(types.InheritanceLink)
self.assertTrue(l1 in result)
result = a3.incoming_by_type(types.InheritanceLink)
self.assertTrue(l1 not in result)
def test_include_incoming_outgoing(self):
frog = ConceptNode("Frog")
thing = ConceptNode("Thing")
animal = ConceptNode("Animal")
ConceptNode("SeparateThing")
InheritanceLink(frog, animal)
InheritanceLink(animal, thing)
assert len(self.space.include_incoming([ConceptNode("Frog")])) == 2
assert len(self.space.include_outgoing(self.space.include_incoming([ConceptNode("Frog")]))) == 3
assert len(self.space.include_incoming(self.space.get_atoms_by_type(types.ConceptNode))) == 6
assert len(self.space.include_outgoing(self.space.get_atoms_by_type(types.InheritanceLink))) == 5
def test_remove(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
self.assertTrue(a1 in self.space)
self.assertTrue(a2 in self.space)
self.assertTrue(a3 in self.space)
self.space.remove(a1)
self.assertTrue(a1 not in self.space)
self.assertTrue(a2 in self.space)
self.assertTrue(a3 in self.space)
l = SimilarityLink(a2, a3)
self.space.remove(a2, True) # won't remove it unless recursive is True
self.assertTrue(a2 not in self.space)
self.assertTrue(l not in self.space)
def test_clear(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
self.space.clear()
self.assertEquals(self.space.size(), 0)
self.assertEquals(len(self.space), 0)
def test_container_methods(self):
self.assertEquals(len(self.space), 0)
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
self.assertTrue(a1 in self.space)
self.assertTrue(a2 in self.space)
self.assertTrue(a3 in self.space)
self.assertEquals(len(self.space), 3)
def test_get_predicates(self):
dog = ConceptNode("dog")
mammal = ConceptNode("mammal")
canine = ConceptNode("canine")
animal = ConceptNode("animal")
dog_mammal = ListLink(dog, mammal)
dog_canine = ListLink(dog, canine)
dog_animal = ListLink(dog, animal)
isA = PredicateNode("IsA")
dogIsAMammal = EvaluationLink(isA, dog_mammal)
dogIsACanine = EvaluationLink(isA, dog_canine)
dogIsAAnimal = EvaluationLink(isA, dog_animal)
dog_predicates = self.space.get_predicates(dog)
self.assertEquals(len(dog_predicates), 3)
count = 0
for dogIs in self.space.xget_predicates(dog):
count += 1
self.assertEquals(count, 3)
def test_get_predicates_for(self):
dog = ConceptNode("dog")
mammal = ConceptNode("mammal")
canine = ConceptNode("canine")
animal = ConceptNode("animal")
dog_mammal = ListLink(dog, mammal)
dog_canine = ListLink(dog, canine)
dog_animal = ListLink(dog, animal)
isA = PredicateNode("IsA")
dogIsAMammal = EvaluationLink(isA, dog_mammal)
dogIsACanine = EvaluationLink(isA, dog_canine)
dogIsAAnimal = EvaluationLink(isA, dog_animal)
human = ConceptNode("human")
dog_human = ListLink(dog, human)
loves = PredicateNode("loves")
dogLovesHumans = EvaluationLink(loves, dog_human)
dog_predicates = self.space.get_predicates_for(dog, isA)
self.assertEquals(len(dog_predicates), 3)
dog_predicates = self.space.get_predicates_for(dog, loves)
self.assertEquals(len(dog_predicates), 1)
count = 0
for dogIsA in self.space.xget_predicates_for(dog, isA):
count += 1
self.assertEquals(count, 3)
count = 0
for dogLoves in self.space.xget_predicates_for(dog, loves):
count += 1
self.assertEquals(count, 1)
class TestEntityRecorder(unittest.TestCase):
def setUp(self):
self.atomspace = AtomSpace()
self.test_entity_recorder = EntityRecorder.init_new_entity_recorder()
def tearDown(self):
del self.test_entity_recorder
del self.atomspace
def testAddandRemoveNoneBlockEntity_NormalEntity_AllGetFunctionsWork(self):
test_pos = (17, 28, 39)
timestamp = 12345
test_handle1 = self.atomspace.add_node(types.EntityNode, "entity").h
entity_is_self = False
entity_is_avatar = False
self.test_entity_recorder.add_none_block_entity(
test_handle1, test_pos, entity_is_self, entity_is_avatar,
timestamp)
test_handle2 = self.test_entity_recorder.get_entity(test_pos)
self.assertEqual(test_handle1, test_handle2)
self.assertEqual(
test_pos,
self.test_entity_recorder.get_last_appeared_location(test_handle1))
self.test_entity_recorder.remove_none_block_entity(test_handle1)
self.assertTrue(
self.test_entity_recorder.get_entity(test_pos).is_undefined())
#preserve record
self.assertEqual(
test_pos,
self.test_entity_recorder.get_last_appeared_location(test_handle1))
def testUpdateEntityLocation_MultipleLocation_LastLocationIsPos2(self):
test_pos1 = (17, 28, 39)
timestamp1 = 12345
test_handle1 = self.atomspace.add_node(types.EntityNode, "entity").h
entity_is_self = False
entity_is_avatar = False
self.test_entity_recorder.add_none_block_entity(
test_handle1, test_pos1, entity_is_self, entity_is_avatar,
timestamp1)
test_pos2 = (17, 28, 40)
timestamp2 = 12346
self.test_entity_recorder.update_none_block_entity_location(
test_handle1, test_pos2, timestamp2)
last_location = self.test_entity_recorder.get_last_appeared_location(
test_handle1)
self.assertEqual(test_pos2, last_location)
def testAddEntity_PressureTest(self):
count = 10000
timestamp = 12345
while count != 0:
print count
count -= 1
test_pos = (count, count, count)
test_handle1 = self.atomspace.add_node(types.EntityNode,
"entity" + str(count)).h
entity_is_self = False
entity_is_avatar = False
self.test_entity_recorder.add_none_block_entity(
test_handle1, test_pos, entity_is_self, entity_is_avatar,
timestamp)
test_handle2 = self.test_entity_recorder.get_entity(test_pos)
self.assertEqual(test_handle1, test_handle2)
self.assertEqual(
test_pos,
self.test_entity_recorder.get_last_appeared_location(
test_handle1))
self.test_entity_recorder.remove_none_block_entity(test_handle1)
self.assertTrue(
self.test_entity_recorder.get_entity(test_pos).is_undefined())
#preserve record
self.assertEqual(
test_pos,
self.test_entity_recorder.get_last_appeared_location(
test_handle1))
class AtomSpaceTest(TestCase):
def setUp(self):
self.space = AtomSpace()
initialize_opencog(self.space)
def tearDown(self):
finalize_opencog()
del self.space
def test_add_node(self):
# Test long form atomspace node addition.
# Test node add
self.space.add_node(types.Node, "node")
# Test with not a proper truthvalue
self.assertRaises(TypeError, self.space.add_node, types.Node, "test",
0, True)
# Test with bad type
self.assertRaises(TypeError, self.space.add_node, "ConceptNode",
"test", TruthValue(0.5, 0.8))
# From here on out we'll use the more compact type constructors
a1 = Node("test")
self.assertTrue(a1)
# duplicates resolve to same atom
a2 = Node("test")
self.assertEquals(a1, a2)
# Should fail when intentionally adding bad type
caught = False
try:
self.space.add_node(types.Link, "test")
except RuntimeError:
caught = True
self.assertEquals(caught, True)
# Test adding with a truthvalue
a3 = Node("test_w_tv").truth_value(0.5, 0.8)
self.assertEquals(self.space.size(), 3)
def test_add_link(self):
n1 = Node("test1")
n2 = Node("test2")
l1 = Link(n1, n2)
self.assertTrue(l1 is not None)
l2 = Link(n1, n2)
self.assertTrue(l2 is not None)
self.assertTrue(l2 == l1)
n3 = Node("test3")
l3 = Link(n1, n3).truth_value(0.5, 0.8)
self.assertTrue(l3 is not None)
# Should fail when adding an intentionally bad type
caught = False
try:
l1 = self.space.add_link(types.Node, [n1, n3])
except RuntimeError:
caught = True
self.assertEquals(caught, True)
def test_is_valid(self):
a1 = Node("test1")
# check with Atom object
self.assertTrue(self.space.is_valid(a1))
# check with raw UUID
self.assertTrue(self.space.is_valid(a1.value()))
# check with bad UUID
self.assertFalse(self.space.is_valid(2919))
# check with bad type
self.assertRaises(TypeError, self.space.is_valid, "test")
def test_truth_value(self):
# check attributes come back as assigned
tv = TruthValue(0.5, 0.8)
self.assertEqual(tv.mean, 0.5)
self.assertAlmostEqual(tv.confidence, 0.8, places=4)
# test string representation
self.assertEqual(str(tv), "(stv 0.500000 0.800000)")
# check equality
tv2 = TruthValue(0.5, 0.8)
tv3 = TruthValue(0.6, 0.8)
self.assertTrue(tv == tv2)
self.assertFalse(tv == tv3)
# check truth_value function of atom
atom = Node("atom with tv")
default_tv = atom.tv
atom.truth_value(0.75, 0.9)
new_tv = atom.tv
self.assertFalse(new_tv == default_tv)
self.assertEqual(new_tv.mean, 0.75)
self.assertAlmostEqual(new_tv.confidence, 0.9, places=4)
def test_attention_value(self):
node = Node("test")
# check values come back as assigned
node.sti = 1
node.lti = 2
node.vlti = 3
assert node.sti == 1
assert node.lti == 2
assert node.vlti == 3
# Check increment and decrement for vlti
node.decrement_vlti()
assert node.vlti == 2
node.increment_vlti()
assert node.vlti == 3
# Check dictionary setting and getting of av property.
node.av = {"sti": 4, "lti": 5, "vlti": 6}
assert node.sti == 4
assert node.lti == 5
assert node.vlti == 6
assert node.av == {"sti": 4, "lti": 5, "vlti": 6}
def test_get_by_type(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
# test recursive subtypes
result = self.space.get_atoms_by_type(types.Node)
self.assertTrue(a1 in result)
self.assertTrue(a2 in result)
self.assertTrue(a3 in result)
# links
l1 = InheritanceLink(a1, a2)
result = self.space.get_atoms_by_type(types.Link)
self.assertTrue(l1 in result)
# test non-recursive subtype
result = self.space.get_atoms_by_type(types.Node, subtype=False)
self.assertTrue(a1 in result)
self.assertTrue(a2 not in result)
self.assertTrue(a3 not in result)
# test empty
result = self.space.get_atoms_by_type(types.AnchorNode, subtype=False)
self.assertEqual(len(result), 0)
def test_get_by_av(self):
a1 = ConceptNode("test1")
a2 = ConceptNode("test2")
a3 = InheritanceLink(a1, a2)
a4 = ConceptNode("test4")
a5 = ConceptNode("test5")
a1.sti = 10
a2.sti = 5
a3.sti = 4
a4.sti = 1
result = self.space.get_atoms_by_av(4, 10)
assert len(result) == 3
assert set(result) == set([a1, a2, a3])
assert a4 not in result
result = self.space.get_atoms_in_attentional_focus()
assert len(result) == 4
assert set(result) == set([a1, a2, a3, a4])
def test_incoming_by_type(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
# test no incoming Node for a1
result = a1.incoming_by_type(types.Node)
self.assertTrue(a1 not in result)
# now check links
l1 = InheritanceLink(a1, a2)
result = a1.incoming_by_type(types.Link)
self.assertTrue(l1 in result)
result = a2.incoming_by_type(types.Link)
self.assertTrue(l1 in result)
result = a3.incoming_by_type(types.Link)
self.assertTrue(l1 not in result)
def test_include_incoming_outgoing(self):
frog = ConceptNode("Frog")
thing = ConceptNode("Thing")
animal = ConceptNode("Animal")
ConceptNode("SeparateThing")
InheritanceLink(frog, animal)
InheritanceLink(animal, thing)
assert len(self.space.include_incoming([ConceptNode("Frog")])) == 2
assert len(
self.space.include_outgoing(
self.space.include_incoming([ConceptNode("Frog")]))) == 3
assert len(
self.space.include_incoming(
self.space.get_atoms_by_type(types.ConceptNode))) == 6
assert len(
self.space.include_outgoing(
self.space.get_atoms_by_type(types.InheritanceLink))) == 5
def test_remove(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
self.assertTrue(a1 in self.space)
self.assertTrue(a2 in self.space)
self.assertTrue(a3 in self.space)
self.space.remove(a1)
self.assertTrue(a1 not in self.space)
self.assertTrue(a2 in self.space)
self.assertTrue(a3 in self.space)
l = SimilarityLink(a2, a3)
self.space.remove(a2, True) # won't remove it unless recursive is True
self.assertTrue(a2 not in self.space)
self.assertTrue(l not in self.space)
def test_clear(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
self.space.clear()
self.assertEquals(self.space.size(), 0)
self.assertEquals(len(self.space), 0)
def test_container_methods(self):
self.assertEquals(len(self.space), 0)
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
self.assertTrue(a1 in self.space)
self.assertTrue(a2 in self.space)
self.assertTrue(a3 in self.space)
self.assertEquals(len(self.space), 3)
def test_get_predicates(self):
dog = ConceptNode("dog")
mammal = ConceptNode("mammal")
canine = ConceptNode("canine")
animal = ConceptNode("animal")
dog_mammal = ListLink(dog, mammal)
dog_canine = ListLink(dog, canine)
dog_animal = ListLink(dog, animal)
isA = PredicateNode("IsA")
dogIsAMammal = EvaluationLink(isA, dog_mammal)
dogIsACanine = EvaluationLink(isA, dog_canine)
dogIsAAnimal = EvaluationLink(isA, dog_animal)
dog_predicates = self.space.get_predicates(dog)
self.assertEquals(len(dog_predicates), 3)
count = 0
for dogIs in self.space.xget_predicates(dog):
count += 1
self.assertEquals(count, 3)
def test_get_predicates_for(self):
dog = ConceptNode("dog")
mammal = ConceptNode("mammal")
canine = ConceptNode("canine")
animal = ConceptNode("animal")
dog_mammal = ListLink(dog, mammal)
dog_canine = ListLink(dog, canine)
dog_animal = ListLink(dog, animal)
isA = PredicateNode("IsA")
dogIsAMammal = EvaluationLink(isA, dog_mammal)
dogIsACanine = EvaluationLink(isA, dog_canine)
dogIsAAnimal = EvaluationLink(isA, dog_animal)
human = ConceptNode("human")
dog_human = ListLink(dog, human)
loves = PredicateNode("loves")
dogLovesHumans = EvaluationLink(loves, dog_human)
dog_predicates = self.space.get_predicates_for(dog, isA)
self.assertEquals(len(dog_predicates), 3)
dog_predicates = self.space.get_predicates_for(dog, loves)
self.assertEquals(len(dog_predicates), 1)
count = 0
for dogIsA in self.space.xget_predicates_for(dog, isA):
count += 1
self.assertEquals(count, 3)
count = 0
for dogLoves in self.space.xget_predicates_for(dog, loves):
count += 1
self.assertEquals(count, 1)
class AnaphoraUnitTester(TestCase):
def setUp(self):
self.atomspace= AtomSpace()
scheme_eval(self.atomspace, "(use-modules (opencog))")
scheme_eval(self.atomspace, "(use-modules (opencog nlp))")
scheme_eval(self.atomspace, "(use-modules (opencog nlp oc))")
self.hobbsAgent=HobbsAgent()
def tearDown(self):
del self.atomspace
del self.hobbsAgent
def getWord(self,name,type=types.WordInstanceNode):
word = self.atomspace.add_node(type, name)
return word
def compare(self,list_1,list_2):
if len(list_1)==len(list_2):
for i in range(len(list_1)):
if list_1[i]!=list_2[i].name:
return False
return True
else:
return False
def test_bfs(self):
'''
Testing the bfs function
'''
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/bfs.scm"))
self.hobbsAgent.run(self.atomspace)
self.assertTrue(self.compare(['a','b','c','d','e','f','g'],self.hobbsAgent.bfs(self.getWord('a'))))
self.atomspace.clear()
def test_getWords(self):
'''
Testing the getWords function
'''
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/getWords.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.compare(['a','b','c','d','e','f','g','h','j'],self.hobbsAgent.getWords()))
self.atomspace.clear()
def test_propose(self):
'''
Testing the propose function
'''
def filter_1():
print("Testing filter #1...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#1/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#1/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#1/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#1/data_#4.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#1/data_#5.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#1/data_#6.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
def filter_2():
print("Testing filter #2...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#2/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#2/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent')))
self.atomspace.clear()
def filter_3():
print("Testing filter #3...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#3/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),3))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#3/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),3))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#3/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),3))
self.atomspace.clear()
def filter_4():
print("Testing filter #4...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#4/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),4))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#4/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),4))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#4/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),4))
self.atomspace.clear()
def filter_5():
print("Testing filter #5...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#5/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),5))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#5/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),5))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#5/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),5))
self.atomspace.clear()
def filter_6():
print("Testing filter #6...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#6/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),6))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#6/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),6))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#6/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),6))
self.atomspace.clear()
def filter_7():
print("Testing filter #7...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#7/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),7))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#7/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),7))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#7/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),7))
self.atomspace.clear()
def filter_8():
print("Testing filter #8...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#8/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),8))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#8/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),8))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#8/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),8))
self.atomspace.clear()
def filter_9():
print("Testing filter #9...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#9/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),9))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#9/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),9))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#9/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),9))
self.atomspace.clear()
def filter_10():
print("Testing filter #10...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#10/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),10))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#10/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),10))
self.atomspace.clear()
def filter_11():
print("Testing filter #11...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#11/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),11))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#11/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),11))
self.atomspace.clear()
def filter_12():
print("Testing filter #12...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#12/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent',types.ParseNode),12))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#12/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),12))
self.atomspace.clear()
def filter_13():
print("Testing filter #13...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#13/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),13))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#13/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),13))
self.atomspace.clear()
def filter_14():
print("Testing filter #14...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#14/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),14))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#14/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),14))
self.atomspace.clear()
def filter_15():
print("Testing filter #15...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#15/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),15))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#15/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),15))
self.atomspace.clear()
def filter_16():
print("Testing filter #16...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#16/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),16))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#16/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),16))
self.atomspace.clear()
def filter_17():
print("Testing filter #17...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#17/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),17))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#17/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),17))
self.atomspace.clear()
def filter_18():
print("Testing filter #18...")
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#18/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.propose(self.getWord('antecedent'),18))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/propose/filter-#18/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.propose(self.getWord('antecedent'),18))
self.atomspace.clear()
filter_1()
filter_2()
filter_3()
filter_4()
filter_5()
filter_6()
filter_7()
filter_8()
filter_9()
filter_10()
filter_11()
filter_12()
filter_13()
filter_14()
filter_15()
filter_16()
filter_17()
filter_18()
def test_pleonastic_if(self):
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/pleonastic_it/data_#1.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/pleonastic_it/data_#2.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/pleonastic_it/data_#3.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertTrue(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/pleonastic_it/data_#4.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/pleonastic_it/data_#5.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.pleonastic_it(self.getWord('it')))
self.atomspace.clear()
def test_conjunctions(self):
self.assertTrue(load_scm(self.atomspace, "tests/nlp/anaphora/data/conjunction.scm"))
self.hobbsAgent.initilization(self.atomspace)
self.assertFalse(self.hobbsAgent.pleonastic_it(self.getWord('waitresses')))
self.atomspace.clear()
print len(concept_nodes),'concepts'
for A in concept_nodes:
for B in concept_nodes:
target = T('SubsetLink', A, B)
print target
results = chainer.bc(target)
print results
if __name__ == '__main__':
atomspace = AtomSpace()
# jade.ATOMS
ENTITY = atomspace.add_node('VariableNode', '$ENTITY')
BLOCK = atomspace.add_node('VariableNode', '$BLOCK')
COLOR = atomspace.add_node('VariableNode', '$COLOR')
atomspace.add_link('ForAllLink',
[atomspace.add_link('ListLink', [ENTITY, BLOCK, COLOR]),
atomspace.add_link('ImplicationLink',
[atomspace.add_link('AndLink',
[atomspace.add_link('EvaluationLink',
[atomspace.add_node('PredicateNode', 'part-of'),
atomspace.add_link('ListLink', [BLOCK, ENTITY])]),
atomspace.add_link('EvaluationLink',
[atomspace.add_node('PredicateNode', 'color'),
atomspace.add_link('ListLink', [BLOCK, COLOR])])]),
atomspace.add_link('EvaluationLink',
[atomspace.add_node('PredicateNode', 'contains-block-of-color'),
# Sample from:
# https://wiki.opencog.org/w/Manipulating_Atoms_in_Python
from opencog.atomspace import AtomSpace, types
a = AtomSpace()
cat = a.add_node(types.ConceptNode, "Cat")
animal = a.add_node(types.ConceptNode, "Animal")
a.add_link(types.InheritanceLink, [cat, animal])
for atom in a:
print (atom)
from opencog.utilities import initialize_opencog
from opencog.type_constructors import *
from opencog.bindlink import satisfying_set
initialize_opencog(a)
a.clear()
color = ConceptNode("Color")
InheritanceLink(ConceptNode("Red"), color)
InheritanceLink(ConceptNode("Green"), color)
InheritanceLink(ConceptNode("Blue"), color)
# Create a pattern to look for color nodes
varlink = TypedVariableLink(VariableNode("$xcol"), TypeNode("ConceptNode"))
pattern = InheritanceLink(VariableNode("$xcol"), color)
colornodes = GetLink(varlink, pattern)
ExecutionLink(
SchemaNode("BLEND:blending-decider"),
ConceptNode("my-config"),
ConceptNode("DecideNull")
)
ExecutionLink(
SchemaNode("BLEND:link-connector"),
ConceptNode("my-config"),
ConceptNode("ConnectConflictInteractionInformation")
)
ExecutionLink(
SchemaNode("BLEND:connect-check-type"),
ConceptNode("my-config"),
ConceptNode("Link")
)
# Start Conceptual Blending.
result = ConceptualBlending(a).run(
[
a.add_node(types.ConceptNode, "bat"),
a.add_node(types.ConceptNode, "man")
],
ConceptNode("my-config")
)
print "Newly blended node:"
print str(result[0]) + "\n"
print "Links in new blended node:"
print result[0].incoming
class AtomSpaceTest(TestCase):
def setUp(self):
self.space = AtomSpace()
initialize_opencog(self.space)
def tearDown(self):
finalize_opencog()
del self.space
def test_add_node(self):
# Test long form atomspace node addition.
# Test node add
self.space.add_node(types.Node, "node")
# Test with not a proper truthvalue
self.assertRaises(TypeError, self.space.add_node, types.Node, "test",
0, True)
# Test with bad type
self.assertRaises(TypeError, self.space.add_node, "ConceptNode",
"test", TruthValue(0.5, 0.8))
# From here on out we'll use the more compact type constructors
a1 = Node("test")
self.assertTrue(a1)
# duplicates resolve to same atom
a2 = Node("test")
self.assertEquals(a1, a2)
# Should fail when intentionally adding bad type
caught = False
try:
self.space.add_node(types.Link, "test")
except RuntimeError:
caught = True
self.assertEquals(caught, True)
# Test adding with a truthvalue
a3 = Node("test_w_tv").truth_value(0.5, 0.8)
self.assertEquals(self.space.size(), 3)
def test_add_link(self):
n1 = Node("test1")
n2 = Node("test2")
l1 = Link(n1, n2)
self.assertTrue(l1 is not None)
l2 = Link(n1, n2)
self.assertTrue(l2 is not None)
self.assertTrue(l2 == l1)
n3 = Node("test3")
l3 = Link(n1, n3).truth_value(0.5, 0.8)
self.assertTrue(l3 is not None)
# Should fail when adding an intentionally bad type
caught = False
try:
l1 = self.space.add_link(types.Node, [n1, n3])
except RuntimeError:
caught = True
self.assertEquals(caught, True)
def test_is_valid(self):
a1 = Node("test1")
# check with Atom object
self.assertTrue(self.space.is_valid(a1))
# check with bad type
self.assertRaises(TypeError, self.space.is_valid, "test")
def test_truth_value(self):
# check attributes come back as assigned
tv = TruthValue(0.5, 0.8)
self.assertEqual(tv.mean, 0.5)
self.assertAlmostEqual(tv.confidence, 0.8, places=4)
# test string representation
self.assertEqual(str(tv), "(stv 0.500000 0.800000)")
# check equality
tv2 = TruthValue(0.5, 0.8)
tv3 = TruthValue(0.6, 0.8)
self.assertTrue(tv == tv2)
self.assertFalse(tv == tv3)
# check truth_value function of atom
atom = Node("atom with tv")
default_tv = atom.tv
atom.truth_value(0.75, 0.9)
new_tv = atom.tv
self.assertFalse(new_tv == default_tv)
self.assertEqual(new_tv.mean, 0.75)
self.assertAlmostEqual(new_tv.confidence, 0.9, places=4)
def test_get_by_type(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
# test recursive subtypes
result = self.space.get_atoms_by_type(types.Node)
self.assertTrue(a1 in result)
self.assertTrue(a2 in result)
self.assertTrue(a3 in result)
# links
l1 = InheritanceLink(a1, a2)
result = self.space.get_atoms_by_type(types.Link)
self.assertTrue(l1 in result)
# test non-recursive subtype
result = self.space.get_atoms_by_type(types.Node, subtype=False)
self.assertTrue(a1 in result)
self.assertTrue(a2 not in result)
self.assertTrue(a3 not in result)
# test empty
result = self.space.get_atoms_by_type(types.AnchorNode, subtype=False)
self.assertEqual(len(result), 0)
def test_incoming_by_type(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
# test no incoming Node for a1
result = a1.incoming_by_type(types.Node)
self.assertTrue(a1 not in result)
# now check links
l1 = InheritanceLink(a1, a2)
result = a1.incoming_by_type(types.InheritanceLink)
self.assertTrue(l1 in result)
result = a2.incoming_by_type(types.InheritanceLink)
self.assertTrue(l1 in result)
result = a3.incoming_by_type(types.InheritanceLink)
self.assertTrue(l1 not in result)
def test_include_incoming_outgoing(self):
frog = ConceptNode("Frog")
thing = ConceptNode("Thing")
animal = ConceptNode("Animal")
ConceptNode("SeparateThing")
InheritanceLink(frog, animal)
InheritanceLink(animal, thing)
assert len(self.space.include_incoming([ConceptNode("Frog")])) == 2
assert len(
self.space.include_outgoing(
self.space.include_incoming([ConceptNode("Frog")]))) == 3
assert len(
self.space.include_incoming(
self.space.get_atoms_by_type(types.ConceptNode))) == 6
assert len(
self.space.include_outgoing(
self.space.get_atoms_by_type(types.InheritanceLink))) == 5
def test_remove(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
self.assertTrue(a1 in self.space)
self.assertTrue(a2 in self.space)
self.assertTrue(a3 in self.space)
self.space.remove(a1)
self.assertTrue(a1 not in self.space)
self.assertTrue(a2 in self.space)
self.assertTrue(a3 in self.space)
l = SimilarityLink(a2, a3)
self.space.remove(a2, True) # won't remove it unless recursive is True
self.assertTrue(a2 not in self.space)
self.assertTrue(l not in self.space)
def test_clear(self):
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
self.space.clear()
self.assertEquals(self.space.size(), 0)
self.assertEquals(len(self.space), 0)
def test_container_methods(self):
self.assertEquals(len(self.space), 0)
a1 = Node("test1")
a2 = ConceptNode("test2")
a3 = PredicateNode("test3")
self.assertTrue(a1 in self.space)
self.assertTrue(a2 in self.space)
self.assertTrue(a3 in self.space)
self.assertEquals(len(self.space), 3)
def test_context_mgr_tmp(self):
a = ConceptNode('a')
with tmp_atomspace() as tmp_as:
b = ConceptNode('b')
self.assertTrue(a in self.space)
# verify that current default atomspace is tmp_as
self.assertFalse(b in self.space)
c = ConceptNode('c')
# verify that current default atomspace is self.space
self.assertTrue(c in self.space)
ps_a = atom_from_tree(ps, a)
pal_a = atom_from_tree(pal, a)
print ps
print pal
ps_a.tv = TruthValue(1.0, confidence_to_count(1.0))
print ps_a.tv
return result_atoms
if __name__ == '__main__':
a = AtomSpace()
log.use_stdout(True)
atom_from_tree(T('EvaluationLink',a.add_node(t.PredicateNode,'A')), a).tv = TruthValue(1, 1)
#atom_from_tree(T('EvaluationLink',1), a).tv = TruthValue(1, 1)
c = Chainer(a)
#search(T('EvaluationLink',a.add_node(t.PredicateNode,'B')))
#fc(a)
#c.bc(T('EvaluationLink',a.add_node(t.PredicateNode,'A')))
# global rules
# A = T('EvaluationLink',a.add_node(t.PredicateNode,'A'))
# B = T('EvaluationLink',a.add_node(t.PredicateNode,'B'))
# rules.append(Rule(B,
# [ A ]))
this relationship.
See:
https://github.com/opencog/opencog/issues/530
Currently, it is represented the same way that Relex2Logic outputs it,
which is not going to work properly.
"""
__author__ = 'Cosmo Harrigan'
from opencog.atomspace import AtomSpace, TruthValue, types
atomspace = AtomSpace()
Socrates = atomspace.add_node(types.ConceptNode, "Socrates")
Man = atomspace.add_node(types.ConceptNode, "man")
Air = atomspace.add_node(types.ConceptNode, "air")
be = atomspace.add_node(types.PredicateNode, "be")
breathe = atomspace.add_node(types.PredicateNode, "breathe")
atomspace.add_link(
types.EvaluationLink,
[be,
atomspace.add_link(
types.ListLink,
[Socrates, Man])],
TruthValue(1, TruthValue().confidence_to_count(1)))
atomspace.add_link(
types.EvaluationLink,
class RulesTest(TestCase):
def setUp(self):
self.atomspace = AtomSpace()
self.chainer = Chainer(self.atomspace)
def tearDown(self):
del self.atomspace
del self.chainer
def _inh_animal_breathe(self):
'''InheritanceLink animal breathe'''
default_av = {'sti':1}
self.animal = self.atomspace.add_node(types.ConceptNode, "animal")
self.breathe = self.atomspace.add_node(types.ConceptNode, "breathe")
self.inh_animal_breathe = self.atomspace.add_link(types.InheritanceLink, [self.animal, self.breathe])
self.animal.tv = TruthValue(0.1, 1)
self.breathe.tv = TruthValue(0.1, 1)
self.inh_animal_breathe.tv = TruthValue(1, 1)
atoms = []
atoms.append( self.animal )
atoms.append( self.breathe )
atoms.append( self.inh_animal_breathe )
for atom in atoms:
atom.av = default_av
return atoms
# def _apply_rule(self, rule,
def test_standardize_apart_input_output(self):
rule = rules.InversionRule(self.chainer, types.InheritanceLink)
(input, output) = rule.standardize_apart_input_output(self.chainer)
def test_InversionRule(self):
rule = rules.InversionRule(self.chainer, types.InheritanceLink)
self._inh_animal_breathe()
result = self.chainer._apply_forward(rule)
print result
def test_InversionRule_backward(self):
rule = rules.InversionRule(self.chainer, types.InheritanceLink)
self._inh_animal_breathe()
self.inh_breathe_animal = self.atomspace.add_link(types.InheritanceLink, [self.breathe, self.animal])
self.inh_breathe_animal.av = {'sti':1}
result = self.chainer._apply_backward(rule)
print result
def disabled_test_rules_generically(self):
'''See what happens if you give a rule the generic inputs. This makes sure that the rule and formula don't have any basic code errors, but doesn't check that they do the right thing.'''
def apply_rule(rule):
generic_inputs = rule.inputs
generic_outpus = rule.outputs
# Take the generic required input atoms and give them boring TVs
for atom in generic_inputs:
atom.av = {'sti':1}
atom.tv = TruthValue(1, 1)
status = self.chainer._apply_forward(rule)
self.assertNotEquals(status, None)
return None
for rule in self.chainer.rules:
apply_rule(rule)
class BackwardChainerTest(TestCase):
def setUp(self):
self.atomspace = AtomSpace()
self.chainer = Chainer(self.atomspace)
def tearDown(self):
del self.atomspace
del self.chainer
def _simple_atoms_1(self):
atoms = []
atoms.append( self.atomspace.add_node(types.ConceptNode, "animal") )
atoms.append( self.atomspace.add_node(types.ConceptNode, "breathe") )
atoms.append( self.atomspace.add_link(types.InheritanceLink, [atoms[0], atoms[1]]) )
return atoms
def test__selectOne(self):
atoms = self._simple_atoms_1()
atoms[0].av = {'sti': 1}
atom = self.chainer._selectOne(atoms)
self.assertNotEquals(atom, None)
self.assertEqual(atom, atoms[0])
atoms[1].av = {'sti': 1}
atoms[2].av = {'sti': 1}
atom = self.chainer._selectOne(atoms)
self.assertTrue(atom in atoms)
def test_get_attentional_focus(self):
atoms = self._simple_atoms_1()
atoms[2].av = {'sti': 1}
print atoms[2]
contents = get_attentional_focus(self.atomspace)
print contents
self.assertEqual( len(contents), 1 )
def test__select_one_matching(self):
atoms = self._simple_atoms_1()
atoms[2].av = {'sti': 1}
template = atoms[2]
result = self.chainer._select_one_matching(template)
self.assertEqual( result, atoms[2] )
atoms[0].av = {'sti': 1}
print get_attentional_focus(self.atomspace)
template = self.atomspace.add_node(types.VariableNode, "$v1")
result = self.chainer._select_one_matching(template)
self.assertNotEqual( result, None )
def test__find_inputs_recursive(self):
def apply(generic_inputs, generic_outputs):
inputs = []
outputs = []
empty_substitution = {}
status = self.chainer._find_inputs_recursive(inputs, outputs, generic_inputs, generic_outputs, empty_substitution)
return (inputs, outputs)
atoms = self._simple_atoms_1()
# test it on lots of simple made up rules that include the edge cases
# [] => []
generic_inputs = []
generic_outputs = []
(inputs, outputs) = apply(generic_inputs, generic_outputs)
self.assertEquals( inputs, [] )
self.assertEquals( outputs, [] )
# [animal] => []
atoms[0].av = {'sti': 1}
generic_inputs = [atoms[0]]
generic_outputs = []
(inputs, outputs) = apply(generic_inputs, generic_outputs)
self.assertEquals( inputs, [atoms[0]] )
self.assertEquals( outputs, [] )
v1 = self.atomspace.add_node(types.VariableNode, "$v1")
# [v1] => []
generic_inputs = [v1]
generic_outputs = []
(inputs, outputs) = apply(generic_inputs, generic_outputs)
self.assertEquals( len(inputs), 1 )
self.assertEquals( outputs, [] )
#from nose.tools import set_trace; set_trace()
# [v1] => [v1]
generic_inputs = [v1]
generic_outputs = [v1]
(inputs, outputs) = apply(generic_inputs, generic_outputs)
print str(inputs[0])
print str(outputs[0])
self.assertEquals( len(inputs), 1 )
self.assertEquals( len(outputs), 1 )
The full definitions are in this Scheme file:
https://github.com/opencog/test-datasets/blob/master/pln/tuffy/smokes/smokes.scm
They are redefined in Python format here for testing, due to this bug that
prevents importing Scheme files without a running cogserver:
https://github.com/opencog/opencog/issues/530
"""
__author__ = 'Cosmo Harrigan'
from opencog.atomspace import AtomSpace, TruthValue, types
atomspace = AtomSpace()
# Basic variable definitions
X = atomspace.add_node(types.VariableNode, "$X")
lX = atomspace.add_link(types.ListLink, [X])
Y = atomspace.add_node(types.VariableNode, "$Y")
lY = atomspace.add_link(types.ListLink, [Y])
X_Y = atomspace.add_link(types.ListLink, [X, Y])
full_confidence = TruthValue().confidence_to_count(1)
crisp_true = TruthValue(1, full_confidence)
# Anna smokes.
Anna = atomspace.add_node(types.ConceptNode, "Anna")
smokes = atomspace.add_node(types.PredicateNode, "smokes")
atomspace.add_link(types.EvaluationLink,
[smokes, atomspace.add_link(types.ListLink, [Anna])],
deduction_agent.py instead. """ from __future__ import print_function from pprint import pprint from pln.examples.deduction import deduction_agent from opencog.atomspace import types, AtomSpace, TruthValue __author__ = "Cosmo Harrigan" # Create an AtomSpace with some sample information, equivalent to the # information in atomspace_contents.scm atomspace = AtomSpace() # Basic concepts frog = atomspace.add_node(types.ConceptNode, "Frog", TruthValue(0.01, 100)) intelligent = atomspace.add_node(types.ConceptNode, "Intelligent", TruthValue(0.05, 100)) slimy = atomspace.add_node(types.ConceptNode, "Slimy", TruthValue(0.01, 100)) animal = atomspace.add_node(types.ConceptNode, "Animal", TruthValue(0.1, 100)) being = atomspace.add_node(types.ConceptNode, "Being", TruthValue(0.1, 100)) moves = atomspace.add_node(types.PredicateNode, "Moves", TruthValue(0.1, 100)) # Attributes of frogs atomspace.add_link(types.InheritanceLink, [frog, intelligent], TruthValue(0.2, 100)) atomspace.add_link(types.InheritanceLink, [frog, slimy], TruthValue(0.5, 100)) atomspace.add_link(types.InheritanceLink, [frog, animal], TruthValue(0.9, 100)) # Attributes of animals atomspace.add_link(types.InheritanceLink, [animal, being], TruthValue(0.9, 100)) atomspace.add_link(types.InheritanceLink, [animal, moves], TruthValue(0.9, 100))
