def test_add_node(self):
layer = Layer(0, 'input')
layer.default_activation_type = 'linear'
node = Node()
layer.add_node(node)
self.assertEqual(1, layer.total_nodes())
self.assertEqual(0, layer.nodes[0].node_no)
self.assertEqual('linear', layer.nodes[0].get_activation_type())
layer.default_activation_type = 'sigmoid'
node = Node()
layer.add_node(node)
self.assertEqual(2, layer.total_nodes())
self.assertEqual(1, layer.nodes[1].node_no)
self.assertEqual('sigmoid', layer.nodes[1].get_activation_type())
node = BiasNode()
layer.add_node(node)
self.assertEqual(3, layer.total_nodes())
self.assertEqual(2, layer.nodes[2].node_no)
node = Node()
node.set_activation_type('tanh')
layer.add_node(node)
self.assertEqual('tanh', layer.nodes[3].get_activation_type())
def test_add_input_connection(self):
connections = len(self.node.input_connections)
self.node.add_input_connection(Connection(ProtoNode(), self.node))
self.assertEqual(connections + 1, len(self.node.input_connections))
self.failUnlessRaises(ValueError, self.node.add_input_connection,
Connection(Node(), Node()))
def setUp(self):
self.upper_node = Node()
self.lower_node = Node()
self.upper_node._value = .2
self.lower_node._value = .1
self.upper_node.error = .8
self.conn = Connection(self.lower_node, self.upper_node)
def test_unconnected_nodes(self):
layer = Layer(1, 'hidden')
conn = Connection(Node(), Node())
layer.add_nodes(2, 'hidden')
layer.nodes[0].add_input_connection(Connection(Node(), layer.nodes[0]))
input_side = layer.unconnected_nodes()
self.assertEqual(1, input_side[0])
self.assertNotEqual(0, input_side[0])
def test_fully_connect(self):
node = Node()
unode1 = Node()
unode2 = Node()
self.rec_config._fully_connect(node, [unode1, unode2])
conn = unode1.input_connections[0]
self.assertEqual(node, conn.lower_node)
self.assertEqual(unode1, conn.upper_node)
conn = unode2.input_connections[0]
self.assertEqual(node, conn.lower_node)
self.assertEqual(unode2, conn.upper_node)
def test_load_source_value(self):
self.node._value = .25
self.node._existing_weight = .25
self.node._incoming_weight = .5
source_node = Node()
source_node.set_value(.3)
source_node.set_activation_type(ACTIVATION_SIGMOID)
self.node.set_source_node(source_node)
# activate
self.node._source_type = 'a'
self.node.load_source_value()
self.assertAlmostEqual(sigmoid(.3) * .5 + .25 * .25, self.node._value)
# value
self.node._value = .25
self.node._source_type = 'v'
self.node.load_source_value()
self.assertAlmostEqual(.3 * .5 + .25 * .25, self.node._value)
# invalid source type
self.node._source_type = 'f'
self.failUnlessRaises(ValueError, self.node.load_source_value)
def _parse_inputfile_node(config, node_id):
"""
This function receives a node id, parses it, and returns the node in
the network to which it pertains. It implies that the network
structure must already be in place for it to be functional.
"""
activation_type = config.get(node_id, 'activation_type')
node_type = config.get(node_id, 'node_type')
if node_type == NODE_BIAS:
node = BiasNode()
elif node_type == NODE_COPY:
node = CopyNode()
node._source_type = config.get(node_id, 'source_type')
node._incoming_weight = float(
config.get(node_id, 'incoming_weight'))
node._existing_weight = float(
config.get(node_id, 'existing_weight'))
node.set_activation_type(activation_type)
else:
node = Node()
node.set_activation_type(activation_type)
node.node_type = node_type
return node
def setUp(self):
self.node = Node()
node1 = Node()
node2 = Node()
node1._value = .2
node2._value = .1
node1.error = .8
node2.error = .4
node1.set_activation_type(ACTIVATION_SIGMOID)
node2.set_activation_type(ACTIVATION_SIGMOID)
self.node.add_input_connection(Connection(node1, self.node, .3))
self.node.input_connections.append(Connection(node2, self.node, .7))
def add_nodes(self, number_nodes, node_type, activation_type=None):
"""
This function adds nodes in bulk for initialization.
If an optional activation type is passed through, that will be set for
the nodes. Otherwise, the default activation type for the layer will
be used.
"""
count = 0
while count < number_nodes:
if node_type == 'copy':
node = CopyNode()
else:
node = Node(node_type)
if activation_type:
node.set_activation_type(activation_type)
self.add_node(node)
count += 1
def test_get_source_node(self):
self.node._source_node = Node()
self.assertEqual(self.node._source_node, self.node.get_source_node())
def test_set_source_node(self):
source_node = Node()
self.node.set_source_node(source_node)
self.assertEqual(source_node, self.node._source_node)
def test__init__(self):
self.node = Node('test')
self.assertEqual('test', self.node.node_type)
