コード例 #1
0
ファイル: Anfis.cs プロジェクト: sinhmd/FuzzyLogic
        /// <summary>
        /// Генерация базы правил на основе субстратной кластеризации
        /// </summary>
        private void Genfis()
        {
            //
            // Подготовка данных для кластеризации
            //
            int len = xin.Length + 1;                       // + 1, т.к. входные данне

            double[][] x = new double[len][];               // Создаем массив данных
            for (int i = 0; i < x.Length - 1; i++)          // Перебираем массивы
            {
                x[i] = xin[i];
            }
            x[x.Length - 1] = xout;

            //
            // Кластеризация данных
            //

            SubtractClustesing subclust = new SubtractClustesing(x, Radii, SqshFactor, AcceptRatio, RejectRatio);

            subclust.SubClust();
            double[][] centers = subclust.Centers;          // Центы кластеров
            double[]   sigmas  = subclust.Sigmas;           // Радиусы кластеров

            //
            // Ращипление центров кластеров
            //

            // Формирование центров кластеров
            double[][] centersIn  = new double[centers.Length - 1][];
            double[]   centersOut = centers[centers.Length - 1];
            for (int i = 0; i < centersIn.Length; i++)
            {
                centersIn[i] = centers[i];
            }
            // Формирование радиусов кластера
            double[] sigmaIn = new double[sigmas.Length - 1];
            for (int i = 0; i < sigmaIn.Length; i++)
            {
                sigmaIn[i] = sigmas[i];
            }
            double sigmaOut = sigmas[sigmas.Length - 1];

            //
            // Формируем входные переменные
            //

            for (int i = 0; i < centersIn.Length; i++)
            {
                // Создаем переменную
                double min, max;
                MinMax(xin[i], out max, out min);
                FuzzyVariable input = new FuzzyVariable(NameInput + (i + 1).ToString(), min, max);
                // Формируем термы / функции принадлежности
                for (int j = 0; j < centersIn[i].Length; j++)
                {
                    input.Terms.Add(
                        new FuzzyTerm(
                            NameMf + (j + 1).ToString(),
                            new NormalMembershipFunction(centersIn[i][j], sigmaIn[i])
                            )
                        );
                }
                // Заносим переменную в список
                Input.Add(input);
            }

            //
            // Формирование выходных переменных
            //

            SugenoVariable output = new SugenoVariable(NameOutput);

            for (int i = 0; i < centersOut.Length; i++)
            {
                Dictionary <FuzzyVariable, double> mf = new Dictionary <FuzzyVariable, double>();
                for (int j = 0; j < centersIn.Length; j++)                      // Перебираем входные переменные
                {
                    mf.Add(InputByName(NameInput + (j + 1).ToString()), 0.0);   // По умолчанию 0,0
                }
                // Константа тоже по умолчанию 0.0
                output.Functions.Add(CreateSugenoFunction(NameMf + (i + 1).ToString(), mf, 0.0));
            }
            Output.Add(output);

            //
            // Формировние базы правил типа
            // if (input1 is mf1) and (input2 is mf1) then (output1 is mf1)
            //
            rulesText = new string[centersOut.Length];          // Текстовое представление правил
            for (int i = 0; i < centersOut.Length; i++)
            {
                StringBuilder sb = new StringBuilder();
                sb.Append("if");
                for (int j = 0; j < centersIn.Length; j++)
                {
                    sb.Append(string.Format(" ({0} is {1}) ", NameInput + (j + 1).ToString(), NameMf + (i + 1).ToString()));
                    if (j != centersIn.Length - 1)
                    {
                        sb.Append("and");
                    }
                }
                sb.Append("then");
                sb.Append(string.Format(" ({0} is {1})", NameOutput, NameMf + (i + 1).ToString()));
                rulesText[i] = sb.ToString();
                Rules.Add(ParseRule(sb.ToString()));                    // Парсим правило
            }
        }
コード例 #2
0
ファイル: Anfis.cs プロジェクト: sinhmd/FuzzyLogic
        /// <summary>
        /// Обучение Fis
        /// </summary>
        /// <param name="anfisTrain">Функция обучения</param>
        public void Train(anfisTrain anfisTrain = null)
        {
            //
            // Генерация Fis
            //
            Genfis();
            //
            // Обучение Fis
            //
            int    epoch = 1;
            double epochError;

            if (Rules.Count == 0)
            {
                throw new Exception("Должно быть хотя бы одно правило.");
            }

            int k = xout.Length;                            // Количество параметров обучающей выборки
            int l = (xin.Length + 1) * Rules.Count;         // (m+1)n - m - количество входных переменных n - количество правил

            Matrix C = new Matrix(l, 1);                    // Столбец весовых коэффициентов
            Matrix Y = new Matrix(k, 1);                    // Вектор столбец выходных данных

            for (int i = 0; i < k; i++)
            {
                Y[i, 0] = xout[i];
            }

            errorTrain = new double[Epochs];
            while (epoch <= Epochs)
            {
                epochError = 0.0;                           // Ошибка на i эпохе
                //
                // Формирование матрицы коэффициентов
                //
                Matrix W  = new Matrix(k, l);
                Matrix ew = new Matrix(k, Rules.Count);
                for (int i = 0; i < k; i++)
                {
                    Dictionary <FuzzyVariable, double> inputValues = new Dictionary <FuzzyVariable, double>();
                    // По количеству переменных
                    for (int j = 0; j < xin.Length; j++)
                    {
                        inputValues.Add(InputByName(NameInput + (j + 1).ToString()), xin[j][i]);
                    }
                    // Посылки правил
                    Dictionary <FuzzyVariable, Dictionary <FuzzyTerm, double> > fuzzyInput = Fuzzify(inputValues);
                    // Агрегирование подусловий
                    Dictionary <SugenoFuzzyRule, double> rulesWeight = EvaluateConditions(fuzzyInput);
                    // Заключение правил
                    double        Stau = 0.0;
                    List <double> tau  = new List <double>();
                    foreach (double _tau in rulesWeight.Values)
                    {
                        Stau += _tau;
                        tau.Add(_tau);
                    }
                    double[] b = new double[tau.Count];
                    for (int j = 0; j < b.Length; j++)
                    {
                        b[j]     = tau[j] / Stau;
                        ew[i, j] = tau[j];
                    }
                    // Формирование входных переменных
                    double[] x = new double[xin.Length + 1];        // +1, т.к. x0 = 1
                    x[0] = 1;                                       // x0 = 1
                    for (int j = 1; j < x.Length; j++)
                    {
                        x[j] = xin[j - 1][i];                       // заполняем x1, x2,...,x3
                    }
                    int columnW = 0;
                    for (int g = 0; g < b.Length; g++)              // перебираем по заключениям
                    {
                        for (int d = 0; d < x.Length; d++)          // перебираем по входным данным
                        {
                            W[i, columnW] = b[g] * x[d];            // переменожаем коэффициенты на переменные
                            columnW++;                              // увеличиваем строку на 1
                        }
                    }
                }

                Matrix Winverse = W.PInverse();     // W+ псевдоинверстная матрица

                //
                // Если псевдоинверстная матрица не найдена
                //
                bool breakTrain = false;
                for (int i = 0; i < Winverse.N; i++)
                {
                    for (int j = 0; j < Winverse.M; j++)
                    {
                        if (double.IsNaN(Winverse[i, j]))
                        {
                            breakTrain = true;
                            break;
                        }
                    }
                    if (breakTrain)
                    {
                        break;
                    }
                }
                if (breakTrain)
                {
                    break;              // Прерываем обучение
                }
                C = Winverse * Y;       // Находим коэффициенты
                //
                // Нахождение вектора фактического выхода сети
                //
                Matrix Ystrich = W * C;
                //
                // Правим коэффициенты
                //
                for (int i = 0; i < Input.Count; i++)
                {
                    FuzzyVariable fv = Input[i];                // Забираем переменную
                    for (int j = 0; j < fv.Terms.Count; j++)
                    {
                        FuzzyTerm term = fv.Terms[j];               // Выбираем j терм i входной переменной
                        //
                        // Меняем в случае если функция принадлежности колоколообразная
                        //
                        IMembershipFunction mf = term.MembershipFunction;
                        if (mf is NormalMembershipFunction)
                        {
                            NormalMembershipFunction mfterm = (NormalMembershipFunction)mf;  // Приводим тип
                            //
                            // Перебираем все переменные k - количество выходных параметров
                            //

                            for (int g = 0; g < k; g++)
                            {
                                double b     = mfterm.B;
                                double sigma = mfterm.Sigma;
                                double xa    = xin[i][g] - b;             // xin - b

                                double yyStrih = Ystrich[g, 0] - xout[g]; // y' - y
                                double p       = ew[g, j];
                                double sp      = 0.0;
                                for (int q = 0; q < Rules.Count; q++)
                                {
                                    sp += ew[g, q];
                                }
                                double pb = p / (sp / Math.Pow(sigma, 2));   // (t/summt) / sigma^2
                                //
                                // Инициализируем матрицы для нахождения c
                                //
                                Matrix x = new Matrix(1, xin.Length + 1);
                                Matrix c = new Matrix(xin.Length + 1, 1);
                                x[0, 0] = 1;                                 //x0 = 1
                                for (int q = 1; q < x.M; q++)
                                {
                                    x[0, q] = xin[q - 1][g];
                                }
                                // Заполняем коэффициенты
                                int start = j * x.M;
                                for (int q = start; q < start + x.M; q++)
                                {
                                    c[q - start, 0] = C[q, 0];
                                }

                                // Перемножаем матрици
                                double cy = ((x * c)[0] - Ystrich[g, 0]);
                                //
                                // Корректируем B
                                //

                                b -= 2 * Nu * xa * yyStrih * cy * pb;

                                //
                                // Корректируем Sigma
                                //

                                sigma -= 2 * Nu * Math.Pow(xa, 2) * yyStrih * cy * pb;
                                //
                                // Условия переобучения и недопустимости применения условий
                                //

                                if (double.IsNaN(mfterm.Sigma) || double.IsNaN(mfterm.B))
                                {
                                    continue;   // Идем на следующую итерацию
                                }
                                else
                                {
                                    mfterm.B     = b;
                                    mfterm.Sigma = sigma;
                                }
                            }
                            //
                            // Загоняем терм обратно
                            //



                            fv.Terms[j].MembershipFunction = mfterm;
                        }
                        //
                        // TODO: Настройка остальных функций принадлежности не реализовано
                        //
                    }

                    Input[i] = fv;                      // Загоняем переменную обратно
                }
                //
                // Находим ошибку выхода
                //
                epochError = 0.0;
                for (int i = 0; i < Ystrich.N; i++)
                {
                    epochError += 0.5 * Math.Pow(Ystrich[i, 0] - xout[i], 2);
                }
                errorTrain[epoch - 1] = epochError;
                anfisTrain?.Invoke(epoch, Epochs, nu, epochError);
                Nu *= NuStep;
                epoch++;
            }   // Конец эпох обучения

            //
            // Применяем параметры коэффициентов y = c0 + c1 * x1 + c2 * x2 + ... + ci * xi
            //
            SetCoefficient(C);
            //
            // Перезаписываем правила в силу архитектуры сети
            //
            Rules.Clear();
            for (int i = 0; i < rulesText.Length; i++)
            {
                Rules.Add(ParseRule(rulesText[i]));
            }

            Console.WriteLine(Rules[0].ToString());
        }