Example #1
0
    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)
Example #2
0
    def test__feed_forward(self):

        #   simplify activations
        self.net.layers[0].set_activation_type('sigmoid')
        self.net.layers[1].set_activation_type('sigmoid')
        self.net.layers[2].set_activation_type('sigmoid')

        #   These values should be replaced
        self.net.layers[1].nodes[0].set_value(1000.0)
        self.net.layers[2].nodes[0].set_value(1000.0)

        self.assertEqual(1000.0, self.net.layers[1].nodes[0].get_value())
        self.assertEqual(1000.0, self.net.layers[2].nodes[0].get_value())

        self.net.layers[0].load_inputs([.2])

        self.net._feed_forward()

        self.assertEqual(.2, self.net.layers[0].nodes[0].get_value())
        self.assertEqual(
            sigmoid(.2) * 1.0, self.net.layers[1].nodes[0].get_value())

        self.assertEqual(
            sigmoid(sigmoid(.2) * 1.0) * .75,
            self.net.layers[2].nodes[0].get_value())
Example #3
0
    def test_feed_forward(self) :

        layer0 = Layer(0, 'input')
        layer0.add_nodes(2, 'input')
        layer0.set_activation_type('sigmoid')

        layer1 = Layer(1, 'hidden')
        layer1.add_nodes(1, 'hidden')

        inode1 = layer0.nodes[0]
        inode2 = layer0.nodes[1]

        inode1.set_value(.25)
        inode2.set_value(.5)

        node = layer1.nodes[0]
        node.add_input_connection(
            Connection(inode1, node, .25))
        node.add_input_connection(
            Connection(inode2, node, .5))

        layer1.feed_forward()

        self.assertAlmostEqual(
            sigmoid(.25) * .25 + sigmoid(.5) * .5, node.get_value())
    def test__feed_forward(self):

        #   simplify activations
        self.net.layers[0].set_activation_type('sigmoid')
        self.net.layers[1].set_activation_type('sigmoid')
        self.net.layers[2].set_activation_type('sigmoid')

        #   These values should be replaced
        self.net.layers[1].nodes[0].set_value(1000.0)
        self.net.layers[2].nodes[0].set_value(1000.0)

        self.assertEqual(1000.0, self.net.layers[1].nodes[0].get_value())
        self.assertEqual(1000.0, self.net.layers[2].nodes[0].get_value())

        self.net.layers[0].load_inputs([.2])

        self.net._feed_forward()

        self.assertEqual(.2, self.net.layers[0].nodes[0].get_value())
        self.assertEqual(
                sigmoid(.2) * 1.0,
                self.net.layers[1].nodes[0].get_value())

        self.assertEqual(
                sigmoid(sigmoid(.2) * 1.0) * .75,
                self.net.layers[2].nodes[0].get_value())
Example #5
0
    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)
Example #6
0
    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)
Example #7
0
    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)