Губин. Ревизия 7

УДК 681.3.06
НЕЙРО-АВТОМАТНОЕ УПРАВЛЕНИЕ
Ю. А. Губин
магистр
А. А. Шалыто
доктор технических наук, профессор
Санкт-Петербургский государственный университет информационных технологий,
механики и оптики
Существует широкий спектр подходов для создания элементов искусственного
интеллекта в прикладных программах и управляющих системах реального времени. В данной
работе предлагается реализация нейро-автоматного управления, основанного на использовании
нейронных сетей и автоматной парадигмы программирования. Рассмотрен пример применения
предлагаемого подхода.
Ключевые слова – искусственный интеллект, нейронные сети, автоматы,
управление.
There is a wide range of approaches for creating the elements of artificial intelligence in software
applications and real-time control systems. This article proposes an implementation of neuro-automata
control system, which is based on neural networks and the automata paradigm, with example usage.
Введение
Искусственный интеллект – одна из наиболее важных теоретических и прикладных
областей в информатике. Существует широкий спектр приемов и подходов для создания
элементов искусственного интеллекта в прикладных программах и управляющих
системах реального времени.
Наиболее широкое развитие в этой области получили нейронные сети [1] и
генетические алгоритмы. Особо отметим класс нейронных сетей с возможностью
самообучения. Однако их применение зависит от предметной области, и они выступают
в роли специальных объектов, задача взаимодействия с которыми возлагается на
дополнительные средства и компоненты программы.
В то же время, существует парадигма автоматного программирования [2], которая
позволяет формализовать поведение программы за счет выделения состояний и
переходов между ними. В данной работе описывается совместное использование
автоматного программирования и нейронных сетей для реализации априори
неопределенной логики переходов в автоматах [3].
Автоматы и М-автоматы
Автоматы используются для реализации поведения программ и представляются в
виде состояний, групп состояний и переходов между ними. Автомат, получая входное
воздействие, обрабатывает его и выполняет выходные воздействия (в том числе
вычисления). В качестве примера на рис. 1 представлен граф переходов автомата,
реализующего регистрацию пользователя в системе.
AdvancedUser : automaton.DSL
Activation .
Active
Pending
enter mac
Suspended.
Captcha
Unsuspended
Delete
Deleted.
Activate
Activate
Actived
enter DA
Activate
Registered.
Blocked.
Remove
Deleted.
Рис. 1. Автомат регистрации пользователей
Этот автомат состоит из нескольких состояний и групп состояний. Каждому
состоянию пользователя соответствует состояние автомата. Для того чтобы пользователь
стал зарегистрированным, он должен ввести контрольное значение (Captcha) и
персональную информацию. Администратор может заблокировать пользователя и
удалить учетную запись пользователя при необходимости.
Автоматная парадигма включает в себя методику разработки спецификации и
описания разработанных автоматов, что делает ее удобной для создания сложных
систем.
Поведение автомата зависит от внешних воздействий, заданных переходов и условий
на переходах. Следовательно, автоматная программа обычно реализует некоторое
поведение, которое заранее определено программистом при ее создании.
Размышления и принятие решений человеком – это тоже процесс, который имеет
определенный путь развития. Принятие решений производится на основе не только
внешних событий, но и оценки значений различных переменных. Часто невозможно
заранее просчитать все комбинации значений переменных и четко определить
зависимость принимаемого решения от них.
Для подобных задач в работе [4] было предложено использовать М-автоматы. Идея
их применения состоит в том, что принятие решения происходит в ходе размышления –
прохождения определенного пути в автомате. Каждый участок этого пути выделяется в
отдельное интеллектуальное состояние, которое оценивает определенный фактор и
влияет на процесс размышления.
Каждое состояние в М-автомате обладает соответствующими свойствами,
присущими определенному чувству или шагу в размышлении. Из каждого состояния Мавтомата существуют переходы в некоторые другие состояния. Эти переходы задаются
программистом на этапе проектирования модуля принятия решения.
В работе [4] описываются возможные методы для управления процессом принятия
решений в М-автоматах: алгоритмы, управляемые задаваемыми параметрами,
логические выражения и т. д. Однако конкретная реализация автоматов в этой работе не
приведена.
Авторами настоящей работы предлагается использовать нейронные сети для
реализации переходов между состояниями. М-автомат в этом случае представляет
собой совокупность небольших нейронных сетей, каждая из которых отвечает за оценку
значений определенных переменных. Такой подход целесообразно применять, так как
обучать небольшие сети значительно проще, чем большую сеть.
Использование нейронных сетей в состояниях автомата
Для реализации описанного подхода предлагается дополнить набор компонент
графов переходов автоматов расширенным состоянием, содержащим нейронную сеть.
Такие состояния в графах переходов будем обозначать пунктиром. При этом
программисту не требуется самому создавать нейронную сеть и организовывать работу с
ней, так как она формируется автоматически при создании расширенного состояния.
В данной работе используются два типа выходных воздействий. Воздействия первого
типа формируются при входе в расширенные состояния и управляют нейросетями, а
воздействия второго типа являются выходными для автомата и формируются в
«простых» состояниях.
На рис. 2 приведен пример расширенного состояния.
X1
X2
X3
Нейросеть
E1
E2
E3
Рис. 2. Пример расширенного состояния
При создании такого состояния указывается число входов и выходов сети и список
названий выходов (событий), которые формируются нейросетью.
Входные переменные, например, X1, X2, X3, которые могут быть вещественными
числами, поступают в нейросеть из стека, дополнительной памяти или от датчиков.
Нейросеть может формировать одно из событий (например, E1, E2 или E3), по
которому автомат осуществляет переход. Эти события могут и не формироваться. При
этом будет сформировано событие «Unknown» и автомат сохранит состояние. На рис. 3
представлена схема с расширенным состоянием B.
A
Start
Unknown
B
E1
C
E2
D
E3
E
Рис. 3. Использование расширенного состояния
При применении предложенного подхода появляется возможность реализовать
априори неопределенную логику переходов. На рис. 4 представлена схема автомата,
использующего расширенные состояния для управления роботом, который может
шагнуть или прыгнуть вперед.
Waiting
Not
Think!
Unknown
Unknown
Detecting state
Ready
Not
Unknown
Detecting power
Enough
power
Detecting pit
Jump
Step
Jump
Step
Рис. 4. Автомат с расширенными состояниями
Автомат содержит несколько простых состояний: Waiting – ожидание команды,
Jump – прыгнуть вперед, Step – шагнуть вперед.
Следующие его состояния являются расширенными. В них определяется: готов ли
робот к действиям (Detecting state), достаточно ли у него энергии для выполнения
срочных действий (Detecting power) и есть ли перед ним яма (Detecting pit).
Переходы соединяют расширенные состояния между собой и с другими состояниями.
Переходы из расширенных состояний срабатывают в результате работы нейронной сети.
Так, автомат при нахождении в состоянии Waiting получает событие Think! и переходит
в расширенное состояние Detecting State. После работы нейросети автомат окажется в
одном из простых состояний. Таким образом, получив одно внешнее воздействие,
автомат выполнит несколько переходов и перейдет в другое простое состояние.
Реализация
Для объектно-ориентированной реализации автоматного подхода в работе [5] была
разработана библиотека. Ее достоинством является простота создания автоматов на
языке Java. Библиотека предоставляет также средства для представления разработанных
автоматов в виде графов переходов по тексту программы.
Для реализации расширенных состояний в эту библиотеку введен класс NState,
который, в свою очередь, использует библиотеку SNeuro [6]. Последняя предоставляет
базовые интерфейсы и реализует несколько типов нейронных сетей.
Для создания экземпляра расширенного состояния необходимо наряду с его именем
передать в конструктор дополнительные параметры: размерности входного и выходного
векторов для нейронной сети, имена событий, которые могут быть сформированы этой
сетью и набор данных (значения входных переменных и выходных воздействий) для ее
обучения. Нейронная сеть будет создана и обучена при создании объекта программы,
соответствующего этому состоянию.
Как отмечалось выше, выходные воздействия первого типа могут выполняться при
входе в состояние. Они используются экземпляром состояния NState для управления
сетью, при котором входные переменные считываются из контекста автомата и
передаются на вход нейронной сети.
Важным моментом предлагаемой реализации является то, что параметры нейронных
сетей в состояниях могут быть откорректированы в процессе работы автомата. При
формировании событий состояние NState сохраняет себя, входные данные и результат в
специальной области памяти, которую была названа «памятью размышлений автомата».
Введя метод correction, который реализован в базовом классе DSL из библиотеки,
описанной в работе [5], можно провести коррекцию нейронных сетей всех состояний,
участвовавших в последнем принятии решений. Это предоставляет дополнительные
возможности для обеспечения настройки автомата.
Применение расширенных состояний
Использование расширенных состояний возможно в задачах, для решения которых
применимы нейронные сети, используемые в этих состояниях. Это может быть анализ
входных данных, распознавание образов или предсказание значений. Также
расширенные состояния можно применять в задачах, где в зависимости от входных
значений необходимо принять одно из нескольких решений или произвести
кластеризацию данных [7].
Существует ряд задач, которые не могут быть эффективно решены с использованием
нейронных сетей. Например, с каждым новым набором входных данных в процессе
обучения нейронная сеть может постоянно изменять коэффициенты узлов так, что
теряются данные для принятия правильного решения для предыдущего набора данных.
Такое возможно при реализации логической функции XOR с помощью нейронной сети.
Известны и другие проблемы нейронных сетей, например, проблема «четности» и «один
в блоке» [7].
Для того чтобы решить задачу с помощью нейронной сети, необходимо собрать и
подготовить данные для обучения, выбрать топологию сети и ее характеристики,
обучить сеть и сделать корректировку параметров обучения.
Нейронные сети используются в расширенных состояниях, но, согласно описанному
выше подходу, расширенное состояние не требует от разработчика реализации обучения,
подбора характеристик сети, параметров обучения, проверки обучения и корректировки
параметров. Поэтому можно сформулировать алгоритм, основанный на использовании
расширенных состояний:
1. Определение структуры блока принятия решений.
2. Создание графа переходов автомата, с использованием расширенных состояний
для блока принятия решений.
3. Выбор топологии нейронной сети, используемой в расширенном состоянии.
4. Сбор и подготовка данных для обучения.
5. Определение правил корректировки характеристик сети в процессе работы
автомата.
6. Проверка адекватности обучения и правил корректировки во время тестирования.
Выполняя эти действия последовательно, можно получить автомат, решающий
поставленную задачу.
Пример
Для демонстрации применения расширенных состояний реализуется автомат для
решения следующей задачи. Автомат управляет поведением ежа, который идет по
прямой и на каждом шагу находит еду, тратя на каждый шаг пять единиц энергии. Еда
может быть ядовита (энергия уменьшается на 40 единиц), а может быть полезна (энергия
увеличивается на 10, 20 или 40 единиц). Еж не должен есть ядовитую еду. Когда он
«наедается» и его энергия становится больше 100 единиц, он не должен есть еду. Еж
делает шаг, ест или пропускает еду и делает следующий шаг. Реализуем автомат
согласно описанному алгоритму.
1. Определение структуры блока принятия решений. Для того, чтобы принять
решение, съесть еду или нет, требуется определить, яд это или нет, а также установить,
наелся еж или нет, в случае, если он нашел не яд. Блок принятия решений будет состоять
из двух расширенных состояний.
2. Создание графа переходов автомата, с использованием расширенных состояний
для блока принятия решений. Зная структуру блока принятия решений и действия,
которые должен совершать еж, построим граф переходов (рис. 5).
Рис. 5. Граф переходов автомата управления ежа
Автомат имеет следующие состояния: Wait – еж ждет команду сделать шаг, Detect
Good_Bad – расширенное состояние: впереди яд или полезная еда, Detect Is Enough –
расширенное состояние (наелся еж или нет), Action – группа из двух простых состояний
(Skip – пропустить и Eat – съесть еду).
3. Выбор топологии нейронной сети, используемой в расширенном состоянии.
Расширенные состояния используют однослойные нейронные сети, являющиеся сетями
Кохонена [8]. Эти нейронные сети позволят принять решение в зависимости от
нескольких входных данных и их можно обучать.
Входные сигналы перемножаются с коэффициентами узлов сети. Полученные
выходные сигналы обрабатываются по правилу «победитель забирает все»: наибольший
сигнал превращается в единичный, остальные обращаются в ноль. Работа с нейронной
сетью выполняется в классе NState. Экземпляр класса NState создается следующим
образом:
public NState goodBad = new NState(
"Detect: Good_Bad",
2,
goodBadEvents,
HungryTrainData.goodBad());
4. Сбор и подготовка данных для обучения. Для того чтобы расширенные состояния
начали принимать правильные решения, необходимо обучить их нейронные сети. Для
этого требуется подготовить данные для обучения. Для того чтобы обучить нейронную
сеть состояния 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}};
Каждый элемент массива входных данных – массив из двух элементов: текущее
значение энергии и энергия еды, которую встречает еж. Каждый элемент массива
выходных данных – это массив из двух элементов: значения выходных значений сети
равные нулю или единице. Это используется для определения перехода, который должен
сработать в результате работы сети.
В разделе статьи «Реализация» было сказано, что в конструктор расширенного
состояния передается список сигналов. В данном случае используется следующий
список сигналов:
String [] goodBadEvents = {"GOOD", "BAD"};
Пара {0,1} означает, что второе выходное значение должно быть равно единице и
сработает переход из этого состояния по событию «BAD». Используя эту обученную
сеть, еж сможет определять яд на своем пути.
Для того чтобы обучить нейронную сеть состояния Detect Is Enough, используются
следующие два массива:
Входные данные:
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». Используя эту сеть, еж сможет
определять, наелся он или нет – может ли он есть еду.
В конструктор расширенного состояния передается название состояния, число
входных сигналов, события, по которым будут срабатывать переходы из состояния и
данные для обучения сети.
5. Определение правил корректировки характеристик сети в процессе работы
автомата. При решении данной задачи не используются правила корректировки сетей
во время работы автомата, так как данные для обучения позволяют предусмотреть
различные комбинации значений и набор входных данных ограничен. Правила
корректировки следует использовать при большом наборе входных значений.
6. Проверка адекватности обучения и правил корректировки во время
тестирования. Авторами было проведено тестирование разработанного автомата. До
обучения энергия ежа в конце пути была равна 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 и автомат начинает «думать». В результате он
попадает в одно из простых состояний группы Action.
Ниже представлен исходный код автомата, используемого в примере:
public class Hungry extends DSL{
public State wait = new State("Wait");
String [] goodBadEvents = {"GOOD", "BAD"};
String [] enoughEvents = {"YES", "NO"};
public NState goodBad = new NState(
"Detect: Good_Bad",
2,
goodBadEvents,
HungryTrainData.goodBad());
public NState enough = new NState(
"Detect: Is Enough",
2,
enoughEvents,
HungryTrainData.enough());
// Переходы
public Transition think = new Transition(
"think", "THINK", wait, goodBad);
public Transition good = new Transition(
"good", "GOOD", goodBad, enough);
public Transition poison, bad, eat, step;
public StateGroup actions = new StateGroup("Action");
public Hungry () {
goodBad.brain.train(HungryTrainData.goodBad());
enough.brain.train(HungryTrainData.enough());
Vector <Entity> sig = new Vector <Entity> ();
// Создание состояний skip, eating.
// …
// Создание переходов
poison = new Transition("Poison", "BAD", goodBad, skip);
// Создание переходов bad, eat, step
// …
}
}
Заключение
Описанный подход позволяет реализовать в автоматном программировании
элементы искусственного интеллекта за счет использования нейронных сетей.
Преимуществами нейро-автоматного управления является то, что применяются
небольшие сети, каждая из которых отвечает за определенные решения. Несколько
простых сетей обучать проще, чем одну сложную сеть, и они быстрее в работе, так как
некоторые участки «размышления» могут быть не задействованы, если процесс пошел
по другому пути.
Нейро-автоматное управление может использоваться в таких задачах, как, например,
обработка электронных платежей. При решении этой задачи можно добавить проверку
подозрительности данного платежа, основываясь на статистике платежей, которые
совершались в прошлом. Подобная возможность позволяет сократить потери и повысить
безопасность клиентов в случае утери или хищения данных для совершения платежа.
Данная работа, наряду с генетическими алгоритмами [9], является одним из методов
обучения
автоматов
и
расширяет
область
использования
автоматного
программирования.
Литература
1. http://ru.wikipedia.org/wiki/Нейросеть
2. Поликарпова Н. И., Шалыто А. А. Автоматное программирование. СПб.: Питер,
2010. http://is.ifmo.ru/books/_book.pdf
3. Штовба С. Д. Введение в теорию нечетких множеств и нечеткую логику. Сообщество
пользователей Matlab и Simulink. http://matlab.exponenta.ru.
4. Амосов Н. М., Касаткин А. М., Касаткина Л. М., Талаев С. А. Автоматы и
разумное поведение. Опыт моделирования. Киев: Наукова думка, 1973.
5. Gubin Y., Timofeev K., Shalyto A. Creation of Automaton Classes from Graphical Models
and Automatic Solution for Inverse Problem /SYRCoSE. M.: 2009.
6. Библиотека для создания нейросетей. https://java-neuro.googlecode.com/svn/trunk
7. http://dic.academic.ru/dic.nsf/ruwiki/13889
8. http://ru.wikipedia.org/wiki/Сеть_Кохонена
9. Лобанов П. Г., Шалыто А. А. Использование генетических алгоритмов для
автоматического построения конечных автоматов в задаче о флибах //Известия РАН.
Теория и системы управления. 2007. № 5.