Что происходит в мозгах у нейронной сети и как им помочь

    public class Synaps {
        private double weight;
        /// <summary>Доступатор к одному параметру</summary>
        virtual public double Weight {
            get { return weight; }
            set {
                if (weight != value) {
                    weight = value;
                    if (axon != null)
                        ChangeActionPotentialHandler(axon.ActionPotential);
                }
            }
        }
        /// <summary>Внутреннее хранилище ссылки на аксон. Возможно, в будущем, в целях оптимизации, разрешим из него читать наследникам, но писать в него точно нельзя.</summary>
        private IAxon axon;
        // Указание на нейрон, с которого снимается информация.
        public IAxon Axon {
            get { return axon; }
            set { // Вот тут навешиваем обработчики, которые следят за изменением состояния исходного нейрона.
                if (axon != null)
                    axon.RemoveChangeActionPotentialHandler(ChangeActionPotentialHandler);
                axon = value;
                if (axon != null) {
                    axon.AddChangeActionPotentialHandler(ChangeActionPotentialHandler);
                    ChangeActionPotentialHandler(axon.ActionPotential);
                }
            }
        }
        
        public double ActionPotential;

        /// <summary> Событие кидается, когда синапс меняет свой потенциал.</summary>
        protected Action WhenActionPotentialСhanged;
        public void AddActionPotentialChangeHandler(Action handler) {
            WhenActionPotentialСhanged += handler;
        }
        public void RemoveActionPotentialChangeHandler(Action handler) {
            WhenActionPotentialСhanged -= handler;
        }

        virtual protected void ChangeActionPotentialHandler(double axonActionPotential) {
            ActionPotential = axonActionPotential * weight; // Проверку на неизменность значения не делаю, потому что она уже есть в нейроне.
            if (WhenActionPotentialСhanged != null)
                WhenActionPotentialСhanged); // Просто передать событие об изменении потенциала на изучаемом нейроне
        }
    }

    public interface IAxon {
        /// <summary>Значение потенциала действия.</summary>
        double ActionPotential { get; }

        /// <summary>Более успешной оптимизации не просматривается.</summary>
        void AddChangeActionPotentialHandler(Action<double> handler);
        void RemoveChangeActionPotentialHandler(Action<double> handler);

        /// <summary>Положение, в котором находится аксон в пространстве нейронной сети.</summary>
        PointF Position { get; set; }

        /// <summary>Имя аксона чтобы идентифицировать его в трейсе.</summary>
        string Name { get; set; }
    }

    public class SensoryNeuron : IAxon {
        protected double actionPotential;
        public double ActionPotential {
            get { return actionPotential; }
            set {
                if (actionPotential != value) {
                    actionPotential = value;
                    if (WhenChangeActionPotential != null)
                        WhenChangeActionPotential(actionPotential);
                }
            }
        }
    }

    /// <summary>Общий предок. Есть только функция активации </summary>
    public class Neuron : IAxon {
        /// <summary> Список синапсов, с которых получает информацию этот нейрон. Список в виде массива, потому что перебирать массив быстрее, а изменение списка делается редко.</summary>
        public Synaps[] Synapses = new Synaps[0];
        /// <summary> Внутренний флаг, означающий, что один из синапсов поменял свой потенциал и нейрон нуждается в пересчёте.</summary>
        protected bool synapsPotentialChanged = false;
        /// <summary> Добавить в нейрон новую синаптическую связь. И нацепить, кроме того, все положенные слушатели. </summary>
        public void AppendSinaps(Synaps target) {
            // При каждом обновлении пересоздаём массив. Выглядит это, конечно, неоптимально, но эта операция делается очень редко, в отличии от самого вычисления.
            Synapses = Synapses.Concat(new Synaps[1] { target }).ToArray();
            target.AddActionPotentialChangeHandler(ChangeSynapsPotentialHandler); // Слушатели новые навешать.
            synapsPotentialChanged = true;
        }
        virtual protected void ChangeSynapsPotentialHandler() {
            synapsPotentialChanged = true;
        }

        /// <summary> Функция активации нейрона. Она тут хранится отдельной переменной, чтобы ускорить процесс вызова.</summary>
        protected DTransferFunction transferFunctionDelegate;
        public virtual DTransferFunction TransferFunction {
            get { return transferFunctionDelegate; }
            set {
                transferFunctionDelegate = value;
            }
        }

        /// <summary> Метод вызывает расчёт в нейроне и может привести к изменению его потенциала действия. </summary>
        public virtual void Excitation() {
            if (!synapsPotentialChanged) return; // Для нецелочисленного нейрона проверка почти всегда бессмысленна
            synapsPotentialChanged = false;
            synapsPotentials = 0;
            for (int i = 0; i < Synapses.Length; i++)
                synapsPotentials += Synapses[i].ActionPotential;
            double newValue = transferFunctionDelegate(synapsPotentials);
            if (actionPotential != newValue) { // Для некоторых специальных случаев значения могут не отличаться. Например, для целочисленного перцептрона.
                actionPotential = newValue;
                if (WhenChangeActionPotential != null)
                    WhenChangeActionPotential(actionPotential);
            }
        }
    }

    /// <summary> Функция определения потенциала действия на основе входных сигналов. </summary>
    /// <param name="argument">Сумма потенциалов синапсов</param>
    /// <returns>Возвращает значение потенциала действия нейрона</returns>
    public delegate double DTransferFunction(double argument);
    DTransferFunction BarrierTransferFunction = (double x) => x <= 0 ? 0 : 1;

    abstract public class NeuralNetwork {
        /// <summary>Вход нейронной сети</summary>
        public SensoryNeuron[] Input = new SensoryNeuron[0];

        /// <summary>
        /// Все добавленыне в сеть нейроны выстраиваются в этом массиве в том порядке, в котором будут обработаны. Сенсорные нейроны сюда вообще не попадают.
        /// Я не закладываю заранее послойность или любой другой предопределённый алгоритм обхода, чтобы конкретная реализация сети могла переопределять порядок обработки по вкусу.
        /// </summary>
        public Neuron[] ExcitationOrder = new Neuron[0];

        /// <summary>Выход нейронной сети</summary>
        public Neuron[] Output = new Neuron[0];

        /// <summary>Универсальный метод, создающий сеть с указанными в классе параметрами</summary>
        /// <param name="input">Количество сенсорных нейронов - входов</param>
        /// <param name="output">Количество выходных нейронов реакции</param>
        abstract public void create(uint input, uint output);

        public void execute(double[] data) {
            // Несовпадение размерности входных сигналов и входа сети на данном этапе не проверяем для экономии
            for (int i = 0; i < Input.Length && i < data.Length; i++) {
                Input[i].ActionPotential = data[i];
            }
            for (int i = 0; i < ExcitationOrder.Length; i++)
                ExcitationOrder[i].Excitation();
        }
        public double[] Result() {
            // return output.Select(s => s.ActionPotential).ToArray(); //TODO Не забыть сравнить с Linq по скорости.
            double[] res = new double[Output.Length];
            for (int i = 0; i < res.Length; i++)
                res[i] = Output[i].ActionPotential;
            return res;
        }
    }
    public class PerceptronClassic : NeuralNetwork {
        // Насколько в слое больше нейронов, чем входов сети
        public int neuronCountsOverSensoric = 15;
        //Сколько синапсов у каждого нейрона
        public int ANeuronSynapsCount;
        // Первый слой нейронов линейного разложения
        public Neuron[] Layer;
        // Класс собирает перцептрон Ролзенблатта по заданным характеристикам
        override public void create(uint inputCount, uint outputCount) {
            rnd = rndSeed >= 0 ? new Random(rndSeed) : new Random();
            // Сенсорные нейроны
            this.Input = new SensoryNeuron[inputCount];
            for (int i = 0; i < inputCount; i++)
                Input[i] = new SensoryNeuron() {Name = "S" + i};
            //Группа нейронов первого слоя - Ассоциативные
            Layer = new Neuron[inputCount + neuronCountsOverSensoric];
            for (int i = 0; i < Layer.Length; i++) {
                // Это сам нейрон
                Layer[i] = new RosenblattNeuron();
                // А это его случайные необучаемые синапсы первого слоя
                SensoryNeuron[] sub = Input.OrderBy((cell) => rnd.NextDouble()).Take(ANeuronSynapsCount).ToArray();
                // Их не больше, чем входных сигналов
                for (int j = 0; j < sub.Length; j++) {
                    Synaps s = new Synaps();
                    s.Axon = sub[j];
                    s.Weight = rnd.Next(2) * 2 - 1;
                    Layer[i].AppendSinaps(s);
                }
            }
            // Назвать сообразно месту в системе.
            for (int i = 0; i < Layer.Length; i++)
                Layer[i].Name = "A" + i;
            // Выходные нейроны - Реагирующие элементы
            Output = new Neuron[outputCount];
            for (int i = 0; i < Output.Length; i++) {
                Output[i] = new RosenblattNeuron();
                Output[i].Name = "R" + i;
                // Их синапсы с каждым из предыдущего слоя
                for (int j = 0; j < Layer.Length; j++) {
                    Synaps s = new Synaps();
                    s.Axon = Layer[j];
                    Output[i].AppendSinaps(s); // Начальный вес 0
                }
            }
            // И складываем в кучу обсчитываемых нейронов
            int lastIndex = 0;
            ExcitationOrder = new Neuron[Layer.Length + Output.Length];
            foreach (Neuron cell in Layer)
                ExcitationOrder[lastIndex++] = cell;
            foreach (Neuron cell in Output)
                ExcitationOrder[lastIndex++] = cell;
        }
    }
    /// <summary>Алгоритм обучения коррекцией ошибки.</summary>
    public class ErrorCorrection : LearningAlgorythm {
        // Метод, описывающий одиночный акт обучения на одном примере
        override protected double LearnNet(double[] required) {
            double error = 0;
            for (int i = 0; i < required.Length && i < net.Output.Length; i++) {
                if (required[i] != net.Output[i].ActionPotential) {
                    error += 1;
                    // Перебираем все ассоциативные нейроны
                    for (int j = 0; j < (net as PerceptronClassic).Layer.Length; j++)
                        // Находим тех из них, кто активировался
                        if ((net as PerceptronClassic).Layer[j].ActionPotential > 0)
                            // У всех нейронов второго слоя
                            foreach (RosenblattNeuron cell in net.Output)
                                // Изменяем веса всех синапсов, которые указывают на активированный ассоциативный нейрон
                                // Если правильное решение – дезактивация, то снижаем вес, если активация – повышаем. Вес может стать отрицательным.
                                cell.Synapses[j].Weight += required[i] <= 0 ? -1 : 1;
                }
            }
            return error;
        }
        /// <summary>Обучает одному набору от начала и до конца</summary>
        public void LearnTasksSet() {
            if (data == null) { Console.WriteLine("Источник данных отсутствует"); return; }
            data.Reset();
            LearnedTaskSetsCount++;
            ErrorsInSet = LearnedTasksInSetCount = 0;
            int max = 1000;
            while (data.MoveNext() && --max >= 0)
                LearnCurrentTask();
            // На выходе сет не переключается, поэтому статистика остается видна.
        }

        /// <summary>Обучать всему сету несколько раз или пока сеть не научится.</summary>
        /// <param name="loops">Сколько раз прогнать учебный сет</param>
        public void LearnSetManyTimesUntilSuccess(int loops) {
            for (int i = 0; i < loops; i++) {
                LearnTasksSet();
                if (ErrorsInSet == 0) {
                    break;
                }
            }

        }
    }

    /// <summary> Функция определения производной от потенциала действия. </summary>
    /// <param name="argument">Сумма потенциалов синапсов</param>
    /// <param name="funcResult">Потенциал действия нейрона, посчитанный для данных значений</param>
    /// <returns>Возвращает значение производной потенциала действия в данной точке.</returns>
    public delegate double DTransferFunctionDerivative(double argument, double funcResult);

    public class NeuronWithDerivative : Neuron {
        /// <summary> Производная функции активации нейрона. Она тут хранится отдельно от своего класса чтобы ускорить процесс вызова.</summary>
        protected DTransferFunctionDerivative transferFunctionDerivativeDelegate;
        /// <summary></summary>
        override public DTransferFunctionDerivative TransferFunction {
            get { return transferFunctionDerivativeDelegate; }
            set { transferFunctionDerivativeDelegate = value; }
        }
        /// <summary>Хранилище для предвычисленного значения первой производной от функции передачи</summary>
        protected double actionPotentialDerivative = 0;
        /// <summary>Первая производная от передаточной функции по её основному параметру.</summary>
        public double ActionPotentialDerivative { get { return actionPotentialDerivative; } }
        /// <summary>Параметр для расчёта обратного распостранения ошибки. Ну, или обратного распостранения производной. Кому как удобнее.</summary>
        public double BackProprigationParametr = 0;

        public override void Excitation() {
            base.Excitation();
            actionPotentialDerivative = transferFunctionDerivativeDelegate(synapsPotentials, actionPotential);
        }
    }

    static class Tools {
        /// <summary>Вызвать делегата в отношении каждого экземпляра в последовательности любого типа.</summary>
        /// <param name="source">Перечислитель с исходными данными.</param>
        /// <param name="func">Делегат, который надо вызывать.</param>
        public static void Each<SequenceType>(this IEnumerator<SequenceType> source, Action<SequenceType> func) {
            while (source.MoveNext())
                func(source.Current);
        }
        /// <summary>Вызвать делегата в отношении каждого экземпляра в последовательности любого типа и передать ему индекс.</summary>
        /// <param name="source">Перечислитель с исходными данными.</param>
        /// <param name="func">Делегат, который надо вызывать. Второй параметр передаваемый делегату - индекс в последовательности. Отсчёт начинается со следующего элемента последовательности. В нетронутой - с начала.</param>
        public static void Each<SequenceType>(this IEnumerator<SequenceType> source, Action<SequenceType, int> func) {
            for (int i = 0; source.MoveNext(); i++)
                func(source.Current, i);
        }
        /// <summary>Вызвать делегата в отношении каждого экземпляра в последовательности любого типа.</summary>
        /// <param name="source">Перечислитель с исходными данными.</param>
        /// <param name="func">Делегат, который надо вызывать.</param>
        public static void Each<SequenceType>(this IEnumerable<SequenceType> source, Action<SequenceType> func) {
            source.GetEnumerator().Each(func);
        }
        /// <summary>Вызвать делегата в отношении каждого экземпляра в последовательности любого типа и передать ему индекс.</summary>
        /// <param name="source">Перечислитель с исходными данными.</param>
        /// <param name="func">Делегат, который надо вызывать. Второй параметр передаваемый делегату - индекс в последовательности. Отсчёт начинается со следующего элемента последовательности. В нетронутой - с начала.</param>
        public static void Each<SequenceType>(this IEnumerable<SequenceType> source, Action<SequenceType, int> func) {
            source.GetEnumerator().Each(func);
        }
    }

    // Многослойный перцептрон из обычных сравнительно быстрых нейронов с первой производной.
    public class RumelhartPerceptron : NeuralNetwork {
        /// <summary> Функция назначаемая нейронам. Задаётся извне.</summary>
        DTransferFunctionDerivative TransferFunctionDerivative;
        /// <summary>Количество нейронов в сети послойно, не считая сенсорного и выходного слоёв</summary>
        public int[] NeuronsCount = new int[0];


        override public void create(uint input, uint output) {
            // Сенсорные нейроны.
            Input = (new SensoryNeuron[input]).Select((empty, index) => new SensoryNeuron(){Name = "S[" + index + "]"}).ToArray();
            // Фабрика всех остальных нейронов
            Func<string, NeuronWithDerivative> create = (name) => {
                NeuronWithDerivative neuron = new NeuronWithDerivative();
                neuron.Name = name;
                neuron.TransferFunction = TransferFunction;
                neuron.TransferFunctionDerivative = TransferFunctionDerivative;
                return neuron;
            };
            Func<IAxon, Synaps> createSynaps = (axon) => { Synaps s = new Synaps(); s.Axon = axon; return s; };

            /// <summary>Нейроны внутренних слоёв</summary>
            // Составим двумерный массив с нейронами слоёв
            NeuronWithDerivative[][] Layers = NeuronsCount.Select((count, layer) => Enumerable.Range(0, count).Select(index => create("A[" + layer + "][" + index + "]")).ToArray()).ToArray();
            // Создаём одномерный массив выходных нейронов
            // Выходной слой
            Output = Enumerable.Range(0, (int)output).Select(index => create("R[" + index + "]")).ToArray();
            // Всем нейронам первого слоя навесить связи со слоем сенсоров.
            Layers[0].Each(neuron => { Input.Select(createSynaps).Each(synaps => { neuron.AppendSinaps(synaps); }); });
            // Всем нейронам, начиная со второго слоя, связи со всеми нейронами предыдущего слоя.
            Layers.Skip(1).Each((layer, layerIndex) => { layer.Each(neuron => { Layers[layerIndex].Select(createSynaps).Each(synaps => { neuron.AppendSinaps(synaps); }); }); });
            // Всем выходным нейронам выдать связи на нейроны 
            Output.Each(neuron => { Layers.Last().Select(createSynaps).Each(synaps => { neuron.AppendSinaps(synaps); }); });
            // Сваливаем всё в очередь выполнения
            ExcitationOrder = Layers.SelectMany(layer => layer).Concat(Output).ToArray();
            // Рандомизируем веса синапсов в диапазоне от -1 до +1
            Random rnd = new Random();
            ExcitationOrder.Each(neuron => neuron.Synapses.Each(synaps => synaps.Weight = rnd.NextDouble() * 2 - 1));

        }
    }

    public class BackPropagationLearning : LearningAlgorythm {

        // Скорость, с которой происходит обучение
        public double LearningSpeed = 0.01;


        override protected double LearnNet(double[] required) {
            double[] errors = net.Output.Select((neuron, index) => neuron.ActionPotential - required[index]).ToArray();
            // Почистить все переменные обратного распостранения. Это позволит суммировать обратные переменные, обходя синапсы в порядке их присутствия в нейроне и не создавая двухсвязного списка связей в сети.
            net.ExcitationOrder.Cast<NeuronWithDerivative>().Each(neuron => { neuron.BackProprigationParametr = 0; });
            // В переменной BackProprigationParametr мы теперь храним dE/dS[i] = dE/dO[i] * F'[i](S[i])
            // Для выходных нейронов производная от ошибки зависит от желаемых значений. BP[i] = dE/dO[i] * F'[i] = 2*(O[i]-T[i])*F'[i];
            net.Output.Cast<NeuronWithDerivative>().Each((neuron, index) => { neuron.BackProprigationParametr = 2 * errors[index] * neuron.ActionPotentialDerivative; });
            // Для всех синапсов посчитать долю производной, которую они внесли в свои аксоны BP[j] = SUM( dE/dO[i] * F'[i] * W[j,i] ) * F'[j] = SUM ( BP[i] * W[j,i] * F'[j])
            net.ExcitationOrder.Reverse().Cast<NeuronWithDerivative>().Each(neuron => {
                neuron.Synapses.SkipWhile(synaps => !(synaps.Axon is NeuronWithDerivative)).Each(synaps => {
                    (synaps.Axon as NeuronWithDerivative).BackProprigationParametr += neuron.BackProprigationParametr * neuron.ActionPotentialDerivative * synaps.Weight;
                });
            });
            // А теперь меняем все веса, до которых дотягиваемся delta W[i,j] = -speed * dE/dS[j] * X[i];
            net.ExcitationOrder.Reverse().Cast<NeuronWithDerivative>().Each(neuron => {
                neuron.Synapses.Each(synaps => {
                    synaps.Weight += -LearningSpeed * neuron.BackProprigationParametr * synaps.Axon.ActionPotential;
                });
            });
            // И возвращаем средний квадрат ошибки. (Усреднят и возьмут корень из него потом вышестоящие инстанции, для логов).
            return errors.Select(e => e * e).Average();
        }

        public void LearnSomeTime(int sek) {
            DateTime begin = DateTime.Now;
            while (TimeSpan.FromTicks(DateTime.Now.Ticks - begin.Ticks).Seconds < sek) {
                LearnTasksSet();
            }
        }
    }