Лабораторная работа № 3. Обучение искусственных нейронных сетей

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

Задание 1. Выполнив следующие действия, адаптировать параметры однослойной статической линейной сети с двумя входами для аппроксимации линейной зависимости вида t = 2p₁ + p₂.

1. С помощью конструктора линейного слоя

net = newlin(PR, s, id, lr),

где PR – массив размера R2 минимальных и максимальных значений для R векторов входа; s – число нейронов в слое; id – описание линий задержек на входе слоя; lr – параметр скорости настройки, сформировать линейную сеть:

net = newlin([–1 1; –1 1], 1, 0, 0).

2. Подготовить обучающие последовательности в виде массивов ячеек, используя зависимости t = 2p₁ + p₂ и четыре пары значений p₁ и p₂ (произвольные):

P = {[ –1; 1] [–1/3; 1/4] [1/2; 0] [1/6; 2/3]};

T = { –1 –5/12 1 1 }.

3. Для группировки представления обучающей последовательности преобразовать массивы ячеек в массивы чисел:

P1 = [P{:}], T1 = [T{:}].

4. Выполнить команды net и gensim(net), проанализировать поля вычислительной модели и структурную схему сети и выписать значения полей, определяющих процесс настройки параметров сети (весов и смещений):

net.initFcn – функция задания начальных матриц весов и векторов смещений;

net.initParam – набор параметров для функции initFcn, которые можно определить с помощью команды help(net.initFcn), где initFcn – заданная функция инициализации: initcon, initlay, initnw, initnwb, initzero;

net.adaptFcn – функция адаптации нейронной сети, используемая при вызове метода adapt класса network: adaptwb или trains;

net.adaptParam – параметры функции адаптации, определяемые с помощью команды help(net.adaptFcn);

net.trainFcn – функция обучения нейронной сети, используемая при вызове метода train класса network: trainb, trainbfg, traingbr, trainc, traincgb, traincgt, traincgp, trainngd, traingda, traingdm, traingdx, trainlm, trainoss, trainr, trainrp, trainscg;

net.trainParam – параметры функции обучения, определяемые с помощью команды help(net.trainFcn);

net.performFcn – функция оценки качества обучения, используемая при вызове метода train: mae, mse, msereg, sse;

net.performParam – параметры функции оценки качества обучения, определяемые с помощью команды help(net.performFcn);

net.layers{1}.initFcn – функция инициализации параметров слоя: initnw, initwb;

net.layers{1}.transferFcn – функция активации: purelin для линейного слоя;

net.layers{1}.netInputFcn – функция накопления для слоя: netprod, netsum;

net.biases{1}.initFcn – функция инициализации вектора смещений: initcon, initzero, rands;

net.biases{1}.lean – индикатор настройки: 0 – с помощью метода adapt, 1 – с помощью метода train;

net.biases{1}.learnFcn – функция настройки вектора смещений: learncon, learngd, learngdm, learnnp, learnwh;

net.biases{1}.learnParam – параметры функции настройки, определяемые с помощью команды help.(net.biases{1}.learnFcn);

net.inputWeights{1, 1}.initFcn – функция инициализации весов входа: initzero, midpoint, randnc, randnr, rands;

net.inputWeights{1,1}.learn – индикатор настройки: 0 – с помощью метода adapt, 1 – с помощью метода train;

net.inputWeights{1,1}.learnFcn – функция настройки весов: learngd, learngdm, learnhd, learnis, learnk, learnlv1, learnlv2, learnos, learnnp, learnpn, learnsom, learnnwh;

net.inputWeights{1,1}.learnParam – параметры функции настройки, определяемые с помощью команды

help(net.inputWeights {1,1}. learnParam);

net.inputWeights{1,1}.weightFcn – функция для вычисления взвешенных входов для слоя: dist, dotprod, mandist,negdist, norm prod;

для многослойных сетей параметры net.inputWeights{i,j}, связанные с обучением такие, как initFcn, learn, learnFcn, learnParam, weightFcn, имеют тот же смысл и могут принимать такие же значения, что и соответствующие параметры для net.inputWeights{1,1}.

5. Выполнить один цикл адаптации сети с нулевым параметром скорости настройки:

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

net1.IW{1,1} % матрица весов после адаптации

a % четыре значения выхода

e % четыре значения ошибки

6. Инициализировать нулями веса входов и смещений и задать параметры скорости настройки для них соответственно 0.2 и 0:

net.IW{1} = [0 0];

net.b{1} = 0;

net.inputWeights{1,1}.learnParm.lr = 0.2;

net.biases{1}.learnParam.lr =0.

Нулевое значение параметра скорости настройки для смещения обусловлено тем, что заданная зависимость t = 2p₁ + p₂ не имеет постоянной составляющей.

7. Выполнить один цикл адаптации с заданным значением параметра скорости адаптации:

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

net1.IW{1,1} % значения весов в сети net1 изменились;

a % четыре значения выхода сети net1;

e % четыре значения ошибки сети net1.

8. Выполнить адаптацию сети net с помощью 30 циклов:

for i = 1:30,

[net, a{i}, e{i}] = adapt(net, P, T); W(i, :) = net.IW{1,1};

end;

cell2mat(a{30}) % значения выхода на последнем цикле;

cell2mat(e{30}) % значение ошибки на последнем цикле;

W(30, :) % веса после 30 циклов;

mse(cell2mat(e{30})) % функция ошибок: 0.0017176.

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

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

subplot(3,1,1)

for i = 1:1:30, plot(i, cell2mat(a{i}), ′k′),

hold on

end;

xlabel(′′), ylabel(′Выходы a(i)′)

grid

subplot(3,1,2)

plot(0:30, [[0 0]; W], ′k′)

xlabel(′′), ylabel(′Веса входов W(i)′)

grid

subplot(3,1,3)

for i = 1:30, E(i) = mse(e{i}); end

semilogy(1:30, E, ′+k′)

xlabel(′Циклы′), ylabel(′Ошибка′), grid

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

P = [ –1 –1/3 1/2 1/6; 1 1/4 0 2/3]; T = [ –1 –5/12 1 1];

net = newlin([ –1 1; –1 1], 1, 0, 0, 0.2);

net = IW{1} = [0 0]; % присваивание начальных весов;

net.l{1} = 0; % присваивание начального смещения;

net.inputWeughts{1,1}.learnParam.lr = 0.2;

EE = 10;

i = 1; % для подсчета количества циклов;

while EE > 0.0017176

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

W(i, :) = net .IW{1,1}; EE = mse(e{i});

ee(i) = EE;

i = i + 1;

end;

11. Проанализировать результаты и сделать их сравнение с результатами для последовательного представления обучающей последовательности:

W(63, :)

cell2mat(a{63})

EE = mse(e{63})

mse(e{1})

12. Для полученных результатов построить графики и сравнить их с предыдущими:

subplot(3,1,1)

for i = 1:1:63, plot(i, cell2mat(a{i}), ′k′),

hold on

end;

xlabel(′′), ylabel(′Выходы a(i′′), grid

subplot(3,1,2)

plot(0:63, [[0 0]; W], ′k′)

xlabel(′′), ylabel(′Веса входов W(i)′), grid

subplot(3,1,3)

semilogy(1:63, ee, ′+k′)

xlabel(′Циклы′), ylabel(′Ошибка′), grid

Задание 2. Адаптировать параметры однослойной динамической сети с одним входом и одной линией задержки для аппроксимации рекуррентного соотношения y(t) = 2 p(t) + p(t – 1), выполнив следующие действия:

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

P = { –1/2 1/3 1/5 1/4); % значения входа p(t)

T = { –1 1/6 11/15 7/10}; % значения цели y(t)

2. Выполнить адаптацию и построение графиков

net = newlin([ –1 1], 1, [0 1], 0.5); % help(newlin)

Pi = {0}; % начальное условие для линии задержки

net.IW{1} = [0 0]; % веса для основного и задержанного входов

net.biasConnect = 0; % значение смещения

EE = 10; i = 1;

while EE > 0.0001

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

W(i, :) = net.IW{1,1};

EE = mse(e{i});

ee(i) = EE;

i = i +1;

end

W(22, :)

a{22} EE subplot(3,1,1)

for i = 1:1:22, plot(i, cell2mat(a{i}), ′k′)

hold on

end;

xlabel(′′), ylabel(′Выходы a(i)′), grid

subplot(3,1,2)

plot(0:22,[[0 0]; W], ′k′)

xlabel(′′), ylabel(‘Веса входов W(i)′), grid

subplot(3,1,3)

semilogy(1:22, ee, ′+k′)

xlabel(′Циклы ′), ylabel(′Ошибка′) grid

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

а) для последовательного способа:

net=newlin ([ –1 1; –1 1], 1, 0, 0);

net.IW{1}= [0 0];

net.b{1} = 0;

P = {[ –1 1][ –1/3; 1/4][1/2 0][1/6;2/3]};

T = { –1 –5/12 1 1}

net.inputWeights{1, 1}.learnParam.lr = 0.2;

net.biases{1}.learnParam.lr = 0;

net.trainParam.epochs = 30;

net1=train (net,P,T);

W = net1.IW{1} % параметры после обучения

Y = sim(net1,p)

EE = mse([Y{:}] – [T{:}]) % ошибка 1.3817*e –003

б) для группового способа:

P = [ –1 –1/3; 1/2 1/6; 1 1/4 0 2/3];

T = [ –1 –5/12 1 1]

net1=train (net,P,T);

W = net1.IW{1} % параметры после обучения

Y = sim(net1,P)

EE = mse(y –T) % та же ошибка 1.3817*e –003

Задание 4. Обучить динамическую линейную сеть, рассмотренную во 2-м задании и сравнить результаты, выполнив следующие команды:

net = newlin([ –1 1] , 1,[0 1], 0.5)

Pi = {0} % начальное условие линии задержки

net.IW{1} = [0 0] % начальные веса входов

net.biasConnect = 0; % смещение отсутствует

net.trainParam.epochs = 22;

P = { –1/2 1/3 1/5 1/4}; % вектор входа

T = { –1 1/6 11/15 7/10}; % вектор цели

net1 = train(net, P, T, Pi); % обучение сети

W = net1.IW{1} % веса после обучения сети

Y = sim(net1, P); % моделирование новой сети

EE = mse( [Y{:}] [T{:}] ) % ошибка = 3.6514е –005

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

1. Создать шаблон сети:

net5 = network(2, ... % число входов

3, ... % число слоёв сети

[1; 1; 1], ... % связь смещений

[1 1 ; 0 0; 0 0], ... % связь входов

[ 0 0 0; 1 0 0; 0 1 0], ... % связь слоёв

[0 0 1], ... % связь выходов

[0 0 1] ); % связь целей

2. Настроить параметры сети для инициализации с помощью алгоритма Нгуена–Видроу для обеспечения возможности использования метода обратного распространения:

net5.initFcn = ′initlay′; % для сети

net5.layers{1}.initFcn = ′initnw′; % для 1 –го слоя

net5.layers{2}.initFcn = ′initnw′; % для 2 –го слоя

net5.layers{3}.initFcn = ′initnw′; % для 3 –го слоя

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

net5 = init(net5);

net5.IW{1, 1} % матрица весов для 1 –го входа

net5.IW{1, 2} % матрица весов для 2 –го входа

net5.LW{2, 1} % матрица весов для 2 –го слоя

net5.LW{3, 2} % матрица весов для 3 –го слоя

net5.b{1} % матрица смещения для 1 –го слоя

net5.b{2} % матрица смещения для 2 –го слоя

net5.b{3} % матрица смещения для 3 –го слоя

4. Промоделировать сеть с начальными значениями весов и смещений:

P = [0.5 1 ; 1 0.5]; % значения входных векторов

Y = sim(net5) % моделирование сети

Задание 6. Создать и инициализировать трёхслойную сеть с двумя входами для последующего обучения различными методами, выполнив следующие действия:

1. Создать шаблон сети, воспользовавшись шаблоном net5:

net6 = net5; % создание новой копии сети

net6 = revert(net5); % возврат к настройке параметров по умолчанию

2. Настроить параметры сети с помощью функции инициализации нулевых значений весов и смещений initzero:

net6.initFcn = ′initlay′;

net6.layers{1}.initFcn = ′initnw′;

net6.layers{2}.initFcn = ′initnw′;

net6.layers{3}.initFcn = ′initnw′;

net6.inputWeights{1 ,1}.initFcn = ′initzero′;

net6.inputWeights{1 ,2}.initFcn = ′initzero′;

net6.layerWeights{2 ,1}.initFcn = ′initzero′;

net6.layerWeights{3 ,2}.initFcn = ′initzero′;

net6.biases{1}.initFcn = ′initzero′;

net6.biases{2}.initFcn = ′initzero′;

net6.biases{3}.initFcn = ′initzero′;

net6.init(net6); % инициализация сети

3. Вывести на экран матрицы весов и смещения, используя команды 3-го пункта 5-го задания.

4. Промоделировать сеть и возвратить её к исходным значениям весов и смещений:

Ynet6 = sim(net6);

net6 = revert(net6).

Задание 7. Создать и инициализировать трёхслойную сеть с двумя входами, используя следующие функции инициализации:

а) rands – для задания случайных весов и смещений.

б) randnc – для задания случайной матрицы с нормированными столбцами;

в) randnv – для задания случайной матрицы с нормированными строками;

г) initcon – для задания равных смещений;

д) midpoint – для задания матрицы средних значений;

Для создания и инициализации сети использовать команды 6 –го задания, заменяя в них функцию initzero на рассматриваемые функции инициализации, а сеть net6 – на сеть net7.

Задание 8. Создать двухслойную нейронную сеть с прямой передачей сигнала, одним входом, двумя нейронами в первом слое и одним нейроном во втором слое, настроить сеть для обучения с использованием алгоритма градиентного спуска GD, обучить эту сеть и путём её моделирования оценить качество обучения. Порядок выполнения задания следующий:

1. Создать нейронную сеть с прямой передачей сигнала:

net8 = newff([0 5], …. % диапазоны значений входа

[2 1], ….. % количество нейронов в слоях

{′tansig′, % функция активации для 1 –го слоя

′logsig′} % функция активации для 2 –го слоя

′traingd′); % имя функции обучения

2. Убедиться, что веса и смещения каждого слоя инициализированы с помощью алгоритма Нгуена–Видроу:

net8.initFcn % должно быть ′initlay′

net8.layers{1}.initFcn % должно быть ′initnw′

net8.layers{2}.initFcn % должно быть ′initnw′

net8.IW{1,1} % вес входа

net8.LW{2,1} % веса для 2 –го слоя. net8.b{1}

net8.b{2}

3. Задать обучающие последовательности входов и целей T:

P = [0 1 2 3 4 5]; % вектор входа

T = [0 0 0 1 1 1]; % вектор целей

4. Вывести на экран параметры обучающей функции traingd и их значений по умолчанию:

info = traingd(′pdefaults′)

info =

epochs: 100 % максимальное количество циклов обучения

show: 2 % интервал вывода данных

goal: 0 % предельное значение критерия обучения

time: Inf % максимальное время обучения

min_grad: 1.0e–006 % максимальное значение градиента критерия качества

max_fail: 5 % макс. допустимый уровень превышения ошибки

% контрольного подмножества по сравнению с обучающим

Процедура обучения прекратится, когда будет выполнено одно из следующих условий:

а) значение функции качества стало меньше предельного goal;

б) градиент критерия качества стал меньше значения min_grad;

в) достигнуто предельное значение циклов обучения epochs;

г) превышено максимальное время, отпущенное на обучение time;

д) ошибка контрольного подмножества превысила ошибку обучающего более чем в max_fail раз.

Функция traingd предполагает, что функции взвешивания dotprod, накопления netsum и активации transig или rogsig имеют производные. Для вычисления производных критерия качества обучения perf по переменным веса и смещения используется метод обратного распространения ошибки. В соответствии с методом градиентного спуска вектор настраиваемых переменных получает следующее приращение:

dx = tr  dperf /dx ,

где tr – параметр скорости настройки, равный по умолчанию 0,01. Функцией одновременного поиска минимума вдоль заданного на правления в данной сети является функция srchbac.

5. Обучить рассматриваемую сеть:

net8.trainParam.epochs = 500;

net8.trainParam.90al = 0.01;

[net8, TR] = train(net8, P, T);

TR % характеристики процедуры обучения

6. Произвести моделирование сети и оценить качество ее обучения:

Ynet8 = sim(net8, P) % целевые значения

Задание 9. Повторить задание 8 для следующих функций обучения: traingda, traingdm, traingdx, trainrp, traincgf, traincgp, traincgb, trainscg, trainbfg, trainoss, trainlm. Сравнить полученные результаты.

Задание 10. Создать и обучить сеть для аппроксимации синусоидальной функции, зашумленной нормально распределенным шумом, выполнив следующие действия:

1. Задать обучающие последовательности:

P = [ –1: .05: 1];

T = sin[2*pi*P] + 0.1*randn(size(P));

2. Сформировать сеть с прямой передачей сигнала:

net10 = newff([ –1 1], [20 1], {′transig′, ′purelin′}, … ′trainbr′);

3. Настроить сеть:

net10.trainParam.epochs = 50;

net10.trainParam.show = 10; % для отображения

4. Обучить сеть и построить график аппроксимируемой функции и график выхода сети:

net10 = train(net, P, T); Y = sim(net, P);

plot(P, Y, P, T, ‘+’) % два графика

5. Изменяя количество нейронов в первом слое, исследовать качество аппроксимации.

Задание 11. Создать сеть и произвести ее последовательную адаптацию, выполнив следующие команды:

net11 = newff([ –1 2; 0 5], [3, 1], … {′tansig′, ′purelin′}, ′traingd′);

net11.inputWeights{1, 1}.learnFcn = ′learngd′;

net11.layerWeights{2, 1}.learnFcn = ′learngd′;

net11.biases{1}.learnFcn = ′learngd′;

net11.biases{2}.learnFcn = ′learngd′;

net11.layerWeights{2, 1}.learnParam.lr = 0.2;

P = [ –1 –1 2 2; 0 5 0 5];

T = [ –1 –1 1 1];

P = num2cell(P,1);

T = num2cell(T,1);

net11.adaptParam.passes = 50;

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

a = sim(net11, P) % [ –1.02] [ –0.99624] [1.0279] [1.0021];

mse(e) % должно быть 5,5909е –004.

Задание 12. Создать сеть и произвести ее последовательную адаптацию, используя следующие функции настройки весов и смещений: learngdm, learnlv1, learnlv2, learnk, learncon, learnis, learnos, learn som, learnh, learnhd. Сравнить алгоритм настройки для одной и той же обучающей последовательности.