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

Инкрементное обучение статических сетей

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

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

Затем для предыдущих входных параметров,

цели были бы

Для инкрементного обучения вы представляете входные параметры и цели как последовательности:

P = {[1;2] [2;1] [2;3] [3;1]};
T = {4 5 7 7};

Во-первых, настройте сеть с нулевыми начальными весами и смещениями. Кроме того, обнулите начальный темп обучения, чтобы показать эффект инкрементного обучения.

net = linearlayer(0,0);
net = configure(net,P,T);
net.IW{1,1} = [0 0];
net.b{1} = 0;

Вспомните из Симуляции с Параллельными Входными параметрами в Статической Сети, что для статической сети симуляция сети производит те же выходные параметры, представлены ли входные параметры как матрица параллельных векторов или как массив ячеек последовательных векторов. Однако это не верно при обучении сети. Когда вы используете adapt функция, если входные параметры представлены как массив ячеек последовательных векторов, то веса обновляются как каждый вход, представлена (инкрементный режим). Как показано в следующем разделе, если входные параметры представлены как матрица параллельных векторов, то веса обновляются только после того, как все входные параметры представлены (пакетный режим).

Вы теперь готовы обучить сеть инкрементно.

[net,a,e,pf] = adapt(net,P,T);

Сетевые выходные параметры остаются нуль, потому что темп обучения является нулем, и веса не обновляются. Ошибки равны целям:

a = [0]    [0]    [0]    [0]
e = [4]    [5]    [7]    [7]

Если вы теперь устанавливаете темп обучения на 0,1, вы видите, как сеть настроена, когда каждый вход представлен:

net.inputWeights{1,1}.learnParam.lr = 0.1;
net.biases{1,1}.learnParam.lr = 0.1;
[net,a,e,pf] = adapt(net,P,T);
a = [0]    [2]    [6]    [5.8]
e = [4]    [3]    [1]    [1.2]

Первый выход эквивалентен, это было с нулевым темпом обучения, потому что никакое обновление не сделано, пока первый вход не представлен. Второй выход отличается, потому что веса были обновлены. Веса продолжают изменяться, когда каждая ошибка вычисляется. Если сеть способна, и темп обучения установлен правильно, ошибка в конечном счете управляется, чтобы обнулить.

Инкрементное обучение с динамическими сетями

Можно также обучить динамические сети инкрементно. На самом деле это было бы наиболее распространенной ситуацией.

Чтобы обучить сеть инкрементно, представьте входные параметры и цели как элементы массивов ячеек. Вот начальный вход Pi и входные параметры P и цели T как элементы массивов ячеек.

Pi = {1};
P = {2 3 4};
T = {3 5 7};

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

net = linearlayer([0 1],0.1);
net = configure(net,P,T);
net.IW{1,1} = [0 0];
net.biasConnect = 0;

Вы хотите обучить сеть, чтобы создать текущую производительность путем подведения итогов тока и предыдущих входных параметров. Это - та же входная последовательность, которую вы использовали в предыдущем примере за исключением того, что вы присваиваете первый срок в последовательности как начальное условие для задержки. Можно теперь последовательно обучить сеть с помощью adapt.

[net,a,e,pf] = adapt(net,P,T,Pi);
a = [0] [2.4] [7.98]
e = [3] [2.6] [-0.98]

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

Обработайте обучение в пакетном режиме со статическими сетями

Пакетное обучение может быть сделано с помощью любого adapt или train, несмотря на то, что train обычно наилучший вариант, потому что он обычно имеет доступ к более эффективным учебным алгоритмам. Инкрементное обучение обычно делается с adapt; пакетное обучение обычно делается с train.

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

P = [1 2 2 3; 2 1 3 1];
T = [4 5 7 7];

Начните со статической сети, используемой в предыдущих примерах. Темп обучения установлен в 0,01.

net = linearlayer(0,0.01);
net = configure(net,P,T);
net.IW{1,1} = [0 0];
net.b{1} = 0;

Когда вы вызываете adapt, это вызывает trains (адаптация по умолчанию функционирует для линейной сети), и learnwh (изучение значения по умолчанию функционирует для весов и смещений). trains использование приобретение знаний Видроу-Хофф.

[net,a,e,pf] = adapt(net,P,T);
a = 0 0 0 0
e = 4 5 7 7

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

net.IW{1,1}
  ans = 0.4900 0.4100
net.b{1}
  ans =
    0.2300

Это отличается от результата после одной передачи adapt с инкрементным обновлением.

Теперь выполните то же пакетное обучение с помощью train. Поскольку правило Видроу-Хофф может быть использовано в инкрементном или пакетном режиме, оно может быть вызвано adapt или train. (Существует несколько алгоритмов, которые могут только использоваться в пакетном режиме (например, Levenberg-Marquardt), таким образом, эти алгоритмы могут только быть вызваны train.)

Для этого случая входные векторы могут быть в матрице параллельных векторов или в массиве ячеек последовательных векторов. Поскольку сеть является статической и потому что train всегда действует в пакетном режиме, train преобразует любой массив ячеек последовательных векторов к матрице параллельных векторов. Параллельная операция режима используется каждый раз, когда возможный, потому что она имеет более эффективное внедрение в коде MATLAB:

P = [1 2 2 3; 2 1 3 1];
T = [4 5 7 7];

Сеть настраивается таким же образом.

net = linearlayer(0,0.01);
net = configure(net,P,T);
net.IW{1,1} = [0 0];
net.b{1} = 0;

Теперь вы готовы обучить сеть. Обучите его в течение только одной эпохи, потому что вы использовали только одну передачу adapt. Учебной функцией по умолчанию для линейной сети является trainb, и функцией изучения значения по умолчанию для весов и смещений является learnwh, таким образом, необходимо получить те же результаты, полученные с помощью adapt в предыдущем примере, где функцией адаптации по умолчанию был trains.

net.trainParam.epochs = 1;
net = train(net,P,T);

Если вы отображаете веса после одной эпохи обучения, вы находите

net.IW{1,1}
  ans = 0.4900 0.4100
net.b{1}
  ans =
    0.2300

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

Обработайте обучение в пакетном режиме с динамическими сетями

Обучение статических сетей является относительно прямым. Если вы используете train сеть обучена в пакетном режиме, и входные параметры преобразованы в параллельные векторы (столбцы матрицы), даже если они первоначально передаются как последовательность (элементы массива ячеек). Если вы используете adapt, формат входа определяет метод обучения. Если входные параметры передаются как последовательность, то сеть обучена в инкрементном режиме. Если входные параметры передаются как параллельные векторы, то обучение пакетного режима используется.

С динамическими сетями обучение пакетного режима обычно делается с train только, особенно если только одна обучающая последовательность существует. Чтобы проиллюстрировать это, рассмотрите снова линейную сеть с задержкой. Используйте темп обучения 0,02 для обучения. (При использовании алгоритма градиентного спуска вы обычно используете меньший темп обучения в обучении пакетного режима, чем инкрементное обучение, потому что все отдельные градиенты суммированы прежде, чем определить ступенчатое изменение к весам.)

net = linearlayer([0 1],0.02);
net.inputs{1}.size = 1;
net.layers{1}.dimensions = 1;
net.IW{1,1} = [0 0];
net.biasConnect = 0;
net.trainParam.epochs = 1;
Pi = {1};
P = {2 3 4};
T = {3 5 6};

Вы хотите обучить сеть с той же последовательностью, используемой в инкрементном обучении ранее, но на этот раз вы хотите обновить веса только после того, как все входные параметры применяются (пакетный режим). Сеть симулирована в последовательном режиме, потому что вход является последовательностью, но веса обновляются в пакетном режиме.

net = train(net,P,T,Pi);

Веса после одной эпохи обучения

net.IW{1,1}
ans = 0.9000    0.6200

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