Не работает процедура обучения нейронной сети

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Diagnostics;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
 
namespace MyANN_Lybrary_Test
{
    [Serializable()]
    public class NNetwork
    {
        [Serializable()]
        public class Neuron
        {
            public double[] Inputs;
            public double Output;
            public double Error;
        }
        [Serializable()]
        public class Layer
        {
            public List<Neuron> Neurons;
            public double[][] Weights;
            public double[][] deltaW;
            public Layer(int NeuronsCount)
            {
                Weights = new double[NeuronsCount][];
                deltaW = new double[NeuronsCount][];
                Neurons = new List<Neuron>();
                for (int i = 0; i <= NeuronsCount - 1; i++)
                {
                    Neurons.Add(new Neuron());
                }
 
            }
        }
 
        Random random = new Random();
        public double LearningRate =20;
        public double Alpha = 0.5;
        public double MSE;
        public List<Layer> layers;
        public int ActivationFunction = 1;//1 - Tanh(x); 2 - 1/(1+Exp(x)); 3 - линейная
        double CurError = 0;
 
        public double GetCurrentError()
        {
            return CurError;
        }
        public void RandomizeWeights(double min, double max)
        {
            foreach (Layer l in layers)
            {
                for (int i = 0; i <= l.Weights.Length - 1; i++)
                {
                    for (int p = 0; p <= l.Weights[i].Length - 1; p++)
 
                        l.Weights[i][p] = min + (random.NextDouble() * (max - min));
                }
            }
        }
        public void PrintWeights()
        {
            foreach (var l in layers)
            {
                foreach (var n in l.Weights)
                {
                    foreach (var w in n)
                    {
                        Console.WriteLine("Weight = " + w);
                    }
                }
            }
        }
        public double GetOut(double x)
        {
            //double a = 1/(1+Math.Exp(Alpha*x));
            switch (ActivationFunction)
            {
                case 1:
                    double a = Math.Tanh(x);
                    //if (x < -45.0) { return 0.0; }
                    //else if (x > 45.0) { return 1.0; }
                    return a;
                    break;
 
                case 2:
                    double b = 1 / (1 + Math.Exp(-x)); ;
                    if (x < -45.0) { return 0.0; }
                    else if (x > 45.0) { return 1.0; }
                    else { return b; }
 
                    break;
 
                case 3:
                    if (x < 0) { return 0.0; }
                    else if (x > 0) { return 1.0; }
                    break;
 
                default:
 
                    throw new Exception("Не правильная активационная функция");
                    return 0;
                    break;
            }
            return 0;
        }
        public double[] Run(double[] input)
        {
            double[] output = new double[layers[layers.Count - 1].Neurons.Count];
            for (int i = 0; i <= layers[0].Neurons.Count - 1; i++)
            {
                layers[0].Neurons[i].Inputs = input;
                double total = 0;
                for (int j = 0; j <= input.Length - 1; j++)
                {
                    total += layers[0].Weights[i][j] * input[j];
                }
                layers[0].Neurons[i].Output = GetOut(total);
                //Console.WriteLine("Layer: 0 Neuron: " + i + " Output: " + layers[0].Neurons[i].Output);
            }
            for (int l = 1; l <= layers.Count - 1; l++)
            {
                for (int i = 0; i <= layers[l].Neurons.Count - 1; i++)
                {
                    double total = 0;
                    for (int j = 0; j <= layers[l - 1].Neurons.Count - 1; j++)
                    {
                        total += layers[l - 1].Neurons[j].Output * layers[l].Weights[i][j];
                    }
                    layers[l].Neurons[i].Output = GetOut(total);
                    //Console.WriteLine("Layer: " +l+ " Neuron: " + i + " Output: " + layers[l].Neurons[i].Output);
                }
            }
            for (int i = 0; i <= layers[layers.Count - 1].Neurons.Count - 1; i++)
                output[i] = layers[layers.Count - 1].Neurons[i].Output;
            return output;
        }
        public double GetMSE(double[][] input, double[][] t)
        {
            MSE = 0;
            double a = 0;
            for (int i = 0; i <= input.Length - 1; i++)
            {
                double[] o = Run(input[i]);
                for (int k = 0; k <= o.Length - 1; k++)
                {
                    a += (t[i][k] - o[k]) * (t[i][k] - o[k]);
                }
                a /= 2;
                MSE += a;
            }
            MSE /= a;
            return Math.Sqrt(MSE);
        }
        public void Train(double[] input, double[] t)
        {
            CurError = 0;
            double[] o = Run(input);
            for (int k = 0; k <= o.Length - 1; k++)
            {
                layers[layers.Count - 1].Neurons[k].Error = o[k] * (1 - o[k]) * (t[k] - o[k]);
                Console.WriteLine("Last layer error:" + layers[layers.Count - 1].Neurons[k].Error);
                CurError += (t[k] - o[k]) * (t[k] - o[k]);
            }
            CurError /= 2;
 
            for (int l = layers.Count - 2; l >= 0; l--)
            {
                for (int j = 0; j <= layers[l].Neurons.Count - 1; j++)
                {
                    double total = 0;
                    for (int k = 0; k <= layers[l + 1].Neurons.Count - 1; k++)
                    {
                        total += layers[l + 1].Neurons[k].Error * layers[l + 1].Weights[k][j];
                    }
                    Console.WriteLine("Layer " + l + " Neuron " + j + " ChangedError= " + total);
                    layers[l].Neurons[j].Error = total;
                }
            }
            foreach (Layer l in layers)
            {
                for (int i = 0; i <= l.Weights.Length - 1; i++)
                {
                    for (int p = 0; p <= l.Weights[i].Length - 1; p++)
                    {
                        l.deltaW[i][p] = Alpha * l.deltaW[i][p] + (1 - Alpha) * LearningRate * l.Neurons[i].Error * l.Neurons[i].Output;
                        l.Weights[i][p] += l.deltaW[i][p];
                    }
                }
            }
            //Console.WriteLine("====================================");
 
        }
        public void Save(string FileName)
        {
            Stream FileStream = File.Create(FileName);
            BinaryFormatter serializer = new BinaryFormatter();
            serializer.Serialize(FileStream, this);
            FileStream.Close();
        }
        public NNetwork(int[] lrs, int inputs)
        {
            layers = new List<Layer>();
            for (int i = 0; i <= lrs.Length - 1; i++)
            {
                layers.Add(new Layer(lrs[i]));
                if (i >= 1)
                {
                    for (int k = 0; k <= layers[i].Neurons.Count - 1; k++)
                    {
                        layers[i].Weights[k] = new double[lrs[i - 1]];
                        layers[i].deltaW[k] = new double[lrs[i - 1]];
                    }
                }
                else
                {
                    for (int k = 0; k <= layers[i].Neurons.Count - 1; k++)
                    {
                        layers[i].Weights[k] = new double[inputs];
                        layers[i].deltaW[k] = new double[inputs];
                    }
                }
            }
        }
 
    }
}