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_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_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 _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 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 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 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))
class NodeTest(unittest.TestCase):
"""
Tests 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 test_set_activation_type(self):
self.node._activate = 'error'
self.node._error_func = 'error'
self.node._activation_type = 'error'
self.node.set_activation_type(ACTIVATION_SIGMOID)
self.assertEqual(sigmoid, self.node._activate)
self.assertEqual(sigmoid_derivative, self.node._error_func)
self.assertEqual(ACTIVATION_SIGMOID, self.node._activation_type)
self.node._activate = 'error'
self.node._error_func = 'error'
self.node._activation_type = 'error'
self.node.set_activation_type(ACTIVATION_TANH)
self.assertEqual(tanh, self.node._activate)
self.assertEqual(tanh_derivative, self.node._error_func)
self.assertEqual(ACTIVATION_TANH, self.node._activation_type)
self.node._activate = 'error'
self.node._error_func = 'error'
self.node._activation_type = 'error'
self.node.set_activation_type(ACTIVATION_LINEAR)
self.assertEqual(linear, self.node._activate)
self.assertEqual(linear_derivative, self.node._error_func)
self.assertEqual(ACTIVATION_LINEAR, self.node._activation_type)
self.failUnlessRaises(ValueError, self.node.set_activation_type,
'error')
def test_set_error_func(self):
self.node._error_func = 'error'
self.node._set_error_func(ACTIVATION_SIGMOID)
self.assertEqual(sigmoid_derivative, self.node._error_func)
self.node._error_func = 'error'
self.node._set_error_func(ACTIVATION_TANH)
self.assertEqual(tanh_derivative, self.node._error_func)
self.node._error_func = 'error'
self.node._set_error_func(ACTIVATION_LINEAR)
self.assertEqual(linear_derivative, self.node._error_func)
def test_set_value(self):
self.node._value = .2
self.node.set_value(.3)
self.assertAlmostEqual(.3, self.node._value)
def test_get_value(self):
self.node._value = .2
self.assertAlmostEqual(.2, self.node.get_value())
def test_error_func(self):
self.node.set_activation_type(ACTIVATION_SIGMOID)
self.assertAlmostEqual(sigmoid_derivative(.2),
self.node.error_func(.2))
def test_feed_forward(self):
self.node_value = 1000.0
self.node.feed_forward()
total = sigmoid(.2) * .3 + sigmoid(.1) * .7
self.assertAlmostEqual(total, self.node._value)
def test__init__(self):
self.node = Node('test')
self.assertEqual('test', self.node.node_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 test_update_error(self):
# upper_node1.error = .8
# upper_node2.error = .4
# conn1 weight = .3
# conn2 weight = .7
self.node.node_type = NODE_OUTPUT
self.node.set_activation_type(ACTIVATION_SIGMOID)
halt_on_extremes = True
self.node._value = .4
self.node.target = .55
self.node.error = 0.0
self.node.update_error(halt_on_extremes)
self.assertAlmostEqual(.55 - sigmoid(.4), self.node.error)
#
self.node.node_type = NODE_HIDDEN
self.node.set_activation_type(ACTIVATION_SIGMOID)
halt_on_extremes = True
self.node._value = .4
self.node.error = .55
self.node.update_error(halt_on_extremes)
self.assertAlmostEqual(.55 * sigmoid_derivative(sigmoid(.4)),
self.node.error)
def test__update_lower_node_errors(self):
self.node.error = .55
halt_on_extremes = True
node1 = self.node.input_connections[0].lower_node
node2 = self.node.input_connections[1].lower_node
node1.error = 0.0
node2.error = 0.0
self.node._update_lower_node_errors(halt_on_extremes)
self.assertAlmostEqual(.3 * .55,
self.node.input_connections[0].lower_node.error)
self.assertAlmostEqual(.7 * .55,
self.node.input_connections[1].lower_node.error)
def test_adjust_weights(self):
learnrate = .35
halt_on_extremes = True
self.node.error = .9
self.node.set_activation_type(ACTIVATION_SIGMOID)
# adjusts incoming values
conn1 = .3 + .35 * sigmoid(.2) * .9
conn2 = .7 + .35 * sigmoid(.1) * .9
self.node.adjust_weights(learnrate, halt_on_extremes)
self.assertAlmostEqual(conn1, self.node.input_connections[0]._weight)
self.assertAlmostEqual(conn2, self.node.input_connections[1]._weight)
def test__adjust_weight(self):
# learnrate = .20
# activate_value = .25
# error = .10
self.assertAlmostEqual(.20 * .25 * .10,
self.node._adjust_weight(.20, .25, .10))
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)