multiLayerPerceptron/NetTest.py at master · WilliamRayJohnson/multiLayerPerceptron · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
'''
@author William Ray Johnson
9/17/17
'''

import unittest

import Net
import Node

class NetTest(unittest.TestCase):

    defaultNet = Net.Net(0, 0, 0, 0.5)

    def setUpExampleNet(self):
        net = Net.Net(2, 2, 2, 0.5)
        net.inputLayer[0].weights = [0.15, 0.25]
        net.inputLayer[1].weights = [0.20, 0.30]
        net.hiddenLayer[0].weights = [0.40, 0.50]
        net.hiddenLayer[0].bias = 0.35
        net.hiddenLayer[1].weights = [0.45, 0.55]
        net.hiddenLayer[1].bias = 0.35
        net.outputLayer[0].bias = 0.60
        net.outputLayer[1].bias = 0.60

        return net

    def testNetInitialization(self):
        net = Net.Net(1, 2, 1, 0.5)

        inNodeOne = net.inputLayer[0]
        hiddenNodeOne = net.hiddenLayer[0]
        hiddenNodeTwo = net.hiddenLayer[1]
        outNodeOne = net.outputLayer[0]

        self.assertEqual(inNodeOne.inNodes, [])
        self.assertEqual(inNodeOne.outNodes[0], hiddenNodeOne)
        self.assertEqual(inNodeOne.outNodes[1], hiddenNodeTwo)

        self.assertEqual(hiddenNodeOne.inNodes[0], inNodeOne)
        self.assertEqual(hiddenNodeTwo.inNodes[0], inNodeOne)
        self.assertEqual(hiddenNodeOne.outNodes[0], outNodeOne)
        self.assertEqual(hiddenNodeTwo.outNodes[0], outNodeOne)

        self.assertEqual(outNodeOne.inNodes[0], hiddenNodeOne)
        self.assertEqual(outNodeOne.inNodes[1], hiddenNodeTwo)
        self.assertEqual(outNodeOne.outNodes, [])

    def testMakeConnections(self):
        nodeOne = Node.Node(0)
        nodeTwo = Node.Node(0)

        self.defaultNet.makeConnections([nodeOne], [nodeTwo])

        self.assertEqual(nodeOne.outNodes[0], nodeTwo)
        self.assertEqual(nodeTwo.inNodes[0], nodeOne)

    def testCalcForwardPass(self):
        net = self.setUpExampleNet()

        net.calcForwardPass([0.05, 0.10])

        x1Value = net.inputLayer[0].value
        x2Value = net.inputLayer[1].value
        h1Value = net.hiddenLayer[0].value
        h2Value = net.hiddenLayer[1].value
        y1Value = net.outputLayer[0].value
        y2Value = net.outputLayer[1].value

        self.assertEqual(x1Value, 0.05)
        self.assertEqual(x2Value, 0.10)
        self.assertEqual(round(h1Value, 4), 0.5933)
        self.assertEqual(round(h2Value, 4), 0.5969)
        self.assertEqual(round(y1Value, 4), 0.7514)
        self.assertEqual(round(y2Value, 4), 0.7729)

    def testCalcError(self):
        net = self.setUpExampleNet()
        net.calcForwardPass([0.05, 0.10])

        net.calcError([0.01, 0.99])

        expectedTotalError = 0.2984
        actualTotalError = net.totalError

        self.assertEqual(round(actualTotalError, 4), expectedTotalError)

    def testCalcSensitivity(self):
        net = self.setUpExampleNet()
        net.calcForwardPass([0.05, 0.10])
        net.calcError([0.01, 0.99])

        net.calcSensitivity([0.01, 0.99])

        w5Sensitivity = net.hiddenLayer[0].sensitivities[0]

        self.assertEqual(round(w5Sensitivity, 4), 0.0822)

    def testUpdateWeights(self):
        net = self.setUpExampleNet()
        net.calcForwardPass([0.05, 0.10])
        net.calcError([0.01, 0.99])
        net.calcSensitivity([0.01, 0.99])

        net.updateWeights()


if __name__ == '__main__':
    unittest.main()