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

Этот пример использует:

Разработка комплексной нечеткой системы вывода (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: [1×3 fuzzy.tuning.MembershipFunctionSettings]
                FISName: "fis"

out = 
  VariableSettings with properties:

                   Type: "output"
           VariableName: "output1"
    MembershipFunctions: [1×3 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              147           32.84           32.84        1
    3              194           32.84           32.84        2
    4              241           32.84           32.84        3
    5              288           32.84           32.84        4
Optimization terminated: maximum number of generations exceeded.

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

optimout

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

optimout.tuningOutputs

ans = struct with fields:
             x: [5 9.1667 5.8333 10 14.1667]
          fval: 32.8363
      exitflag: 0
        output: [1×1 struct]
    population: [50×5 double]
        scores: [50×1 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              147           32.84           32.84        1
    3              194           32.84           32.84        2
    4              241           32.84           32.84        3
    5              288           32.84           32.84        4
Optimization terminated: maximum number of generations exceeded.

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

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

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

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

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

rule=3×1 object
  3×1 RuleSettings array with properties:

    Index
    Antecedent
    Consequent
    FISName

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

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

Доступны ли индексы MF ввода/вывода для настройки. По умолчанию параметры пункта свободны для настройки.
Позволяет ли пункт использование НЕ логика, другими словами, позволяет ли это отрицательные индексы MF. По умолчанию правила не позволяют НЕ логику.
Позволяет ли пункт отсутствие переменных ввода/вывода, другими словами, если это позволяет нулевые индексы 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              147           1.648           2.448        1
    3              194           1.648           2.212        2
    4              241           1.648           2.052        3
    5              288           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              147           1.648           2.448        1
    3              194           1.648           2.212        2
    4              241           1.648           2.052        3
    5              288           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              590           0.165          0.2891        1
    3              780           0.165          0.2685        2
    4              970           0.165          0.2548        3
    5             1160           0.165          0.2378        4
Optimization terminated: maximum number of generations exceeded.

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

fisout.Rules

ans = 
  1×3 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              590           0.165          0.2891        1
    3              780           0.165          0.2685        2
    4              970           0.165          0.2548        3
    5             1160           0.165          0.2378        4
Optimization terminated: maximum number of generations exceeded.

fisout.Rules

ans = 
  1×3 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              590           0.165          0.2738        1
    3              780           0.165          0.2545        2
    4              970           0.165          0.2271        3
    5             1160           0.165          0.2083        4
Optimization terminated: maximum number of generations exceeded.

fisout.Rules

ans = 
  1×3 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              590          0.1624          0.2776        1
    3              780          0.1624          0.2653        2
    4              970          0.1592          0.2486        0
    5             1160          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, отдельно настройте fis1 и fis2 параметры. Во-первых, получите установки параметров для 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 = 
  1×5 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 = 
  1×5 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 = 
  1×5 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 = 
  1×5 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, смотрите Нечеткие Деревья.

Локальные функции

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

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