cleanup

sobek/network.py

@@ -51,11 +51,8 @@ class network:
                 self.activations.append(_input)
 
             #activation function application
-            #for i in range(len(_input)):
-            #    _input[i] = network.__sigmoid(_input)
             _input = network.__sigmoid(_input)
 
-            #On peut comparer la performance si on recalcul plus tard
             if (__storeValues): 
                 self.outputs.append(_input)
 
@@ -110,18 +107,14 @@ class network:
                     errorSumsBiases = [np.zeros(layer.shape) for layer in self.biases]
                     self.__errors = [np.zeros(len(layer)) for layer in self.weights]
 
-                    #rempli self.activations et self.outputs
+                    #Rempli self.activations et self.outputs
                     self.process(_input, True)
+
                     self.__desiredOutput = desiredOutput
 
-                    #A optimiser
                     for layerNumber in range(len(errorSumsWeights)-1, -1, -1):
                         for neuronNumber in range(len(errorSumsWeights[layerNumber])):
                             errorSumsBiases[layerNumber][neuronNumber] += self.__Error(layerNumber, neuronNumber)
-                            #for weightNumber in range(len(errorSumsWeights[layerNumber][neuronNumber])):
-                                #print("layer : " + str(layerNumber) + " neuron : " + str(neuronNumber) + " weight : " + str(weightNumber))
-                                #errorSumsWeights[layerNumber][neuronNumber][weightNumber] += self.__PartialDerivative(layerNumber, neuronNumber, weightNumber)
-                                #errorSumsWeights[layerNumber][neuronNumber][weightNumber] = errorSumsBiases[layerNumber][neuronNumber] * self.outputs[layerNumber][weightNumber]
                             errorSumsWeights[layerNumber][neuronNumber] = np.dot(errorSumsBiases[layerNumber][neuronNumber],self.outputs[layerNumber])
 
                 total = 0
@@ -133,27 +126,6 @@ class network:
                     errorSumsBiases[layerNumber] = np.multiply(errorSumsBiases[layerNumber], -(learningRate/len(inputBatch)))
                     self.biases[layerNumber] = np.add(self.biases[layerNumber], errorSumsBiases[layerNumber])
 
-                #print(self.__biases)
-                """
-                
-                for layerNumber in range(len(errorSumsWeights)):
-                        for neuronNumber in range(len(errorSumsWeights[layerNumber])):
-
-                            errorSumsBiases[layerNumber][neuronNumber] = errorSumsBiases[layerNumber][neuronNumber] / len(inputBatch)
-                            total += errorSumsBiases[layerNumber][neuronNumber]
-                            self.biases[layerNumber][neuronNumber] -= learningRate * errorSumsBiases[layerNumber][neuronNumber]
-                            
-                            for weightNumber in range(len(errorSumsWeights[layerNumber][neuronNumber])):
-
-                                #Probablement faisable avec une multiplication de matrices
-                                errorSumsWeights[layerNumber][neuronNumber][weightNumber] = errorSumsWeights[layerNumber][neuronNumber][weightNumber] / len(inputBatch)
-                                
-                                #total += errorSumsWeights[layerNumber][neuronNumber][weightNumber]
-
-                                #Probablement faisable avec une somme de matrices
-                                self.weights[layerNumber][neuronNumber][weightNumber] -= learningRate * errorSumsWeights[layerNumber][neuronNumber][weightNumber]
-
-                #print("Error : " + str(total))"""
         if (visualize):
             ani = animation.ArtistAnimation(fig, vizualisationData, interval=100)
             plt.show()
@@ -172,9 +144,6 @@ class network:
             upperLayerLinksSum += self.weights[layer+1][upperLayerNeuron][neuron] * self.__errors[layer+1][upperLayerNeuron]
         return network.__sigmoid(self.activations[layer][neuron], derivative=True) * upperLayerLinksSum
 
-    #def __PartialDerivative(self, layer, neuron, weight):
-    #    return self.__Error(layer, neuron) * self.outputs[layer][weight]
-
     def accuracy(self, inputs, desiredOutputs):
         if (type(inputs) != list or type(desiredOutputs) != list):
             raise TypeError("The inputs and desired outputs must be lists of numpy arrays !")

test.py

@@ -1,14 +0,0 @@
-import numpy as np
-from sobek.network import network
-
-test = network(16, 16, 8, 4)
-"""
-for y in test.weights:
-    print(y, end="\n\n")
-
-for y in test.biases:
-    print(y, end="\n\n")"""
-
-#print(network.__reLu(8))
-
-print(test.process(np.random.default_rng(42).random((16))))

tests/MNISTDrawingPrediction.py

@@ -1,7 +1,11 @@
 import tkinter
 from PIL import Image, ImageDraw
-from sobek.network import network
 import numpy as np
+from sys import path
+path.insert(1, "..")
+from sobek.network import network
+
+
 
 class Sketchpad(tkinter.Canvas):
     def __init__(self, parent, predictionLabel, **kwargs, ):

tests/MNISTLearning.py

@@ -1,7 +1,10 @@
 import numpy as np
-from sobek.network import network
 import gzip
 import time
+from sys import path
+path.insert(1, "..")
+from sobek.network import network
+
 
 print("--- Data loading ---")
 

tests/MNISTLoadTest.py

@@ -1,6 +1,8 @@
 import numpy as np
-from sobek.network import network
 import gzip
+from sys import path
+path.insert(1, "..")
+from sobek.network import network
 
 print("--- Data loading ---")
 

tests/testLearning.py

@@ -1,5 +1,7 @@
 import numpy as np
 import random
+from sys import path
+path.insert(1, "..")
 from sobek.network import network
 
 random.seed()

tests/testLearningNAND.py

@@ -1,7 +1,9 @@
 import numpy as np
 import random
-from sobek.network import network
 import time
+from sys import path
+path.insert(1, "..")
+from sobek.network import network
 
 random.seed()
 
@@ -33,20 +35,12 @@ for i in range(nbRep):
 
     startTime = time.perf_counter()
 
-    #for j in range(10000):
-    #    inputs = []
-    #    desiredOutputs = []
-        
-        #if (j%1000 == 0):
-        #    print(j)
-        
-    #    myNetwork.train(test, result, learningRate)
-
     myNetwork.train(test, result, learningRate, len(test), 10000, visualize=False)
 
     endTime = time.perf_counter()
     learningTime += endTime - startTime
 learningTime = learningTime / nbRep
+
 test = []
 result = []
 test.append(np.zeros(2))

tests/testNAND.py

@@ -1,5 +1,6 @@
 import numpy as np
-import random
+from sys import path
+path.insert(1, "..")
 from sobek.network import network
 
 myNetwork = network(2, 1)