МИНИСТЕРСТВО ОБРАЗОВАНИЯ и НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИ
КАБАРДИНО-БАЛКАРСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ
им. Х.М.Бербекова
Моделирование нейронных сетей
Лабораторный практикум по дисциплинам «Нейрокомпьютерные системы»,
«Системы искусственного интеллекта» для направлений …
Нальчик, 2012
1
УДК 681.3
С34 (ББК 32.973.2018 Я73)
Рецензент:
зав. отделом мультиагентных систем института информатики и проблем регионального управления КБНЦ РАН к.т.н. З. В. Нагоев
Составитель: Бозиев О.Л.
Моделирование нейронных сетей. Лабораторный практикум. – Нальчик:
Кабардино-Балкарский Государственный Университет, 2012, 48 с.
Лабораторный практикум предназначен для приобретения навыков моделирования различных типов нейронных сетей для последующего их анализа и
обучения решению конкретных задач. Для выполнения лабораторных работ используются средства пакета Neural Network Toolbox системы научных и инженерных расчетов MATLAB.
УДК 681.3
С34
(ББК 32.973.2018 Я73)
Кабардино-Балкарский Государственный Университет
им. Х.М.Бербекова
2
Содержание
Лабораторная работа № 1. Активационная функция .............................................. 4
Лабораторная работа № 2. Искусственные нейронные сети .................................. 6
Лабораторная работа № 3. Обучение искусственных нейронных сетей ............. 12
Лабораторная работа № 4. Персептронные сети ................................................... 25
Лабораторная работа № 5. Линейные нейронные сети ......................................... 28
Лабораторная работа № 6. Сети Эльмана ............................................................... 34
Лабораторная работа № 7. Сети Хопфилда ........................................................... 37
Лабораторная работа № 8. Радиальные базисные сети общего вида .................. 38
Лабораторная работа № 9. Радиальные базисные сети типа GRNN .................... 41
Лабораторная работа № 10. Радиальные базисные сети типа PNN ..................... 42
Лабораторная работа № 11. Самоорганизующиеся слои Кохонена .................... 44
Лабораторная работа № 12 Самоорганизующиеся карты Кохонена ................... 46
Литература ................................................................................................................. 51
3
Лабораторная работа № 1. Активационная функция
Цель работы: исследование активационных функций и моделей нейронов.
Задание 1. Для активационной функции “жесткая ступенька” hardlim и её
производной dhardlim, определяемыми соотношениями
0, n 0,
hard lim(n)
1, n 0,
0, n 0,
dhard lim(n)
0, n 0,
выполнить следующие действия:
1. Вывести на экран информацию об этих функциях с помощью команд:
name=hardlim(′name′)
% название функции
dname=hardlim(′deriv′)
% название производной
inrange=hardlim(′active′)
% диапазон входа
outrange=hardlim(′output′)
% диапазон выхода
2. Построить графики функций:
n= –5:0.1:5;
a=hardlim(n);
da=dhardlim(n);
plot(n,a,′r′)
% график функции – красный
hold on
plot (n,da,′c′)
% график производной – голубой
3. Рассчитать векторы выхода А и производной dA_dN для слоя из трёх
нейронов с вектором входа N, состоящим из трёх компонент:
N=[–0,7; 0,1; 0,8];
A=hardlim(N)
% вектор выхода активационной функции
dA_dN=dhardlim(N,A)
% вектор выхода производной
4. Рассмотренную последовательность команд оформить в виде скрипта и
записать в М-файл с именем hardlimfile.
Задание 2. Для симметричной активационной функции “жесткая ступенька” hardlims и её производной dhardlims, определяемыми соотношениями
1, n 0,
hard lim s(n)
1, n 0,
4
0, n 0,
dhardlms (n)
0, n 0,
вывести на экран информацию об этих функциях, построить их графики и рассчитать векторы выхода, воспользовавшись скриптом из М-файла hardlimfile.
Новый скрипт записать в файл под именем hardlimsfile.
Задания 2-10 (табл. 1). Вывести на экран информацию об указанных
функциях и их производных, построить их графики и рассчитать векторы выхода, аналогично заданию 1. Воспользоваться скриптом из М-файла hardlimfile.
Новый скрипт записать в файл с указанным именем.
Табл. 1.
Название
функции
Жесткая сту2 пенька
Функция
Производная
Имя
файла
1, n 0,
hard lim s(n)
1, n 0
0, n 0,
dhardlms(n)
0, n 0
hardlimsfile
рurelin = n
dpurelin = 1
purelinfile
0, n 0,
poslin(n)
n, n 0
0, n 0,
soflin(n) n,0 n 1,
n, n 1
0, n 0,
dposlin(n)
1, n 0
0, n 0,
dsoflin(n) 1,0 n 1,
1, n 0
Симметрич6
ная линейная
1, n 1,
satlins(n) n,1 n 1,
n, n 1
0, n 1,
dsatlins(n) 1,1 n 1,
1, n 1
satlinsfile
Радиальная
базисная
radbas = exp(–2n)
dradbas = –2ne(–2n)
radbasfile
№
3 Линейная
Положитель4
ная линейная
Линейная с
5 ограничениями
7
0, n 1,
0, n 1,
1, 1 n 0,
tribas(n) 1 abs(n), 1 n 1,
dtribas(n)
8 Треугольная
0, n 1
1, 0 n 1,
0, n 1
Логистическая
Гиперболи10 ческий тангенс
9
logsig(n) =
= 1/(1 + exp(–n))
tansig(n) =
= 2/(1 + exp(–2n)) – 1
dlogsig(n) =
=exp(–n)/(1+exp(–n)2)
dtansig(n) =
= 1 – tansig2(n)
poslinfile
satlinfile
tribasfile
logsigfile
tansigfile
Задание 11. Для конкурирующей функции активации compet, используемой для формирования вероятных и самоорганизующихся нейронных сетей
5
выполнить следующие действия:
1. Вывести на экран информацию об этой функции с помощью следующего скрипта:
Name = compet(′name′)
% название функции
Dname = compet(′dеriv′)
% название производной
Inrange = compet(′active′)
% диапазон входа
Outrange = compet(′outrut′)
% диапазон выхода
2. Построить диаграммы для вектора входа и для вектора выхода, используя слой из четырех нейронов:
N = [0; 1; –0.5; 0.5];
A = compet(n);
subplot(2, 1, 1),
% подокна 21; вывод в 1–е
bar(n),
% столбцовая диаграмма
ylabet(‘n’)
% метка оси ординат
subplot(2, 1, 2),bar(a),ylabet(‘a’) % во 2–м подокне
3. Рассмотренную последовательность команд оформить в виде скрипта в
М-файл с именем competlile.
Задание 12. Выполнить действия 11-го задания для конкурирующей функции активации с мягким максимумом softmax, записав при этом новый скрипт в
М-файл с именем softmaxfile.
Лабораторная работа № 2. Искусственные нейронные сети
Цели работы: 1) изучение архитектуры искусственных нейронных сетей,
способов их графического изображения в виде функциональных и структурных
схем и программного представления в виде объектов специального класса
network, включающих массив структур с атрибутами сети и набор необходимых
методов для создания, инициализации, обучения, моделирования и визуализации сети; 2) приобретение навыков построения сетей различной архитектуры с
помощью инструментального программного пакета Neural Network Toolbox
6
(NNT) системы MATLAB.
Задание 1. Создать вычислительную модель нейронной сети с двумя выходами, тремя слоями и одним целевым входом, с помощью общего конструктора
сети с параметрами
Net = network(numInputs, numLayers, biasConnect, inputConnect, layerConnect,
outputConnect, tartegtConnect).
Связи между слоями должны быть только прямыми, входы необходимо
соединить с первым слоем, а выход – с последним. Выход должен быть целевым, первый слой должен иметь смещения.
Определим смысл и значения параметров конструктора для создания модели сети заданной архитектуры:
numInputs=2 – количество входов сети;
numLayers=3 – количество слоёв в сети;
biasConnect=[1; 0; 0] – матрица связности для смещений размера numLayers;
inputConnect=[1 1; 0 0; 0 0] – матрица связности для входов размера numLayers
numInputs;
layerConnect=[0 0 0; 1 0 0 0; 0 1 0] – матрица связности для слоёв размера
numLayers numLayers;
outputConnect=[0 0 1] – матрица связности для выходов размера numLayers;
targetConnect=[0 0 1] – матрица связности для целей размера numLayers.
Порядок выполнения задания следующий:
1. Создать шаблон сети, выполнив команду
net = network (2, 3, [1; 0; 0], [1 1; 0 0; 0 0], …. ,[0 0 0; 1 0 0; 0 1 0], [0 0 1])
2. Проверить значения полей вычислительной модели нейронной сети net и
их соответствие заданным значениям в списке параметров.
3. Проверить значения вычисляемых полей модели, которые дополняют
описание архитектуры сети
numOutputs = 1 – количество выходов сети;
numTargets = 1 – количество целей сети;
7
numInputDelays = 0 – максимальное значение задержки для входов сети.
numLayersDelays = 0 – максимальное значение задержки для слоёв сети.
Каждый выход и каждая цель присоединяются к одному или нескольким
слоям при этом количество компонент выхода или цели равно количеству
нейронов в соответствующем слое. Для увеличения возможности модели в сеть
включают линии задержки либо на её входах, либо между слоями. Каждая линия задерживает сигнал на один такт. Параметры numInputDelays и
NumLayerDelays определяют максимальное число линий для какого-либо входа
или слоя соответственно.
4. Проанализировать структурную схему построенной сети, выполнив команду gensim(net) и детализируя блоки с помощью двойного щелчка левой клавиши мыши по рассматриваемому блоку. На структурных схемах искусственных нейронных сетей в пакете NNT используются следующие обозначения:
а) Neural Network – искусственная нейронная сеть с обозначениями входов
p{1}, p{2}, … и выхода y{1};
б) входы Input1 или p{1} и Input2 или p{2};
в) дисплей y{1};
г) Layer 1, Layer 2, Layer 3, … слои нейронов с обозначениями входов p{1},
p{2}, a{1}, a{2}, … и выходов a{1}, a{2}, a{3}, … , y{1};
д) TDL – линии задержки (Time Delay) с именами Delays1, Delays2, ..., которые обеспечивают задержку входных сигналов или сигналов между слоями
нейронов на 1, 2, 3, … такта;
е) Weights – весовая матрица для входных сигналов или сигналов между
слоями нейронов; размер матрицы весов для каждого вектора входа равен S×R,
где S – число нейронов входного слоя, а R – число компонент вектора входа,
умноженное на число задержек; размер матрицы для сигналов от слоя j к слою i
равен S×R, где S – число нейронов в слое i, а R – число нейронов в слое j,
умноженное на число задержек;
ж) dotprod – блок взвешивания входных сигналов и сигналов между слоя-
8
ми, на выходе которого получается сумма взвешенных, т. е. умноженных на соответствующие веса компонент сигнала;
з) mux – концентратор входных сигналов и сигналов между слоями, преобразует набор скалярных сигналов в вектор, а набор векторов в один вектор
суммарной длины;
и) netsum – блок суммирования компонент для каждого нейрона слоя: компонент от нескольких векторов входа с учётом задержек, смещения и т. п.;
к) hardlim, purelin и т. д. – блоки функций активации;
л) pd{1, 1}, pd{1, 2}, ad{2, 1}, ... – сигналы после линий задержки (delay);
м) iz{1, 1}, iz{1, 2}, lz{2, 1}, lz{3, 2} – векторы-сигналы с выхода концентратора;
н) bias – блок весов смещений для слоя нейронов;
о) IW – массив ячеек с матрицами весов входов: IW{i, j} – матрицы для
слоя i от входного вектора j;
п) LW – массив ячеек с матрицами весов для слоёв: LW{i, j} – матрицы для
слоя i от слоя j.
5. Проанализировать все параметры каждого блока структурной схемы
рассматриваемой нейронной сети. В случае необходимости обратиться к справочной системе пакета NNT.
6. Задать нулевые последовательности сигналов для входов командой
P = [0 0; 0 0]
и произвести моделирование сети:
A = sim(net, P).
7. Задать диапазоны входных сигналов и весовые матрицы с помощью следующих присваиваний:
net.inputs{1}.range = [0 1];
net.inputs{2}.range = [0 1];
net.b{1} = 1/4;
net.IW{1, 1} = [0.5];
9
net.IW{1, 2} = [0.5];
net.LW{2, 1} = [0.5];
net.LW{3, 2} = [0.5].
Исполнить команду gensim(net) и проверить параметры блока.
8. Вывести на экран поля вычислительной модели и их содержимое, используя функцию celldisp. Убедиться в правильности значений полей модели.
9. Промоделировать созданную статическую сеть, т. е. сеть без линий задержки, используя групповое и последовательное представление входных сигналов
PG = [0.5 1; 1 0.5];
PS = {[0.5 1] [1 0.5]};
AG = sim(net, PG);
AS = sim(net, PS).
Убедиться, что для статической сети групповое и последовательное представления входных сигналов дают один и тот же результат.
10. Дополнить архитектуру созданной нейронной сети линиями задержки
для входных сигналов и для сигналов между 2-м и 3-м слоями, преобразовав,
таким образом, статическую сеть в динамическую:
net.inputWeights{1, 1}.delays = [0 1];
net.inputWeights{1, 2}.delays = [0 1];
net.layerWeights{3, 2}.delays = [0 1 2].
Построить структурную схему динамической сети и выяснить смысл используемых операторов присваивания.
11. Скорректировать весовые матрицы:
net.IW{1, 1} = [0.5 0.5];
net.IW{1, 2} = [0.5 0.25];
net.LW{3, 2} = [0.5 0.25 1].
12. Построить модель динамической сети, используя групповое и последовательное представление входных сигналов:
10
AG = sim(net, PG);
AS = sim(net, PS).
Убедиться, что групповое представление входных сигналов искажает результат, так как в этом случае работа одной сети заменяется параллельной работой двух (по числу последовательностей) одинаковых сетей с нулевыми
начальными значениями сигналов на выходах линий задержки.
13. Вывести на печать поля вычислительной модели и их содержимое, используя функцию celldisp.
14. Сохранить содержимое командного окна в М-файле для последующего
использования.
Задание 2. Создать точно такую же динамическую сеть asgnet, используя
конструктор класса network без параметров и задавая значения соответствующих полей вычислительной модели с помощью операторов присваивания. Убедиться в идентичности сетей net и asgnet. Сравнить результаты работы полученных сетей.
Задание 3. Используя конструктор класса network с параметрами и операторы присваивания для полей и ячеек объектов этого класса, построить, вывести на экран и построить модели искусственных нейронных сетей следующей
архитектуры:
а) однослойная сеть с тремя нейронами, тремя двухкомпонентными входами и одним целевым выходом;
б) трёхслойная сеть с прямой передачей сигналов и с тремя нейронами в
каждом слое; количество входов – три с двумя, пятью и тремя компонентами;
для всех слоёв имеется смещение; выход – один;
в) трёхслойная сеть, в которой каждый слой соединён со всеми остальными; вход – один и состоит из двух компонентов; количество нейронов в каждом
слое – три; слои имеют смещения;
г) трёхслойная динамическая сеть с тремя нейронами в каждом слое; число
входов – три, из них каждый состоит из трёх компонентов; имеются смещения
11
на всех слоях; линии задержки задерживают сигналы на один и два такта и
включены между всеми слоями, а так же на входе;
д) квадратная сеть с десятью слоями и десятью нейронами в каждом слое;
десять векторов подключаются по одному к каждому слою; имеется десять выходов от всех слоёв сети; смещения подключены к каждому слою.
Лабораторная работа № 3. Обучение искусственных нейронных сетей
Цель работы: приобретение навыков разработки искусственных нейронных сетей и практического применения методов и алгоритмов их инициализации и обучения.
Задание 1. Выполнив следующие действия, адаптировать параметры однослойной статической линейной сети с двумя входами для аппроксимации линейной зависимости вида t = 2p1
+ p2.
1. С помощью конструктора линейного слоя
net = newlin(PR, s, id, lr),
где PR – массив размера R2 минимальных и максимальных значений для R
векторов входа; s – число нейронов в слое; id – описание линий задержек на
входе слоя; lr – параметр скорости настройки, сформировать линейную сеть:
net = newlin([–1 1; –1 1], 1, 0, 0).
2. Подготовить обучающие последовательности в виде массивов ячеек, используя зависимости t = 2p1 + p2 и четыре пары значений p1 и p2 (произвольные):
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), проанализировать поля вычислительной модели и структурную схему сети и выписать значения полей, опреде-
12
ляющих процесс настройки параметров сети (весов и смещений):
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 – параметры функции настройки, определяемые с по-
13
мощью команды 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.
14
Нулевое значение параметра скорости настройки для смещения обусловлено тем, что заданная зависимость t = 2p1 + p2 не имеет постоянной составляющей.
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)
15
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})
16
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);
17
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;
18
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. Создать шаблон сети:
19
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. Создать и инициализировать трёхслойную сеть с двумя входами
для последующего обучения различными методами, выполнив следующие дей-
20
ствия:
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 – для задания случайной матрицы с нормированными строками;
21
г) 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 и их значений
по умолчанию:
22
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;
23
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′;
24
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.
Сравнить алгоритм настройки для одной и той же обучающей последовательности.
Лабораторная работа № 4. Персептронные сети
Цель работы: изучение архитектуры персептрона и специальных функций
для создания персептрона, настройки его весов и смещений и адаптации, ознакомление с демонстрационными примерами, а также приобретение навыков построения и обучения персептронов для различных областей применения.
Задание 1. Создать персептрон с одним нейроном и одноэлементным входом, диапазон значений которого от 0 до 1, и проанализировать значения параметров его вычислительной модели, выполнив следующие действия:
1. Создать и инициализировать персептрон:
net = newp([0 1], 1)
% на экране весь объект
net.inputWeights{1,1}
% веса входа объекта
25
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 + p2 + 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)
p = [1; –1];
26
%a=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
27
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. Линейные нейронные сети
Цели работы: 1) изучение архитектуры статистических и динамических
линейных нейронных сетей и специальных функций для их создания, настройки параметров по методу Вудроу–Хоффа, адаптации и обучения, ознакомление
с демонстрационными примерами и их скриптами; 2) приобретение навыков
построения и обучения линейных сетей для классификации векторов, линейной
аппроксимации, предсказания, слежения и фильтрации сигналов, идентификации и моделирования линейных систем.
Задание 1. Выполнить задания 1 – 4 лабораторной работы № 4 и для линейной нейронной сети с таким же числом нейронов и входов, что и у соответствующего персептрона, заменив функцию newp функцией newlin, оставляя параметры неизменными и используя значения параметров id и lr по умолчанию,
т. е. [0] и 0,01 соответственно.
Задание 2. Построить поверхность ошибок для линейной сети с одним
нейроном и одним входом, используя функцию errsurf и выполнив следующие
команды:
Р = [1 –1.2];
T = [0.5 1];
28
net = newlind(P,T);
Y = sim(net, P)
% 0.5 и 1
net.IW{1,1}
% 0.22727
net.b{1}
% 0.72727
w_rangle = 1: 0.1: 0
% диапазон весов
b_ rangle = 0.5: 0.1: 1
% диапазон смещений
ES = errsulf(P, T, w_ rangle, b_ rangle, 'purelin');
contour(w_ rangle, b_ rangle, ES, 20)
% 20 уровней
hold on
plot( –2.2727e – 001, 7.2727e – 001, 'x')
hold off
% точка
% 'x' оптимальные значения весов и смещений
Задание 3. Создать с помощью функции newlin линейную сеть с одним
нейроном и одним входом, обучить эту сеть, используя процедуру train, и построить поверхность функции критерия качества и траекторию обучения, выполнив следующие действия:
1. Сформировать обучающее множество и рассчитать максимальное значение параметра обучения maxlr:
P = [1 –1.2];
T = [0.5 1];
maxlr = 0.40*maxlinlr(P,'bias').
2. Создать линейную сеть:
net = newlin([ –2 2], 1, [0], maxlr);
gensim(net).
3. Рассчитать функцию критерия качества:
w_rangle = –1: 0.2: 1; b_rangle = –1: 0.2: 1;
ES = errsulf(P, T, w_rangle, b_rangle, 'purelin').
4. Построить поверхность функции критерия качества:
surfc(w_ rangle, b_ rangle, ES).
5. Рассчитать траекторию обучения:
29
Х = zeros(1, 50);
Y = zeros(1, 50);
net.IW{1,1} = 1;
net.b{1} = 1;
% начальные значения
X(1) = net.IW{1};
Y(1) = net.b{1};
net.trainParam.goal = 0.001;
net.trainParam.epochs = 1;
6. Вычислить веса и смещения:
for I=2:50,
[net, tr] = train(net, P, T);
X(I) = net.IW{1, 1};
Y(I) = net.b{1};
end
7. Построить линии уровня и траекторию обучения:
clc;
% очистка экрана
contour(w_ rangle, b_ rangle, ES, 20)
% 20 линий
hold on
plot(X,Y,'_ *')
% построение траектории
hold off
8. Оценить значения параметров настройки для двух значений цели goal:
net.IW{1, 1} = 1; net.b{1} = 1;
net.trainParam.epochs = 50;
net.trainParam.goal = 0.001;
% первое значение
[net, tr] = train(net, P, T);
net.IW{1, 1}, net.b{1}
% [0.22893] [0.70519]
net.trainParam.goal = 0.00001;
% второе значение
[net, tr] = train(net, P, T);
net.IW{1, 1}, net.b{1}
30
% [0.22785] [0.72495]
Задание 4. Построить линейную сеть с одним нейроном, одним входом со
значениями из диапазона [1, 1], и линией задержки типа [0 1 2] для воспроизведения заданного отклика некоторой системы, выполнив следующие действия:
1. Создать линейную сеть заданной архитектуры с параметром скорости
настройки, равным 0,01:
net = newlin([ –1 1], 1, [0 1 2], 0.01);
gensim(net).
2. Сформируем две обучающие последовательности:
Р1 = {0 –1 1 1 0 –1 1 0 0 1};
Т1 = {0 –1 0 2 1 –1 0 1 0 1};
Р2 = {1 0 –1 –1 1 1 1 0 –1};
T2 = {2 1 –1 –2 0 2 2 1 0}.
3. Выполнить обучение для последовательностей Р1 и Т1:
net = train(net, P1, T1);
net.IW{1, 1}, net.b{1},
% [0.875] [0.8875] [0.1336] [0.0619]
Y1 = sim(net, [P1 P2]);
4. Выполнить обучение сети на всем объеме обучающих данных:
net = init(net);
P3 = [P1 P2];
T3 = [T1 T2];
net.trainParam.epochs = 200;
net.trainParam. goal = 0.01;
net = train(net, P3, T3);
net.IW{1, 1}, net.b{1}
% [0.9242] [0.9869] [0.0339] [0.0602]
Y3 = sim(net, P3)
% дискретная модель
% Yk = 0.9242rk+0.9869 rk1+0.0339 rk2+0.0602
5. Построить графики отклика Т3 и приближений Y1 и Y3:
plot(0:0,01:20, T3, 'G'), hold on
% зеленый
plot(0:0,01:20, Y1, 'B'), hold on
% синий
31
plot(0:0,01:20, Y3, 'R'), hold off
% красный
Задание 5. Сформировать линейную сеть из одного нейрона и одного входа, который обеспечивает для заданного входа Р, близкий к цели Т, выполнив
следующие команды:
P = 0:3;
T = [0.0 2.0 4.1 5.9];
% зависимость t = 2p
net = newlind(P, T);
gensim(net)
net.IW{1, 1}, net.b{1}
% [1.9800] [0.3000]
Y = sim(net, P)
% [0.0300] [2.0100] [3.9900] [5.9700]
Задание 6. Сформировать линейную сеть из одного нейрона и одного входа
с двумя элементами для классификации значений входа, выполнив следующие
действия:
P = [2 1 2 1; 2 –2 2 1];
T = [0 1 0 1];
net = newlin([2 2; 2 2], 1);
net.trainParam.goal = 0.1;
[net, tr] = train(net, P, T);
net.IW{1, 1}, net.b{1}
A = sim(net, P);
err = TA
% погрешности сети весьма значительны
Задание 7. Сформировать линейную сеть из одного нейрона, одного входа
и одного выхода для цифровой фильтрации сигнала, выполнив следующие действия:
1. Создать сеть и произвести ее инициализацию:
net = newlin([0 10], 1);
% диапазон входа от 0 до 10
net.inputWeights{1, 1}.delays = [0 1 2];
net.IW{1, 1} = [7 8 9];
net.b{1} = [0];
32
% инициализация весов и смещения
pi = {1 2};
% начальные условия на линиях задержки
2. Определить входной сигнал и выходной сигнал фильтра в виде последовательности значений:
P = {3 4 5 6};
% входной сигнал
T = {10 20 30 40};
% требуемый выходной сигнал
3. Провести моделирование необученной сети:
[a, pf] = sim(net, P, pi);
% a = [46] [70] [94] [118] pf = [5] [6].
4. Выполнить адаптацию сети с помощью 10 циклов:
net.adaptParam.passes = 10;
[net, y, E, pf, af] = adapt(net, P, T, pi);
y
% y = [10.004] [20.002] [29.999] [39.998]
Задание 8. Сформировать сеть ADALINE с одним нейроном и одним входом, значения которого изменяются от –1 до +1, двумя линиями задержки и одним выходом для предсказаний значений детерминированного процесса p(t),
выполнив следующие действия:
1. Сформировать колебательное звено, реакция которого на ступенчатый
сигнал будет использована в качестве детерминированного процесса p(t):
clear
sys = ss(tf(1, [1 1 1]));
% колебательное звено
time = 0:0.2:10;
% интервал процесса
[Y, time] = step(sys, 0:0.2:10).
2. Сформировать обучающее множество:
p = y(1: length(time) 2)' ;
% входной сигнал
t = y(3: length(time))' ;
% целевой выход
time = 0:0.2:10;
[Y, time] = step(sys, 0:0.2:10 ).
3. Сформировать сеть ADELINE и множества Р и Т:
net = newlin([1 1], 1, [1 2]);
% lr = 0.01
33
P = num2sell(p);
T = num2cell(t).
4. Настроить сеть:
pi = {0 0}
% начальные значения для задержек
net.adaptParam.passes = 5;
[net, Y, E, Pf, Af] = adapt(net, P, T, pi);
Y1 = cat(1, Y{:})
% массив ячеек в массив чисел
5. Построить графики:
plot(time, Y1, 'b:', time, P, 'r –', …
xlabel('Время, c'), ylabel('Процессы'))
title('Обучение нейронной сети').
6. Промоделировать сеть ADALINE:
x = sim(net, P);
x1 = cat(1, x{:});
plot(time, x1, 'b', time, p, 'r');
title('Моделирование нейронной сети').
Лабораторная работа № 6. Сети Эльмана
Цели работы: 1) изучение архитектуры рекуррентных нейронных сетей
Эльмана и специальных функций для их создания, инициализации, настройки
весов и смещений, обучения; 2) ознакомление с демонстрационным примером и
его скриптом, а также приобретение навыков построения сетей управления
движущимися объектами, построения систем технического зрения и решения других динамических задача.
Задание 1. Создать рекуррентную нейронную сеть Эльмана, которая для
случайной булевой последовательности из нулей и единиц выдаёт булеву последовательность, имеющую единицы только в том случае, когда во входной
последовательности встретились две единицы подряд:
P = round (rand ( 1, 20 ));
34
T = [0 ( P ( 1 : end – 1 ) + P ( 2 : end ) = = 2 )];
Pseq = con2seq(P); % – массив ячеек Pseq;
Tseq = con2seq(T); % – массив ячеек Tseq;
net – newelm ( [0 1], [10, 1], {′tansig′, ′logsig′})
% 10 нейронов во входном слое
gensim(net)
net.trainParam.goal = 0.001;
net.trainParam.epochs = 1000;
net = train(net, Pseq, Tseq);
Y = sim(net, Pseq)
Y1 = seq2con(Y);
E = round(T – Y1{1})
% нулевые ошибки.
Задание 2. Создать сеть Эльмана для детектирования амплитуды гармонического сигнала, выполнив следующие действия:
1. Создать выборки из двух синусоид с амплитудами 1.0 и 2.0:
p1 = sin(1 : 20);
p2 = sin(1 : 20) * 2;
2. Сформировать целевые векторы:
t1 = ones(1, 20);
t2 = ones(1, 20) * 2;
3. Сформировать набор векторов входа и целей:
p = [p1 p2 p1 p2];
t = [t1 t2 t1 t1].
4. Сформировать обучающие последовательности:
Pseq = con2seq(p);
% массив ячеек;
Tseq = con2seq(t);
% массив ячеек;
5. Создать сеть Эльмана:
net = newelm( [ -2 2], [10, 1], …
{′tansig′, ′purelin′}, …, ′traingdx′)
35
net.layers{1}, net.IW{1, 1}, net.LW{1, 1}
net.layers{2}, net.LW{2, 1}.
6. Обучить сеть:
net.trainParam.epochs = 1000;
net.trainParam.show = 25;
net.trainParam.goal = 0.01;
[net, tr] = train(net, Pseq, Tseq);
net.IW{1, 1}, net.LW{1, 1}, net.LW{2, 1}.
7. Проверить сеть на обучающей последовательности:
figure(2)
a = sim(net, Pseq);
time = 1 : length(p);
plot(time, t, ′- -′, time, cat(2, a {:} ) )
axis([1 80 0.8 2.2]).
8. Проверить сеть на произвольной последовательности:
p3 = sin(1 : 20) * 1.6;
t3 = ones(1, 20) * 1.6;
p4 = sin(1 : 20) * 1.2; t4 = ones(1, 20) * 1.2;
p9 = [p3 p4 p3 p4];
t9 = [t3 t4 t3 t4];
pgseq = con2seq(pg);
figure(3);
a = sim(met, pgseq);
time = 1 : length(pg);
time = 1 : length(pg);
plot(time, tg, ‘- -’, time, cat(2, a{ : } ) )
axis( [1 80 0.8 2.2] ).
36
Лабораторная работа № 7. Сети Хопфилда
Цели работы: 1) изучение архитектуры рекуррентных нейронных сетей
Хопфилда и специальных функций для их создания, взвешивания входов,
накопления и активизации; 2) ознакомление с демонстрационными примерами
и их скриптами, а также приобретение навыков построения таких сетей для решения задач распознавания образов и создания ассоциативной памяти.
Задание 1. Создать сеть Хопфилда с двумя устойчивыми точками в трёхмерном пространстве, выполнив следующие команды:
T =[-1 -1 1 ; 1 -1 1]
% целевые вершины
net =newhop(T);
% создание сети
net, gensim(net)
% параметры и структура сети
Ai = T ;
% начальные условия для линий задержки
Y = sim(net,2,[], Ai);
% сеть устойчива
Ai ={[-0.9 ; -0.8 ; 0.7]};
Y=sim(net,{1 5},{}, Ai);
% переход к устойчивому состоянию [-1 -1 1]
Задание 2. Создать сеть Хопфилда с четырьмя устойчивыми точками в
двухмерном пространстве, выполнив следующие команды:
T = [1 -1; -1 1; 1 1; -1 -1]′
plot(T(1, : ),T(2, : ), ′*r′)
% точки равновесия;
axis([-1.1 1.1 -1.1 1.1]);
title(′Точки равновесия проектируемой сети′);
xlabel(′a(1)′), ylabel(′a(2)′)
net =newhop(T);
W=net.LW{1,1}
b=net.b{1,1}
Ai = T;
Y=sim(net,4,[],Ai)
plot(T(1, : ),T(2, : ), ′*r′), hold on ]
axis([-1.1 1.1 -1.1 1.1]) xlabel(‘a(1)’), ylabel(′a(2)′)
37
new=newhop(T);
[Y,Pf,Af]=sim(net,4,[],T);
for i=1:25
a={rands(2,1)};
[Y,Pf,Af]=sim(net,{1,20},{},a);
record=[cell2mat(a),cell2mat(Y)]
start=cell2mat(a);
plot(start(1.1), start(2.1),′kx′.record(1,:),record(2,:))
end
Лабораторная работа № 8. Радиальные базисные сети общего вида
Цели работы: 1) изучение архитектуры радиальных базисных нейронных
сетей общего вида и специальных функций для их создания и автоматической
настройки весов и смещений, ознакомление с демонстрационными примерами
и их скриптами; 2) приобретение навыков построения таких сетей для классификации векторов и аппроксимации функций.
Задание 1. Создать радиальную базисную сеть с нулевой ошибкой для обучающей последовательности P = 0:3 и T = [0.0 2.0 4.1 5.9], проанализировать
структурную схему построенной сети и значения параметров ее вычислительной модели, выполнив следующие действия:
1. Создать радиальную базисную сеть с нулевой ошибкой:
P = 0:3;
T = [0.0 2.0 4.1 5.9];
net = newrbe(P, T);
2. Проанализировать структурную схему построенной сети:
gensim(net);
3. Проанализировать параметры вычислительной модели сети:
net
net.layers{1}.size
38
% число нейронов в 1-м слое
net.layers{2}.size
% число нейронов во 2-м слое
net.layers{1}.initFcn
net.layers{1}.netInputFcn
net.layers{1}.transferFcn
net.layers{2}.initFcn
net.layers{2}.transferFcn
net.layers{2}.netInputFcn
net.inputWeights{1, 1}.initFcn
net.inputWeights{1, 1}.weightFcn
net.inputWeights{2, 1}.initFcn
net.inputWeights{2, 1}.weightFcn
net.inputWeights{1, 1}.learnFcn
net.IW{1, 1}, net.b{1}
net.LW{2, 1}, net.b{2}
net.inputWeights{1, 1},
net.biases{1} net.inputWeights{2, 1},
net.biases{2}
4. Выполнить моделирование сети и построить графики:
plot(P, T, ‘*r’, ′MarkerSize′, 2, ′LineWidth′, 2)
hold on
V=sim(net, P);
plot(P, V, ′*b′, ′MarkerSize′, 9, ′LineWidth′, 2) P1=0.5:2.5;
Y=sim(net, P1);
plot(P1, Y, ′*k′, ′MarkerSize′, 10, ′LineWidth′, 2)
Задание 2. Создать радиальную базисную сеть для обучающей последовательности P = 0:3 и T = [0.0 2.0 4.1 5.9] при средней квадратичной ошибке 0.1,
проанализировать структурную схему построенной сети и значения параметров
ее вычислительной модели, выполнив действия задания и заменив в командах
функцию newrbe(P, T) на newrb(P, T, 0.1).
39
Задание 3. Создать радиальную базисную сеть с нулевой ошибкой для
большого числа значений входа и цели, выполнив следующие действия:
1. Задать обучающую последовательность и построить для нее график:
P = –1:0.1:1;
T = [–0.9602 –0.5770 –0.0729 0.3771 0.6405 0.6600 …
0.4609 0.1336 –0.2013 –0.4344 –0.5000 –0.3930…
–0,1647 0.988 0.3072 0.3960 0.3449 0.1816
–0.0312 –0.2189 –0.3201];
plot(P, T, ′*r′, ′MarkerSize′, 4, ′LineWidth′, 2)
hold on
2. Создать сеть и определить число нейронов в слоях:
net = newrbe(P, T);
net.layers{1}.size
% 21нейрон в первом слое
net.layers{2}.size
% 1 нейрон во втором слое
gensim(net);
3. Выполнить моделирование сети и построить график:
V = sim(net, P);
plot(P, V, ′*b′, ′MarkerSize′, 5, ′LineWidth′, 2) P = [–0.75 –0.25 0.25 0.75]
V = sim(net, P);
hold on
plot(P, V, ′*b′, ′MarkerSize′, 10, ′LineWidth′, 2).
Задание 4. Создать радиальную базисную сеть для большого числа значений входа и цели при средней квадратичной ошибке 0.01, выполнив действия
задания 3 и заменив функцию newrbe(P, T) на функцию newrb(P, T, 0.01).
Задание 5. Провести аппроксимацию функции f(x) с помощью разложения
в ряд радиальных базисных функций:
p = –3:0.1:3;
a1 = radbas(P);
a2 = padbas(P–1.5);
40
a3 = radbas(P+2);
a = a1 + a2 + 0.5*a3;
plot(P, a1, p, a2, p, 0.5*a3, p, a).
Разложение указанного вида может быть реализовано на двухслойной
нейронной сети, первый слой которой состоит из радиальных базисных нейронов, а второй – из единственного нейрона с линейной характеристикой, на котором суммируются выходы нейронов первого слоя.
Лабораторная работа № 9. Радиальные базисные сети типа GRNN
Цели работы: 1) изучение архитектурных особенностей радиальных базисных нейронных сетей типа GRNN и специальных функций для их создания, автоматической настройки весов и смещений и нормированного взвешивания; 2)
ознакомление с демонстрационным примером и его скриптом, а также приобретение навыков построения таких сетей для решения задач обобщенной регрессии, анализа временных рядов и аппроксимации функций.
Задание 1. Создать обобщенную регрессионную сеть для обучающей последовательности Р=0:3 и Т[0.0 2.0 4.1 5.9], проанализировать ее структурную
схему и значения параметров вычислительной модели, выполнить моделирование сети для различных входов, построить графики и оценить влияние на выходные значения параметра SPREAD, выполнив следующие команды:
P = 0:3;
T = [0.0 2.0 4.1 5.9];
net = newgrnn(P,T)
% параметр SPREAD = 1.0
gensim (net)
plot(P,T, ′*r′, ′MarkerSize′, 2, ′LineWidth′, 2)
hold on
V = sim(net, P)
plot(P,V, ′o8′, ′MarkerSize′, 8, ′LineWidth′, 2) P1 = 0.5:2.5;
Y = sim(net, P1);
41
plot(P1,V, ′+k′, ′MarkerSize′, 10, ′LineWidth′, 2)
Y = sim(net, 0:0.5:3)
% для нового входа
net = newgrnn(P, T, 0.1)
% параметр SPREAD = 0.1
Y = sim(net, 0:0.5:3)
% сравнить результаты
Задание 2. Построить обобщенную регрессионную сеть для решения задачи аппроксимации и экстраполяции нелинейной зависимости, восстанавливаемой по экспериментальным точкам, выполнив следующие команды:
P = [1 2 3 4 5 6 7 8 ];
% экспериментальные
T = [0 1 2 3 2 1 2 1 ];
% данные в 8 точках
SPREAD = 0.7;
% значение меньше шага Р = 1
net = newgrnn(P, T, SPREAD)
net.layers{1}.size, net.layers{2}.size % 8 и 8;
A = sim(net, P);
plot(P, T, ′*k′, ′MarkerSize′, 10),
hold on
plot(P, A, ′ok′, ′MarkerSize′, 10)
% аппроксимация
P2 = –1: 0.1: 10;
% диапазон Р2 больше диапазона Р
A2 = sim(net, P2);
plot(P2, A2, ′ –k′, ′LineWidth′, 2)
% экстраполяция
hold on,
plot(P, T, ′*k′, ′MarkerSize′, 10)
% сравнить точки
Лабораторная работа № 10. Радиальные базисные сети типа PNN
Цели работы: 1) изучение архитектурных особенностей радиальных базисных нейронных сетей типа PNN и специальных функций для их создания, автоматической настройки весов и смещений и конкурирующей активации; ознакомление с демонстрационным примером и его скриптом; 2) приобретение
навыков построения таких сетей для решения задач классификации на основе
подсчёта вероятности принадлежности векторов к рассматриваемым классам и
42
для решения других вероятностных задач.
Задание 1. Создать вероятностную нейронную сеть для обучающей последовательности, состоящей из вектора входа Р=[1 2 3 4 5 6 7] и индекса классов
Тс=[1 2 3 2 2 3 1], проанализировать её структурную схему и параметры вычислительной модели, осуществить моделирование сети и оценить правильность
классификации, выполнив следующие команды:
Р=[1 2 3 4 5 6 7];
% значения входа
Tc=[1 2 3 2 2 3 1];
% индексы классов (3)
T=ind2uec(Tc);
% матрица связанности (целей)
net=newpnn(P,T);
% создание сети PNN
gensim(net);
% структура сети
net;
% параметры сети
Y=sim(net,P);
% моделирование сети
Yc=iecc2ind(Y);
% классы входных векторов
% 1 2 3 2 2 3 1.
Задание 2. Создать вероятностную нейронную сеть для определения принадлежности двухэлементных входных векторов к одному из трёх классов на
основании обучающей последовательности 7 входов Р[0 0; 1 1; 0 3; 1 4; 3 1; 4 1;
4 3] и индекса классов Тс=[1 1 2 2 3 3 3], значения в котором определяют класс
соответствующего вектора входа, выполнив команды:
Р=[0 0; 1 1; 0 3; 1 4; 3 1; 4 1; 4 3 ]; % 7 векторов
Тс=[1 1 2 2 3 3 3];
% классы
T=ind2vec(Tc);
% формирование разреженной матрицы
% связанности
T= full (T);
% преобразование к полной матрице
net= newpnn;
% создание вероятностной сети
net.layers {1}.size
% число нейронов 1 –го слоя
net.layers {2}.size
% число нейронов 2 –го слоя
Y= sim (net, P);
% моделирование сети
43
Yc= vec2ind(Y);
% формирование индекса классов
Pt= [1 3; 0 1; 5 2]’;
% векторы для тестирования
A= sim (net, Pt);
% тестирование сети
Ac= vec2ind (A);
% формирование индекса классов
Задание 3. Проанализировать структурные схемы, значения параметров
вычислительных моделей и результаты моделирования нейронных сетей, используемых в следующих демонстрационных примерах:
Demorb1 – радиальные базисные сети;
Demorb3 – использование не перекрывающихся функций активации (передаточных функций);
Demorb4 – использование перекрывающихся передаточных функций;
Demogrn1 – аппроксимация функций с помощью сети типа GRNN;
Demopnn1 – классификация векторов с помощью сети типа PNN.
Для анализа использовать скрипты примеров.
Лабораторная работа № 11. Самоорганизующиеся слои Кохонена
Цели работы: 1) изучение архитектуры самоорганизующихся нейронных
слоев Кохонена и специальных функций для их создания, инициализации,
взвешивания, накопления, активации, настройки весов и смещений, адаптации
и обучения; 2) ознакомление с демонстрационными примерами и их скриптами;
3) приобретение навыков построения самоорганизующихся слоев для исследования топологической структуры данных, их объединением в кластеры (группы) и распределением по классам.
Задание 1. Создать слой Кохонена для двух векторов входа, проанализировать его структурную схему и параметры вычислительной модели, произвести
обучение сети и моделирование, выполнив следующие команды:
44
P = [.1 .8 .1 .9; .2 .9 .1 .8];
% для обучения слоя;
net = newc([01;01],2);
% создание слоя
gensim (net);
% структура слоя
net = train(net,P);
% обучение слоя
w = net.Iw{1,1};
% веса после обучения
b = net.b{1};
% смещение после обучения
plot(P(1,:),P(2,:),’+k’)
title (′Векторы входа′),xlabel(′P(1,:)′), ylabel(′P(2,:)′)
hold on
plot (w, ′or′)
P1= [0.2:0.1:0.7; 0.2:0.1:0.7];
y = sim(net,P1)
yc = vec2ind(Y)
Задание 2. Создать слой Кохонена, который для 48 случайных векторов
формирует 8 кластеров, выполнив следующие команды:
c = 8;
% число кластеров
n = 6;
% число векторов в классе
x = [–10 10; –5 5];
% диапазон входов
[r,q] = size(x);
% r – число строк, q – число столбцов
minU = min(x′)′
% минимальные значения
maxU = max(x′)′
% максимальные значения
v = rand(r,c)*((maxv – minU)*ones(1,c)+minU*ones(1,c));
t = c*n
% число точек
v = [v v v v v v];
% 48 двухэлементных векторов
v =v+randn(r,t)*d;
% координаты точек
P = v;
% векторы с отклонениями (нормальный закон)
plot (P(1,:),P(2,:), ′+k′)
title (‘Векторы входа’),xlabel(′P(1,:)′), ylabel(′P(2,:) ′)
net =newc([–2 12; –1 6],8 0.1);
wo = net.IW{1,1}
% веса после инициализации
bo = net.b{1}
% смещения после инициализации
co = exp(1)/60
% начальная активность
45
net.trainParam.epochs = 500;
% обучение
net = train(net, P) , a = sim(net, P), ac = vec2ind(a)
net.IW{1}
% веса после обучения
bn = net.b{1}
% смещения после обучения
cn = exp(1)/bn
% активность после обучения
net = newc([–2 12; –1 6], 8 0.1);
% начальная активность
co = exp(1). /net.b{1}
net.adaptParam.passes = 500;
[net, y,e] = adapt (net, mat2cell(p)) % адаптация
a = sim(net, P)
% моделирование после
ac = vec2ind(a)
% адаптации.
Задание 3. Построить график приращений вектора смещений и проанализировать пример democ1.
Лабораторная работа № 12 Самоорганизующиеся карты Кохонена
Цели работы: 1) изучение архитектуры самоорганизующихся нейронных
сетей в виде карт Кохонена и специальных функций для создания карты и её
топологии, взвешивания, накопления, настройки весов (размещение нейронов),
адаптации и обучения; 2) ознакомление с демонстрационными примерами и их
скриптами, а также приобретение навыков построения самоорганизующихся
карт для решения задач кластеризации входных векторов.
Задание 1. Рассчитать положение нейронов на четырехмерной сетке с прямоугольной топологией размера 5432 и построить график расположения
нейронов, выполнив следующие команды:
pos=gridtop(5,4,3,2)
% массив координат узлов размера N*S
% где N – количество измерений, равное 4
% S – количество узлов сетки
% равное произведению числа нейронов по
% каждому измерению 5*4*3*2=120
46
% вывод только трех размерностей.
plotsom(pos)
Задание 2. Рассчитать положение нейронов на двухмерной сетке с прямоугольной топологией размера 23 и построить график расположения нейронов,
выполнив следующие команды:
рos =gridtop(2,3)
%010101
%001122
plotsom(pos)
% плоский график.
Задание 3. Рассчитать положение нейронов на двухмерной сетке с прямоугольной топологией размера 32 и построить график расположения нейронов,
выполнив следующие команды:
рos =gridtop(3,2)
%010101
%001122
plotsom(pos)
% плоский график.
Задание 4. Рассчитать положение нейронов на трехмерной сетке с гексагональной топологией размера 543 с 60 нейронами и построить график их расположения, выполнив следующие команды:
рos =Hextop(5,4,3) % массив размера 3*60;
рlotsom(pos)
% построение графика.
Задание 5. Сформировать гексагональную сетку размером 23 и построить
график, выполнив команды:
pos=hextop(2,3)
% 0 1,0 0,5 1,5 0 1,.0
% 0 0 0,866 0,866 1,7321 1,7321
plotsom(pos)
Задание 6. Создать сетку размера 23 со случайным расположением узлов
и построить график расположения нейронов, выполнив следующие действия:
pos=randtop(2,3)
% 0,062 0,647 0,49 и т. д.
% 0 0,122 0,904 и т. д.
plotsom(pos)
% построение графика.
Задание 7. Создать сетку размера 543 со случайным расположением уз-
47
лов и построить график расположения нейронов, выполнив команды:
pos=randtop(5,4,3)
% создание сетки
plotsom(pos)
% построение графика.
Задание 8. Вычислить евклидово расстояние между нейронами сети с теологией, для которой задана матрица для 10 нейронов в трехмерном пространстве, выполнив следующие команды:
pos=rand(3,10)
% случайная матрица координат
d=dist(pos)
% евклидово расстояние между нейронами
Задание 9. Вычислить расстояние максимального смещения координат
нейронов, размещенных в трехмерном пространстве, выполнив команды
pos = rand(3,10);
% случайная матрица координат
d = boxdist(pos)
% максимальное координатное смещение, для
% векторов х и у вычисляется как d = max(abs(x –y))
Задание 10. Вычислить суммарные координатные смещения для сетки из
10 нейронов в трехмерном пространстве со случайной матрицей координат,
выполнив следующие действия:
pos = rand(3,10)
% случайные координаты для 10 нейронов
d = mandist(pos)
% суммарное координатное смещение, для
% векторов х и у вычисляется как d = sum(abs(x –y))
Задание 11. Вычислить расстояние связи между нейронами, распределёнными случайным образом в трехмерном пространстве, выполнив команды:
pos = rand(3,10)
% массив случайных координат для 10 нейронов.
d = linkdist(pos)
% расстояния связи между нейронами,
% определяемые следующим образом:
%011111111111
%101111111111
%110111111111
% 1 1 1 0 2 1 2 1 1 1 1 1 и т. д.
Задание 12. Создать гексагональную карту Кохонена размером 23, про-
48
анализировать ее структурную схему и параметры вычислительной модели,
произвести обучение карты и ее моделирование, а также построить необходимые графики, выполнив следующие команды:
net = newsom([0 2; 0 1],[2 3]);
% два входа
net, net.layers{1}
% вычислительная модель
P = [0.1 0.3 1.2 1.1 1.8 1.7 0.1 0.3 1.2 1.1 1.8 1.7;…….
0.2 0.1 0.3 0.1 0.3 0.2 1.8 1.8 1.9 1.9 1.7 1.8];
plotsom(net.IW{1,1}, net.layers{1}.distances)
hold on
plot(P(1,:),P(2,:),′*k′,′MarkerSize′,10)
net.trainParam.epochs = 2000;
net.trainParam.show = 100;
net = train(net,P);
plot(P(1,:),P(2,:),′*′,′MarkerSize′,10)
hold on
plotsom(net.IW{1,1}, net.layers{1}.distances)
net.IW{1,1}
a = sim(net,[1.5;1]
% a = (3,1) 1
Задание 13. Создать одномерную карту Кохонена из 10 нейронов, обучить
её на последовательности из 100 двухэлементных векторов единичной длины,
распределенных равномерно в пределах от 0 до 90º, построить график распределения векторов по кластерам и выполнить моделирование сети для одного
вектора входа, выполнив следующие команды:
аngels=0 : 0.5 +pi/99 : 0.5*pi;
p=[sin(angels); cos(angels)];
plot(P(1, 1:10:end), P(2, 1:10:end), ′*8′)
hold on
net=newsom([0 1 ;0 1], [10]);
net.trainparam.epochs=2000;
49
net.trainparam.show=100;
[net,tr]=train(net,P);
plotsom(net.iw{1,1}, net.layers{1}.distances)
figure(2)
a=sim(net,P)
% моделирование на обучающем множестве и
% построение столбцовой диаграммы
a=sim(net,[1;0])
% отнесен к 10–му кластеру.
Задание 14. Создать двухмерную карту Кохонена размеров 56 с гексагональной топологией, обучить на последовательности из 1000 двухэлементных
случайных векторов, элементы которых распределены по равномерному закону
в интервале [ –1; 1], и выполнить моделирование, используя команды:
P=rands(2,1000)
plot(P(1,:), P(2,:), ′+′)
net.trainparam.epochs=1000;
net.trainparam.show=100;
net=train(net,P);
plotsom(net, w{1, 2}, net.layers{1}.distances)
a=sim(net, P); bar(sum(a′))
a=sim(net, [0.5; 0.3], hold on
plot(0.5, 0.3, ′*k′).
50
% столбцы
Литература
1. А.В. Сивохин, А.А. Лушников, С.В. Шибанов. Искусственные нейронные
сети. – Пенза: Изд-во Пенз. гос. ун-та, 2004. – 136 с.
2. Д.А. Тархов. Нейронные сети. Модели и алгоритмы. – М.: Радиотехника,
2005. – 256 с.
3. С.Хайкин. Нейронные сети: полный курс, 2-е издание. – М.: Издательский дом «Вильямс», 2006. – 1104 с.
4. М.С. Тарков Нейрокомпьютерные системы. – М.: Интернет-Университет
Информационных Технологий: Бином. Лаборатория знаний, 2006. – 142 с.
5. Р. Тадеусевич, Б. Боровик, Т. Гончаж, Б. Леппер. Элементарное введение
в технологию нейронных сетей с примерами программ. – М.: Горячая линия – Телеком, 2011 – 408 с.
51
