Universal-Neural-Network

1
import unittest
2

3
from libUNN.neuralNetwork.neuralNetwork import *
4
from libUNN.core.functions import *
5

6

7
class NeuralNetworkTest(unittest.TestCase):
8
    def testCalculate(self):
9
        n = NeuralNetwork()
10
        n.layers.addInputNeural()
11
        n.layers.addInputNeural()
12
        n.layers.addLayers()
13

14
        r1 = sigmoid(n.layers.neural(1, 0).weight(0) + n.layers.neural(1, 0).weight(1) + n.layers.neural(1, 0).weight(2))
15
        result = sigmoid(r1 * n.layers.neural(2, 0).weight(0))
16

17
        self.assertEqual(result, n.calculate([1, 1, 1])[0][0])
18

19
    def testInput(self):
20
        n = NeuralNetwork()
21
        n.layers.addInputNeural()
22
        n.layers.addLayers()
23

24
        self.assertEqual(list(n.calculate(np.array([0, 0]))),
25
                         list(n.calculate([[0, 0]])),
26
                         "Should be Equal")
27

28
        self.assertEqual(list(n.calculate(np.array([1, 1]))),
29
                         list(n.calculate([1, 1])),
30
                         "Should be Equal")
31

32
        self.assertEqual(list(n.calculate(np.array([[1, 1]]))),
33
                         list(n.calculate([[1, 1]])),
34
                         "Should be Equal")
35

36
        self.assertEqual(list(n.calculate(np.array([[1, 1], [0, 0]]))),
37
                         list(n.calculate([[1, 1], [0, 0]])),
38
                         "Should be Equal")
39

40
        self.assertEqual(n.calculate(np.array([0, 0, 0])), None,
41
                         "Should be None")
42
        self.assertEqual(n.calculate([0, 0, 0]), None,
43
                         "Should be None")
44
        self.assertEqual(n.calculate(np.array([1])), None,
45
                         "Should be None")
46
        self.assertEqual(n.calculate([1]), None,
47
                         "Should be None")
48
        self.assertEqual(n.calculate(np.array([[1]])), None,
49
                         "Should be None")
50
        self.assertEqual(n.calculate([[1]]), None,
51
                         "Should be None")
52

53
    def testCopy(self):
54
        n = NeuralNetwork()
55
        n.layers.addInputNeural()
56
        n.layers.addLayers(2)
57
        n.layers.addNeural(1)
58
        n2 = n.copy()
59
        self.assertEqual(n.structure(), n2.structure())
60

61
    def testAdd(self):
62
        n = NeuralNetwork()
63
        self.assertTrue(n.layers.addLayers())
64
        self.assertTrue(n.layers.addLayers())
65
        self.assertTrue(n.layers.addNeural(0))
66
        self.assertTrue(n.layers.addNeural(1))
67
        self.assertTrue(n.layers.addNeural(2))
68
        self.assertTrue(n.layers.addNeural(3))
69
        self.assertFalse(n.layers.addNeural(4))
70

71
    def testRemove(self):
72
        n = NeuralNetwork()
73
        self.assertTrue(n.layers.addLayers())
74
        self.assertTrue(n.layers.addLayers())
75

76
        self.assertTrue(n.layers.removeLayer(1))
77
        self.assertFalse(n.layers.removeLayer(4))
78

79
        self.assertTrue(n.layers.deleteNeural(1, 0))
80
        self.assertFalse(n.layers.deleteNeural(6, 0))
81

82
    def testSetStructure(self):
83
        n = NeuralNetwork()
84
        structure = [1, 1, 1]
85
        n.createStructure(structure)
86
        self.assertEqual(n.structure(), [1, 1, 1], "Should be [1, 1, 1]")
87

88
        structure = [0, 1, 0]
89
        n.createStructure(structure)
90
        self.assertEqual(n.structure(), [1, 1, 1], "Should be [1, 1, 1]")
91

92
        structure = [0, 1, 0]
93
        n.createStructure(structure)
94
        self.assertEqual(n.structure(), [1, 1, 1], "Should be [1, 1, 1]")
95

96
        structure = [0, 0]
97
        n.createStructure(structure)
98
        self.assertEqual(n.structure(), [1, 1], "Should be [1, 1]")
99

100
        structure = [0, 4, 4, 5, 0]
101
        n.createStructure(structure)
102
        self.assertEqual(n.structure(), [1, 4, 4, 5, 1], "Should be [1, 4, 4, 5, 1]")
103

104
        structure = [0]
105
        self.assertFalse(n.createStructure(structure))
106

107
        structure = [0, 0, 0, 0]
108
        self.assertFalse(n.createStructure(structure))
109

110
        structure = [0, 4, 0, 5, 0]
111
        self.assertFalse(n.createStructure(structure))
112

113
        structure = [0, -1, 4, 5, 0]
114
        self.assertFalse(n.createStructure(structure))
115

116
    def testStructure(self):
117
        n = NeuralNetwork()
118
        self.assertEqual(n.structure(), [1, 1], "Should be Equal [1, 1]")
119
        n.layers.addLayers()
120
        self.assertEqual(n.structure(), [1, 1, 1], "Should be Equal [1, 1, 1]")
121
        n.layers.addNeural(1)
122
        self.assertEqual(n.structure(), [1, 2, 1], "Should be Equal [1, 2, 1]")
123
        n.layers.addNeural(1)
124
        self.assertEqual(n.structure(), [1, 3, 1], "Should be Equal [1, 3, 1]")
125
        n.layers.addInputNeural()
126
        self.assertEqual(n.structure(), [2, 3, 1], "Should be Equal [2, 3, 1]")
127
        n.layers.addOutputNeural()
128
        self.assertEqual(n.structure(), [2, 3, 2], "Should be Equal [2, 3, 2]")
129
        n.layers.addLayers()
130
        self.assertEqual(n.structure(), [2, 3, 1, 2], "Should be Equal [2, 3, 1, 2]")
131

132
    def testSave(self):
133
        n = NeuralNetwork()
134
        n.layers.addInputNeural()
135
        n.layers.addInputNeural()
136
        file = os.getcwd() + '/neural.nn'
137
        self.assertTrue(n.save(file))
138

139
        with open(file) as f:
140
            self.assertEqual(n.weights(), json.load(f))
141
        os.remove(file)
142

143
        failFile2 = 'dont.txt'
144
        self.assertFalse(n.save(failFile2))
145

146
    def testLoad(self):
147
        n = NeuralNetwork()
148
        n.layers.addInputNeural()
149
        n.layers.addInputNeural()
150
        file = os.getcwd() + '/neural.nn'
151
        self.assertTrue(n.save(file))
152

153
        n2 = NeuralNetwork(file)
154
        self.assertEqual(n2.weights(), n.weights())
155
        os.remove(file)
156

157
        failFile = 'dont.nn'
158
        failFile2 = 'dont.txt'
159
        self.assertFalse(n2.load(failFile))
160
        self.assertFalse(n2.load(failFile2))
161

162

163
if __name__ == '__main__':
164
    unittest.main()
165