Лабораторная работа № 1 - Пензенский государственный

Министерство образования и науки Российской Федерации
Пензенский государственный университет
А. В. Сивохин, А. А. Лушников, С. В. Шибанов
ИСКУССТВЕННЫЕ НЕЙРОННЫЕ СЕТИ
Лабораторный практикум
Наградной
логотип
вуза
Издательство
Пензенского государственного
университета
Пенза 2004
УДК 681.3
С34
Рецензенты:
Научно-технический совет Федерального государственного
унитарного предприятия ОАО «НПП «Рубин»
Кандидат технических наук, доцент кафедры «Прикладная математика»
Пензенского государственного педагогического университета
им. В. Г. Белинского
В. В. Дрождин
С34
Сивохин, А. В. Искусственные нейронные сети [Текст]: Лаб.
практикум / А. В. Сивохин, А. А. Лушников, С. В. Шибанов. – Пенза:
Изд-во Пенз. гос. ун-та, 2004. – 136 с.: 8 ил., библиогр. 10 назв.
Рассматриваются вопросы проектирования, обучения, анализа и
моделирования известных типов нейронных сетей в системе MATLAB 6 с
использованием пакета Neural Networks Toolbox (NNT).
Лабораторный практикум подготовлен на кафедре «Математическое
обеспечение и применение ЭВМ» и предназначен для студентов
специальностей
220400
и
220100
при
изучении
дисциплин
«Нейрокомпьютерные системы», «Системы искусственного интеллекта» и
«Системное программное обеспечение».
УДК 681.3
© Издательство Пензенского государственного
университета, 2004
© Сивохин А. В., Лушников А. А.,
Шибанов С. В., 2004
2
Введение
Искусственные нейронные сети основаны на весьма простой
биологической модели нервной системы, состоящей из огромного
числа (1011) нейронов, каждый из которых принимает взвешенную
сумму входных сигналов и при определенных условиях передает
сигнал другим нейронам. Количество связей нейронов в системе
достигает 1015.
Теория нейронных сетей возникла из исследований в области
искусственного интеллекта и связана с попытками воспроизведения
способности нервных биологических систем обучаться и исправлять
ошибки, моделируя низкоуровневую структуру мозга. Исследования
по созданию таких систем на основе высокоуровневого
(символьного) моделирования процесса мышления не принесли
желаемых результатов. Эта теория развивалась в течение последних
пяти десятилетий и за последние пятнадцать лет нашла широкое
практическое применение: в космонавтике и аэронавтике – для
имитации траекторий полета и построения систем автоматического
пилотирования; в военном деле – для управления оружием и
слежением за целями; в электронике – для разработки систем
машинного зрения и синтеза речи; в медицине – для диагностики
заболеваний и конструирования протезов; в производстве – для
управления технологическими процессами, роботами и т. д. Такой
успех нейронных сетей объясняется тем, что была создана
необходимая элементная баз для реализации нейронных сетей, а
также разработаны мощные инструментальные средства для их
моделирования в виде пакетов прикладных программ. К числу
подобных
пакетов
относится
пакет
Neural
Networks
Toolbox (NNT) системы математического моделирования MATLAB 6
фирмы Math Works.
3
Пакет прикладных программ NNT содержит средства для
построения нейронных сетей, базирующихся на поведении
математического аналога нейрона. Пакет обеспечивает эффективную
поддержку проектирования, обучения, анализа и моделирования
множества известных типов сетей – от базовых моделей персептрона
до самых современных ассоциативных и самоорганизующихся сетей.
В пакете имеется более 15 таких типов. Для каждого типа
архитектуры и обучающих правил имеются М-функции
инициализации, обучения, адаптации, создания, моделирования,
отображения, оценки и демонстрации, а также примеры применения.
Обеспечена возможность генерации переносимого кода с помощью
пакета Real Time Workshop, также входящего в систему MATLAB 6.
Лабораторные работы, описания которых содержатся в данном
практикуме, разработаны с целью научить студентов эффективно
использовать мощный инструментальный пакет NNT системы
MATLAB 6 для проектирования, анализа и моделирования
нейронных сетей. Первые две лабораторные работы позволяют
освоить интегрированную среду системы MATLAB и основы
программирования на языке сверхвысокого уровня этой системы.
Остальные лабораторные работы дают возможность познакомиться
со многими типами нейронных сетей, научиться создавать, обучать и
исследовать такие сети. Описательная часть лабораторной работы
содержит необходимый минимум сведений по теме, практическая
часть включает достаточное число заданий для приобретения
навыков в использовании пакета NNT.
4
Лабораторная работа № 1
Основы программирования
в системе MATLAB
Цель работы: изучение основ проблемно-ориентированной
системы программирования MATLAB, обеспечивающей работу с
массивами строковых и числовых данных, матрицами, структурами,
классами и ячейками с помощью матричных операций, функций,
разнообразных управляющих структур и средств расширения
системы, а также приобретение навыков применения команднографического интерфейса системы для построения и исследования
нейронных сетей различной архитектуры.
Теоретические сведения
Введение
Мощная инструментальная система MATLAB обеспечивает
процедурное,
операторное,
функциональное,
логическое,
структурное, объектно-ориентированное и визуальное (средствами
пакета Simulink) программирование. Она базируется на математикоориентированном языке сверхвысокого уровня, который упрощает
запись алгоритмов и открывает новые методы их создания.
Язык системы MATLAB по своей структуре напоминает
популярный командный язык Бейсик. Команды языка исполняются в
режиме интерпретации. С его помощью можно создавать текстовые
модули-функции и модули-сценарии. Файлы, где хранятся такие
модули, имеют расширение *.m и называются М-файлами, а
находящиеся в них функции – М-функциями. В системе имеется
огромная библиотека М-функций в текстовом формате, которые
можно модифицировать для достижения желаемых целей.
Пользователь может создавать собственные М-функции и включать
их в систему по словарному принципу.
5
Базовые средства языка программирования
Система MATLAB может использоваться в двух режимах: в
режиме непосредственного счета (командный режим) и в режиме
программирования.
В командном режиме пользователь последовательно вводит
команды входного языка и получает ответ. С помощью этого режима
можно решить множество математических задач различной
сложности.
Однако при решении серьезных задач возникает необходимость
сохранения используемых последовательностей вычислений, а также
их дальнейших модификаций. Для решения этой задачи система
MATLAB имеет в своем составе мощный язык программирования
высокого уровня.
Программами в системе MATLAB являются файлы текстового
формата с расширением m, содержащие запись программ в виде
программных кодов.
Для редактирования файлов программ может использоваться
любой текстовый редактор, а также специальный многооконный
редактор. Редактор программ системы MATLAB имеет следующие
возможности:
цветовая подсветка синтаксиса, позволяющая выявить ошибки;
синтаксический контроль на стадии подготовки М-файла;
установка точек прерывания при интерпретации команд;
автоматическая нумерация строк программы для выдачи сообщений.
Язык программирования системы MATLAB имеет следующие
средства для построения команд и написания М-файлов:
1) данные различного типа: double, numeric, char, cell, array;
2) константы и переменные: 25, pi, eps, ‘Hello’, ans, m, n;
3) операторы, включая операторы математических выражений: +,-,*;
4) встроенные команды и функции: help, clear, plot, sin, cos;
5) функции пользователя: func, map, draw, paint, neuron;
6) управляющие структуры: if, for, while, switch, try, catch, end;
7) системные операторы и функции: realmin, realmax, Inf, Nan;
6
8) средства расширения языка: пакет NNT, пакет Simulink.
M-файлы сценариев и функций
M-файлы системы MATLAB делятся на два класса:
 файлы-сценарии, не имеющие входных параметров;
 файлы-функции, имеющие входные параметры.
Файл-сценарий или Script-файл не имеет списка входных
параметров. Он использует глобальные переменные, т. е. такие
переменные, значения которых могут быть изменены в любой момент
сеанса работы и в любом месте программы. Для запуска файласценария из командной строки MATLAB достаточно указать его имя в
этой строке.
Файл-сценарий имеет следующую структуру:
%Основной комментарий – одна строка (обязателен)
%Дополнительный комментарий – любое число строк (не обязателен)
Тело файла с любыми выражениями, командами и
управляющими структурами.
Основной комментарий выводится при выполнении команд
lookfor и help имя_каталога. Полный комментарий выводится при
выполнении команды help имя_файла, причём вывод производится
до первой пустой строки.
Файл-функция отличается от файла-сценария прежде всего тем,
что созданная им функция имеет входные параметры, список
которых указывается в круглых скобках. Используемые в файлахфункциях переменные и имена параметров являются локальными
переменными, изменение значений которых в теле функции не
влияет на значения, которые те же самые переменные могут иметь за
пределами функции.
Файл-функция имеет следующую структуру:
function var=f_name (Список_параметров_передаваемых_
значений)
%Основной комментарий – одна строка (обязателен)
7
%Дополнительный
(необязателен)
комментарий
Тело файла с любыми
управляющими структурами.
var=выражение
–
любое
выражениями,
число
строк
командами
и
Последняя инструкция
“var=выражение” вводится, если
требуется, чтобы функция возвращала результат вычислений. Если
необходимо большее количество выходных параметров, структура
модуля будет иметь следующий вид:
Function[var1,var2,...]=f_name(Список_параметров_передаваемых_
значений)
%Основной комментарий – одна строка (обязателен)
%Дополнительный комментарий – любое число строк
(необязателен)
Тело файла с любыми выражениями, командами и
управляющими структурами.
var1=выражение
var2=выражение
...
Имена var, var1, var2, ... для возвращаемых значений являются
глобальными или известными в теле вызывающей М-функции.
Управляющие структуры
Помимо программ с линейной структурой, инструкции которых
исполняются строго по порядку, MATLAB позволяет создавать
программы, структура которых нелинейна. Для создания таких
программ применяются следующие управляющие структуры:
1. Диалоговый ввод: input (строка);
8
2. Условный оператор: if ... elsif ... else... end;
3. Циклы типа for...end: for Заголовок_цикла Тело_цикла end;
4. Циклы типа while...end: while Условие_цикла Тело_цикла
end;
5. Конструкция переключателя: switch Exp case B1 case b2 …
otherwise end;
6. Конструкция try...catch...end: try Тело_try catch Тело_catch
end;
7. Создание паузы в вычислениях: pause, pause (...), pause on,
pause off.
Для организации диалогового вывода используются функции
input и disp.
Функция input имеет следующий синтаксис:
переменная = input(строка)
При выполнении этой команды вначале выводится строка, затем
происходит остановка работы программы и ожидается ввод
значения. Ввод подтверждается нажатием клавиши Enter, после чего
введенное значение присваивается переменной.
Функция disp предназначена для вывода ее параметра на экран:
disp (Выводимое значение)
Условный оператор if в общем виде записывается следующим
образом:
if Условие
Список_инструкций_If
elseif Условие
Список_инструкций_Elsif
else
Список_инструкций_Else
9
end
Циклы типа for...end обычно используются для организации
вычислений с заданным числом повторяющихся циклов.
Конструкция такого цикла имеет следующий вид:
for var=Выражение, Список_инструкций end
Выражение чаще всего записывается в виде s:d:e, где s –
начальное значение переменной цикла var, d – приращение этой
переменной и e – конечное значение управляющей переменной, при
достижении которого цикл завершается. По умолчанию d равно 1.
Цикл типа while...end
истинным условие:
выполняется до тех пор, пока остается
while Условие
Список_инструкций
end
Досрочное завершение циклов реализуется с помощью
операторов break или continue.
Для осуществления множественного выбора (или ветвления)
используется конструкция с переключателем типа switch:
switch switch_Выражение
case case_Выражение
Список_инструкций
case
{case_Выражение1,case_Выражение2,case_Выражение3,...}
Список_инструкций
...
otherwise,
Список_инструкций
10
end
Case_выражение может быть числом, константой, переменной,
вектором ячеек или даже строчной переменной. В последнем случае
оператор case истинен, если функция strcmp(значение, выражение)
возвращает логическое значение “истина”.
Конструкция блока вывода ошибок try...catch...end имеет
следующий синтаксис:
try
Список_инструкций
catch
Список_инструкций
end
Эта конструкция выполняет все списки инструкций. Если в какомто списке до оператора catch появляется ошибка, то выводится
сообщение об ошибке, но системная переменная последней ошибки
lasterr не меняется. В выражениях после catch сообщение об ошибке
не выводится.
Во всех управляющих структурах список инструкций, или тело,
представляет собой последовательность выражений, команд или
вложенных управляющих структур, разделяемых пробелом, запятой
или точкой с запятой. Точка с запятой запрещает вывод данных на
экран.
Для остановки программы используется оператор pause. Он
используется в следующих формах:
1) pause – останавливает вычисления до нажатия любой клавиши;
2) pause(N) – останавливает вычисления на N секунд;
3) pause on – включает режим обработки пауз;
4) pause off – выключает режим обработки пауз.
11
Практические задания
Задание 1. Разработать файл-сценарий для построения графика
синусоиды линией красного цвета с выведенной масштабной сеткой
в интервале [xmin, xmax].
1. Запустить редактор m-файлов и ввести следующую программу:
%Plot with color red
%Строит график синусоиды линией красного цвета
%с выведенной масштабной сеткой в интервале [xmin, xmax]
x=xmin:0.1:xmax;
plot(x,sin(x),'r')
grid on
2. Сохранить файл под именем «pcr.m».
3. Выполнить в командном окне MATLAB следующую команду:
>> help pcr
Ha экран выведется информация, находящаяся в основном и
дополнительном комментариях файла:
Plot with color red
Строит график синусоиды линией красного цвета
с выведенной масштабной сеткой в интервале [xmin, xmax]
>>
4. Затем запустить сценарий на выполнение:
>> pcr
??? Undefined function or variable 'xmin'.
Error in ==> C:\MATLAB6p1\work\pcr.m
On line 4 ==> x=xmin:0.1:xmax;
12
На экран выводится сообщение об ошибке, так как сценарий
использует глобальные переменные, которые не определены. Для
успешного выполнения примера необходимо задать следующие
действия:
5. Определить переменные xmin и xmax
>> xmin=-10;
>> xmax = 10;
6. Запустить сценарий на выполнение
>> pcr
Задание 2. Разработать файл-функцию для решения предыдущей
задачи, выполнив следующие действия:
1. Запустить редактор m-файлов и ввести следующую программу:
%Plot with color red
%Строит график синусоиды линией красного цвета
%с выведенной масштабной сеткой в интервале [xmin, xmax]
function x=fun(xmin,xmax)
x=xmin:0.1:xmax;
plot(x,sin(x),'r')
grid on
2. Сохранить файл под именем «fun.m».
3. Выполнить в командном окне MATLAB следующую команду:
fun(-10,10);
Обратите внимание на то, что xmin и xmax передаются как
параметры и объявлять глобальные переменные не требуется.
13
Задание 3. Разработать файл-сценарий для решения предыдущей
задачи с возможностью ввода значений пользователем, выполнив
следующие действия:
1.Запустить редактор m-файлов и ввести следующую программу:
%Plot with color red
%Строит график синусоиды линией красного цвета
%с выведенной масштабной сеткой в интервале [xmin, xmax]
disp('введите xmin и xmax ');
xmin=input('xmin = ');
xmax=input('xmax = ');
x=xmin:0.1:xmax;
plot(x,sin(x),'r')
grid on
2.Сохранить файл под именем «pcrdialog.m».
3.Выполнить в командном окне MATLAB следующие команды:
>> pcrdialog
Обратите внимание на то, что xmin и xmax объявляются в теле
сценария, поэтому объявлять глобальные переменные не требуется.
14
Лабораторная работа № 2
Массивы, структуры, ячейки
и классы системы MATLAB
Цель работы: изучение принципов работы с матрицами,
структурами, ячейками и классами в MATLAB, а также
приобретение навыков их применения для построения моделей
нейронных сетей и их исследования.
Теоретические сведения
Векторы, матрицы и многомерные массивы
В системе MATLAB любые данные представляются только в виде
массивов: одномерных (векторов), двумерных (матриц) и
многомерных любой размерности.
Система MATLAB выполняет сложные и трудоемкие операции
над векторами и матрицами даже в режиме прямых вычислений без
какого-либо
программирования.
Поддерживается
множество
операций над матрицами, таких как:
1. Создание матриц с заданными свойствами: ones, zeros, rand;
2. Конкатенация матриц: cat (dim, А, В), cat (dim, A1, A2, A3, ...);
3. Перестановка элементов: fliplr, flipud, perms;
4. Вычисление произведений и суммирование: prod, cumprod,
sum;
5. Поворот: rot 90(A), rot 90(A,k);
6. Выделение треугольных частей матриц: tril (x), tril (x,k), triu ;
7. Вычисление сопровождающей матрицы: compan;
8. Матричные операции векторной алгебры: cand, det, rank, norm;
9. Операции с многомерными массивами: +, -, *, .*, /, ./, ^, .^ .
Интересно отметить, что даже обычные числа и переменные в
MATLAB рассматриваются как матрицы размера 1х1, что дает
единообразные формы и методы проведения операций над
обычными числами и массивами. Данная операция называется
15
векторизацией. Векторизация обеспечивает и упрощение записи
операций, и существенное повышение скорости их выполнения. Это
также означает, что большинство функций может работать с
аргументами в виде векторов и матриц.
Структуры
Массив записей – это новый тип массива, в котором разрешается
накапливать в виде записей разнородные данные. Отличительная
особенность такого массива – наличие именованных полей.
MATLAB поддерживает следующие функции при работе с
массивами записей:
Функция
Описание
struct
Создать массив записей
fieldnam
Получить имена полей
getfield
Получить содержимое поля
setfield
Установить содержимое поля
rmfield
Удалить поле
isfield
Истинно, если это поле массива записей
isstruct
Истинно, если это массив записей
es
Пользователь может расширить состав функций, создавая
специальные М-файлы для обработки конкретных данных.
Определение структуры
Структура – это массив записей с именованными полями,
предназначенными для хранения данных; причем поле может
16
содержать данные любого типа: векторы, матрицы, массивы и
структуры.
Структуру можно построить двумя способами:
а) используя операторы присваивания;
б) используя функцию struct.
Для того чтобы сформировать простейшую структуру размера
1х1, необходимо присвоить данные соответствующим полям.
Система MATLAB автоматически формирует структуру по мере ее
заполнения.
Функция struct имеет следующий синтаксис:
str_array=struct('<имя_поля1>’,'<значение1>','<имя_поля2>','
<значение2>',...).
Используя индексацию, можно легко определить значение любого
поля или элемента структуры. Точно также можно присвоить
значение любому полю или элементу поля. Чтобы обратиться к
некоторому полю, необходимо ввести точку (.) после имени
структуры, за которым должно следовать имя поля.
Непосредственная индексация – это, как правило, наиболее
эффективный способ определить или присвоить значение полю
записи. Однако если использовалась функция fieldnames и известно
имя поля, то можно воспользоваться функциями setfield и getfield.
Функция getfield позволяет определить значение поля или
элемента поля:
f = getfield(array, {array_index}, 'field', {field_index})
где аргументы array_index и field_index задают индексы для
структуры и поля; они не являются обязательными для структуры
размера 1х1. Результат применения функции getfield соответствует
элементу следующей структуры
17
f = array(array_index).field(field_index);
По аналогии функция setfield позволяет присваивать значения
полям, используя обращение следующего вида:
f = setfield(array, {array_index}, 'field', {field_index}, value)
Выполнение операций с полями и элементами полей абсолютно
аналогично операциям с элементами обычного числового массива. В
обоих случаях надо использовать индексные выражения.
Для обработки структур со специфической архитектурой полей
могут понадобиться специальные функции обработки полей и их
элементов. При написании М-файлов для обработки структур
необходимо помнить, что пользователь должен сам выполнить
анализ возникновения возможных ошибок, связанных с обработкой
полей.
Массивы ячеек
В систему MATLAB включен специальный тип массивов ячеек,
элементы которого сами, в свою очередь, являются массивами.
Имеются следующие функции для работы с массивами ячеек:
Функция
Описание
cell
Создать массив ячеек
celldisp
Показать содержимое массива ячеек
cellplot
Показать графическую структуру массива ячеек
num2cell
Преобразовать числовой массив в массив ячеек
deal
Обмен данными между любыми классами массивов
18
cell2struct
Преобразовать массив ячеек в структуру
struct2cell
Преобразовать структуру в массив ячеек
iscell
Истинно, если это массив ячеек
Пользователь может расширить состав этих функций, создавая
специальные М-файлы для обработки конкретных данных.
Определение массива ячеек
Массив ячеек – это массив, где элементами являются ячейки,
которые могут содержать любой тип массива, в том числе и массив
ячеек. Массивы ячеек позволяют хранить массивы с элементами
разных типов и разных размерностей.
Создать массивы ячеек можно двумя способами:
а) используя операторы присваивания;
б) используя функцию cell, которая позволяет предварительно
разместить массив, а затем присвоить данные ячейкам.
Можно построить массив ячеек, присваивая данные отдельным
ячейкам. В этом случае система MATLAB автоматически строит
массив по мере ввода данных. Существует два способа присвоения
данных отдельным ячейкам.
Индексация ячеек
В этом случае необходимо заключить индексы ячейки в круглые
скобки, используя стандартные обозначения для массива. Заключить
содержимое ячейки в правой части оператора присваивания в
фигурные скобки { }.
Индексация содержимого
Для того чтобы индексировать массив ячеек, надо в левой части
оператора присваивания указать элемент ячейки в виде индексов в
фигурных скобках по аналогии с элементами обычного массива, а
также указать содержимое ячейки в правой части оператора
присваивания.
19
Существует также два способа для извлечения данных из массива
ячеек и передачи их либо в некоторый числовой массив, либо в
новый массив ячеек:
а) доступ к содержимому ячейки с помощью индексации
содержимого;
б) доступ к подмножеству ячеек с помощью индексации ячеек.
Доступ к содержимому ячеек (индексация
содержимого)
Используя индексирование содержимого в правой части
оператора присваивания, можно получить доступ к некоторым или
всем данным в одной ячейке. Определить переменную в левой части
оператора присваивания, чтобы запомнить содержимое ячейки.
Заключить индексное выражение в правой части оператора
присваивания в фигурные скобки. Это будет означать, что
присваивается содержимое ячеек, а не сами ячейки.
Доступ к подмножеству ячеек (индексация
ячеек)
Используя индексацию ячеек, можно переназначить любой набор
ячеек другой переменной для создания нового массива ячеек.
Используя двоеточие, можно получить доступ к подмножествам
ячеек внутри массива ячеек.
Удаление и переопределение массива ячеек
Удаляя ячейки из массива, можно уменьшить размерность
массива, применив единственный оператор присваивания. По
аналогии с обычным массивом следует использовать индексацию
вектора для удаления строки или столбца ячеек, присваивая при
этом пустую матрицу подмассиву:
A(j : k ) = [ ]
Таким образом, при удалении ячеек фигурные скобки вообще не
применяются в операторах присваивания.
Как и для обычных массивов с помощью функции reshape можно
переопределять размеры массива ячеек, причем общее количество
20
ячеек должно оставаться неизменным; с помощью функции reshape
ни удалить, ни добавить ячейки нельзя.
Описание списков переменных
Массивы ячеек могут быть использованы для замены следующих
списков переменных:
а) списков входных переменных;
б) списков выходных переменных;
в) операций вывода на экран терминала;
д) квадратных и фигурных скобок при формировании массивов.
Когда для индексирования многомерного массива ячеек
используются двоеточие и фигурные скобки, то система MATLAB
обрабатывает содержимое каждой ячейки как отдельную
переменную.
Классы
Классы и объекты позволяют добавлять новые типы данных и
новые операции. Класс описывает тип переменной и определяет,
какие операции и функции могут быть применены к этому типу
переменной. Объект – это структура или образец некоторого класса.
Добавление классов осуществляется в рамках операционной
среды системы MATLAB, которая обеспечивает возможность
хранения созданных объектов и организации каталога М-файлов,
определяющих допустимые методы обработки для данного класса
объектов. Каталог класса включает М-функции, определяющие
способы, с помощью которых операторы системы MATLAB,
включая арифметические, обработки индексов, конкатенации,
обрабатывают
объекты
данного
класса.
Переопределение
встроенных операторов для нового класса объектов в рамках
объектно-ориентированного подхода называется переопределением
методов.
В языке MATLAB отсутствует механизм объявления переменных.
Например, оператор A = zeros(10, 10) формирует обычную матрицу
размера 10х10, которая является объектом класса double. Точно
также оператор s = 'Hello world' создает объект класса char.
21
То же самое относится и к вновь создаваемым классам. Никаких
объявлений переменных или объектов не требуется. Объекты
создаются динамически посредством вызова конструктора класса.
Каталог класса
М-файлы, определяющие методы для объектов данного класса
объединяются в каталог класса, название которого задается как
@<имя_класса>.
Конструктор класса
Каталог класса должен обязательно содержать М-файл,
называемый конструктором класса. Название конструктора должно
совпадать с названиями класса и каталога без префикса @.
Конструктор создает объекты, используя данные в виде массива
записей (структуры) и приписывая им метку класса.
Функции isa и class. Эти функции используются конструктором,
но могут применяться и вне каталога класса.
Функция isa(a, 'class_name') проверяет, принадлежит ли объект a
данному классу.
При использовании вне контекста методов функция class
допускает только один аргумент.
Команда class(a) возвращает строку, содержащую имя класса для
объекта a.
Преобразование классов. Вызов функции преобразования класса
имеет вид
b = class_name(a),
где a – объект некоторого класса, отличного от class_name. В этом
случае система MATLAB ищет метод с именем class_name в
каталоге классов для объекта a. Такой метод преобразовывает объект
одного класса в объект другого класса. Если данный объект уже
является объектом класса class_name, то система MATLAB вызывает
функцию конструктора, который просто возвращает этот объект.
Наиболее важными функциями преобразования классов являются
double и char. Преобразование к классу double создает
традиционный массив системы MATLAB, хотя это может и не
22
отражать требуемого соответствия для некоторых классов.
Преобразование к классу char полезно для вывода на печать.
При работе с объектами и методами система MATLAB использует
специальное множество правил, чтобы гарантировать вызов
требуемой функции. Если, по крайней мере, один из аргументов
является объектом, система MATLAB рассматривает список
параметров слева направо, чтобы определить их старшинство. Для
операторов равного старшинства выбирается крайний левый. Затем к
нему применяются следующие правила:
1. Если имя вызываемой функции совпадает с именем встроенной
функции, то проверяется, существует ли переопределенная версия
этой функции для этого класса, а затем – для родительского. Если ни
один из этих случаев не имеет место, выдается ошибка.
2. Если имя функции совпадает с названием каталога классов,
проверяется, не является ли эта функция функцией преобразования,
и если да, то эта функция преобразования вызывается. В противном
случае вызывается конструктор класса.
3. Если оба случая не подходят, то анализируются следующие
возможности:
а) если есть метод соответствующего типа, то вызывается этот
метод;
б) если есть метод родительского класса, то вызывается метод
родительского класса;
в) если есть функция с таким именем на пути поиска, то
вызывается эта функция;
г) в противном случае генерируется ошибка.
Частные методы и функции. Каталоги классов могут иметь
связанные с ними частные каталоги. Такие каталоги могут содержать
как частные методы, которые работают с объектами данного класса,
так и частные функции, которые не работают с объектами, но
выполняют общие вычисления. Можно устанавливать частный
каталог в каталоге класса точно так же, как создается любой частный
каталог, т. е. просто создать каталог, именуемый private, внутри
каталога @class_name.
23
Во многих случаях можно изменить поведение операторов и
функций системы MATLAB, когда в качестве аргумента выступает
объект.
Это
осуществляется
путем
переопределения
соответствующих функций. Переопределение класса открывает
возможность обработки с помощью этой функции различных типов
данных при произвольном количестве входных аргументов.
Переопределение
арифметических
операций.
Каждый
встроенный оператор в системе MATLAB имеет имя. Поэтому любой
оператор может быть переопределен путем создания М-файла с
соответствующим названием в каталоге классов.
Переопределение функций. Можно переопределить любую Мфункцию, создавая функцию с тем же именем в каталоге класса.
Когда функция применяется к объекту, MATLAB прежде всего
просматривает каталог соответствующего класса, а уже потом другие
пути доступа.
Практические задания
Задание 1.Создать массив ячеек, содержащий данные различного
типа, с помощью индексации ячеек и индексации содержимого.
1. Для создания массива ячеек с помощью индексации ячеек
ввести следующие команды:
>> A(1,1)={[1 4 3; 0 5 8; 7 2 9]};
>> A(1,2)={'Anne Smith'};
>> A(2,1)={3+7i};
>> A(2,2)={-pi:pi/10:pi};
>> A
A=
[3x3 double] 'Anne Smith'
[3.0000+ 7.0000i] [1x21 double]
2. Для создания массива ячеек с
содержимого ввести следующие команды:
>> A{1, 1} = [1 4 3; 0 5 8; 7 2 9];
>> A{1, 2} = 'Anne Smith';
24
помощью
индексации
>> A{2, 1} = 3+7i;
>> A{2, 2} = -pi:pi/10:pi
A=
[3x3 double] 'Anne Smith'
[3.0000+ 7.0000i] [1x21 double]
3. Для отображения содержимого ячеек использовать функцию
celldisp:
>> celldisp(A)
A{1,1} =
1 4 3
0 5 8
7 2 9
A{2,1} =
3.0000 + 7.0000i
A{1,2} =
Anne Smith
A{2,2} =
Columns 1 through 9
-3.1416 -2.8274 -2.5133 -2.1991 -1.8850 -1.5708 -1.2566
-0.9425 -0.6283
Columns 10 through 18
-0.3142 0 0.3142 0.6283 0.9425 1.2566 1.5708 1.8850
2.1991
Columns 19 through 21
2.5133 2.8274 3.1416
Задание 2. Создать массив структур, содержащих имя, фамилию и
год рождения.
25
1. Для создания массива структур ввести следующие команды:
>> S.name = 'Ed';
>> S.fam = 'Plum';
>> S.year = 1979
S=
name: 'Ed'
fam: 'Plum'
year: 1979
>> S(2).name = 'Tony';
>> S(2).fam = 'Miller';
>> S(2).year = 1980
S=
1x2 struct array with fields:
name
fam
year
>> S(3) = struct('name','Jerry','fam','Garcia','year',1981)
S=
1x3 struct array with fields:
name
fam
year
Задание 3. Разработать файл-сценарий для решения предыдущей
задачи с возможностью ввода значений пользователем.
1. Запустить редактор m-файлов и ввести следующую программу:
%Ввод структуры S
%Структура имеет три поля:
26
%имя name, фамилию fam и год рождения year
disp('Введите поля структуры');
S.name=input('name = ');
S.fam=input('fam = ');
S.year=input('year = ');
disp(S)
2. Сохранить файл под именем «strdialog.m».
3. Выполнить в командном окне MATLAB следующую команду:
>> strdialog
Обратите внимание на то, что xmin и xmax объявляются в теле
сценария и объявлять глобальные переменные не требуется.
Задание 4. На системном диске, где установлена математическая
система MATLAB, найти папки инструментального пакета по
нейронным сетям Neural Network Toolbox (NNT, или ПППНС) и
скопировать в рабочий каталог все методы класса network,
обеспечивающие
создание,
инициализацию,
обучение,
моделирование и визуализацию нейронной сети. В рабочем каталоге
найти М-файл конструкторов класса и проанализировать их
структуру.
Задание 5. Запустить на пошаговое исполнение конструктор сети
network, который не имеет параметров, и проследить
последовательность действий по формированию объекта класса network и заданию значений по умолчанию для его атрибутов.
Задание 6. Создать объект класса нейронной сети network,
исполнив команду
net = network,
и вывести на экран все поля и все ячейки этого объекта, используя
функцию celldisр.
Задание 7. Создать объект класса нейронной сети network,
27
исполнив команду
net = network(2,3,[1;0;0], [11;00;00], ...
[000;100;010], [001], [001],
и вывести на экран все поля и все ячейки этого объекта, используя
функцию celldisр.
Задание 8. Исполнив команду gensim(net), получить на экране
структурную схему созданной сети, раскрыть её блоки с помощью
двойного щелчка мыши и выяснить смысл параметров конструктора
network. Изменяя значения параметров, проследить их влияние на
элементы структурной схемы.
28
Лабораторная работа № 3
Модели искусственного нейрона
Цель работы: изучение основных моделей искусственного
нейрона, их математического описания, а также функционального и
структурного графических представлений, исследование функций
активации и рассмотренных моделей нейронов с помощью
инструментального пакета имитационного моделирования Simulink
системы MATLAB.
Теоретические сведения
Простой нейрон
Элементарной ячейкой нейронной сети является нейрон.
Структура нейрона с единственным скалярным входом показана
на рис. 3.1,а.
а
б
Рис. 3.1. Простой нейрон
Скалярный входной сигнал р умножается на скалярный весовой
коэффициент w, и результирующий взвешенный вход w*p является
аргументом функции активации нейрона, которая порождает
скалярный выход а.
Нейрон, показанный на рис. 3.1,б, дополнен скалярным
смещением b. Смещение суммируется со взвешенным входом w*p и
приводит к сдвигу аргумента функции на величину b. Действие
смещения можно свести к схеме взвешивания, если представить что
29
нейрон имеет второй входной сигнал со значением, равным 1. Вход n
функции активации нейрона по-прежнему остается скалярным и
равным сумме взвешенного входа и смещения b. Эта сумма является
аргументом функции активации f; выходом функции активации
является сигнал а. Константы w и b являются скалярными
параметрами нейрона. Основной принцип работы нейронной сети
состоит в настройке параметров нейрона с тем, чтобы
функционирование сети соответствовало некоторому желаемому
поведению. Регулируя веса или параметры смещения, можно
“научить” сеть выполнять конкретную работу; возможно также, что
сеть сама будет корректировать свои параметры, чтобы достичь
требуемого результата.
Уравнение нейрона со смещением имеет вид
a = f(w*p+b*l).
Как уже отмечалось, смещение b – настраиваемый скалярный
параметр нейрона, который не является входом, а константа 1,
которая управляет смещением, рассматривается как вход и может
быть учтена в виде линейной комбинации векторов входа
 p
a  w b    .
1
Функция активации
Функции активации (передаточные функции) нейрона могут
иметь самый разнообразный вид. Функция активации f, как правило,
принадлежит классу сигмоидальных функций с аргументом n и
выходом а.
Ниже рассмотрены три наиболее распространенные функции
активации.
Единичная функция активации с жестким ограничениям
hardlim. Эта функция описывается соотношением а =
hardlim(n) = 1(n) и показана на рис. 3.2. Она равна 0, если
n < 0, и 1,если n >= 0.
30
Рис. 3.2. Функция активации hardlim
В состав пакета ППП Neural Network Toolbox входит
М-функция hardlim, реализующая функцию активации с
жесткими ограничениями.
Линейная функция
активации
purelin. Эта
функция
описывается соотношением а = purelin(n) = n и показана на рис.
3.3.
31
Рис. 3.3. Линейная функция активации purelin
Логистическая функция активации logsig. Эта функция
описывается соотношением а = logsig(n) = 1/(1 + ехр(-n)) и
показана на рис. 3.4. Она принадлежит к классу сигмоидальных
функций, и ее аргумент может принимать любое значение в
диапазоне
от   до   , а выход изменяется в диапазоне от 0 до 1. В пакете
ППП Neural Network Toolbox она представлена М-функцией logsig.
Благодаря свойству дифференцируемости эта функция часто
используется в сетях с обучением на основе метода обратного
распространения ошибки.
Рис. 3.4. Функция logsig
Символ в квадрате в правом верхнем углу графика характеризует
функцию активации. Это изображение используется на структурных
схемах нейронных сетей.
В пакет ППП Neural Network Toolbox включены и другие функции
активации. Используя язык MATLAB, пользователь может создавать
и свои собственные уникальные функции.
Нейрон с векторным входом
Нейрон с одним вектором входа р с R элементами p1 , p2 ,, p R
показан на рис. 3.5. Здесь каждый элемент входа умножается на веса
32
w11, w12 ,, w1R соответственно и взвешенные значения передаются
на сумматор. Их сумма равна скалярному произведению векторастроки W на вектор входа р.
Рис. 3.5. Функциональная схема нейрона
Нейрон имеет смещение b, которое суммируется со взвешенной
суммой входов. Результирующая сумма n определяется как
n  w11 p1  w12 p2    w1R pR  b
и служит аргументом функции активации f. В нотации языка
MATLAB это выражение записывается так:
n = W*p + b.
Структура нейрона, показанная на рис. 3.5, содержит много
лишних деталей. При рассмотрении сетей, состоящих из большого
числа нейронов, будет использоваться укрупненная структурная
схема нейрона (рис. 3.6).
Вход нейрона изображается в виде темной вертикальной черты,
под которой указывается количество элементов входа R. Размер
вектора входа р указывается ниже символа р и равен Rxl. Вектор
входа умножается на вектор-строку W длины R. Как и прежде,
константа 1 рассматривается как вход, который умножается на
скалярное смещение b. Входом n функции активации нейрона
33
служит сумма смещения b и произведения W*p. Эта сумма
преобразуется функцией активации f, на выходе которой получается
выходная величина нейрона а, которая в данном случае является
скалярной величиной. Структурная схема, приведенная на рис. 3.6,
называется слоем сети. Слой характеризуется матрицей весов W,
смещением b, операциями умножения W*p, суммирования и
функцией активации f. Вектор входов р обычно не включается в
характеристики слоя.
Рис. 3.6. Структурная схема нейрона
Каждый раз, когда используется сокращенное обозначение сети,
размерность матриц указывается под именами векторно-матричных
переменных. Эта система обозначений поясняет строение сети и
связанную с ней матричную математику.
На укрупненной структурной схеме для обозначения типа
функции активации применяются специальные графические
символы; некоторые из них приведены на рис. 3.7, где а –
ступенчатая; б – линейная; в – логистическая функция.
34
Рис. 3.7. Функции активации
Практические задания
Задание 1. Для функции активации с
ограничениями
hardlim
и
её
производной
определяемыми следующими соотношениями:
жесткими
dhardlim,
0, n  0;
hardlim (n)  
1, n  0;
0, n  0;
dhardlim (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′) % – график функции активации – красный;
hard on
35
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;
hardlims (n)  
 1, n  0;
0, n  0;
dhardlims (n)  
0, n  0,
выдать на экран информацию об этих функциях, построить их
графики и рассчитать векторы выхода, воспользовавшись скриптом
из М-файла hardlimfile. Новый скрипт записать в файл под именем
hardlimsfile.
Задание 3. Для линейной функции активации purelin и ее
производной, dpurelin, определяемыми соотношениями
рurelin = n;
dpurelin = 1,
выдать на экран информацию об этих функциях, построить их
графики и рассчитать векторы выхода, воспользовавшись скриптом
из М-файла hardlimfile. Новый скрипт записать в файл под именем
purelinfile.
36
Задание 4. Для положительной линейной функции активации
poslin и ее производной dposlin, определяемыми соотношениями
0, n  0;
рoslin  
n, n  0;
0, n  0;
dposlin  
1, n  0,
выдать на экран информацию об этих функциях, построить их
графики и рассчитать векторы выхода, воспользовавшись скриптом
из М-файла hardlimfile. Новый скрипт записать в файл под именем
poslinfile.
Задание 5. Для линейной функции активации с ограничениями
saflin и ее производной dsaflin, определяемыми соотношениями
0, n < 0;
soflin(n) = n, 0  n  1;
n, n > 0,
0, n < 0;
dsoflin(n)= 1, 0  n  1
1, n > 0,
выдать на экран информацию об этих функциях, построить их
графики и рассчитать векторы выхода, воспользовавшись скриптом
из М-файла hardlimfile. Новый скрипт записать в файл под именем
satlinfile.
Задание 6. Для симетричной линейной функции активации satlins
с ограничениями и ее производной dsatlins, определяемыми
соотношениями
-1, n < -1;
satlins(n) = n, -1  n
1, n > 1,

1;
37
0, n < -1;
dsatlins(n) = 1, -1  n  1
0, n > 1,
выдать на экран информацию об этих функциях, построить их
графики и рассчитать векторы выхода, воспользовавшись скриптом
из М-файла hardlimfile. Новый скрипт записать в файл под именем
satlinsfile.
Задание 7. Для радиальной базисной функции активации radbas и
ее производной dradbas, определяемыми соотношениями
radbas = e-2n,
dradbas = -2ne-2n,
выдать на экран информацию об этих функциях, построить их
графики и рассчитать векторы выхода, воспользовавшись скриптом
из М-файла hardlimfile. Новый скрипт записать в файл под именем
radbasfile.
Задание 8. Для треугольной функции активации tribas и ее
производной dtribas, определяемыми соотношениями
0, n < -1;
tribas(n) =
1-abs(n), -1  n
0, n > 1,

1;
0, n < -1;
dtribas(n) =
1, -1  n
 0
-1, 0 < n  1
0, n > 1,
выдать на экран информацию об этих функциях, построить их
графики и рассчитать векторы выхода, воспользовавшись скриптом
из М-файла hardlimfile. Новый скрипт записать в файл под именем
tribasfile.
Задание 9. Для логистической функции активации logsig и ее
производной dlogsig определяемыми соотношениями
38
logsig(n) = 1 / (1 + e-n);
dlogsig(n) = e-n / (1 + e-n)2,
выдать на экран информацию об этих функциях, построить их
графики и рассчитать векторы выхода воспользовавшись скриптом
из М-файла hardlimfile. Новый скрипт записать в файл под именем
logsigfile.
Задание 10. Для гиперболической тангенциальной функции
активации tansig и ее производной dtansig определяемыми
соотношениями
tansig(n) = 2 / (1 + e-2n) – 1;
dtansig(n) = 1 – tansig2(n),
выдать на экран информацию об этих функциях, построить их
графики и рассчитать векторы выхода, воспользовавшись скриптом
из М-файла hardlimfile. Новый скрипт записать в файл под именем
tansigfile.
Задание 11. Для конкурирующей функции активации compet
используемой для формирования вероятных и самоорганизующихся
нейронных сетей выполнить следующие действия:
1. Выдать на экран информацию об этой функции с помощью
следующего скрипта:
Name = compet(′name′)
% – cometitive;
Dname = compet(′dеriv′)
% – ″;
Inrange = compet(′active′) % – -in : inf;
Outrange = compet(′outrut′) % – 0 1.
2. Построить столбцовые диаграммы для вектора входа и для
вектора выхода, используя слой из четырех нейронов:
N = [0; 1; - 0.5; 0.5];
A = compet(n);
39
subplot(2, 1, 1), % – подокна 2  1; вывод в 1-е;
bar(n),
% – столбцовая диаграмма;
ylabet(‘n’)
% – метка оси ординат;
subplot(2, 1, 2), bar(a), ylabet(‘a’) % – во 2-м подокне.
3. Рассмотренную последовательность команд оформить в виде
скрипта в М-файл с именем competlile.
Задание 12. Выполнить действия 11-го задания для
конкурирующей функции активации с мягким максимумом softmax,
записав при этом новый скрипт в М-файл с именем softmaxfile.
Задание 13. Для простого нейрона с одним двойным входом Р и
функции активации hardlim подобрать весовой коэффициент W и
смещение b таким образом, чтобы обеспечить инвертирование
входного сигнала, т. е. замену нуля единицей, а единицы нулем.
Задание 14. Для нейрона с двумя двойными входами р1 и р2 и
функцией активации hardlim подобрать весовые коэффициенты и
смещение таким образом, чтобы нейрон выполнял функции
логического сложения и логического умножения.
Задание 15. Для нейрона с двумя двойными входами р1 и р2 и
функцией активации hardlim подбирать весовые коэффициенты W11
и W12 и смещение b таким образом, чтобы классифицировать
входные двойные наборы на два класса – нулевой и первый:
а) {00, 01} – нулевой класс, {10, 11} – первый класс;
б) {11} – нулевой класс, {00, 01, 10} – первый класс;
в) {00, 11} – нулевой класс, {01, 10} – первый класс;
г) {00, 11} – первый класс, {01, 10} – нулевой класс.
Задание 16. Для нейрона с двумя непрерывными входами р1 и р2 и
функции активации hardlim построить график разделяющей линии,
определяемой уравнением
40
W11p1 + W12p2 + b = 0,
считая, что значения весовых коэффициентов W11 W12 и смещения b
заданы. Убедиться, что наборы входов р1 и р2 по разную сторону от
разделяющей линии принадлежат разным классам и что не всякое
множество наборов значений входов можно разделить на два класса,
используя нейрон рассмотренного типа.
Задание 17. Используя блоки имитационного моделирования
инструментального пакета Simulink системы MATLAB (блоки
источников и регистраторов сигналов, математические и нелинейные
блоки)
построить рассмотренные в заданиях 1 – 16 модели
нейронов, провести исследования моделей нейронов и оформить в
электронном виде отчет с помощью генератора отчетов Simulink.
41
Лабораторная работа № 4
Искусственные нейронные сети
Цель работы: изучение архитектуры искусственных нейронных
сетей, способов их графического изображения в виде
функциональных и структурных схем и программного представления
в виде объектов специального класса network, включающих массив
структур с атрибутами сети и набор необходимых методов для
создания, инициализации, обучения, моделирования и визуализации
сети, а также приобретение навыков построения сетей различной
архитектуры с помощью инструментального программного пакета
Neural Network Toolbox системы MATLAB.
Теоретические сведения
Хотя отдельные нейроны и способны после некоторой процедуры
обучения решать ряд задач искусственного интеллекта, все же для
эффективного решения сложных задач по распознаванию образов,
идентификации и классификации объектов, распознаванию и синтезу
речи, оптимальному управлению применяют достаточно большие
группы нейронов, образуя из них искусственные нейронные сети в
виде связанных между собой слоёв, напоминающие биологические
нейронные (нервные) сети человека и животных.
Существует множество способов организации искусственных
нейронных сетей, которые могут содержать различное число слоёв
нейронов. Нейроны могут быть связаны между собой как внутри
отдельных слоёв, так и между слоями. В зависимости от направления
передачи сигнала эти связи могут быть прямыми или обратными.
Слой нейронов, непосредственно принимающий информацию из
внешней среды, называется входным слоем, а слой, передающий
информацию во внешнею среду, – выходным слоем. Остальные слои,
если они имеются в сети, называются промежуточными, или
скрытыми. В ряде случаев такого функционального распределения
слоёв сети не производится, так что входы и выходы могут
присоединяться к любым слоям и иметь произвольное число
компонент.
42
Структура, или архитектура сети искусственных нейронов зависит
от той конкретной задачи, которую должна решать сеть. Она может
быть однослойной без обратных связей или с обратными связями,
двухслойной с прямыми связями, трехслойной с обратными связями
и т. д. Сети с обратными связями называют часто рекуррентными.
Описание архитектуры искусственной нейронной сети помимо
указания числа слоёв и связей между ними должно включать
сведения о количестве нейронов в каждом слое, виде функций
активации в каждом слое, наличии смещений для каждого слоя,
наличии компонент входных, выходных и целевых векторов, а в ряде
случаев и характеристики топологии слоёв. Например, для
аппроксимации любой функции с конечным числом точек разрыва
широко используется сеть с прямой передачей сигналов. В этой сети
имеется несколько слоёв с сигмоидальными функциями активации.
Выходной слой содержит нейроны с линейными функциями
активации. Данная сеть не имеет обратных связей, поэтому её
называют сетью с прямой передачей сигналов (FF-net).
Графически искусственная нейронная сеть изображается в виде
функциональной или структурой схемы. На функциональной схеме
сети с помощью геометрических фигур изображаются её
функциональные блоки, а стрелками показываются входы, выходы и
связи. В блоках и на стрелках указываются необходимые
обозначения и параметры.
Структурная схема сети изображается с помощью типового
набора блоков, соединительных элементов и обозначений, принятых
в инструментальном программном пакете Neural Network Toolbox
системы MATLAB и пакете имитационного моделирования Simulink
той же системы. Структурная схема сети может быть укрупнённой
или детальной, причём степень детализации определяется
пользователем. Системы обозначений блоков, элементов и
параметров сети является векторно-матричной, принятой в системе
MATLAB. Если в обозначении используется два индекса, то, как
правило, первый индекс (индекс строки) указывает адресата, или
пункт назначения, а второй индекс (индекс столбца) – источник
структурной схемы сети. Структурные схемы создаются системой
автоматически с помощью команды gensim. Если элементом вектора
43
или матрицы на структурной схеме является сложный объект, то
используются соответственно ячейка и массив ячеек.
Программным представлением, или вычислительной моделью
искусственной нейронный сети, является объект специального класса
network, который включает массив структур с атрибутами сети и
набор методов, необходимых для создания сети, а также для её
инициализации, обучения, моделирования и визуализации. Класс
Network имеет два общих конструктора, один из которых не имеет
параметров и обеспечивает создание массива структур с нулевыми
значениями полей, а второй – имеет минимальный набор параметров
для создания модели нейронной сети, достраиваемой затем до
нужной конфигурации с помощью операторов присваивания. Для
создания нейронных сетей определённого вида используются
специальные конструкторы.
Практические задания
Задание 1. Создать вычислительную модель нейронной сети с
двумя выходами, тремя слоями и одним целевым входом, используя
общий конструктор сети с параметрами
Net = network (numInputs, numLayers, biasConnect, imputConnect,
layerConnect, outputConnect, tartegtConnect).
Связи между слоями должны быть только прямыми, входы
необходимо соединить с первым слоем, а выход – с последним.
Выход должен быть целевым, первый слой должен иметь смещения.
Смысл и значения параметров конструктора для создания модели
сети заданной архитектуры таковы:
numImputs=2 – количество входов сети;
numLayers=3 – количество слоёв в сети;
biasConnect=[1; 0; 0] – матрица связности для смещений
размера numLayers * 1;
44
inputConnect=[1 1; 0 0; 0 0] – матрица связности для входов
размера numLayers * numImputs;
layerConnect=[0 0 0;1 0 0 0 ; 0 1 0] – матрица связности для
слоёв размера numLayers * numLayers;
outputConnect=[0 0 1] – матрица связности для выходов
размера 1* numLayers;
targetConnect=[0 0 1] – матрица связности для целей размера 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 – количество целей сети;
numInputDelays = 0 – максимальное значение задержки для
входов сети.
numLayersDelays = 0 – максимальное значение задержки для
слоёв сети.
Заметим, что каждый выход и каждая цель присоединяются к
одному или нескольким слоям при этом количество компонент
выхода или цели равно количеству нейронов в соответствующем
слое. Для увеличения возможности модели в сеть включают линии
задержки либо на её входах, либо между слоями. Каждая линия
задерживает сигнал на один такт. Параметры numInputDelays и
NumLayerDelays определяют максимальное число линий для какоголибо входа или слоя соответственно.
45
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 – блок взвешивания входных сигналов и сигналов
между слоями, на выходе которого получается сумма взвешенных, т.
е. умноженных на соответствующие веса компонент сигнала;
з) mux – концентратор входных сигналов и сигналов между
слоями, преобразует набор скалярных сигналов в вектор, а набор
векторов в один вектор суммарной длины;
и) netsum – блок суммирования компонент для каждого нейрона
слоя: компонент от нескольких векторов входа с учётом задержек,
смещения и т. п.;
к) hardlim, purelin и т. д. – блоки функций активации;
л) pd{1, 1}, pd{1, 2}, ad{2, 1}, ... – сигналы после линий задержки
(d - delay);
46
м) 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} = - ¼;
net.IW{1, 1} = [0.5];
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]};
47
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. Промоделировать динамическую сеть, используя групповое и
последовательное представление входных сигналов:
AG = sim(net, PG);
AS = sim(net, PS).
Убедиться, что групповое представление входных сигналов
искажает результат, так как в этом случае работа одной сети
заменяется
параллельной
работой
двух
(по
числу
последовательностей) одинаковых сетей с нулевыми начальными
значениями сигналов на выходах линий задержки.
13. Вывести на печать поля вычислительной модели и их
содержимое, используя функцию celldisp.
14. Сохранить содержимое командного окна в М-файле для
последующего использования.
Задание 2. Создать точно такую же динамическую сеть asgnet,
используя конструктор класса network без параметров и задавая
48
значения соответствующих полей вычислительной модели с
помощью операторов присваивания. Убедиться в идентичности сетей
net и asgnet. Сравнить результаты работы полученных сетей.
Задание 3. Используя блоки имитационного моделирования
инструментального пакета Simulink системы MATLAB, построить
модель динамической сети asgnet, провести исследование модели,
проверить адекватность её поведения поведению модели net и
оформить электронный отчёт с помощью генератора Report Generator.
Задание 4. Используя конструктор класса network с параметрами
и операторы присваивания для полей и ячеек объектов этого класса,
построить, выдать на экран и промоделировать искусственные
нейронные сети следующей архитектуры:
а) однослойная
сеть
с
тремя
нейронами,
тремя
двухкомпонентными входами и одним целевым выходом;
б) трёхслойная сеть с прямой передачей сигналов и с тремя
нейронами в каждом слое; количество входов – три с двумя, пятью и
тремя компонентами; для всех слоёв имеется смещение; выход –
один;
в) трёхслойная сеть, в которой каждый слой соединён со всеми
остальными; вход – один и состоит из двух компонентов; количество
нейронов в каждом слое – три; слои имеют смещения;
г) трёхслойная динамическая сеть с тремя нейронами в каждом
слое; число входов – три, из них каждый состоит из трёх
компонентов; имеются смещения на всех слоях; линии задержки
задерживают сигналы на один и два такта и включены между всеми
слоями, а также на входе;
д) квадратная сеть с десятью слоями и десятью нейронами в
каждом слое; десять векторов подключаются по одному к каждому
слою; имеется десять выходов от всех слоёв сети; смещения
подключены к каждому слою.
49
Лабораторная работа № 5
Методы и алгоритмы обучения
искусственных нейронных сетей
Цель работы: изучение и приобретение навыков практического
применения методов и алгоритмов инициализации и обучения
искусственных нейронных сетей, а также овладение способами их
разработки.
Теоретические сведения
После того как сформирована архитектура нейронной сети,
должны быть заданы начальные значения весов и смещений, или
иными словами, сеть должна быть инициализирована. Такая
процедура выполняется с помощью метода init для объектов класса
network. Оператор вызова этого метода имеет вид:
net = init (net).
Перед вызовом этого метода в вычислительной модели сети
необходимо задать следующие свойства:
net.initFcn – для определения функций, которые будут
использоваться для задания начальных матриц весов и весов слоёв, а
также начальных векторов смещений;
net.layers {i}. initFcn – для задания функции инициализации i-го
слоя;
net.biases{i}.initFcn – для задания начального вектора смещения
i-го слоя;
net.inputWeights{i,j}.initFcn – для задания функции вычисления
матрицы весов к слою i от входа j;
net.layerWeight{i,j}.initFcn – для задания функции вычисления
матрицы весов к слою i от входа j;
net.initParam – для задания параметров функций инициализации.
Способ инициализации сети определяется заданием свойств и
net.initFcn net.layers{i}.initFcn. Для сетей с прямой передачей
сигналов по умолчанию используется net.initFcn = ‘initlay’, что
50
разрешает для каждого слоя использовать собственные функции
инициализации, задаваемые свойством net.layers{i}.initFcn с двумя
возможными значениями: ‘initwb’ и ’initnw’.
Функция initwb позволяет использовать собственные функции
инициализации для каждой матрицы весов и для каждого вектора
смещений, при этом возможными значениями для свойств
net.inputWeights{i,j}.initFcn и net.layerWeight{i,j}.initFcn являются:
‘initzero’, ‘midpoint’, ’randnc’, ’rands’, а для свойства
net.biases{i}.initFcn – значения ‘initcon’, ‘initzero и ‘rands’. Для
сетей без обратных связей с линейными функциями активации
веса обычно инициализируются случайными значениями из
интервала [-1 1].
Функция initnw реализуют алгоритм Nguyen-Widrow и
применяется для слоёв, использующих сигмоидальные функции
активации. Эта функция генерирует начальные веса и смещения для
слоя так, чтобы активные области нейронов были распределены
равномерно относительно области входов, что обеспечивает
минимизацию числа нейронов сети и время обучения.
Другими возможными значениями свойства net.initFcn являются:
‘initcon’, ‘initnw’, ‘initwb’ и ‘initzero’.
Помимо функции initnw следующие функции производят
непосредственную инициализацию весов и смещений:
initzero присваивает матрицам весов и векторам смещений
нулевые значения;
rands присваивает матрицам весов и векторам смещений
случайные значения из диапазона [-1 1];
randnr присваивает матрице весов случайные нормированные
строки из диапазона [-1 1];
randnc присваивает матрице весов случайные нормированные
столбцы из диапазона [-1 1];
midpoint присваивает элементам вектора смещения начальные
равные смещения, зависящие от числа нейронов в слое, и
используется вместе с функцией настройки learncon.
51
Таким образом, задание функций инициализации для
вычислительной модели нейронной сети является многоступенчатым
и выполняется по следующему алгоритму:
1. Выбрать для свойства net.initFcn одно из возможных
значений: ‘initzero’, ‘initcon’, ‘initnw’, ‘initwb’ или ‘initlay’.
2. Если выбраны значения ‘initzero’, ‘initcon’ или ‘initnw’, то
задание функций инициализации сети завершено.
3. Если выбрано значение ‘initwb’, то переход к шагу 6.
4. Если выбрано значение ‘initlay’, то переходим к слоям и для
каждого слоя i свойству net.layers{i}.initFcn необходимо задать одно
из возможных значений: ‘initnw’ или ‘initwb’.
5. Если для i-го слоя выбрано значение ‘initnw’, то для этого слоя
задание функций инициализации завершено.
6. Если для всех слоев сети или для какого-то слоя установлено
свойство ‘initwb’, то для этих слоёв необходимо задать свойства
net.biases{i}.initFcn, выбрав его из набора: ‘initzero’, ‘rands’ или ‘initcon’, а также свойства net.layerWeights{i,j}.initFcn, используя
следующие значения: ‘initzero’, ‘midpoint’, ‘randnc’, ‘randnr’ или
‘rands’.
Заметим, что с помощью оператора revert(net) можно возвратить
значения весов и смещений к ранее установленным значениям.
После инициализации нейронной сети её необходимо обучить
решению конкретной прикладной задачи. Для этих целей нужно
собрать обучающий набор данных, содержащий интересующие
признаки изучаемого объекта, используя имеющийся опыт. Сначала
следует включить все признаки, которые, по мнению аналитиков и
экспертов, являются существенными; на последующих этапах это
множество, вероятно, будет сокращено. Обычно для этих целей
используются эвристические правила, которые устанавливают связь
между количеством необходимых наблюдений и размером сети.
Обычно количество наблюдений на порядок больше числа связей в
сети и возрастает по нелинейному закону, так что уже при довольно
небольшом числе признаков, например 50, может потребоваться
огромное число наблюдений. Эта проблема носит название
52
"проклятие размерности". Для большинства реальных задач бывает
достаточно нескольких сотен или тысяч наблюдений.
После того как собран обучающий набор данных для
проектируемой сети, производится автоматическая настройка весов и
смещений с помощью процедур обучения, которые минимизируют
разность между желаемым сигналом и полученным на выходе в
результате моделирования сети. Эта разность носит название
"ошибки обучения". Используя ошибки обучения для всех
имеющихся наблюдений, можно сформировать функцию ошибок или
критерий качества обучения. Чаще всего в качестве такого критерия
используется сумма квадратов ошибок. Для линейных сетей при этом
удаётся найти абсолютный минимум критерия качества, для других
сетей достижение такого минимума не гарантируется. Это
объясняется тем, что для линейной сети критерий качества, как
функция весов и смещения, является параболоидом, а для других
сетей – очень сложной поверхностью в N+1-мерном пространстве,
где N – число весовых коэффициентов и смещений.
С учётом специфики нейронных сетей для них разработаны
специальные
алгоритмы
обучения.
Алгоритмы
действуют
итеративно, по шагам. Величина шага определяет скорость обучения
и регулируется параметром скорости настройки. При большом шаге
имеется большая вероятность пропуска абсолютного минимума, при
малом шаге может сильно возрасти время обучения. Шаги алгоритма
принято называть эпохами или циклами.
На каждом цикле на вход сети последовательно подаются все
обучающие наблюдения, выходные значения сравниваются с
целевыми значениями и вычисляется функция критерия качества
обучения – функция ошибки. Значения функции ошибки, а также её
градиента используются для корректировки весов и смещений, после
чего все действия повторяются. Процесс обучения прекращается по
следующим трём причинам, если:
а) реализовано заданное количество циклов;
б) ошибка достигла заданной величины;
в) ошибка достигла некоторого значения и перестала
уменьшаться.
53
Во всех этих случаях сеть минимизировала ошибку на некотором
ограниченном обучающем множестве, а не на множестве реальных
входных сигналов при работе модели. Попытки усложнить модель и
снизить ошибку на заданном обучающем множестве могут привести
к обратному эффекту, когда для реальных данных ошибка становится
ещё больше. Эта ситуация называется явлением переобучения
нейронной сети.
Для того чтобы выявить эффект переобучения нейронной сети,
используется механизм контрольной проверки. С этой целью часть
обучающих наблюдений резервируется как контрольные наблюдения
и не используется при обучении сети. По мере обучения
контрольные наблюдения применяются для независимого контроля
результата. Если на некотором этапе ошибка на контрольном
множестве перестала убывать, обучение следует прекратить даже в
том случае, когда ошибка на обучающем множестве продолжает
уменьшаться, чтобы избежать явления переобучения. В этом случае
следует уменьшить количество нейронов или слоёв, так как сеть
является слишком мощной для решения данной задачи. Если же,
наоборот, сеть имеет недостаточную мощность, чтобы воспроизвести
зависимость, то явление переобучения скорее всего наблюдаться не
будет и обе ошибки – обучения и контроля – не достигнут требуемого
уровня.
Таким образом, для отыскания глобального минимума ошибки
приходится экспериментировать с большим числом сетей различной
конфигурации, обучая каждую из них несколько раз и сравнивая
полученные результаты. Главным критерием выбора в этих случаях
является контрольная погрешность. При этом применяется правило,
согласно которому из двух нейронных сетей с приблизительно
равными контрольными погрешностями следует выбирать ту,
которая проще.
Необходимость многократных экспериментов ведёт к тому, что
контрольное множество начинает играть ключевую роль в выборе
нейронной сети, т. е. участвует в процессе обучения. Тем самым его
роль как независимого критерия качества модели ослабляется,
поскольку при большом числе экспериментов возникает риск
переобучения нейронной сети на контрольном множестве. Для того,
54
чтобы гарантировать надёжность выбираемой модели сети,
резервируют ещё тестовое множество наблюдений. Итоговая модель
тестируется на данных из этого множества, чтобы убедиться, что
результаты, достигнутые на обучающем и контрольном множествах,
реальны. При этом тестовое множество должно использоваться
только один раз, иначе оно превратится в контрольное множество.
Итак, процедура построения нейронной сети состоит из
следующих шагов:
1. Выбрать начальную конфигурацию сети в виде одного слоя с
числом нейронов, равным половине общего количества входов и
выходов.
2. Обучить сеть и проверить ее на контрольном множестве,
добавив в случае необходимости дополнительные нейроны и
промежуточные слои.
3. Проверить, не переобучена ли сеть. Если имеет место эффект
переобучения, то произвести реконфигурацию сети.
Для того чтобы проектируемая сеть успешно решала задачу,
необходимо
обеспечить
представительность
обучающего,
контрольного и тестового множества. По крайней мере, лучше всего
постараться сделать так, чтобы наблюдения различных типов были
представлены равномерно. Хорошо спроектированная сеть должна
обладать свойством обобщения, когда она, будучи обученной на
некотором множестве данных, приобретает способность выдавать
правильные результаты для достаточно широкого класса данных, в
том числе и не представленных при обучении.
Другой подход к процедуре обучения сети можно
сформулировать, если рассматривать её как процесс, обратный
моделированию. В этом случае требуется подобрать такие значения
весов и смещений, которые обеспечивали бы нужное соответствие
между входами и желаемыми значениями на выходе. Такая
процедура обучения носит название процедуры адаптации и
достаточно широко применяется для настройки параметров
нейронных сетей.
По умолчанию для сетей с прямой передачей сигналов в качестве
критерия обучения используется функционал, представляющий
55
собой сумму квадратов ошибок между выходами сети и их целевыми
значениями:
J
1 Q S q
(ti  diq ) 2 ,

2 q1 i1
где Q – объём выборки; q – номер выборки; i – номер выхода;
t iq – целевое значение для i-го выхода выборки q; aiq – сигнал на i-м
выходе при подаче входных сигналов q-й выборки. Целью обучения
сети является минимизация этого функционала с помощью
изменения весов и смещений.
В настоящее время разработано несколько методов минимизации
функционала ошибки на основе известных методов определения
экстремумов функций нескольких переменных. Все эти методы
можно разделить на три класса:
а) методы нулевого порядка, в которых для нахождения
минимума используется только информация о значениях
функционала в заданных точках;
б) методы первого порядка, в которых используется градиент
функционала ошибки по настраиваемым параметрам, использующий
частные производные функционала;
в) методы второго порядка, в которых используются вторые
производные функционала.
Для линейных сетей задача нахождения минимума функционала
(параболоида) сводится к решению системы линейных уравнений,
включающих веса, смещения, входные обучающие значения и
целевые выходы и, таким образом, может быть решена без
использования итерационных методов. Во всех остальных случаях
надо использовать методы первого или второго порядка.
Если используется градиент функционала ошибки, то
X k 1  X k   k g k ,
где X k и X k 1 – векторы параметров на k-й и k+1-й итерациях;
 k – параметр скорости обучения; g k – градиент функционала,
соответствующий k-й итерации.
56
Если используется сопряжённый градиент функционала, то на
первой итерации направление движения p0 выбирают против
градиента g 0 этой итерации:
p0  g 0 .
Для следующих итераций направление
pk
выбирают как
линейную комбинацию векторов g k и pk 1 :
pk   g k   k pk 1 ,
а вектор параметров рассчитывают по формуле:
X k 1  X k   k pk ,
Для методов второго порядка расчет параметров на k-м шаге
производят по формуле (метод Ньютона):
X k 1  X k  H k1 g k ,
где Hk – матрица вторых частных производных целевой функции
(матрица Тессе); gk – вектор градиента на k-й итерации. Вычисление
матрицы Тессе требует больших затрат машинного времени, поэтому
её заменяют приближенными выражениями (квазиньютоновские
алгоритмы).
Градиентными алгоритмами обучения являются:
GD – алгоритм градиентного спуска;
GDM – алгоритм градиентного спуска с возмущением;
GDA – алгоритм градиентного спуска с выбором параметра
скорости настройки;
Rprop – пороговый алгоритм обратного распространения ошибки;
GDX – алгоритм градиентного спуска с возмущением и
адаптацией параметра скорости настройки.
Алгоритмами,
основанными
на
использовании
метода
сопряженных градиентов, являются:
CGF – алгоритм Флетчера–Ривса;
CGP – алгоритм Полака–Ребейры;
CGB – алгоритм Биеле–Пауэлла;
57
SCG – алгоритм Молера.
Квазиньютоновскими алгоритмами являются:
DFGS – алгоритм Бройдена, Флетчера, Гольдфарба и Шанно;
OSS – одношаговый алгоритм метода секущих плоскостей
(алгоритм Баттини);
LM – алгоритм Левенберга–Марквардта;
BR – алгоритм Левенберга–Марквардта с регуляризацией по Байесу.
В процессе работы алгоритмов минимизации функционала
ошибки часто возникает задача одномерного поиска минимума вдоль
заданного направления. Для этих целей используется метод золотого
сечения GOL, алгоритм Брента BRE, метод половинного деления и
кубической интерполяции HYB, алгоритм Чараламбуса CHA и
алгоритм перебора с возвратом BAC.
Практические задания
Задание 1. Адаптировать параметры однослойной статической
линейной сети с двумя входами для аппроксимации линейной
зависимости вида t  2 p1  p2 , выполнив следующие действия:
1. С помощью конструктора линейного слоя
net = newlin(PR, s, id, lr),
где PR – массив размера Rx2 минимальных и максимальных
значений для R векторов входа; s – число нейронов в слое; id –
описание линий задержек на входе слоя; lr – параметр скорости
настройки, сформировать линейную сеть:
net = newlin([-1 1; -1 1], 1, 0, 0).
2. Подготовить обучающие последовательности в виде массивов
ячеек, используя зависимости t  2 p1  p2 и четыре пары значений
p1 и p2 (произвольные):
P = {[-1; 1] [-1/3; 1/4] [1/2; 0] [1/6; 2/3]};
T = { -1
-5/12
1
1
}.
3. Для
группировки
представления
обучающей
последовательности преобразовать массивы ячеек в массивы чисел:
58
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;
59
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,
normprod;
для многослойных сетей параметры 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
% – четыре значения ошибки.
60
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  2 p1  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 – функция среднеквадратичной ошибки.
61
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;
62
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′)
63
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)
64
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];
65
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], ... % – связь слоёв;
66
[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); % – возврат к настройке параметров по
умолчанию.
67
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 – для задания матрицы средних значений;
68
Для создания и инициализации сети использовать команды 6-го
задания, заменяя в них функцию initzero на рассматриваемые
функции инициализации, а сеть net6 – на сеть net7.
Задание 8. Создать двухслойную нейронную сеть с прямой
передачей сигнала, одним входом, двумя нейронами в первом слое и
одним нейроном во втором слое, настроить сеть для обучения с
использованием алгоритма градиентного спуска GD, обучить эту
сеть и путём её моделирования оценить качество обучения. Порядок
выполнения задания следующий:
1. Создать нейронную сеть с прямой передачей сигнала:
net8 = newff([0 5], …. % – диапазоны значений входа;
[2 1], …..
% – количество нейронов в слоях;
{′tansig′,
% – функция активации для 1-го слоя;
′logsig′}
% – функция активации для 2-го слоя;
′traingd′);
% – имя функции обучения.
2. Убедиться, что
веса
и
смещения
каждого слоя
инициализированы с помощью алгоритма Нгуена–Видроу:
net8.initFcn
net8.layers{1}.initFcn
net8.layers{2}.initFcn
net8.IW{1,1}
net8.LW{2,1}
net8.b{1}
net8.b{2}
% – должно быть ′initlay′;
% – должно быть ′initnw′;
% – должно быть ′initnw′;
% – вес входа;
% – веса для 2-го слоя.
3. Задать обучающие последовательности входов и целей T:
P = [0 1 2 3 4 5];
T = [0 0 0 1 1 1];
% – вектор входа;
% – вектор целей.
69
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 по переменным веса и смещения используется метод
обратного распространения. В соответствии с методом градиентного
спуска вектор настраиваемых переменных получает следующее
приращение:
70
dx  lr * 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. Настроить сеть:
71
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,
72
learnos, learnsom, learnh, learnhd. Сравнить алгоритм настройки для
одной и той же обучающей последовательности.
Задание 13. Создать, обучить и апробировать многослойную
нейронную сеть с прямой передачей сигнала для принятия решения о
зачислении в высшее учебное заведение абитуриентов, сдавших
вступительные экзамены по математике, физике и русскому языку.
Правила приема таковы:
1. Проходной балл для абитуриентов, не имеющих льгот, должен
быть равен 11;
2. Удовлетворительные оценки по математике и физике для этой
категории абитуриентов недопустимы;
3. Абитуриенты, имеющие льготы, зачисляются при любых
положительных оценках по всем трем предметам.
Для обучения сети следует использовать все изученные методы
адаптации и обучения и провести анализ их эффективности. Следует
также определить минимальное количество слоев и нейронов,
обеспечивающее удовлетворительное решение поставленной задачи.
Для формирования обучающего, контрольного и тестового
множества построить дискретную имитационную модель, используя
инструментальный пакет Simulink.
73
Лабораторная работа № 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, которая корректирует веса и смещения по
результатам обработки каждой пары входных и выходных значений
74
(обучение с учителем). Применение функции adapt гарантирует, что
любая задача классификации с линейно отделимыми векторами
будет решена за конечное число циклов настройки. Функция
обучения train, когда настройка параметров сети выполняется не
после каждого прохода, а в результате всех проходов обучающего
множества, в ряде случаев не обеспечивает сходимости процесса
настройки, поэтому не используется для обучения персептрона.
Настройка весов и смещений, реализуемая функциями learnp и
learnpn, производится по следующим правилам:
а) для входных сигналов вычисляются выходные;
б) определяются ошибки как разность между целевым выходом и
соответствующим выходным сигналом;
в) производится корректирование весов и смещений путем
сложения старых значений с приращениями, каждое из которых
равно произведению соответствующего сигнала на ошибку того
нейрона, для которого корректируется параметр.
Для того, чтобы сделать время обучения нечувствительным к
большим или малым выбросам векторов входа, производят
нормирование входных данных при вычислении приращений весов и
смещений:
pni = pi (sqrt(1+ p12 +…+ pr2)).
Такое нормирование обеспечивается применением функции
learnp для настройки как весов, так и смещений. Также
автоматически свойству net.adaptFcn задается значение adaptwb,
что позволяет использовать любые функции для настройки весов и
смещений, а свойству net.adaptParam – набор параметров по
умолчанию.
Адаптация
персептрона
производится
функцией-методом
adapt(net,P,T), где P – входные векторы; T – целевые значения.
Процесс адаптации продолжается до тех пор, пока не будет
достигнуто требуемое значение критерия качества обучения в виде
средней абсолютной ошибки, вычисляемой функцией mae.
75
Практические задания
Задание 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,
76
а затем с помощью моделирования определить классы значений
входного вектора, выполнив следующие действия:
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]};
77
p1=cat(2, p{:});
T1=num2cell(p1(1,:) & p1(2,:))
T2=num2cell(p1(1,:) | p1(2,:))
% – функция AND;
% – функция 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}
% – настраиваемые параметры.
78
Задание 5. Создать, обучить и апробировать персептрон для
принятия решения о зачислении в высшее учебное заведение
абитуриентов, сдавших вступительные экзамены.
79
Лабораторная работа № 7
Исследование линейных нейронных
сетей
Цель работы: изучение архитектуры статистических и
динамических линейных нейронных сетей и специальных функций
для их создания, настройки параметров по методу Вудроу–Хоффа,
адаптации и обучения, ознакомление с демонстрационными
примерами и их скриптами, а также приобретение навыков
построения и обучения линейных сетей для классификации векторов,
линейной аппроксимации, предсказания, слежения и фильтрации
сигналов, идентификации и моделирования линейных систем.
Теоретические сведения
Линейная сеть – это один слой из S нейронов и R входов, каждый
из которых может состоять из нескольких элементов. Передаточной
функцией каждого нейрона слоя является линейная функция purelin.
Это является единственным отличием линейной сети от персептрона.
Благодаря линейной передаточной функции каждый выход сети
может принимать любое значение, в то время как выход персептрона
ограничен значениями 1 и 0.
Линейные сети, как и персептроны, способны решать только
линейно отделимые задачи классификации, однако в них
используется правило обучения по методу Вудроу–Хоффа,
основанное на использовании функции наименьших квадратов,
которое является более мощным, чем правило обучения персептрона.
Помимо основных входов нейроны линейной сети имеют вход для
постоянного смещения, равного единице. Элементы входов и
смещения взвешиваются с помощью функции скалярного
произведения dotprod и суммируются с помощью функции
накопления netsum.
Линейная нейронная сеть может быть создана одним из
следующих способов:
net=newlin(PR, S, id, lr),
80
net=newlin(PR, S, 0, P),
net=newlind(P, T),
где PR – массив размера R*2 минимальных и максимальных
значений для R векторов входа;
S – число нейронов;
id – описание линии задержки на входе сети, по умолчанию [0];
lr – параметр скорости настройки, по умолчанию 0,01;
P – обучающие последовательности входов размера R*Q, причем
Q – количество последовательностей;
Т – последовательность целей для Р размера S*Q;
0 – нуль.
.
Первый способ применяется, когда в сеть включаются задержки,
т. е. для создания динамических адаптивных линейных нейронных
сетей ADALIN (ADApture Linear Neuron networks), которые
позволяют корректировать веса и смещения при поступлении на вход
каждого элемента обучающего множества. Такие сети широко
применяются при решении задач обработки сигналов и в системах
управления.
Второй способ формирует линейный слой с параметром скорости
настройки, гарантирующим максимальную степень устойчивости для
данного входа Р. В этом случае линии задержки не используются и
сеть является статической.
Для первого и второго способа инициализация сети проводится
при ее создании с помощью функции initzero. Адаптация и обучение
сети затем осуществляется с помощью функции adaptwb, которая
модифицирует веса и смещения, используя функцию Видроу –
Хоффа hearnwh до тех пор, пока не будет достигнуто требуемое
значение критерия качества обучения в виде средней квадратичной
ошибки, вычисляемой функцией mse.
Третий способ формирует и настраивает линейную статическую
сеть, решая систему линейных алгебраических уравнений на основе
метода наименьших квадратов. Он используется для подбора
коэффициентов аппроксимирующей функции и для идентификации
параметров динамических систем в задачах управления. Матричная
81
запись решаемой системы линейных алгебраических уравнений
такова:
[W b]*[P;ones]=T,
при этом должно выполняться условие
S*R + S = Q.
Функция learnwh вычисляет приращение весов входов и
смещений по следующим векторным формулам:
pn = p/(sqrt(1+P(1)^2)+… +P(R)^2);
dW = lr*e*pn;
db = lr*e.
При работе с моделями линейных сетей могут возникнуть
ситуации, когда число настраиваемых параметров недостаточно,
чтобы выполнить все условия; в этом случае сеть считается
переопределенной. Если число параметров слишком велико, сеть
считается недоопределенной. И в том и в другом случае метод
наименьших квадратов осуществляет настройку, стремясь
минимизировать ошибку сети.
Архитектура
однослойной
линейной
сети
полностью
определяется задачей, которая должна быть решена, причем число
входов сети и число нейронов в слое определяются числом входов и
выходов задачи соответственно.
Практические задания
Задание 1. Выполнить задания с 1-го по 5-е лабораторной работы № 6 и для линейной нейронной сети с таким же числом нейронов
и входов, что и у соответствующего персептрона, заменив функцию
newp функцией newlin, оставляя параметры неизменными и
используя значения параметров id и lr по умолчанию, т. е. [0] и 0,01
соответственно.
82
Задание 2. Построить поверхность ошибок для линейной сети с
одним нейроном и одним входом, используя функцию errsurf и
выполнив следующие команды:
Р = [1 -1.2];
T = [0.5 1];
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).
83
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. Рассчитать траекторию обучения:
Х = 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;
84
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} % – [-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];
85
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 rk-1+0.0339 rk-2+0.0602.
5. Построить графики отклика Т3 и приближений Y1 и Y3:
plot(0:0,01:20, T3, 'G'), hold on % – зеленый;
plot(0:0,01:20, Y1, 'B'), hold on % – синий;
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);
86
err = T-A % – погрешности сети весьма значительны.
Задание 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];
весов и смещения
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), выполнив следующие действия:
87
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;
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:
88
x = sim(net, P);
x1 = cat(1, x{:});
plot(time, x1, 'b', time, p, 'r');
title('Моделирование нейронной сети').
89
Лабораторная работа № 8
Исследование радиальных базисных
сетей
общего вида
Цель работа: изучение архитектуры радиальных базисных
нейронных сетей общего вида и специальных функций для их
создания и автоматической настройки весов и смещений,
ознакомление с демонстрационными примерами и их скриптами;
приобретение навыков построения таких сетей для классификации
векторов и аппроксимации функций.
Теоретические сведения
Радиальная, базисная сеть общего вида – это двухслойная
нейронная сеть с R входами, каждый из которых может состоять из
нескольких элементов. Передаточной функцией нейронов входного
слоя является колоколообразная симметричная функция следующего
вида:
radbas (n)  e  n .
2
Эта функция имеет максимум, равный 1, при n = 0 и плавно
убывает при увеличении n, достигая значения 0.5 при n = ±0.833.
Передаточной функцией нейронов выходного слоя является
линейная функция perelin.
Функция взвешивания для входного слоя вычисляет евклидово
расстояние между каждой строкой матрицы весов и каждым
столбцом матрицы входов:
dist (wi , p j )  sqrt (( wi  p j ) 2 ) .
Затем эта величина умножается на смещение нейрона и поступает
на вход передаточной функции, так что
a{i} = radbas(net.prod(dist(net.IW{1, 1}, p).net.b{i})).
90
Для нейронов выходного слоя функцией взвешивания является
скалярное произведение dotprod, а функцией накопления – функция
суммирования взвешенных входов и взвешенного смещения netsum.
Для того чтобы понять поведение радиальной базисной сети
общего вида, необходимо проследить прохождение вектора входа p.
При задании значений элементам вектора входа каждый нейрон
входного слоя выдает значение в соответствии с тем, как близок
вектор входа к вектору весов каждого нейрона. Таким образом,
нейроны с векторами весов, значительно отличающимися с вектором
входа p, будут иметь выходы, близкие к 0, и их влияние на выходы
линейных нейронов выходного слоя будет незначительное.
Напротив, входной нейрон, веса которого близки к вектору p, выдаст
значение, близкое к единице.
Для построения радиальных базисных сетей общего вида и
автоматической настройки весов и смещений используются две
функции newrbe и newrb. Первая позволяет построить радиальную
базисную сеть с нулевой ошибкой, вторая позволяет управлять
количеством нейронов входного слоя. Эти функции имеют
следующие параметры:
net = newrbe(P, T, SPREAD),
net = newrb(P, T, GOAL, SPREAD),
где P – массив размера RxQ входных векторов, причем R – число
элементов вектора входа, а Q – число векторов в
последовательности;
T – массив размера SxQ из Q векторов цепи и S классов;
SPREAD – параметр влияния, определяющий крутизну функции
radbas, значение по умолчания которого равно единице;
GOAL – средняя квадратичная ошибка, при этом значение по
умолчанию равно 0.0.
Параметр влияния SPREAD существенно влияет на качество
аппроксимации функции: чем больше его значение, тем более
гладкой будет аппроксимация. Слишком большое его значение
91
приведет к тому, что для получения гладкой аппроксимации быстро
изменяющейся функции потребуется большое количество нейронов:
слишком малое значение параметра SPREAD потребует большего
количества нейронов для аппроксимации гладкой функции. Обычно
параметр влияния SPREAD выбирается большим, чем шаг разбиения
интервала задания обучающей последовательности, но меньшим
размера самого интервала.
Функция newrbe устанавливает веса первого слоя равным P′, а
смещения – равными 0.8326/ SPREAD, в результате радиальная
базисная функция пересекает значение 0.5 при значениях
евклидового расстояния ±SPREAD. Веса второго слоя LW{2,1} и
смещения b{2} определяются путем моделирования выходов первого
слоя A{1} и последующего решения системы линейных уравнений:
[LW{2,1} b{2}]*[A{1}; ones] = T.
Функция newrb формирует сеть следующим образом. Изначально
первый слой не имеет нейронов. Сеть моделируется и определяется
вектор входа с самой большой погрешностью, добавляется нейрон с
функцией активации radbas и весами, равными вектору входа, затем
вычисляются весовые коэффициенты линейного слоя, чтобы не
превысить средней допустимой квадратичной ошибки.
Практические задания
Задание 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);
92
2. Проанализировать структурную схему построенной сети:
gensim(net);
3. Проанализировать параметры вычислительной модели сети:
net
net.layers{1}.size % – число нейронов в первом слое;
net.layers{2}.size % – число нейронов во втором слое;
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;
93
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).
Задание 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);
94
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) с помощью
i (x) в виде следующего
радиальных базисных функций
разложения в ряд:
n
f ( x )    i i ( x ) ,
i 1
здесь коэффициенты разложения по радиальным базисным
функциям:
p = -3:0.1:3;
a1 = radbas(P);
a2 = padbas(P-1.5);
a3 = radbas(P+2);
a = a1 + a2 + 0.5*a3;
plot(P, a1, p, a2, p, 0.5*a3, p, a).
Как видно из графика, разложение по радиальным базисным
функциям обеспечивает необходимую гладкость. Разложение
указанного вида может быть реализовано на двухслойной нейронной
сети, первый слой которой состоит из радиальных базисных
нейронов, а второй – из единственного нейрона с линейной
характеристикой, на котором суммируются выходы нейронов
первого слоя.
Задание 6. Исследовать гладкость аппроксимации при следующих
значениях параметра SPREAD: 1, 0.01 и 12, используя команды из
четвертого задания.
95
Лабораторная работа № 9
Исследование радиальных базисных
сетей
типа GRNN
Цель работы: изучение архитектурных особенностей радиальных
базисных нейронных сетей типа GRNN и специальных функций для
их создания, автоматической настройки весов и смещений и
нормированного взвешивания; ознакомление с демонстрационным
примером и его скриптом, а также приобретение навыков построения
таких сетей для решения задач обобщенной регрессии, анализа
временных рядов и аппроксимации функций.
Теоретические сведения
Радиальная базисная сеть типа GRNN(Generalized Regression
Neural Network), или обобщенная регрессионная сеть имеет
архитектуру, аналогичную архитектуре радиальной базисной сети
общего вида, и отличается от нее структурой второго слоя, в котором
используется блок normprod для вычисления нормированного
скалярного произведения строки массива весов LW{2,1} и вектора
выхода первого слоя а{1} в соответствии со следующим
соотношением:
n{2} = LW{2,1} * a{1}/sum(a{1}).
В общем виде функция normprod определяется так:
normprod(W,P) = W * P/sum(P/1),
где W – матрица весов размера S × R,
P – массив входов размера R × Q,
sum(P,1) – сумма элементов массива Р по столбцам.
Создание сети осуществляется фукцией
net = newgrnn(P,T,SPREAD).
Эта функция устанавливает веса первого слоя равным Р′, а
смещение – равным величине 0.8326/SPREAD, что приводит к
радиальным базисным функциям, которые пересекают величину 0.5
96
при значениях взвешенных входов ± SPREAD. Веса второго слоя
устанавливаются равными Т. Смещения отсутствуют.
Первый слой сети GRNN – это радиальный базисный слой с
числом нейронов, равными числу элементов Q обучающего
множества. В качестве начального приближения для матрицы весов
выбирается массив Р′, смещение для этого слоя устанавливается
равным вектор-столбцу с элементами 0.8326/SPREAD. Функция dist
вычисляет расстояние между вектором входа и вектором веса
нейрона. Вход передаточной функции равен поэлементному
произведению взвешенного входа сети на вектор смещения. Входом
каждого нейрона первого слоя является значение функции radbas.
Если вектор веса нейрона равен транспонированному вектору входа,
то
взвешенный
вход
Равен 0, а выход равен 1. Если расстояние между вектором входа и
вектором веса нейрона равно SPREAD, то выход нейрона будет равен
0.5.
Второй слой сети GRNN – это линейный слой с числом нейронов,
также равным числу элементов Q обучающего множества, причем в
качестве начального приближения для матрицы весов LW{2,1}
выбирается массив Т. Если на вход подается вектор Рi, близкий к
одному из векторов входа Р из обучающего множества, то этот
вектор сгенерирует значение выхода слоя, близкое к единице. Это
приведет к тому, что выход второго слоя будет близок к ti.
Если параметр влияния SPREAD мал, радиальная базисная
функция характеризуется резким спадом и диапазон входных
значений, на который реагируют нейроны входного слоя,
оказывается весьма малым. При увеличении этого параметра
диапазон увеличивается и выходная функция становится более
гладкой.
Практические задания
Задание 1. Создать обобщенную регрессионную сеть для
обучающей последовательности Р=0:3 и Т[0.0 2.0 4.1 5.9],
проанализировать ее структурную схему и значения параметров
вычислительной модели, выполнить моделирование сети для
различных входов, построить графики и оценить влияние на
97
выходные значения параметра 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);
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);
98
plot(P2, A2, ′-k′, ′LineWidth′, 2) % – экстраполяция;
hold on,
plot(P, T, ′*k′, ′MarkerSize′, 10) % – сравнить точки.
99
Лабораторная работа № 10
Исследование радиальных базисных
сетей
типа PNN
Цель работы: изучение архитектурных особенностей радиальных
базисных нейронных сетей типа PNN и специальных функций для их
создания, автоматической настройки весов и смещений и
конкурирующей активации; ознакомление с демонстрационным
примером и его скриптом; приобретение навыков построения таких
сетей для решения задач классификации на основе подсчёта
вероятности принадлежности векторов к рассматриваемым классам
и для решения других вероятностных задач.
Теоретические сведения
Радиальная базисная сеть типа PNN (Probabilistic Neural
Networks), или вероятностная нейронная сеть, имеет архитектуру,
аналогичную архитектуре радиальной базисной сети общего вида, и
отличается от неё структурой второго слоя, в котором используются
функция взвешивания dotprod (скалярное произведение сигналов и
весов), функция накопления netsum и передаточная функция compet –
конкурирующая функция, преобразующая вектор входа слоя
нейронов таким образом, чтобы нейрон с самым большим входом
имел выход, равной единице, а все другие нейроны имели выходы,
равные нулю. Смещения используются только в первом слое.
Создание вероятностей сети осуществляется функцией
net=newpnn(P,T,spread),
где Р – массив размера R*Q из Q входных векторов с R элементами;
T – массив размера S*Q из Q векторов цели и S классов;
SPREAD – параметр влияния, значение по умолчанию 1.0.
Для вероятностей сети необходимо задать обучающее множество
из Q пар векторов входа и целей. Каждый вектор цели имеет K
элементов, указывающих класс принадлежности и, таким образом,
каждый вектор входа ставится в соответствие одному из К классов. В
100
результате образуется матрица связанности T размера K*Q,
состоящая из нулей и единиц, строки которой соответствуют классам
принадлежности, а столбцы – векторам входа. Таким образом, если
элемент Т(i,j) матрицы связанности равен единице, то это означает,
что j-й входной вектор принадлежит к классу i.
Весовая матрица входного слоя IW формируется как и для
радиальной базисной сети общего вида с использованием векторов
входа из обучающего множества.
Весовая матрица второго слоя соответствует матрице связанности Т, которая строится с помощью функции ind2vec.
Практические задания
Задание 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], значения в котором определяют
класс соответствующего вектора входа, выполнив команды:
101
Р=[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);
% – моделирование сети;
Yc= vec2ind(Y); % – формирование индекса классов;
Pt= [1 3; 0 1; 5 2]’; % – векторы для тестирования;
A= sim (net, Pt); % – тестирование сети;
Ac= vec2ind (A); % – формирование индекса классов.
Задание 3. Проанализировать структурные схемы, значения
параметров вычислительных моделей и результаты моделирования
нейронных сетей, используемых в следующих демонстрационных
примерах:
Demorb1 – рациональные базисные сети;
Demorb3 – использование не перекрывающихся функций
активации (передаточных функций);
Demorb4 – использование перекрывающихся передаточных
функций;
Demogrn1 – аппроксимация функций с помощью сети типа GRNN;
Demogrn1 – классификация векторов с помощью сети типа PNN.
Для анализа использовать скрипты примеров.
102
Лабораторная работа № 11
Исследование самоорганизующихся
слоев Кохонена
Цель работы: изучение архитектуры самоорганизующихся
нейронных слоев Кохонена и специальных функций для их создания,
инициализации, взвешивания, накопления, активации, настройки
весов и смещений, адаптации и обучения; ознакомление с
демонстрационными примерами и их скриптами, а также
приобретение навыков построения самоорганизующихся слоев для
исследования топологической структуры данных, их объединением в
кластеры (группы) и распределением по классам.
Теоретические сведения
Самоорганизующийся слой Кохонена – это однослойная
нейронная сеть с конкурирующей передаточной функцией compet,
которая анализирует выходные значения нейронов слоя и выдаёт в
качестве результата наибольшее из этих значений (значение нейронапобедителя).
Инициализация весов входов производится с помощью функции
средних значений
W = midpoint (S,PR),
где S – число нейронов в слое Кохонена;


j
j
, Pmax
PR – матрица размера Rx2, задающая диапазоны Pmin
изменения R элементов входного вектора;
W – матрица весов размера SxR для входов слоя, столбцы которой
имеют значения
P
j
min

j
 Pmax
.
2
Инициализация весов смещений нейронов слоя производится с
помощью функции равных смещений
B = initcon(S,PR),
103
которое каждому нейрону задаёт одно и то же смещение, равное
exp(1)*S. Например, для S=5 это смещение равно 5*2.71828=
=1.359740*101.
Взвешивание входов слоя Кохонена реализуется в виде
отрицательного евклидова расстояния между каждой строкой Wi
матрицы весов W и каждым столбцом Pj матрицы входов P, которое
вычисляется функцией negdist(W,P). Суммирование взвешенных
входов со смещениями производится функцией netsum.
Формирование
самоорганизующегося
слоя
Кохонена
осуществляется функцией
net = newc(PR,S,KLr,clr),
где KLr – параметр функции настройки весов, значение по
умолчанию которого равно 0.01;
clr – параметр функции настройки смещений, значение по
умолчанию которого равно 0.001.
Эта функция формирует однослойную сеть с R нейронами и R
входами. Веса
входов устанавливаются равными половине
диапазона соответствующего вектора входа для всех нейронов.
Также для всех нейронов устанавливается одно и то же смещение,
равное e*s. Выходы нейронов поступают на конкурирующую
передаточную функцию compet, которая определяет победителя.
Номер активного нейрона-победителя I* определяет ту группу
(кластер), к которой наиболее близок входной вектор.
Для того чтобы сформированная таким образом сеть решала
задачу кластеризации данных, необходимо предварительно
настроить ее веса и смещения по обучающей последовательностью
векторов с помощью функций настройки learnk и learncon
соответственно, используя процедуру адаптации adapt или
процедуру обучения train.
Функция learnk рассчитывает приращение весов dW в
зависимости от вектора входа P, выхода а, весов w и параметра
скорости настройки lr в соответствии с правилом Кохонена:
lr  (p '  w), a j  0;
dw  
0, a j  0.
104
Таким образом, вектор веса, наиболее близкий к вектору входа,
модифицируется так, чтобы расстояние между ними стало ещё
меньше. Результат такого обучения заключается в том, что
победивший нейрон, вероятно, выиграет конкуренцию и в том
случае, когда будет представлен новый входной вектор, близкий к
предыдущему, и его победа менее вероятна, когда будет представлен
вектор, существенно отличающийся от предыдущего. Когда на вход
сети поступает всё большее и большее число векторов, нейрон,
являющийся ближайшим, снова корректирует свой весовой вектор w.
В конечном счёте, если в слое имеется достаточное количество
нейронов, то каждая группа близких векторов окажется связанной с
одним из нейронов слоя. В этом и заключается свойство
самоорганизации
слоя
Кохонена.
Одно из ограничений всякого конкурирующего слоя состоит в
том, что некоторые нейроны оказываются незадействованными, или
“мертвыми”. Это происходит оттого, что нейроны, имеющие
начальные весовые векторы, значительно удаленные от векторов
входа, никогда не выигрывают конкуренции, независимо от
продолжительности обучения. Для ликвидации нечувствительности
таких нейронов используют положительные смещения, которые
добавляются к отрицательным расстояниям удаленных нейронов.
Функция learncon производит такую корректировку смещений
следующим образом.
В начале процедуры настройки сети всем нейронам присваивается
одинаковый характер активности C0 = 1/S. В процессе настройки эта
величина для активных нейронов увеличивается, а для неактивных
нейронов уменьшается:
ΔC  lr  (a  c) .
Нетрудно убедиться, что для всех нейронов, кроме нейронапобедителя, приращения отрицательны. Функция learcon рассчитывает приращения вектора смещений следующим образом:
Δb  exp(1  log(c))  b .
Увеличение смещений для неактивных нейронов позволяет
расширить диапазон покрытия входных значений, и неактивный
105
нейрон начинает формировать кластер, что улучшает кластеризацию
входных данных.
Практические задания
Задание 1. Создать слой Кохонена для двух векторов входа,
проанализировать его структурную
схему
и
параметры
вычислительной модели,
произвести обучение сети и
моделирование, выполнив следующие команды:
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);
minU = min(x′)′
% – число кластеров;
% – число векторов в классе;
% – диапазон входов;
% – r число строк; q – число столбцов;
% – минимальные значения;
106
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
% – начальная активность;
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.
Задание 4. С помощью слоя Кохонена произвести кластеризацию
оценок абитуриентов.
107
Лабораторная работа № 12
Исследование самоорганизующихся
карт Кохонена
Цель работы: изучение архитектуры самоорганизующихся
нейронных сетей в виде карт Кохонена и специальных функций для
создания карты и её топологии, взвешивания, накопления, настройки
весов (размещение нейронов), адаптации и обучения; ознакомление с
демонстрационными примерами и их скриптами, а также
приобретение навыков построения самоорганизующихся карт для
решения задач кластеризации входных векторов.
Теоретические сведения
Cамоорганизующаяся карта Кохонена – это однослойная
нейронная сеть без смешения с конкурирующей функцией compet,
имеющая определенную топологию размещения нейронов в Nмерном пространстве. В отличие от слоя Кохонена карта Кохонена
после обучения поддерживает такое топологическое свойство, когда
близким входным векторам соответствуют близко расположенные
активные нейроны.
Первоначальная топология размещения нейронов в карте
Кохонена формируется при создание карты с помощью функции
newsom, одним из параметров которого является имя
топологической функции gridtop, nextop
или randtop, что
соответствует размещению нейронов в узлах либо прямоугольной,
либо гексагональной сетки, либо в узлах сетки со случайной
топологией.
Расстояния между нейронами и векторами входов вычисляются с
помощью следующих функций:
dist – евклидово расстояние d=sqrt((posi-pj).^2);
boxdist – максимальное координатное смещение
d=max(abs(posi-pj));
mandist – расстояние суммарного координатного смещения
d=sum(abs(posi-pj));
108
linkdist – расстояние связи
1, dist( posi  p j )  1;%  евклидово пространство;

2, k , d ik1  d kj  1;%  один промежуточный;
3, k , k , d k  d

1 2
i 1
k1k21  d k1 j  1;
d ij  
........................................................................................
 N , k , k ...k , d k  d  ...  d  1;
1 2
n
i 1
k1k2
knj

S , в остальных случаях
Формирование
саморганизующейся
карты
Кохонена
осуществляется функцией
net=newsom(PR,[d1, d2,…],tfcn, dfсn, olr, osteps, tlr, tnd)),
где Pr – массив размера R*2 минимальных значений векторов входа;
d1, d2…– число нейронов по i-й размерности карты. По
умолчанию – двумерная карта с числом нейронов 5*8;
tfсn – функция топологии карты, по умолчанию nextop;
dfcn – функция расстояния, по умолчанию linkdist;
olr – параметр скорости обучения на этапе размещения, по
умолчанию 0.9;
osteps – число циклов обучения на этапе подстройки, по
умолчанию 1000;
tlr – параметр скорости на этапе подстройки, по умолчанию 0.02;
tnd – размер окрестности на этапе подстройки, по умолчанию 1.
Настройка карты Кохонена производится по каждому входному
вектору независимо от того, применяется метод адаптации или метод
обучения. В любом случае функция learnsom выполняет настройку
карты нейронов.
Прежде всего определяется нейрон-победитель и корректируется
его вектор весов и векторы соседних нейронов согласно
соотношению
dw=lr*A2*(p′ – w),
где lr – параметр скорости обучения, равный olr для этапа
упорядочения нейронов и tlr для этапа подстройки;
109
A2 – массив соседства для нейронов, расположенных в
окрестности нейрона-победителя i:
1, a(i, q)  1;

A2(i, q)  0.5, a(j, q)  1 & D(i, j)  nd;
0, в остальных случаях.

Здесь а(i,q) – элемент выхода нейронной сети;
D(i,j) – расстояние между нейронами i и j;
nd – размер окрестности нейрона-победителя.
Таким образом, вес нейрона-победителя
изменяется
пропорционально половинному параметру скорости обучения, а веса
соседних нейронов – пропорционально половинному значению этого
параметра.
Весь процесс обучения карты Кохонена делится на два этапа:
А) этап упорядоченности векторов весовых коэффициентов в
пространстве признаков;
Б) этап подстройки весов нейронов по отношению к набору
векторов входа.
На этапе упорядочения используется фиксированное количество
шагов. Начальный размер окрестности назначается равным
максимальному расстоянию между нейронами для выбранной
топологии и затем уменьшается до величины, используемой на
следующем этапе, и вычисляется по следующей формуле:
nd=1.00001+(max(d)-1)(1-s/S),
где max(d) – максимальное расстояние между нейронами; s – номер
текущего шага, а S – количество циклов на этапе упорядочения.
Параметр скорости обучения изменяется по правилу
lr =tlr+(olr-tlr)(1-s/S).
На этапе подстройки, который продолжается в течение
оставшейся части процедуры обучения, размер окрестности остается
постоянным и равным
nd=tnd+0.00001,
а параметр скорости обучения изменяется по следующему правилу
lr= tlr*S/s.
110
Параметр скорости обучения продолжает уменьшаться, но очень
медленно. Малое значение окрестности и медленное уменьшение
параметра скорости обучения хорошо настраивают сеть при
сохранении размещения, найденного на предыдущем этапе. Число
шагов на этапе подстройки должно значительно превышать число
шагов на этапе размещения. На этом этапе происходит тонкая
настройка весов нейронов по отношению к набору векторов входов.
Нейроны карты Кохонена будут упорядочиваться так, чтобы при
равномерной плотности векторов входа нейроны также были
распределены равномерно. Если векторы входа распределены
неравномерно, то и нейроны будут иметь тенденцию распределяться
в соответствии с плотностью размещения векторов входа.
Таким образом, при обучении карты Кохонена решается не только
задачи кластеризации входных векторов, но и выполняется частичная
классификация.
Практические задания
Задание 1. Рассчитать положение нейронов на четырехмерной
сетке с прямоугольной топологией размера 5*4*3*2 и сделать
попытку построить график расположения нейронов, выполнив
следующие команды:
pos=gridtop(5,4,3,2) % – массив координат узлов размера N*S,
% где N – количество измерений, равное 4,
%а S 
N
 dim i – количество узлов сетки,
i 1
% равное произведению числа нейронов по
% каждому измерению 5*4*3*2=120;
plotsom(pos) % – вывод только трех размерностей.
Задание 2. Рассчитать положение нейронов на двухмерной сетке с
прямоугольной топологией размера 3*2 и построить график
расположения нейронов, выполнив следующие команды:
рos =gridtop(2,3) % 0 1 0 1 0 1
%0 0 1 1 2 2
plotsom(pos) % – плоский график.
111
Задание 3. Рассчитать положение нейронов на двухмерной сетке с
прямоугольной топологией размера 3*2 и построить график
расположения нейронов, выполнив следующие команды:
рos =gridtop(3,2) % 0 1 0 1 0 1
%0 0 1 1 2 2
plotsom(pos)
% – плоский график.
Задание 4. Рассчитать положение нейронов на трехмерной сетке с
гексагональной топологией размера 5*4*3 с 60 нейронами и
построить график их расположения, выполнив следующие команды:
рos =Hextop(5,4,3) % – массив размера 3*60;
рlotsom(pos)
% – построение графика.
Задание 5. Сформировать гексагональную сетку размером 2*3 и
построить график, выполнив команды:
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. Создать сетку размера 2*3 со случайным
расположением узлов и построить график расположения нейронов,
выполнив следующие действия:
pos=randtop(2,3) % 0.062
0.647
0.49 и т. д.
%
0
0.122
0,904 и т. д.
plotsom(pos)
% – построение графика.
Задание 7. Создать сетку размера 5*4*3 со случайным
расположением узлов и построить график расположения нейронов,
выполнив следующие действия:
pos=randtop(5,4,3) % – создание сетки ;
plotsom(pos)
% – построение графика.
112
Задание 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 и т. д.
113
Задание 12. Создать гексагональную карту Кохонена размером 2х3, проанализировать ее структурную схему и параметры
вычислительной модели, произвести обучение карты и ее
моделирование, а также построить необходимые графики, выполнив
следующие команды:
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]);
114
net.trainparam.epochs=2000;
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. Создать двухмерную карту Кохонена размеров 5*6 с
гексагональной топологией, обучить на последовательности из 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], holdon
plot(0.5, 0.3, ′*k′).
115
Лабораторная работа № 13
Исследование самоорганизующихся
LVQ-сетей
Цель работы: изучение архитектуры самоорганизующихся
нейронных сетей типа LVQ и специальных функций для их
создания, настройки весов и обучения; ознакомление с
демонстрационными примерами и их скриптами, а также
приобретение навыков построения таких сетей для решения задач
классификации входных векторов.
Теоретические сведения
Самоорганизующиеся нейронные сети типа LVQ (Learning
Vector Quantization), или сети для классификации входных
векторов, состоят из двух слоёв без смещения. Входной слой
является конкурирующим и используется для кластеризации
векторов. Выходной слой является линейным с передаточной
функцией purelin и обеспечивает соотнесение кластеров с целевыми
классами, заданными пользователем. На каждый кластер во входном
слое должен быть задан один нейрон, причём количество классов не
должно быть больше количества кластеров.
Поскольку заранее известно, как кластеры первого слоя
соотносятся с целевыми классами второго слоя, то это позволяет
заранее задать элементы матрицы весов LW второго слоя. Однако
чтобы найти правильный кластер для каждого вектора обучающего
множества, необходимо выполнить процедуру обучения сети.
Для создания LVQ-сетей используется функция newlog,
обращение к которой имеет следующий вид:
net = newlvg(PR, S1, PC, LR, LF),
где PR – массив размером Rх2 минимальных и максимальных
значений R векторов входа;
S1 – число нейронов входного слоя (число кластеров);
PC – вектор размером 1хS2, указывающий распределение по
долям каждого класса из набора классов S2;
116
LR – параметр скорости настройки, по умолчанию 0.01;
LF – функция настройки параметров, по умолчанию learnlv2.
В результате выполнения функции newlog создаётся двухслойная
сеть. Первый слой использует функции взвешивания negdist,
накопления netsum и передаточную функцию compet. Второй слой
использует функции взвешивания dotprod, накопления netsum и
передаточную функцию purelin. Слои не имеют смещений. Веса
первого слоя инициализируются с помощью функции midpoint; веса
второго слоя устанавливаются так, чтобы каждому нейрону на
выходе соответствовал единственный нейрон первого слоя.
Адаптация и обучение выполняются с помощью функций adaptwb,
которая модифицирует веса первого слоя, используя функцию
настройки learnlv1.
LVQ – сеть обучается на основе множества пар – выход
обучающей последовательности:
{p1, t1}, {p2, t2}, …, {pQ, tQ}.
Каждый целевой вектор имеет единственный элемент, равный
единице, а остальные элементы равны нулю.
Предположим, что при задании вектора входа p(q) весовые
коэффициенты нейрона i* входного слоя наиболее близки к вектору
входа p(q) и нейрон i* выигрывает конкуренцию. Тогда
конкурирующая функция compet выдаст единицу в качестве i*-го
элемента вектора выхода a1 первого слоя сети, причём все другие
элементы a1 будут равны нулю. Во втором, линейном слое,
произведение матрицы весов LWa1 выявляет некоторый столбец
LW, в котором единичное значение указывает на класс k*. Таким
образом, сеть связывает вектор входа p(q) с классом k*. Это
назначение может оказаться либо правильным, либо ошибочным.
Поэтому в процессе обучения необходимо откорректировать строку
i* матрицы IW таким образом, чтобы приблизить её к вектору p(q),
если назначение правильное, и удалить от вектора p(q) если
назначение неправильное:
i*IW(q) = i*IW(q-1)+LR(p(q)-i*IW(q-1)), a2k* = tk* = 1;
i*IW(q) = i*IW(q-1)-LR(p(q)-i*IW(q-1)), (a2k* = 1) ≠ (tk*= 0).
117
Это правило гарантирует, что при правильной классификации
нейрон-победитель приближается к векторам входа данного класса, а
при неправильной классификации удаляется от них. Оно различается
функцией настройки весов слоя LVQ-сети learnlv1. Другая функция
настройки весов learnlv2 позволяет улучшить настройку параметров.
Она производит корректировку двух весовых векторов, близких к
входному. Два весовых вектора с евклидовыми расстояниям di и dj
до вектора входа p считаются близкими, если выполняется условие
min(di*/ dj*, dj*/ di*) > 0.5  0.7.
Если при этом строка i* принадлежит к области в пространстве
признаков, соответствующей требуемому классу, а строка j* не
принадлежит, то корректировка весов производится следующим
образом:
i * IW(q)  i * IW(q  1)  lr(p(q))  i * IW(q  1);

 j * IW(q)  i * IW(q  1)  lr(p(q))  j * IW(q  1).
Практические задания
Задание 1. Создать нейронную LVQ-сеть для обучающей
последовательности двухэлементных векторов, имеющих 4 нейрона
во входном слое и 2 нейрона в выходном с распределением [0.6 0.4],
проанализировать её структурную схему и значения параметров
вычисленной модели, обучить сеть и промоделировать её на
обучающей последовательности, выполнив следующие команды:
P = [-3 -2 -2 0 0 0 0 +2 +2 +3; …
0 +1 -1 2 1 -1 -2 +1 -1 0];
Tc = [1 1 1 2 2 2 2 1 1 1 ]; % – индексы классов;
T = ind2vec(Tc);
% – разряженная целевая матрица;
T = full(T);
% – полная целевая матрица;
net = newlvq(minmax(P), 4, [0.6 0.4]); % – параметры вычисли% тельной модели
gensim(net);
% – структурная схема LVQ-сети;
net = train(net, P, T);
% – обучение сети со значениями
%параметров по умолчанию;
Y = sim(net, P)
% – моделирование LVQ-сети;
118
Yc = vec2ind(Y)
% – индексы классов, которые
% получила сеть;
% Сравнить Yc и Tc.
Задание 2. Повторить первое задание для всевозможных векторов
индексов Tс и выявить случаи несовпадения Yc и Tc, т. е. случаи
неправильной классификации.
Задание 3. Создать нейронную LVQ-сеть с теми же параметрами,
что и в первом задании, обучить сеть, промоделировать её, построить
график распределения входных векторов по кластерам и
разделяющую линию областей точек, принадлежащих разным
классам, выполнив следующие команды:
P = [-3 -2 –2 0 0 0 0 +2 +2 +3; …
0 +1 –1 2 1 –1 –2 +1 –1 0]
Tc = [1 1 1 2 2 2 2 1 1 1 ]; % – индексы классов;
T = full(ind2vec(Tc));
net = newlvg(minmax(P), 4, [0.6 0.4]);
net.inputWeights{1, 1}
net.IW{1, 1} % – веса входного слоя после инициализации;
net.LW{2,1} % – веса выходного слоя после инициализации;
net.b{1}, net.b{2}
net.trainParam.epoch = 2000;
net.trainParam.show = 100;
net.trainParam.lr = 0.05;
net = train(net, P, T);
net.IW{1, 1}
% – веса выходного слоя после обучения;
net.LW{2, 1}
% – веса выходного слоя после обучения;
I1 = find(Tc = = 1); % – вектор индексов первого класса;
I2 = find(Tc = = 2); % – вектор индексов второго класса;
axis([-4, 4, -3, 3]) % – диапазоны для X и Y;
P1 = P(: , I1)
% – векторы первого класса;
119
P2 = P(: , I2)
% – векторы второго класса;
V = net.IW{1, 1}
% – веса выходного слоя;
plot(P1(1, :), P1(2, :), ′+ k′), hold on
plot(P2(1, :), P2(2, :), ′b′), hold on
plot(V(:, 1), V(:, 2), ′or′)
Y = sim(net, P)
Yc=vec2ind(Y)
% Построение разделяющей линии для классов:
function P = mesh2P(x, y) % – начало М-функции;
%Вычисление массива координат прямоугольной сетки
[X,Y] = meshgrid(X, Y);
P = cat(3, X, Y);
[n1, n2, n3] = size(P);
P = permute(P, [3 2 1]);
P = reshape(P, [n3 n1*n2]);
% конец М-функции.
X = -4 : 0.2 : 4;
Y = -3 : 0.2 : 3;
P = mesh2P(X, Y);
Y = sim(net, P);
Yc = vec2ind(Y);
I1 = find(Yc = = 1); I2 = find(Yc = = 2);
plot(P(1, I1),P(2, I2), ′+k′), hold on
plot(P(1, I1),P(2, I2), ′*b′).
Задание 4. Создать нейронную LVQ-сеть для разбиения
двухэлементных векторов на 8 кластеров и 4 класса, обучить сеть,
промоделировать её, построить график распределения векторов по
кластерам и разделяющую границу векторов, модифицируя команды
3-го задания.
120
Лабораторная работа № 14
Исследование сетей Элмана
Цель работы: изучение архитектуры рекуррентных нейронных
сетей Элмана и специальных функций для их создания,
инициализации, настройки весов и смещений, обучения;
ознакомление с демонстрационным примером и его скриптом, а
также приобретение навыков построения сетей управления
движущимися объектами, построения систем технического зрения и
решения других динамических задача.
Теоретические сведения
Сети Элмана относятся к классу рекуррентных нейронных сетей.
Характерной особенностью архитектуры рекуррентных сетей
является наличие блоков динамической задержки и обратных связей.
Это позволяет таким сетям обрабатывать динамические модели.
Сети Элмана состоят их двух слоёв – выходного и входного, при
этом входной слой охвачен динамической обратной связью с
использованием линии задержки. Динамическая обратная связь
позволяет учесть предысторию наблюдаемых процессов и накопить
информацию для выработки правильной стратегии управления. В
ряде применений используется несколько слоёв нейронов.
Во входном слое двухслойной сети Элмана используется
передаточная функция гиперболического тангенса transig, в
выходном
слое – линейная функция purelin. Такое сочетание передаточных
функций позволяет максимально точно аппроксимировать функции с
конечным числом точек разрыва. Для этих целей необходимо также,
чтобы выходной слой имел достаточно большое число нейронов.
Все эти слои Элмана имеют смещения. Функциями взвешивания и
накопления являются функции dotprod и ntesum соответственно.
Выход последнего слоя является выходом сети. Веса и смещения
инициализируются с помощью функции initnw, реализующей
алгоритм Нгуена–Видроу. Aдаптация реализуется с помощью
функции adaptwb, которая устанавливает режим, при котором веса и
121
смещения каждого слоя могут быть настроены с использованием
собственных функций настройки. Для сетей Элмана такими
функциями могут быть либо функция настройки методом
градиентного спуска с возмущением leargdm. Критерием качества
обучения может быть одна из двух функций: mse или msereg.
Сети Элмана создаются функцией
net = newelm(PR, [S1, S2, …, SN],
{TF1, TF2, …, TFN},
BTF, BLF, PF),
где PR – массив размера R  2 минимальных и максимальных
значений для R векторов входа;
S1, S2, …, SN – количество нейронов в слоях;
TF1, TF2, …, TFN – функции активации в слоях, по умолчанию
tansig;
BTF – обучающая функция, реализующая метод обратного
распространения, по умолчанию traingdx;
BLF – функция настройки, реализующая метод обратного
распространения, по умолчанию learngdm;
PF – критерий качества обучения, по умолчанию mse.
Динамическое
описание
входного
слова
определяется
рекуррентными уравнениями:
1
11 1
11
1 1
1

n (k )  LW a (k  1)  IW p  b , a (0)  a0 ;
 1
1

a (k )  transig(n (k )).
Второй линейный слой является безынерционным и описывается
соотношениями:
n2(k) = LW21a1(k) + b2;
a2(k) = purelin(n2(k)).
Задание 1. Создать рекуррентную нейронную сеть Элмана,
которая для случайной булевой последовательности из нулей и
единиц выдаёт булеву последовательность, имеющую единицы
122
только в том случае, когда во входной последовательности
встретились две единицы подряд:
P = round ( rand ( 1, 20 ) );
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];
123
t = [t1 t2 t1 t1].
4. Сформировать обучающие последовательности:
Pseq = con2seq(p); % – массив ячеек;
Tseq = con2seq(t); % – массив ячеек;
5. Создать сеть Элмана:
net = newelm( [ -2 2], [10, 1], …
{′tansig′, ′purelin′}, …
′traingdx′)
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]).
124
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] ).
9. Обучить и проверить сеть для четырех гармонических
сигналов.
125
Лабораторная работа № 15
Исследование сетей Хопфилда
Цель работы: изучение архитектуры рекуррентных нейронных
сетей Хопфилда и специальных функций для их создания,
взвешивания входов, накопления и активизации; ознакомление с
демонстрационными примерами и их скриптами, а также
приобретение навыков построения таких сетей для решения задач
распознавания образов и создания ассоциативной памяти.
Теоретические сведения
Сеть Хопфилда относится к классу рекуррентных нейронных
сетей. Она имеет один нейронный слой с функциями взвешивания
dotprod, накопления netsum и линейной ограниченной функцией
активизации satlins. Слой охвачен динамической обратной связью с
весами LW{1,1} и имеет смещения.
Сети Хопфилда обладают тем отличительным свойством, что при
поступлении на вход некоторого вектора признаков в виде
начальных условий, они за конечное число тактов времени приходят
в состояние устойчивого равновесия, зависящего от входного
вектора. Это позволяет ассоциировать входной вектор с некоторым
состоянием сети, или объектом предметной области. Состояния
устойчивого равновесия называются также аттракторами сети.
Помимо целевых аттракторов в сети могут иметь место паразитные,
которые не соответствуют никаким векторам входа. При создании
сети Хопфилда специальные алгоритмы синтеза сводят к минимуму
число таких паразитных точек равновесия и
обеспечивают
максимальный размер области притяжения для точек равновесия.
Функция для создания сети Хопфилда имеет вид:
net=newhop(T),
где Т – массив размера R*Q,объединяющий Q целевых векторов со
значениями +1 или -1 для элементов;
R – число элементов вектора входа.
После того как начальные условия заданы в виде массива T,
определяющего ряд целевых вершин замкнутого гиперкуба, сеть для
126
каждой вершины генерирует выход, который по обратной связи
подаётся на вход. Этот процесс при создании сети повторяется много
раз, пока её выход не установится в положение равновесия для
каждой из целевых вершин. При подаче затем произвольного
входного вектора сеть Хопфилда переходит в результате
рекурсивного процесса к одной из точек равновесия, наиболее
близкой к входному сигналу.
Динамическая модель рекуррентного слоя одной из модификаций
сети Хопфилда описывается следующим образом:
1
11 1
1

a (k )  satlins ( LW a (k  1)  b );
 1

a (0)  p.
Когда сеть Хопфилда спроектирована, она может быть проверена
с одним или большим числом векторов входа. Весьма вероятно, что
векторы входа, близкие к целевым точкам равновесия, найдут свои
цели. Способность сети Хопфилда быстро обрабатывать наборы
векторов входа позволяет проверить сеть за относительно короткое
время. Сначала следует проверить, что точки равновесия целевых
векторов действительно принадлежат вершинам гиперкуба, а затем
можно определить области притяжения этих точек и обнаружить
паразитные точки равновесия.
Практические задания
Задание 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);
% – сеть обеспечила переход
% к устойчивому состоянию
127
% [-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)′)
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
128
Лабораторная работа № 16
Применение нейронных сетей
для проектирования систем
управления
динамическими процессами
Цель
работы:
овладение
методами
решения
задач
идентификации, проектирования и моделирования систем
управления динамическими процессами и способами их применения
на практике.
Теоретические сведения
Применение нейронных сетей для решения задач управления
динамическими процессами позволяет выделить два этапа
проектирования систем управления такими процессами:
1. Этап идентификации динамического процесса, для которого
проектируется система управления.
2. Этап синтеза закона управления и его реализация с помощью
нейронной сети.
На этапе идентификации разрабатывается модель управляемого
процесса в виде нейронной сети, которая на этапе синтеза
используется для построения регулятора.
Динамические модели систем управления с нейросетевыми
регуляторами размещены в разделе Control Systems библиотеки
блоков для моделирования нейронных сетей Neural Network
Blockset, доступ к которым обеспечивается браузером Library
Browser пакета Simulink или командой neural. В этой библиотеке
имеются также следующие разделы:
Net Input Function – раздел блоков функций накопления: netprod
и netsum;
Transfer
Function
–
раздел
блоков
передаточных
функций(функций активации): hardlim, hardlims, purelin, satlin, satlins, poslin, logsig, transig, radbas, tribas, softmax и compet;
129
Weight function – раздел блоков функций взвешивания: dotprod,
normprod, dist и negdist.
В разделе блоков управляющих систем Control Systems имеется
три вида нейронных регуляторов:
Neural Net Predictive Controller – регулятор с предсказанием
будущих реакций процесса на случайные сигналы управления.
Алгоритм оптимизации вычисляет управляющие сигналы, которые
минимизируют разность между желаемыми и действительными
изменениями сигнала на выходе модели и таким образом
оптимизируют
управляемый
процесс.
Построение
модели
управляемого процесса выполняется автономно с использованием
нейронной сети, которая обучается в групповом режиме с
использованием одного из алгоритмов обучения. Реализация такого
регулятора требует значительного объема вычислений, поскольку
расчеты по оптимизации выполняются на каждом такте управления.
Narmal2(Nonlinear Autoregressive – Moving Average) –
регулятор на основе модели авторегрессии со скользящим средним.
Данный регулятор представляет собой модифицированную
нейросетевую модель управляемого процесса, полученную на этапе
автономной идентификации. Вычисления в реальном времени
связаны только с реализацией нейронной сети.
Model Reference Controller – регулятор на основе эталонной
модели. Такой регулятор требует обучения нейронной сети
управляемого процесса и нейронной сети регулятора. При этом
обучение регулятора оказывается достаточно сложным, поскольку
обучение основано на динамическом варианте метода обратного
распространения ошибки, так как нейронная сеть использует линии
задержки. Регуляторы на основе эталонной модели применимы к
различным классам управляемых процессов.
Для каждой из трёх архитектур регуляторов используется одна и
та же процедура идентификации управляемого процесса. Нейронная
модель во всех случаях представляет собой двухслойную сеть с
прямой передачей сигнала и с линиями задержки на каждом слое.
Входной, или скрытый (hiden) слой может иметь произвольное
число нейронов. Выходной слой имеет только один нейрон. Для
входного слоя функции взвешивания, накопления и активизации
130
являются соответственно dotprod, netsum и logsig. Выходной слой
имеет такие же функции взвешивания и накопления, а функцией
активизации для него является линейная функция purelin. Известно,
что сети с такой архитектурой могут воспроизводить весьма
сложные нелинейные зависимости между входом и выходом сети.
Настройка параметров нейронной сети, являющейся моделью
объекта, выполняется автономно методом последовательного
обучения с использованием данных, полученных при испытаниях
реального объекта. Для обучения сети может быть использован
любой из обучающих алгоритмов для нейронных сетей.
Использование контрольного и тестового множеств обучающих
данных позволяет избежать явления переобучения сети. Изменяя
число нейронов в первом слое, количество линий задержки на входе
и выходе сети, а также интервал квантования, или дискретности,
можно
обеспечить
требуемую
точность
моделирования
управляемого процесса.
Диалоговая панель для идентификации управляемого процесса
Plant Identification входит в состав всех трёх регуляторов раздела
Control Systems библиотеки нейронных блоков системы Simulink,
является универсальным средством и может быть использована для
построения нейросетевых моделей любых динамических объектов,
которые могут быть представлены блоками этой системы.
С помощью управляющих элементов панели Plant Identification
можно задать архитектуру нейронной сети, параметры обучающей
последовательности и параметры обучения, а также управлять
процессом идентификации и оценивать качество этого процесса.
Набор управляющих элементов для задания архитектурных
параметров нейронной сети следующий:
1. Size of the Hiden Layer – количество нейронов на входном или
скрытом слое;
2. No. Delayed Plant Inputs – число линий задержки для входного
слоя;
3. No. Delayed Plant Outputs – число линий задержки для
выходного слоя;
131
4. Samling Interval – интервал квантования или шаг
дискретности, в секундах, между двумя последовательными
моментами отсчёта данных;
5. Notmalize Training Data – переключатель нормирования для
преобразования обучающих данных к диапазону [0 1].
Набор управляющих элементов для задания характеристик
обучающей последовательности таков:
1. Training Samples – число точек отсчёта для получения
обучающей последовательности в виде пар значений вход-выход для
управляемого процесса, определяемого моделью Simulink;
2. Maximum Plant Input – максимальное значение входного
сигнала;
3. Minimum Plant Input – минимальное значение входного
сигнала;
4. Maximum Interval Value (sec) – максимальный интервал
идентификации, в секундах;
5. Minimum Interval Value (sec) – минимальный интервал
идентификации, в секундах;
6. Limit Output Data – переключатель для ограничения значений
выходного сигнала;
7. Maximum Plant Output – максимальное значение выходного
сигнала, задаваемое при включённом переключателе Limit Output
Data;
8. Minimum Plant Output – максимальное значение выходного
сигнала, задаваемое при включённом переключателе Limit Output
Data;
9. Simulink Plant Model – для задания модели управляемого
процесса, реализованной с помощью блоков Simulink, имеющий
порты входа и выхода и сохранённой в файле *.mdl; выбор модели
производится с помощью кнопки Browse; имя модели отображается
в специальном окне.
Параметры обучения задаются следующим образом:
1. Training Epochs – количество циклов обучения;
2. Training Function – для задания обучающей функции;
132
3. Use Current Weights – переключатель для использования
текущих весов нейронной сети;
4. Use Validation Data – переключатель для использования
контрольного множества в объёме 25 % от обучающего множества;
5. Use Testing Data – переключатель для использования
тестового множества в объёме 25% от обучающего множества.
Для идентификации управляемого процесса необходимо
выполнить следующие действия:
1. Задать архитектуру нейронной сети, которая будет моделью
управляемого процесса.
2. Задать параметры обучения.
3. Выбрать модель Simulink для управляемого процесса.
4. Сгенерировать обучающую последовательность заданного
объёма, запустив модель Simulink с помощью кнопки Generate
Training Data. Генерация обучающей последовательности
производится с помощью воздействия ряда ступенчатых сигналов на
модель управляемого процесса и снятия значений на выходе и входе
модели через каждый шаг квантования. Графики входного и
выходного сигнала отображаются в окне Plant Input-Output Data.
5. По завершении генерации обучающей последовательности
необходимо либо принять эти данные, нажав на кнопку Accept Data,
и тогда они будут использованы для обучения нейронной сети, либо
отвергнуть их, нажав кнопку Reject Data, и повторить процесс
идентификации управляемого процесса, представленного моделью
Simulink.
6. После получения обучающей последовательности необходимо
установить требуемые параметры обучения и с помощью кнопки
Train Network запустить процесс обучения нейронной сети.
7. После завершения обучения его результаты отображаются на
графиках изменения ошибки сети для обучающей, контрольной и
тестирующей последовательностей, а также выходных значений
модели и сети при подаче на вход указанных последовательностей.
8. Если результаты обучения приемлемы, то надо сохранить
параметры нейросетевой модели управляемого процесса и
133
приступить к синтезу регулятора того или иного класса, нажав
кнопки
Apply
и Ok.
9. Если результаты обучения неприемлемы, то следует нажать
кнопку Cаncel и повторить процесс идентификации сначала, изменяя
архитектуру сети и параметры обучающей последовательности.
10. Обучающую последовательность можно импортировать из
рабочей области или из файла, нажав на кнопку Import Data. Если
необходимо обучающую последовательность сохранить в рабочей
области или в файле для подбора параметров архитектуры
нейронной сети, то следует после получения данных нажать на
кнопку
Export Data.
11. Удалить только что сгенерированные данные при
необходимости можно с помощью кнопки Erase Generated Data.
Таким образом, диалоговая панель Plant Identification позволяет
идентифицировать управляемый процесс, представленный в виде
имитационной модели Simulink, построить двухслойную нейронную
сеть прямой передачи сигнала с необходимым числом нейронов и
линий задержки, обучить эту сеть для получения нейронной модели
управляемого процесса, оценить качество обучения и работу
нейронной сети. Для регулятора на основе авторегрессии со
скользящим средним, этап его синтеза отсутствует, так как такой
регулятор представляет собой полученную нейросетевую модель
управляемого процесса с предсказанием. Для регуляторов на основе
эталонной модели с предсказанием, этап синтеза необходим.
Управление с предсказанием использует принцип управляющего
горизонта, когда нейросетевая модель управляемого процесса
предсказывает реакцию объекта управления на определенном
интервале времени в будущем. Предсказания используются
программой численной оптимизации для того, чтобы вычислить
управляющий сигнал, который минимизирует следующий критерий
качества управления:
Y
N2

[Yr (t  j)  Ym (t  j)] 2  ρ
j N1
Nu
[U(t  j  1)  U(t  j  2)] ,
2
j1
134
где константы N1, N2, Nu задают пределы, внутри которых
вычисляются ошибка слежения и мощность управляющего сигнала;
U′ (t) – пробный управляющий сигнал;
Yr(t) – желаемый управляющий сигнал;
Ym(t) – истинная реакция модели управляемого сигнала;
ρ – коэффициент, определяющий вклад, вносимый мощностью
управления в критерий качества.
Структурная схема регулятора с предсказанием представлена на
рисунке.
Yr
Оптимизация
Ym
U′
U Модель объекта в виде
нейронной сети
U
Управляемый
процесс
Yp
Блок
оптимизации определяет
значения
U′,
которые
минимизируют критерий качества управления, а соответствующий
сигнал управляет процессом.
Синтез регулятора с предсказанием осуществляется с помощью
диалоговой панели Neural Network Predictive Control, на которой
имеются следующие управляющие элементы:
Cost Horizon (N2) – верхний предел суммирования в показателе
качества, при этом нижний предел N1 всегда равен единице;
Control Horizon (Nu) – верхний предел при оценке мощности
управления;
Control Weightin Factor (ρ) – коэффициент веса для
составляющей мощности управления;
Search Parameter (α) – параметр одномерного поиска, задающий
порог уменьшения показателя качества;
Minimization Routine – параметр для выбора процедуры
одномерного поиска;
Iterations Per Sample Time – число итераций на один такт
дискретности.
135
После установки параметров оптимизации необходимо их ввести
в регулятор с помощью кнопок Apply и OK и произвести
моделирование полученной системы.
Для регулятора на основе эталонной модели необходимо
построить две нейронные сети: сеть для модели объекта управления
и сеть для самого регулятора. Нейронная сеть модели объекта
управления строится точно так же, как и для регуляторов
рассмотренного вида. Для этих целей надо на основной панели Model Reference Control, которая вызывается двойным щелчком левой
кнопки мыши по блоку регулятора, воспользоваться кнопкой Plant
Identification. Щелчок по этой кнопке вызывает диалоговую панель
Plant Identification, которая имеет такой же набор управляющих
элементов, как и для других регуляторов. С помощью этой панели
надо задать архитектуру нейронной сети для управляемого объекта,
задать характеристики обучающей последовательности и параметры
обучения, произвести идентификацию управляемого объекта и
обучить нейронную сеть. С помощью кнопок Apply и OK завершить
построение модели объекта и возвратиться к основной диалоговой
панели
Model
Reference
Control для синтеза нейронной модели регулятора.
Архитектура нейронной модели регулятора аналогична
архитектуре нейронной модели объекта, поэтому управляющие
элементы на панели Model Reference Control такие же, что и на
панели Plant Identification, отсутствуют управляющие элементы для
задания характеристик выходного сигнала, так как он
непосредственно поступает на вход модели объекта, а обучающая
последовательность разбивается на сегменты, для чего имеется
специальное поле Controller Training Segments.
Для синтеза регулятора необходимо определить все требуемые
параметры
на
панели,
сгенерировать
обучающие
последовательности, нажав на кнопку Training Data и обучить
нейронную сеть с помощью кнопки Train Controller, используя
текущие веса и режим обучения с накоплением (если необходимо).
Затем нажать на кнопку Apply для завершения процесса синтеза
регулятора.
136
По окончании построения регулятора необходимо нажать но
кнопку OK, вернуться в окно Simulink и выполнить моделирование
работы системы нейронного регулирования для оценки
характеристик регулятора.
Практические задания
Задание 1. Создать нейронную модель регулятора с
предсказанием для управлением каталитическим реактором с
непрерывным помешиванием. Динамическая модель управляемого
процесса описывается следующими обыкновенными нелинейными
дифференциальными уравнениями:
dh

 w1 t   w2 t   0,2 h ;

dt
 dCb
w t 
w t 
K1Cb
 (Cb1  Cb) 1  Cb2  Cb  2 
,

dt
h
h
1  K 2Cb2

где h – уровень жидкости в резервуаре, который не регулируется;
w1(t) – скорость потока продукта с концентрацией Cb1;
w2(t) – скорость потока продукта с концентрацией Cb2;
Cb – концентрация продукта на выходе объекта;
K1 и K2 – константы скорости расхода продукта.
Цель регулирования состоит в поддержании концентрации
продукта путем регулирования скорости потока w2(t).
Для синтеза модели процесса использовать следующие значения
его параметров:
Cb1 = 29,4; Cb2 = 29,4; K1 = K2 = 1; w1(t) = 1; w2(t) = 0,1.
Основные этапы синтеза таковы:
1. Построение модели Simulink для управляемого процесса и её
исследование.
2. Идентификация процесса и синтез его нейронной модели.
3. Задание параметров оптимизации и синтез регулятора.
137
4. Моделирование регулируемой системы и анализ качества
регулирования.
Задание 2.
Создать нейронную модель регулятора с
использованием нелинейной авторегрессии со скользящим средним.
Управляемым объектом является магнит, который движется в
электромагнитном поле электромагнита. Уравнение движения этой
системы имеет вид
d2y
 i 2 (t )  dy(t )
,


g


dt 2
 y(t )  dt
где y(t) – расстояние движущегося магнита от электромагнита;
g – ускорение силы тяжести;
α – постоянная магнитного поля, зависящая от числа витков
обмотки и намагниченности электромагнита;
i(t) – управляющий ток электромагнита:
М – масса магнита;
β – коэффициент вязкого трения.
Задание 3. Создать нейронную модель регулятора на основе
эталонной модели. Регулируемым объектом является звено робота,
описываемое дифференциальным уравнением
d 2
d
 10 sin   2
u ,
2
dt
dt
где φ – угол поворота звена;
u – момент, развиваемый двигателем постоянного тока.
Цель обучения регулятора состоит в том, чтобы положение звена
отслеживало выход эталонной модели
d 2 yr
dy
 9 yr  6 r  9r ,
2
dt
dt
где yr – выход эталонной модели;
r – задающий сигнал на выходе модели.
Основные этапы синтеза нейронного регулятора таковы:
138
1. Построение модели Simulink для управляемого объекта и
эталонной моделей и их исследование.
2. Идентификация объекта и синтез его нейронной модели.
3. Идентификация эталонной модели и синтез регулятора.
4. Моделирование регулируемой системы и анализ качества
регулирования.
139
Cписок литературы
1. Дьяконов, В. Matlab 6: учебный курс [Текст] / В. Дьяконов. –
СПб.: Питер, 2001. – 592 с.
2. Медведев, В. Г. Нейронные Сети Matlab 6 / В. Г. Медведев;
под общ. ред. к.т.н. В. Г. Потемкина. – М.: ДИАЛОГ-МИФИ, 2002. –
496 с. – (Пакеты прикладных программ; Кн.4).
3. Галушкин, А. И. Теория нейронных сетей [Текст] / А. И. Галушкин. – М.: ИПРЖР, 2000. – 416 с.
4. Галушкин, А. И. Нейрокомпьютеры [Текст]. – М.: ИПРЖР,
2000. – 532 с.
5. Нейрокомпьютеры и интеллектуальные работы [Текст] / под
ред. В. Г. Неелова. – Киев: Пресса Украины, 1999. – 150 с.
6. Дунин-Барковский, В. П. Информационные процессы в
нейронных структурах [Текст] / В. П. Дунин-Барковский. – М.:
Наука, 1978.
7. Сивохин, А. В. Искусственные нейронные сети [Текст] /
А. В. Сивохин; учеб. пособие / под ред. профессора Б. Г. Хмелевского. – Пенза: Изд-во Пенз. гос. ун-та, 2002. – 70 с.
8. Щербаков, М. А. Искусственные нейронные сети: Конспект
лекций [Текст] / М. А. Щербаков. – Пенза: Изд-во Пенз. гос. тех. унта, 1996. – 44 с.
9. Осовский, С. Нейронные сети для обработки информации
[Текст] / С. Осовский; пер. с польского И. Д. Рудинского. – М.:
Финансы и статистика, 2002. – 344 с.
10. Дьяконов, В. П. Matlab 6/6.1/6.5 + Simulink 4/5. Основы
применения. [Текст]. Полное руководство пользователя / В. П.
Дьяконов. – М.: СОЛОН-Пресс, 2002. – 768 с.
140
СОДЕРЖАНИЕ
Введение...................................................................................................................... 3
Лабораторная работа № 1. Основы программирования в системе MATLAB ....... 5
Лабораторная работа № 2. Массивы, структуры, ячейки
и классы системы MATLAB .................................................................................... 15
Лабораторная работа №3. Модели искусственного нейрона ................................ 28
Лабораторная работа №4. Искусственные нейронные сети ................................. 41
Лабораторная работа № 5. Методы и алгоритмы обучения искусственных
нейронных сетей ....................................................................................................... 49
Лабораторная работа № 6. Исследование персептронных сетей ......................... 73
Лабораторная работа № 7. Исследование линейных нейронных сетей ............... 78
Лабораторная работа № 8. Исследование радиальных базисных сетей
общего вида .............................................................................................................. 87
Лабораторная работа № 9. Исследование радиальных базисных сетей
типа GRNN ................................................................................................................ 93
Лабораторная работа № 10. Исследование радиальных базисных сетей
типа PNN ................................................................................................................... 96
Лабораторная работа № 11. Исследование самоорганизующихся
слоев Кохонена ......................................................................................................... 99
Лабораторная работа № 12. Исследование самоорганизующихся
карт Кохонена ......................................................................................................... 104
Лабораторная работа № 13. Исследование самоорганизующихся LVQ-сетей . 112
Лабораторная работа № 14. Исследование сетей Элмана ................................... 117
Лабораторная работа № 15. Исследование сетей Хопфилда .............................. 122
Лабораторная работа № 16. Применение нейронных сетей для
проектирования систем управления динамическими процессами ..................... 125
Список литературы ................................................................................................ 135
141