Чудит нейронная сеть некоректный выход

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Collections;
 
namespace Test
{
    public class Program
    {
 
        static void Main(string[] args)
        {
            NeuronNetwork NN_Lay;
            int[] layers_NeuralNumb = new int[] {  2, 3, 1 }; // конфиг сети
 
            double[,] inp_Data = new double[,] { { 0, 0 }, 
                                                 { 0, 1 },
                                                 { 1, 0 },
                                                 { 1, 1 } }; // Обучающий масив 
 
            double[] ideal = new double[] { 0, 1, 1, 0 }; // Масив ответов
 
            // создаём генератор случайных чисел
            Random random = new Random(DateTime.Now.Millisecond);
 
 
            NN_Lay = new NeuronNetwork(layers_NeuralNumb, random);
 
 
            NN_Lay.Training(ref NN_Lay, 0.001, layers_NeuralNumb, ideal, inp_Data, 10000); // Обуем
 
            Console.ReadLine();
 
 
        }
    }
 
 
    struct LayT
    {
 
        public neuronT[] Neuron;
    }
    struct neuronT
    {
        public double[] weghits; //веса выходных синапсов
        public double error; // ошибка 
        public double x; // Вход нейрона
        public double y; // Выход после функции активации
        public double df; // Производная 
 
 
    }
 
    class NeuronNetwork
    {
        LayT[] Lay;
        int[] layers_NeuralNumb;
 
        public NeuronNetwork(int[] layers_NeuralNumb, Random random)
        {
            this.layers_NeuralNumb = layers_NeuralNumb;
 
            Lay = new LayT[layers_NeuralNumb.Length];
 
            for (int count_lay = 0; count_lay < layers_NeuralNumb.Length; count_lay++)
            {
                Lay[count_lay].Neuron = new neuronT[layers_NeuralNumb[count_lay]];
 
                for (int count_neuron = 0; count_neuron < layers_NeuralNumb[count_lay]; count_neuron++)
                {
 
                    if (Lay.Length - 1 == count_lay)
                        Lay[count_lay].Neuron[count_neuron].weghits = new double[0];
                    else
                        Lay[count_lay].Neuron[count_neuron].weghits = new double[layers_NeuralNumb[count_lay + 1]];
 
                    // Lay[count_lay].Neuron[count_neuron].x = random.NextDouble() - 0.5; // Заполняем рандомом входа нейронов
                    // Lay[count_lay].Neuron[count_neuron].y = 1 / (1 + Math.Exp(-Lay[count_lay].Neuron[count_neuron].x)); // Заполняем рандомом выхода 
 
                    for (int i = 0; i < Lay[count_lay].Neuron[count_neuron].weghits.Length; i++)
                        Lay[count_lay].Neuron[count_neuron].weghits[i] = random.NextDouble() - 0.5;
                }
            }
 
        }
 
        public void Forward()
        {
            double temp, temp2;
            for (int i = 1; i < layers_NeuralNumb.Length; i++) // Идем по слоям
            {
                for (int j = 0; j <= layers_NeuralNumb[layers_NeuralNumb.Length - 1]; j++) // идем по нейронам
                {
                    try // Костыль НАДО ПОФИКСИТЬ!!!!
                    {
                        Lay[i].Neuron[j].x = 0;
                        Lay[i].Neuron[j].y = 0;
                    }
                    catch { break; }
                    for (int w = 0; w < layers_NeuralNumb[i - 1]; w++) // идем по весам
                    {
                        temp2 = Lay[i - 1].Neuron[w].weghits[j] * Lay[i - 1].Neuron[w].y;
                        Lay[i].Neuron[j].x += Lay[i - 1].Neuron[w].weghits[j] * Lay[i - 1].Neuron[w].y;
 
 
                    }
 
                    Lay[i].Neuron[j].y = 1 / (1 + Math.Exp(-Lay[i].Neuron[j].x));
                    Lay[i].Neuron[j].df = Lay[i].Neuron[j].y * (1 - Lay[i].Neuron[j].y);
                }
 
            }
 
        }
 
        public void Backward(double[] ideal) //ref double error)
        {
 
            //error = 0; // обнуляем ошибку
            for (int i = layers_NeuralNumb.Length - 1; i >= 0; i--)
            {
                if (i == 0) { break; }
                for (int j = 0; j <= Lay[i].Neuron.Length - 1; j++)
                {
                    Lay[i].Neuron[j].error = 0; // чистим ячейку
 
                    if (i != layers_NeuralNumb.Length - 1) // если не последний слой 
                    {
                        for (int w = 0; w < Lay[i + 1].Neuron.Length; w++)
                        {
                            Lay[i].Neuron[j].error += Lay[i].Neuron[j].weghits[w] * Lay[i + 1].Neuron[w].error;
                            // Lay[i].Neuron[j].error *= Lay[i].Neuron[j].df;
                        }
                    }
                    else // если последний слой сети
                    {
                        Lay[i].Neuron[j].error = ideal[j] - Lay[i].Neuron[j].y;
                    }
 
                }
            }
 
        }
 
        public void Updating_Weights(double Kn) // Обновление весов 
        {
            int temp3 = 0; // для теста
            double temp = 0.0;
            for (int i = 1; i < layers_NeuralNumb.Length; i++) // Идем по слоям сети начинаем с 1 т к 0 это дендриты
            {
                temp3 = layers_NeuralNumb[i - 1]; // Переменная костыль если один нйрон в слою
 
                for (int j = 0; j < temp3; j++)
                {
 
                    for (int k = 0; (k < layers_NeuralNumb[i]); k++)
                    {
                        temp = Lay[i].Neuron[k].y * (1 - Lay[i].Neuron[k].y); // Для проверки производной
 
                        if (layers_NeuralNumb[i] == 1) // если текушем слою 1 нейрон
                        {
                            // Новый вес нейрона предыдущего слоя = старый вес нейрона предыдущего слоя + Коэф_Обучения * Ошибка нейрона * Производная нейрона * Выходное значение нейрона
 
                            Lay[i - 1].Neuron[j].weghits[k] += Kn * Lay[i].Neuron[k].error * temp* Lay[i].Neuron[0].x;
                            //Lay[i - 1].Neuron[j].weghits[k] -= Kn * Lay[i].Neuron[k].error * Lay[i].Neuron[0].y;
                            if (temp3 == layers_NeuralNumb[i])
                                temp3++;
                        }
                        else
                            Lay[i - 1].Neuron[j].weghits[k] += Kn * Lay[i].Neuron[k].error * temp * Lay[i].Neuron[j].x;
                        //Lay[i - 1].Neuron[j].weghits[k] -= Kn * Lay[i].Neuron[k].error * Lay[i].Neuron[j].y;
                    }
                }
            }
        }
 
        public void Training(ref NeuronNetwork NN, double Kn, int[] layers_NeuralNumb, double[] ideal, double[,] inp_Data, int epoch)
        {
            int epoch_Count = 0;
            double[] ideal_Main = new double[layers_NeuralNumb[0]];
 
            do
            {
 
                for (int i = 0; i < (inp_Data.Length / layers_NeuralNumb[0]); i++) // Перебираем примеры
                {
                    for (int j = 0; j < layers_NeuralNumb[0]; j++)//Перебираем нейроны
                    {
                        NN.Lay[0].Neuron[j].y = inp_Data[i, j];
 
                        ideal_Main[j] = ideal[i]; // подставляем нужный ответ, для примера
                    }
 
 
                    NN.Forward(); // Прямое
                    NN.Backward(ideal_Main); // обратное 
                    NN.Updating_Weights(Kn); // обновление весов|
 
                    Console.WriteLine("X1 {0} \nX2 {1} \nideal {2} \nNN_out {3}",
                        NN.Lay[0].Neuron[0].y, NN.Lay[0].Neuron[1].y, ideal_Main[0], (double)NN.Lay[2].Neuron[0].y); // 
                }
 
                Console.WriteLine("Эпоха {0}", epoch_Count); // 
 
                epoch_Count++;
            }
            while (epoch_Count <= epoch);
        }
 
 
        public LayT this[int i]
        {
            get { return Lay[i]; } // получение значения
            set { Lay[i] = value; } // изменение значения
        }
 
 
 
 
 
    }
}