blusson/PT21-22-Reseau-Neurones
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

des résultats, mais faux

Browse Source
This commit is contained in:
eynard
2021-12-16 17:06:51 +01:00
parent a8a8edac7c
commit 8189a03abf
5 changed files with 231 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
sobek/network.py
View File

@@ -1,4 +1,5 @@
import numpy as np
import math
class network:
@@ -10,7 +11,7 @@ class network:
self.__inputLayerSize = inputLayerSize
oldLayerSize = inputLayerSize
for layerSize in layerSizes:
self.__weights.append( np.random.default_rng(42).random((oldLayerSize, layerSize)) )
self.__weights.append( np.random.random((layerSize, oldLayerSize)) )
oldLayerSize = layerSize
self.__biases = [[0]*layerSize for layerSize in layerSizes]
self.__weights = np.array(self.__weights, dtype=object)
@@ -24,7 +25,7 @@ class network:
def __sigmoid(value, derivative=False):
if (derivative):
return network.__sigmoid(value) * (1 - network.__sigmoid(value))
return 1/(1+np.exp(-value))
return 1/(1+math.exp(-value))
def process(self, _input, __storeValues=False):
if type(_input) != np.ndarray:
@@ -35,61 +36,70 @@ class network:
# raise TypeError("The input vector must contain floats!")
if (__storeValues):
self.activations = np.array([])
self.outputs = np.array([])
self.activations = []
self.outputs = []
for layerWeights, bias in zip(self.__weights, self.__biases):
_input = np.matmul(_input, layerWeights)
_input = np.matmul(layerWeights, _input)
_input = np.add(_input, bias)
if (__storeValues):
print("-------------------")
print(bias)
print("-------------------")
self.activations = np.append(self.activations, _input)
self.activations[len(self.activations)-1] = np.insert(self.activations[len(self.activations)-1], 0, bias)
self.activations.append(_input.copy())
#reLu application
with np.nditer(_input, op_flags=['readwrite'], flags=['refs_ok']) as layer:
for neuron in layer:
neuron = network.__reLu(neuron)
for neuron in range(len(_input)):
_input[neuron] = network.__sigmoid(_input[neuron])
#On peut comparer la performance si on recalcul plus tard
if (__storeValues):
self.outputs = np.append(self.outputs, _input)
self.outputs[len(self.outputs)-1] = np.insert(self.outputs[len(self.outputs)-1], 0, 1)
self.outputs.append(_input.copy())
self.activations = np.array(self.activations, dtype=object)
self.outputs = np.array(self.outputs, dtype=object)
return _input
def train(self, inputs, desiredOutputs, learningRate):
ErrorSums = [[0]*(len(layer)+1) for layer in self.__biases]
errorSums = [[[0]*(len(neuron)) for neuron in layer] for layer in self.__weights]
self.__errors = [[0]*(len(layer)) for layer in self.__weights]
for _input, desiredOutput in zip(inputs, desiredOutputs):
self.__output = self.process(_input, True)
self.__desiredOutput = desiredOutput
for layerNumber in range(len(ErrorSums)-1, -1, -1):
ErrorSums[layerNumber][0] += self.__partialDerivative(layerNumber, 0)
for neuronNumber in range(1, len(ErrorSums[layerNumber])):
print("layer : " + str(layerNumber) + " neuron : " + str(neuronNumber))
ErrorSums[layerNumber][neuronNumber] += self.__partialDerivative(layerNumber, neuronNumber)
for i in range(len(ErrorSums)):
for j in range(len(ErrorSums[i])):
ErrorSums[i][j] = 1 / ErrorSums[i][j]
self.__biases[i, j] -= learningRate * ErrorSums[i][j]
for layerNumber in range(len(errorSums)-1, -1, -1):
for neuronNumber in range(len(errorSums[layerNumber])):
for weightNumber in range(len(errorSums[layerNumber][neuronNumber])):
#print("layer : " + str(layerNumber) + " neuron : " + str(neuronNumber) + " weight : " + str(weightNumber))
errorSums[layerNumber][neuronNumber][weightNumber] += self.__partialDerivative(layerNumber, neuronNumber, weightNumber)
total = 0
for i in range(len(errorSums)):
for j in range(len(errorSums[i])):
for k in range(len(errorSums[i][j])):
errorSums[i][j][k] = errorSums[i][j][k] / len(inputs)
total += errorSums[i][j][k]
self.__weights[i][j][k] -= learningRate * errorSums[i][j][k]
print("Error : " + str(total))
def __Error(self, layer, neuron):
return self.__ErrorFinalLayer(neuron) if (layer == len(self.__weights)-1) else self.__ErrorHiddenLayer(layer, neuron)
if (self.__errors[layer][neuron] == 0 ):
self.__errors[layer][neuron] = self.__ErrorFinalLayer(neuron) if (layer == len(self.__weights)-1) else self.__ErrorHiddenLayer(layer, neuron)
return self.__errors[layer][neuron]
def __ErrorFinalLayer(self, neuron):
print(self.activations)
return network.__reLu(self.activations[len(self.activations)-1][neuron], True) * (self.__output[neuron] - self.__desiredOutput[neuron])
return network.__sigmoid(self.activations[len(self.activations)-1][neuron], True) * (self.__output[neuron] - self.__desiredOutput[neuron])
def __ErrorHiddenLayer(self, layer, neuron):
upperLayerLinksSum = 0
for upperLayerNeuron in range(len(self.__weights[layer+1]-1)):
#A comparer avec un acces direct au erreurs precalcules
upperLayerLinksSum += self.__weights[layer+1][upperLayerNeuron][neuron] * self.__Error(layer+1, neuron)
return network.__reLu(self.activations[layer][neuron], True) * upperLayerLinksSum
return network.__sigmoid(self.activations[layer][neuron], True) * upperLayerLinksSum
def __partialDerivative(self, layer, neuron):
return self.__Error(layer, neuron) * self.outputs[layer][neuron]
def __partialDerivative(self, layer, neuron, weight):
return self.__Error(layer, neuron) * self.outputs[layer-1][weight]