Настройка нечетких систем вывода

Этот пример использование:

Разработка комплексной нечеткой системы вывода (FIS) с большим количеством входных параметров и функций принадлежности (MFS) является сложной проблемой из-за большого количества параметров MF и растущего числа правил. Многообещающее решение этой проблемы состоит в том, чтобы разработать деревья FIS, которые включают иерархически соединенный модульный ФИСС, имеющий небольшое количество входных параметров. Разработка дерева FIS с соответствующими параметрами MF и правилами, однако, является трудной задачей, когда соответствующие экспертные знания не доступны для сложной системы. Следовательно, управляемый данными подход настройки и оптимизации MF и параметров правила предлагает изящное решение этой проблемы.

Можно настроить нечеткую систему с помощью команды tunefis. Следующие данные показывают, как нечеткая система настраивается с данными тренировки ввода/вывода. Настраивающий процесс использует метод оптимизации на задаче оптимизации, созданной из нечеткой системы.

В каждой итерации метод оптимизации генерирует несколько наборов решений, которые являются значениями для выбранных параметров нечеткой системы. Нечеткая система обновляется с каждым решением и затем оценила использование входных данных тренировки. Оцененный вывод по сравнению с выходными данными тренировки, чтобы сгенерировать затраты на решения. Этот процесс продолжается для нескольких итераций, пока условие остановки не соблюдают, и затем это возвращает минимальное экономичное решение с оптимизированными нечеткими системными параметрами. Для примера, который использует этот подход, смотрите Мелодию Mamdani Нечеткая Система Вывода.

Если данные тренировки ввода/вывода не доступны, можно использовать пользовательскую модель вместо данных тренировки, чтобы оценить нечеткую систему для измерения стоимости. Этот подход показывают в следующей фигуре.

В этом случае пользовательская модель использует нечеткую систему, чтобы минимизировать стоимость достижения целей реального исполнения. Решение для параметра, которое производит лучшую производительность пользовательской модели, возвращено как результат оптимизации. Например, в модели навигации робота, цель производительности состоит в том, чтобы минимизировать расстояния, на которые путешествуют, чтобы предназначаться для положений, не сталкиваясь ни с одним из препятствий. Следовательно, модель навигации использует нечеткую систему, чтобы управлять направлением заголовка робота, чтобы достигнуть цели. Для примера, который использует этот подход, смотрите Мелодию Нечеткие Системы с помощью Пользовательской Функции стоимости.

Можно выбрать отдельный MF и управлять параметрами нечеткой системы для оптимизации.

Настройте параметры функции принадлежности

Этот пример показывает, как задать установки параметров для каждого MF ввода и вывода FIS и настроить его.

Создайте FIS.

fis = mamfis;
fis = addInput(fis,[0 10],'NumMFs',3);
fis = addOutput(fis,[0 1],'NumMFs',3);
fis = addRule(fis,[1 1 1 1;1 1 1 1;1 1 1 1]);

Извлеките установки параметров ввода и вывода от FIS.

[in,out] = getTunableSettings(fis)

in = 
  VariableSettings with properties:

                   Type: "input"
           VariableName: "input1"
    MembershipFunctions: [1x3 fuzzy.tuning.MembershipFunctionSettings]
                FISName: "fis"

out = 
  VariableSettings with properties:

                   Type: "output"
           VariableName: "output1"
    MembershipFunctions: [1x3 fuzzy.tuning.MembershipFunctionSettings]
                FISName: "fis"

Установки параметров представлены объектами VariableSettings, которые включают имя FIS, тип переменной, имя переменной и установки параметров MF. Исследуйте установки параметров MF 1 входа 1.

in(1).MembershipFunctions(1).Parameters

ans = 
  NumericParameters with properties:

    Minimum: [-Inf -Inf -Inf]
    Maximum: [Inf Inf Inf]
       Free: [1 1 1]

Для каждого значения параметров MF ввода/вывода можно задать, доступно ли это для настройки и ее минимальных и максимальных значений. По умолчанию все параметры MF свободны для настройки, и их области значений установлены в [-Inf,Inf]. Make MF 1 входа 1 ненастраиваемое.

in(1).MembershipFunctions(1) = setTunable(in(1).MembershipFunctions(1),false);

Точно так же сделайте первый параметр MF 2 входа 1 ненастраиваемым.

in(1).MembershipFunctions(2).Parameters.Free(1) = false;

Установите минимальные области значений для вторых и третьих параметров MF 3 входа от 1 до 0.

in(1).MembershipFunctions(3).Parameters.Minimum(2:3) = 0;

Установите максимальные области значений для вторых и третьих параметров MF 3 входа 1 - 15.

in(1).MembershipFunctions(3).Parameters.Maximum(2:3) = 15;

Обратите внимание на то, что минимальные и максимальные значения области значений по умолчанию настраиваемых параметров MF установлены к соответствующим областям значений ввода/вывода в настраивающем процессе.

Наконец, сделайте вывод ненастраиваемым.

out = setTunable(out,false);

Теперь, когда вы сконфигурировали параметры, задайте данные тренировки ввода и вывода. Сгенерируйте некоторые данные для этого примера.

x = (0:0.1:10)';
y = abs(sin(2*x)./exp(x/5));

Задайте опции для tunefis. Используйте генетический алгоритм для оптимизации.

options = tunefisOptions("Method","ga");

Задайте максимальные 5 поколений для оптимизации.

options.MethodOptions.MaxGenerations = 5;

Если у вас есть программное обеспечение Parallel Computing Toolbox™, можно улучшить скорость настраивающего процесса установкой options.UseParallel к true. Если у вас нет программного обеспечения Parallel Computing Toolbox, установите options.UseParallel на false.

По умолчанию tunefis использует среднеквадратическую ошибку (RMSE) для расчета стоимости. Можно изменить функцию стоимости на norm1 или norm2 установкой options.DistanceMetric.

options.DistanceMetric = "norm1";

Настройте fis с помощью установок параметров, данных тренировки, и настроив опции.

rng('default')  % for reproducibility
[fisout,optimout] = tunefis(fis,[in;out],x,y,options);

                                  Best           Mean      Stall
Generation      Func-count        f(x)           f(x)    Generations
    1              100           32.84           32.84        0
    2              150           32.84           32.84        1
    3              200           32.84           32.84        2
    4              250           32.84           32.84        3
    5              300           32.84           32.84        4
Optimization terminated: maximum number of generations exceeded.

fisout включает обновленные значения параметров. optimout обеспечивает дополнительные выходные параметры метода оптимизации и любого сообщения об ошибке, которые возвращены во время процесса обновления входа нечеткая система с помощью оптимизированных значений параметров.

optimout

optimout = struct with fields:
    tuningOutputs: [1x1 struct]
     errorMessage: []

optimout.tuningOutputs

ans = struct with fields:
             x: [5 9.1667 5.8333 10 14.1667]
          fval: 32.8363
      exitflag: 0
        output: [1x1 struct]
    population: [50x5 double]
        scores: [50x1 double]

Можно опционально настроить fis с помощью любого ввода или вывода установки параметров. В этом примере настройки выходного параметра установлены в ненастраиваемый. Поэтому настройка fis только с входными установками параметров приводит к тем же результатам.

rng('default')
tunefis(fis,in,x,y,options);

                                  Best           Mean      Stall
Generation      Func-count        f(x)           f(x)    Generations
    1              100           32.84           32.84        0
    2              150           32.84           32.84        1
    3              200           32.84           32.84        2
    4              250           32.84           32.84        3
    5              300           32.84           32.84        4
Optimization terminated: maximum number of generations exceeded.

Обратите внимание на то, что лучшие затраты на оптимизацию, показанные в столбце 3 обоих настраивающихся результатов, являются тем же самым, которое указывает, что результаты оптимизации являются тем же самым в обоих случаях.

Настройте нечеткие правила

Можно задать только параметры правила нечеткой системы для настройки.

Используйте getTunableSettings, чтобы получить установки параметров правила от нечеткой системы. Постановите, что установки параметров возвращены как третий выходной аргумент.

[~,~,rule] = getTunableSettings(fis)

rule = 
  3x1 RuleSettings array with properties:

    Index
    Antecedent
    Consequent
    FISName

Каждое правило установки параметров включает имя FIS, индекс правила в FIS и установки параметров для антецедента правила и следствия (пункт правила).

Установки параметров для пункта правила включают три опции:

Доступны ли индексы MF ввода/вывода для настройки. По умолчанию параметры пункта свободны для настройки.
Позволяет ли пункт использование НЕ логика, другими словами, позволяет ли это отрицательные индексы MF. По умолчанию правила не позволяют НЕ логику.
Позволяет ли cluase отсутствие переменных ввода/вывода, другими словами, если это позволяет нулевые индексы MF. По умолчанию отсутствие переменной позволено.

rule(1).Antecedent(1)

ans = 
  ClauseParameters with properties:

      AllowNot: 0
    AllowEmpty: 1
          Free: 1

Позвольте НЕ логику в антецеденте правила 1.

rule(1).Antecedent.AllowNot = true;

Сделайте следствие правила 1 не доступным для настройки.

rule(1).Consequent.Free = 0;

Не позволяйте отсутствие переменной в следствии правила 2.

rule(2).Consequent.AllowEmpty = false;

Установите ненастраиваемое правило 3.

rule(3) = setTunable(rule(3),false);

Установите options.DistanceMetric на norm2.

options.DistanceMetric = "norm2";

Настройте fis с установками параметров правила.

rng('default')  % for reproducibility
fisout = tunefis(fis,rule,x,y,options);

                                  Best           Mean      Stall
Generation      Func-count        f(x)           f(x)    Generations
    1              100           1.648           2.575        0
    2              150           1.648           2.448        1
    3              200           1.648           2.212        2
    4              250           1.648           2.052        3
    5              300           1.648           1.874        4
Optimization terminated: maximum number of generations exceeded.

Поскольку вы сделали правило 3 ненастраиваемым, можно исключить правило 3, когда вы настраиваете fis.

rng('default')  % for reproducibility
tunefis(fis,rule(1:2),x,y,options);

                                  Best           Mean      Stall
Generation      Func-count        f(x)           f(x)    Generations
    1              100           1.648           2.575        0
    2              150           1.648           2.448        1
    3              200           1.648           2.212        2
    4              250           1.648           2.052        3
    5              300           1.648           1.874        4
Optimization terminated: maximum number of generations exceeded.

Изучите нечеткие правила

Можно настроить нечеткую систему без любых правил в tunefis. В этом случае установите опцию OptimizationType tunefisOptions к learning так, чтобы tunefis изучил правила для FIS.

fisin = fis;
fisin.Rules = [];
options.OptimizationType = 'learning';

Задайте максимальный размер основы правила к 3. Это значение задает максимальное количество правил в настроенном FIS.

options.NumMaxRules = 3;

Обратите внимание на то, что размер настроенной основы правила может быть меньше, чем NumMaxRules, потому что tunefis удаляет дублирующиеся правила из настроенного FIS. Если вы не задаете NumMaxRules, то tunefis добавляет максимальное количество правил, определенных комбинациями входа MFs. Комбинации входа MF по умолчанию включают нулевые индексы MF, которые позволяют отсутствие переменных. Комбинации по умолчанию исключают отрицательные индексы MF, так, чтобы НЕ логика не была позволена.

Установите options.DistanceMetric на rmse и настройте FIS.

options.DistanceMetric = "rmse";
rng('default')  % for reproducibility
fisout = tunefis(fisin,[],x,y,options);

                                  Best           Mean      Stall
Generation      Func-count        f(x)           f(x)    Generations
    1              400           0.165          0.2973        0
    2              600           0.165          0.2891        1
    3              800           0.165          0.2685        2
    4             1000           0.165          0.2548        3
    5             1200           0.165          0.2378        4
Optimization terminated: maximum number of generations exceeded.

Во время настраивающего процесса FIS автоматически изучает правила после оптимизации стоимости с данными тренировки. Исследуйте настроенные правила.

fisout.Rules

ans = 
  1x3 fisrule array with properties:

    Description
    Antecedent
    Consequent
    Weight
    Connection

  Details:
                   Description           
         ________________________________

    1    "input1==mf3 => output1=mf1 (1)"
    2    "input1==mf1 => output1=mf2 (1)"
    3    "input1==mf2 => output1=mf1 (1)"

Можно удалить некоторые существующие правила и изучить дополнительные правила.

fisout.Rules(2:end) = [];
rng('default')  % for reproducibility
fisout = tunefis(fisin,[],x,y,options);

                                  Best           Mean      Stall
Generation      Func-count        f(x)           f(x)    Generations
    1              400           0.165          0.2973        0
    2              600           0.165          0.2891        1
    3              800           0.165          0.2685        2
    4             1000           0.165          0.2548        3
    5             1200           0.165          0.2378        4
Optimization terminated: maximum number of generations exceeded.

fisout.Rules

ans = 
  1x3 fisrule array with properties:

    Description
    Antecedent
    Consequent
    Weight
    Connection

  Details:
                   Description           
         ________________________________

    1    "input1==mf3 => output1=mf1 (1)"
    2    "input1==mf1 => output1=mf2 (1)"
    3    "input1==mf2 => output1=mf1 (1)"

Можно также настроить существующие правила и изучить новые правила.

fisout.Rules(2:end) = [];
fisout.Rules(1).Antecedent = 1;
fisout.Rules(1).Consequent = 1;
[~,~,rule] = getTunableSettings(fisout);
rng('default')
fisout = tunefis(fisin,rule,x,y,options);

                                  Best           Mean      Stall
Generation      Func-count        f(x)           f(x)    Generations
    1              400           0.165          0.3075        0
    2              600           0.165          0.2738        1
    3              800           0.165          0.2545        2
    4             1000           0.165          0.2271        3
    5             1200           0.165          0.2083        4
Optimization terminated: maximum number of generations exceeded.

fisout.Rules

ans = 
  1x3 fisrule array with properties:

    Description
    Antecedent
    Consequent
    Weight
    Connection

  Details:
                   Description           
         ________________________________

    1    "input1==mf1 => output1=mf2 (1)"
    2    "input1==mf2 => output1=mf1 (1)"
    3    "input1==mf3 => output1=mf1 (1)"

Настройте параметры правила и MF

Можно настроить все параметры FIS вместе.

[in,out,rule] = getTunableSettings(fis);
options = tunefisOptions('Method','ga');
options.MethodOptions.MaxGenerations = 5;
rng('default')  % for reproducibility
fisout = tunefis(fis,[in;out;rule],x,y,options);

                                  Best           Mean      Stall
Generation      Func-count        f(x)           f(x)    Generations
    1              400          0.1624          0.2997        0
    2              600          0.1624          0.2776        1
    3              800          0.1624          0.2653        2
    4             1000          0.1592          0.2486        0
    5             1200          0.1592          0.2342        1
Optimization terminated: maximum number of generations exceeded.

Для большой нечеткой системы, настраивая все параметры FIS в том же настраивающем процессе может взять несколько итераций, чтобы получить ожидаемые результаты. Следовательно, вы можете настройки параметров на двух шагах:

Настройте или изучите параметры правила только.
Настройте и MF и параметры правила.

Первый шаг является менее в вычислительном отношении дорогим из-за небольшого количества параметров правила. Это быстро сходится к нечеткой основе правила во время обучения. На втором шаге с помощью основы правила от первого шага, когда начальное условие обеспечивает быструю сходимость настраивающего процесса параметра.

Настройте древовидные параметры FIS

Можно настроить параметры дерева FIS с помощью подобного двухступенчатого процесса для того, описанного выше для настройки FIS.

Создайте дерево FIS к модели $\frac{\sin (x) + потому что (x)}{\exp (x)}$ как показано в следующей фигуре.

Создайте fis1, когда Sugeno вводит FIS, который приводит к более быстрому настраивающему процессу из-за в вычислительном отношении эффективного defuzzification метода. Добавьте два входных параметров с областью значений [0 10] наличие трех MFS каждый. Используйте сглаженный дифференцируемый MF, такой как gaussmf, чтобы совпадать с характеристиками типа данных, который вы моделируете.

fis1 = sugfis('Name','fis1');
fis1 = addInput(fis1,[0 10],'NumMFs',3,'MFType','gaussmf');
fis1 = addInput(fis1,[0 10],'NumMFs',3,'MFType','gaussmf');

Добавьте вывод с областью значений [–1.5 1.5] наличие девяти MFS, чтобы обеспечить максимальную гранулярность, соответствующую каждой комбинации входа MFs. Выходная область значений установлена согласно значениям $\sin (x) + потому что (x)$ .

fis1 = addOutput(fis1,[-1.5 1.5],'NumMFs',9);

Создайте fis2, когда Sugeno вводит FIS также. Добавьте два входных параметров. Используйте [-1.5 1.5] как область значений первого входа, который является выводом fis1. Второй вход совпадает с входными параметрами fis1, таким образом, это также использует область значений [0 10]. Добавьте три MFS для каждых из входных параметров.

fis2 = sugfis('Name','fis2');
fis2 = addInput(fis2,[-1.5 1.5],'NumMFs',3,'MFType','gaussmf');
fis2 = addInput(fis2,[0 10],'NumMFs',3,'MFType','gaussmf');

Добавьте вывод с областью значений [0 1] наличие девяти MFS, чтобы обеспечить максимальную гранулярность, соответствующую каждой комбинации входа MFs. Выходная область значений установлена согласно значениям $\frac{\sin (x) + потому что (x)}{\exp (x)}$ .

fis2 = addOutput(fis2,[0 1],'NumMFs',9);

Соедините входные параметры и выходные параметры как показано в схеме. Выведите 1 из fis1, соединяет с входным 1 из fis2, вводит 1, и 2 из fis1 соединяются друг с другом и вводят 2 из подключений fis1 к входному 2 из fis2.

con1 = ["fis1/output1" "fis2/input1"];
con2 = ["fis1/input1" "fis1/input2"];
con3 = ["fis1/input2" "fis2/input2"];

Наконец, создайте дерево FIS с помощью fis1, fis2, con1, con2 и con3.

fisT = fistree([fis1 fis2],[con1;con2;con3]);

Задайте дополнительный вывод к дереву FIS, чтобы получить доступ к выводу fis1.

fisT.Outputs = ["fis1/output1";fisT.Outputs];

Сгенерируйте данные тренировки ввода и вывода.

x = (0:0.1:10)';
y1 = sin(x)+cos(x);
y2 = y1./exp(x);
y = [y1 y2];

Настройте древовидные параметры FIS на двух шагах. Во-первых, используйте глобальный метод оптимизации, такой как рой частицы или генетический алгоритм, чтобы изучить правила дерева FIS. Создайте опции tunefis для изучения с методом particleswarm.

options = tunefisOptions('Method','particleswarm','OptimizationType','learning');

Этот настраивающий шаг использует небольшое количество итераций, чтобы изучить основу правила, не сверхсоответствуя данным тренировки. Основа правила обеспечивает образованное начальное условие для второго шага, чтобы оптимизировать все древовидные параметры FIS вместе. Определите максимальный номер итерации к 5 и изучите основу правила.

options.MethodOptions.MaxIterations = 5;
rng('default')  % for reproducibility
fisTout1 = tunefis(fisT,[],x,y,options);

                                 Best            Mean     Stall
Iteration     f-count            f(x)            f(x)    Iterations
    0             100          0.6682          0.9395        0
    1             200          0.6682           1.023        0
    2             300          0.6652          0.9308        0
    3             400          0.6259           0.958        0
    4             500          0.6259           0.918        1
    5             600          0.5969          0.9179        0
Optimization ended: number of iterations exceeded OPTIONS.MaxIterations.

Чтобы настроить все древовидные параметры FIS, второй шаг использует локальный метод оптимизации, такой как поиск шаблона или метод отжига симуляции. Локальная оптимизация обычно быстрее, чем глобальная оптимизация и может привести к лучшим результатам, когда вход нечеткие системные параметры уже сопоставим с данными тренировки.

Используйте метод patternsearch для оптимизации. Определите номер итераций к 25.

options.Method = 'patternsearch';
options.MethodOptions.MaxIterations = 25;

Используйте getTunableSettings, который будет введен, выведен, и управляйте установками параметров от fisTout1.

[in,out,rule] = getTunableSettings(fisTout1);

Настройте все древовидные параметры FIS.

rng('default') % for reproducibility
fisTout2 = tunefis(fisTout1,[in;out;rule],x,y,options);

Iter     Func-count       f(x)      MeshSize     Method
    0           1       0.596926             1      
    1           3       0.551284             2     Successful Poll
    2          13       0.548551             4     Successful Poll
    3          20       0.546331             8     Successful Poll
    4          33       0.527482            16     Successful Poll
    5          33       0.527482             8     Refine Mesh
    6          61       0.511532            16     Successful Poll
    7          61       0.511532             8     Refine Mesh
    8          92       0.505355            16     Successful Poll
    9          92       0.505355             8     Refine Mesh
   10         128       0.505355             4     Refine Mesh
   11         175       0.487734             8     Successful Poll
   12         212       0.487734             4     Refine Mesh
   13         265       0.487734             2     Refine Mesh
   14         275       0.486926             4     Successful Poll
   15         328       0.486926             2     Refine Mesh
   16         339       0.483683             4     Successful Poll
   17         391       0.483683             2     Refine Mesh
   18         410       0.442624             4     Successful Poll
   19         462       0.442624             2     Refine Mesh
   20         469        0.44051             4     Successful Poll
   21         521        0.44051             2     Refine Mesh
   22         542       0.435381             4     Successful Poll
   23         594       0.435381             2     Refine Mesh
   24         614       0.398872             4     Successful Poll
   25         662       0.398385             8     Successful Poll
   26         698       0.398385             4     Refine Mesh
Maximum number of iterations exceeded: increase options.MaxIterations.

Стоимость оптимизации уменьшает с 0,59 до 0,39 на втором шаге.

Настройте дерево FIS с выбранными нечеткими системами

Можно настроить определенные нечеткие системы в дереве FIS. Чтобы получить установки параметров определенных нечетких систем, используйте getTunableSettings. Например, после изучения основы правила предыдущего дерева FIS, отдельно настройте параметры fis2 и fis1. Во-первых, получите установки параметров для fis1.

[in,out,rule] = getTunableSettings(fisTout1,"FIS","fis1");

Настройте параметры fis1 дерева.

rng('default')
fisTout2 = tunefis(fisTout1,[in;out;rule],x,y,options);

Iter     Func-count       f(x)      MeshSize     Method
    0           1       0.596926             1      
    1           3       0.551284             2     Successful Poll
    2          18       0.510362             4     Successful Poll
    3          28       0.494804             8     Successful Poll
    4          56       0.494804             4     Refine Mesh
    5          84       0.493422             8     Successful Poll
    6         107       0.492883            16     Successful Poll
    7         107       0.492883             8     Refine Mesh
    8         136       0.492883             4     Refine Mesh
    9         171       0.492883             2     Refine Mesh
   10         178       0.491534             4     Successful Poll
   11         213       0.491534             2     Refine Mesh
   12         229       0.482682             4     Successful Poll
   13         264       0.482682             2     Refine Mesh
   14         279       0.446645             4     Successful Poll
   15         313       0.446645             2     Refine Mesh
   16         330        0.44657             4     Successful Poll
   17         364        0.44657             2     Refine Mesh
   18         384       0.446495             4     Successful Poll
   19         418       0.446495             2     Refine Mesh
   20         461       0.445938             4     Successful Poll
   21         495       0.445938             2     Refine Mesh
   22         560       0.422421             4     Successful Poll
   23         594       0.422421             2     Refine Mesh
   24         597       0.397265             4     Successful Poll
   25         630       0.397265             2     Refine Mesh
   26         701       0.390338             4     Successful Poll
Maximum number of iterations exceeded: increase options.MaxIterations.

В этом случае стоимость оптимизации улучшена путем настройки только значений параметров fis1.

Затем, получите настройки параметра для fis2 и настройте параметры fis2.

[in,out,rule] = getTunableSettings(fisTout2,"FIS","fis2");
rng('default') 
fisTout3 = tunefis(fisTout2,[in;out;rule],x,y,options);

Iter     Func-count       f(x)      MeshSize     Method
    0           1       0.390338             1      
    1           2       0.374103             2     Successful Poll
    2           5       0.373855             4     Successful Poll
    3          10       0.356619             8     Successful Poll
    4          33       0.356619             4     Refine Mesh
    5          43       0.350715             8     Successful Poll
    6          65       0.349417            16     Successful Poll
    7          65       0.349417             8     Refine Mesh
    8          87       0.349417             4     Refine Mesh
    9          91       0.349356             8     Successful Poll
   10         112       0.349356             4     Refine Mesh
   11         138       0.346102             8     Successful Poll
   12         159       0.346102             4     Refine Mesh
   13         172       0.345938             8     Successful Poll
   14         193       0.345938             4     Refine Mesh
   15         222       0.342721             8     Successful Poll
   16         244       0.342721             4     Refine Mesh
   17         275       0.342721             2     Refine Mesh
   18         283       0.340727             4     Successful Poll
   19         312       0.340554             8     Successful Poll
   20         335       0.340554             4     Refine Mesh
   21         366       0.340554             2     Refine Mesh
   22         427       0.337873             4     Successful Poll
   23         457       0.337873             2     Refine Mesh
   24         521        0.33706             4     Successful Poll
   25         551        0.33706             2     Refine Mesh
   26         624       0.333193             4     Successful Poll
Maximum number of iterations exceeded: increase options.MaxIterations.

Стоимость оптимизации далее уменьшается путем настройки значений параметров fis2. Чтобы постараться не сверхсоответствовать отдельных значений параметров FIS, можно далее настроить и fis1 и параметры fis2 вместе.

[in,out,rule] = getTunableSettings(fisTout3);
rng('default') 
fisTout4 = tunefis(fisTout3,[in;out;rule],x,y,options);

Iter     Func-count       f(x)      MeshSize     Method
    0           1       0.333193             1      
    1           8       0.326804             2     Successful Poll
    2          91       0.326432             4     Successful Poll
    3         116       0.326261             8     Successful Poll
    4         154       0.326261             4     Refine Mesh
    5         205       0.326261             2     Refine Mesh
    6         302       0.326092             4     Successful Poll
    7         352       0.326092             2     Refine Mesh
    8         391       0.325964             4     Successful Poll
    9         441       0.325964             2     Refine Mesh
   10         478        0.32578             4     Successful Poll
   11         528        0.32578             2     Refine Mesh
   12         562       0.325691             4     Successful Poll
   13         612       0.325691             2     Refine Mesh
   14         713       0.229273             4     Successful Poll
   15         763       0.229273             2     Refine Mesh
   16         867        0.22891             4     Successful Poll
   17         917        0.22891             2     Refine Mesh
   18        1036       0.228688             4     Successful Poll
   19        1086       0.228688             2     Refine Mesh
   20        1212       0.228688             1     Refine Mesh
   21        1266       0.228445             2     Successful Poll
   22        1369       0.228441             4     Successful Poll
   23        1381       0.227645             8     Successful Poll
   24        1407       0.226125            16     Successful Poll
   25        1407       0.226125             8     Refine Mesh
   26        1447       0.226125             4     Refine Mesh
Maximum number of iterations exceeded: increase options.MaxIterations.

В целом, стоимость оптимизации уменьшает с 0,59 до 0,22 на трех шагах.

Настройтесь с пользовательской функцией стоимости

Предположим, что вы хотите изменить предыдущее дерево FIS как показано в следующей схеме.

Создайте дерево FIS.

fis1 = sugfis('Name','fis1');
fis1 = addInput(fis1,[0 10],'NumMFs',3,'MFType','gaussmf');
fis1 = addOutput(fis1,[-1 1],'NumMFs',3);

fis2 = sugfis('Name','fis2');
fis2 = addInput(fis2,[0 10],'NumMFs',3,'MFType','gaussmf');
fis2 = addOutput(fis2,[-1 1],'NumMFs',3);

fis3 = sugfis('Name','fis3');
fis3 = addInput(fis3,[0 10],'NumMFs',3,'MFType','gaussmf');
fis3 = addOutput(fis3,[0 1],'NumMFs',3);

con = ["fis1/input1" "fis2/input1";"fis2/input1" "fis3/input1"];

fisT = fistree([fis1 fis2 fis3],con);

Чтобы реализовать операции сложения и умножения, используйте пользовательскую функцию стоимости. В данном примере используйте функциональный customcostfcn, включенный в конце примера. Изучите основу правила с этой функцией стоимости.

options.Method = 'particleswarm';
options.MethodOptions.MaxIterations = 5;
rng('default')
fisTout1 = tunefis(fisT,[],@(fis)customcostfcn(fis,x,y),options);

                                 Best            Mean     Stall
Iteration     f-count            f(x)            f(x)    Iterations
    0             100           0.746           1.318        0
    1             200          0.5787           1.236        0
    2             300          0.5787           1.104        1
    3             400          0.5787           1.097        0
    4             500          0.5171           1.155        0
    5             600          0.5171           1.067        1
Optimization ended: number of iterations exceeded OPTIONS.MaxIterations.

Настройте все параметры дерева FIS.

options.Method = 'patternsearch';
options.MethodOptions.MaxIterations = 25;
[in,out,rule] = getTunableSettings(fisTout1);
rng('default')
fisTout2 = tunefis(fisTout1,[in;out;rule],@(fis)customcostfcn(fis,x,y),options);

Iter     Func-count       f(x)      MeshSize     Method
    0           1        0.51705             1      
    1          11       0.514884             2     Successful Poll
    2          21       0.512873             4     Successful Poll
    3          43       0.512873             8     Successful Poll
    4          56       0.512873             4     Refine Mesh
    5          79       0.512873             2     Refine Mesh
    6         106       0.512869             4     Successful Poll
    7         129       0.512869             2     Refine Mesh
    8         174       0.512869             1     Refine Mesh
    9         197       0.512862             2     Successful Poll
   10         242       0.512862             1     Refine Mesh
   11         314       0.512862           0.5     Refine Mesh
   12         388       0.512862          0.25     Refine Mesh
   13         422       0.510163           0.5     Successful Poll
   14         429       0.509153             1     Successful Poll
   15         439       0.509034             2     Successful Poll
   16         460       0.509034             4     Successful Poll
   17         483       0.507555             8     Successful Poll
   18         495       0.507555             4     Refine Mesh
   19         519       0.507555             2     Refine Mesh
   20         565       0.507555             1     Refine Mesh
   21         636       0.507555             2     Successful Poll
   22         682       0.507555             1     Refine Mesh
   23         755       0.507555           0.5     Refine Mesh
   24         799       0.507554             1     Successful Poll
   25         872       0.507554           0.5     Refine Mesh
   26         947       0.507554          0.25     Refine Mesh
Maximum number of iterations exceeded: increase options.MaxIterations.

Можно добавить больше MFS ввода/вывода и задать дополнительные древовидные выходные параметры FIS, чтобы улучшать настраивающуюся производительность. Используя дополнительные параметры MF и больше данных тренировки для дополнительных древовидных выходных параметров FIS может далее точно настроить выходные параметры fis1, fis2 и fis3.

Пользовательский метод оптимизации

Можно реализовать собственный метод оптимизации параметров управления FIS с помощью getTunableSettings, getTunableValues и setTunableValues. Этот пример использует эти функции, чтобы настроить основу правила нечеткой системы.

Создайте FIS, чтобы аппроксимировать $\sin (θ)$ , где $θ$ отличается от 0 до $2 π$ .

fisin = mamfis;

Добавьте вход с областью значений [0 $2 π$ ] наличие пяти MFS Гауссова типа и вывода с областью значений [–1 1] наличие пяти MFS Гауссова типа.

fisin = addInput(fisin,[0 2*pi],'NumMFs',5,'MFType','gaussmf');
fisin = addOutput(fisin,[-1 1],'NumMFs',5,'MFType','gaussmf');

Добавьте 5 правил.

fisin = addRule(fisin,[1 1 1 1;2 2 1 1;3 3 1 1;4 4 1 1;5 5 1 1]);
fisin.Rules

ans = 
  1x5 fisrule array with properties:

    Description
    Antecedent
    Consequent
    Weight
    Connection

  Details:
                   Description           
         ________________________________

    1    "input1==mf1 => output1=mf1 (1)"
    2    "input1==mf2 => output1=mf2 (1)"
    3    "input1==mf3 => output1=mf3 (1)"
    4    "input1==mf4 => output1=mf4 (1)"
    5    "input1==mf5 => output1=mf5 (1)"

Установите DisableStructuralChecks на истину для быстрее обновления FIS.

fisin.DisableStructuralChecks = true;

Получите установки параметров правила.

[~,~,rule] = getTunableSettings(fisin);

Сделайте антецедент ненастраиваемым. В следствии не позволяйте НЕ логику (отрицательные индексы MF) или пустые переменные (нулевые индексы MF) в правилах.

for i = 1:numel(rule)
    rule(i).Antecedent.Free = false;
    rule(i).Consequent.AllowNot = false;
    rule(i).Consequent.AllowEmpty = false;
end

Сгенерируйте данные для настройки.

x = (0:0.1:2*pi)';
y = sin(x);

Чтобы настроить параметры правила, используйте функцию, определяемую customtunefis в конце этого примера. Определите номер итераций к 2 и не позволяйте значения недопустимого параметра при обновлении FIS использование setTunableValues.

numite = 2;
ignoreinvp = false;
fisout = customtunefis(fisin,rule,x,y,numite,ignoreinvp);

Initial cost = 1.170519
Iteration 1: Cost = 0.241121
Iteration 2: Cost = 0.241121

Отобразите настроенные правила.

fisout.Rules

ans = 
  1x5 fisrule array with properties:

    Description
    Antecedent
    Consequent
    Weight
    Connection

  Details:
                   Description           
         ________________________________

    1    "input1==mf1 => output1=mf4 (1)"
    2    "input1==mf2 => output1=mf5 (1)"
    3    "input1==mf3 => output1=mf3 (1)"
    4    "input1==mf4 => output1=mf1 (1)"
    5    "input1==mf5 => output1=mf2 (1)"

Позвольте НЕ логику в правилах и оптимизируйте FIS снова.

for i = 1:numel(rule)
    rule(i).Consequent.AllowNot = true;
end
fisout = customtunefis(fisin,rule,x,y,numite,ignoreinvp);

Initial cost = 1.170519
Iteration 1: Cost = 0.357052
Iteration 2: Cost = 0.241121

fisout.Rules

ans = 
  1x5 fisrule array with properties:

    Description
    Antecedent
    Consequent
    Weight
    Connection

  Details:
                   Description           
         ________________________________

    1    "input1==mf1 => output1=mf4 (1)"
    2    "input1==mf2 => output1=mf5 (1)"
    3    "input1==mf3 => output1=mf3 (1)"
    4    "input1==mf4 => output1=mf1 (1)"
    5    "input1==mf5 => output1=mf2 (1)"

С НЕ логика, существует больше комбинаций параметров правила, и обычно требуется больше итераций, чтобы настроить FIS.

Затем, сбросьте AllowNot к false и установите AllowEmpty на true, другими словами, позвольте отсутствие переменных (обнулите индексы вывода MF) в следствии. Настройте FIS с обновленными установками параметров правила.

for i = 1:numel(rule)
    rule(i).Consequent.AllowNot = false;
    rule(i).Consequent.AllowEmpty = true;
end

try
    fisout = customtunefis(fisin,rule,x,y,numite,ignoreinvp);
catch me
    disp("Error: "+me.message)
end

Initial cost = 1.170519
Error: Rule consequent must have at least one nonzero membership function index.

Настраивающие сбои процесса начиная с FIS только содержат тот вывод, который должен быть ненулевой (непустой) в следствии правила. Чтобы проигнорировать значения недопустимого параметра, задайте IgnoreInvalidParameters с setTunableValues.

Установите ignoreinvp на true, который задает значение IgnoreInvalidParameters в вызове setTunableValues, используемого в customtunefis.

ignoreinvp = true;
fisout = customtunefis(fisin,rule,x,y,numite,ignoreinvp);

Initial cost = 1.170519
Iteration 1: Cost = 0.241121
Iteration 2: Cost = 0.241121

fisout.Rules

ans = 
  1x5 fisrule array with properties:

    Description
    Antecedent
    Consequent
    Weight
    Connection

  Details:
                   Description           
         ________________________________

    1    "input1==mf1 => output1=mf4 (1)"
    2    "input1==mf2 => output1=mf5 (1)"
    3    "input1==mf3 => output1=mf3 (1)"
    4    "input1==mf4 => output1=mf1 (1)"
    5    "input1==mf5 => output1=mf2 (1)"

В этом случае настраивающий процесс обходит недопустимые значения и использует только допустимые значения параметров для оптимизации.

По умолчанию tunefis игнорирует недопустимые значения при обновлении нечетких системных параметров. Можно изменить это поведение установкой tunefisOptions.IgnoreInvalidParameters к false.

Сгенерируйте FIS от данных и мелодии

Можно сгенерировать FIS от данных тренировки с помощью genfis и затем оптимизировать FIS с tunefis. В этом подходе настраивающий процесс может использовать локальный метод оптимизации, потому что основа правила выведена от данных тренировки.

Этот пример описывает настраивающиеся шаги, чтобы аппроксимировать функцию

$\frac{\sin (2 x)}{\exp (\frac{x}{5})}$ ,

где вход $x$ отличается от 0 до 10.

Сгенерируйте данные тренировки.

x = (0:0.1:10)';
y = sin(2*x)./exp(x/5);

Создайте опции для genfis, которые задают пять MFS, Гауссов MF для входа и постоянный MF для вывода.

goptions = genfisOptions('GridPartition','NumMembershipFunctions',5, ...
    'InputMembershipFunctionType','gaussmf', ...
    'OutputMembershipFunctionType','constant');

Сгенерируйте начальный FIS и получите его установки параметров.

fisin = genfis(x,y,goptions);
[in,out,rule] = getTunableSettings(fisin);

Используйте метод поиска шаблона для оптимизации, определяя максимальный номер итераций к 25, и настройте FIS.

toptions = tunefisOptions('Method','patternsearch');
toptions.MethodOptions.MaxIterations = 25;
rng('default')
fisout = tunefis(fisin,[in;out],x,y,toptions);

Iter     Func-count       f(x)      MeshSize     Method
    0           1       0.346649             1      
    1          19       0.346649           0.5     Refine Mesh
    2          28       0.295219             1     Successful Poll
    3          34       0.295069             2     Successful Poll
    4          48       0.295069             1     Refine Mesh
    5          56       0.295064             2     Successful Poll
    6          71       0.294986             4     Successful Poll
    7          82       0.294986             2     Refine Mesh
    8          98       0.294986             1     Refine Mesh
    9         112       0.293922             2     Successful Poll
   10         128       0.293922             1     Refine Mesh
   11         131        0.29151             2     Successful Poll
   12         144       0.290141             4     Successful Poll
   13         156       0.290141             2     Refine Mesh
   14         171       0.290006             4     Successful Poll
   15         184       0.290006             2     Refine Mesh
   16         200       0.290006             1     Refine Mesh
   17         207       0.289743             2     Successful Poll
   18         223       0.289743             1     Refine Mesh
   19         243       0.289743           0.5     Refine Mesh
   20         257       0.286935             1     Successful Poll
   21         260       0.282278             2     Successful Poll
   22         263       0.281878             4     Successful Poll
   23         267       0.280144             8     Successful Poll
   24         272       0.280144             4     Refine Mesh
   25         278       0.275167             8     Successful Poll
   26         284       0.275167             4     Refine Mesh
Maximum number of iterations exceeded: increase options.MaxIterations.

Можно увеличить число итераций, чтобы далее оптимизировать стоимость.

Подтвердите учебные результаты

Чтобы постараться не сверхсоответствовать обучающих наборов данных, проверяйте производительность обученной нечеткой системы с данными о валидации. Один общий подход должен разделить доступные данные на наборы данных обучения и валидации так, чтобы оба набора данных включали подобные характеристики.

Если обучение и производительность валидации значительно отличаются, вы можете:

Измените максимальное количество настраивающихся итераций. Например, если учебная производительность лучше, чем производительность валидации, можно сократить количество настраивающихся итераций.
Передискретизируйте наборы данных обучения и валидации, чтобы поддержать однородность.

Чтобы видеть, как производительность валидации может отличаться на основе неоднородной выборки, создайте один вход один вывод нечеткая система вывода, чтобы смоделировать функцию

$\frac{\sin (2 x)}{\exp (\frac{x}{5})}$ ,

где вход отличается от 0 до 10, и выходная область значений [0 1]. Добавьте пять MFS по умолчанию во ввод и вывод. Получите установки параметров ввода и вывода.

fisin = sugfis;
fisin = addInput(fisin,[0 10],'NumMFs',5,'MFType','gaussmf');
fisin = addOutput(fisin,[0 1],'NumMFs',5);
[in,out] = getTunableSettings(fisin);

Создайте опции tunefis для learning с методом оптимизации particleswarm и определите максимальный номер итераций к 5.

options = tunefisOptions('Method','particleswarm','OptimizationType','learning');
options.MethodOptions.MaxIterations = 5;

Разделите доступные данные на два набора, не поддерживая однородность в наборах данных.

x = (0:0.1:10)';
n = numel(x);
midn = floor(n/2);
trnX = x(1:midn);
vldX = x(midn+1:end);
f = @(x)(sin(2*x)./exp(x/5));
trnY = f(trnX);
vldY = f(vldX);

Настройте параметры FIS.

rng('default')
fisout = tunefis(fisin,[in;out],trnX,trnY,options);

                                 Best            Mean     Stall
Iteration     f-count            f(x)            f(x)    Iterations
    0             100          0.4279          0.5932        0
    1             200          0.3846          0.6183        0
    2             300          0.3751          0.5675        0
    3             400          0.3606           0.568        0
    4             500          0.3606          0.5596        1
    5             600          0.3598          0.5307        0
Optimization ended: number of iterations exceeded OPTIONS.MaxIterations.

Найдите оптимизацию стоившей за данные о валидации с помощью функции, определяемой findcost в конце этого примера.

vldCost = findcost(fisout,vldX,vldY)

vldCost = 0.1780

Обратите внимание на то, что стоимость валидации отличается от лучшей стоимости обучения, показанной в столбце 3 настраивающегося результата.

Затем, передискретизируйте доступные данные и создайте два однородных набора данных для обучения и валидации.

trnX = x(1:2:end);
vldX = x(2:2:end);
f = @(x)(sin(2*x)./exp(x/5));
trnY = f(trnX);
vldY = f(vldX);

Настройте FIS с новыми данными тренировки.

rng('default')
fisout = tunefis(fisin,[in;out],trnX,trnY,options);

                                 Best            Mean     Stall
Iteration     f-count            f(x)            f(x)    Iterations
    0             100          0.3445          0.5852        0
    1             200          0.2996          0.5616        0
    2             300          0.2907          0.5381        0
    3             400          0.2878          0.5334        0
    4             500          0.2878          0.5624        1
    5             600          0.2877             Inf        0
Optimization ended: number of iterations exceeded OPTIONS.MaxIterations.

Найдите оптимизацию стоившей за новые данные о валидации.

vldCost = findcost(fisout,vldX,vldY)

vldCost = 0.2803

В этом случае однородная выборка уменьшает различие между затратами на обучение и валидацию.

Способы улучшить настраивающиеся результаты

Можно улучшить учебную ошибку настроенные нечеткие системы следующим эти инструкции.

Используйте несколько шагов в настраивающем процессе. Например, сначала изучите правила нечеткой системы, и затем настройте параметры MF ввода/вывода с помощью изученной основы правила. Можно также отдельно настроить отдельные параметры FIS в дереве FIS и затем настроить все нечеткие системы вместе, чтобы обобщить значения параметров.
Увеличьте число итераций и в изучающих правило и в настраивающих параметр фазах. Выполнение так увеличивает длительность процесса оптимизации. Это может также увеличить ошибку валидации из-за сверхнастроенных системных параметров с данными тренировки.
Используйте глобальные методы оптимизации, такие как ga и particleswarm, и в изучающих правило и в настраивающих параметр фазах. Глобальные оптимизаторы ga и particleswarm выполняют лучше для больших диапазонов настройки параметра, чем локальные оптимизаторы. Локальные оптимизаторы patternsearch и simulannealbnd выполняют лучше для маленьких областей значений параметра. Если правила уже добавляются к дереву FIS с помощью данных тренировки, то patternsearch и simulannealbnd могут произвести более быструю сходимость по сравнению с ga и particleswarm. Для получения дополнительной информации об этих методах оптимизации и их опциях, смотрите ga, particleswarm, patternsearch и simulannealbnd.
Измените кластеризирующийся метод, используемый genfis. В зависимости от кластеризирующегося метода сгенерированные правила могут отличаться по своему представлению данных тренировки. Следовательно, использование различных методов кластеризации может влиять на производительность tunefis.
Свойства Change FIS. Попытайтесь изменить свойства, такие как тип FIS, количество входных параметров, количество MFS ввода/вывода, типов MF и количества правил. Система Sugeno имеет меньше параметров вывода MF (принимающий постоянный MFS) и быстрее defuzzification. Поэтому для нечетких систем с большим количеством входных параметров, Sugeno FIS обычно сходится быстрее, чем Mamdani FIS. Небольшие числа MFS и правил сокращают количество параметров, чтобы настроиться, производя более быстрый настраивающий процесс. Кроме того, большое количество правил может сверхсоответствовать данным тренировки.
Измените настройки настраиваемого параметра для MFS и правил. Например, можно настроить поддержку треугольного MF, не изменяя его пиковое местоположение. Выполнение так сокращает количество настраиваемых параметров и может произвести более быстрый настраивающий процесс для определенных приложений. Для правил можно исключить нулевые индексы MF путем установки AllowEmpty настраиваемая установка на false, который сокращает общее количество правил во время фазы изучения.
Измените древовидные свойства FIS, такие как количество нечетких систем и связей между нечеткими системами.
Используйте различный рейтинг и группировку входных параметров к дереву FIS. Для получения дополнительной информации о создании деревьев FIS, смотрите Нечеткие Деревья.

Localfunctions

function cost = customcostfcn(fis,x,y)

tY = evalfis(fis,x);
sincosx = tY(:,1)+tY(:,2);
sincosexpx = sincosx.*tY(:,3);
actY = [sincosx;sincosexpx];
d = y(:)-actY;
cost = sqrt(mean(d.*d));

end

function fis = customtunefis(fis,rule,x,y,n,ignore)

% Show initial cost.
cost = findcost(fis,x,y);
fprintf('Initial cost = %f\n',cost);

% Optimize rule parameters.
numMFs = numel(fis.Outputs.MembershipFunctions);
for ite = 1:n
    for i = 1:numel(rule)
        % Get consequent value.
        pval = getTunableValues(fis,rule(i));
        % Loop through output MF indices to minimize the cost.
        % Use output indices according to AllowNot and AllowEmpty.
        allowNot = rule(i).Consequent.AllowNot;
        allowEmpty = rule(i).Consequent.AllowEmpty;
        if allowNot && allowEmpty
            mfID = -numMFs:numMFs;
        elseif allowNot && ~allowEmpty
            mfID = [-numMFs:-1 1:numMFs];
        elseif ~allowNot && allowEmpty
            mfID = 0:numMFs;
        else
            mfID = 1:numMFs;
        end
        cost = 1000;
        minCostFIS = fis;
        for j = 1:length(mfID)
            % Update consequent value.
            pval(1) = mfID(j);
            % Set updated consequent value to the FIS.
            fis = setTunableValues(fis,rule(i),pval,'IgnoreInvalidParameters',ignore);
            % Evaluate cost.
            rmse = findcost(fis,x,y);
            % Update FIS with the minimum cost.
            if rmse<cost
                cost = rmse;
                minCostFIS = fis;
            end
        end
        fis = minCostFIS;
    end
    fprintf('Iteration %d: Cost = %f\n',ite,cost);
end

end

function cost = findcost(fis,x,y)

actY = evalfis(fis,x);
d = y - actY;
cost = sqrt(mean(d.*d));

end

Документация