Нейронные сети (NN)

using System;
namespace PersLab5 {
    public class Neuron
    {
        public static bool ActivationStep(double s, double t)
        {
            return s>t;
        }
 
        public static double ActivationLinear(double s, double k)
        {
            return s*k;
        }
 
        public static double ActivationSigma(double s, double alpha) 
        {
            return 1/(1+Math.Exp(-alpha*s));
        }
 
        public static double ActivationSigmaDif(double y, double alpha) 
        {
            return alpha*y*(1-y); 
        }
    }   
}

namespace PersLab5
{
    /// <summary>
    /// Персептрон
    /// </summary>
    public class NeuralNetwork {
        private int m_NumIn;      // Количество входов
        private int m_NumOut;     // Количество выходов
        private int m_NumLayer;   // Количество скрытых слоёв
        private int m_NumNeirons; // Количество нейронов в скрытых слоях
        private double m_Alpha;   // 
        private double[][,] w;    // Массив весов синоптических связей
        private double[][] m_y;
 
        /// <summary>
        /// Количество входов
        /// </summary>
        public int NumIn{get{return m_NumIn;}} 
        /// <summary>
        /// Количество выходов
        /// </summary>
        public int NumOut{get{return m_NumOut;}}
 
        /// <summary>
        /// Конструктор
        /// </summary>
        /// <param name="NumIn">Количество входов</param>
        /// <param name="NumOut">Количество выходов</param>
        /// <param name="NumLayer">Количество скрытых слоёв</param>
        /// <param name="NumNeiron">Количество нейронов в скрытом слое</param>
        public NeuralNetwork(int NumIn, int NumOut, int NumLayer, int NumNeiron, double Alpha) {
            m_NumIn=NumIn;
            m_NumOut=NumOut;
            m_NumLayer=NumLayer;
            m_NumNeirons=NumNeiron;
            m_Alpha=Alpha;
            // Создание массива промежуточных выходов нейронов
            m_y = new double[m_NumLayer+1][];
            m_y[m_NumLayer] = new double[m_NumOut];
            for(int i=0; i<m_NumLayer; i++)
                m_y[i] = new double[m_NumNeirons];
            // Инициализация весов синоптических связей случайными числами
            w = new double[m_NumLayer+1][,];
            w[0] = new double[m_NumNeirons, m_NumIn];
            for(int i=1; i<m_NumLayer; i++)
                w[i] = new double[m_NumNeirons, m_NumNeirons];
            w[m_NumLayer] = new double[m_NumOut, m_NumNeirons]; 
        }
 
        /// <summary>
        /// Инициализация весов синоптических связей случ. числами
        /// </summary>
        public void InitW()
        {
            Random rand = new Random();
            for(int i=0; i<m_NumNeirons; i++)
                for(int j=0; j<m_NumIn; j++)
                    w[0][i, j]=rand.NextDouble();
            for(int k=1; k<m_NumLayer; k++)
                for(int i=0; i<m_NumNeirons; i++)
                    for(int j=0; j<m_NumNeirons; j++)
                        w[k][i, j]=rand.NextDouble();
            for(int i=0; i<m_NumOut; i++)
                for(int j=0; j<m_NumNeirons; j++)
                    w[m_NumLayer][i, j]=rand.NextDouble();
        }
 
        /// <summary>
        /// Возвращает вектор выходов от вектора входов
        /// </summary>
        /// <param name="x">Вектор входов</param>
        /// <returns>Вектор выходов</returns>
        public double[] Out(double[] x) 
        {
            for(int i=0; i<m_NumNeirons; i++)
            {
                double s=0;
                for(int j=0; j<m_NumIn; j++)
                    s+=w[0][i, j]*x[j];
                m_y[0][i]=Neuron.ActivationSigma(s, m_Alpha);
            }
            for(int k=0; k<m_NumLayer; k++) {
                int N;
                if(k==m_NumLayer-1)
                    N=m_NumOut;
                else N=m_NumNeirons;
                for(int i=0; i<N; i++) {
                    double s=0;
                    for(int j=0; j<m_NumNeirons; j++)
                        s+=w[k+1][i, j]*m_y[k][j];
                    m_y[k+1][i]=Neuron.ActivationSigma(s, m_Alpha);
                }
            }
            return (double[])m_y[m_NumLayer].Clone();
        }
 
        /// <summary>
        /// Ошибка персептрона для выборки (x, d)
        /// </summary>
        /// <param name="x">Вектор входов</param>
        /// <param name="d">Желаемый вектор выходов</param>
        /// <returns>Ошибка</returns>
        public double GetSituationError(double[] y, double[] d) {
            double error=0;
            for(int i=0; i<m_NumOut; i++) {
                error+=(y[i]-d[i])*(y[i]-d[i]);
            }
            return Math.Sqrt(error)/m_NumOut;
        }
 
        public double GetError(int size, double[][] X, double[][] D) {
            double error=0;
            for(int p=0; p<size; p++)
                error=Math.Max(error, GetSituationError(Out(X[p]), D[p]));
            return error;
        }
 
        /// <summary>
        /// Коррекция весов синоптических связей
        /// </summary>
        /// <param name="x">вектор входов</param>
        /// <param name="d">требуемый вектор выходов</param>
        /// <param name="tetta">коэффициент обучения</param>
        void Correct(double[] x, double[] d, double tetta) {
            // Вычисляем выходы всех слоёв
            Out(x);
            // Выделяем память под delta
            double[][] delta = new double[m_NumLayer+1][]; 
            delta[m_NumLayer] = new double[m_NumOut];
            for(int i=0; i<m_NumLayer; i++)
                delta[i] = new double[m_NumNeirons];
            // Вычисляем delta и корректируем веса синоптических связей
            for(int i=0; i<m_NumOut; i++) {
                delta[m_NumLayer][i]=(m_y[m_NumLayer][i]-d[i])*Neuron.ActivationSigmaDif(m_y[m_NumLayer][i], m_Alpha);
                for(int j=0; j<m_NumNeirons; j++)
                    w[m_NumLayer][i, j]-=tetta*delta[m_NumLayer][i]*m_y[m_NumLayer-1][j];
            }
            for(int l=m_NumLayer-1; l>=0; l--) {
                for(int i=0; i<m_NumNeirons; i++) {
                    int N;
                    if(l==m_NumLayer-1)
                        N=m_NumOut;
                    else N=m_NumNeirons;
                    double s=0;
                    for(int k=0; k<N; k++)
                        s+=delta[l+1][k]*w[l+1][k, i];
                    delta[l][i]=s*Neuron.ActivationSigmaDif(m_y[l][i], m_Alpha);
                    if(l==0) {
                        for(int j=0; j<m_NumIn; j++)
                            w[0][i, j]-=tetta*delta[0][i]*x[j];
                    }
                    else
                        for(int j=0; j<m_NumNeirons; j++)
                            w[l][i, j]-=tetta*delta[l][i]*m_y[l-1][j];
                }
            }
        }
 
        /// <summary>
        /// Обучение
        /// </summary>
        /// <param name="size">Размер выборки</param>
        /// <param name="x">Массив векторов входов</param>
        /// <param name="d">Массив векторов требуемых выходов</param>
        /// <param name="eps">Погрешность</param>
        /// <param name="tetta">Скорость обучения</param>
        /// <param name="MaxStep">Максимальное количество иттераций</param>
        /// <returns>Количество иттераций за которое обучилась нейронная сеть</returns>
        public int Learn(int size, double[][] x, double[][] d, double eps, double tetta, int MaxStep) {
            InitW();
            int t=0;
            while((GetError(size, x, d)>eps)&&(t<MaxStep)) {
                t++;
                for(int p=0; p<size; p++)
                    Correct(x[p], d[p], tetta);
            }
            return t;
        }
    }
}