Нечеткие вычисления при помощи переговоров программных

ВВЕДЕНИЕ ....................................................................................................................... 5
ГЛАВА 1. ОСНОВЫ МЯГКИХ И НЕЧЕТКИХ ВЫЧИСЛЕНИЙ ......................... 8
1.1 Область применения ............................................................................................ 8
1.2 Обзор основных методов мягких вычислений .................................................... 9
1.3 История развития .............................................................................................. 10
1.4 Нечеткие множества ........................................................................................ 11
1.5 Гранулирование информации ............................................................................. 13
1.6 Нечеткие и лингвистические переменные ....................................................... 13
1.7 Нечеткая логика.................................................................................................. 15
1.8 Нечеткие логические операции ......................................................................... 17
1.9 Нечеткие отношения ......................................................................................... 18
1.10 Нечеткий логический вывод............................................................................. 22
1.11 Гибриды (интеграция с интеллектуальными парадигмами) ....................... 28
ГЛАВА 2. ОСНОВЫ МУЛЬТИАГЕНТНЫХ СИСТЕМ ......................................... 32
2.1 Мультиагентное моделирование ...................................................................... 32
2.2 Применение мультиагентных систем в компьютерной анимации............... 35
2.3 Мультиагентное имитационное моделирование ............................................ 36
2.4 Совместное использование мультиагентных систем и нечеткой логики ... 38
2.5 Обзор математической теории переговоров .................................................. 39
ГЛАВА 3. ОПИСАНИЕ МУЛЬТИАГЕНТНОГО ПОДХОДА К НЕЧЕТКОМУ
ПРОГРАММИРОВАНИЮ ........................................................................................... 49
3.1 Модель нечеткие вычисления при помощи переговоров программных
агентов....................................................................................................................... 49
3.2 Реализация классического нечеткого вывода в мультиагентной
архитектуре .............................................................................................................. 50
3.3 Расширение возможностей нечеткого программирования ........................... 55
ГЛАВА 4. ПРОГРАММНАЯ РЕАЛИЗАЦИЯ И ЭКСПЕРИМЕНТЫ .................. 62
4.1 Используемые технологии.................................................................................. 62
4.2 Интерфейс работы с программными агентами ............................................ 62
4.3 Протокол сети сервисов .................................................................................... 63
4.4 Среда (Environtment) мультиагентного моделирования ................................ 64
4.5 Система переговоров ......................................................................................... 65
4.6 Описание численного эксперимента. ................................................................ 69
ЗАКЛЮЧЕНИЕ.............................................................................................................. 82
СПИСОК ЛИТЕРАТУРЫ ............................................................................................ 83
4
ВВЕДЕНИЕ
Нечеткие вычисления (Fuzzy Computing) являются одним из методов мягких
вычислений (Soft Computing), которые так же включают такие направления, как:
нейровычисления,
байесовский
вывод
генетические
и
т.д.
вычисления,
Основным
самообучающиеся
отличием
мягких
системы,
вычислений
от
традиционных, жестких является приспособление к «всеобъемлющей неточности
реального
мира». Руководящим принципом мягких вычислений
является:
«терпимость к неточности, неопределенности и частичной истинности для
достижения удобства манипулирования, низкой стоимости решения и лучшего
согласия с реальностью» [1]. Исходной моделью для мягких вычислений служит
человеческое мышление.
Мягкие вычисления применяются в тех случаях, когда эффективного четкого
решения не существует либо по причине вычислительной сложности самой задачи
(например, нечеткий эвристический алгоритм для решения задачи из NPC), либо,
когда четкое решение невозможно в силу особенностей предметной области
(например, обработка натуральных языков). Наиболее широко нечеткие вычисления
применяются для автоматизации процесса принятия решений, основанного на базе
экспертных знаний. Потому, что как правило экспертные знания (человеческий
опыт) удается выразить именно в виде набора нечетких правил. Вот основные
области применения нечетких алгоритмов:
 автоматическое/полуавтоматическое управление в экономике;
 семантический веб;
 медицина (постановка диагноза);
 ИИ для компьютерных игр;
 распознавание образов;
 автоматическое управление (например ABS в автомобиле);
 тревожные системы (предупреждения об опасности);
5
 диагностика в медицине.
Нечеткий алгоритм традиционно представляет собой набор правил вида:
IF x0 IS a0 THEN y0 IS b0
IF x1 IS a1 THEN y1 IS b1
…
или
IF condition0 THEN action0()
IF condition1 THEN action1()
…
Исполнение нечеткого алгоритма состоит из четырех этапов: фазификация
(введение нечеткости), нечеткий вывод, композиция и дефазификация (построение
четкого ответа). Алгоритмы нечеткого вывода различаются видом используемых
правил логических операций и способом дефазификации. Наиболее известны
следующие модели нечеткого вывода: Мамдани, Сугено, Ларсена, Цукамото.
В данной работе будет предложен новый
способ кодирования и
интерпретации нечетких алгоритмов. Исследуемый способ позволяет кодировать и
исполнять нечеткие инструкции более общего вида. Исполнение нечетких
инструкций осуществляется посредством эмулирования переговоров программных
агентов, что позволяет естественно и гибко формулировать нечеткие правила и
интерпретировать их. Используя мультиагентные системы таким образом, можно
разрабатывать реактивные системы с нечетким поведением. Мультиагентные
системы хорошо подходят для моделирования исполнения нечетких правил потому,
что концепция взаимодействия программных агентов ориентирована именно на
работу в условиях неточных и неполных знаний и субоптимальности поведения.
Предложенный способ позволяет получать более сложный по своей структуре
выходной результат вычислений (или способ поведения реактивной системы). Это
обеспечивается тем, что множество результатов переговоров агентов очень велико.
6
Агенты могут как прийти к единому, кооперативному решению, так и разбиться на
произвольные
коалиции.
Каждая
коалиция
при
этом
сформирует
свой,
индивидуальный план действий.
Существует
много научных работ в которых предложено обратное:
использование нечеткой логики для осуществления переговоров программных
агентов. Предложенный способ проведения нечетких вычислений ранее не
выдвигался. Нечеткие инструкции будут задаваться и интерпретироваться
посредством введения различных программных агентов и запуска процесса
переговоров. У каждого агента будет собственная, предпочтительно простая,
модель поведения и собственные интересы.
Таким образом, задача данной работы формулируется так: разработать
мультиагентную модель кодирования и исполнения нечетких правил. Разработать
правила кодирования и исполнения классических нечетких инструкций в рамках
предложенной модели. Разработать правила кодирования и интерпретации
расширенного набора конструкций типа FOR_EACH, FOR, WHILE. Опробовать
предложенную модель, разработав и реализовав нечеткий эвристический алгоритм,
нешающий NP-полную задачу о расположении факультетов (facility location
problem). Провести численный эксперимент с реализацией алгоритма и сравнить с
широко известным приближенным factor-3 алгоритмом, решающим ту же задачу.
7
ГЛАВА 1. ОСНОВЫ МЯГКИХ И НЕЧЕТКИХ ВЫЧИСЛЕНИЙ
В этой главе приводится описание основных аспектов теории мягких
вычислений и нечетких вычислений, как подраздела мягких вычислений.
Приводится обзор основных достижений науки в данной области.
1.1 Область применения
Как уже было упомянуто во введении, мягкие вычисления широко
применяются при разработке искусственного интеллекта в таких областях, как:
 автоматическое/полуавтоматическое управление в экономике;
 семантический веб;
 медицина (постановка диагноза);
 ИИ для компьютерных игр;
 распознавание образов;
 автоматическое управление (например ABS в автомобиле);
 тревожные системы (предупреждения об опасности);
 компьютерное зрение;
 распознавание речи;
 распознавание текста и рукописей;
 распознавание образов;
 поиск в мультимедийных базах данных и рекомендующие системы;
 управление неопределенностью
 диагностика в медицине.
Главным преимуществом мягких вычислений, обеспечившим успешное их
применение в разработке искусственного интеллекта, является способность
работать с неточными и неполными или частично истинными данными о реальном
мире, которые алгоритм получает на вход. Способность интерпретировать ряд
нечетких инструкций и рекомендаций экспертов, лежащий в основе логики
алгоритма. Как следствие, главным ориентиром при проектировании таких систем
8
является «терпимость к неточности, неопределенности и частичной истинности для
достижения удобства манипулирования, робастности, низкой стоимости решения и
лучшего согласия с реальностью» [1] .
1.2 Обзор основных методов мягких вычислений
Было отмечено, что мягкие вычисления — это не конкретная методология, а
группа вычислительных методов, в совокупности позволяющая разрабатывать и
развивать интеллектуальные системы. Понятие «мягкие вычисления» объдиняет
следующие подходы:
 нечеткие вычисления (Fuzzy Computing);
 нейровычисления (Neurocomputing) ;
 генетические вычисления (Genetic Programming) ;
 вероятностные вычисления (Probabilistic Computing);
 рассуждения на базе свидетельств (Evidential Reasoning) ;
 байесовская сеть доверия вывод (Bayesian Network);
 хаотические системы (Chaotic Systems) ;
 теория машинного обучения (Machine Learning).
Каждая из приведенных методологий имеет свои преимущетсва при
использования в рамках мягких вычислений. Нечеткая логика лежит в основе
методов работы с неточностью, с зернистой, гранулированной (подробнее смотри в
пункте 1.5) информацией и, что наиболее важно, вычислений со словами
(Computing with Words). Нейровычисления отражают способность к обучению,
адаптации и идентификации. В случае генетических вычислений, речь идет о
возможности систематизировать случайный поиск и достигать оптимального
значения характеристик.
для
Вероятностные
вычисления
обеспечивают
базу
управления неопределенностью и проведения рассуждений, исходящих из
свидетельств [1].
Одной
из
ключевых
особенностей
мягких
вычислений
является
9
направленность на конкурирующую взаимодополняемость различных методов. Это
означает, что часто наиболее успешного результата удается достичь только путем
совместного применения нескольких подходов с последующим сравнением и
объединением результатов вычислений.
Системы, в которых указанные методы используются в комбинации,
называются гибридными. Наиболее известными системами этого типа являются так
называемые нейро-нечеткие системы. Так же имеют место быть нечеткогенетические системы, нейро-генетические системы и нейро-нечетко-генетические
системы. Подробнее эти классы систем будут описаны в пункте 1.11 настоящей
работы.
С этой позиции подход, использующий процесс переговоров программных
агентов предоставляет естественную и гибкую архитектуру для алгоритма,
комбинирующего ряд методов мягких вычислений. Каждый метод можно
представить в виде агента, или множества агентов, которые будут производить свои
собственные вычисления с входными данными, получать собственные результаты и
оценивать их достоверность. Далее они будут производить переговорный процесс,
для формирования общего решения.
1.3 История развития
Математическая теория нечетких множеств (Fuzzy Sets) и нечеткая логика
(Fuzzy
Logic)
являются
обобщениями
классической
теории
множеств
и
классической формальной логики. Данные понятия были впервые предложены
американским ученым Лотфи Заде (Lotfi Zadeh) в 1965 г. Мотивацией появления
новой
теории
стало
осознание
свойства
нечеткости
и
приближенности
производимых человеком рассуждений при описании процессов, систем и
объектов.
Прежде чем нечеткий подход к моделированию сложных систем получил
признание во всем мире, прошло не одно десятилетие с момента зарождения
10
теории нечетких множеств. И на этом пути развития нечетких систем принято
выделять три периода. Первый период (конец 60-х–начало 70 гг.) характеризуется
развитием теоретического аппарата нечетких множеств (Л. Заде, Э. Мамдани,
Беллман). Во втором периоде (70–80-е годы) появляются первые практические
результаты в области нечеткого управления сложными техническими системами
(парогенератор с нечетким управлением).
Одновременно стало уделяться внимание вопросам построения экспертных
систем, построенных на нечеткой логике, разработке нечетких контроллеров.
Нечеткие экспертные системы для поддержки принятия решений находят широкое
применение в медицине и экономике. Наконец, в третьем периоде, который длится
с конца 80-х годов и продолжается в настоящее время, появляются пакеты
программ для построения нечетких экспертных систем, а области применения
нечеткой логики заметно расширяются. Она применяется в автомобильной,
аэрокосмической и транспортной промышленности, в области изделий бытовой
техники, в сфере финансов, анализа и принятия управленческих решений и многих
других.
Триумфальное
шествие
нечеткой
логики
по
миру
началось
после
доказательства в конце 80-х Бартоломеем Коско знаменитой теоремы FAT (Fuzzy
Approximation Theorem). В бизнесе и финансах нечеткая логика получила
признание после того как в 1988 году экспертная система на основе нечетких
правил для прогнозирования финансовых индикаторов единственная предсказала
биржевой крах. И количество успешных фаззи-применений в настоящее время
исчисляется тысячами.
Более подробную информацию можно найти в [2].
1.4 Нечеткие множества
Характеристикой нечеткого множества выступает функция принадлежности
(Membership Function). Обозначим через MFC : X  [0,1] , MFC (x)
— степень
11
принадлежности
x X
к нечеткому множеству C, представляющей собой
обобщение понятия характеристической функции обычного множества. Здесь X —
область рассуждений. Тогда нечеткое множеством С может быть задано вектором
упорядоченных пар:
C  {MFC ( x) \ x : x  X , MFC ( x)  [0,1]} .
Значение MFC ( x)  0 означает отсутствие принадлежности x к множеству X,
MFC ( x)  1 — полную принадлежность. Носителем нечеткого множества A с
областью рассуждений X является множество: {x  X : MFA ( x)  1} т. е. те элементы X,
которые полностью принадлежат A.
Проиллюстрируем это на примере неточного определения «горячий чай». В
качестве X (области рассуждений) возьмем шкалу температуры в градусах Цельсия,
она будет изменяться от 0 до 100 градусов. Нечеткое множество для понятия
«горячий чай» может выглядеть следующим образом:
C = { 0/0, 0/10, 0/20, 0.1 /30, 0.3 /40, 0.6 /50, 0.8 /60, 0.9 /70, 1/80, 1/90, 1 /100 }
Так, чай с температурой 60°С принадлежит к множеству «горячий» со степенью
принадлежности 0.8. Для одного человека чай при температуре 60°С может
оказаться горячим, для другого — не слишком горячим. Именно в этом и
проявляется нечеткость задания соответствующего множества.
Для нечетких множеств, как и для обычных, определены основные
логические операции. Самыми основными, необходимыми для расчетов, являются
пересечение

и

объединение. Пересечение двух нечетких множеств
A  B : MFA B ( x)  min( MFA ( x), MFB ( x)) .
Объединение
двух
нечетких
множеств
A  B : MFA B ( x)  max( MFA ( x), MFB ( x)) . В теории нечетких множеств разработан
общий подход к выполнению операторов пересечения, объединения и дополнения,
реализованный
в так
называемых
треугольных нормах и
конормах [3].
Приведенные выше реализации операций пересечения и объединения — наиболее
распространенные случаи.
12
1.5 Гранулирование информации
Ранее говорилось, что нечеткие вычисления оперируют с гранулированной
информацией (Information Granulation), вычисления производятся со словами, а не с
числами. Гранулирование информации — есть процесс объединения схожих точек
или объектов в одну группу.
Тогда нечеткость подобных групп есть прямое
следствие нечеткости понятия сходства. Простыми примерами таких групп
являются понятия «средний возраст», «деловая часть города» и др. Отметим, что
стремление объединять схожие по свойствам объекты в одну группу характерно для
человеческих рассуждений. Понятие гранулированной информации находят свое
отражение в теории нечетких вычислений в терминах нечеткой и лингвистической
переменной [4].
1.6 Нечеткие и лингвистические переменные
Целью введения нечеткого множества чаще всего является формализация
нечетких понятий и отношений естественного языка. Данную формализацию
можно выполнить, воспользовавшись понятиями нечеткой и лингвистической
переменных.
Нечеткая переменная описывается набором  X , N , A  , где N —
название переменной, X — универсальное множество (синоним область
рассуждений), A — нечеткое множество на X. Понятие лингвистической
переменной строится на базе нечеткой переменной, т.е. лингвистическая
переменная находится на более высоком уровне [4].
Формально: лингвистическая переменная задается пятеркой  N , T , X , G, M  ,
где N — имя переменной; T — терм-множество, каждый элемент которого (терм)
представляется, как нечеткое множество на универсальном множестве X; G —
синтаксические правила, часто в виде формальной грамматики, порождающие
название
термов;
M
—
семантические
правила,
задающие
функции
принадлежности нечетких термов, порожденных синтаксическими правилами G.
Таким образом T — множество нечетких переменных (возможно бесконечное)
13
имена переменных из T порождаются грамматикой G, а функции принадлежности
— семантическими правилами M.
Существует большое разнообразие типовых форм кривых для задания
функций принадлежности. Наибольшее распространение получили: треугольная,
трапецеидальная и гауссова функции принадлежности [5].
Рассмотрим такое нечеткое понятие как «температура чая». Это и есть
название лингвистической переменной. Сформируем для нее базовое терммножество, которое будет состоять из трех нечетких переменных:
T(base) = {«холодный», «теплый», «горячий»}
и зададим область рассуждений в виде X = [0, 100] (градусы цельсия). В
предыдущем примере рассматривался дискретное множество X, а функция
принадлежности задавалась набором: ключ, значение. Здесь универсальное
множество непрерывно, а функция принадлежности действует из [0, 100] в [0, 1].
В качестве грамматики G разрешим названиям лингвистических переменных
иметь модификаторы: «очень», «не», «слегка». Модификаторы можно повторять
несколько раз и комбинировать, например «слегка не очень очень горячий» чай. А
также разрешим термы (возможно с модификаторами) соединять связками «и»,
«или», например: «теплый или слегка горячий»
чай. Таким образом T будет
состоять из базовых термов и всего, что можно породить из T(base) при помощи
указанной грамматики G.
В качестве функции принадлежности для каждого лингвистического терма из
базового
терм-множества
T
возьмем
треугольную
кривую,
определяемую
формулой:
 bt
1  b  a , a  t  b

MF (t )   t  b
1  c  b , b  t  c
 0 ,
иначе
a, b, c — параметры кривой, для терма «холодный» возьмем: (a = 0, b = 0, c = 40)
«теплый»: (a = 30, b = 60, c = 80), «горячий»: (a = 70, b = 100, c = 100).
14
Наконец зададим семантику M:
MFочень LV ( x)  MFLV ( x) 2
MFслегка LV ( x)  MFLV ( x)1/ 2
MFне LV ( x)  1  MFLV ( x)
MFA и B ( x)  min( MFA ( x), MFB ( x))
MFA или B ( x)  max( MFA ( x), MFB ( x))
Здесь
модификаторы
«очень»,
«слегка»
используются
с
семантикой
ослабления / усиления терма к которому они относятся. Соответствующие им
операции возведения в квадрат / извлечения корня называются операциями
концентрации/растяжения соответственно.
Более подробную информацию можно найти в[2, 3, 5].
1.7 Нечеткая логика
В данном разделе речь пойдет о месте нечеткой логики в мягких
вычислениях. Термин нечеткая логика используется в двух различных смыслах. В
узком смысле, нечеткая логика — это логическая система, являющаяся
расширением многозначной логики. Однако, даже для нечеткой логики в узком
смысле, список основных операций очень отличается как по духу, так и по
содержанию от списка основных операций для систем многозначных логик.
В широком смысле, нечеткая логика равнозначна теории нечетких множеств,
т.е. классов с неточными, размытыми границами [6]. Таким образом, нечеткая
логика, понимаемая в узком смысле, является разделом нечеткой логики в широком
смысле.
Важной характеристикой нечеткой логики является то, что любая теория Th
может быть фаззифицирована (Fuzzified) и, следовательно, обобщена путем замены
понятия четкого множества в Th понятием нечеткого множества. Таким способом
можно прийти к нечеткой арифметике, нечеткой топологии, нечеткой теории
вероятностей и т. д. Выигрышем от фаззификации является большая общность и
15
лучшее соответствие модели действительности. Однако с нечеткими числами
труднее оперировать. Более того, значения большинства нечетких понятий зависят
от контекста и/или приложения. Это та цена, которую необходимо заплатить за
лучшее согласие с реальностью. Более подробную информацию можно найти в
оригинальной статье [1].
Особое место в нечеткой логике занимает лингвистическая переменная
«истинность». В классической логике истинность может принимать только два
значения: истинно и ложно. В нечеткой логике истинность размытая. Нечеткая
истинность определяется аксиоматически, причем разные авторы делают это поразному. Интервал [0, 1] используется как универсальное множество для задания
лингвистической переменной «истинность». Обычная, четкая истинность может
быть представлена нечеткими множествами-синглтонами. В этом случае четкому
понятию истинно будет соответствовать функция принадлежности
0, u  1
0, u  0
, а четкому понятию ложно MFистинно(u )  
, u  [0,1] .
MFистинно(u )  
1, u  1
1, u  0
Для
задания
нечеткой
истинности
Заде предложил такие
функции
принадлежности термов «истинно» и «ложно»:


0ua
0,
  u  a  2
a 1
MFистинно(u )  2  
au
,
 ,
2
  1 a 
2

 u 1 a 1
 u 1
1  2  
 ,
2

1 a 
MFложно (u )  MFистинно(1  u ) для u  [0,1] .
Здесь a  [0,1] — параметр, определяющий носители (смотри пункт 1.4) нечетких
множеств «истинно» и «ложно». Для нечеткого множества «истинно» носителем
будет полуоткрытый интервал (a, 1], а для нечеткого множества «ложно» — [0, a).
Функции принадлежности нечетких термов «истинно» и «ложно» изображены на
рис. 1. Они построены при значении параметра a = 0.4. Как видно, графики
функций принадлежности термов «истинно» и «ложно» представляют собой
16
зеркальные отображения [7].
Рис. 1. лингвистическая переменная « истинность» по Зайде.
1.8 Нечеткие логические операции
Вначале кратко напомнить основные положения обычной (булевой) логики.
Рассмотрим два утверждения A и B, каждое из которых может быть истинным или
ложным, т.е. принимать значения 1 или 0. Для этих двух утверждений всего
существует 24 = 16 различных логических операций, из которых содержательно
интерпретируются
лишь
пять:
AND,
OR,
XOR,
→
(импликация),
=
(эквивалентность).
Предположим, что логическое утверждение может принимать не два значения
истинности, а три, например: «истинно», «ложно» и «неопределенно». В этом
случае мы будем иметь дело не с двухзначной, а трехзначной логикой. Общее
количество бинарных операций, а, следовательно, и таблиц истинности, в
трехзначной логике равно 39.
Нечеткая логика является разновидностью многозначной логики, в которой
значения истинности задаются лингвистическими переменными или термами
лингвистической переменной «истинность». Правила выполнения нечетких
17
логических операций получают из булевых логических операций с помощью
принципа обобщения.
Обозначим нечеткие логические переменные через A и B, а функции
принадлежности, задающие истинностные значения этих переменных через MFA(u)
и MFB(u), u  [0 .. 1]. Нечеткие логические операции AND, OR, XOR, →
(импликация) выполняются по таким правилам:
MFA AND B (u )  min( MFA (u ), MFB (u ))
MFA OR B (u )  max( MFA (u ), MFB (u ))
MFA XOR B (u )  max( MFA (u ), MFB (u ))  min( MFA (u ), MFB (u ))
MFA  B (u )  max( 1  MFA (u ), MFB (u ))
В многозначной логике логические операции могут быть заданы таблицами
истинности. В нечеткой логике количество возможных значений истинности может
быть бесконечным, следовательно, в общем виде табличное представление
логических операций невозможно. Однако в табличной форме можно представить
нечеткие логические операции для ограниченного количества истинностных
значений,
например,
для
терм-множества
{«истинно»,
«очень истинно»,
«не истинно», «более-менее ложно», «ложно»} [5].
1.9 Нечеткие отношения
Прежде чем ввести понятие нечеткого отношения, вспомним обычные
отношения и их свойства.
Отношением R на множествах X, Y называется некоторое подмножество
декартова произведения X×Y. Через IndR обозначим индикаторную функцию
отношения R:
1,  x, y  R
Ind R ( x, y )  
.
0, иначе
Индикаторная функция однозначно задает отношение. Следовательно, если
множество X, Y конечны, то отношение R можно задать матрицей со значениями
18
{0, 1}: R = ri , j .
Пусть заданы два отношения A и B. Тогда рассмотрим отношение C=A B,
которое является объединением двух отношений, его индикаторной функцией будет:
IndC(<x, y>) = max(IndA(<x, y>), IndB(<x, y>)).
Пересечением
отношений
A,
B
называется D = A  B, при IndD(<x, x>) = min(IndA(<x, y>), IndB(<x, y>)). Говорят,
что отношение B включает в себя отношение A, если для соответствующих
множеств A  X×Y и B  X×Y выполняется условие A  B. Если между X и Y
существует отношение R, то обратным к нему называется такое отношение R-1, что
x R-1 y тогда и только тогда, когда не y R x.
Произведение (композиция) отношений A⋅B для A заданном на X×Y, B — на
Y×Z, C = A  B — на Y×Z определяется следующим образом:
IndC(<x, z>) = IndA B(<x, z>) = 1, x  X z  Z,
если существует y  Y: IndA(<x, y>) = 1 и IndB(<y, z>).
Основные свойства отношений:
1. Отношение R на X×X рефлексивно, если IndR(<x, x>) = 1 для любого x X;
2. Отношение R на X×X антирефлексивно, если IndR(<x, x>) = 0 для любого
x  R;
3. Отношение R симметрично, если из того, что IndR(<x, y>) = 1 следует
IndR(<y, x>) = 1;
4. Антисимметрично, если из того, что IndR(<x, y>) = 1 следует IndR(<y, x>) = 0.
5. Для транзитивного отношения выполняется следующее условие: R⋅R⊆R
Теперь введем понятия нечеткого отношения и рассмотрим его свойства.
Нечетким отношением R на универсальном множестве X×Y называется нечеткое
подмножество декартова произведения X×Y, которое характеризуется такой
функцией принадлежности µR(<x, y>): X×Y → [0, 1] (нечеткий аналог IndR(<x, y>)).
Причем µR(<x, y>) принимается как субъективная мера выполнения отношения x R y.
Аналогично строятся n-арные отношения, как нечеткое подмножество декартова
19
произведения универсальных множеств: U1, …, U1n. Если нечеткое отношение R
строится на конечных X×Y, то его функция принадлежности µR(<x, y>) задается в виде
матрицы R = ri , j , с элементами rij  [0, 1].
Пусть на множестве X×Y заданы два нечетких отношения A и B с функциями
принадлежности µA , µB. Тогда множество C = A  B — объединение A, B задается
функцией принадлежности:
µС(<x, y>) = max{µA(<x, y>), µB(<x, y>)}
Аналогично множество D = A ∩ B является пересечением нечетких множеств
A и B, если:
µD(<x, y>) = min{µA(<x, y>), µB(<x, y>)}
Нечеткое отношение B включает в себя (или содержит) нечеткое отношение
A (A ⊂ B), если для них выполняется соотношение:
µA(<x, y>) ≤ µB(<x, y>),  x  X,  y  Y
Нечеткое отношение R — дополнение к R, если:
µ R (  x, y  )  1  µ R (  x, y  )
R-1 — обратное к R (на X×X), если:
µR1 ( x, y )  1  µR ( y, x ) при x,y  X
Первая проекция R(1) нечеткого отношения R определяется функцией
принадлежности:
µ R(1) ( x)  max (µ R ( x, y ))
yY
Аналогично, вторая проекция:
µ R( 2 ) ( y )  max (µ R ( x, y ))
xX
Вторая проекция первой проекции (или наоборот) называется глобальной
проекцией нечеткого отношения и обозначается h(R). Таким образом:
20
h(R )  max max (µ R ( x, y ))  max max (µ R ( x, y ))
xX
yY
yY
xX
Если h(R) = 1 — отношение нормально, если h(R) < 1 — субнормально.
Важное значение в теории нечетких множеств имеет композиция (или
произведение) нечетких отношений. В отличие от обычных (четких) отношений
композицию (произведение) нечетких отношений можно определить разными
способами.
Максиминная композиция нечетких отношений A и B характеризуется
функцией принадлежности:
µAB ( x, z )  max min( µ A ( x, y ), µ B ( y, z ))
yY
Минимаксная композиция нечетких отношений A и B обозначается A°B и
определяется функцией принадлежности:
µ AB ( x, z )  min max( µ A ( x, y ), µ B ( y, z ))
yY
Максимультиплекативная композиция нечетких отношений A и B:
µ AB ( x, z )  sup{(µ A ( x, y )  µ B ( y, z )}
yY
Свойства нечетких отношений:
1. Нечеткое отношение R называется рефлексивным на X×Y, если:
µR(<x, x>) = 1,  x  X
2. Нечеткое отношение R антирефлексивно, если
µR(<x, x>) = 0,  x  X
3. Нечеткое отношение R симметрично, если
µR(<x, y>) = µR(<y, x>),  x  X,  y  Y
4. R (на X×X) антисимметрично, если верно:
µR(<x, y>) ≠ µR(<y, x>) или µR(<x, y>) = µR(<y, x>)=0
для  x,y  X
5. R (на X×X) совершенно антисимметрично, если:
из того, что µR(<x , y>) > 0 следует µR(<y, x>) = 0, для  x ≠ y  X
6. R транзитивно, если верно:
21
µR ( x, z )  max min( µ R ( x, y ), µ R ( y, z ))
yY
для  x, y, z  X
Пусть R — нечеткое отношение на X×X. Определим:
R2 = R×R,
µR 2 ( x, z )  max min( µ R ( x, y ), µ R ( y, z ))
yY
Заметим, что существует эквивалентное определение транзитивности:
R=R × R
Аналогично, пусть:
R(k) = R×R(k-1)
Несложно доказать, что: R(k-1)  R(k)
Транзитивным замыканием R* отношения R называется нечеткое отношение с
функцией принадлежности:
µ R* ( x, z )  sup{µ Rk ( x, y )}
k
Несложно убедиться, что это будет минимальное отношение (в смысле нечеткого
включения множеств), которое обладает свойством транзитивности и R=R*.
Доказательство смотри в [5].
Нечетким отношением предпорядка называют бинарное нечеткое отношение,
обладающее свойствами транзитивности и рефлексивности. Для таких отношений
верно: если R — транзитивно и рефлексивно (т. е. предпорядок), то Rk = R,  k.
Нечетким отношением порядка называется бинарное отношение, которое:
рефлексивно; транзитивно; антисимметрично.
Более подробно смотри в [5].
1.10 Нечеткий логический вывод
Основой для проведения операции нечеткого логического вывода является
база правил, содержащая нечеткие высказывания в форме «IF-THEN» и функции
принадлежности для соответствующих лингвистических термов. Эти правила
имеют структуру:
22
IF <fuzzy condition> THEN var_out IS val_out
<fuzzy condition>
—
является
нечетким
условием
(нечетким
логическим
выражением) и задается грамматикой:
<fuzzy condition> =
<fuzzy check> ||
<fuzzy condition> <operator> <antecedent>
<antecedent> = <fuzzy variable> IS <linguistic variable>
<operator> = OR || AND
<fuzzy variable> — нечеткая переменная
<linguistic variable> — лингвистическая переменная, смотри пункт 1.6.
Переменные из <fuzzy condition> называются посылками нечеткого
правила. Говорят, что это правило указано для переменной var_out. Выражение
вида var_0 IS val_0, обозначенное в грамматике <antecedent> называется
антецедентом. Набор таких нечетких правил называется нечеткой базой знаний. В
большинстве
случаев
<fuzzy condition>
имеет
тривиальный
вид:
var_0 IS val_0. Более сложные нечеткие условия, как правило, записывают в
дизъюнктивной нормальной форме (ДНФ), т. е. В выражении вида:
(var_0 IS val_0) OR
(var_1 IS val_1 AND var_2 IS val_2 AND var_3 IS val_3 … )… .
При осуществлении нечеткого логического вывода выделяют следующие
классы переменных: входные переменные — являются исходными данными
логического вывода, известны еще до начала вычислений; выходные переменные —
так же вычисляются в процессе вывода, являются результатом вычислений. При
этом должны соблюдаться следующие условия:

существует хотя бы одно правило для каждого лингвистического терма
выходной переменной;

для любого терма входной переменной имеется хотя бы одно правило, в
23
котором
этот
терм
используется
в
качестве
предпосылки
(<fuzzy condition>).
В противном случае имеет место неполная база нечетких правил. Если значение
выходной переменной в правиле задано нечетким множеством, тогда правило
может быть представлено в виде нечеткого отношения. Например:
IF tчая IS горячий THEN tчая
5 минут назад
IS очень горячий
задается нечетким отношением на множестве [0°С .. 100°С]×[0°С .. 100°С]. Для
расчета нечеткого отношения можно применять нечеткую импликацию [5].
Следует отметить различие в трактовках присваивания переменным значений
при исполнении нечетких и классических программ. В классическом алгоритме
переменная имеет в точности то значение, которое ему присвоено в последней
конструкции «IF-THEN» с истинным условием. В случае исполнения нечеткого
алгоритма, последовательные правила «IF-THEN» из набора нечетких инструкций
равноправны не зависимо от порядка. Значения выходных переменных зависят
лишь от степени достоверности нечетких условий правил. В случае если степень
уверенности эксперта в адекватности различных правил из базы непостоянна,
каждому правилу можно приписать соответствующий весовой коэффициент. В
этом случае порядок нечетких правил в базе по-прежнему роли не играет.
Пусть в базе правил имеется m правил вида:
R1: IF x1 IS A11 AND ... xn IS A1n THEN y IS B1
...
Rk: IF xk IS Ak1 AND ... xn IS Akn THEN y IS Bk
...
Rm: IF xm IS Am1 AND ... xn IS Amn THEN y IS Bm
где xj, j=1..n — входные переменные; y — выходная переменная; Aik —
заданные нечеткие множества с функциями принадлежности. Результатом
нечеткого вывода является четкое значение переменной y на основе заданных
24
четких значений xk, k=1..n.
Вот общая схема процесса нечеткого вывода:
1 Фаззификация. С помощью функций принадлежности всех термов
входных лингвистических переменных и на основании задаваемых четких значений
из универсумов входных лингвистических переменных определяются степени
уверенности в том, что выходная лингвистическая переменная принимает
конкретное значение.
2 Нечеткий вывод. На основании набора правил — нечеткой базы знаний
вычисляется значение истинности для предпосылки каждого правила на основании
конкретных нечетких операций, соответствующих конъюнкции или дизъюнкции
термов в левой части правил. В большинстве случаев это либо максимум, либо
минимум из степеней уверенности термов, вычисленных на этапе фаззификации,
который применяется к заключению каждого правила. Используя один из способов
построения
нечеткой
импликации,
мы
получим
нечеткую
переменную,
соответствующую вычисленному значению степени уверенности в левой части
правила и нечеткому множеству в правой части правила.
Обычно в качестве вывода используется минимизация или правила
продукции. При минимизирующем логическом выводе выходная функция
принадлежности ограничена сверху в соответствии с вычисленной степенью
истинности посылки правила (нечеткое логическое И). В логическом выводе с
использованием продукции выходная функция принадлежности масштабируется с
помощью вычисленной степени истинности предпосылки правила.
3 Композиция (агрегация, аккумуляция).
Все
нечеткие
множества,
назначенные для каждого терма каждой выходной лингвистической переменной,
объединяются вместе, и формируется единственное нечеткое множество —
значение
для
каждой
выводимой
лингвистической
переменной.
Обычно
достаточно
большое
используются функции MAX или SUM.
4 Дефаззификация
(необязательный).
Имеется
25
количество методов перехода к точным значениям. Два примера общих методов —
«методы
полной интерпретации» и «по
максимуму». В методе полной
интерпретации точное значение выводимой переменной вычисляется как значение
«центра тяжести» функции принадлежности для нечеткого значения. В методе
максимума в качестве точного значения выводимой переменной принимается
максимальное значение функции принадлежности.
Данный
этап
является
опциональным
(необязательным)
и
включается/исключается в зависимости от того, какого рода значения выводимых
лингвистических переменных требуется получить: четкого, или нечеткого.
[http://www.intuit.ru/department/ds/fuzzysets/10/3.html]
Разработан и исследован целый ряд моделей нечеткого вывода, наиболее
известны среди них: Мамдани [5], Сугено [8], Ларсена [9], Цукамото [10].
В нечеткой логике нечеткие правила играют центральную роль в языке
нечетких зависимостей и команд (Fuzzy Dependency and Command Language,
FDCL). С неформальной точки зрения, это как раз тот язык, который используется в
большинстве приложений нечеткой логики. При сравнении нечеткой логики с
другими методологиями ключевой момент состоит в том, что нечеткий алгоритм
обычно представляет собой человеческое решение, выраженное в FDCL. Здесь
вполне понятным примером может служить задача парковки автомобиля, в которой
целью является установка автомобиля рядом с обочиной и почти параллельно ей.
Нечетко-логическим решением проблемы парковки был бы набор нечетких
«IF-THEN» — правил, которые описывают то, как человек паркует автомобиль.
Напротив, проблему парковки тяжело решить при помощи классического
управления, поскольку в нем отправной точкой является не человеческое решение,
а описание конечного состояния, начального состояния, ограничений и уравнений
движения.
Другим примером, иллюстрирующим суть гранулирования информации,
является следующий. Рассмотрим ситуацию, в которой субъект A разговаривает по
26
телефону с субъектом B, которого A не знает. За короткое время разговора, скажем,
за 10-20 секунд, A может сформировать грубую оценку возраста B, выраженную,
например, следующим образом: «Вероятность того, что B очень молодой, очень
малая», «Вероятность того, что B молодой, малая», «Вероятность того, что B
средних лет, большая», «Вероятность того, что B старый, малая», «Вероятность
того, что B очень старый, очень малая».
Эти оценки могут интерпретироваться как гранулярное (смотри 1.5)
представление распределения P возраста B. В символической форме P может быть
представлено так:
P = {«очень малая»\«очень молодой» + «малая»\«молодой» +
«большая»\«средних лет» + «малая»\«старый» + «очень малая»\«очень старый»}
В этом выражении + означает оператор объединения, а терм типа «малая\старый»
означает, что «малая» есть лингвистическая вероятность того, что B — «старый».
Важным моментом является то, что человек может формировать такие
оценки, используя лингвистические, т.е. гранулированные значения возраста и
вероятностей. В то же время человек не может думать на основе численных оценок
в форме «Вероятность того, что субъекту B 25 лет равна 0.012». Следует заметить,
что во многих случаях человек оценил бы возраст B термином «средних лет»,
опуская его вероятность.
Гранулирование информации лежит в центре человеческих рассуждений,
взаимодействий и формирования понятий. В рамках нечеткой логики оно играет
ключевую роль в вычислениях со словами (Computing with Words CW). Вычисления
со словами можно рассматривать как один из наиболее важных результатов
нечеткой логики. При вычислениях со словами объектами вычислений являются
слова, а не числа, причем слова играют роль меток Гранул.
Для различных моделей нечеткого вывода разработаны и реализованы
алгоритмы их реализующие, смотри [11] и ссылки в этой работе. Существует ряд
бесплатно распространяемых и коммерческих программных реализаций нечеткого
27
вывода: DotFuzzy (.NET), jFuzzyLogic (Java), pyfuzzy (Python) и др.
1.11 Гибриды (интеграция с интеллектуальными парадигмами)
Гибридизация методов интеллектуальной обработки информации — одно из
основных направлений исследования в области ИИ 90-х годов.
В результате объединения нескольких технологий искусственного интеллекта
появился специальный термин — «мягкие вычисления» (Soft Computing), который
ввел Л. Заде в 1994 году. В настоящее время мягкие вычисления объединяют такие
области как: нечеткая логика, искусственные нейронные сети, вероятностные
рассуждения и эволюционные алгоритмы. Они дополняют друг друга и
используются
в
различных
комбинациях
для
создания
гибридных
интеллектуальных систем. Влияние нечеткой логики оказалось, пожалуй, самым
обширным. Подобно тому, как нечеткие множества расширили рамки классической
математическую теорию множеств, нечеткая логика «вторглась» практически в
большинство методов Интеллектуальный анализ данных (Data Mining), наделив их
новой функциональностью. Ниже приводятся наиболее интересные примеры таких
объединений.
Нечеткие нейронные сети (Fuzzy-Neural Networks) осуществляют выводы
на основе аппарата нечеткой логики, однако параметры функций принадлежности
настраиваются с использованием алгоритмов обучения НС. Поэтому для подбора
параметров таких сетей применим метод обратного
распространения ошибки,
изначально предложенный для обучения многослойного персептрона. Для этого
модуль нечеткого управления представляется в форме многослойной сети. Нечеткая
нейронная сеть как правило состоит из четырех слоев: слоя фазификации входных
переменных, слоя агрегирования значений активации условия, слоя агрегирования
нечетких правил и выходного слоя.
Наибольшее распространение в настоящее время получили архитектуры
нечеткой НС вида ANFIS и TSK. Доказано, что такие сети являются
28
универсальными
аппроксиматорами.
Быстрые
алгоритмы
обучения
и
интерпретируемость накопленных знаний — эти факторы сделали сегодня нечеткие
нейронные сети одним из самых перспективных и эффективных инструментов
мягких вычислений.
Адаптивные нечеткие системы (Adaptive Fuzzy Systems). Классические
нечеткие системы обладают тем недостатком, что для формулирования правил и
функций принадлежности необходимо привлекать экспертов той или иной
предметной области, что не всегда удается обеспечить. Адаптивные нечеткие
системы решают эту проблему. В таких системах подбор параметров нечеткой
системы производится в процессе обучения на экспериментальных данных.
Алгоритмы обучения адаптивных нечетких систем относительно трудоемки и
сложны по сравнению с алгоритмами обучения нейронных сетей, и, как правило,
состоят из двух стадий:
1. Генерация лингвистических правил;
2. Корректировка функций принадлежности.
Первая задача относится к задаче переборного типа, вторая — к оптимизации в
непрерывных пространствах. При этом возникает определенное противоречие: для
генерации нечетких правил необходимы функции принадлежности, а для
проведения нечеткого вывода — правила. Кроме того, при автоматической
генерации
нечетких
правил
необходимо
обеспечить
их
полноту
и
непротиворечивость. Значительная часть методов обучения нечетких систем
использует генетические алгоритмы (Genetic Fuzzy Systems) [12, 13, 14].
Нечеткие запросы к базам данных (Fuzzy Queries) — перспективное
направление в современных системах обработки информации. Данный инструмент
дает возможность формулировать запросы на естественном языке, например:
«Вывести список недорогих предложений о съеме жилья близко к центру города»,
что невозможно при использовании стандартного механизма запросов. Для этой
цели разработана нечеткая реляционная алгебра и специальные расширения языков
29
SQL для нечетких запросов [15].
Нечеткие ассоциативные правила (Fuzzy Associative Rules) — инструмент
для извлечения из баз данных закономерностей, которые формулируются в виде
лингвистических высказываний. Здесь введены специальные понятия нечеткой
транзакции, поддержки и достоверности нечеткого ассоциативного правила.
Нечеткие когнитивные карты (Fuzzy Cognitive Maps) используются для
моделирования
причинных
взаимосвязей,
выявленных
между
концептами
некоторой области. В отличие от простых когнитивных карт, нечеткие когнитивные
карты представляют собой нечеткий ориентированный граф, узлы которого
являются нечеткими множествами. Направленные ребра графа не только отражают
причинно-следственные связи между концептами, но и определяют степень
влияния (вес) связываемых концептов.
Активное использование нечетких когнитивных карт в качестве средства
моделирования систем обусловлено возможностью наглядного представления
анализируемой системы и легкостью интерпретации причинно-следственных
связей между концептами. Основные проблемы связаны с процессом построения
когнитивной карты, который не поддается формализации. Кроме того, необходимо
доказать, что построенная когнитивная карта адекватна реальной моделируемой
системе. Для решения данных проблем разработаны алгоритмы автоматического
построения когнитивных карт на основе выборки данных [16, 17 , 18].
Нечеткая кластеризация (Fuzzy Clustering) в отличие от четких методов
(например, нейронные сети Кохонена), позволяют одному и тому же объекту
принадлежать одновременно нескольким кластерам, но с различной степенью.
Нечеткая кластеризация во многих ситуациях более «естественна», чем четкая,
например, для объектов, расположенных на границе кластеров. Наиболее
распространены: алгоритм нечеткой самоорганизации c-means и его обобщение в
виде алгоритма Густафсона-Кесселя [19, 20, 21].
Список можно продолжить и дальше: нечеткие деревья решений, нечеткие
30
сети Петри, нечеткая ассоциативная память, нечеткие самоорганизующиеся карты
и другие гибридные методы.
31
ГЛАВА 2. ОСНОВЫ МУЛЬТИАГЕНТНЫХ СИСТЕМ
2.1 Мультиагентное моделирование
Вычислительные мультиагентные модели применяются для имитирования
поведения, действий и взаимодействий автономных индивидуумов (называемых
агентами), объединённых в систему. Целью моделирования является оценка
влияния поведения каждого агента на систему в целом. Имитирование действий
каждого агента позволяет воспроизводить и предсказывать поведение системы.
Предполагается, что каждый агент действует исключительно в своих интересах,
повышает свою экономическую прибыль (в экономических моделях), или свой
социальный статут (при социологическом моделировании).
Считается, что каждый агент обладает ограниченными знаниями о системе. В
процессе
моделирования
агенты
могут
накапливать
опыт,
обучаться
и
самовоспроизводиться.
Принято считать, что мультиагентные модели берут свое начало с
вычислительных машин Джон фон Неймана (Von Neumann), являющихся
теоретическими машинами, способными к воспроизводству. Джон фон Нейман
предложил использовать машины, которые следуют детальным инструкциям для
создания точных копий самих себя.
Впоследствии подход был усовершенствован другом фон Неймана
—
Станиславом Уламом, который предложил изображать машину на бумаге — в
качестве набора клеток на решетке. Данный подход стал началом развития
клеточных автоматов. Наиболее известной реализацией клеточного автомата стала
игра «Жизнь», предложенная Джоном Хортоном Конвеем (John Horton Conway),
отличающаяся от машины фон Неймана достаточно простыми правилами
поведения агентов.
Использование мультиагентных моделей для социальных систем взяло свое
начало с работы программиста Крега Рейнолдса (Craig Reynolds), в которой он
32
предпринял попытку моделирования деятельности
живых
биологических
агентов (модель «Artificial life» — Искусственная жизнь).
В основе мультиагентных моделей лежат три основные идеи:
 объектная ориентированность;
 обучаемость агентов (или их эволюция);
 сложность вычислений.
Доминирующим методологическим подходом является подход, при котором
вычисляется равновесие или псевдоравновесие системы, содержащей в себе
множество агентов. При этом, сами модели, используя простые правила поведения,
могут выдавать весьма интересные результаты, отвечающий целям разработчика.
Здесь стоит особо упомянуть теорию Гегеля о хитрости разума, которая точно
выражает
идею
мультиагентных
систем:
«хитрость
исторического
разума
заключается в опосредствующей деятельности, которая, дав объектам действовать
друг на друга соответственно их природе и истощать себя в этом воздействии, не
вмешиваясь вместе с тем непосредственно в этот процесс, все же осуществляет
лишь свою собственную цель» [22].
Мультиагентные модели состоят из динамически взаимодействующих по
определенным правилам агентов и среды, в которой они взаимодействуют. Среда
может быть достаточно сложной.
Основные свойства агентов:
 Интеллектуальность. В то же время, это свойство должно быть умеренным
для того, чтобы агенты не могли познать нечто большее, выходящее за рамки
правил игры.
 Наличие жизненной цели. Расположение во времени и пространстве. Имеется
ввиду некоторая «среда обитания», которая может быть представлена и в виде
решетки (как в игре «Жизнь»), так и в виде более сложной структуры.
Иногда, результат взаимодействия агентов в «среде обитания» — равновесие,
иногда — непрекращающийся процесс эволюции, а иногда — бесконечный цикл
33
без определенного решения. Считается, что мультиагентное моделирование
дополняет традиционные аналитические методы. Последние позволяют нам
охарактеризовать равновесие системы, а моделирование позволяет исследовать
возможность получения такого состояния.
Мультиагентные модели могут объяснить причину возникновения таких
явлений как:
 террористические организации;
 войны;
 обрушения рынка акций.
В идеале, мультиагентные модели могут помочь идентифицировать критические
моменты времени, после наступления которых, чрезвычайные последствия будут
иметь необратимый характер.
С середины 1990-х годов, мультиагентные модели стали использовать для
решения множества коммерческих и технологических проблем. Примерами могут
послужить задачи:
 оптимизации сети поставщиков;
 логистика;
 моделирования
потребительского поведения
(в том числе социальные
сети);
 распределенных вычислений;
 менеджмента трудовых ресурсов;
 управления транспортом;
 управления инвестиционными портфелями.
В этих и других приложениях стратегии поведения определяются с учетом
поведения множества индивидуальных агентов-атомов и их взаимодействий. Таким
образом,
мультиагентные
модели
могут
помочь
в
изучении
влияния
индивидуального поведения агентов на эволюцию всей системы.
34
2.2 Применение мультиагентных систем в компьютерной анимации
За последнее десятилетие ряд известных компаний, занятых в области кино и
анимации выпустили программные продукты для генерации батальных сцен с
участием огромного количества персонажей. Так, например, студия Pixar выпустила
Renderman, Digital Domain — Nuke. Наконец уникальный 3D пакет MASSIVE был
выпущен компанией Weta Digital. Далее речь пойдет именно о нем.
MASSIVE (Multiple Agent Simulation System in Virtual Environment) —
программный пакет, базирующийся на использовании искусственного интеллекта и
предназначенный для генерации массовых сцен в компьютерной анимации.
В основе работы программного продукта лежит генерация большого числа
агентов
искусственного
интеллекта,
которые
весьма
правдоподобно
взаимодействовали с окружением. У каждого такого агента есть свой уникальный
искусственный интеллект, что позволяет ему индивидуальным образом реагировать
на
события
внешней
среды
и
действия
остальных
агентов.
Действия,
предпринимаемые программными агентами, лежат в основе генерации движений
анимационных персонажей, что позволяет создавать сцены с согласованными,
реалистичными действиями толпы. Так, в батальных сценах широко известной
трилогии «Властелин колец», воины (агенты) атаковали противника в момент его
наибольшей уязвимости. Агент может быть и неодушевленным предметом:
корабль, автомобиль, мяч и т.д.
MOTION предоставляет ряд дополнительной полезной функциональности,
такой, как: симуляция одежд, генерация анатомичных телодвижений, работа с
аппаратным 3D ускорителем и т. д. Особо стоит отметить, что компьютерные
марионетки способны принимать интеллектуальные решение со скоростью показа
фильма.
Получив восторженные отзывы, продукт сразу же был взят на вооружение
крупнейшими студиями, работавшими над масштабными сценами с большим
количеством массовки. Так Massive использовался британской VFX студией MPC
35
(Moving Picture Company) при постановке сцены осады Иерусалима в кинофильме
«Царство Небесное» Ридли Скотта. Из более свежих примеров стоит упомянуть
такие широкоизвестные картины, как «Хроники Нарнии», «300 спартанцев»,
«Аватар», «Валли-и» и др.
Как отмечают профессионалы в области компьютерной анимации, кроме
Massive, существует ряд других
методов увеличения
числа персонажей.
Размножение отснятых людей, системы частиц, конечные автоматы (State
Machines), автономные агенты … Но, по мнению профессионалов в области
компьютерной анимации, ни одно из решений не сравнится по качеству и
предоставляемым возможностям с мультиагентной системой Massive.
2.3 Мультиагентное имитационное моделирование
В имитационном моделировании существует несколько парадигм —
постановок проблем и подходов к их решению, используемых в качестве «каркаса»
при построении и анализе моделей. Можно выделить четыре различающиеся
системы взглядов: динамические системы [23], системная динамика [24],
дискретно-событийное моделирование [25] и мультиагентные модели.
Эти парадигмы различаются не столько областями применения, сколько
концепциями и взглядами на проблему и подходами к решению проблемы. Очень
часто приверженцы одной парадигмы считают, что «правильные» постановка и
решение проблем имитационного моделирования возможны только в рамках
концепций
и
методик
именно
этой
парадигмы.
Например,
апологеты
моделирования и анализа динамических систем считают, что остальные подходы
«не совсем» научны, либо они являются частным случаем представления и анализа
систем в виде систем алгебро-дифференциальных уравнений. В действительности,
каждая из парадигм имеет право на жизнь, их использование определяется только
целью моделирования и связанным с этой целью выбранным уровнем абстракции
при решении проблем.
36
Мультиагентный подход, как способ имитационного моделирования появился
сравнительно недавно. Агентная модель представляет реальный мир в виде набора
активных сущностей, называемых агентами и среды, где они обитают. Каждый из
агентов взаимодействует с другими агентами, которые для него являются лишь
частью внешней среды, и в процессе функционирования может изменить как среду,
так и свое поведение. Обычно в таких системах не существует глобального
централизованного управления, агенты функционируют по своим законам
асинхронно. Задачи имитационного моделирования — строить простые модели
сложных реальных систем. Такое стремление, стоит отметить, соответствует
современным тенденциям в объектно ориентированном программирывании [26].
Это способствует тому, что мультиагентные модели, как правило, реализуют
программно именно с использованием объектно ориентированной парадигмы.
Существует множество определений понятия агента. Общим во всех этих
определениях является то, что агент — это некоторая сущность, которая обладает
активностью, автономным поведением, может принимать решения в соответствии с
некоторым набором правил, может взаимодействовать с окружением
агентами,
а также
может
и
другими
изменяться (эволюционировать) и самообучаться.
Цель агентных моделей — получить представление об этих глобальных правилах и
общем поведении системы, исходя из предположений об индивидуальном, частном
поведении ее отдельных активных объектов и взаимодействии этих объектов в
системе.
Мультиагентные
модели
используются
для
исследования
децентрализованных систем, динамика функционирования которых определяется
не глобальными правилами и законами, а наоборот, эти глобальные правила и
законы являются результатом индивидуальной активности членов группы.
Например, в области экономики, в которой весь организм формируется «снизу
вверх», не совсем адекватны модели и описания установившихся равновесных
режимов. Гораздо интереснее и адекватнее анализ моделей, позволяющих
37
выполнить анализ формирования правил и тенденций глобального поведения как
интегральных характеристик поведений многих составляющих активных игроков.
Сущности мультиагентного моделирования в общем случае можно разделить
на два класса: обычные, традиционные объекты среды, которые можно считать
пассивными, поскольку они ожидают сообщения прежде, чем выполнить
операцию. После того, как объекты инициированы, они выполняют свои функции и
«засыпают» до получения следующего задания. Активные объекты, которые
реагируют на события своей среды, а также предпринимают определенные
действия, не дожидаясь прямого обращения к себе, естественно моделировать с
помощью агентов.
Очевидно, что применение этого подхода к моделированию наиболее удобно
в случаях, когда нас интересуют характеристики поведения всей системы, которые
определяются как интегральные характеристики всей совокупности агентов. Одну
и ту же систему в зависимости от поставленной цели моделирования можно в
рамках различных парадигм. Более подробную информацию смотри в [27].
2.4 Совместное использование мультиагентных систем и нечеткой логики
Существуют исследования, устанавливающие связи между нечеткостью и
многоагентным подходом. Часто встречается совместное использование нечеткой
логики и теории автоматических переговоров. Так, например, в [28] описан способ
реализации программных агентов, способных вести торги на онлайн-рынке.
Модель переговоров агентов основана на использовании нечеткой логики. По
мнению авторов, это позволяет одновременно снизить сложность переговорного
процесса и работать с нечеткой и рассеянной информацией, которую можно найти в
интернете.
В [29] предложен еще один вариант применения технологии нечетких
вычислений и программных агентов в экономике: в рамках этих исследований была
построена интеллектуальная система управления большим объемом инвестиций
38
(Giga-Investments). Агенты в этой системе делятся на две основные группы. К
первой относятся агенты, ответственные за сканирование внешних данных
(внешние базы данных, интернет) и преобразование актуальной информации во
внутреннее представление. Ко второй — ответственные за анализ внутренних
данных,
общение
с
пользователем
и
предпринимаемые
действия.
Все
перечисленные агенты руководствуются нечеткими инструкциями.
Совместное использование нечеткой логики и программных агентов также
находит широкое применение в семантическом вебе. Например, в [30] описана
рекомендательная система, использующая агентов с нечетким поведением. Система
состоит
из
агентов
пользовательского
интерфейса,
фильтрации,
заданий,
пользовательского профиля и рекомендующего агента. Агенты производят
переговоры,
осуществляют
поиск
потенциально
интересных
пользователю
документов и реализуют обратную связь (обновляют данные в профиле
пользователя, исходя из высказанных им предпочтений).
Однако все вышеперечисленные исследования рассматривают связь между
нечеткостью и программными агентами как конструирование многоагентных
систем, состоящих из агентов, действующих по нечетким правилам. Нами же
предлагается к исследованию метод, в котором совместное использование
переговоров агентов и нечеткой логики используется как средство для построения
нечетких систем.
2.5 Обзор математической теории переговоров
Для описания основ теории переговоров потребуются базовые определения
теории игр.
Игрой в нормальной форме называют тройку объектов: <N, X, U>, где N =
{1 .. n} — множество игроков, обозначаемых 1 .. n, X = {X1 .. Xn} — вектор множеств
стратегий каждого игрока. То есть игрок i должен выбрать стратегию xi  Xi. И
наконец U = {u1 .. un} — вектор функций выигрыша каждого игрока, семантику U
39
смотри чуть ниже. Игра состоит в том, что каждый игрок делает свой ход, выбирает
стратегию. Формируется так называемый исход игры (Game Outcome): XN — вектор
из всех решений принятых каждым игроком, XN ={x1  X1, …, xn  Xn}. Обозначим χN
— пространство всех исходов игры: χN = {XN}. Функция выигрыша каждого игрока
зависит от исхода игры целиком: ui : χN → R.
Целью каждого игрока является максимизация только собственной функции
выигрыша. Соответственно, поведение игроков строится на основе эгоистических
(selfish) соображений: ни какого стремления помочь равно, как и навредить,
другому игроку быть не может. В случае если в моделируемой жизненной ситуации
действуют какие-либо морально-этические принципы, способные оказать влияние
на игроков, их эффекты следует учитывать при построении функции выигрыша,
например, вводить штрафы за неэтичное поведение.
Сразу стоит отметить, что функцию выигрыша не следует воспринимать, как
деньги, по крайней мере, в классических играх. Это означает, что игрок не обладает
способностью производить «выплаты» другому игроку, дабы склонить оного к
определенным
действиям.
Фактически,
действительное
значение
функции
выигрыша игрока A имеет целью только задать линейный порядок на множестве
исходов, который бы выражал предпочтения данного игрока A. Впрочем, в теории
игр рассматриваются и расширения классической игры, допускающие подобные
выплаты, или, например, угрозы.
Так же рассматриваются игры, в которых от участников требуется создавать
коалиции — так называемые кооперативные игры (Cooperative Games). Общая
формулировка такова: кооперативной игрой называется пара <N, v>, где N = {1 .. n}
N
— это множество игроков, а v — функция: 2 → R+, из множества всех коалиций в
множество
положительных
вещественных
чисел,
так
называемая
характеристическая функция. Эта функция показывает именно денежный
выигрыш коалиции, который потом игрокам нужно будет делить. Предполагается,
40
что пустая коалиция зарабатывает ноль, т.е. v( Ø ) = 0. Характеристическая функция
описывает величину выгоды, которую данное подмножество игроков может
достичь путем объединения в коалицию. Подразумевается, что игроки примут
решение о создании коалиции в зависимости от размеров выплат внутри коалиции.
Обычно функция v обладает следующими свойствами:
Монотонность — у больших (в смысле включения) коалиций выплаты больше:
A  B  v( A)  v( B) .
Супераддитивность — для любых двух непересекающихся коалиций A и B сумма
их выгод по отдельности не больше их выгоды при объединении:
A  B  Ø  v( A  B)  v( A)  v( B) .
Выпуклость:
v( A  B)  v( A  B)  v( A)  v( B) .
Исходом игры будет разбиение множества всех игроков на коалиции:
C = {c1 .. ck}, ci  N — попарно дизъюнтны,
c  N
и функция выплат каждому
cC
игроку: p: N → R+,
 p(i)  v(c) .
ic
Среди
свойств
исходов
кооперативных
игр
выделяют
следующие:
принадлежность С-ядру [31], принадлежность N-ядру [32], принадлежность K-ядру
[33].
При мультиагентном моделировании, однако, стоит иметь в виду, что
поведение агентов лишь субоптимально, что и будет учтено при проектировании
протокола переговоров [34, 35].
В теории игр определяется и рассматривается ряд свойств равновеся исходов
игры, например равновесие в доминирующих стратегиях, равновесие Нэша,
оптимальность по Парето и т. д. Более подробную информацию смотри в [36].
Перейдем к формальному описанию задачи переговоров (the Bargaining
Problem) [37], которая является частным случаем игровой задачи. Задача
41
переговоров представляет из себя вектор объектов: <N, Δ, U> где N = {1 .. n} —
вектор игроков, Δ = {δ1 .. δk} — множества сделок, наконец U = {u1 .. un} — вектор
функций выигрышей игроков: ui: Δ → R+. Причем в Δ всегда содержится
выделенная сделка δ-  Δ:
 i  N  ui(δ-) = 0.
Семантически это означает
отсутствие сделки, при котором все игроки получат нулевой выигрыш. Задачей
является выбор сделки δ* Δ.
Обозначим за BgP — множество всех задач переговоров (всевозможных
векторов <N, Δ, U>) Протоколом переговоров называется функция f : BgP → ΔBgP
т. е. Функция, определяющая оптимальную сделку. Единого мнения о том, что
такое «оптимальность» сделки (а соответственно и оптимальность протокола) —
нет, однако современная теория игр выделяет ряд полезных свойств сделок
(соответственно и переговорных протоколов).
Сделка δ1 доминирует по Парето сделку δ2, если:
 i  N  ui(δ1)  ui(δ2)
и
 i0  N: ui0(δ1) > ui0 (δ2)
Сделка δ* (соответственно и протокол, приводящий к этой сделке)
оптимальна по Парето (Pareto Optimal), если не существует другой сделки
δ: δ доминирует по Парето δ*.
Протокол f обладает свойством независимости от единиц измерения
(Independence of Utility Units), если:
 <N, Δ, U>  BgP,
 β = {β(1) .. β(n): β(i)  R+}  Rn 
f(<N, Δ, U>) = f(<N, Δ, β  U>)
где выражение β  U = {u'1 .. u'n} означает: u'i(δ) = ui(δ) βi
 δ  Δ.
т. е. для такого протокола верно, что его результат не изменится от того, что,
например, некоторые игроки начнут измерять свой выигрыш не в долларах, а в
евро.
Протокол f симметричен (Symmetry), если:
 <N, Δ, U>  BgP,  r — перестановка из n чисел 
f(<N, Δ, U>) = f(<N, Δ, r(U)>)
42
где выражение r(U) = {u'1 .. u'n} означает: u'i (δ) = ur(i)(δ)  δ  Δ
т. е. f — устойчив к перестановки игроков местами.
Протокол
f
обладает
индивидуальной
рационаленостью
(Individual
Rationality), если:
 <N, Δ, U>  BgP
δ* = f(<N, Δ, U>)   i  N ui(δ*)  ui(δ-)=0

т. е. каждый положение каждого игрока будет не хуже той ситуации, когда сделка
вовсе не была бы заключена.
Протокол f обладает независимостью от нерелевантных альтернатив
(Independece of Irrelavant Alternatives), если:
 <N, Δ, U>  BgP

δ* = f(<N, Δ, U>)   Δ'  Δ и δ*  Δ' 
f(<N, Δ, U>) = f(<N, Δ', U>)
т. е. f устойчив к исключению ряда нерелевантных альтернатив (тех, которые он в
полной задаче бы не выбрал).
Наконец опишем ряд широко известных в современной теории переговоров
протоколов.
Уравнительный протокол (Egalitarian Solution) приводит к сделке, которая
обеспечивает всем агентам одинаковый выигрыш, при этом максимизирую этот
выигрыш:
 *  arg max {u1 ( )} ,
 E
где E = {δ  Δ :  i, j  N верно ui(δ) = uj(δ)}.
Это наиболее простой протокол, но он не обладает даже оптимальностью по
Парето, по этой причине используется крайне редко. Однако заметим, он всегда
приводит к решению: E, очевидно, всегда не пусто, так как, по крайней мере,
δ-  E.
Протокол социальной справедливости (Egalitarian Social Welfare Solution)
приводит к решению, которое максимизирует выигрыш игрока с наименьшим
значением функции выигрыша:
 *  arg max { min ui ( ) }
 E
iN
43
Такой протокол не всегда дает оптимальное по Парето решение но несложно
показать, что среди множества: { : min ui ( )  min ui ( * )} (то есть множество сделок
iN
iN
на которых достигается социальная справедливость) всегда найдется оптимальное
по Парето.
Утилитарный
протокол
(Utilitarian
Solution)
приводит
к
сделке,
максимизирующей суммарную прибыль:
 *  arg ma x {  ui ( )}
 
iN
для этого протокола свойство оптимальности по Парето уже выполняется, так же
решение обладает свойством симметричности и независимостью от нерелевантных
альтернатив. Доказательство смотри в [35]. Однако данное решение не обладает
свойством независимости от единиц измерения.
Решение Нэша (Nash Bargaining Solution) максимизирует произведение
значений функции выигрыша:
 *  arg max {  ui ( )}
 
iN
это решение всегда будет оптимальным по Парето, симметричным, независимым
от нерелевантных альтернатив и независимым от единиц измерения. Доказано, что
это единственное решение, которое удовлетворяет всем четырем перечисленным
свойствам [35].
Решение Калая-Смородинского (Kalai-Smorodinsky Solution) распределяет
выигрыш игроков пропорционально максимальному возможному индивидуальному
выигрышу каждого игрока:
пусть ui*  max ui ( ) ,
пусть Δ' = {δ  Δ : δ оптимально по Парето}
 
тогда выберем
ui ( * )
ui*
  ' :

для  i, j  N
u j ( * ) u *j
*
44
Здесь, конечно, необходимым является условие существования такой сделки δ*.
Можно доказать, что если множество Δ является выпуклым подмножеством
линейного пространства, а функции ui непрерывны на Δ, то решение КалаяСмородинского всегда существует [35]. Это решение примечательно тем, что
наравне с решением Нэша обладает свойством независимости от единиц
измерения, однако не обладает устойчивостью к нерелевантным альтернативам.
От
формальных,
математических
протоколов
перейдем
к
более
алгоритмическим.
Протокол поочередных предложений Рубинштейна (Rubinstein’s Alternating
Offers) для задачи о разделе доллара. Задача формулируется крайне просто: двум
агентам требуется договориться о разделе доллара, причем принятое соглашение о
соотношении раздела (например 40 центов / 60 центов) должно быть подтверждено
обоими агентами. Протокол так же прост, он представляет собой итеративный
процесс: первый игрок предлагает вариант раздела, второй волен либо
подтвердить (accept) его, тогда это и будет исход игры, либо отвергнуть (reject),
тогда игроки меняются ролями. При этом отвергнутое ранее предложение более
никогда не рассматривается. Такие переговоры продолжаются до тех пор, пока
какое-то предложение не будет принято. Исследования показывают, что данная игра
не имеет доминирующей стратегии. Однако если добавить так называемый
скидочный (discount) эффект, то есть происходит инфляция и с каждой новой
итерацией игроки делят α  [0 .. 1) — часть от предыдущей суммой, то
доминирующая стратегия появится [35].
Такой
же
протокол
поочередных
предложений
без
особых
усилий
распространяется и на случай N агентов и произвольного множества Δ. Поочередно
агенты вносят предложение о сделке, все остальные должны его либо подтвердить,
либо отвергнуть. Дважды ни какое предложение не рассматривается. Если более
сделок не осталось, а решение не принято, то насильно принимается сделка δ-. Это
является
примером
наиболее
простого
переговорного
протокола
агентов,
45
применяемого в программных реализациях.
Протокол монотонных уступок (Monotonic Concession Protocol) является
развитием предыдущего протокола. Теперь добавлено правило: каждое следующее
предложение формулируемое агентом A0 должно быть для всех остальных агентов
чуть более выгодным, чем предыдущее предложение того же агента A0. Так начиная
с наиболее эгоистичных сделок, агенты придут к общему решению. Протокол
обладает рядом очевидных недостатков: он может сходиться очень долго, в случае
континуального множества Δ, даже бесконечно долго, кроме того протокол
существенно использует то, что все агенты знают функции выигрыша друг друга.
Дальнейшее развитие этого протокола решило проблему времени сходимости.
Протокол Зейтена (Zeuthen) вычисляет так называемый показатель риска агентов
(семантически это мера того, как быстро убывает функция полезности данного
агента, если он идет на уступки остальным). В каждый момент времени выбирается
агент с минимальным показателем риска. Этот агент и делает уступки остальным
до тех пор, пока он перестанет обладать минимальным риском. Для этого протокола
доказано, что он сходится за конечное время и обладает оптимальностью по
Парето. Больше того, доказано, что протокол является равновесным по Нэшу (по
крайней мере для случая двух игроков) в том смысле, что если игрок A0 объявляет,
что он использует этот протокол, то наилучшим ответом для второго игрока будет
так же использование этой же стратегии [35]. Протокол пригоден для программной
реализации, но часто затруднен тем, что оценка рисков игроков может быть
вычислительно сложна.
Переговоры о многомерных сделках (Multi-Dimensional Deal) являются
расширением классических переговоров. Здесь Δ = D1 × .. × Dk — прямое
произведение k доменов, где Di = {xi,j, j = 1 .. ti}. Такая модель множества сделок
является характерной для реального мира. Широко используются в подобных
задачах такие протоколы как имитация отжига (Annealing Method) или подъем в
гору (Hill Climbing) [46]. Подробнее смотри в [35].
46
Особо же отметим протокол для ведения переговоров о многомерных сделках,
получивший название аргументационно-ориентированный (Argumentation-Based
Negotiation). Сам по себе алгоритм является достаточно простым расширением
протокола поочередных уступок, однако допускает отсутствие знаний (или
неполное знание) агентов о функции выигрыша друг друга. Протокол предписывает
агентам помимо сообщений о предложениях, так же обмениваться сообщениями о
наиболее критичном параметре. Это означает, что агент A0, отвергнув предложение,
публикует информацию вида: «меня более всего не устраивает параметр Di, я бы
хотел его поменять с xi на xi'». Несмотря на свою простоту (а точнее благодаря ней),
протокол получил широкое распространение в программных реализациях.
Сеть переговоров (Negotiation Networks) представляет собой не протокол
переговоров, а структуру множества Δ. Здесь множество агентов может заключать
сделки из универсального множества Δ = {δ1 .. δk} в парах друг с другом (без
участия других агентов). Сеть же представляет из себя граф с множеством вершин,
совпадающим с Δ, ребро в графе <δi, δj> существует, если сделки δi, δj совместны,
т. е. если агент A0, заключив сделку δi, с агентом A1 все еще имеет возможность
заключить сделку δj с A2.
Сеть контрактов (Contract Net Protocol). Здесь роли агентов делятся на два
класса:
работодатели
(employers)
и
работники
(employee).
Работодатели
размещают контракты, предложения о выполнении работы. Работники делают
ставки, объявляют оплату за которую они готовы выполнить ту или иную работу.
Работодатель выбирает наиболее выгодную ставку. По сути, такая переговорная
система представляет собой единое статическое место, где агенты единообразно
публикуют любые предложения, а так же просматривают предложения других
агентов и, возможно, откликаются на них. [38, 39].
Сеть контрактов можно распространить и на случай, когда непосредственной
выплаты нет. Одни агенты публикуют предложения в этом статическом месте,
другие агенты откликаются на предложения.
Конечная цель этих действий —
47
договориться о совместных действиях, или сформировать коалиций (смотри
коалиционные игры, описанные выше). Будем обозначать такую переговорную
систему сеть предложений (Proposition Net Protocol).
Архитектура сети, как контрактов, так и сети предложений часто совмещается
с архитектурой сети переговоров, в которой можно задавать соотношения такого
рода: может ли данный работник выполнять данный контракт, или может ли
данный агент откликаться на данное предложение.
Отдельным разделом теории мультиагентных систем вобщем и теории
переговоров в частности являются аукционы, описание которых можно найти в [40,
41, 42, 43] и ссылках из этих работ. Для данной работы аукционы не представляют
существенного интереса, поэтому их описание опускается.
48
ГЛАВА 3. ОПИСАНИЕ МУЛЬТИАГЕНТНОГО ПОДХОДА К
НЕЧЕТКОМУ ПРОГРАММИРОВАНИЮ
В данной главе настоящей работы будет описана модель нечетких
вычислений при помощи переговоров программных агентов. Будет приведена
мотивация и основные преимущества данного подхода.
3.1 Модель нечеткие вычисления при помощи переговоров программных агентов
В пункте 1.10 настоящей работы говорится о том, что, по сути, нечеткий
алгоритм состоит из набора нечетких правил вида «IF-THEN». Переменные,
используемые в этих правилах, подразделяются на входные и выходные. Задача
нечеткого вывода состоит в том, чтобы по набору известных четких значений
входных переменных получить четкие/нечеткие (в зависимости от цели вывода)
значения выходных переменных, посредством интерпретации нечетких правил.
Сам же процесс нечеткого вывода состоит из следующих этапов: 1 фаззификация, 2
нечеткий
вывод,
3
композиция
(агрегация,
аккумуляция)
и
наконец,
4
дефаззификация.
Использование предложенного способа затрагивает этапы 3, 4 классической
схемы и частично этап 2. В пункте 3.2 настоящей работы приводится способ
реализации классической схемы нечеткого вывода с мультиагентной архитектурой.
Для каждой синтаксической конструкции нечеткого алгоритма будет создан
программный агент или группа агентов. Далее запускается переговорный процесс,
по ходу которого будут производиться вычисления нечетких и лингвистических
переменных.
По сути, такой процесс аналогичен классической схеме. Однако, за счет
распределения знаний среди агентов можно добиться большей гибкости (как будет
объяснено
далее).
Например,
в
таких
вопросах
как:
какую
функцию
предпочтительнее использовать для вычисления данного оператора AND / OR или
49
же, какой способ аггрегации (дефаззификации) стоит использовать при финальном
вычислении той или иной выходной переменной.
Такая гибкость, безусловно, является преимуществом, однако не дает ничего
принципиально нового. Расширенные возможности, которые предоставляет
мультиагентные подход будут описаны в пункте 3.3.
3.2 Реализация классического нечеткого вывода в мультиагентной архитектуре
Напомним, что нечеткий алгоритм представляет собой набор правил,
сформулированных на языке, порождаемом грамматикой, смотри пункт 1.10.
Как было и обещано в предыдущем пункте, опишем процесс аггрегации и
дефаззификации в рамках мультиагентного подхода. Так, как мы имеем дело с
набором нечетких правил, порядок описания которых не влияет на выполнение
нечеткого вывода, то самым логичным и естественным шагом будет ввести для
каждого правила по программному агенту, который будет «представлять интересы»
данного правила в процессе переговоров, реализующих стадию аггрегации.
Обозначим множество исходных правил: FKB = {FR1 .. FRN}, а представляющих
правила агентов: Rags = {RA1 .. RAN}. Нечеткое присваивание правила i
(конструкцию var_outi IS val_outi) будем называть пожеланием агента. В
процессе переговоров каждый агент будет стремиться реализовать свое пожелание.
Формально это будет выражаться в прямой зависимости функции выигрыша агента
RAi от степени достоверности выражения: var_outi IS val_outi. Ранее
отмечалось, что при нечетком программировании часто возникает необходимость
каждому
правилу
сопоставить
определенный
вес,
выражающий
степень
уверенности эксперта в адекватности этого правила. Пусть у каждого агента будет
свойство, в которое мы и скопируем этот вес, обозначим его weight[RAi]. Считаем,
что веса всех правил, а, следовательно, и агентов нормированы, т. е.
weight[RAi]  [0 .. 1].
Способ
вычисления
конструкций,
обозначенных
в
грамматике,
как
50
<fuzzy condition> пока оставим без изменений. Тогда теперь у нас есть набор
агентов, для каждого из которых известен его вес (мера адекватности) и сосчитана
его
степень
правдоподобия
(функция
принадлежности
соответствующего
<fuzzy condition> к нечеткому множеству «истина»), а так же его пожелание
— то, что выражено синтаксической конструкцией var_out IS val_out.
Остается выбрать функцию выигрыша (Utility Function) каждого агента, а затем и
протокол переговоров, в ходе которого получался бы результат нечеткого вывода.
Множеством сделок в данном переговорном процессе является пространство
всевозможных векторов из всех выходных переменных нечеткого алгоритма
(собственно результат нечеткого вывода).
На вопрос, какая функция выигрыша будет оптимальной, в общем случае
однозначного ответа дать нельзя: это зависит от конкретной задачи, которую решает
нечеткий алгоритм. Больше того, есть возможность для различных агентов задавать
различные по своей структуре функции выигрыша, в этом и заключается гибкость
мультиагентного подхода к исполнению нечетких программ. Однако можно
сформулировать ряд очевидных и естественных свойств, которыми эта функция
должна обладать:
 монотонное возрастание по показателю: var_outi IS val_outi для i-го
агента, логично: чем в большей степени удовлетворено пожелание агента, тем
больше его функция выигрыша;
Замечание:
здесь
же
отметим,
что
если
конструкцию
var_out IS val_out рассматривать не как нечеткое присваивание, а как
функцию принадлежности var_out нечеткому множеству val_out, то это
будет действительное число из [0 .. 1] и разговор о монотонности уместен.
 монотонное убывание по значению веса: как правило, протокол переговоров
стремится максимизировать функцию выигрыша игроков, следовательно, в
случае высокого значения веса, протокол будет стремиться повысить
функцию
выигрыша
за
счет
удовлетворенности
пожелания
(var_out IS val_out) агента;
 монотонное убывание по <fuzzy condition> — по аналогичным
51
причинам;
 должны выполняться краевые условия:
(1) при weight(RAi) = 0 верно: UFi = максимальному возможному
значению;
(2) при
<fuzzy condition> = 1
верно:
UFi = максимальному
возможному значению;
(3) при var_outi IS val_outi = 0 верно: UFi = 0.
Причем правила (1), (2) имеют больший приоритет, чем (3).
Наиболее простой функцией выигрыша, удовлетворяющей всем требованиям,
является:
u ( RAi ) 
var_ outi IS val _ outi
 fuzzy condition   weight[ RAi ]
Однако при таком варианте функции выигрыша появляется неприятный
нюанс: при <fuzzy condition> → 0 будет: u(RAi) → ∞, Модифицируем эту формулу
так:
u ( RAi ) 
1
)
 fuzzy condition 
weight[ RAi ]
(var_ outi IS val _ outi )  arctg (
Бесконечное значение u(RAi) все еще возможно при weight[RAi] = 0, но
вводить правила с нулевым весом (нулевой адекватностью) — само по себе абсурд,
поэтому считаем, что таких правил нет, либо все такие правила отбрасываем в
самом начале вычислений.
Тогда, выбирая протокол переговоров, сразу следует отметить, что от
свойства независимости «от единиц измерения» (смотри пункт 2.5) стоит
отказаться потому, что такое свойство необходимо привело бы к игнорированию
параметра веса агента.
Доказательство: в определении независимости от единиц измерения
(Independence of Utility Units), пункт 2.5 достаточно взять:
β = {β(i) =weight[RAi]}
52
тогда:
u ' ( RAi )    u ( RAi ) 
1
)
 fuzzy condition 
 weight[ RAi ] 
weight[ RAi ]
(var_ outi IS val _ outi )  arctg (
 (var_ outi IS val _ outi )  arctg (
1
)  const(weig ht[RA i ])
 fuzzy condition 
Например, всем требованиям удовлетворяет утилитарный протокол (пункт 2.5),
максимизирующий сумму всех функций выигрыша.
В случае же если мы хотим полного соответствия результатов вычислений
мультиагентного и классического способов, можно в качестве протокола
переговоров реализовать один из классических алгоритмов аггрегации и
дефаззификации, например, метод первого максимума, или метод центра масс [3].
Таким образом, получаем, что классическая схема является частным случаем
мультиагентного подхода.
Более подробно рассмотрев структуру нечетких правил, можно построить
еще более гибкую мультиагентную модель нечеткого вывода. Эта модель, как и
было обещана в пункте 3.1, будет затрагивать еще и этап [2] общей схемы нечеткого
вывода (смотри пункт 1.10). Теперь для каждого правила из нечеткой базы знаний
будем создавать не одного агента, а группу следующим способом.
Рассмотрим «IF-THEN» правило FRs ∈ FKB. Нечеткое условие этого правила
(элемент <fuzzy condition>) строится по формальной грамматике, описанной
в пункте 1.10 настоящей работы. Рассмотрим дерево разбора [44] этого правила,
пусть оно состоит из узлов {Nds1 .. Ndsk} (смотри там же, [44]). Для каждого узла Ndsj
этого дерева создадим программного агента Agsj и включим его в переговорный
процесс. Все связи между узлами дерева скопируем в созданных агентов. Это
означает, что если узел Ndsi дерева разбора имел потомков {Ndsp1 .. Ndspk}, то
соответствующий агент Ai будет иметь список потомков: {Agsp1 .. Agsp1} (где агент
Agspj соответствует узлу Ndspj). Так же оставим агентов RAgs = {RA1 .. RAN}.
Рассмотрим конкретного агента AgSj, он отвечает за узел NdSj. У этого узла есть
53
поддерево, которое порождает определенную часть исходного нечеткого условия
(<fuzzy condition>) [44], добавим этому агенту метод, вычисляющий степень
достоверности выражения нечеткой логики, порождаемого частью дерева разбора с
вершиной в узле NdSj. Пусть вершиной всего дерева разбора целиком является узел
NdS1, тогда в соответствии с этим правилом AgS1 будет вычислять степень
достоверности всего нечеткого условия правила FRs.
Таким образом, для каждого конкретного нечеткого правила FRs в
переговорах будет участвовать иерархически организованная (в соответствии с
деревом разбора), группа агентов, обозначим ее FCAgss = {NdAg1 .. NdAgk} плюс
еще один агент RAgs, который будет представлять правило целиком. Ранее действия
агента RAgs опирались на степень достоверности нечеткого условия из правила FRs.
Теперь агент RAgs будет получать эту величину, вызывая соответствующий метод у
агента AgS1. В итоге, единственное, что сейчас изменилось — это то, что процесс
нечеткого вывода был переложен на группу агентов, сформированную из дерева
разбора условия правила FRs.
Это добавило в модель гибкость: теперь, например, чтобы заменить функцию,
вычисляющую нечеткий оператор AND, достаточно изменить настройки агента,
соответствующего узлу дерева разбора, который порождает этот оператор AND. Это
дает возможность в различных правилах использовать различные функции,
вычисляющие значение операторов AND, OR и т. д. Кроме того, это позволяет
агентам из RAgs обмениваться более сложными по своей структуре сообщениями с
агентами, представляющими узлы, если это будет необходимо для улучшения
алгоритма.
Однако пока не было приведено конкретных примеров применения этих
дополнительных возможностей. Этот пробел будет восполнен в главе 4, где наряду
с
программной
реализацией
описывается
пример
нечеткого
алгоритма,
реализованного при помощи мультиагентного подхода. Новые возможности
существенно используются в приведенном алгоритме. Применены как те
54
возможности, которые описывались в данном пункте, так и те, которые приведены
в следующем, где объяснено, как предлагаемый подход позволяет добавить новые
синтаксические конструкции в язык нечеткого программирования.
3.3 Расширение возможностей нечеткого программирования
В пункте 1.10 настоящей работы приведен общий вид нечеткой программы.
Единственная
синтаксическая
конструкция,
применяемая
в
нечетком
программировании — это «IF-THEN», что является существенным ограничением.
Наиболее остро ощущается нехватка циклов. В данном пункте будет описан способ
применения
мультиагентного
подхода,
позволяющий
вводить
нечеткие
конструкции, аналогичные WHILE или FOR в классическом программировании.
Далее, в главе 4 настоящей работы будет описана программная реализация
предложенного способа и приведен пример нечеткого алгоритма, использующего
этот подход.
Начнем с наиболее простой конструкции FOR, а точнее конкретного ее
подвида: FOR_EACH. Эта конструкция осуществляет итерацию по какой-либо
наперед заданной коллекции объектов. Для каждого элемента конструкции введем
агента, «представляющего» этот элемент. Здесь существенно то, что это именно
конструкция FOR_EACH: добавление каждого нового агента требует выделение под
него памяти. Так как предполагается, что сама коллекция уже где-то хранится, то
память, выделенная под агентов, не превзойдет памяти, выделенной под
коллекцию, более чем в константное число раз. А это значит, что введение
нечеткости не скажется асимптотически на эффективности алгоритма по памяти.
Кроме того, тот факт, что каждый вводимый агент представляет какой-либо
конкретный объект реального мира — является естественным свойством
мультиагентных систем.
Переговорный процесс, а следовательно и процесс интерпретации нечеткого
алгоритма, будет заключаться в том, что каждому агенту поочередно будет
55
предоставлена возможность участия в голосовании — у объекта, реализующего
функциональность агента будет вызван определенный метод negotiate(…)
(смотри главу 4). Исполняя этот метод, агент способен как предпринимать
индивидуальные действия, так и обмениваться сообщениями с остальными
агентами. Конкретные действия агента зависят уже от самого нечеткого алгоритма.
Разберем на примере мультиагентного нечеткого алгоритма решающего
задачу кластеризации (Data Clustering) [45]. Псевдокод нечеткого алгоритма
приведен в алг. 1.
0 FOR_EACH vertex IN vertexList:
1
2
3
4
5
FOR_EACH cluster IN clustersList:
IF cluster хорошо подходит для vertex THEN:
vertex2clusterMap[vertex] IS cluster
IF vertex2clusterMap[vertex] IS пуст THEN:
vertex2clusterMap[vertex] IS new Cluster()
Алг. 1. кластеризация.
Замечание: Считаем, что во время создания нового кластера (new Cluster())
он будет автоматически добавлен в список clustersList.
Для реализации этого алгоритма создадим группу агентов VAgs, каждый
агент этой группы будет «представлять интересы» соответствующей вершины. Так
же создадим группу агентов CAgs, которая изначально будет пуста, а в процессе
создания новых кластеров будет пополняться агентами, «представляющими
интересы» кластеров. Жизненной целью каждого агента из VAgs будет попасть в
кластер, в котором все остальные агенты будут на него похожи. Пусть функция
выигрыша каждого агента будет зависеть от суммы расстояний от данного агента
до всех остальных агентов в кластере. Причем функция выигрыша должна убывать
с ростом расстояний. Например, подойдет:
56
1
u (a) 

DIST (a, b)
b  ClusterOf [ a ]
Более
подробно
обсуждать
функцию
выигрыша
в
этом
примере
бессмысленно.
Заметим, что мы получили пример кооперативной игры, описанной в пункте
2.5 настоящей работы. Агентам нужно разбиться на коалиции, в соответствии с
выбранным разбиением на кластеры каждый агент получит определенный
выигрыш. Правда, в данной задаче не выполняются такие полезные свойства как
монотонность, супераддитивность, выпуклость.
Однако в таком случае решение игровой задачи будет тривиальным: каждого
агента можно поместить в отдельный кластер. Проблему можно решить просто,
добавив еще одного агента ClustersCounter с большим весом, функция выигрыша
которого обратным образом зависит от количества созданных кластеров. Этот агент
будет выступать в роли штрафа за большое количество кластеров.
Система переговоров сама автоматически будет перебирать агентов из VAgs и
вызывать у каждого из них переговорный метод. Агент из VAgs, получив
управление, запустит аналогичный переговорный процесс для агентов из CAgs,
которые в процессе переговоров решат какому кластеру в большей степени
подходит текущий агент из VAgs. Наконец если окажется так, что ни один кластер
не будет достаточно хорошо подходить для текущего агента, то будет создан новый
кластер, состоящий только из него. Отметим, что на этом этапе агент из Vags
должен обменяться сообщением с ClustersCounter, чтобы решить: стоит создать
новый кластер, или присоединиться к уже существующему (если штраф за
количество кластеров слишком велик). Таким образом просто создав агента,
представляющего каждый элемент коллекции, мы построили мультиагентную
модель интерпретации нечеткой конструкции FOR_EACH.
Опишем, как в мультиагентной модели нечетких вычислений реализуется
57
общий вид конструкции FOR. В таких четких языках программирования, как C++,
Java или C# конструкция FOR и конструкция WHILE очень похожи в
использовании. В нечетком программировании эти конструкции еще менее
различимы. Поэтому опишем реализацию конструкции WHILE, конструкцию FOR
предлагается исполнять абсолютно аналогично.
Предложенный
ранее
нечеткий
алгоритм
кластеризации
обладает
существенным недостатком: агенты из VAgs участвуют в переговорах единожды в
строгой последовательности. Поэтому, участвуя в переговорах, каждый агент
обладает информацией лишь о том в какие кластеры попали все предыдущие
агенты и ничего не знает о последующих. Усовершенствуем этот алгоритм. Будем
использовать разбиение на кластеры, полученное предыдущим алгоритмом, как
первое приближение, отправную точку. Далее будем улучшать этот результат при
помощи следующего алгоритма (такая схема получила название подъем в гору, Hill
Climbing [46]), приведенного в алг. 2.
0 WHILE есть существенный прогресс AND время не истекло:
1
2
FOR_EACH c IN clustersList:
IF можно относительно эффективно разделить c AND
3
NOT количество кластеров слишком велико THEN:
4
split( c )
5
6
7
FOR_EACH c1 IN clustersList:
FOR_EACH c2 IN clustersList:
IF c1 относительно похож на с2 OR
8
количество кластеров слишком велико THEN:
9
join( c1, c2 )
Алг. 2. кластеризация Hill Climbing.
Конструкции FOR_EACH были уже изучены ранее и в данном случае мы
обращаемся с ними точно так же: для каждого кластера из clustersList сознаем
агента, который будет «представлять его интересы». Множество таких агентов
58
будем обозначать CAgs, а выражением
CAgs[c] для c  clustersList будем
обозначать агента, представляющего кластер c. Конструкция IF стр. 2-4 имеет
сложное условие, состоящее из двух лексем, соединенных операторами AND и
NOT. Проверка первой части условия (можно эффективно разделить c, терм
«относительно» здесь опущен намеренно, семантику и реализацию этого терма
смотри ниже) — сугубо индивидуальное действие агента CAgs[c]. Проверка же
второго условия (количество кластеров слишком велико) — сугубо индивидуальное
действие агента clustersCounter. Поэтому пусть агент CAgs[c], вычислив степень
достоверности того, что кластер можно эффективно разделить, обменяется
сообщениями с агентом clustersCounter, выяснит, как достоверно свойство
количество кластеров слишком велико,
и
в
результате
сможет
оценить
достоверность нечеткого условия «можно относительно эффективно разделить c
AND NOT количество кластеров слишком велико» целиком для того, чтобы принять
финальное четкое решение: выполнять ли split().
Теперь раскроем смысл модификатора «относительно», что поможет нам
убедиться в эффективности и гибкости мультиагентного подхода. Каждый агент
индивидуально не может знать, насколько эффективно могут быть разделены
кластеры остальных агентов. Поэтому может возникнуть такая неприятная
ситуация: первые n / 2 агентов из CAgs решат, что их кластеры могут быть
разделены эффективно и выполнят split(). При этом последние n / 2 агентов
способны разделить свои кластеры еще более эффективно, но сделать этого не
смогут: им помешает условие «NOT количество кластеров слишком велико»,
которое уже вступит в силу. Воспользовавшись преимуществом мультиагентного
подхода, можно проводить переговоры о цикле FOR_EACH стр. 1-4 в два этапа.
Сначала все агенты из CAgs оценят эффективность разделения своего кластера,
затем clustersCounter выберет подмножество наиболее эффективных агентов и
разошлет именно им сообщение, разрешающее произвести операцию split().
Разберем двойной цикл FOR_EACH стр. 5-9. Здесь можно воспользоваться
59
преимуществом мультиагентной модели дважды. Во-первых, двойной цикл будем
интерпретировать, как обмен сообщениями агентов из CAgs: каждый с каждым.
Обмениваясь сообщениями, агенты оценивают, насколько их кластеры похожи.
Сигнал, побуждающий произвести операцию join() происходить по аналогичной
схеме: clustersCounter выбирает подмножество наиболее похожих пар (так, чтобы
ни один агент из CAgs не входил в две выбранные пары) и рассылает сообщения
соответствующим агентам.
Наконец опишем способ интерпретации конструкции WHILE, обозначенной
на стр. 0. Добавим выделенного агента mainWhile, который будет постоянно
следить за тем, насколько были эффективны преобразования (операции split, join),
выполненные за последние k шагов. Если прогресс ниже какого-то наперед
заданного значения, или если время выполнения алгоритма уже истекло, то
mainWhile разошлет сообщение остальным агентам, заставляющее их прекратить
дальнейшие переговоры.
Разработав мультиагентную интерпретацию данного нечеткого кода, мы
модифицировали все стандартные стадии нечеткого вывода 2 .. 4. Процесс
аггрегации выполнялся периодически во время переговоров, когда выбиралось
наиболее эффективное подмножество агентов (пар агентов). А дефаззификация
производилась, когда рассылались сообщения о запуске четкого метода split, или
join. Фаза 2 нечеткого вывода затрагивалась, когда мы задавали интерпретацию
нечеткого модификатора «относительно».
Из приведенного примера видно, что мультиагентный подход позволяет более
эффективно и гибко интерпретировать нечеткие алгоритмы такого рода. Более того,
этот
подход
позволяет
использовать
новые
синтаксические
конструкции
(FOR_EACH, FOR, WHILE) при нечетком программировании. В пункте 4.6
настоящей работы будет приведен пример программной реализации похожего
алгоритма, решающего задачу о расположении факультетов (Facility Location
Problem). Этот алгоритм будет сравнен с широко известным приближенным
60
алгоритмом, решающим ту же задачу. Будут приведены результаты численного
эксперимента, подтверждающего эффективность мультиагентного способа.
61
ГЛАВА 4. ПРОГРАММНАЯ РЕАЛИЗАЦИЯ И ЭКСПЕРИМЕНТЫ
В данной главе настоящей работы описывается технические аспекты
программной реализации фреймворка для кодирования и интерпретации нечетких
алгоритмов на базе мультиагентной модели нечетких вычислений. Так же
приводится описание численных экспериментов с разработанным фреймворком. В
конце главы содержатся результаты экспериментов.
4.1 Используемые технологии
Результатом исследования, произведенного в ходе работы, стала программная
библиотека, реализующая предложенный подход к интерпретации нечетких
алгоритмов.
Библиотека
разрабатывалась
на
языке
Java
и
называется
JFuzzyPrincipless. Программирование велось на основании широко известной
практики разработки через тестирование (Test Driven Development, TDD) [47].
Реализация
численного
эксперимента,
проводимого
с
разработанной
библиотекой, требует больших вычислительных затрат. Поэтому реализация
эксперимента проводилась частично на языке Java, частично на языке C++, что
позволило более эффективно производить наиболее критичные вычисления.
Межъязыковое взаимодействие осуществлялось при помощи технологии JNI.
4.2 Интерфейс работы с программными агентами
Начать
описание
библиотеки
стоит
с
пакета
jfuzzyprincepless.agents
содержащего центральный интерфейс библиотеки, приведенный в алг. 3.
62
public interface INegotiatingAgent {
public void onNegotiationStart(INegotiationContext
context);
/**
* returns true if wants to continue negotiation
*/
public boolean negotiate(INegotiationContext context);
}
Алг. 3. интерфейс INegotiationAgent.
метод onNegotiationStart вызывается у всех агентов до начала переговорного
процесса для того, чтобы была произведена инициализация агентов, в частности
выполняя этот метод, агенты регистрируют предоставляемые ими сервисы (смотри
пункты 4.3, 4.4). Метод negotiate передает управление агенту, реализующему
функциональность агента. Выполняя этот метод, агент производит итерацию
переговорного процесса. Возвращаемое значение типа boolean семантически
означает: желает ли агент продолжить участие в переговорах. Описание интерфейса
InegotiationContext смотри в пункте 4.4.
4.3 Протокол сети сервисов
В пункте 2.5 настоящей работы описываются протокол сети предложений
(Proposition Network). В библиотеке JFuzzyPrincepless используется расширенный,
объектно-ориентированный вариант этого протокола, который в работе будем
обозначать протокол сети сервисов (Service Network Negotiation Protocol). В
действительности
этот
протокол
повторяет
концепцию
протокола
сети
предложений. Но в новом варианте протокола агенты не публикуют свои
предложения в едином статическом месте, как это было раньше. Так же агенты не
обмениваются сообщениями друг с другом непосредственно. Обмен сообщениями
и публикация предложений происходит посредством типизированных сервисов.
Агенты их извлекают из переговорного контекста.
Таким образом, все общение агентов с внешним миром осуществляется
63
посредством сервисов. Следовательно, контекст, из которого агенты эти сервисы
получают, фактически и является средой обитания агентов. Для более детального
описания
принципов
работы
сети
сервисов,
обратимся
к
рассмотрению
программного кода.
4.4 Среда (Environtment) мультиагентного моделирования
Ранее говорилось, что обязательным элементом любой мультиагентной
системы, помимо набора агентов, является среда, в которой эти агенты существуют.
В библиотеке JFuzzyPrincepless среда обитания агентов представлена интерфейсом
INegotiationContext, приведенным в алг. 4, который основывается на
меточном интерфейсе IService (алг. 5).
public interface INegotiationContext {
public <ServT extends IService> ServT getService(
Class<ServT> clazz
);
public <ServT extends IService> void registerService(
Class<ServT> clazz,
ServT service
);
}
Алг. 4. интерфейс INegotiationContext.
/**
* label interface for all negotiation services
*/
public interface IService {
}
Алг. 5. интерфейс IService.
Интерфейс IService
интерфейсом,
базовым
для
не содержит методов, он является меточным
всех
сервисов.
Метод
registerService
регистрирует в контексте сервис, а метод getService — соответственно
64
возвращает последний зарегистрированный сервис с указанным интерфейсом, либо
null, если такого сервиса зарегистрировано не было. Если агент получает null,
вместо требуемого сервиса, то в зависимости от ситуации, либо работа с данным
сервисом игнорируется, либо возникает исключительная ситуация.
Так, например, работа с упомянутым в пункте 3.3 агентом, отвечающим за
прекращение цикла WHILE, осуществляется, как показано в алг.6.
IWhileService whileService =
context.getService(IWhileService.class);
if (whileService == null) {
throw new …
}
return whileService.isAgentAlive(this);
Алг. 6. реализация выхода из WHILE.
Таким
образом,
протокол
сети
сервисов
является
типизированным,
структурированным и объектно-ориентированным расширением протокола сети
предложений.
4.5 Система переговоров
Наконец, перейдем к собственно системе переговоров абстракцию которой
выражает интерфейс INegotiation приведенный в алг. 7.
public interface INegotiation {
/**
* negotiation with specified context
*/
public void negotiate(INegotiationContext context);
}
Алг. 7. интерфейс INegotiation.
Имплементация данного интерфейса — это реализация какого-либо протокола
переговоров.
На
вход
объекту,
реализующему
этот
интерфейс,
подается
65
переговорный контекст (среда обитания агентов) в изначальном состоянии.
Выходным результатом будет измененное состояние контекста, которое произошло
в ходе переговорного процесса. Поскольку INegotiation всегда работает с
INegotiationContext, то все реализации INegotiation являются частным
случаем протокола сети сервисов.
Наиболее
простой
и
используемой
чаще
всего
имплементацией
INegotiation является DefaultNegotiation (алг. 8.).
public class DefaultNegotiation implements INegotiation {
@Override
public void negotiate(INegotiationContext context) {
List<INegotiatingAgent> agentsList =
getAgentsList(context);
for (INegotiatingAgent agent : agentsList) {
agent.onNegotiationStart(context);
}
Set<INegotiatingAgent> negAgents =
new LinkedHashSet<INegotiatingAgent>(agentsList);
while (!negAgents.isEmpty()) {
for (
Iterator<INegotiatingAgent> it =
negAgents.iterator();
it.hasNext();
) {
INegotiatingAgent agent = it.next();
boolean isAlive = agent.negotiate(context);
if (!isAlive) {
it.remove();
}
}
}
}
}
Алг. 8. реализация DefaultNegotiation.
Как видно из кода, переговорная система действует крайне просто: она извлекает из
контекста список агентов и последовательно передает управление каждому агенту
в, процессе удаляя из рассмотрения тех агентов, которые сами пожелали не
66
участвовать более в переговорах. Так продолжается до тех пор, пока множество
переговаривающихся агентов не пусто.
Наряду с DefaultNegotiation были реализованы и другие переговорные
системы, например UtilityFuncNegotiation (алг. 9., алг.10.)
public class UtilityFuncNegotiation implements INegotiation {
private INegotiation subnegotiation;
public UtilityFuncNegotiation(
INegotiation subnegotiation
) {
this.subnegotiation = subnegotiation;
}
@Override
public void negotiate(INegotiationContext context) {
List<INegotiatingAgent> agentsList =
getAgentsList(context);
for (INegotiatingAgent agent : agentsList) {
agent.onNegotiationStart(context);
}
Set<INegotiatingAgent> negAgents =
new LinkedHashSet<INegotiatingAgent>(agentsList);
while (continueNegotiation(context)) {
subnegotiation.negotiate(context);
analiseUtilities(context, agents);
}
}
private boolean continueNegotiation(
InegotiationContext context)
{ … }
Алг. 9. реализация UtilityFuncNegotiation (a).
67
private void analiseUtilities(
INegotiationContext context,
List<INegotiatingAgent> agents
) {
IUtilityFuncNegotiationAgent minUtilAgent = null;
double minUtility = Double.MAX_VALUE;
List<IUtilityFuncNegotiationAgent> ufagents =
extractUFAgents(agents);
for (IUtilityFuncNegotiationAgent agent : ufagents) {
double utility = agent.computeUtility(context);
if (utility < minUtility) {
minUtility = utility;
minUtilAgent = agent;
}
}
if (minUtilAgent == null) {
return;
}
minUtilAgent.negotiatePrivileged(context);
}
private void extractUFAgents(
List<INegotiatingAgent> agents)
{ … }
}
Алг. 10. реализация UtilityFuncNegotiation (b).
Как
видно
из
кода,
реализует
UtilityFuncNegotiation
паттерн
проектирования Decorator [48], в поле subnegotiation хранится декорируемая
переговорная
система.
UtilityFuncNegotiation
в
цикле
запускает
декорируемую систему переговоров, затем анализирует функции выигрыша
игроков, выбирает агента с минимальной функцией выигрыша и передает ему
управление в привилегированном режиме, дабы он смог поменять состояние
контекста и улучшить свое благосостояние. Это происходит до тех пор, пока
стратегия останова, реализованная в методе continueNegotiation (которая
здесь опущена) не даст сигнал к прекращению переговоров. Таким образом,
UtilityFuncNegotiation реализует протокол переговоров с Egalitarian Social
68
Welfare свойством (смотри пункт 2.5).
4.6 Описание численного эксперимента.
Для оценки эффективности предложенного метода в ходе работы был
разработан, реализован и протестирован нечеткий эвристический алгоритм,
решающий NP-полную задачу о расположении факультетов (Facility Location
Problem) [49].
Задача состоит в следующем: имеется F — множество факультетов, C —
множество городов и наконец Rds = {<c, f>: c  C, f  F} — множество дорог.
Изначально все факультеты и все дороги закрыты. Известны функции: fp: F → R+ и
rp: Rds → R+ — цены открытия факультетов и дорог соответственно. Требуется
открыть подмножество факультетов и подмножество дорог минимальной общей
стоимости так, чтобы каждый город имел хотябы одну смежную открытую дорогу,
ведущую в открытый факультет. Задача принадлежит к классу NPC [50], это
означает, что науке не известен точный и эффективный алгоритм ее решения.
Однако есть приближенный factor-3 [49] алгоритм, использующий так называемую
primal-dual
схему.
Описание
алгоритма
можно
найти
в
[49].
Свойство
приближенного алгоритма factor-3 означает, что найденное им решение будет не
более чем в три раза хуже оптимального.
Разработанный в ходе данной работы алгоритм относится к классу
алгоритмов подъема в гору (Hill Climbing) [46]. Это означает, что он использует
некоторое приближенное решение в качестве базового, а затем при помощи
локальных оптимизаций [51] его улучшает до тех пор, пока есть прогресс и не
истекло время, отведенное на вычисление. В качестве базового будем использовать
то самое factor-3 решение. Так как алгоритм подъема в гору никогда не ухудшает
базового решения, то полученный нами алгоритм так же будет обладать свойством
factor-3. Таким образом, разработанный алгоритм будет итеративно улучшать
существующее решение.
69
Будем обозначать: fwtn[c], для c  C — открытый факультет, который
соединен с городом c, такой факультет будем называть свидетелем (witness) для c.
Так как мы оптимизируем корректное решение, то свидетель для любого города
существует. Можно считать, что свидетель для каждого города единственен ибо нет
смысла открывать несколько дорог смежных одному городу, так как в противном
случае дорогу к второму свидетелю можно закрыть, при этом ничего не нарушится,
а стоимость решения уменьшится.
В алг. 11. приведен псевдокод тривиального нечеткого алгоритма. Здесь под
термом «f1 более дешев для c чем f2» понимается то, что дорога от c до f1 дешевле
дороги от c до f2: rp(<c, f1>) < rp(<c, r2>).
Этот алгоритм является набором из трех эвристических наблюдений. Первое
и самое простое описывается циклом FOR_EACH стр. 1 .. 4. Более того, это даже не
нечеткий, а вполне классический код: для каждого города выбирается открытый
факультет с самой дешевой дорогой. Тем не менее, для сохранения однообразия
реализуем это при помощи мультиагентного подхода уже устоявшимся способом
(смотри пункт 3.3). Пусть множество агентов CAgs представляет города, будем
обозначать CAgs[c] — агент, представляющий город c. Аналогично, FAgs —
множество
агентов,
представляющих
факультеты,
а
FAgs[f]
—
агент,
представляющий факультет f.
70
0 WHILE есть сещественный прогресс AND время не истекло:
1
FOR_EACH c IN citiesList:
2
FOR_EACH f IN openFacilitiesList:
3
IF f дешевле для c чем fwtn[c] THEN:
4
fwtn[c] IS f
5
FOR_EACH f IN closedFacilitiesList:
6
wanted IS false
7
FOR_EACH c IN citiesList:
8
IF f более дешев для c чем fwtn[c] THEN:
9
wanted IS true
10
11
12
13
IF wanted AND f не слишком дорог THEN:
open(f)
FOR_EACH f1 IN closedFacilitiesList:
FOR_EACH f2 IN openFacilitiesList:
14
goodAlt IS false
15
FOR_EACH c IN getCitiesWithWitness(f2):
16
IF f1 более дешев для с чем f2 OR
c может найти дешевого свидетеля
кроме f2 THEN:
17
18
goodAlt IS true
IF goodAlt OR f1 дешевле чем f2 THEN:
19
open(f1)
20
close(f2)
Алг. 11. Facility Location Problem тривиальный нечеткий алгоритм.
Для реализации конструкции двойного FOR_EACH стр. 1 .. 4 каждый агент из
CAgs будет обмениваться сообщением с каждым агентом из FAgs и в случае, если
этот факультет открыт и дорога к нему дешевле, чем к fwtn[c], то значение fwtn[c]
будет перезаписано. Когда агент CAgs[c] меняет своего свидетеля fwtn[c] на нового,
71
с
более
дешевой
дорогой,
будем
говорить,
что
он
получает
прибыль
rp(<c, fwtn[c] old>) - rp(<c, fwtn[c] new>). Аналогично, когда открывается новый
факультет, агент из CAgs может использовать этот факультет в качестве свидетеля,
тогда будем говорить, что агент CAgs[c] получает прибыль от открытия факультета f
и будем обозначать эту ситуацию так:
profit(c, open=f) = max(0, rp(<c, fwtn[c]old>) - rp(<c, fwtn[c] new>))
здесь fwtn[c]old – оптимальный выбор свидетеля для города c до открытия f, а
fwtn[c]new – после. Когда происходит закрытие факультета, ряду городов приходится
использовать другого, свидетеля дорога к которому будет, быть может, более
дорогой. В этом случае будем говорить об убытке агента CAgs[c]:
loss(c, close=f) = max(0, rp(<c, fwtn[c] new>) - rp(<c, fwtn[c]old>))
семантика fwtn[c]new , fwtn[c]old аналогична.
Распространим на более общий случай:
profit(c, open={f1 .. fk}, close={ f’1 .. f’m}) =
max(0, rp(<c, fwtn[c]old>) - rp(<c, fwtn[c]new>))
loss(c, open={f1 .. fk}, close={ f’1 .. f’m}) =
max(0, rp(<c, fwtn[c]new>) - rp(<c, fwtn[c]old>))
Замечание: в данном случае, если произошло так, что после замены:
{f’1 .. f’m} → {f1 .. fk} город с не может выбрать свидетеля (все смежные с
ним факультеты закрыты), полагаем rp(<c, fwtn[c] new>) = rp(<c, null) = ∞ и
соответственно loss = ∞.
Наконец, определим общую прибыль / убытки, как:
totalProfit(open  {f 1 ..f k },close  {f 1' ..f k' }) 
totalLoss(open  {f 1 ..f k },close  {f 1' ..f k' }) 
 profit(c, open  {f
cC
 loss(c, op en  {f
cC
1
1
..f k },close  {f 1' ..f k' })
..f k },close  {f 1' ..f k' })
72
Конструкция FOR_EACH стр. 5 .. 11 представляет уже больший интерес:
здесь во вложенном цикле FOR_EACH стр. 7 .. 9 подсчитывается значение
лингвистической переменной wanted, выражающей то, на сколько сильно агенты,
представляющие города хотят видеть текущий факультет f открытым. Очевидно,
что для определения того, стоит ли открывать факультет f, необходимо вычислить
сумму прибыли, которую получат все города от возможности присоединяться к
новому свидетелю. Заметим однако, что в этом случае ни один из способов
аггрегации, описанных в главе 1 настоящей работы не применим так как в
классических нечетких вычислениях функции принадлежности в чистом виде не
складывают.
В мультиагентной же модели это вычисление будет выглядеть просто: при
агрегировании
лингвистической
переменной
считается
сумма
прибыли,
получаемой каждым агентом из CAgs, при дефаззификации эта сумма сравнивается
со стоимостью открытия факультета fp(f). В случае, если прибыль больше
стоимости:
totalProf it(open  { f }, close  Ø)  fp(f)
факультет открывается. Считается, что в операцию open стр. 11 включен процесс
уведомления агентов из CAgs о том, что они могут использовать новый факультет f
в качестве свидетеля.
Наконец перейдем к описанию мультиагентной реализации конструкции
FOR_EACH стр. 12 .. 20 представляющей наибольший интерес. На примере этого
цикла демонстрируется конкурирующая деятельность агентов. Здесь агент,
представляющий закрытый факультет f1 пытается заменить собой открытый
факультет f2 т. е. закрыть f2 и открыть f1. При этом ряду городов, использующих f2
в качестве свидетеля, придется перейти на использование другого факультета.
Поэтому агент, отвечающий за f1, обменивается сообщениями со всеми городами,
использующими в качестве свидетеля f2, производя опрос об их прибыли / убытках
73
от замены f2 на f1. При этом информация агрегируется в лингвистической
переменной
goodAlt
по
старой
технологии:
считается
общая
сумма
прибыли/убытков. Далее эта величина сравнивается с fp(f2) - fp(f1). Четкое
решение (дефаззификация): выполнять операции open(f1), close(f2) принимается,
если:
fp(f2) - fp(f1) + totalCAgsProfit(open={f1}, close={f2}) totalCAgsLoss(open={f1}, close={f2}) > 0
Агент, отвечающий за конструкцию WHILE стр. 0 ведет себя аналогично
примеру, описанному в пункте 3.3 : по событию истечения времени, отведенного на
вычисление, или при низкой величине прогресса последних k итераций, рассылает
сообщение остальным агентам, побуждающее их прекратить переговоры.
Таким образом, в этих трех циклах: стр. 1 .. 4, 5 .. 11, 12 .. 20 выражены
следующие тривиальные эвристические идеи:
1 город может выбрать для себя открытый факультет — свидетеля с самой
дешевой дорогой, ведущей в него;
2 можно открыть новый факультет, если при этом прибыль агентов из СAgs
покроет стоимость самого факультета;
3 можно заменить один факультет другим, если при этом в прибыли окажутся
агенты из CAgs, или стоимость нового факультета сильно меньше стоимости
старого.
Этот нечеткий алгоритм был назван тривиальным, так как он реализует
действительно только локальную оптимизацию: за один шаг изменяется состояние
не более чем двух факультетов. Более того, при затрате некоторых усилий, этот
нечеткий эвристический алгоритм без проблем переписывается в четкой форме.
Сейчас будет рассмотрен алгоритм, который способен за один шаг менять
состояние произвольного количества факультетов. Алгоритм основан как на
конкурирующем, так и на кооперативном поведении агентов и в более
74
существенной форме использует преимущества нечеткого программирования.
В
алг. 12.
приведен
псевдокод
продвинутого
варианта
нечеткого
эвристического алгоритма. Здесь под new Cluster({f}) понимается создание новой
коалиции из множества агентов, содержащего только f. Как видно из кода, данный
алгоритм похож на уже разобранный нами в пункте 3.3 Нечеткий алгоритм
кластеризации. Здесь на кластеры делятся факультеты. В качестве функции оценки
похожести кластеров (смотри конструкцию IF стр. 24) берется следующая:
SIM(A, B) =

enemyFclt  F
totalProfit(open=A  B, close={enemyFclt} .
Таким образом, более похожи те кластера, одновременное открытие которых
принесет наибольшую общую прибыль. Алгоритм кластеризует закрытые
факультеты, далее для каждого кластера clstr выбирает подмножество открытых
факультетов activEnemies и заменяет activEnemies на clstr, если это приносит
прибыль.
Теперь опишем, как все происходит на уровне агентов. Код на строках 0 .. 2
производит инициализацию данных и свойством нечеткости не обладает. Условие
выхода из основного цикла WHILE стр. 3 реализуется по описанной ранее схеме.
75
0 fcltClusters = Ø
1 FOR_EACH f IN closedFacilitiesList:
2
fcltClusters.add( new Cluster({f}) )
3 WHILE есть существенный прогресс AND время не истекло:
4
FOR_EACH clstr IN fcltClusters:
5
activEnemies = Ø
6
FOR_EACH enemy IN openFacilitiesList:
7
IF enemy хорошо заменяется на clstr OR
цена enemy велика THEN:
8
activEnemies.add(enemy)
9
goodChange IS false
10
FOR_EACH c IN citiesList:
11
FOR_EACH f IN clstr:
12
IF fwtn[c] ∈ activEnemies AND
f дешевле для c чем fwtn[c] THEN:
13
14
goodChange IS true
IF goodChange OR
стоимость activEnemies больше стоимости clstr
THEN:
15
open(clstr)
16
fcltClusters.remove(clstr)
17
close(activEnemies)
18
FOR_EACH aEnm IN activEnemies:
19
20
21
22
fcltClusters.add( new Cluster({aEnm}) )
FOR_EACH clstr1 IN fcltClusters:
FOR_EACH clstr2 IN fcltClusters:
IF clstr1 похож на clstr2 AND
( стоимость clstr1 не слишком велика OR
стоимость clstr2 не слишком велика ) THEN:
23
join(clstr1, clstr2)
Алг. 12. Facility Location Problem продвинутый нечеткий алгоритм.
76
Понятие
кластера
факультетов,
используемое
в
нечетком
коде
в
мультиагентной модели реализуется в виде коалиции агентов из FAgs. В
мультиагентной реализации строчек кода 6 .. 8 агенты из Fagsclosed (представляющие
закрытые факультеты) обмениваются сообщениями из FAgsopen (представляющие
открытые факультеты) и определяют для каждой коалиции нечеткое множество
наиболее актуальных открытых факультетов activEnemies. Здесь существенно, что
множество activEnemies нечеткое, так как при исполнении строчек кода 10 .. 15
коалиция clstr будет пробовать закрыть факультеты из activEnemies с наибольшим
значением функции принадлежности.
Вывод лингвистической переменной goodChange, производимый на стр. 9 ..
13 в мультиагентной модели так же реализован по схеме подсчета общей
прибыли / убытков агентов. А при интерпретации нечеткой конструкции IF стр. 14
.. 19 при расчете условия прибыли / убытки сравниваются с разностью цен
факультетов из clstr и activEnemies. В итоге четкое решение: производить ли замену
clstr → activEnemies принимается исходя из формулы:
totalProf it(open  clstr, clo se  activEnemies)  totalLoss(open  clstr, clo se  activEnemies) 

fp(enm) 
enm  activEnemies
В
случае
положительного
исхода,

fp(cm)  0
cm  clstr
множество
факультетов
activEnemies
закрывается, кластер clstr — открывается, а цикл FOR стр. 18 .. 19 является четким
и просто добавляет набор одноэлементных коалиций, состоящих из агентов,
представляющих факультеты activEnemies.
Наконец двойной цикл FOR_EACH стр. 20 .. 23 производит итерацию
объединения кластеров. Его мультиагентная интерпретация так же производится по
описанной ранее схеме. Происходит обмен сообщениями между коалициями
агентов, каждая коалиция с каждой. Для каждой пары оценивается степень их
похожести и размеры коалиций. Условие «стоимость clstr1 не слишком велика OR
стоимость clstr2 не слишком велика» добавлено для того, чтобы не появлялись
77
коалиции со слишком большой суммарной стоимостью. Далее специальный агент
выбирает подмножество пар коалиций с наибольшими значениями достоверности
условия из конструкции IF стр. 22 .. 23 и производит объединение только этих пар
коалиций.
Теперь переходим к описанию результатов численного эксперимента. В
процессе эксперимента решалась задача расположения факультетов при помощи
набора алгоритмов:

известный factor-3 алгоритм, использующий так называемую primal-dual
схему [49];

«наивный» эвристический алгоритм;

тривиальный нечеткий мультиагентный алгоритм, приведенный в алг. 11;

продвинутый нечеткий мультиагентный алгоритм, приведенный в алг. 12;
Здесь под наивным эвристическим алгоритмом понимается следующий: открыть
все факультеты, для каждого города выбрать самую дешевую дорогу, ведущую к
факультету, закрыть все факультеты, которыми никто не воспользовался.
Шаги численного эксперимента:
1. генерации ряда взвешенных двудольных графов разного размера;
2. запуск каждого из алгоритмов на каждом из сгенерированных графов и замер
результатов — суммарной стоимости найденных решений;
3. построения графика зависимости результата от размера графа для каждого из
алгоритмов.
На рис. 2. приведен этот график зависимости стоимости найденного решения
от размера графа
78
Рис. 2. график стоимостей решений Facility Location Problem.
здесь:
- наивный алгоритм;
- factor-3 алгоритм;
- тривиальный нечеткий алгоритм (алг. 11);
- продвинутый нечеткий алгоритм (алг. 12).
Рис. 3. показывает разность в стоимостях решений найденных factor-3
алгоритмом и нечеткими эвристическими алгоритмами:
- тривиальный нечеткий алгоритм (алг. 11);
- продвинутый нечеткий алгоритм (алг. 12).
Наконец рис. 4. содержит показатель «сложности» коалиций, которые
успешно заменили собой набор открытых факультетов. Эта величина вычисляется
по формуле:

( coal  1) 2
coal  SC
Таким образом, если бы все успешно сработавшие коалиции были бы
тривиальными и состояли всего из одного элемента, то этот график был бы
тождественным нулем.
79
Рис. 3. график преимущества эвристических алгоритмов перед factor-3 алгоритмом.
Рис. 4. график показателя «сложности» коалиций.
Как видно из графиков, наивный алгоритм находит несколько менее
оптимальное решение, чем factor-3 алгоритм, кроме того, для последнего доказано
то, что его решение не более, чем в три раза хуже оптимального. Для наивного же
алгоритма без труда строится пример, когда его решение в сколько угодно раз хуже
оптимального (смотри упражнения в [49]).
Эвристические алгоритмы показали себя с лучшей стороны: на всем
80
множестве решений они выдавали результаты примерно в полтора-два раза лучше,
чем factor-3 алгоритм. Графики обоих эвристических алгоритмов практически
совпадают, однако из рис. 3 следует, что продвинутый нечеткий алгоритм выдает
чуть более оптимальный результат, чем тривиальный. Рис. 4 показывает, что
коалиции, сформировавшиеся в ходе выполнения алгоритма достаточно сложны по
своей структуре. Что подтверждает нетривиальное, интеллектуальное поведение
мультиагентной системы вцелом.
Кроме того, стоит специально отметить тот факт, что оба нечетких алгоритма
выдавали результаты «ноздря в ноздрю» несмотря на то, что и сами нечеткие
алгоритмы и агенты, использованные во время реализации, в корне отличаются.
Это является подтверждением того, что оба алгоритма находили решения,
приближенные к оптимальным.
81
ЗАКЛЮЧЕНИЕ
1. Предложена мультиагентная модель нечетких вычислений. Приведено
обоснование того, что модель естественным и гибким образом расширяет
классическую схему нечеткого вывода.
2. Классическая схема нечеткого вывода может быть представлена, как
частный случай предложенной мультиагентной модели.
3. Предложенный метод позволяет не только более гибким образом
интерпретировать классические нечеткие программы, но и расширяет набор
синтаксических конструкций, доступных программисту. Так например, доступны
конструкции FOR_EACH, FOR, WHILE.
4. Разработана программная библиотека JFuzzyPrincepless, позволяющая
кодировать и интерпретировать нечеткие алгоритмы с расширенным набором
синтаксических конструкций.
5. При помощи исследуемого метода разработан и реализован ряд нечетких
эвристических алгоритмов разной сложности, ищущих приближенное решение NPполной задачи расположения факультетов (Facility Location Problem).
6. Численный эксперимент показывает, что разработанные алгоритмы находят
решения в полтора-два раза оптимальнее решений, найденных известным четким
factor-3 алгоритмом.
82
СПИСОК ЛИТЕРАТУРЫ
1 Заде Л.А. Роль мягких вычислений и нечеткой логики в понимании,
конструировании и развитии информационных интеллектуальных систем. Новости Искусственного Интеллекта, №2-3, 2001, с. 7 - 11.
http://zadeh.narod.ru/zadeh_papers.html
2 web-ресурс Нечеткая логика - математические основы
http://www.basegroup.ru/library/analysis/fuzzylogic/math/
3 Jang J.R. Neuro-Fuzzy and Soft Computing. 1997.
http://lib.prometey.org/?id=15558
4 Заде Л. Понятие лингвистической переменной и его применение к
принятию приближенных решений. – М.: Мир, 1976.
5 Хаптахаева Н.Б., Дамбаева С.В., Аюшеева Н.Н. Введение в теорию
нечетких множеств. Улан-Удэ: Изд-во ВСГТУ, 2004.
http://window.edu.ru/window/library?p_rid=18671
6 Zadeh L.A. Toward a Theory of Fuzzy Systems // Aspect Network and System
Theory. – New York: Rinehart and Winston, 1971.
7 Штовба С.Д. Введение в теорию нечетких множеств и нечеткую логику.
http://matlab.exponenta.ru/fuzzylogic/book1/index.php
8 Ярушкина Н.Г., Семушин И.В., Нуруллин А.Ю. Архитектура internetсервиса экспресс-анализа экономического состояния предприятия на
основе системы нечеткого вывода.
9 Кукса
П.П.
Система
моделирования
нечетких
систем
на
алгоритмическом уровне.
http://paul.rutgers.edu/~pkuksa/publications/fz-sim-02.pdf
10 Рогозин О.В. Метод нечеткого вывода решения в задаче подбора
программного обеспечения на основе качественных характеристик
этого обеспечения как объекта инвестиций.
83
11 Герасимов А.С. Разработка и реализация алгоритма поиска вывода в
расширении бесконечнозначной предикатной логики Лукасевича.
12 S. Bououden, S. Filali, K. Kemih. Adaptive fuzzy tracking control for
unknown nonlinear systems.
13 Chaio-Shiung Chen. Adaptive fuzzy control systems with dynamic structure
14 Jang-Hyun P., Sam-Jun S., Gwi-Tae P. Robust adaptive fuzzy controller for
nonlinear system using estimation of bounds for approximation errors.
15 Shyi-Ming C., Woei-Tzy J. Fuzzy query translation for relational database
systems.
16 Tsadiras K., Konstantinos G. Margaritis A New Balance Degree for Fuzzy
Cognitive Maps
17 Stach W., Kurgan L., Pedrycz W. Reformat Genetic learning of fuzzy
cognitive maps.
18 Margaritis K. G. Two neuron fuzzy cognitive map dynamics
19 Bandyopadhyay S., Baragona R., Maulik U. Fuzzy clustering of univariate
and multivariate time series by genetic multiobjective optimization.
20 Saha I., Maulik U., Bandyopadhyay S. An Improved Multi-objective
Technique for Fuzzy Clustering with Application to IRS Image.
21 Timm H., Döring C., Kruse R. Different approaches to fuzzy clustering of
incomplete datasets.
22 Гегель Г. Сочинения в 14-ти тт. 1929—1958, т. I. М.-Л.: 1929, с. 318—319.
23 Anatole K., Hasselblatt B. Introduction to the modern theory of dynamical systems.
Cambridge. ISBN 0-521-57557-5. 1996.
24 Jorgen R. Elements of the System Dynamics Method. Cambridge: MIT Press.
ISBN 0915299399. 1980.
25 Banks J., Carson J., Nelson B., Nicol D. Discrete-event system simulation - fourth
edition. Pearson. 2005.
26 Мейер Б. Основы ООП.
84
27 Карпов Ю.Г. Моделирование агентов — новая парадигма в имитационном
моделировании.
28 Xin Wang, Xiaojun Shen, Nicolas D. Georganas. A fuzzy logic based intelligent
negotiation agent (fina) in eCommerce. Proc. of the Canadian Conference on
Electrical and Computer Engineering, pp. 276-279. 2006.
29 Collan M. Dynamic management of investments with long economic lives:
extending fuzzy planning to operational management. Proc. of the 6th
Management Accounting Research Conference, May 26-28, University of Twente,
The Netherlands. 2003.
30 Herrera-Viedma E., Peis E., Morales-del-Castillo J.M. Gathering information on
the Web using fuzzy linguistic agents and Semantic Web technologies. Proc. of the
EUSFLAT Conference, pp. 1243-1249. 2005.
31 Бондарева О.Н.
Некоторые
применения
методов
линейного
программирования к теории кооперативных игр. //Проблемы кибернетики. —
Т. 10. — С. 119 - 140. 1963.
32 Bilbao, Jesús. Cooperative Games on Combinatorial Structures, Kluwer Academic
Publishers. 2000.
33 Davis, M.. Maschler, M.. The kernel of a cooperative game. Naval Research
Logistics Quarterly 12: 223–259, doi:10.1002/nav.3800120303 1965
34 Bilbao, Jesús. Cooperative Games on Combinatorial Structures, Kluwer
Academic Publishers. 2000.
35 Jos ́ M. Vidal. Fundamentals of Multiagent Systems with NetLogo
Examples. 2009.
36 Мулен Э. Теория игр с примерами из математической экономики
(Theorie des jeux pour l'economie et la politique).
37 Nash, J. F. The bargaining problem. Econometrica, 18:155–162. 1950.
38 Smith, R. G. The contract net protocol: High-level communication and
control in a distributed problem solver. IEEE Transactions on Computers, C85
29(12):1104–1113. 1981.
39 Davis, R. and Smith, R. G. Negotiation as a metaphor for distributed problem
solving. Artificial Intelligence, 20:63–109. 1983.
40 Conen, W. and Sandholm, T. Partial-revelation VCG mechanism for com-binatorial
auctions. In Proceedings of the National Conference on Artificial Intelligence,
pages 367–372. 2002.
41 Fujishima, Y., Leyton-Brown, K., Shoham, Y. Taming the compu-tational
complexity of combinatorial auctions: Optimal and approximate ap-proaches. In
Proceedings of the Sixteenth International Joint Conference on Artificial
Intelligence, pages 548–553. Morgan Kaufmann Publishers Inc. 1999.
42 Kelly, F. and Stenberg, R. A combinatorial auction with multiple winners for
universal service. Management Science, 46(4):586–596. 2000.
43 Leyton-Brown, K., Pearson, M., and Shoham, Y. Towards a universal test suite for
combinatorial auction algorithms. In Proceedings of the 2nd ACM
conference on
Electronic commerce, pages 66–76. ACM Press. 2000.
44 Aho, S., Ullman. Compilers: Principles, Techniques, and Tools, AddisonWesley, ISBN 0-201-10088-6. 1986.
45 Berkhin P. Survey of Clustering Data Mining Techniques, Accrue Software.
2002.
46 Russell, Stuart, Norvig. Artificial Intelligence: A Modern Approach (2nd
ed.), Upper Saddle River, New Jersey: Prentice Hall, pp. 111-114, ISBN 013-790395-2 2003.
47 Beck, K. Test-Driven Development by Example, Addison Wesley, 2003.
48 Gamma, E., Helm R., Johnson R., Vlissides J. Design Patterns: Elements of
Reusable Object-Oriented Software. Addison-Wesley. ISBN 0-201-63361-2.
1995.
49 Vazirani V. V. Approximation Algorithms (2nd ed.). Springer. ISBN 3-540653667-8 2003.
86
50 Кормен Т. Х. Алгоритмы: построение и анализ — 2-е изд. — М.: «Вильямс»,
— С. 1296. — ISBN 0-07-013151-1. 2006.
51 Hoos, H.H., Stutzle, T. Stochastic Local Search: Foundations and
Applications, Morgan Kaufmann. 2005.
87