1. автоматное программирование и нейронные сети

МИНИСТЕРСТВО ОБРАЗОВАНИЯ И НАУКИ РОССИЙСКОЙ ФЕДЕРАЦИИ
Федеральное агентство по образованию
Государственное образовательное учреждение высшего профессионального образования
«САНКТ-ПЕТЕРБУРГСКИЙ ГОСУДАРСТВЕННЫЙ УНИВЕРСИТЕТ
ИНФОРМАЦИОННЫХ ТЕХНОЛОГИЙ, МЕХАНИКИ И ОПТИКИ»
Факультет___Информационных технологий и программирования________________
Направление Прикладная математика и информатика_____
Специализация :__Технологии производства ПО _________________________________
Академическая степень ___магистр прикладной математики и информатики______
Кафедра__Компьютерных технологий_____группа_6539_________________________
МАГИСТЕРСКАЯ ДИССЕРТАЦИЯ
на тему
______Нейро-автоматное управление в машинном обучении_______________________
___________________________________________________________________________
Автор магистерской диссертации _Губин Ю.А._________________________(подпись)
( Фамилия, И., О. )
Научный руководитель_Шалыто А.А._________________________________(подпись)
( Фамилия, И., О. )
Руководитель магистерской программы________________________________(подпись)
( Фамилия, И., О. )
К защите допустить
Зав. кафедрой ____ВАСИЛЬЕВ В.Н.
___________________________(подпись)
( Фамилия, И., О. )
“____”____________________20 ____г.
Санкт-Петербург, 2010 г.
ОГЛАВЛЕНИЕ
ВВЕДЕНИЕ .............................................................................................................. 4
1. АВТОМАТНОЕ ПРОГРАММИРОВАНИЕ И НЕЙРОННЫЕ СЕТИ ............ 5
1.1. Основные концепции автоматного программирования ................... 5
1.2. Искусственные нейронные сети ....................................................... 10
ВЫВОДЫ ПО ГЛАВЕ 1 ....................................................................................... 18
2. ИСПОЛЬЗОВАНИЕ НЕЙРОННЫХ СЕТЕЙ В АВТОМАТАХ ................... 18
2.1. Нейронная сеть – источник логических переменных .................... 19
2.2. Автомат как источник входных данных для нейронной сети ....... 20
2.3. Клеточные автоматы и нейронные сети .......................................... 21
ВЫВОДЫ ПО ГЛАВЕ 2 ....................................................................................... 22
3. МЕТОД ПОСТРОЕНИЯ АВТОМАТНЫХ ПРОГРАММ С
ИСПОЛЬЗОВАНИЕМ РАСШИРЕННОГО СОСТОЯНИЯ ...................... 23
3.1. Автоматы и М-автоматы ................................................................... 23
3.2. Использование нейронных сетей в состояниях автомата .............. 26
3.3. Применение расширенных состояний ............................................. 33
3.4. Корректировка нейронных сетей в расширенных состояниях ..... 34
3.5. Реализация .......................................................................................... 35
3.6. Пример использования. Использование расширенных
состояний для принятия решения ......................................................... 37
3.7. Пример использования. Автомат управления роботомисследователем ........................................................................................ 44
3.8. Отличия метода .................................................................................. 56
ВЫВОДЫ ПО ГЛАВЕ 3 ....................................................................................... 57
ЗАКЛЮЧЕНИЕ ..................................................................................................... 57
ИСТОЧНИКИ ........................................................................................................ 59
ВВЕДЕНИЕ
Теория нейронных сетей [7], является одним из разделов науки об
искусственном
интеллекте.
искусственные
нейронные
Начиная
сети
с
середины
стали
двадцатого
развиваться
века
вместе
с
вычислительной техникой и появлением новых знаний о биологической
структуре
головного
мозга.
Среди
всех
подходов
при
создании
искусственного интеллекта методы теории нейронных сетей отличаются
тем, что они основаны на моделировании структуры головного мозга. Эти
методы позволяют, в меру современного представления, использовать
принципы обработки информации, свойственные человеческому мозгу.
Автоматное
программирование
[3]
–
это
парадигма
программирования, при использовании которой программа или её
фрагмент осмысливается как модель какого-либо формального автомата.
Более того, в парадигме автоматного программирования предлагается
создавать программы в виде совокупности автоматизированных объектов
управления. Каждый такой автоматизированный объект управления
состоит из управляющего автомата или совокупности взаимодействующих
автоматов и объекта управления. Управляющий автомат состоит из
конечных множеств входных воздействий, управляющих состояний,
выходных воздействий, а также начального состояния, функции выходов и
функции переходов. Использование искусственных нейронных сетей
предоставляет дополнительную возможность организации взаимодействия
управляющего автомата с объектом управления. Особенно в тех случаях,
когда при создании функции переходов необходимо учитывать возможное
изменение в логике срабатывания переходов между состояниями автомата.
Цель работы состоит в разработке нового способа совместного применения
искусственных нейронных сетей и автоматного программирования.
Существующие способы совместного применения нейронных сетей и
автоматного программирования отделяют управляющий автомат от
нейронной сети, используя автомат как источник входных данных для
нейронной сети [13] или нейронную сеть как источник данных для
автомата [12]. При использовании таких способов нейронная сеть и
автомат выступают в роли самостоятельных элементов, что усложняет
повторное использование разработанных автоматов в совокупности с
другими управляющими автоматами. В настоящей работе предлагается
метод совместного использования нейронных сетей, при использовании
которого автомат и нейронные сети не выделяются в отдельные элементы
и нейронные сети являются частью автомата, что позволит использовать
разработанный управляющий автомат с другими, не сталкиваясь с
необходимостью дополнительного преобразования нейронных сетей.
1. АВТОМАТНОЕ ПРОГРАММИРОВАНИЕ И
НЕЙРОННЫЕ СЕТИ
В
этой
главе
приводятся
общие
принципы
автоматного
программирования и нейронных сетей. Рассматривается понятие «система
со сложным поведением» и обосновывается применение автоматного
подхода для описания систем этого типа. Приводятся примеры задач, в
которых
нейронные
сети
успешно
применяются
для
управления
автоматных систем. Приводятся примеры задач, в которых применяются
нейронные сети и могут быть использованы в автоматах.
1.1. Основные концепции автоматного программирования
В этом разделе описываются понятия «системы со сложным
поведением» и «реактивной» системы. Приводятся основные идеи
автоматного программирования.
1.1.1. Системы со сложным поведением
В
процессе
создания
программного
обеспечения
возникает
необходимость реализации систем со сложным поведением. Таким
поведением обладают многие устройства управления, сетевые протоколы и
т.д.
Считается, что система обладает сложным поведением, если в ответ
на возникновение некоторого события она, в зависимости от предыстории
может совершить одно из нескольких действий.
В программных и программно-аппаратных вычислительных системах
сущности со сложным поведением встречаются очень часто. Таким
свойством
обладают
устройства
управления,
сетевые
протоколы,
диалоговые окна, персонажи компьютерных игр и многие другие объекты
и системы.
Распознать сущность со сложным поведением в исходном коде
программы можно следующим образом: при традиционной реализации
таких сущностей используются логические переменные, называемые
флагами,
и
многочисленные
запутанные
конструкции
ветвления,
условиями в которых выступают различные комбинации значений флагов.
Такой способ описания логики сложного поведения плохо структурирован,
труден для понимания и модификации, подвержен ошибкам.
Вместо
поведением,
этого
предлагается
приписывая
каждой
описывать
из
них
системы
со
некоторое
сложным
множество
управляющих состояний. В этих состояниях поведение системы обычно
является простым и может быть описано явно. Связь управляющих
состояний с действиями и механизм переходов между состояниями удобно
описывать с помощью конечных автоматов с выходами[1]. При этом все
поведение системы оказывается сосредоточенным в автомате или системе
взаимодействующих автоматов. Такой подход к описанию поведения
называют автоматным[2].
Считается, что система обладает сложным поведением, если она
описывается автоматом, или системой взаимодействующих автоматов с
достаточно большим числом состояний и переходов.
Одна и центральных идей автоматного программирования[3] состоит
в отделении описания логики поведения (при каких условиях необходимо
выполнить те или иные действия) от описания его семантики (собственно
смысла каждого из действий). Кроме того, описание логики при
автоматном подходе жестко структурировано. Эти два свойства делают
автоматного описание сложного подведения ясным и удобным.
Одним из классов систем, обладающих сложным поведением,
являются реактивные системы. Системы этого класса могут быть также
названы событийными. В таких системах в качестве входных воздействий
используются события и входные переменные. События, в отличие от
входных переменных, не опрашиваются программой, а вызывают
соответствующие им обработчики. Входные переменные и выходные
воздействия реализуются произвольными подпрограммами (функциями).
Перечислим основные отличия реактивных систем от систем других
классов.
Если в системах логического управления[4] в качестве входных
воздействий используются опрашиваемые программой двоичные входные
переменные и предикаты, соответствующие определенным состояниям
автоматов, взаимодействующих с рассматриваемым автоматом, то для
реактивных систем это понятие расширено. Во-первых, в качестве
входных переменных применяются любые подпрограммы (функции),
возвращающие двоичные значения, а, во-вторых, введены события.
События, как и входные переменные, являются глобальными
переменными программы или модуля программы, в котором находится
автомат. В том случае, если события исключительны (два события не
могут произойти одновременно), для хранения текущего события
достаточно ввести одну целочисленную переменную, значение которой в
дешифраторе
входных
идентификаторами
воздействий
конкретных
событий.
будет
Если
сравниваться
с
же
в
события
разрабатываемой системе не обладают свойством исключительности, для
хранения множества текущих событий можно использовать битовый
вектор. В таком случае представление событий ничем не отличается от
представления входных переменных.
События являются аргументами функции такта автомата. Это
проектное решение отражает различие между событиями и входными
переменными: здесь автомат обрабатывает событие (или набор событий), в
то время как значения входных переменных лишь при необходимости
опрашиваются автоматом по его собственной инициативе. Кроме того, при
реализации автомата вручную такое решение предотвращает программные
ошибки, возможные при первом подходе: когда программист забывает
установить переменную для хранения события перед вызовом такта
автомата.
Каждому событию сопоставляется отдельная функция. Это решение
подходит только для реализации исключительной модели событий. Кроме
того, оно отражает активную роль событий, тот факт, что именно
возникновение события инициировало вызов автомата. К тому же, это
решение
лучше
всего
согласовано
с
традиционной
структурой
программного модуля в событийных системах, где любая самостоятельная
часть программы представляет собой множество обработчиков связанных
по смыслу событий.
Другое отличие «реактивных» систем от систем логического
управления состоит в том, что в них в качестве выходных воздействий
применяются не только двоичные переменные, но и произвольные
подпрограммы.
Также как и в системах логического управления, в «реактивных»
системах алгоритмы представляются в виде системы взаимосвязанных
автоматов. При этом если в системах первого типа взаимодействие
автоматов в основном осуществляется за счет обмена номерами состояний,
а вложенность присутствует в начальном состоянии, то в реактивных
системах число способов взаимодействия увеличилось.
В качестве примера системы, управляемой автоматами, приведем
реализацию протокола «SMTP» на основе SWITCH-технологии[5][6],
которая изображена на рис. 1.
Рис.1. Схема взаимодействия автоматов реализации протокола
«SMTP»
1.1.2. Автоматное программирование
Парадигма
представлении
автоматного
систем
со
программирования[3]
сложным
состоит
поведением
в
в
виде
автоматизированных объектов управления. Автоматизированный объект
управления представляет собой объект управления, интегрированный с
системой управления в одно устройство. При этом система управления
обладает сложным поведением и представляется в виде системы
взаимодействующих конечных автоматов, а объект управления обладает
простым поведением и реализуется традиционными методами.
В случае, когда автоматы описывают системы со сложным
поведением, и когда логика поведения не полностью определена на момент
проектирования
системы,
появляется
возможность
использовать
нейронные сети.
1.2. Искусственные нейронные сети
Искусственные нейронные сети (ИНС)[7] — математические модели,
а также их программные или аппаратные реализации, построенные по
принципу организации и функционирования биологических нейронных
сетей — сетей нервных клеток живого организма. Это понятие возникло
при изучении процессов, протекающих в мозге, и при попытке
смоделировать эти процессы.
1.2.1. Возникновение искусственных нейронных сетей
Первой такой попыткой были нейронные сети Маккалока и
Питтса[7]. Они предложили систему обработки информации в виде сети,
состоящей
из
простых
вычислителей,
созданных
по
принципу
биологического нейрона. Каждый такой элемент i =1,2...n имеет входы и
выходы, принимающие значения 0 или 1. Состояние отдельного нейрона
определяется влиянием остальных как взвешенная линейная комбинация
∑ 𝑤𝑖𝑗 𝑛𝑗 их выходов 𝑛𝑗 . К сумме затем применяется пороговая функция
вида 𝑔(∑ < 0) = 0; 𝑔(∑ ≥ 0) = 1 [7]. Маккалок и Питтс показали, что
такие сети могут производить произвольные вычисления, подобно
известной машине Тьюринга. При этом единственной нерешенной
проблемой оставался подбор весов 𝑤𝑖𝑗 – настраиваемых параметров для
задачи. В 1962 г. Ф. Розенблатт для решения проблемы классификации
символов приложил использовать особый тип искусственной нейронной
сети, названный им персептроном[7][8]. В этой же работе им был
предложен итеративный алгоритм получения весов 𝒘𝒊𝒋 , моделирующих
силу синоптической связи. Значения весов получались по известным
входным значениями и соответствующим желаемым выходам сети.
В 1969 г. Минский и Паперт в своей работе[7][9] показали, что
персептрон не может решать целый класс простых задач, таких как,
например, реализация логической операции XOR. Все исследования в этой
области были приостановлены до середины 80-х годов.
В 1986 г.Д. Румельхарт, Г. Хинтон и Р. Вильямс предложили
эффективный
алгоритм
для
обучения
более
совершенного,
так
называемого многослойного, персептрона[7][10].
С конца 80-х годов по настоящее время теория нейронных сетей
активно развивается. В современный период нейронные сети все чаще
применяются для решения разнообразных практических задач. Более того,
они все чаще применяются в диагностике, промышленности, финансовой
схеме и в повседневной жизни – там, где необходимо решать задачи, с
которыми раньше справлялся только человек.
1.2.2. Топологии искусственных нейронных сетей
Существует несколько распространенных топологий нейронных
сетей. Каждая из них обладает своими достоинствами и подходит для
решения определенного типа задач.
Многослойный персептрон [10][7] - это искусственная нейронная сеть
с прямыми связями (feedforward), в которой имеется несколько слоев
нейро-элементов
с
настраиваемыми
весами
связей.
Архитектура
трехслойного персептрона, получившего наибольшее распространение,
приведена на рис. 2.
Y1
YM
Выходной слой
...
X’’N2
X’’1
Скрытый слой
...
X’1
X’N1
Входной слой
...
X1
XN
Рис. 2. Архитектура многослойного персептрона
К элементам входного слоя применимо следующее правило: 𝑥𝑗′ =
′′ ′′
𝑓(∑𝑁
𝑖=1 𝑤𝑖𝑗 𝑥𝑖𝑗 ) 𝑗 = 1. . 𝑁1 .
К
элементам
скрытого
слоя
применимо
′′ ′′
следующее правило: 𝑥𝑘′′ = 𝑓(∑𝑁1
𝑗=1 𝑤𝑗𝑘 𝑥𝑗𝑘 ) 𝑘 = 1. . 𝑁2 .
Элементы
выходного
слоя
рассчитываются
как
𝑌𝑙 =
′′ ′′
𝑓(∑𝑁2
𝑘=1 𝑤𝑘𝑙 𝑥𝑘𝑙 ) 𝑙 = 1. . 𝑀.
В
отличие
от
элементарного
персептрона,
формирующего
классифицирующую гиперплоскость, многослойный персептрон может
формировать в режиме обучения сложные нелинейные гиперповерхности
(кусочно-линейные,
полиномиальные
и
т.
п.).
Благодаря
этому
многослойный персептрон способен распознавать произвольное число
классов, имеющих сложную структуру в пространстве первичных
признаков. При этом классы могут представлять собой выпуклые,
невыпуклые и многосвязные объекты.
Сети
Хопфилда
[10][7]
представляют
собой
широкий
класс
искусственных нейронных сетей, включающий в себя многие типы сетей в
качестве частных подклассов. Это обусловлено тем, что сеть Хопфилда
является абсолютно однородной структурой без какой-либо внутренней
специализации ее нейро-элементов (рис. 3).
1
2
N-1
N
1
2
N-1
N
1
2
N-1
N
Рис. 3. Архитектура сети Хопфилда
Существуют две основные разновидности ИНС Хопфилда:
 сеть с пороговыми элементами;
 сеть с сигмоидальными элементами.
Сеть с пороговыми элементами функционируют в асинхронном
режиме, то есть каждый элемент в случайные моменты времени с
некоторой средней частотой определяет свое состояние. В качестве
порогового уровня для всех элементов обычно выбирается ноль.
Благодаря этому оказалось возможным описать динамику сети
Хопфилда в рамках энергетического подхода. При этом оказывается
полезной механическая аналогия между поведением сети и движением
шарика по некоторому вязкому рельефу под действием силы тяжести.
Поведение сети с сигмоидными элементами описывается системой
нелинейных дифференциальных уравнений, учитывающих синхронность и
непрерывность переключения элементов.
Основными недостатками искусственной нейронной сети Хопфилда
являются:
1. неэкономное использование памяти (количество случайных образов,
которое сеть может запомнить с вероятностью последующего
восстановления, равной 1, не превышает 15 % от общего количества
элементов);
2. чувствительность к искажениям распознаваемых образов (сеть имеет
весьма скромные возможности распознавания, так как допустимо
лишь искажение образов ограниченным аддитивным шумом);
3. неинвариантность к геометрическим преобразованиям образов
(например,
к
аффинным
или
проективным
преобразованиям
распознаваемых изображений).
Нейросети
Хемминга[7][10]
–
искусственная
нейронная
сеть
Хемминга реализует оптимальный в смысле минимума ошибки алгоритм
классификации, используемый для решения задач в области связи
(восстановление искаженного случайным шумом эталонного сигнала).
Архитектура ИНС Хемминга показана на рис. 4.
1
2
N-1
1
N-H1
2
N-H1
1
N
N-HM-1
2
N
N-1
N-HM
N-1
N
Рис. 4. Архитектура сети Хемминга
Сеть представляет собой двухуровневую структуру, в каждом слое
которой расположены элементы с насыщением. Число элементов в
верхнем и нижнем слоях одинаково и равно числу классов образов. Веса
связей и пороги элементов задаются при обучении сети Хемминга.
После задания весов связей и порогов элементов на входы сети
подается двоичный N-мерный вектор (образ). Он должен сохраняться на
входах в течение времени, достаточного для параллельного срабатывания
всех элементов нижнего слоя и инициализации элементов верхнего слоя.
Каждый элемент нижнего слоя вычисляет следующую величину N - Hi, где
Hi - расстояние Хемминга между входным вектором и i-м эталоном.
После удаления входного вектора с входов сети состояние элементов
нижнего слоя не изменяется, а в верхнем слое происходит синхронное
срабатывание элементов.
Верхний слой осуществляет выбор элементов с наибольшим уровнем
возбуждения. Критерием окончания процесса классификации служит
отсутствие выходных сигналов на выходах всех элементов верхнего слоя,
за исключением одного. Номер этого элемента соответствует классу, к
которому принадлежит искаженный шумом входной образ. По сравнению
с сетью Хопфилда сеть Хемминга:
1. требует почти на порядок меньшего числа соединений между
элементами при одинаковой информационной емкости сети;
2. в
процессе
работы
всегда
"сходится"
(эволюционирует)
к
некоторому эталонному образу.
Порогово-полиномиальные нейросети[7][10] – предназначены для
распознавания сложных (линейно не разделимых) классов образов,
заданных в n-мерном пространстве двоичных признаков [10]. Схема
порогово-полиномиальной сети изображена на рис. 5.
Y1
x1
C
f1
П
...
...
...
xn
C
Р
Класс 1
fm
П
Yn
Р
Класс 2
Рис. 5. Схема архитектуры порогово-полиномиальной нейросети
На входе сети имеется сенсорный блок пороговых элементов (Сэлементов), фиксирующий признаки объектов х = (xj, ..., хn) в виде
двоичных кодов. Полученный входной образ (двоичный вектор х)
поступает на блок полиномиальных преобразователей (А-элементов),
формирующий m-мерный вектор вторичных (полиномиальных) признаков
z = (f1(х), ..., fm(х)). Эти вторичные признаки определяют m-мерное
пространство полиномиальных fj(х), j = 1...m, признаков, называемое
спрямляющим пространством. Явный вид функций fj(х) выбирается
адекватно решаемой задаче непосредственно по обучающей выборке. В
выходном слое расположены решающие пороговые элементы (Рэлементы), каждый из которых "отвечает" за распознавание одного из
классов объектов.
1.2.3. Применение нейронных сетей
Настройка нейронных сетей производится при помощи трех парадигм
обучения[7]:
 обучение «с учителем». При данном подходе считается, что для
каждого примера xn из обучающей выборки {xn} заранее известен
желаемый результат t ∈ {tn} работы нейронной сети. Это позволяет
эффективно корректировать веса сети. Примером обучения «с
учителем»
может
служить
процедура
обучения
персептрона.
Очевидным недостатком подобного подхода является то, что не
всегда имеется достаточное количество примеров «с ответами», а
порой их и вовсе невозможно получить;
 обучение «без учителя». Этот тип обучения предполагает, что
желаемые выходы сети не определены, и алгоритм обучения
нейронной
сети
подстраивает
веса
по
своему
усмотрению.
Фактически при этом нейронная сеть ищет закономерности в
обучающих данных и выполняет группирование схожих входных
векторов
по
неявным
признакам.
Чаще
всего
этот
метод
используется для задач классификации;
 обучение методом критики. Данный подход является фактически
промежуточным между первыми двумя. Предполагается, что
имеется возможность только оценивать правильность работы сети и
указывать желаемое направление обучения. Подобная ситуация
часто
встречается
в
системах,
связанных
с
оптимальным
управлением. Подобная нейронная сеть состоит из так называемых
эгоистичных нейронов. Процедура обучения таких нейронов
поощряет
каждый
отдельный
нейрон
к
увеличению
только
собственной «награды», а не производительности всей сети.
Нейронные сети могут быть применены для решения следующих
задач[11]:
 Распознавание образов и классификация. В качестве образов могут
выступать различные объекты: символы, изображения, образцы
звуков.
 Принятие решений и управление.
 Кластеризация.
 Прогнозирование.
 Аппроксимация.
 Сжатие данных и ассоциативная память.
В общем случае при применении нейронных сетей выделяют
несколько этапов решения задачи[11]:
1. Сбор данных для обучения.
2. Подготовка и нормализация данных.
3. Выбор топологии сети.
4. Экспериментальный подбор характеристик сети.
5. Экспериментальный подбор параметров обучения.
6. Собственно обучение.
7. Проверка адекватности обучения.
8. Корректировка параметров, окончательное обучение.
ВЫВОДЫ ПО ГЛАВЕ 1
1. Автоматное программирование – парадигма программирования,
предназначенная
для
проектирования
систем
со
сложным
поведением в терминах состояний, переходов, входных и выходных
воздействий. Этот подход имеет ряд достоинств и подходит для
создания реактивных систем.
2. Вычислительные
системы,
основанные
на
нейронных
сетях,
обладают рядом качеств, таких как: распределенность представления
информации и вычислений, способность к обучению и обобщению,
адаптивность.
2. ИСПОЛЬЗОВАНИЕ НЕЙРОННЫХ СЕТЕЙ В
АВТОМАТАХ
Искусственный интеллект – одна из наиболее важных теоретических и
прикладных областей информатики. Существует широкий спектр приемов
и подходов для создания элементов искусственного интеллекта в
прикладных программах и управляющих системах реального времени.
Наиболее широкое развитие в этой области получили нейронные сети
и генетические алгоритмы. Особо отметим класс нейронных сетей с
возможностью
самообучения.
Однако
их
применение
зависит
от
предметной области, и они выступают в роли специальных объектов,
задача взаимодействия с которыми возлагается на дополнительные
средства и компоненты программы.
В то же время, существует парадигма автоматного программирования,
которая позволяет формализовать поведение программы за счет выделения
состояний и переходов между ними. В настоящей главе представляется
несколько известных способов совместного использования нейронных
сетей и автоматов.
2.1. Нейронная сеть – источник логических переменных
Этот
метод
совместного
применения
конечных
автоматов
и
нейронных сетей был предложен в работах [12]. При использовании этого
метода для управления системой со сложным поведением предлагается
совместно применять нейронную сеть и конечный автомат, которые
совместно строятся генетическим алгоритмом.
При этом нейронная сеть используется для классификации значений
вещественных входных переменных и выработки входных логических
переменных для автомата, а автомат – для выработки выходных
воздействий на систему со сложным поведением (рис. 6).
Числовые или
логические
входные
переменные
Внешняя
среда
Логические
переменные
Нейронная
сеть
Выходные
воздействия
Система со
сложным
поведением
Конечный
автомат
Рис. 6. Структурная схема системы управления
Стоит отметить, что в данном случае нейронная сеть является
единственным
Указанный
источником
метод
логических
применялся
для
переменных
построения
для
автомата.
конечно
автомата
управления моделью беспилотного летательного аппарата[12].
2.2. Автомат как источник входных данных для нейронной
сети
Этот
метод
совместного
применения
конечных
автоматов
и
нейронных сетей был предложен в работе [13] для решения задачи
распознавания динамических образов.
Типичная нейронная сеть может использоваться для распознавания
изображений. Цвет каждой из точек изображения передается на входы
входного слоя сети. При этом с помощью весовых
коэффициентов и
функции активации вычисляется вектор входных сигналов. Круг задач,
решаемых такой нейронной сетью, ограничен распознаванием статических
изображений (без учета предыстории изменений). Нейронная сеть
вычисляет результат по конкретному набору исходных данных, не
учитывая динамику и изменение этих данных.
В тех задачах, где требуется учитывать динамику процесса, в работе
[13] предлагается применять другие структуры, например, комбинацию
нейронной сети и набора конечных автоматов (рис.7).
Внешняя
среда
Нейронная
сеть
Автоматы
Рис. 7. Схема использования автоматов и нейронных сетей для
распознавания динамических образов
При помощи автоматов выделяются параметры, которые невозможно
измерить для одного конкретного входного образа, но которые видны при
обзоре всей динамики происходящих процессов. Эти параметры могут
обрабатываться нейронной сетью, которая на их основе может принимать
решения.
С каждой из точек входного изображения связан конечный автомат,
на
который
подаются
события,
определяемые
изменениями,
происходящими в этой точке. Каждый автомат, в свою очередь, связан с
нейронной сетью, на входы которой он отправляется сигналы. Нейронная
сеть,
распознавая
различные
конфигурации
состоянии
конечных
автоматов, распознает динамические образы. Одной из задач, которые
может решать такая структура, является отслеживание движения объекта.
2.3. Клеточные автоматы и нейронные сети
Клеточным автоматом[14] называют сеть из элементов, меняющих
свое состояние в дискретные моменты времени в зависимости от
состояния самого элемента и его ближайших соседей в предшествующий
момент времени.
Различные клеточные автоматы могут демонстрировать весьма
разнообразное поведение, которое может быть адаптировано для целей
обработки информации за счет выбора (а) закона изменения состояния
элемента и (б) конкретного определения понятия “ближайшие соседи”.
Нейронная сеть Хопфилда вполне может рассматриваться, как клеточный
автомат, элементами которого являются формальные нейроны [15]. В
качестве закона изменения состояния нейро-автомата используется
пороговое преобразование взвешенной суммы входов нейронов, а
ближайшими соседями каждого элемента являются все прочие элементы
автомата.
ВЫВОДЫ ПО ГЛАВЕ 2
1. Совместное применение автоматов и нейронных сетей служит для
решения различных задач, где с одной стороны есть система со
сложным поведением, а с другой есть необходимость использовать
достоинства нейронных сетей.
2. Рассмотрены ситуации, когда нейронная сеть является источником
входных воздействий для автомата и автомат является источником
входных данных для нейронной сети.
3. Рассмотрен способ создания нейронной сети с помощью клеточных
автоматов.
4. Для задач, в которых требуется использовать нейронную сеть в
автомате без усложнения его взаимодействия с внешней средой,
нужно реализовывать частное решение. Данный вопрос будет
подробно рассмотрен в следующей главе.
3. МЕТОД ПОСТРОЕНИЯ АВТОМАТНЫХ ПРОГРАММ
С ИСПОЛЬЗОВАНИЕМ РАСШИРЕННОГО
СОСТОЯНИЯ
3.1. Автоматы и М-автоматы
Автоматы используются для реализации поведения систем со
сложным поведением. Поведение автомата определяется состояниями и
заданными переходами. Реакция автомата на входное воздействие зависит
только от входного воздействия и текущего состояния. Понятие входное
воздействие
является
одним
из
базовых
для
автоматного
программирования. Входные воздействия можно разделить на события и
входные
переменные.
обрабатывает
их
и
Автомат,
формирует
получая
выходные
входные
воздействия,
воздействия.
Правила
формирования выходных воздействий называют функцией выходов
автомата, а правила, по которым происходит смена состояний – функцией
переходов автомата. Схема автомата, используемая в автоматном
программировании, представлена на рис. 8.
Состояние
Функция
переходов
Функция
выходов
Выходные
воздействия
Входные
воздействия
Рис. 8. Автомат в автоматном программировании
Отметим, что выходные воздействия автомата обычно являются
функциями, связывающими между собой входные и выходные данные.
В качестве примера использования автоматов на рис. 9 показан граф
переходов автомата AdvancedUser [16], реализующего регистрацию
пользователя в системе.
AdvancedUser
Activation
Delete
Suspended
Active
Unsuspended
Captcha
Pending enter
mac
Deleted
Activate
Blocked
Activate
Remove
Actived enter
DA
Deleted
Activate
Registered
Рис. 9. Автомат регистрации пользователей
Этот автомат состоит из нескольких состояний и групп состояний.
Каждому состоянию пользователя соответствует состояние автомата.
Начальное состояние пользователя – Suspended. Оно означает, что
пользователь не начал регистрироваться. По событию Unsuspended автомат
переходит в состояние Pending enter mac в группе состояний Activation, и
пользователь вводит личную информацию. По событию Activate автомат
переходит в состояние Captcha в группе состояний Active, в котором
пользователь вводит одно из входных данных – контрольное значение для
предотвращения автоматической регистрации. По событию Activate
автомат переходит в состояние Actived enter DA, в котором пользователь
должен подтвердить свои данные. По событию Activate автомат переходит
в
состояние
Registered,
зарегистрирован.
которое
означает,
что
пользователь
После того, как автомат перешел в одно из состояний группы
Activation, администратор системы может заблокировать пользователя. По
событию Delete автомат перейдет в состояние Blocked в группе Deleted. По
событию Remove автомат переходит в состояние Deleted, и все данные
пользователя будут удалены из системы.
Парадигма автоматного программирования включает в себя описание
поведения программы c использованием конечных автоматов, что делает
ее удобной для создания систем со сложным поведением.
Из изложенного следует, что автоматная программа обычно реализует
некоторое поведение, которое заранее определено программистом и
является решением поставленной задачи.
Однако принять решение относительно реализации выходных
воздействий бывает весьма сложно, так как часто невозможно заранее
сформировать зависимости между входными и выходными данными.
Для подобных задач в работе [17] было предложено использовать
автоматы мышления – М-автоматы. Идея их применения состоит в том,
что принятие решения происходит в ходе размышления – прохождения
определенного пути в автомате. Каждый участок этого пути выделяется в
отдельное интеллектуальное состояние, которое оценивает определенный
фактор и влияет на процесс размышления.
Состояние в М-автомате обладает соответствующими свойствами,
присущими определенному чувству или шагу в размышлении. Из каждого
состояния М-автомата существуют переходы в некоторые другие
состояния.
Эти
переходы
задаются
программистом
на
этапе
проектирования.
В работе [17] описываются возможные методы для управления
процессом принятия решений в М-автоматах: алгоритмы, управляемые
задаваемыми параметрами, логические выражения и т. д. Однако
конкретная реализация автоматов в этой работе не приведена.
3.2. Использование нейронных сетей в состояниях автомата
Идея М-автоматов может быть использована в
автоматном
программировании для создания ядра автомата. Ядро автомата – это его
часть, содержащая состояния и переходы между ними, которая создана для
решения определенной задачи, для принятия решения. В настоящей работе
предлагается использовать нейронные сети для обработки входных данных
в состояниях ядра автомата. При этом ядро автомата будет представлять
собой совокупность переходов и состояний, содержащих небольшие
нейронные сети, каждая из которых будет обрабатывать соответствующие
входные данные.
Для реализации описанного подхода предлагается дополнить набор
компонент для отображения графов переходов автоматов расширенным
состоянием, содержащим нейронную сеть. Такие состояния в графах
переходов будем
выделять
пунктиром,
с
обозначением
или
без
обозначения нейронной сети.
Для того чтобы показать, как организовать работу с нейронной сетью
в автомате рассмотрим пример многослойного персептрона (рис. 10).
V1
VM
Выходной слой
...
V’’N2
V’’1
Скрытый слой
...
V’1
V’N1
Входной слой
...
D1
DN
Рис 10. Многослойный персептрон
Нейронная сеть состоит из нейронов и синапсов [7]. Нейрон – это узел
сети, который хранит определенное значение. Синапс – это связь между
нейронами сети, он передает значение одного нейрона другому. Синапс
хранит коэффициент, который влияет на передаваемое значение.
Для того чтобы организовать работу с нейронной сетью необходимо
подать входные переменные D1..DN, а также выполнить алгоритм для
расчета узлов (нейронов) сети [7] в зависимости от значений синапсов
(связи между нейронами) для получения значений выходных переменных
V1..VM. Выходные переменные V1..VM – это вещественные числа, которые в
данной работе обрабатываются по правилу: переменной с наибольшим
значением присваивается единица, а остальным ноль.
В данной работе в качестве входных воздействий автомата
используются только события, а
входные данные, обрабатываемые
нейронной сетью, могут быть сохранены в контексте автомата, под
которым понимаются переменные, применяемые в работе автомата для
хранения различной информации.
На рис. 11 показано как расширенное состояние связано с нейронной
сетью (НС).
Состояние
Функция
работы с НС
Расчет выходных
переменных НС
Функция
переходов
Функция
выходов
НС
Входные данные
События
Рис. 11. Действие с нейронной сетью
Выходные
воздействия
Функция работы с НС – вычисляет выходные переменные нейронной
сети при входе в состояние. Это понятие будет дополнено далее.
На рис. 12 приведена схема расширенного состояния, которое
функционирует, как описано ниже.
1
2
A
Событие E
3
E
B
4
Входные данные
D 1, D 2, D 3
V1
D1
НС
D2
V2
V3
D3
Рис 12. Расширенное состояние
На рис. 12 цифрами обозначена последовательность обработки
входного воздействия автоматом.
1)
Автомат находится в состоянии А и сеть расширенного состояния
B уже настроена.
2)
Подаются событие E и входные данные D1, D2, D3.
3)
По этому событию срабатывает переход, и автомат переходит из
состояния A в расширенное состояние B.
4)
При входе в расширенное состояние входные данные подаются
на
вход
нейронной
сети,
и
рассчитываются
выходные
переменные сети V1, V2, V3.
Выходные переменные сети V1, V2, V3 являются результатом работы
сети. В терминах М–автоматов это является реализацией одного
интеллектуального
состояния.
Для
того
чтобы
построить
путь
размышления и заставить автомат осуществлять переходы между
расширенными состояниями предлагается использовать результаты работы
сети как источник нового события (рис. 13).
Состояние
Функция
работы с НС
Расчет выходных
переменных НС
Результат
Функция
переходов
Функция
выходов
Выходные
воздействия
НС
События
Входные данные
События
Рис. 13. Использование результатов работы сети
На этом рисунке показано как дополняется понятие функции работы с
НС. При входе в состояние, функция работы с НС рассчитывает выходные
переменные сети, обрабатывает результат и генерирует новое событие в
зависимости от правил, которые задает программист. Например, для сети с
двумя выходами V1, V2 программист может указать, что если V1 равно
единице, то
сгенерировать событие E2, а если V2, то событие Stop –
названия событий могут быть произвольными.
На рис. 14 показана схема генерации нового события.
1
2
A
Событие E1
3
E1
4
Входные данные
D 1, D 2 , D 3, D 4 , D 5
B
V1
D1
D2
НС
D3
5
7
6
C
V4
D4
E2
НС
V2
D5
V3
V5
Рис. 14. Пример генерации события
На
этом
рисунке
цифрами
обозначена
последовательность
функционирования фрагмента автомата:
1)
Автомат находится в состоянии A.
2)
Подаются событие E1 и входные данные D1, D2, D3, D4, D5.
3)
По этому событию срабатывает переход из состояния A в
расширенное состояние B.
4)
При входе в расширенное состояние B входные данные D1, D2,
D3 подаются на вход нейронной сети, и рассчитываются
выходные данные V1, V2, V3.
5)
Выходные данные нейронной сети в состоянии B используются
для генерации нового события E2.
6)
По этому событию срабатывает переход из расширенного
состояния B в расширенное состояние C.
7)
На вход нейронной сети в состоянии C подаются входные данные
D4, D5. Рассчитываются выходные данные V4, V5.
Может возникнуть ситуация, когда все значения выходов V1, V2, V3
равны нулю. Это означает, что сеть не смогла принять решения. Это тоже
результат. В данном случае можно использовать такой результат как
источник нового события, например, Unknown.
При применении предложенного подхода появляется возможность
реализовать априори неопределенную логику переходов. На рис. 15
представлена
схема
автомата
использующего
Robot,
расширенные
состояния для управления роботом, который может шагнуть или прыгнуть
вперед.
Robot
Not enough
power
Waiting
Unknown
Detecting
power
Not ready
Enough
power
Think
Unknown
Unknown
Detecting state
Detecting pit
Ready
Jump
Jumping
Step
Walking
Рис. 15. Автомат с расширенными состояниями
Автомат содержит несколько простых состояний: Waiting – ожидание
команды, Jumping – прыгать, Walking – шагать.
В расширенных состояниях определяется:
 Готов ли робот к действиям (Detecting state). НС этого состояния
имеет две выходных переменных и только одна из них может быть
равна единице: V1, V2. Если V1 равна единице, то генерируется
событие Ready, если V2 – Not ready, если обе равны нулю –
Unknown.
 Достаточно ли у него энергии для выполнения срочных действий
(Detecting power). НС этого состояния имеет две выходных
переменных и только одна из них может быть равна единице: V3, V4.
Если V3 равна единице, то генерируется событие Enough power, если
V4 – Not enough power, если обе равны нулю – Unknown.
 Есть ли перед ним яма (Detecting pit). НС этого состояния имеет две
выходных переменных: V5, V6. Если V5 равна единице, то
генерируется событие Jump, если V6 – Step, если обе равны нулю –
Unknown.
Ядро автомата представлено на рис. 16.
Robot
Not enough
power
Unknown
Detecting
power
Not ready
Enough
power
Unknown
Unknown
Detecting state
Detecting pit
Ready
Jump
Step
Рис. 16. Ядро автомата Robot
Переходы (рис. 8) соединяют расширенные состояния между собой и
с другими состояниями. Так, автомат в состоянии Waiting получает
событие Think и переходит в расширенное состояние Detecting State. После
работы нейронной сети в состоянии Detecting state функцией работы с НС
по определенным правилам может быть сгенерировано одно из трех
событий: Ready, Not ready или Unknown. Из состояния Detecting State
автомат может перейти в другое расширенное состояние: Detecting pit (по
событию Ready) или Detecting power (по событию Not ready).
После работы нейронной сети в состоянии Detecting power может
быть сгенерировано одно из трех событий: Enough power, Not enough power
или Unknown. Из состояния Detecting power автомат может перейти в
состояние Waiting (по событию Not enough power) и ожидать следующего
события Think, или перейти в другое расширенное состояние Detecting pit
(по событию Enough Power).
После работы нейронной сети в состоянии Detecting pit может быть
сгенерировано одно из трех событий: Jump, Step или Unknown. Из
состояния Detecting pit автомат может перейти в простое состояние
Jumping (по событию Jump) или Walking (по событию Step).
3.3. Применение расширенных состояний
Для того чтобы решить задачу с помощью нейронной сети,
необходимо собрать и подготовить данные для обучения, выбрать
топологию
сети
и
ее
характеристики,
обучить
сеть
и
сделать
корректировку параметров обучения.
Сформулируем алгоритм, основанный на применении расширенных
состояний.
1.
Определение структуры ядра автомата (как показано, например,
на рис. 15, 16).
2.
Создание
графа
переходов
автомата
с
использованием
расширенных состояний.
3.
Выбор топологии нейронной сети, используемой в расширенном
состоянии.
4.
Реализация функции работы с нейронной сетью.
5.
Сбор и подготовка данных для обучения.
6.
Обучение нейронных сетей.
7.
Определение правил корректировки характеристик сети в
процессе работы автомата.
8.
Проверка адекватности обучения и правил корректировки во
время тестирования.
Выполняя эти действия последовательно, можно получить автомат,
решающий поставленную задачу.
3.4. Корректировка нейронных сетей в расширенных
состояниях
Для того чтобы нейронные сети в расширенных состояниях начали
возвращать
правильные
результаты
необходимо
их
обучить.
В
предложенном в пункте 3.4 алгоритме применения расширенных
состояний указывается, что необходимо собрать и подготовить данные для
обучения и обучить нейронные сети.
В случае, когда можно подготовить набор тестовых данных его можно
использовать для
обучения нейронной сети при создании экземпляра
расширенного состояния. Если же такой набор данных подготовить
невозможно, то предлагается корректировать коэффициенты синапсов
нейронных сетей в процессе работы автомата.
Для того чтобы это сделать необходимо предварительно сохранить
отдельное решение в памяти автомата, которое включает в себя входные
данные для нейронной сети и значения выходных переменных сети.
Значения выходных переменные могут содержать одну единицу и нули
(если они предварительно обрабатываются по правилу «победитель
забирает все»: наибольшему значению выходной переменно присваивается
единица, остальные обращаются в ноль), или это могут быть различные
вещественные числа. В памяти автомата может храниться только
последнее
решение
или
цепочка
из
нескольких
решений.
Сама
корректировка может вызываться, когда одна из переменных автомата
превышает какое-либо пороговое значение или по событию.
Если выходные переменные нейронной сети были обработаны по
правилу «победитель забирает все» и только одна переменная равна
единице, то ее можно использовать для того, чтобы изменить значения
коэффициентов, считая, что это приятое решение ошибочно. То есть, если
значения синапсов обозначены как wij (синапс соединяет нейрон i и
выходную переменную j), и выходная переменная Vk равна единице то
𝑤𝑖𝑘 = 𝑤𝑖𝑘 + ∆𝑤𝑖𝑘 , где ∆𝑤𝑖𝑘 может зависеть от выбранных параметров
скорости обучения сети, начального значения синапса и других
параметров.
Если выходные переменные являются вещественными числами, а не
обрабатываются по правилу «победитель забирает все», то можно
использовать
алгоритм
обратного
распространения
ошибки
[7],
использующий вместо функции расчета ошибки значение E = Vk.
3.5. Реализация
Для объектно-ориентированной реализации автоматного подхода в
работе [18] была разработана библиотека. Ее достоинством является
простота создания автоматов на языке Java. Библиотека предоставляет
также средства для отображения разработанных автоматов в виде графов
переходов по тексту программы.
Для реализации расширенных состояний в эту библиотеку введен
класс NState, который, в свою очередь, использует библиотеку SNeuro [19].
Последняя предоставляет базовые интерфейсы и реализует несколько
типов нейронных сетей.
Для создания экземпляра расширенного состояния необходимо наряду
с его именем передать в конструктор дополнительные параметры:
размерность вектора входных данных, число и названия выходов
нейронной сети, входные и выходные данные для ее обучения. Нейронная
сеть в расширенном состоянии будет создана и обучена при создании
объекта программы, соответствующего этому состоянию.
Как отмечалось выше, при входе в состояние функция работы с НС
вычисляет выходные переменные сети, обрабатывает результат и
генерирует новый сигнал. Эта функция реализована в классе NState:
processNet = new Action() { // Cоздается функция работы с НС
// . . .
// ev - массив названий генерируемых событий
public void go() { // Этот метод вызывается при вызове функции
// Получение контекста автомата
double[] mycontext = getContext();
// n – это объект нейронной сети, экземпляр
NState. // Вычисление результатов
int[] result = n.result(mycontext);
класса
из
библиотеки
// Получение индекса выходной переменной, равной единице
int rIndex = findOneInA(result);
// Сохранение принятого решения в памяти
saveInMemoryThisDecision(result, rIndex, mycontext);
// Генерация нового события
sendEvent(ev[rIndex]);
}
// . . .
}
При входе в расширенное состояние, экземпляр класса NState
считывает входные данные из контекста и подает их на вход нейронной
сети (рис. 13, 14). После этого осуществляется расчет выходных значений,
а они используются для генерации нового события.
Важным в предлагаемой реализации является то, что параметры
нейронных сетей в состояниях могут быть откорректированы в процессе
работы автомата. Перед генерацией нового события экземпляр класса
NState (расширенное состояние) сохраняет свое название, входные и
выходные данные нейронной сети в специальной области памяти,
реализованной в библиотеке и названной «памятью размышлений
автомата». Вызывая функцию correction, которая реализована в базовом
классе DSL из библиотеки, описанной в работе [18], можно провести
коррекцию нейронных сетей всех расширенных состояний, участвовавших
в последнем принятии решений. Это предоставляет дополнительные
возможности для обеспечения настройки автомата, так как логику
срабатывания переходов можно изменить в процессе работы.
3.6. Пример использования. Использование расширенных
состояний для принятия решения
Для демонстрации применения расширенных состояний построим
автомат, управляющий поведением ежа, который идет по прямой и на
каждом шагу находит еду, тратя на шаг, пять единиц энергии. Еда может
быть ядовита (энергия уменьшается на 40 единиц), а может быть полезна
(энергия увеличивается на 10, 20 или 40 единиц). Еж не должен есть
ядовитую еду. Когда он «наедается» и его энергия становится больше 100
единиц, он не должен больше есть. Собственная энергия ежа имеет
начальное значение 30 и хранится в контексте автомата. Еж делает шаг, ест
или пропускает еду и делает следующий шаг.
Порядок работы с автоматом такой: сначала обновляется контекст
автомата, и подаются входные данные (значение энергии еды), потом
подается сигнал Think и ядро автомата принимает решение – съесть еду
или пропустить и автомат совершает выбранное действие. Далее поступает
сигнал Step, еж делает шаг и тратит энергию. Затем снова обновляется
контекст автомата и так далее.
Реализуем автомат согласно описанному алгоритму.
1. Определение структуры ядра автомата. Для того чтобы принять
решение, съесть еду или нет, требуется определить яд это или нет. Для
этого введем расширенное состояние Detect Good_Bad, которое определит
впереди яд или полезная еда. Также требуется установить, наелся еж или
нет, в том случае, если он нашел не яд. Для этого введем расширенное
состояние Detect Need_Food. Ядро автомата будет состоять из двух
расширенных состояний и нескольких переходов (рис. 17).
Hedgehog
Think
Unknown
Detect
Good_Bad
Bad
Good
Unknown
Detect
Need_Food
No
Yes
Рис. 17. Ядро автомата Hedgehog
В состояние Detect Good_Bad автомат перейдет из другого состояния
по событию Think. Из этого расширенного состояния по событию Bad
автомат выйдет из ядра автомата и перейдет в другое состояние. По
событию Good автомат перейдет в расширенное состояние Detect
Need_Food. Из него по событиям No и Yes автомат перейдет в другие
состояния.
2.
Создание
графа
переходов
автомата
с
использованием
расширенных состояний. В процессе работы еж должен не только
понимать, что делать с едой, но и совершать действия: ждать команду, есть
еду, пропустить еду. Зная структуру ядра автомата (рис. 17) и действия,
которые должен совершать еж, построим граф переходов (рис. 18).
Hedgehog
Wait
Step
Think
Actions
Unknown
Detect
Good_Bad
Bad
Skip
Good
Unknown
Detect
Need_Food
No
Eat
Yes
Рис. 18. Граф переходов автомата управления ежа
Ядро автомата дополнено состоянием Wait – еж ждет команду сделать
шаг. Также создана группа состояний Actions, содержащая состояния Skip –
пропустить еду и Eat – съесть еду. По событию Step автомат перейдет из
состояния в группе Actions в состояние Wait, из которого по событию Think
автомат перейдет в расширенное состояние Detect Good_Bad.
3. Выбор топологии нейронной сети, используемой в расширенном
состоянии. Расширенные состояния используют однослойные нейронные
сети, являющиеся сетями Кохонена [7]. Эти нейронные сети позволят
принять решение в зависимости от нескольких входных переменных и их
можно обучать.
Входные данные перемножаются с коэффициентами синапсов сети.
Полученные выходные данные обрабатываются по правилу «победитель
забирает все»: наибольшее значение превращается в единичное, остальные
обращаются в ноль.
Входными данными для нейронных сетей расширенных состояний
ядра автомата (рис.17) являются значения энергии еды и значение энергии
ежа. Выходные данные по описанному выше правилу равны единице или
нулю.
4. Реализация функции работы с нейронной сетью. В разделе 3.5.
«Реализация» был приведен пример функции управления нейронной
сетью, реализованной в используемой
библиотеке [18]. Эта функция
реализована в классе NState и используется в расширенных состояниях.
В функции используются следующие правила генерации событий:
 Нейронная сеть в расширенном состоянии Detect Good_Bad имеет
две выходных переменных: V1, V2. Если V1 равна единице, то
генерируется событие Good (еда не ядовитая), если V2 –
генерируется событие Bad (еда ядовитая), если обе – Unknown.
 Нейронная сеть в расширенном состоянии Detect Need_Food имеет
две выходных переменных: V3, V4. Если V3 равна единице, то
генерируется событие Yes (еж может есть), если V4, то генерируется
событие No (еж наелся и не должен есть), если обе – Unknown.
Работа с нейронной сетью выполняется в классе NState. Экземпляр
класса NState создается следующим образом:
public NState GoodBad = new NState(
"Detect: Good_Bad",
2,
GoodBadEvents,
HungryTrainData.GoodBad());
5. Сбор и подготовка данных для обучения. Для того чтобы
расширенные
состояния
начали
принимать
правильные
решения,
необходимо обучить их нейронные сети. Для этого требуется подготовить
данные для обучения. Для обучения нейронной сети в состоянии Detect
Good_Bad, используются два массива: для входных и выходных данных.
Каждый элемент массива входных данных – массив из двух
элементов: текущее значение энергии ежа и энергия еды, которую
встречает еж. Каждый элемент массива выходных данных – это массив из
двух элементов, равных нулю или единице.
Входные данные:
double [][] inputs = {{10,-10}, {10,10}, {20,20}, {25,20}, {25,12},{20,-4}, {25,-5}, {50,40}, {100,40}, {1,-100}, {12,-40}, {50,-40},
{34,1}};
Выходные данные:
int [][] results = {{0,1}, {1,0}, {1,0}, {1,0}, {0,1}, {0,1}, {0,1},
{1,0}, {1,0}, {0,1}, {0,1}, {0,1}, {1,0}};
В разделе статьи «3.5. Реализация» отмечалось, что в конструктор
расширенного состояния передается количество и названия выходных
значений нейронной сети. В данном случае используется следующий
список:
String [] GoodBadEvents = {"Good", "Bad"};
Пара {0,1} означает, что второе выходное значение должно быть
равно единице и буден сгенерировано управляющее воздействие Bad.
Используя обученную сеть состояния Detect Good_Bad, еж сможет
определять яд на своем пути.
Для того чтобы обучить нейронную сеть состояния Detect Need_Food,
применяются массивы входных и выходных данных. Элементы массива
входных данных содержат текущее значение энергии и энергию еды.
Входные данные:
double [][] inputs = {{10,10}, {20,10}, {99,10}, {90,10}, {80,10},
{30,10}, {80,10}, {50,10}, {30,10}, {60,10}, {60,10}, {86,10}, {30,10}};
Выходные данные:
int [][] results = {{1,0}, {1,0}, {0,1}, {0,1}, {0,1}, {1,0}, {0,1},
{1,0}, {1,0}, {0,1}, {1,0}, {0,1}, {1,0}};
Список названий выходных значений:
String [] enoughEvents = {"Yes", "No"};
Пара {0,1} означает, что второе выходное значение должно быть
равно единице и будет сгенерировано управляющее воздействие No.
Используя эту сеть, еж определит: может ли он есть еду.
6. Обучение нейронных сетей. В разделе 3.5. «Реализация» указано,
что нейронная сеть обучится автоматически при создании экземпляра
класса, поскольку алгоритм обучения нейронной сети реализован в классах
пакета SNeuro.
Для проверки того, что нейронная сеть обучена, существуют
специальные переменные, которые позволяют узнать состояние сети.
7. Определение правил корректировки характеристик сети в процессе
работы автомата. При решении данной задачи не используются правила
корректировки сетей во время работы автомата, так как данные для
обучения позволяют предусмотреть различные комбинации значений
переменных автомата, а набор входных данных ограничен. Правила
корректировки следует применять при большом наборе входных значений.
Для использования корректировки можно было бы добавить функцию
на переходе по входному воздействию Step, которая анализировала бы
значение энергии ежа. В случае, если энергия ежа стала бы больше 100, то
можно было бы вызывать функцию correction и произвести корректировку
нейронных сетей. Например: уменьшить
значения коэффициентов
синапсов сети в состоянии Detect Need_Food, которые привели к тому, что
автомат оказался в состоянии Eat. То есть синапсов, из-за которых
выходная переменная V3 стала равна единице.
8. Проверка адекватности обучения и правил корректировки во время
тестирования. Для проверки адекватности обучения нейронной сети
после создания расширенных состояний вызываются функции проверки
адекватности обучения, которые прогоняют данные, использованные при
обучении, и считают число допущенных ошибок в вычислении выходных
значений.
Sysytem.out.prinln(GoodBad.stateOfNN()); // печатает 0
Sysytem.out.prinln(enough.stateOfNN()); // печатает 0
Авторами было проведено тестирование разработанного автомата. До
обучения энергия ежа в конце пути была равна 30, а в результате обучения
она повысилась до 110. Это демонстрируется фрагментом протокола
поведения ежа с начальным значением энергии, равным 30. Протокол
состоит из трех столбцов, читаемых последовательно:
Food: (10.0)
Think
Good
Yes
Eating (10.0)
Step
Weight is 35.0
Food: (20.0)
Think
Good
Yes
Eating (20.0)
Step
Weight is 50.0
Food: (40.0)
Think
Good
Yes
Eating (40.0)
Step
Weight is 85.0
Food: (-40.0)
Think
Bad
Skip
Step
Weight is 80.0
Food: (10.0)
Think
Good
No
Skip
Step
Weight is 75.0
Food: (20.0)
Think
Good
Yes
Eating (20.0)
Step
Weight is 90.0
Food: (40.0)
Think
Good
Yes
Eating (40.0)
Step
Weight is 125.0
Food: (-40.0)
Think
Bad
Skip
Step
Weight is 120.0
Food: (10.0)
Think
Good
No
Skip
Step
Weight is 115.0
Food: (20.0)
Think
Good
No
Skip
Step
Weight is 110.0
Result is 110.0
Из протокола следует, что сначала обновляется контекст автомата –
добавляется еда, как и обозначено в постановке задачи. Далее подается
входное воздействие Think и автомат начинает «думать». В результате он
попадает в одно из простых состояний группы Actions (см. рис. 18).
Ниже представлен исходный код автомата, используемого в примере:
// создается автомат
public class Hedgehog extends DSL{
// состояние Wait
public State wait = new State("Wait");
// Массивы, используемые в функциях работы с НС в сетях
String [] GoodBadEvents = {"Good", "Bad"};
String [] enoughEvents = {"Yes", "No"};
// Расширенное состояние Detect Good_Bad
public NState GoodBad = new NState(
"Detect Good_Bad",2, GoodBadEvents, HungryTrainData.GoodBad());
// Расширенное состояние Detect Need_Food
public NState enough = new NState(
"Detect Need_Food", 2, enoughEvents, HungryTrainData.enough());
// Переход из wait в Detect Good_Bad
public Transition think = new Transition(
"think", "Think", wait, GoodBad);
// Переход из Detect Good_Bad в Detect Need_Food
public Transition Good = new Transition(
"Good", "Good", GoodBad, enough);
// Определяются после создания состояний группы Actions
public Transition poison, bad, eat, step;
// Создается группа состояний Actions
public StateGroup actions = new StateGroup("Actions");
// . . .
public Hedgehog () {
// Создание состояний skip, eating.
// . . .
// Создание перехода из Detect Good_Bad в Skip
poison = new Transition("poison", "Bad", GoodBad, skip);
// Создание переходов, срабатывающих по событиям Bad, Eat, Step
// . . .
}
}
3.7. Пример использования. Автомат управления роботомисследователем
Для демонстрации применения расширенных состояний построим
автомат, управляющий поведением робота-исследователя. Робот находится
на ограниченном координатном поле размерами 100x100 и может
двигаться в одном из четырех направлений (вверх, вправо, вниз, влево) на
один шаг, равный единице.
У робота есть свои параметры – запас топлива (F) и запас прочности
(S). Начальное значение F и S равно 100. На каждый шаг робот тратит 5
единиц топлива, то есть после очередного шага запас топлива S = S – 5. На
этом поле цепочками размещаются объекты нескольких типов, и робот
может взаимодействовать с ними: собрать объект или уничтожить его.
Каждый объект имеет свои параметры ∆F и ∆S. Параметры ∆F и ∆S –
положительные числа. Если робот собирает объект, то его прочность
вычисляется как S = S – ∆S, а запас топлива F = F + ∆F. Если робот
уничтожает объект, то его прочность вычисляется как S = S – ∆F, то есть
при уничтожении объекта с ∆F > 0 запас прочности S робота уменьшается.
Типы объектов роботу заранее неизвестны. Каждый тип объекта
помечается маской – вещественным числом больше нуля и меньшим либо
равным единице. Робот видит маски типов объектов, находящихся на
расстоянии менее четырех единиц от него.
У
робота есть два режима работы: режим автоматического
исследования и режим ручного управления. Можно переводить робот из
одного режима в другой с помощью событий Explore и Stop, а также робот
должен сам перейти в режим ручного управления при нештатной ситуации
(когда запас топлива F < 30 или прочность S < 20). В режиме
автоматической работы робот самостоятельно двигается по полю, собирает
или уничтожает объекты. В режиме ручного управления пользователь сам
управляет роботом, но может использовать функцию автоматического
взаимодействия: то есть с помощью события Think заставить робота
собрать или уничтожить объект, расстояние до которого меньше единицы,
используя возможности нейронных сетей.
Порядок работы с роботом такой: сначала случайным образом
размещаются объекты на карте, после этого в точку с координатами (0,0)
помещается робот и ему подается событие Explore, после которого робот
переходит в режим автоматического исследования и начинает исследовать
поле, учится правильно взаимодействовать с объектами различных типов,
собирая или уничтожая их. В любой момент работа робота в режиме
автоматического исследования может быть остановлена событием Stop,
после которого робот переходит в режим ручного управления.
Критерием работы робота является максимальная прочность S, когда
заканчивается запас топлива F (то есть когда F < 20 и робот переходит в
режим ручного управления).
В режиме ручного управления автомат может двигаться вниз, вверх,
влево, вправо по карте, а также собирать и уничтожать объекты по
команде, или используя сконфигурированную в автоматическом режиме
нейронную сеть.
Реализуем автомат согласно описанному алгоритму.
1. Определение структуры ядра автомата. Ядро автомата включает в
себя состояния и переходы для автоматического режима работы. Для того
чтобы робот начал работать в режиме автоматического исследования и
взаимодействовать с объектами, нужно определить видит ли он какиенибудь объекты из текущей позиции. Для этого введем расширенное
состояние Detect see anything, в котором робот определит, видит ли он хотя
бы один объект. Если робот видит хоть один объект, то нужно определить
есть ли объект, расстояние до которого меньше единицы. Для этого введем
расширенное состояние Detect element in current position.
Если есть объект удаленный менее чем на единицу, то робот должен
определить, что с ним сделать: собрать или уничтожить. Для этого введем
расширенное состояние Define action, в котором робот определит действие,
которое нужно совершить с объектом.
Если робот видит хоть один объект, и нет объекта удаленного менее
чем на единицу, то робот должен определить объект, к которому нужно
идти. Для этого введем расширенное состояние Find way, в котором робот
определяет объект, в направлении к которому нужно двигаться. Для
выявления нештатной ситуации введем расширенное состояние Detect
state, в котором робот определит, нужно ли переходить в режим ручного
управления. Ядро автомата будет состоять из пяти расширенных
состояний и нескольких переходов (рис. 19).
Explorer
Core
Go
Bad v Unknown
Z: x=true
Z: Step
Detect state
x=true
Explore
Z: x=false
Stop
Z: x=true
Good
Z: Correct
Unknown v No
Z: Random_step
Destroy^¬x
Z: Destroy
Collect ^¬x
Detect see
anything
Yes
Z: Collect
Unknown
Detect element in
current position
Define action
Yes
No ^¬x
Unknown
Unknown
Find way
Рис. 19. Ядро автомата
Для определения режима работы вводится переменная x, которая
принимает значения true или false. В ручном режиме x=true, а в
автоматическом x=false. Все расширенные состояния и переходы между
ними объединены в группу состояний Core. По событию Explore автомат
перейдет в состояние Detect see anything, потому что это состояние
является начальным состоянием в группе состояний Core. Из этого
состояния автомат по событию Yes перейдет в Detect element in current
position. По другим событиям (No, Unknown) автомат остается в этом
состоянии, но вызывается функция Random step и робот перейдет в одну из
соседних клеток.
Из расширенного состояния Detect element in current position автомат
по событию Yes перейдет в состояние Define action, а по событию No
перейдет в состояние Find way (в автоматическом режиме) или выйдет из
группы состояний в ручном режиме. По событию Unknown автомат
останется в этом состоянии.
Из расширенного состояния Define Action по событию Destroy
вызовется функция Destroy, то есть робот уничтожит объект и автомат
перейдет в состояние Detect state (в автоматическом режиме) или выйдет
из группы состояний Core в ручном режиме. По событию Collect вызовется
функция Collect (робот соберет объект) и автомат перейдет в Detect state в
автоматическом режиме или выйдет из группы состояний в ручном
режиме. По событию Unknown автомат останется в этом состоянии.
Из расширенного состояния Find way автомат по событию Go
перейдет в состояние Detect state и вызовется функция Step (робот
переместится в направлении выбранного объекта, эта функция будет
описана в пункте четыре при создании функции работы с НС). По событию
Unknown автомат останется в этом состоянии.
Из расширенного состояния Detect state автомат по событию Good
перейдет в Detect see anything, вызовется функция корректировки Correct
(она будет описана в пункте семь при реализации правил корректировки) и
робот продолжит исследовать. По событию Bad автомат выйдет из группы
Core, и робот перейдет в режим ручного управления.
По событию Stop автомат выйдет из любого состояния группы Core, и
робот перейдет в режим ручного управления.
2.
Создание
графа
переходов
автомата
с
использованием
расширенных состояний. Дополним ядро автомата (рис. 19) состояниями и
переходами для ручного режима работы. Граф переходов автомата
представлен на рис. 20.
Explorer
Core
Go
Bad v Unknown
Z: x=true
Z: Step
Detect state
x=true
Destroy
Z: Destroy
Explore
Z: x=false
Stop
Z: x=true
Wait
Collect
Good
Z: Correct
Destroy^¬x
Z: Destroy
Collect ^¬x
Z: Collect
Unknown v No
Z: Random_step
Detect see
anything
Yes
Z: Collect
Unknown
Collect ^x
Go
Detect element in
current position
Z: Collect
Define action
Stop
Destroy^x
Z: Destroy
Yes
No ^¬x
Move
Up
Left
Z: Left
Right
Z:Right
Down
Z: Up
Unknown
Unknown
Find way
Think
No ^x
Z: Down
Рис. 20. Граф переходов автомата
Ядро автомата дополнено состоянием Wait – робот находится в режим
ручного управления и ждет команд. По событию Explore робот перейдет в
автоматический режим. Также введено состояние Move, в которое автомат
может перейти из Wait по событию Go. В этом состоянии робот
перемещается по полю по событиям Left, Right, Up и Down. Из этого
состояния автомат перейдет в Wait по событию Stop.
Также в состоянии Wait по событию Collect робот соберет объект,
удаленный менее чем на единицу, или по событию Destroy уничтожит его.
Для того, чтобы использовать возможность автоматического принятия
решения в ручном режиме введен переход из Wait в Define element in
current position по событию Think. В этом случае робот определит, есть ли
объект, удаленный менее чем на единицу, затем определит какое действие
нужно с ним совершить и выполнит его и вернется в состояние Wait.
3. Выбор топологии нейронной сети, используемой в расширенном
состоянии. Расширенные состояния Detect see anything, Detect state и
Detect element in current position используют однослойный персептрон, так
как его функциональности достаточно для принятия правильного решения.
Сеть в состоянии Detect state получает на вход два значения: S и F, в
зависимости от которых принимается решение: перейти в ручной режим
работы, или продолжить автоматическую работу.
Сеть в состоянии Detect see anything получает на вход значение равное
количеству видимых объектов. Эта НС имеет только одну входную
переменную и если она равна нулю – то это означает, что видимых
элементов нет. В этом случае робот должен сделать шаг в любом
направлении.
Сеть в состоянии Detect element in current position получает на вход
маску типа объекта, удаленного не далее чем на единицу от робота, или
ноль. В зависимости от результатов работы сети принимается решение:
обрабатывать ближайший элемент или определять объект, к которому
нужно двигаться.
Расширенные состояния Define Action и Find way используют
многослойные персептроны. Сеть в состоянии Define Action принимает на
вход маску ближайшего объекта и в зависимости от результатов работы
сети принимается решение собрать или уничтожить объект.
Сеть в состоянии Find way принимает на вход массив из 54 элементов,
который состоит из масок видимых объектов, или, если видимых объектов
меньше – вместо маски в массив добавляется ноль. Эта нейронная сеть
имеет 54 выхода, которые в дальнейшем обрабатываются функцией
работы с НС (она описана в пункте четыре реализации алгоритма).
Полученные выходные данные всех нейронных сетей обрабатываются
по правилу «победитель забирает все», то есть наибольшее значение
превращается в единицу, а остальные обращаются в ноль.
4. Реализация функции работы с нейронной сетью. В разделе
«Реализация» был приведен пример функции управления нейронной
сетью, реализованной в используемой
библиотеке [18]. Эта функция
реализована в классе NState и используется в расширенных состояниях.
В функции используются следующие правила генерации событий:
 Нейронная сеть в расширенном состоянии Detect state имеет две
выходных переменных: V1, V2. Если V1 равна единице, то
генерируется событие Good (робот может продолжить работу в
автоматическом режиме), если V2 – генерируется событие Bad (робот
переходит в режим ручного управления), если обе равны нулю –
Unknown.
 Нейронная сеть в расширенном состоянии Detect see anything имеет
две выходных переменных: V3, V4. Если V3 равна единице, то
генерируется событие Yes (есть видимые объекты), если V4 – No
(видимых объектов нет, нужно передвинуться по полю), если обе
переменных равны нулю – то генерируется событие Unknown.
 Нейронная сеть в расширенном состоянии Detect element in current
position имеет две выходных переменных: V5, V6. Если V5 равна
единице,
то
генерируется
событие
Yes
(нужно
обработать
ближайший объект), если V6 – генерируется событие No, если обе
равны нулю – Unknown.
 Нейронная сеть в расширенном состоянии Define action имеет две
выходных переменных: V7, V8. Если V7 равна единице, то
генерируется событие Collect, если V8 – генерируется событие
Destroy, если обе равны нулю – Unknown.
 Нейронная сеть в расширенном состоянии Find way имеет 54
выходных переменных: Vi, где i ≥ 9 и ≤ 62. Если хоть одна
переменная Vi равна единице, то в переменную x’ автомата
сохраняется значение i, то есть номер объекта, к которому нужно
двигаться. Эта переменная используется в функции Step, которая
вызывается при переходе из этого состояния и робот перемещается
на единицу к выбранному объекту. Если все Vi равны нулю –
генерируется событие Unknown.
Работа с нейронной сетью выполняется в классе NState. Экземпляр
класса NState создается следующим образом:
// создается состояние detectState
public NState detectState = new NState(
"Detect state", // название состояния
2, // число входных переменных сети
detectStateEvents, // генерируемые события для функции работы с НС
TrainData.detectState() // данные для обучения сети
);
5. Сбор и подготовка данных для обучения. Для того чтобы
расширенные
состояния
начали
принимать
правильные
решения,
необходимо обучить их нейронные сети. Для этого требуется подготовить
данные для обучения. Для этого в состоянии Detect state используются
массивы входных и выходных данных, приведенные ниже.
Каждый элемент массива входных данных – два элемента: текущее
значение переменных F и S автомата. Каждый элемент массива выходных
данных – два элемента, равных нулю или единице.
Входные данные:
double [][] inputs = {{40,50}, {50,60}, {20,20}, {25,40}, {10,90},
{60,10}, {40,15}, {50,40}, {100,100}, {10,10}, {12,40}, {0,0}, {30,20}};
Выходные данные:
int [][] results = {{1,0}, {1,0}, {0,1}, {0,1}, {0,1}, {0,1}, {0,1},
{1,0}, {1,0}, {0,1}, {0,1}, {0,1}, {1,0}};
В разделе «Реализация» отмечалось, что в конструктор расширенного
состояния передаются число и названия выходных значений нейронной
сети. В данном случае используется следующий список:
String [] detectStateEvents = {"Good", "Bad"};
Пара {0,1} означает, что второе выходное значение должно быть
равно единице и будет сгенерировано событие Bad. Используя обученную
сеть состояния Detect state, робот сможет переходить в режим ручного
управления.
Для обучения нейронной сети в состоянии Detect see anything,
применяются массивы входных и выходных данных, приведенные ниже.
Элемент массива входных данных содержит число видимых объектов.
Входные данные:
double [][] inputs = {1, 2, 3, 5, 10, 15, 0, 12, 9, 0, 6, 7};
Выходные данные:
int [][] results = {{1,0}, {1,0}, {1,0}, {1,0}, {1,0}, {1,0}, {0,1},
{1,0}, {1,0}, {0,1}, {1,0}, {1,0}};
Для того, чтобы получить единицу при входной переменной равной
нулю используется ненулевое значение для увеличения значения. Список
названий выходных значений:
String [] detectSeeAnythingEvents = {"Yes", "No"};
Пара {0,1} означает, что второе выходное значение должно быть
равно единице и будет сгенерировано событие No. Используя эту сеть,
робот сможет работать в автоматическом режиме.
Для обучения нейронной сети в состоянии Detect element in current
position, применяются массивы входных и выходных данных, приведенные
ниже. Элемент массива входных данных содержит маску объекта
удаленного от робота на расстояние менее единицы. Если такого объекта
нет – используется нулевое значение.
Входные данные:
double [][] inputs =
0.200149, 0.542002, 0, 1};
{0.684794,
0.001789,
0.529403,
0,
0.731290,
Выходные данные:
int [][] results = {{1,0}, {1,0}, {1,0}, {0,1}, {1,0}, {1,0}, {1,0},
{0,1}, {1,0}};
Для того, чтобы получить единицу при входной переменной равной
нулю используется ненулевое значение для увеличения значения. Список
названий выходных значений:
String [] detectElementInCurrentPositionEvents = {"Yes", "No"};
Пара {0,1} означает, что второе выходное значение должно быть
равно единице и будет сгенерировано событие No.
Нейронные сети в состояниях Find way и Define action не обучаются
при создании, а корректируются в процессе работы.
6. Обучение нейронных сетей. В пункте «Реализация» отмечалось, что
нейронная сеть обучится автоматически при создании экземпляра класса,
поскольку алгоритм обучения нейронной сети реализован в классах пакета
SNeuro.
Для проверки того, что нейронная сеть обучена, в используемых
классах существуют специальные переменные, которые позволяют узнать,
на сколько хорошо обучилась сеть, то есть, сколько ошибок допускается
при расчете выходных переменных для входных данных, используемых
при обучении.
7. Определение правил корректировки характеристик сети в процессе
работы автомата. В процессе работы автомата корректируются
нейронные сети двух состояний: Find way и Define action. Функция работы
с НС в этих состояниях сохраняет входные данные и результат в памяти
решений автомата. Функция Correct вызывает функцию correction класса
DSL и осуществляет корректировку нейронной сети, участвовавшей в
принятии последнего решения, и очищает память решений автомата.
Корректировка происходит с использованием параметров нейронной
сети. Если значения синапсов обозначены как wij (синапс соединяет нейрон
i и выходную переменную j), и выходная переменная Vk равна единице то
𝑤𝑖𝑘 = 𝑤𝑖𝑘 + ∆𝑤𝑖𝑘 , где ∆𝑤𝑖𝑘 зависит от параметров скорости обучения сети
и
начального
значения
синапса. Эти
параметры
устанавливаются
автоматически при создании сети.
8. Проверка адекватности обучения и правил корректировки во время
тестирования. Для проверки адекватности обучения нейронной сети
после создания расширенных состояний вызываются функции проверки
адекватности обучения, которые прогоняют данные, использованные при
обучении, и считают число допущенных ошибок в вычислении выходных
значений.
// печатает 0
Sysytem.out.prinln(detectState.stateOfNN());
// печатает 0
Sysytem.out.prinln(detectSeeAnything.stateOfNN());
// печатает 0
Sysytem.out.prinln(detectElementInCurrentPosition.stateOfNN());
Авторами было проведено тестирование разработанного автомата. В
процессе работы робот переходил в режим ручной работы, но после
нескольких итераций робот научился правильно взаимодействовать с
объектами, и в дальнейшем не переходил в режим ручного управления.
Тестирование
робота
было
проведено
в
несколько
итераций,
и
использовались одни и те же типы объектов. В первой итерации
необученный робот помещался на поле и начинал исследовать. При S < 20
робот перешел в режим ручного управления. То есть он взаимодействовал
с объектами и в процессе обучения не корректно обрабатывал объекты. Во
второй итерации уже обучавшийся робот помещался на новое поле. Робот
перешел в режим ручного управления при F < 30, и значение S было равно
40. После пятой итерации значение S было равно 100 при F < 30. Это
показывает,
что
робот
обучился
правильно
взаимодействовать
с
объектами.
Ниже представлен фрагмент исходного кода автомата, используемого
в примере:
package explorer.auto;
public class Explorer extends DSL {
// функции и переменные автомата
. . .
// состояния
public State wait = new State("Wait");
public State move = new State("Move");
// группа состояний Core.
// состояния этой группы создаются в конструкторе класса
public StateGroup core = new StateGroup("Core");
// переходы, будут созданы в конструкторе класса
public Transition explore, stop, left, right, down, up, collect,
destroy, think;
public Transition good, bad, yesDSeeA_DECurPos, yesDECurPos_DA, ...;
public ExplorerA() {
// создается состояние detectState
detectState = new NState(
"Detect state", // название состояния
2, // число входных переменных сети
// генерируемые события для функции работы с НС
detectStateEvents,
TrainData.detectState() // данные для обучения сети
);
// создается состояние detectSeeAnything
detectSeeAnything = new NState(
"Detect see anything",
1,
detectSeeAnythingEvents,
TrainData.detectSeeAnything()
);
// Создаются другие расширенные состояния
// ...
// Создаются переходы
explore = new Transition("Explore", "Explore", wait, core)
yesDECurPos_DA
=
new
Transition("See
detectElementInMyPosition, defineAction);
element",
"Yes",
collectDA_DS = new Transition("Collect", "Collect", null,
Action() {
public void go() { eatFunc(); } // функция на переходе
}, defineAction, detectState);
new
// добавление всех созданных объектов в вектор, для их обработки
// в группе состояний
Vector<Entity> elements = new Vector<Entity>();
elements.add(detectState);
elements.add(detectElementInMyPosition);
elements.add(detectSeeAnything);
elements.add(collectDA_DS);
//....
// обработка элементов в группе состояний
core.setAll(elements);
}
}
3.8. Отличия метода
Данный метод по принципу организации работы автомата и
нейронной сети объединяет идеи использовать автомат как источник
входных данных для нейронных сетей и нейронные сети как источник
воздействия на автомат. При этом нейронные сети являются частью
состояний автомата, и внешняя среда взаимодействует не с нейронной
сетью, а с автоматом. По сравнению со схемой взаимодействия описанной
в работе [12] можно отметить следующее:
 в предложенном методе в автомате используются не одна, а
несколько нейронных сетей, каждая из которых создается и
настраивается для решения определенной задачи;
 в настоящей работе предлагается использовать каждую нейронную
сеть как источник событий, то есть появляется возможность
реализовать заранее неопределенную логику переходов без внешних
событий;
 в предложенном методе предлагается использовать коррекцию
нейронных сетей в автомате, то есть появляется возможность
изменить
логику
работы
части
автомата
в
процессе
его
использования;
 поскольку в предложенной реализации нейронная сеть является
частью состояния, и внешняя среда взаимодействует с автоматным
классом, то появляется возможность наследовать новые автоматные
классы от существующих, вместе с расширенными состояниями и
нейронными сетями, что невозможно сделать при раздельной
реализации нейронной сети и автомата как представлено на рис. 6
ВЫВОДЫ ПО ГЛАВЕ 3
1. Предложен метод использования нейронных сетей в автоматах.
2. Предложено использование расширенных состояний.
3. Продемонстрировано
применение
предложенного
метода
на
примерах.
ЗАКЛЮЧЕНИЕ
В работе предложен метод совместного использования нейронных
сетей и автоматного программирования, который позволяет реализовать
заранее неопределенную логику переходов между состояниями автомата.
Применение этого метода было показано для реализации ядра автомата,
принимающего решение и в автомате у которого логика переходов между
состояниями корректируется в процессе работы автомата. Дальнейшими
направлениями исследований в данной области являются:
 анализ
применения
генетического
программирования
для
корректировки структуры используемых в расширенных состояниях
нейронных сетей;
 верификация автоматных программ, созданных с использованием
предложенного метода.
По материалам работы были сделаны доклады на конференции
SYRCoSe 2009 (28 –29 мая 2009 года, Высшая школа экономики, Москва)
и пятой ежегодной конференции CEE-SECR «Разработка ПО 2009» (28–29
октября 2009 года, Высшая школа экономики, Москва).
Таким образом, задачи исследования решены, поставленные цели
достигнуты, а результаты и материалы исследования были представлены
на научных конференциях.
ИСТОЧНИКИ
1. Хопкрофт Дж., Мотвани Р., Ульман Дж. Введение в теорию
автоматов, языков и вычислений. М.:Вильямс, 2002.
2. Непейвода Н.Н. Стили и методы программирования. М.: Интернетуниверситет информационных технологий, 2005.
3. Поликарпова Н.И., Шалыто А.А. Автоматное программирование.
СПб: Питер, 2009.
4. Царев
Ф.Н.
Разработка
метода
совместного
применения
генетического программирования и конечных автоматов на примере
игры «Летающие тарелки». СПбГУ ИТМО. Бакалаврская работа.
2007.
5. Шалыто
А.А.
Switch-технология.
Алгоритмизация
и
программирование задач логического управления. СПб: Наука, 1998.
6. Агафонов К.А., Порох Д.С., Шалыто А.А. Реализация протокола
«SMTP» на основе SWITCH-технологии. Проектная документация.
http://is.ifmo.ru/projects/smtp/
7. Аксенов С.В., Новосельцев В.Б. Организация и использование
нейронных сетей (методы и технологии).Томск: Издательство
Научно-Техничсеской литературы, 2006.
8. Розенблатт Ф. Принципы нейродинамики. Персептрон и теория
механизмов мозга. М.:Мир, 1965.
9. Минский М., Пайперт С. Персептроны. М.: Мир, 1971.
10.Дюк В., Самойленко А. "Data Mining: учебный курс", СПб: Питер,
2001. http://masters.donntu.edu.ua/2004/fvti/solomka/library/ist3.htm
11.Круглов В. В., Борисов В.В. Искусственные нейронные сети.
Теория и практика. М.: Горячая линия - Телеком, 2001.
12.Царев.
Ф.Н.
программирования,
Совместное
конечных
применение
автоматов
и
генетического
искусственных
нейронных сетей для построения системы управления беспилотным
летательным аппаратом. //Научно-Технический вестник СПбГУ
ИТМО. Выпуск 53. Автоматное программирование, с. 42-60.
13.Первушин Е.В. Применение конечных автоматов для улучшения
характеристик
нейроподобных
сетей.
СПбГУ
ИТМО.
2007.
http://is.ifmo.ru/projects/11-08-2007_pervushin_neural/
14.Тоффоли Т., Марголус Н. Машины клеточных автоматов. М.:Мир
1991
15.Терехов. С.А. Лекции по теории и приложениям искусственных
нейронных сетей. http://alife.narod.ru/lectures/neural/Neu_index.htm
16.Тимофеев К.И., Астафуров А.А., Шалыто А.А. Наследование
автоматных
классов с использованием динамических языков
программирования (на примере языка RUBY) // Информационноуправляющие системы. 2009. №4.
17.Амосов Н. М., Касаткин А. М., Касаткина Л. М., Талаев С. А.
Автоматы и разумное поведение. Опыт моделирования. Киев:
Наукова думка, 1973.
18.Gubin Y., Timofeev K., Shalyto A. Creation of Automaton Classes from
Graphical Models and Automatic Solution for Inverse Problem
/SYRCoSE. M.: 2009.
19.Библиотека
для
создания
neuro.googlecode.com/svn/trunk
нейросетей.
https://java-