public NNNeuralNetwork(int nbInputs, int nbOutputs, int[] sizeHL)
{
this.nbOfInputs = nbInputs;
this.nbOfOutputs = nbOutputs;
if (sizeHL == null)
{
this.nbOfHiddenLayers = 0;
}
else
{
this.nbOfHiddenLayers = sizeHL.Length;
}
this.sizeHiddenLayers = sizeHL;
Layers = new List <NNLayer>(nbOfHiddenLayers);
if (sizeHiddenLayers.Length == nbOfHiddenLayers)
{
for (var i = 0; i < nbOfHiddenLayers; i++)
{
var HiddenLayer = new NNLayer(sizeHiddenLayers[i]);
Layers.Add(HiddenLayer);
}
var OutputLayer = new NNLayer(nbOfOutputs);
Layers.Add(OutputLayer);
}
}
private void UpdateWeights(NNNeuralNetwork nn, double[] nnInputs, double learningRate)
{
for (int i = 0; i < nn.nbOfHiddenLayers + 1; i++)
{
NNLayer Layer = nn.Layers[i];
double[] inputs;
// Récupération des inputs du layer
if (i != 0)
{
inputs = new double[nn.Layers[i - 1].nbOfNeurons];
for (int j = 0; j < nn.Layers[i - 1].nbOfNeurons; j++)
{
inputs[j] = nn.Layers[i - 1].Neurons[j].output;
}
}
else
{
inputs = nnInputs;
}
// Mise à jour des poids de chaque neurone du layer
Layer.Neurons.ForEach(Neuron =>
{
for (int j = 0; j < inputs.Length; j++)
{
Neuron.weights[j] += learningRate * Neuron.delta * inputs[j];
}
Neuron.w0 += learningRate * Neuron.delta;
});
}
}
private int BackwardPropagateError(NNNeuralNetwork nn, double[] expected)
{
if (nn.nbOfOutputs == expected.Length)
{
// Parcours inverse des layers
for (int i = nn.nbOfHiddenLayers; i >= 0; i--)
{
NNLayer Layer = nn.Layers[i];
double[] errors = new double[Layer.nbOfNeurons];
// Si ce n'est pas le dernier layer
if (i != nn.nbOfHiddenLayers)
{
// Parcours des neurones du layer courant
// Calcul de l'erreur
for (int j = 0; j < Layer.nbOfNeurons; j++)
{
var error = 0.0;
// Parcours des neurones du layers précédent
nn.Layers[i + 1].Neurons.ForEach(Neuron => {
error += Neuron.weights[j] * Neuron.delta;
});
errors[i] = error;
}
}
// Si c'est le dernier layer
else
{
// Parcours des neurones du layer courant
// Calcul de l'erreur
for (int j = 0; j < Layer.nbOfNeurons; j++)
{
errors[j] = (expected[j] - Layer.Neurons[j].output);
}
}
// Parcours des neurones du layer courant
// Calcul de delta
for (int j = 0; j < Layer.nbOfNeurons; j++)
{
NNNeuron Neuron = Layer.Neurons[j];
Neuron.delta = errors[j] * NNNeuron.TransfertDerivative(Neuron.output);
}
}
return(0);
}
else
{
return(1);
}
}