Искусственные нейронные сети (стр. 4 )

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

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

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. Адаптировать параметры однослойной динамической сети с одним входом и одной линией задержки для аппроксимации рекурентного соотношения , выполнив следую­щие действия:

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 = []; % – вектор входа;

T = []; % – вектор целей.

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

info = traingd(′pdefaults′)

info =

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

show: 25 % – интервал вывода данных;

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 по переменным веса и смещения используется метод обратного распространения. В соответствии с методом градиентного спуска вектор настраиваемых переменных получает следующее приращение:

,

где 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; ];

T = [-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, learnsom, learnh, learnhd. Сравнить алгоритм настройки для одной и той же обучающей последовательности.

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

1.  Проходной балл для абитуриентов, не имеющих льгот, должен быть равен 11;

2.  Удовлетворительные оценки по математике и физике для этой категории абитуриентов недопустимы;

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

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

Лабораторная работа № 6

Исследование персептронных сетей

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

Теоретические сведения

Персептрон – это однослойная нейронная сеть с S нейронами и R входами, каждый из которых может состоять из нескольких элементов. Передаточной функцией каждого нейрона является ступенчатая функция типа hardlim или hardlims. Помимо основных входов, нейроны персептрона имеют вход для постоянного смещения, равного единице. Элементы входов и смещения взвешиваются с помощью функции скалярного произведения dotprod и суммируются с помощью функции накопления netsum.

Создание персептрона производится следующей функцией:

net = newp(PR, S, tf, lf),

где net – объект класса network;

PR – массив размера Rx2 минимальных и максимальных значений для R векторов входа;

S – число нейронов персептрона;

tf – передаточная функция из списка { hardlim, hardlims }, причем по умолчанию задается hardlim;

lf – обучающая функция из списка {learnp, learnpn}, причем по умолчанию – learnp.

При создании персептрона, матрица весов и вектор смещений инициализируются нулями с помощью функций initzero.

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

Настройка весов и смещений, реализуемая функциями learnp и learnpn, производится по следующим правилам:

а)  для входных сигналов вычисляются выходные;

б)  определяются ошибки как разность между целевым выходом и соответствующим выходным сигналом;

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

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

pni = pi (sqrt(1+ p12 +…+ pr2)).

Такое нормирование обеспечивается применением функции learnp для настройки как весов, так и смещений. Также автоматически свойству net.adaptFcn задается значение adaptwb, что позволяет использовать любые функции для настройки весов и смещений, а свойству net.adaptParam – набор параметров по умолчанию.

Адаптация персептрона производится функцией-методом adapt(net,P,T), где P – входные векторы; T – целевые значения. Процесс адаптации продолжается до тех пор, пока не будет достигнуто требуемое значение критерия качества обучения в виде средней абсолютной ошибки, вычисляемой функцией mae.

Практические задания

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

1. Создать и инициализировать персептрон:

net = newp([0 1], 1) % – на экране весь объект;

net.inputWeights{1,1} % – веса входа объекта;

net.biases{1} % – смещение нейрона;

net.IW{1,1} % – значение весов;

net.b{1} % – значение смещения;

net.IW{1,1}=[3] % – задание веса;

net.b{1}=[4] % – задание смещения;

net = init(net); % – инициализация нулями;

net.IW{1,1} % – нулевое значение веса;

net.b{1} % –нулевое значение смещения;

net.inputWeights{1,1}.initFcn=′rands′;

net.biases{1}.initFcn=′rands′;

net = init(net); % – инициализация случайными значе
% ниями;

net.IW{1,1}, net.b{1} % – новые значения;

p = {[0] [1] [0.5]}; % – последовательность входов;

a = sim(net, p) % – моделирование сети;

Задание 2. Создать персептрон с одним нейроном и одним двухэлементным вектором входа, значения элементов которого изменяются в диапазоне от –2 до 2, настроить веса и смещение для реализации разделяющей линии

-p1 + p1 + 1 = 0,

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

1.  Создать персептрон:

net = newp([-2 2; -2 2], 1).

2.  Произвести ручную инициализацию:

net.IW{1,1} = [-1 1] ;

net.b{1} = [1].

3.  Произвести проверку персептрона:

p = [1;1];

a = sim(net, p) % a = 1;

p = [1;-1];

a = sim(net, p) % a = 0.

4.  Определить классы значений вектора:

p = {[-2;-2] [-2;-1] [-2;0] [-2;1] [-2;2]…

[-1;-2] [-1;-1] [-1;0] [-1;1] [-1;2]…

[0;-2] [0;-1] [0;0] [0;1] [0;2]…

[1;-2] [1;-1] [1;0] [1;1] [1;2]…

[2;-2] [2;-1] [2;0] [2;1] [2;2];

a = sim(net, p) % [0]-0-й класс; [1]-1-й класс.

Задание 3. Создать персептрон с одним нейроном и двоичным входом и настроить его параметры, сначала для выполнения логической функции AND, а затем для выполнения логической функции OR, выполнив следующие действия:

1.  Создать персептрон:

net = newp([0 1;0 1], 1).

2. Подготовить обучающие последовательности:

p={[0;0] [0;1] [1;0] [1;1]};

p1=cat(2, p{:});

T1=num2cell(p1(1,:) & p1(2,:)) % – функция AND;

T2=num2cell(p1(1,:) | p1(2,:)) % – функция OR.

3. Настроить параметры персептрона для выполнения логической функции AND, используя процедуру адаптации:

net.adaptParam.passes = 10; % – число проходов;

net.adapt(net,p,T1); % – настройка на AND;

net. IW{1,1},net.b{1} % – линия 2p1 + p2 –3=0;

Y =sim(net,p) % – моделирование AND.

4.  Настроить параметры персептрона для выполнения логической функции OR, используя процедуру обучения:

net.trainParam.epochs=20; % – число циклов;

net = init(net); % – инициализация;

net = train(net, p,T2); % – настройка на OR;

net. IW{1,1},net. b{1} % – линия 2p1 + 2p2 –2=0;

Y = sim(net,p) % – моделирование OR.

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

net.adaptParam.passes = 1;

net.trainParam.epochs = 1;

[net, Y,e]=adapt(net, p,T1); % – для AND;

[net, Y, e]=train(net, p,T2); % – для OR;

net.IW{1,1},net.b{1} % – настраиваемые параметры.

Задание 5. Создать, обучить и апробировать персептрон для принятия решения о зачислении в высшее учебное заведение абитуриентов, сдавших вступительные экзамены.

Лабораторная работа № 7

Исследование линейных нейронных сетей

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

Теоретические сведения

Линейная сеть – это один слой из S нейронов и R входов, каждый из которых может состоять из нескольких элементов. Передаточной функцией каждого нейрона слоя является линейная функция purelin. Это является единственным отличием линейной сети от персептрона. Благодаря линейной передаточной функции каждый выход сети может принимать любое значение, в то время как выход персептрона ограничен значениями 1 и 0.

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

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