internal void AdjustWeights(DataPoint _point, double _learningRate)
        {
            // P : point testé et le taux d’apprentissage.

            // Deltas pour les sorties
            double[] outputDeltas = new double[nbOutputs]; // Tableau des deltas  des différents neurones de sortie.
            for (int i = 0; i < nbOutputs; i++)
            {
                // Pour chaque neurone de sortie.
                double output         = outputNeurons[i].Output;                     // Sortie Obtenue suit au calcul.
                double expectedOutput = _point.Outputs[i];                           // Sortie Attendue.
                outputDeltas[i] = output * (1 - output) * (expectedOutput - output); // Calcul du deltas
            }

            // Deltas pour les neurones cachés
            double[] hiddenDeltas = new double[nbHidden];             // Tableau des deltas  des différents neurones cachés.
            for (int i = 0; i < nbHidden; i++)
            {
                // pour chaque neurones cachés.
                double hiddenOutput = hiddenNeurons[i].Output; // Sortie Obtenue suit au calcul.
                double sum          = 0.0;
                for (int j = 0; j < nbOutputs; j++)
                {
                    // Pour chaque neurones de sorties reliés au neurones cachés courant.
                    sum += outputDeltas[j] * outputNeurons[j].Weight(i);
                    // Sum = deltasSorties[j] * Weight[i-j]. (i : neurones cachés courants,j : neurones de sortie).
                }
                hiddenDeltas[i] = hiddenOutput * (1 - hiddenOutput) * sum; // Calcul du deltas.
            }

            double value;

            // Ajustement des poids des neurones de sortie
            for (int i = 0; i < nbOutputs; i++)
            {
                Neuron outputNeuron = outputNeurons[i];
                for (int j = 0; j < nbHidden; j++)
                {
                    value = outputNeuron.Weight(j) + _learningRate * outputDeltas[i] * hiddenNeurons[j].Output;
                    // wi += taux * di * oi
                    outputNeuron.AdjustWeight(j, value);
                }
                // Et biais
                value = outputNeuron.Weight(nbHidden) + _learningRate * outputDeltas[i] * 1.0;
                outputNeuron.AdjustWeight(nbHidden, value);
            }

            // Ajustement des poids des neurones cachés
            for (int i = 0; i < nbHidden; i++)
            {
                Neuron hiddenNeuron = hiddenNeurons[i];
                for (int j = 0; j < nbInputs; j++)
                {
                    value = hiddenNeuron.Weight(j) + _learningRate * hiddenDeltas[i] * _point.Inputs[j];
                    //wi += taux * di * xi
                    hiddenNeuron.AdjustWeight(j, value);
                }
                // Et biais
                value = hiddenNeuron.Weight(nbInputs) + _learningRate * hiddenDeltas[i] * 1.0;
                hiddenNeuron.AdjustWeight(nbInputs, value);
            }
        }