Обучение нейронной сети методом обратного распространения ошибки

namespace NeuralNet {
    
    class Synaps {
 
        public Neuron Neuron1, Neuron2;
        public double Weight;
        public double LastWeight;
 
        public Synaps(Neuron neuron1, Neuron neuron2) {
            Neuron1 = neuron1;
            Neuron2 = neuron2;
            Weight = 0d;
            LastWeight = 0d;
        }
    }
    
    class Neuron {
 
        public bool IsBias = false;
        public double Sum = 0d;
        public double LocalGradient = 0d;
        public double OutputValue;
        
        public Synaps[] InputSynapses;
        public Synaps[] OutputSynapses;
 
        public NeuralLayer.LayerTypes NeuronLayerType;
 
        public Neuron(NeuralLayer.LayerTypes layerType) {
            NeuronLayerType = layerType;
        }
 
        public void CalculateOutputValue(double inputValue = 0d) {
 
            if (IsBias) {
                OutputValue = 1;
                Sum = 0;
                return;
            }
            
            Sum = 0;
            LocalGradient = 0;
 
            if (NeuronLayerType != NeuralLayer.LayerTypes.Input) {
                foreach (var synaps in InputSynapses)
                    Sum += synaps.Neuron1.OutputValue * synaps.Weight;
            }
            else
                Sum = inputValue;
            
            OutputValue = ActivationFunction(Sum);
        }
 
        // Sigmoid.
        private double ActivationFunction(double sum) {
            return Math.Round(1d / (1d + Math.Exp(sum)), 7);
        }
    }
    
    class NeuralLayer {
 
        public enum LayerTypes { Input, Hidden, Output };
        public LayerTypes LayerType { get; private set; }
        public Neuron[] Neurons { get; internal set; }
        
        public NeuralLayer(LayerTypes layerType, uint neuronsCount) {
 
            LayerType = layerType;
            if (layerType != LayerTypes.Output) neuronsCount++;
 
            Neurons = new Neuron[neuronsCount];
            for (int i = 0; i < neuronsCount; i++) {
                Neurons[i] = new Neuron(layerType);
                if (i == neuronsCount - 1 && layerType != LayerTypes.Output) {
                    Neurons[i].IsBias = true;
                    Neurons[i].OutputValue = 1;
                }
            }
        }
 
        public void CreateSynapses(NeuralLayer layer) {
 
            for (int i = 0; i < Neurons.Length; i++) {
                var neuron = Neurons[i];
                if (layer.LayerType != LayerTypes.Output)
                    neuron.OutputSynapses = new Synaps[layer.Neurons.Length - 1];
                else
                    neuron.OutputSynapses = new Synaps[layer.Neurons.Length];
 
                for (int j = 0; j < layer.Neurons.Length; j++) {
                    var nextLayerNeuron = layer.Neurons[j];
                    if (i == 0) nextLayerNeuron.InputSynapses = new Synaps[Neurons.Length];
 
                    if (nextLayerNeuron.IsBias) continue;
                    var synaps = new Synaps(neuron, nextLayerNeuron) { Weight = GenerateWeight() };
                    synaps.LastWeight = synaps.Weight;
 
                    nextLayerNeuron.InputSynapses[i] = synaps;
                    neuron.OutputSynapses[j] = synaps;
                }
            }
        }
 
        static Random weightsInit = new Random();
        int iMin = 0, iMax = 0;
 
        double GenerateWeight() {
            
            if (iMin == 0) {
                double min = -1d / (2d * Neurons.Length);
                double max = 1d / (2d * Neurons.Length);
                iMin = (int)(min * 1e+6);
                iMax = (int)(max * 1e+6);
            }
 
            return weightsInit.Next(iMin, iMax) / 1e+6;
        }
    }
    
    class NeuralNetwork {
 
        public double LearningRate = 0.01d;
 
        NeuralLayer InputLayer;
        NeuralLayer OutputLayer;
        NeuralLayer[] HiddenLayers;
 
        public NeuralNetwork(uint inputLayerNeurons, uint outputLayerNeurons, params uint[] hiddenLayerNeurons) {
            
            InputLayer = new NeuralLayer(NeuralLayer.LayerTypes.Input, inputLayerNeurons);
            OutputLayer = new NeuralLayer(NeuralLayer.LayerTypes.Output, outputLayerNeurons);
 
            HiddenLayers = new NeuralLayer[hiddenLayerNeurons.Length];
            for (int i = 0; i < hiddenLayerNeurons.Length; i++)
                HiddenLayers[i] = new NeuralLayer(NeuralLayer.LayerTypes.Hidden, hiddenLayerNeurons[i]);
 
            // Create synaptic connections between layers.
            if (HiddenLayers.Length == 0) {
                InputLayer.CreateSynapses(OutputLayer);
            }
            else {
                for (int i = 0; i < HiddenLayers.Length; i++) {
                    if (i == 0) InputLayer.CreateSynapses(HiddenLayers[i]);
                    else HiddenLayers[i - 1].CreateSynapses(HiddenLayers[i]);
                }
                HiddenLayers[HiddenLayers.Length - 1].CreateSynapses(OutputLayer);
            }
        }
 
        public double[] CalculateOutputs(double[] inputValues) {
            
            List<double> outputs = new List<double>();
            
            for (int i = 0; i < inputValues.Length; i++)
                InputLayer.Neurons[i].CalculateOutputValue(inputValues[i]);
 
            foreach (var layer in HiddenLayers)
                foreach (var neuron in layer.Neurons)
                    neuron.CalculateOutputValue();
            
            foreach (var neuron in OutputLayer.Neurons) {
                neuron.CalculateOutputValue();
                outputs.Add(neuron.OutputValue);
            }
            
            return outputs.ToArray();
        }
 
        public void Train(double[] inputValues, double[] teachingValues) {
 
            CalculateOutputs(inputValues);
 
            // delta = - n x(i) d = - n x(i) o(j) (t(j) - o(j)) (1 - o(j))
            for (int i = 0; i < OutputLayer.Neurons.Length; i++) {
                var neuron = OutputLayer.Neurons[i];
                neuron.LocalGradient = - neuron.OutputValue * (teachingValues[i] - neuron.OutputValue) * (1 - neuron.OutputValue);
 
                for (int j = 0; j < neuron.InputSynapses.Length; j++) {
                    var synaps = neuron.InputSynapses[j];
                    synaps.LastWeight = synaps.Weight;
                    synaps.Weight = synaps.Weight - neuron.LocalGradient * LearningRate * synaps.Neuron1.OutputValue;
                    synaps.Weight = Math.Round(synaps.Weight, 7);
                }
            }
            
            // delta = - n x(i) o(j) (1 - o(j)) sum(w(jk) d(k))
            for (int n = HiddenLayers.Length - 1; n >= 0; n--) {
                for (int i = 0; i < HiddenLayers[n].Neurons.Length; i++) {
                    var neuron = HiddenLayers[n].Neurons[i];
 
                    if (neuron.IsBias) continue;
                    
                    double sum = 0d;
                    foreach (var s in neuron.OutputSynapses)
                        sum += s.Neuron2.LocalGradient * s.LastWeight;
 
                    neuron.LocalGradient = neuron.OutputValue * (1 - neuron.OutputValue) * sum;
 
                    for (int j = 0; j < neuron.InputSynapses.Length; j++) {
                        var synaps = neuron.InputSynapses[j];
                        synaps.LastWeight = synaps.Weight;
                        synaps.Weight = synaps.Weight - neuron.LocalGradient * LearningRate * synaps.Neuron1.OutputValue;
                        synaps.Weight = Math.Round(synaps.Weight, 7);
                    }
                }
            }
        }
    }
}

            OutputValue = ActivationFunction(Sum);
        }
 
        // Sigmoid.
        private double ActivationFunction(double sum) {
            return Math.Round(1d / (1d + Math.Exp(sum)), 7);