Выдержка из текста работы
Экспертные системы — практический результат применения и развития интеллектуальных систем, а также методов искусственного интеллекта — совокупности научных дисциплин, изучающих методы решения задач интеллектуального характера с использованием ЭВМ.
Под интеллектуальной системой будем понимать объединенную информационным процессом совокупность технических средств и программного обеспечения, работающую во взаимосвязи с человеком (коллективом людей) или автономно, способную на основе сведений и знаний при наличии мотивации синтезировать цель, вырабатывать решение о действии и находить рациональные способы достижения цели. [38]
Экспертные системы обычно определяют как программы ЭВМ, моделирующие действия эксперта-человека при решении задач в узкой предметной области на основе накопленных знаний, составляющих базу знаний. ЭС выдают советы, проводят анализ, дают консультации, выполняют классификацию и т.д. Практическое применение ЭС на предприятиях способствует значительному увеличению эффективности работы.
Главным достоинством экспертных систем является возможность накопления знаний и сохранение их длительное время.
В данной дипломной работе ставится задача аппроксимации логического вывода экспертной системы, то есть ее цель заключается в том, чтобы для любого момента времени найти оптимальный выход экспертной системы в виде функции, с заданными параметрами. Актуальность выбранной темы состоит в том, что методов и подходов для решения задачи аппроксимации логического вывода экспертной системы на сегодняшний день известно не очень много. В работе при решении данной задачи используется подход на основе новых методов генетического программирования и сетевого оператора (А.И. Дивеев). Следует отметить, что сетевой оператор может быть также полезен для исследования решений многих нерешенных математических задач. Например, сетевой оператор можно использовать для нахождения приближенного решения любых вариационных, обратных задач, интегралов, интегральных, дифференциальных уравнений и т.д.
Целью дипломной работы является разработка эффективного вычислительного метода аппроксимации логического вывода динамической экспертной системы.
Для достижения поставленной цели было осуществлено решение следующих задач:
— обзор методов и подходов решения поставленной задачи аппроксимации логического вывода экспертной системы;
— разработка и исследование метода сетевого оператора для решения поставленной задачи;
— проведение вычислительного эксперимента.
В основе аппроксимации логического вывода экспертной системы заложен сетевой оператор, основная задача которого — поиск необходимого математического выражения, где можно определить состав математического выражения: входящие параметры, переменные и вычислительные операции. ЭВМ генерирует множество математических выражений, отвечающих указанным требованиям. С помощью оптимизационного алгоритма ЭВМ находит необходимое математическое выражение вместе с входящими в него значениями параметров. Для реализации указанного подхода возникает проблема эффективной записи математического выражения в память ЭВМ. В символьной форме записи, которую использует метод генетического программирования, должны быть строго определены символы операций, операндов и их порядок. При расчете по символьной записи специальная программа (анализатор) расшифровывает выражения и осуществляет вычисления. В данной дипломной работе представлена форма записи математического выражения в виде ориентированного графа, который назван сетевым оператором. Он содержит необходимую информацию для вычисления результата математического выражения: операнды, операции, порядок вычислений. В работе ориентированный граф представлен в виде специальной целочисленной матрицы, построенной на основе матрицы смежности. Здесь структура данных при вычислении результата математического выражения не требует использования анализатора, поэтому быстрее, чем символьная запись, позволяет вычислить результат математического выражения.
Рассмотрим общую постановку задачи аппроксимации логического вывода экспертной системы. Дана некоторая часть экспертной системы и заданы терминальные точки. Необходимо аппроксимировать логический вывод экспертной системы, обеспечив достижение терминальных точек и минимизировать заданные функционалы качества. Решением задачи является множества Парето в пространстве функционалов. Каждая точка множества Парето представляет собой математическое выражение со значением вектора параметров. Конкретная система управления определяется, как одно из решений на множестве Парето, выбираемое по дополнительным критериям.
В дипломной работе в качестве наглядного примера используется замкнутая комната с препятствиями, в которой мобильный робот должен переместиться в некоторые терминальные точки. Для этого была создана программа на основе генетического алгоритма. Для разработки эффективного вычислительного метода решения задачи аппроксимации логического вывода экспертной системы необходимо использовать последнее достижение в области вычислительных алгоритмов, которым является создание метода генетического программирования для решения различных математических задач с помощью ЭВМ. Наиболее важным результатом последних лет в этом направлении является создание метода генетического программирования в 1992 году (J.R. Koza) [8], которое позволяет получить с помощью вычислительной машины аналитические решения различных математических задач. В генетическом программировании для универсального описания математического выражения и его кодировки используется польская запись программного кода, которая представляет собой строку символов, описывающих операторы и операнды. Польская запись является промежуточным кодом, к которому преобразуют трансляторы исходные тексты программ при их переводе в машинные команды. Для строк польской записи Коза разработал генетические операции скрещивания и мутации.
Новый разработанный метод является развитием генетического алгоритма (Davis Lawrence, D.E. Goldberg, J.H. Holland), позволив реализовывать на вычислительной машине любые функциональные зависимости. Методы генетического программирования, основанные на использовании структуры данных в виде строк польской записи, обладают существенными недостатками, связанными с работой с динамической памятью и лексическим анализом строк, что приводит к значительным вычислительным затратам. Для повышения эффективности вычислительных алгоритмов в работе используется метод сетевого оператора, разработанный А.И. Дивеевым, позволяющий в наиболее удобной для поиска на компьютере форме представлять функциональные зависимости.
Основная идея метода сетевого оператора [8, 9] состоит в том, что он позволяет описывать произвольные математические выражения и представлять их в ЭВМ с помощью целочисленной матрицы. Матрица сетевого оператора — это целочисленная матрица, на диагонали которой расположены номера бинарных операций, а остальные элементы либо нули, либо номера унарных операций, причем при замене диагональных элементов на нули, а ненулевых недиагональных элементов на единицы получаем матрицу смежности графа сети, которая удовлетворяет свойствам сетевого оператора [8]. В матрице смежности сетевого оператора вместо единиц, которые соответствуют дугам графа, необходимо записывать соответствующие номера унарных операций, а на диагонали — соответствующие номера бинарных операций. Верхний треугольный вид матрицы сетевого оператора вычисляется по шагам сетевого оператора. Вектор узлов, с помощью которого можно легко совершать вычисления и хранить результаты.
В основе дипломной работы лежит разработка генетического алгоритма для решения задачи аппроксимации логического вывода экспертной системы на основе метода сетевого оператора. При построении генетического алгоритма, работающего с матрицами сетевых операторов, используем принцип базисного решения для того, чтобы не нарушать структуру решения. Генетические операции выполняются не над самой структурой, а над множеством допустимых вариаций структуры. Для решения задачи на основе сетевого оператора необходимо определить конструктивные множества: переменных, параметров, унарных и бинарных операций. Затем необходимо установить размерность сетевого оператора, определить множество вариаций и выбрать базисные решения. После этого реализовать генетический алгоритм для поиска оптимальных решений в среде Delphi 6. Разработанный в дипломной работе метод аппроксимации логического вывода экспертной системы может быть использован в реальных экспертных системах.
1. Экспертные системы
Как было сказано выше, в контурах управления интеллектуальных систем используются динамические экспертные системы. Рассмотрим подробнее структуру, принципы работы и организацию экспертных систем.
Экспертная система [41] — компьютерная система, способная частично заменить специалиста-эксперта в разрешении проблемной ситуации. Современные экспертные системы начали разрабатываться исследователями искусственного интеллекта в 1970-х годах. Предтечи экспертных систем были предложены в 1832 году С.Н. Корсаковым, создавшим механические устройства, так называемые «интеллектуальные машины», позволявшие находить решения по заданным условиям, например определять наиболее подходящие лекарства по наблюдаемым у пациента симптомам заболевания.
В информатике экспертные системы рассматриваются совместно с базами знаний как модели поведения экспертов в определенной области знаний с использованием процедур логического вывода и принятия решений, а базы знаний — как совокупность фактов и правил логического вывода в выбранной предметной области деятельности.
Основные назначения экспертных систем [41]:
1) Интерпретация — процесс определения смысла данных, результаты которого должны быть согласованными и корректными.
2) Планирование — заранее намеченный порядок, последовательность осуществления какой-либо программы, работы, проведения мероприятий.
3) Прогнозирование — обоснованное описание последовательности событий, с возможностью обнаружения новых факторов.
4) Мониторинг — непрерывное оповещение о состоянии системы, приложения или процесса.
5) Проектирование — процесс создания новой информации об объекте, системе (имеется возможность исключения профессионала из процесса проектирования).
6) Диагностика — процесс распознавания состояния на основе имеющихся факторов.
7) Обучение — обучение пользователя, а так же самообучение системы, как на этапе приобретения знаний, так и в процессе работы ЭС (пополнение базы знаний (БЗ) ЭС новыми цепочками вывода).
Классификация экспертных систем:
По способу формирования решения, экспертные системы можно разделить на анализирующие и синтезирующие. В системах первого типа осуществляется выбор решения из множества известных решений на основе анализа знаний, в системах второго типа решение синтезируется из отдельных фрагментов знаний.
В зависимости от способа учета временного признака, экспертные системы делят на статические и динамические:
Статические экспертные системы [36] предназначены для решения задач с неизменяемыми в процессе решения данными и знаниями, а динамические экспертные системы допускают такие изменения.
Динамическая экспертная система (ДЭС) [38] есть некоторое комплексное образование, способное оценивать состояние системы и среды, сопоставлять параметры желаемого и реального результатов действия, принимать решение и вырабатывать управление, способствующее достижению цели. Для этого ДЭС должна обладать запасом знаний и располагать методами решения задач.
По видам используемых данных и знаний различают экспертные системы с детерминированными и неопределенными знаниями. Под неопределенностью знаний и данных понимаются их неполнота, ненадежность, нечеткость.
Экспертные системы могут создаваться с использованием одного или нескольких источников знаний.
Продукционные экспертные сиситемы [2] представляют знания в форме предикатов первого порядка, а правила манипулирования ими — с помощью конструкций «ЕСЛИ — ТО». База правил состоит из множества фраз типа:
-ЕСЛИ объект системы управления не осуществил применение средства воздействия вида ПК (ПУСК = 0)
-И объект системы управления имеет разрешение применения средства воздействия вида ПК (ПУСК = 1)
-ТО система рекомендует применение средства воздейстия вида ПК.
Типовая структура экспертных систем:
Рис. 1 Типовая структура экспертных систем.
Экспертные системы имеют две категории пользователей и два отдельных «входа», соответствующих различным целям взаимодействия пользователей с ЭС:
1. обычный пользователь (эксперт), которому требуется консультация ЭС — диалоговый сеанс работы с ней, в процессе которой она решает некоторую экспертную задачу. Диалог с ЭС осуществляется через диалоговый процессор — специальную компоненту ЭС. Существуют две основные формы диалога с ЭС — диалог на ограниченном подмножестве естественного языка (с использованием словаря-меню (при котором на каждом шаге диалога система предлагает выбор профессионального лексикона экспертов) и диалог на основе из нескольких возможных действий);
2. экспертная группа инженерии знаний, состоящая из экспертов в предметной области и инженеров знаний. В функции этой группы входит заполнение базы знаний, осуществляемое с помощью специализированной диалоговой компоненты ЭС — подсистемы приобретения знаний, которая позволяет частично автоматизировать этот процесс.
Механизм логического вывода (МЛВ) [49] предназначен для получения новых фактов на основе сопоставления исходных данных из рабочей памяти и знаний из базы знаний. Механизм логического вывода во всей структуре экспертной системы занимает наиболее важное место. Он реализует алгоритмы прямого и/или обратного вывода и формально может быть представлен четверкой: <v,s,k,w>. Где:
· V процедура выбора из базы знаний и рабочей памяти правил и фактов;
· S процедура сопоставления правил и фактов, в результате которой определяется множество фактов к которым применимы правила для присвоения значений;
· K процедура разрешения конфликтов, определяющая порядок использования правил, если в заключении правила указаны одинаковые имена фактов с разными значениями;
· W процедура, осуществляющая выполнение действий, соответствующих полученному значению факта (заключению правила).
2. Постановка задачи
Рассмотрим интеллектуальную систему управления с динамической экспертной системой. Система управления использует базу знаний экспертной системы для выработки управления на основе функции логического вывода или принятия решений. Задача заключается в том, чтобы по входным данным, получаемым из базы знаний и известным решениям или выводам, полученным с помощью экспертов аппроксимировать функцию логического вывода. При большом количестве исходных данных и известных решений, полученная в результате аппроксимации функция логического вывода должна обеспечивать получение правильного решения для значений не рассмотренных в процессе обучения. Если полученная функция логического вывода, которая для большинства известных аргументов всегда находит необходимое решение, то наличие экспертной системы в контуре управления не требуется.
Рассмотрим подробнее формальную постановку задачи.
2.1 Формальная постановка задачи
Пусть задано несколько систем управления . В зависимости от дополнительных условий, которые зависят от компонент вектора состояния х, выбираем одну из систем управления. Управление имеет вид:
В соотношении (1) выбор одной системы управления определяет выполнение условия .
Значение дополнительной компоненты управления определяем по функции дополнительных признаков состояния объекта
где — целочисленная функция выбора, y — целочисленный вектор признаков определения выбора
В большинстве случаев функция выбора не задана в аналитическом виде, а определена в виде множеств значений векторов признаков и значений функции выбора
Соотношение (4) задаёт любая экспертная система, которая содержит запись вывода значения функции выбора по значениям векторов признаков
Синтез функции выбора , совместно с синтезирующими функциями , в общем виде затруднён, так как функционалы и начальные условия в задачах синтеза для каждой синтезирующей функции могут быть различны.
Рассмотрим идентификацию функции выбора , с помощью метода сетевого оператора.
Задана экспертная система для значений признаков и функции выбора. Экспертную систему можно формально записать в виде множества строк, которые содержат значения признаков и соответствующее им значение функции выбора
Необходимо найти аналитический вид функции выбора
обеспечивающей минимум функционала
Для решения задачи используется метод сетевого оператора, который обеспечивает генерацию различных функций выбора и поиск решения среди сгененрированныз функций с помощью генетического алгоритма.
3. Разработка алгоритма решения задачи
3.1 Генетический алгоритм и генетическое программирование
Генетический алгоритм — адаптивный метод поиска, который в последнее время часто используется для решения задач функциональной оптимизации. Он основан на генетических процессах биологических организмов: биологические популяции развиваются в течение нескольких поколений, подчиняясь законам естественного отбора и по принципу «выживает наиболее приспособленный» [6].
Подражая этому процессу генетический алгоритм способен «развивать» решения реальных задач, если те соответствующим образом закодированы. Генетический алгоритм может использоваться для проектирования структуры моста, поиска максимального отношения прочности, для использования интерактивного управления процессом или балансировании загрузки на многопроцессорном компьютере [8]. Основные принципы генетического алгоритма были сформулированы Голландом (Holland, 1975) [8]. Алгоритм моделирует те процессы в популяциях, которые являются существенными для развития. Генетический алгоритм работает с совокупностью «особей» — популяцией, каждая из которых представляет возможное решение данной проблемы. Каждая особь оценивается мерой ее «приспособленности» согласно тому, насколько «хорошо» соответствующее ей решение задачи.
Воспроизводится вся новая популяция допустимых решений, выбирая лучших представителей предыдущего поколения, скрещивая их и получая множество новых особей. Это новое поколение содержит более высокое соотношение характеристик, которыми обладают хорошие члены предыдущего поколения. Таким образом, из поколения в поколение, хорошие характеристики распространяются по всей популяции. Скрещивание наиболее приспособленных особей приводит к тому, что исследуются наиболее перспективные участки пространства поиска. В конечном итоге, популяция будет сходиться к оптимальному решению задачи.
Рис. 2 Основные этапы генетического алгоритма.
Особенности генетического алгоритма:
1.варианты решения кодируются битовой строкой (хромосома);
2.поиск осуществляется в кодовом пространстве параметров;
3.оценка вариации решения осуществляется по значению функции приспособленности, которая строится на основе целевой функции и ограничений оптимизационной задачи;
4.разнообразие множества кодов возможных решений достигается за счет специальных операций селекции, скрещивания и мутации;
5.селекция осуществляет отбор пар кодов возможных решений для скрещивания по значению функции приспособленности;
6.скрещивание обеспечивает построение пары новых кодов решений на основе двух отобранных;
7.мутация обеспечивает случайную вариацию кода возможного решения;
8.завершение вычислений осуществляется по удовлетворительному значению функции приспособленности или по конечному числу циклов воспроизводства популяций возможных решений (поколения);
9. решение — хромосома, которая дает наилучшее значение функции приспособленности.
Генетический алгоритм [8] является достаточно мощным средством и может с успехом применяться для широкого класса прикладных задач, включая те, которые трудно, а иногда и вовсе невозможно, решить другими методам. Однако, генетический алгоритм, как и другие методы эволюционных вычислений, не гарантирует обнаружения глобального решения за полиномиальное время, не гарантирует и того, что глобальное решение будет найдено, но они хороши для поиска «достаточно хорошего» решения задачи «достаточно быстро».
Главным же преимуществом генетического алгоритма является то, что они могут применяться даже на сложных задачах, там, где не существует никаких специальных методов. Генетическое программирование [6, 8, 28] впервые предложил Джон Коза в 1992 году, которое является развитием метода генетического алгоритма. Оно появилось при использовании генетического алгоритма для автоматического написания программ, то есть создание такой программы, которая могла бы создавать другие программы без детального описания алгоритма, используя только набор требований и условий. Преимуществом автоматического написания программ является то, что заранее не надо указывать размер, форму, сложность структуры решения. Генетическое программирование является поиском необходимой программы адаптивным и интеллектуальным способом. Интеллектуальный поиск на любом множестве начинается с выбора одной или более структур из данного множества и оценки ее пригодности при решении задачи. Затем эту информацию используем для изменения, улучшения и направления поиска видов выбора структур из множества. В алгоритме выбираем точку, ее пригодность сравниваем с пригодностью близлежащих точек, затем осуществляем движение точки в направлении точки с наилучшей пригодностью. Траектория движения точки зависит от информации, полученной на предыдущих итерациях.
В генетическом программировании возможным решением является код программы, который удовлетворяет заданным требованиям или решает поставленную задачу. Для универсального описания и ее кодировки используется польская запись программного кода. Польская запись является промежуточным кодом, к которому преобразуют трансляторы исходные тексты программ при их переводе в машинные команды. Она является удобным и универсальным видом записи программы. Математическое выражение — это любая запись математических символов, допускающая однозначное вычисление. В генетическом программировании для описания возможного решения используют строку символов, которую называют записью. Каждый символ записи обозначает либо операцию, либо числовой параметр.
Для выполнения операции необходимы операнды. Операции от операндов отличают последовательностью символов записи. Количество необходимых операндов определяют по типу операции. Символ числового параметра не требует операндов. Числовой параметр называют нульместной операцией. В отличие от генетических алгоритмов в генетическом программировании все операции производятся не над строками, а над деревьями. При этом используются такие же операторы, как и в генетических алгоритмах: селекция, скрещивание и мутация.
В генетическом программировании хромосомами являются программы. Генетический алгоритм генерирует массу случайных программ — вариантов решения проблемы. Каждый вариант запускается и оценивается согласно ряду критериев. Алгоритм выбирает из каждого поколения лучшие варианты решения и получает от них потомство. Но в генетических алгоритмах используются кодированные строки, которые обрабатываются программой моделирования, и лучшие из них смешиваются, образуя новое поколение. В генетическом программировании участвуют не кодированные представления решений, а непосредственно компьютерные программы. Генетический алгоритм представляет собой новое направление в алгоритмизации.
Символьная запись:
1. инфиксная (используется для бинарных операций, когда операция ставится между аргументами);
2. префиксная (используется сначала символ операции, затем символьный аргумент);
3. постфиксная (используется сначала аргумент, затем операция);
Путем скрещивания из двух родительских записей (особей, решений) формируются две новые записи (особи, решения).
В генетическом программировании существуют определенные параметры: размер популяции, максимальное число поколений, вероятность скрещивания, мутация и т.д. Так как генетическое программирование обеспечивает поиск решения на множестве функциональных зависимостей, то можем его считать как базовый подход для решения поставленной задачи.
Но генетическое программирование имеет и свои значительные минусы.
Недостатки генетического программирования:
1. требуется анализатор на стадиях преобразования для расшифровки символов при выполнении вычисления с помощью строки символов;
2. число входящих переменных должно равняться числу листьев на дереве;
3. необходимо определять подстроки символов при выполнении операции скрещивания;
4. операция скрещивания может варьировать формулу;
5. сложно задать структуру математического выражения.
Пример 1:
Рис. 3 Функция 1, представленная в древовидной форме.
|
Операция |
Символ |
Число аргументов |
|
|
+ |
+ |
2 |
|
|
* |
2 |
||
|
# |
1 |
||
|
^ |
1 |
||
|
exp |
— |
1 |
|
|
y=x |
@ |
1 |
|
|
x |
X |
0 |
|
|
y |
Y |
0 |
|
|
z |
Z |
0 |
Рис. 4 Функция 2, представленная в древовидной форме.
Произведем скрещивание первой записи и второй.
Рис. 5 Оператор скрещивания для древовидного представления программ.
Одним из основных проблем генетического программирования является способ кодирования программы. Программа должна быть закодирована так, чтобы можно было автоматически вносить случайные изменения (оператор мутации) и объединять два алгоритма в один (оператор скрещивания) и при этом, чтобы не доставляло никаких проблем и трудностей. Существуют два способа кодирования: прямое кодирование — генетический алгоритм работает с программой в явном виде и косвенное кодирование — генетический алгоритм работает не с самим кодом программы, а с правилами его построения. То есть генетический алгоритм работает с программой, которая генерирует нужную нам программу. В древовидном кодировании каждый узел дерева содержит функцию, а каждый лист — операнд, где оператор скрещивания реализуется обменом между двумя деревьями какими — либо узлами вместе с их потомками. Операнд — аргумент операции; данные, которые обрабатываются командой и обозначают выражение, задающее значение аргумента операции; иногда операндом называют место, где должен стоять аргумент операции.
Для осуществления генетического алгоритма на основе непосредственно базисного решения в качестве хромосомы берем упорядоченный набор векторов вариаций. Главными параметрами генетического алгоритма являются количество хромосом, поколений, скрещиваемых пар, количество векторов, то есть длина хромосомы, от которой зависит сложность вычисления. Так как количество поколений в генетическом алгоритме является эпохой, то базисное решение остается неизменным. При смене эпохи базисное решение необходимо поменять на лучшее найденное решение. Для решения задачи на основе сетевого оператора необходимо определить: множество переменных, параметров, унарных, бинарных операций, размерность сетевого оператора, определить множество вариаций и выбрать базисные решения. После этого можно построить генетический алгоритм для поиска решений. Выбор базисного решения влияет на эффективность работы алгоритма, чем ближе к оптимальному по количеству вариаций, тем быстрее найдется решение. В генетическом программировании состояние адаптивной системы в любой момент времени определяется только текущей популяцией записей. Также необходимо хранить контрольные параметры процесса, набор аргументов и функций, наилучшую ранее найденную запись. Никакой дополнительной памяти или централизованного учета не требуется.
Процесс генетического программирования может быть бесконечным, но для получения конкретных результатов его надо завершать, как только выполнен критерий останова. Критерием останова может быть достижение заранее заданного максимального числа поколений или выполнение некоторого дополнительного условия успешного завершения работы. Таким условием может быть нахождение всех правильных решений задачи. В некоторых задачах невозможно определить насколько хорошее решение мы получили или получить точное решение в принципе невозможно. В таких случаях обычно устанавливают подходящий нижний уровень условия успешного завершения работы или анализируют результаты, полученные после прохождения количества поколений. Одним из методов определения результата в генетическом программировании является определение одной из лучшей особи из всех поколений. Мы просто храним лучшую найденную особь и выдаем ее результат, когда процесс завершается по критерии останова. Альтернативным методом является определение лучшей особи в поколении на момент остановки вычислений. Тогда хранение в памяти лучшей особи, полученной в предыдущих поколениях, не требуется. Этот метод обычно дает такой же результат, как и первый, потому что лучшая особь обычно переходит из поколения в поколение или вычисления прекращаются, как только такая особь найдена.
При решении некоторых задач вся популяция или ее часть, выбранная пропорционально, пригодности, объявляется результатом. В этом случае набор особей рассматривается как набор альтернативных решений задачи. В генетическом программировании существует ряд контрольных параметров. Основными численными параметрами являются размер популяции и максимальное число поколений, второстепенными — вероятности скрещивания, воспроизводства, мутации. К качественным параметрам, определяющим путь выполнения вычислений, относятся методы выбора особей для воспроизводства и скрещивания, установленное значение пригодности.
В процессе поиска генетического алгоритма может менять эволюционные настройки, например, размер популяции, вид и параметры генетических операторов.
Уменьшение размера популяции повышает скорость решения задачи, увеличение популяции расширяет область поиска. Изменение размера популяции в зависимости от текущих результатов эволюции, может дать лучший результат за меньшее время, чем при постоянном размере популяции.
3.2 Метод сетевого оператора
Метод генетического программирования [8], основанный на использовании структуры данных в виде деревьев или строк польской записи, является универсальным и может применяться для решения большого количества задач, в которых необходимо автоматическое построение программ. Использование структур данных требует неэкономичных вычислений, связанных с работой с динамической памятью для деревьев или лексическим анализом строк для польской записи. При решении более узкого класса задач, при выборе вида функциональной зависимости — вектор аргументов, , возможно использование более эффективного с точки зрения вычислений аппарата сетевых операторов. Функциональная зависимость может быть представлена в виде дерева, во внутренних узлах которого находятся операции, а во внешних — операнды.
Дерево является видом ориентированного связанного графа без циклов. Любой граф может быть представлен в виде матрицы смежности в котором — количество строк и столбцов равное количеству узлов графа, а элементы равны 1, если существует дуга от узла к узлу и 0, если такой дуги нет. Для повышения эффективности вычислительных алгоритмов в работе используется метод сетевого оператора, позволяющий в наиболее удобной для поиска на компьютере форме представлять функциональные зависимости.
Сетевой оператор [8] — структура данных, которая позволяет представить математическое выражение в форме графа.
Также сетевой оператор — ориентированный граф, который обладает следующими свойствами:
1. граф не имеет циклов;
2. каждый узел графа, который не является источником, имеет путь от какого — либо узла — источника;
3. каждый узел графа, который не является стоком, имеет путь до какого — либо узла — стока;
4. каждый узел графа, который не является источником, связан с какой — либо бинарной операцией .
5. каждая дуга графа соответствует какой — либо унарной операции ;
6. каждый узел — источник графа связан с каким — либо элементом из множества параметров или переменных.
Для четкого понятия сетевого оператора, напишем ряд необходимых определений:
Множество переменных — это упорядоченное множество символов, которые в момент вычисления могут представляться в виде чисел из множества вещественных чисел.
Множество параметров — это упорядоченное множество чисел, не меняющихся в процессе вычислений.
Множество унарных операций — это упорядоченное множество функций, заданных на числовом множестве.
Множество бинарных операций — это упорядоченное множество функций двух аргументов, которое дает один результат.
Любой сетевой оператор соответствует какому — либо математическому выражению. , где — множество чисел, — множество пар чисел.
Граф описывает некоторую структуру, где вершиной графа является узел, а ребром графа — дуга. Если в графе путь (набор вершин) замкнут, то в нем имеется цикл, если нет цикла, то обязательно присутствуют узлы и стоки. В случаи, если в узел не входит ни одна дуга значит, узел является источником. Таким образом, если из узла не выходят дуги, то узел является стоком. Если в ориентированном графе есть узлы и истоки, то такой граф называется сетью. Сетевой оператор позволяет описывать математические выражения, которые состоят из переменных параметров унарных и бинарных операций.
Пример 2: , где — параметры, — переменные, — унарная операция, — бинарные операции. Таким образом, введем множество параметров , множество переменных , множество унарных операций , множество бинарных операций . Причем берем такие операции, которые
1. коммутативны
2. ассоциативны
3. операции должны иметь единичный элемент .
Сетевой оператор отражает структуру графа вычислений и вычислительные операции. Следует отметить, что сетевой оператор позволяет не только описывать граф вычислений в виде дерева, но и структуру вычислений в виде графа сети без циклов.
Правила вычисления по сетевому оператору:
1. Вычисления начинаются с дуги, выходящей из узла, в который не входит никакая другая дуга;
2. Выполняется унарная, которая соответствует дуге, выходящей из найденного узла и бинарная операция, соответствующая узлу, в который дуга входит. В качестве аргумента унарной операции используется значение, которое хранится в найденном узле. В качестве первого аргумента бинарной операции используют либо единицу, либо результат последнего вычисления, который хранится в данном узле. В качестве второго аргумента используем результат вычисления унарной операции;
3. Исключается узел и дуга. Найденный узел исключается, если этот узел не является узлом — стоком, не имеет ни одной выходящей дуги. Дугу исключаем во всех случаях, если операция, которая соответствует данной дуге, выполнена.
Вычисления выполняются до тех пор, пока в сетевом операторе не останутся только узлы — стоки, в которых хранятся результаты вычислений. Выполнение унарной операции согласно выходящей из узла дуге, осуществляется, если в узел, из которого данная дуга выходит, не входит ни одна дуга. Для любой формулы, данной в графическом виде, можно построить сетевой оператор.
Пример 3:
Пример 4:
Запишем множество параметров , множество переменных , множество унарных операций , множество бинарных операций .
Построение математического выражения в виде сетевого оператора:
1. Программная запись — запись математического выражения, с помощью компонентов конструктивных множеств (множество параметров , множество переменных , множество унарных операций , множество бинарных операций ).
Пример 5:
Пример 6:
Пример 7:
2. Графическая запись — программная запись, которая отвечает следующим свойствам:
а) внешняя операция бинарная;
б) аргументами бинарной операции могут быть только унарные операции;
в) аргументами унарной операции могут быть либо бинарная операция, либо параметр; (либо )
г) аргументами бинарной операции не могут быть унарные операции, аргументами которой является одна и та же переменная или параметр один и тот же.
Утверждение: любую программную запись можно привести к графической записи с помощью введения тождественной унарной операции и с помощью введения дополнительной бинарной операции к одним из аргументов, которой является единственный элемент.
Пример 8:
Правило построения графа по графической записи:
Номер унарной операции соответствует дуге, а бинарной операции — узлу.
Число узлов на графе должно быть не меньше, чем сумма чисел количества параметров, переменных и бинарных операций.
Пример 9:
Граф для графической записи является сетевым оператором.
3.3 Матрица сетевого оператора
Сетевой оператор [8, 28] представляет собой ориентированный граф без циклов, поэтому его структуру можно описать с помощью матрицы смежности верхнего треугольного вида. Утверждение: матрица смежности любого ориентированного графа без циклов с помощью изменения номеров узлов всегда может быть представлена в верхнем треугольном виде. Матрица сетевого оператора — это целочисленная матрица, на диагонали которой расположены номера бинарных операций , а остальные элементы либо нули, либо номера унарных операций , причем при замене диагональных элементов на нули, а ненулевых недиагональных элементов на единицы получаем матрицу смежности графа сети. Чтобы представить граф в памяти компьютера используется матрица смежности (показывает какой узел, с каким узлом соединяется), которая состоит из 1 и 0, имеет размерность , где — число узлов в графе. 1 находится на пересечении — строки и — столбцы, где — номер узла, откуда выходит дуга, а — номер узла, куда входит дуга. Для графической записи желательно пронумеровать узлы так, чтобы номер узла от дуги выходит, был меньше, куда дуга входит. Для ориентированного графа без циклов это всегда можно сделать. Матрица сетевого оператора имеет ту же структуру, что и матрица смежности, только вместо единиц стоят номера унарных операций , а на диагоналях стоят номера бинарных операций .
Пример 10:
Для более четкого представления и вычисления формулы по матрице сетевого оператора используем следующий алгоритм: Шаг 0. Задана матрица сетевого оператора в верхнем треугольном виде , , если , , Определены векторы номеров узлов входных переменных , параметров и вектор номеров узлов выходных переменных
Шаг 1. Задаем начальные значения вектора узлов
где — единичный элемент для бинарной операции, — множество номеров узлов-источников или номеров нулевых столбцов матрицы сетевого оператора.
Шаг 2. .
Шаг 3. .
Шаг 4. Если , то .
Шаг 5. . Если , то переходим на шаг 4.
Шаг 6. . Если , то переходим на шаг 3, иначе завершаем вычисления.
3.4 Метод вариаций сетевого оператора
Вариация сетевого оператора [8] — это такое изменение сетевого оператора, которое приводит к однотипному сетевому оператору. Верхний треугольный вид матрицы сетевого оператора вычисляется по шагам сетевого оператора. Он проходит строки матрицы и вычисляет их с помощью унарных операций , у которых ненулевые недиагональными элементы в строке, и бинарные операции , где номера являются диагональными элементами, расположенные в столбцах с ненулевыми недиагональными элементами. Вектор узлов , с помощью которого можно легко совершать вычисления и хранить результаты, где — количество узлов сетевого оператора. Для первого шага вычислений необходимо задать начальные значения вектора узлов. Векторы аргументов определяют номера узлов источников сетевого оператора. Если в бинарной операции имеется сложение, то единицей для данной операции является ноль, а, если умножение, то единица. Начальное значение вектора узлов , последовательно проходим в матрице сетевого оператора все строки по столбцам. Если встречаем в строке в столбце не нулевой элемент, то выполняем сначала унарную операцию , номер которой определяем по элементу матрицы сетевого оператора, над значением элемента вектора узлов. Затем над результатом вычислений выполняем бинарную операцию , номер которой определяем по элементу матрицы сетевого оператора, причем первым аргументом бинарной операции является последнее значение элемента вектора узлов. Результат вычислений присваиваем элементу вектора узлов. Рассмотрим операции по шагам, которые необходимо выполнить при каждой вариации. Для некоторых вариаций необходимо выполнить проверку ее допустимости. Вариация выполняется, если она допустима. При выполнении вариаций необходимо выполнить следующие действия:
Шаг 0. Определяем дугу и меняем номер унарной операции, с которой связана дуга, .
Шаг 1. Определяем узел и меняем номер бинарной операции, с которой связан узел, , если .
Шаг 2. Определяем два узла и добавляем дугу между ними вместе с унарной операцией .
Шаг 3. Определяем дугу , проверяем, если в узел входит еще одна дуга, , то удаляем дугу , , .
Шаг 4. Определяем номер , который будет присвоен последнему узлу , проверяем, если не существует узлов, начиная с номера , откуда выходят дуги, входящие в узел , то узлу присваиваем номер , и увеличиваем на единицу номера всех узлов, начиная с номера .
Шаг 5. Определяем номер , которому будет присвоен последний номер , проверяем, если из узла не выходит ни одна дуга, то узлу присваиваем номер , а всем остальным узлам, начиная с номера , уменьшаем номера на единицу.
Шаг 6. Добавляем еще один узел с бинарной операцией и дугу с унарной операцией . Шаг 7. Удаляем последний узел , , с входящей в него дугой . Задаем унарные и бинарные операции:
0 — единица для сложения, 1 — единица для умножения, Пример 11:
— матрица смежности,
— матрица сетевого оператора.
— матрица сетевого оператора, — вектор узлов.
Строка 1:
Строка 2:
Строка 3:
Строка 4:
— базисное решение.
Вариации сетевого оператора:
0 — изменение унарной операции, связанной с дугой сетевого оператора; 1 — добавление дуги вместе с унарной операцией; 2 — изменение бинарной операции, связанной с узлом сетевого оператора; 3 — удаление дуги, если узел, куда дуга входит, имеет еще и входящую дугу; 4 — увеличение номеров узлов; 5 — уменьшение номеров узлов; 6 — добавление узла с бинарной операцией и входящей в узел дуги, связанной с унарной операцией; 7 — удаление узла вместе с входящей в него дугой, если узел является узлом — стоком и в него входит только одна дуга.
Рассмотрим пример 11 далее:
Строка 1:
Строка 2:
Строка 3:
Строка 4:
Находим вариацию для данного примера, где — вектор вариации, — номер вариации; — номер строки; — номер столбца; — номер операции, — длина вариации.
При построении генетического алгоритма для решения задачи аппроксимации логического вывода экспертной системы используем принцип базисного решения. Данный принцип заключается в том, что задается одно базисное решение в виде сетевого оператора, описывающего математическое выражение. Множество возможных решений определяется множеством вариаций базисного решения. Основная цель работы генетического алгоритма состоит во внесении таких изменений (вариаций) в матрицу сетевого оператора базисного решения, чтобы на выходе получился сетевой оператор, представляющий формулу искомого оптимального управления. Внесение изменений в матрицу сетевого оператора базисного решения осуществляем путем последовательного внесения в нее малых вариаций одного из перечисленных типов: замена унарной операции на дуге графа; замена бинарной операции в узле графа; добавление дуги; удаление дуги, т.е. используем вариации, которые не влияют на размерность сетевого оператора. Каждая вариация изменяет граф сетевого оператора, сохраняя его свойства. При реализации генетического алгоритма на основе принципа базисного решения в качестве хромосомы используем упорядоченный набор векторов вариаций. Для того чтобы обеспечить достаточную вариабельность решений при малой длине хромосомы необходимо периодически изменять базисное решение. Базисное решение изменяем после нескольких поколений, или эпох, которые являются основными циклами генетического алгоритма. При смене эпохи базисное решение заменяется наилучшим найденным решением, при этом в популяции необходимо создать тождественную хромосому, состоящую из векторов вариаций, не меняющих решение.
4. Вычислительный эксперимент
Для более наглядного примера была рассмотрена задача о достижении мобильным роботом терминальных точек, расположенных в замкнутой комнате с препятствиями. Экспертом были составлены оптимальные пути движения робота из разных точек этой комнаты и введены в экспертную систему продукционного вида (см. стр. 11), часть которой была загружена в программный комплекс.
Рис. 6 Комната с препятствиями (пример)
Координаты терминальных точек (целей):
Расположение управления:
Далее приведена небольшая часть экспертной системы:
Полную экспертную систему, загруженную в программу для обучения, можно посмотреть в приложении В.
Таким образом, если робот находится в точке (0,1) и движется к цели №3, то он выбирает путь движения (управление) 2, исходя из выхода экспертной системы. Либо, если робот находится в точке (5,14) и движется к цели №2, то он выбирает путь движения (управление) 1.
После загрузки экспертной системы в программу, производится обучение робота (получение функции, которая заменит собой экспертную систему) с помощью генетического алгоритма на основе сетевого оператора.
Часть программного кода, разработанного в среде Delphi 6, представлена в приложении А.
4.1 Описание программы
Эксперимент проводится на программном комплексе для аппроксимации логического вывода экспертной системы в среде Delphi 6.
Рис. 7 Главное меню программы
Главное меню содержит следующие разделы:
1) Раздел Initial data:
a. Parameters of initial data — ввод количества входов, выходов, а так же количества точек.
b. Initial data — отображение введённой части экспертной системы. В этом окне можно загрузить экспертную систему из файла, сохранить её в файл, а так же изменять введённую экспертную систему.
2) Раздел Load ExpSys — загрузка полной экспертной системы (для проверки)
3) Раздел Network operator:
a. Parameters of Network Operator Matrix — ввод параметров матрицы сетевого оператора.
b. Network operator — матрица сетевого оператора. Её можно загрузить или сохранить, а так же изменять в этом окне.
4) Раздел Genetic algorithm:
a. Create object — Parameters of object for GA with NOM — Создание объекта для генетического алгоритма (ввод количества хромосом в популяции, количества функционалов и количества вариаций в одной хромосоме).
b. Parameters of GA — Genetic algorithm with network operator — Ввод параметров генетического алгоритма.
c. Search of Pareto Set — поиск множества Парето
5) Раздел Solution:
a. Show — просмотр полученных выражений
b. Print to file — запись полученных выражений в файл
c. Clear — очистить окно
6) Раздел The set of Pareto:
a. Pareto set — множество Парето
7) Раздел Simulation:
a. Simulation after the teaching — Показывает полученные графики (совпадение точек, полученных с помощью выведенной формулы с точками из взятой нами полной экспертной системы). Так же в этом окне производится расчет выходного значения по заданным входам и цели.
4.2 Моделирование эксперимента
Проводим эксперимент, используя часть составленной нами экспертной системы. Для поиска решений используем генетический алгоритм с параметрами, приведёнными в Таблице № 1 и программу из Приложения A для аппроксимации логического вывода экспертной системы методом сетевого оператора.
Таблица 1
Параметры генетического алгоритма
|
Параметр |
Значение |
|
|
Размер начальной популяции хромосом или возможных решений |
512 |
|
|
Число поколений |
512 |
|
|
Число пар в одном поколении |
128 |
|
|
Число изменений в одной хромосоме |
8 |
|
|
Число функционалов |
2 |
|
|
Число искомых параметров |
3 |
|
|
Число поколений в одной эпохе между сменой базисного решения |
10 |
|
|
Число элитарных хромосом |
32 |
|
|
Параметр для скрещивания |
0.4 |
|
|
Вероятность мутации |
0.7 |
|
|
Размер матрицы сетевого оператора |
32 |
|
|
Число переменных |
3 |
|
|
Число выходных параметров |
2 |
Рис. 8 Базисная матрица сетевого оператора.
Для решения используем множество унарных и бинарных операций из Приложения Б.
z_0=x_0
z_1=x_1
z_2=x_2
z_3=And2(2,z_0)
z_4=And2(2,z_1,z_0)
z_5=And2(2,z_2,not z_1,z_0)
z_6=Equ2(0,z_5,z_4,z_3)
z_7=Xor2(0,z_5,z_4,z_3)
z_8=Or2(0,z_7,z_6)
z_9=Or2(0,z_8)
z_10=And2(2,z_9)
z_11=Xor2(0,z_10)
z_12=Or2(0,z_11)
z_13=Or2(0,z_12)
z_14=Or2(0,z_13)
z_15=Or2(0,z_14,not z_12)
z_16=Or2(0,z_15)
z_17=Or2(0,z_16)
z_18=Or2(0,z_17,z_2)
z_19=Or2(0,z_18)
z_20=Or2(0,z_19)
z_21=Or2(0,z_20,not z_18)
z_22=Or2(0,z_21)
z_23=Or2(0,z_22)
z_24=Or2(0,z_23,not z_18)
z_25=Or2(0,not z_24)
z_26=Or2(0,z_25)
z_27=Or2(0,z_26,not z_3)
z_28=Xor2(0,z_27)
z_29=And2(2,z_28,not z_22)
z_30=Or2(0,z_29)
z_31=Or2(0,z_30)
Исследование 1:
Рассмотрим область Парето:
Рис. 9 Множество Парето
Условное множество Парето
|
№ |
Кол-во решений |
F_0 |
F_1 |
|
|
0 |
0 |
85 |
110 |
|
|
1 |
46 |
85 |
110 |
|
|
2 |
53 |
85 |
110 |
|
|
3 |
71 |
85 |
110 |
По значению F_0 видно, что из 299 введённых точек экспертной системы, мы смогли обучить робота только на 214 точек (299-85=214). Значение F_1 показывает сумму, на которую отличается требуемое и полученное управления.
Результаты моделирования представлены на рис. 10, 11 (Остальные графики моделирования представлены в приложении Г).
Рис. 10 Результат сравнения работы полученной функции с выходами экспертной системы
Рис. 11 Результат сравнения работы полученной функции с выходами экспертной системы
Из полученных графиков мы можем сделать вывод, о количестве совпавших точек:
Взяли выборку из 100 случайных точек: , и получили 73% совпадений, учитывая то, что введённая часть экспертной системы даёт только совпадений. Следовательно, полученная нами функция даёт достаточно хороший результат и может уже сейчас заменить собой данную экспертную систему.
Исследование 2:
Для получения более точного результата алгоритм был запущен ещё несколько раз.
Рассматриваем область Парето:
Рис. 12 Множество Парето
Таблица 2
Условное множество Парето
|
№ |
Кол-во решений |
F_0 |
F_1 |
|
|
0 |
0 |
72 |
93 |
|
|
1 |
1 |
72 |
93 |
|
|
… |
… |
… |
… |
|
|
96 |
230 |
72 |
93 |
|
|
… |
… |
… |
… |
|
|
213 |
511 |
72 |
93 |
В таблице 2 приведены номера возможных решений во множестве. В условном множестве Парето 512 точек.
По значению F_0 видно, что из 299 введённых точек экспертной системы, мы смогли обучить робота только на 227 точек (299-72=227). Значение F_1 показывает сумму, на которую отличается требуемое и полученное управления.
Базисное решение, записанное с помощью матрицы сетевого оператора размерностью , имеет вид :
0 4 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 4 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 0 0 0 0
0 0 0 0 1 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 3 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 2 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 2 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 3 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 3 0 0 4 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 3 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 3 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 2 1 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
Результаты моделирования со сравнением решения от полученной формулы с изначальной экспертной системой представлены на последующих рисунках 13,14 (Остальные графики моделирования представлены в приложении Г):
Рис. 13 Результат сравнения работы полученной функции с выходами экспертной системы
Рис. 14 Результат сравнения работы полученной функции с выходами экспертной системы
Из графиков видно, что полученная формула удовлетворяет нас, как решение поставленной задачи аппроксимации логического вывода экспертной системы, т.к. при сравнении результатов, полученных с помощью формулы и результатов из изначальной экспертной системы, видим, что вероятность их совпадения для выборки из 100 случайных точек достаточно велика: , то есть мы получили 76% совпадений, учитывая то, что введённая часть экспертной системы даёт только совпадений.
Заключение
В данной дипломной работе было осуществлено решение следующих задач:
1. Разработан и исследован метод сетевого оператора для аппроксимации логического вывода экспертной системы, который является графическим представлением разнообразных сложных формул. Определены его свойства, обоснован метод преобразования формулы в сетевой оператор.
2. Рассмотрен принцип матрицы смежности сетевого оператора с помощью, которой было показано построение матрицы сетевого оператора, являющееся эффективной структурой данных для вычисления формулы, а также создан алгоритм вычисления формулы по матрице сетевого оператора.
3. На основе разработанного метода получена формула, заменяющая собой экспертную систему. С помощью моделирования показано, что данная формула обеспечивает получение результата, аналогичного результату из экспертной таблицы.
4. Программа разработана в среде Dеlphi 6, реализующая алгоритм для решения задачи аппроксимации логического вывода экспертной системы на основе генетического программирования с сетевым оператором. Несмотря на всю представленную сложность, алгоритм управления можно реализовать на ЭВМ.
Список литературы
1. Беллман Р. «Динамическое программирование» — М.: ИЛ, 1960;
2. Васильев С.Н., Жерлов А.К., Федосов Е.А., Федунов Б.Е. Интеллектуальное управление динамическими системами. — М.: Физико-математическая литература. 2000. — 253 с. — ISBN 5-9221-0-50-5.
3. Васильев В.И., Ильясов Б.Г. Интеллектуальные системы. Теория и практика. М.: Радиотехника, 2009. 392 с.
4. Васильевский А.С., Исследование принципов построения экспертных систем реального времени — отчет о НИР №96-01-00595 (Российский фонд фундаментальных исследований)
5. Гаврилова Т.А., Хорошевский В.Ф. Базы знаний интеллектуальны систем. — Спб: Питер, 2000. — 384 c.
6. Гладков Л.А., Курейчик В.В., Курейчик В.М. «Генетические алгоритмы» — М.: ФИЗМАТЛИТ, 2006;
7. Грибова В.В., Клещев А.С., Шалфеева Е.А. Управление программными средствами в интеллектуальных системах//Изв. РАН. ТиСУ. 2010. №6. С. 122-137.
8. Дивеев А.И., Софронова Е.А. «Основы генетического программирования Учебно-методическое пособие» — М.: Изд-во РУДН, 2006;
9. Дивеев А.И., Шмалько Е.Ю. «Метод генетического программирования для решения задачи оптимального управления» — М.: Научная сессия МИФИ-2008, том 10, «Интеллектуальные системы и технологии», 2008;
10. Дивеев А.И., Софронова Е.А. Метод генетического программирования для автоматического подбора формул в задаче структурного синтеза системы управления // Труды института системного анализа РАН. Динамика неоднородных систем. / Под ред. Ю.С. Попкова. — Вып. 10(1). — М.: ИСА РАН, КомКнига, 2010. — С. 14-26.
11. Дивеев А.И., Сафронова Е.А. Метод сетевого оператора и его применение в задачах управления. — М.:РУДН, 2012. — 182 с.
12. Дивеев А.И. Метод сетевого оператора. М.: Изд-во ВЦ РАН.2010.178 с.
13. Дивеев А.И. Метод сетевого оператора. — М.: Учреждение Российской академии наук Вычислительный центр им. А.А. Дородницына РАН, 2010.
14. Дивеев А.И., Софронова Е.А., Идентификация системы логического вывода методом сетевого оператора — Вестник Российского университета дружбы народов. Серия: Инженерные исследования. 2010.№ 4. С. 51-59.
15. Дивеев А.И., Софронова Е.А. Генетический алгоритм для многокритериального структурно-параметрического синтеза // Вестник Российского университета дружбы народов. Серия «Инженерные исследования». — 2007. — №4. — С. 126—131.
16. Дивеев А.И., Софронова Е.А. Метод сетевого оператора для идентификации систем управления // Вестник Российского университета дружбы народов. Серия «Инженерные исследования». — 2008. — №4. — С. 78—85.
17. Дивеев А.И., Софронова Е.А. Метод генетического программирования для автоматиче ского подбора формул в задаче структурного синтеза системы управления // Труды инсти тута Системного анализа РАН. Динамика неоднородных систем / Под ред. Ю.С. Попкова. — М.: ИСА РАН: КомКнига, 2006. — Вып. 10(1). — С. 14—26.
18. Дивеев А.И., Крылова М.В., Софронова Е.А. Метод генетического программирования для многокритериального структурно-параметрического синтеза систем автоматического управления // Вопросы теории безопасности и устойчивости систем: Сб. статей. — М.: ВЦ РАН, 2008. — Вып. 10. — С. 93—100.
19. Джарратано Дж. Экспертные системы. Принципы разработки и программирование / ДжозефДжарратано, Гари Райли. — 4-е изд. — М.: Вильямс, 2006. — 1152 с.
20. Джексон П. Введение в экспертные системы. М.: Издательский дом «Вильямс», 2001. -624 c.
21. Долин Г., Что такое ЭС. — Компьютер Пресс, 1992/2.
22. Дюк В., Самойленко А., Data Mining: учебный курс. — СПб.: Питер, 2001. — 368 с.
23. Евстигнеев Д.В. «Интеллектуальный мобильный робот» — М.: Энергия, 2008;
24. Еремеев А.П., Проблема корректности базы знаний в динамических экспертных системах — Известия Южного федерального университета. Технические науки. 1997. Т. 6. №3. С. 213-214.
25. Искусственный интеллект: современный подход. — М.: Издательский дом «Вильямс», 2006. — 1408 c.
26. Искусственный интеллект. Кн. 1. Системы общения и экспертные системы: Справочник / Под ред. Э.В. Попова. — М.: Радио и связь. 1990. -464с.
27. Корнеев В.В., Гареев А.Ф., Васютин С.В., Райх В.В., Базы данных. Интеллектуальная обработка информации. — М.: Изд-во «Нолидж», 2000. — 352 c.
28. Курейчик B.M. «Генетические алгоритмы» — Таганрог: Изд-во ТРТУ, 1998;
29. Кусимов С.Т., Васильев В.И., Ильясов Б.Г. Управление динамическими системами в условиях неопределенности М.: Наука, 1998. 625 с.
30. Лернер А.Я., Розенман Е. А. «Оптимальное управление» — М.: Энергия, 1970;
31. Ли Э.Б., Маркус Л. «Основы теории оптимального управления» — М.: Наука, 1972;
32. Макаров И.М., Лохин В.М. Интеллектуальные системы автоматического управления — М ФИЗМАТЛИТ, 2001 — 576 с — ISBN 5-9221-0162-5
33. Нейлор К. Как построить свою экспертную систему: — М.: Энергоатомиздат, 1991.
34. Нзамба Сенуво, Чинакал В.О. Разработка структуры интеллектуальной системы поддержки принятия решений при управлении установкой первичной переработки нефти. Вестник Российского Университета Дружбы Наровод. Серия: Инжененрные исследования №4, 2010г. 79-87 стр.
35. Попов Э.В., Кисель Е.Б., Кондрашова Е.Н., Ломакина В.В., Ломохов Г.А., Тюжина Е.А., Фоминых И.Б., Теоретическое и экспериментальное исследование принципов создания и использования динамических экспертных систем — отчет о НИР № 95-01-01278 (Российский фонд фундаментальных исследований)
36. Попов Э.В., Фоминых И.Б., Кисель Е.Б., Шапот М.Д. Статические и динамические экспертные системы // под ред. Попова Э.В. — М.: Финансы и статистика, 1996. — 320 с.
37. Построение экспертных систем. Под ред. Ф. Хайеса-Рота и др. — М., «Мир», 1987.
38. Пупков К.А., Коньков В.Г. Интеллектуальные системы. // МГТУ им. Н.Э. Баумана. М., 2003.
39. Рутковская Д., Рутковский Л. Нейронные сети, генетические алгоритмы и нечеткие системы. М.: Горячая линия, 2008. 355 с.
40. Рутковская Д., Пилиньский М., Рутковский Л. Нейронные сети, генетические алгоритмы и нечеткие системы: Пер. с польск. Рудинский И.Д. — М.: Горячая линия — Телеком, 2009 г. — 452 с.
41. Сидоркина И.Г. Системы искусственного интеллекта. — КноРус. 2011. 248 с.
42. Сойер Б., Фостер Д.Л. Программирование экспертных систем на Паскале. — М.: Финансы и статистика, 1990.
43. Сороколетов П.В., К вопросу построения динамических экспертных систем — Известия ТРТУ
44. Таунсенд К., Фохт Д. Проектирование и программная реализация экспертных систем на персональных ЭВМ. — М.: Фининсы и статистика, 1990.
45. Электронный журнал «Молодежный научно-технический вестник». Издатель ФГБОУ ВПО «МГТУ им. Н.Э. Баумана». Эл No. ФС77-51038. ISSN 2307-0609.
46. Diveyev A.I., Sofronova E.A. Application of network operator method for synthesis of optimal structure and parameters of automatic control system // Proceedings of 17-th IFAC World Congress, Seoul, 2008, 05.07.2008—12.07.2008. — P. 6106—6113.
47. Dorigo M., Maniezzo V. Parallel Genetic Algorithms: Introduction and Overview of Current Research. // Parallel Genetic Algorithms: Theory and Applications. / Ed. by J. Stenders. — Amsterdam, IOS Press, 2012.
48. Goldin D.A., Pavlov B.V., Chesnokov A.M. Structures of informational control complex of technical systems / IFAC Symposium on Manufacturing, Modeling, Management and Control. MIM 2000. Greece, 2000. Preprints, P. 217-221.
49. http://www.aiportal.ru — Экспертные системы, Структура экспертной системы (Дата обращения: 07.04.2013)
50. http://www.cosc.brocku.ca — Recursive problem of calibration of expert systems (Дата обращения: 18.04.2013)
51. http://www.deepdyve.com/lp/association-for-computing-machinery/modeling-of-thoughtful-behavior-with-dynamic-expert-system-0gizU90uVy?autoClickRent=true (Дата обращения: 05.05.2013)
52. http://elibrary.ru -научная электронная библиотека (Дата обращения: 01.03.2013)
Приложения
Приложение А
unit Unit1;
//*********************************************************
INTERFACE
//*********************************************************
uses
Windows, Messages, SysUtils, Variants, Classes,
Graphics, Controls, Forms,Log02,
Dialogs, StdCtrls, ComCtrls, Menus, UnitLogObjects;
type
TForm1 = class(TForm)
SaveDialog1: TSaveDialog;
ProgressBar1: TProgressBar;
Label1: TLabel;
Memo1: TMemo;
PopupMenu1: TPopupMenu;
Unaryoperations1: TMenuItem;
Binaryoperations1: TMenuItem;
MainMenu1: TMainMenu;
Initialdate1: TMenuItem;
Networkoperator1: TMenuItem;
Ge1: TMenuItem;
Createobject1: TMenuItem;
ParametersofGA1: TMenuItem;
SearchofParetoset1: TMenuItem;
Paretoset1: TMenuItem;
Simulation1: TMenuItem;
Showsolution1: TMenuItem;
Show1: TMenuItem;
Printtofile1: TMenuItem;
Clear1: TMenuItem;
LoadExpSys1: TMenuItem;
procedure LoadExpSys1Click(Sender: TObject);
procedure Printtofile1Click(Sender: TObject);
procedure Clear1Click(Sender: TObject);
procedure Show1Click(Sender: TObject);
procedure Simulation1Click(Sender: TObject);
procedure Paretoset1Click(Sender: TObject);
procedure SearchofParetoset1Click(Sender: TObject);
procedure ParametersofGA1Click(Sender: TObject);
procedure Createobject1Click(Sender: TObject);
procedure Networkoperator1Click(Sender: TObject);
procedure Initialdate1Click(Sender: TObject);
procedure Binaryoperations1Click(Sender: TObject);
procedure UnaryOperations1Click(Sender: TObject);
Procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
TUser=class(TGANOPLog)
Constructor Create (hh1, pp1, rr1, nfu1, lchr1, epo1,
kel1: integer; alfa1, pmut1: real; L1, Mout1,
kp1,kw1,kv1: integer);
Procedure Func(var Fu:TArrInt); override;
end;
const
Pnumc:array[0..2] of integer=(0,1,2);
Dnumc:array[0..1] of integer=(31,31); //15,15
xinpc:array[0..26,0..2]of integer=
((0,0,0),(0,0,1), (0,0,2),(0,1,0),
(0,1,1),(0,1,2), (0,2,0),(0,2,1),
(0,2,3),(3,0,0), (1,0,1),(1,0,2),
(1,1,0),(1,1,1), (1,1,2),(1,2,0),
(1,2,1),(1,2,2), (2,0,0),(2,0,1),
(2,0,3),(3,1,0), (2,3,1),(2,1,2),
(2,2,0),(2,2,1), (2,2,2));
youtc:array[0..26] of integer=
( 0, 1, 2, 3,
1, 2, 0, 1,
2, 3, 1, 0,
0, 1, 2, 0,
1, 2, 0, 1,
2, 3, 1, 0,
0, 1, 2);
PsiBasc:array[0..31,0..31] of integer =
((0,0,0,1, 1,1,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 1,1,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,1,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,1, 0,0,1,1, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 1,0,1,1, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,1,1,1, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 1,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,1, 1,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,1,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,1,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,1, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 1,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,1,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,1,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,1, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 1,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,1,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,1,0, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,1, 0,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 1,0,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,1,0,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,1,0, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,1, 0,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 1,0,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,1,0,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,1,0, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,1, 0,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 1,0,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,1,0,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,1,0),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,1),
(0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0));
Form1: TForm1;
EA:TUser;
hh1:integer=512; //256 number of chromosomes in an initial population
pp1:integer=512; // number of generations
rr1:integer=128; //128 number of couples in one generation
nfu1:integer=2; // number of functionals
lchr1:integer=8; //number of variations in one chromosome
Epo1:integer=10; // number of generations between exchange of basic NOM
kel1:integer=32; // number of elitaring chromosomes
alfa1:real=0.4; // parameter for crossover
pmut1:real=0.7; // probability of mutation
L1:integer=32; // dimension of network operator matrix
kP1:integer=3; //cardinal of set of variables
kw1:integer=2; //cardinal of set of unary operations
kv1:integer=4; //cardinal of set of binary operations
Mout1:integer=2; // number of outputs
Pnum1,
Dnum1:TArrInt;
Psi1:TArrArrInt;
kChoose:integer;// number of choose chromosome
xinp,xinp1:TArrArrInt;
yout,yout1:TArrArrInt;
xetc1:array of array of integer;
yetc1:array of array of integer;
nx:integer=3;
ny:integer=2;
np:integer=27;
Procedure UpProgressBar;
Procedure Gendatas;
//*********************************************************
IMPLEMENTATION
//*********************************************************
Uses Calc5, Calc4, Unit3, Unit2, Unit7, Unit11, Unit6, Unit8, Unit10, Unit12, Unit13;
{$R *.dfm}
Procedure TForm1.Binaryoperations1Click(Sender: TObject);
Begin
Form5:=TForm5.create(self);
Form5.ShowModal;
End;
Procedure TForm1.Clear1Click(Sender: TObject);
Begin
memo1.Clear;
End;
Procedure TForm1.Createobject1Click(Sender: TObject);
Begin
Form6:=TForm6.create(self);
Form6.ShowModal;
EA:=TUser.Create(hh1, pp1, rr1, nfu1, lchr1, epo1,
kel1,alfa1, pmut1, L1, Mout1,kp1,kw1,kv1);
EA.NOP.SetPnum(Pnum1);
EA.NOP.SetDnum(Dnum1);
EA.NOP.SetPsi(Psi1);
EA.EndGeneration:=Upprogressbar;
Createobject1.Enabled:=false;
Simulation1.Enabled:=true;
End;
Procedure TForm1.FormCreate(Sender: TObject);
i:integer;
j: Integer;
Begin
randomize;
ProgressBar1.top:=212;
ProgressBar1.left:=0;
ProgressBar1.width:=ClientWidth;
Memo1.Top:=0;
Memo1.Left:=0;
Memo1.Height:=progressbar1.top;
Memo1.Width:=ClientWidth;
Memo1.ReadOnly:=true;
Setlength(xinp1,np,nx);
Setlength(yout1,np,ny);
Simulation1.Enabled:=false;
Setlength(Pnum1,kP1);
Setlength(Dnum1,Mout1);
Gendatas;
for i:=0 to kP1-1 do
Pnum1[i]:=Pnumc[i];
for i:=0 to Mout1-1 do
Dnum1[i]:=Dnumc[i];
SetLength(Psi1,L1,L1);
for i:=0 to L1-1 do
for j:=0 to L1-1 do
Psi1[i,j]:=PsiBasc[i,j];
End;
Procedure TForm1.Initialdate1Click(Sender: TObject);
i,j:integer;
Begin
Form3:=TForm3.create(self);
Form3.ShowModal;
SetLength(xinp,np,nx);
SetLength(yout,np,ny);
Form2:=TForm2.create(self);
Form2.ShowModal;
for i:=0 to np-1 do
begin
for j:=0 to nx-1 do
xinp[i,j]:=xinp1[i,j];
for j:=0 to ny-1 do
yout[i,j]:=yout1[i,j];
end;
End;
procedure TForm1.LoadExpSys1Click(Sender: TObject);
begin
Form13:=TForm13.create(self);
Form13.ShowModal;
end;
Procedure TForm1.Networkoperator1Click(Sender: TObject);
i,j:integer;
Begin
Form11:=TForm11.Create(self);
Form11.ShowModal;
Form7:=TForm7.create(self);
Form7.ShowModal;
End;
Procedure TForm1.ParametersofGA1Click(Sender: TObject);
Begin
Form8:=TForm8.create(self);
Form8.ShowModal;
EA.PP:=pp1;
EA.RR:=rr1;
EA.epo:=epo1;
EA.kel:=kel1;
EA.alfa:=alfa1;
EA.pmut:=pmut1;
End;
Procedure TForm1.Paretoset1Click(Sender: TObject);
Begin
Form10:=TForm10.create(self);
Form10.ShowModal;
label1.Caption:=inttostr(kchoose);
EA.ReadChromosome(kchoose,Psi1);
End;
Procedure TForm1.Printtofile1Click(Sender: TObject);
Begin
if savedialog1.Execute then
Memo1.Lines.SaveToFile(Savedialog1.FileName);
End;
Procedure TForm1.SearchofParetoset1Click(Sender: TObject);
Begin
Paretoset1.Enabled:=false;
ProgressBar1.Max:=EA.PP;
EA.NOP.SetPsi(Psi1);
EA.GenAlgorithm;
Paretoset1.Enabled:=true;
End;
Procedure TForm1.Show1Click(Sender: TObject);
s:string;
i:integer;
Begin
EA.NOP.SetPsi(Psi1);
EA.NOP.PsitoPasStr;
for i:=0 to EA.NOP.L-1 do
memo1.Lines.Add(EA.NOP.zs[i]);
End;
Procedure TForm1.Simulation1Click(Sender: TObject);
Begin
Form12:=TForm12.Create(self);
Form12.ShowModal;
End;
Procedure TForm1.Unaryoperations1Click(Sender: TObject);
Begin
Form4:=TForm4.create(self);
Form4.ShowModal;
End;
Procedure UpProgressBar;
Begin
Form1.ProgressBar1.StepIt;
Form1.Refresh;
End;
{ TGANOPUser }
Constructor TUser.Create(hh1, pp1, rr1, nfu1, lchr1, epo1,
kel1: integer; alfa1, pmut1: real; L1, Mout1,
kp1,kw1,kv1: integer);
Begin
Inherited Create(hh1, pp1, rr1, nfu1, lchr1, epo1,
kel1, alfa1, pmut1, L1, Mout1, kp1,kw1,kv1);
End;
Procedure TUser.Func(var Fu: TArrInt);
i,j,s0,s1:integer;
Begin
// inherited;
s0:=0;
s1:=0;
for i:=0 to np-1 do
begin
for j:=0 to NOP.kP-1 do
NOP.Vs[j]:=xinp[i,j];
NOP.RPControl;
if yout[i,0]<>NOP.z[NOP.Dnum[0]] then
begin
s0:=s0+1;
s1:=s1+abs(yout[i,0]-NOP.z[NOP.Dnum[0]]);
end;
end;
Fu[0]:=s0;
Fu[1]:=s1;
End;
Procedure Gendatas;
i,j:integer;
Begin
for i:=0 to np- 1 do
begin
for j:= 0 to nx-1 do
xinp1[i,j]:=xinpc[i,j];
yout1[i,0]:=youtc[i];
yout1[i,1]:=yout1[i,0];
end;
End;
END.
unit Unit2;
//*********************************************************
INTERFACE
//*********************************************************
uses
Windows, Messages, SysUtils, Variants, Classes,
Graphics, Controls, Forms,
Dialogs, StdCtrls, Grids;
type
TForm2 = class(TForm)
StringGrid1: TStringGrid;
Button1: TButton;
OpenDialog1: TOpenDialog;
SaveDialog1: TSaveDialog;
Button2: TButton;
Button3: TButton;
Memo1: TMemo;
procedure Button3Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Form2: TForm2;
Cyfr:set of char;
//*********************************************************
IMPLEMENTATION
//*********************************************************
Uses Unit1;
{$R *.dfm}
Procedure TForm2.Button1Click(Sender: TObject);
i,j:integer;
Begin
SetLength(xinp1,np,nx);
SetLength(yout1,np,ny);
for i:=0 to np-1 do
begin
for j:=0 to nx-1 do
xinp1[i,j]:=StrtoInt(StringGrid1.Cells[j+1,i+1]);
for j:=0 to ny-1 do
yout1[i,j]:=StrtoInt(StringGrid1.Cells[j+1+nx,i+1]);
end;
close;
End;
Procedure TForm2.Button2Click(Sender: TObject);
i,j:integer;
s:string;
Begin
SaveDialog1.FileName:=’Input00.txt’;
if SaveDialog1.Execute then
begin
Memo1.Clear;
for i:=0 to np-1 do
begin
s:=»;
for j:=0 to nx+ny-1 do
s:=s+StringGrid1.Cells[j+1,i+1]+’ ‘;
Memo1.Lines.Add(s);
end;
Memo1.Lines.SaveToFile(SaveDialog1.FileName);
end;
End;
Procedure TForm2.Button3Click(Sender: TObject);
i,j,k:integer;
s1:string;
Begin
OpenDialog1.FileName:=’Input00.txt’;
if OpenDialog1.Execute then
begin
Memo1.Clear;
Memo1.Lines.LoadFromFile(OpenDialog1.FileName);
for i:=0 to np-1 do
begin
k:=1;
for j:=1 to length(Memo1.Lines[i]) do
if Memo1.Lines[i][j] in Cyfr then
s1:=s1+Memo1.Lines[i][j]
else
begin
StringGrid1.Cells[k,i+1]:=s1;
s1:=»;
k:=k+1;
end;
end;
end;
End;
Procedure TForm2.FormCreate(Sender: TObject);
i,j:integer;
Begin
color:=RGB(250,200,250);
StringGrid1.Color:=color;
StringGrid1.ColCount:=nx+ny+1;
StringGrid1.RowCount:=np+1;
Cyfr:=[‘0’..’9′];
for i:=0 to np-1 do
StringGrid1.Cells[0,i+1]:=inttostr(i);
for j:=0 to nx-1 do
StringGrid1.Cells[j+1,0]:=’x[‘+inttostr(j)+’]’;
for j:=0 to ny-1 do
StringGrid1.Cells[j+1+nx,0]:=’y[‘+inttostr(j)+’]’;
End;
END.
unit Unit3;
//*********************************************************
INTERFACE
//*********************************************************
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm3 = class(TForm)
Edit1: TEdit;
Label1: TLabel;
Edit2: TEdit;
Label2: TLabel;
Edit3: TEdit;
Label3: TLabel;
Button1: TButton;
procedure Button1Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Form3: TForm3;
//*********************************************************
IMPLEMENTATION
//*********************************************************
Uses Unit1;
{$R *.dfm}
Procedure TForm3.Button1Click(Sender: TObject);
Begin
nx:=StrtoInt(Edit1.text);
ny:=StrtoInt(Edit2.text);
np:=StrtoInt(Edit3.text);
close;
End;
Procedure TForm3.FormCreate(Sender: TObject);
Begin
color:=RGB(220,220,250);
Edit1.Color:=color;
Edit2.Color:=color;
Edit3.Color:=color;
Edit1.text:=Inttostr(nx);
Edit2.text:=Inttostr(ny);
Edit3.text:=Inttostr(np);
End;
END.
unit Unit6;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm6 = class(TForm)
Edit1: TEdit;
Label1: TLabel;
Edit2: TEdit;
Label2: TLabel;
Label6: TLabel;
Edit6: TEdit;
Button1: TButton;
procedure Button1Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Form6: TForm6;
implementation
Uses Unit1;
{$R *.dfm}
Procedure TForm6.Button1Click(Sender: TObject);
Begin
HH1:=strtoint(Edit1.Text);
nfu1:=strtoint(Edit2.Text);
lchr1:=strtoint(Edit6.Text);
close;
End;
Procedure TForm6.FormCreate(Sender: TObject);
Begin
color:=RGB(250,250,100);
Edit1.Color:=color;
Edit2.Color:=color;
Edit6.Color:=color;
Edit1.Text:=inttostr(HH1);
Edit2.Text:=inttostr(nfu1);
Edit6.Text:=inttostr(lchr1);
End;
end.
unit Unit7;
//*********************************************************
INTERFACE
//*********************************************************
uses
Windows, Messages, SysUtils,
Variants, Classes, Graphics,
Controls, Forms, Dialogs,
StdCtrls, Grids;
type
TForm7 = class(TForm)
StringGrid3: TStringGrid;
StringGrid5: TStringGrid;
Label3: TLabel;
Label5: TLabel;
StringGrid6: TStringGrid;
Label6: TLabel;
Label7: TLabel;
Button1: TButton;
Button2: TButton;
SaveDialog1: TSaveDialog;
Button3: TButton;
OpenDialog1: TOpenDialog;
Memo1: TMemo;
procedure Button4Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure StringGrid6Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
const
Cyfr:set of char=[‘0’..’9′];
Form7: TForm7;
//*********************************************************
IMPLEMENTATION
//*********************************************************
Uses Unit1;
{$R *.dfm}
Procedure TForm7.Button1Click(Sender: TObject);
i,j:integer;
Begin
for i:=0 to kP1-1 do
Pnum1[i]:=strtoint(StringGrid3.Cells[1,i]);
for i:=0 to Mout1-1 do
Dnum1[i]:=strtoint(StringGrid5.Cells[1,i]);
for i:=0 to L1-1 do
for j:=0 to L1-1 do
Psi1[i,j]:=strtoint(StringGrid6.Cells[j,i]);
Close;
End;
Procedure TForm7.Button2Click(Sender: TObject);
i,j:integer;
s:string;
Begin
SaveDialog1.Filename:=’Psi00.txt’;
if SaveDialog1.Execute then
begin
Memo1.Clear;
for i:= 0 to StringGrid6.RowCount-1 do
begin
s:=»;
for j:= 0 to StringGrid6.ColCount-1 do
s:=s+StringGrid6.Cells[j,i]+’ ‘;
Memo1.Lines.Add(s);
end;
Memo1.Lines.SaveToFile(SaveDialog1.FileName);
end;
End;
Procedure TForm7.Button3Click(Sender: TObject);
i,j,k:integer;
s1:string;
Begin
OpenDialog1.FileName:=’Psi00.txt’;
if OpenDialog1.Execute then
begin
Memo1.Clear;
Memo1.Lines.LoadFromFile(OpenDialog1.FileName);
for i:=0 to L1-1 do
begin
k:=0; s1:=»;
for j:=1 to length(Memo1.Lines[i]) do
if Memo1.Lines[i][j] in Cyfr then
s1:=s1+Memo1.Lines[i][j]
else
begin
StringGrid6.Cells[k,i]:=s1;
s1:=»;
k:=k+1;
end;
end;
end;
End;
Procedure TForm7.Button4Click(Sender: TObject);
i,j:integer;
s:string;
Begin
if Opendialog1.Execute then
begin
memo1.Clear;
memo1.Lines.LoadFromFile(Opendialog1.FileName);
end;
End;
Procedure TForm7.FormCreate(Sender: TObject);
i,j:integer;
Begin
color:=RGB(240,240,100);
StringGrid3.color:=color;
StringGrid5.color:=color;
StringGrid6.color:=color;
StringGrid3.RowCount:=kP1;
StringGrid5.RowCount:=Mout1;
StringGrid6.RowCount:=L1;
StringGrid6.ColCount:=L1;
for i:=0 to nx-1 do
begin
StringGrid3.Cells[0,i]:=InttoStr(i);
StringGrid3.Cells[1,i]:=InttoStr(PNum1[i]);
end;
for i:=0 to High(DNum1) do
begin
StringGrid5.Cells[0,i]:=InttoStr(i);
StringGrid5.Cells[1,i]:=InttoStr(DNum1[i]);
end;
for i:=0 to L1 -1 do
for j:=0 to L1 -1 do
StringGrid6.Cells[j,i]:=InttoStr(Psi1[i,j]);
End;
Procedure TForm7.StringGrid6Click(Sender: TObject);
Begin
Label7.Caption:=’Psi[‘+inttostr(StringGrid6.Row)+’,’+
inttostr(StringGrid6.Col)+’]’;
End;
END.
unit Unit8;
//*********************************************************
INTERFACE
//*********************************************************
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm8 = class(TForm)
Edit2: TEdit;
Label2: TLabel;
Edit3: TEdit;
Label3: TLabel;
Edit9: TEdit;
Label9: TLabel;
Edit10: TEdit;
Label10: TLabel;
Edit11: TEdit;
Label11: TLabel;
Button1: TButton;
Edit1: TEdit;
Label1: TLabel;
procedure Button1Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Form8: TForm8;
//*********************************************************
IMPLEMENTATION
//*********************************************************
Uses Unit1;
{$R *.dfm}
Procedure TForm8.Button1Click(Sender: TObject);
Begin
pp1:=strtoint(Edit2.Text);
rr1:=strtoint(Edit3.Text);
Epo1:=strtoint(Edit9.Text);
kel1:=strtoint(Edit10.Text);
alfa1:=strtofloat(Edit11.Text);
pmut1:=strtofloat(Edit1.Text);
close;
End;
Procedure TForm8.FormCreate(Sender: TObject);
Begin
color:=RGB(250,100,250);
Edit2.Color:=Color;
Edit3.Color:=Color;
Edit9.Color:=Color;
Edit10.Color:=Color;
Edit11.Color:=Color;
Edit1.Color:=Color;
Edit2.Text:=inttostr(pp1); // number of generations
Edit3.Text:=inttostr(rr1); // number of couples in one generation
Edit9.Text:=inttostr(Epo1);//number of ganerations between exchange of basic NOM
Edit10.Text:=inttostr(kel1); // number of elitaring chromosomes
Edit11.Text:=floattostr(alfa1); // parameter for crossover
Edit1.Text:=floattostr(pmut1); // probability of mutation
End;
END.
unit Unit10;
//*********************************************************
INTERFACE
//*********************************************************
uses
Windows, Messages, SysUtils, Variants,
Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Grids, TeEngine,
Series, ExtCtrls, TeeProcs, Chart;
type
TForm10 = class(TForm)
Chart1: TChart;
Series1: TPointSeries;
StringGrid1: TStringGrid;
ComboBox1: TComboBox;
ComboBox2: TComboBox;
Label1: TLabel;
Label2: TLabel;
Button1: TButton;
Button2: TButton;
Button3: TButton;
SaveDialog1: TSaveDialog;
Memo1: TMemo;
procedure Button2Click(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure Button3Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Form10: TForm10;
kol:integer;
//*********************************************************
IMPLEMENTATION
//*********************************************************
Uses Unit1;
{$R *.dfm}
Procedure TForm10.Button1Click(Sender: TObject);
Begin
if StringGrid1.Row>=1 then
kChoose:=strtoint(StringGrid1.Cells[1,StringGrid1.Row])
else
kchoose:=EA.Pareto[0];
EA.ReadChromosome(kchoose,Psi1);
End;
Procedure TForm10.Button2Click(Sender: TObject);
i,j:integer;
s:string;
Begin
for i:=0 to StringGrid1.RowCount-1 do
begin
s:=»;
for j:=0 to StringGrid1.ColCount-1 do
s:=s+StringGrid1.Cells[j,i]+’ ‘;
memo1.Lines.Add(s);
end;
savedialog1.FileName:=’Pareto’;
if SaveDialog1.Execute then
begin
Chart1.SaveToBitmapFile(savedialog1.FileName+’.bmp’);
Memo1.Lines.SaveToFile(savedialog1.FileName+’.txt’);
end;
End;
Procedure TForm10.Button3Click(Sender: TObject);
i:integer;
Begin
Series1.Clear;
for i:=0 to kol-1 do
Series1.AddXY(EA.Fuh[EA.Pareto[i],ComboBox1.ItemIndex],
EA.Fuh[EA.Pareto[i],ComboBox2.ItemIndex]);
End;
Procedure TForm10.FormCreate(Sender: TObject);
i,j,k:integer;
Begin
color:=RGB(230,150,250);
kol:=length(EA.Pareto);
StringGrid1.ColCount:=nfu1+2;
StringGrid1.RowCount:=kol+1;
StringGrid1.Colwidths[0]:=32;
StringGrid1.Colwidths[1]:=32;
for i:=0 to nfu1-1 do
StringGrid1.Colwidths[i+2]:=96;
for i:=0 to kol-2 do
for j:=i+1 to kol-1 do
if EA.Fuh[EA.Pareto[i],0]>EA.Fuh[EA.Pareto[j],0] then
begin
k:=EA.Pareto[i];
EA.Pareto[i]:=EA.Pareto[j];
EA.Pareto[j]:=k;
end;
for i:=0 to nfu1-1 do
StringGrid1.Cells[2+i,0]:=’F_’+inttostr(i);
for i:=0 to kol-1 do
begin
StringGrid1.Cells[0,i+1]:=inttostr(i);
StringGrid1.Cells[1,i+1]:=inttostr(EA.Pareto[i]);
end;
for i:=0 to kol-1 do
for j:=0 to nfu1-1 do
StringGrid1.Cells[j+2,i+1]:=inttostr(EA.Fuh[EA.Pareto[i],j]);
ComboBox1.Clear;
ComboBox2.Clear;
Series1.Clear;
for i:=0 to nfu1-1 do
begin
ComboBox1.Items.Add(inttostr(i));
ComboBox2.Items.Add(inttostr(i));
end;
ComboBox1.ItemIndex:=0;
ComboBox2.ItemIndex:=1;
Button3.Click;
End;
END.
unit Unit11;
//*********************************************************
INTERFACE
//*********************************************************
uses
Windows, Messages, SysUtils, Variants, Classes,
Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm11 = class(TForm)
Edit1: TEdit;
Button1: TButton;
Label1: TLabel;
Edit2: TEdit;
Label2: TLabel;
Edit3: TEdit;
Label3: TLabel;
procedure Button1Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Form11: TForm11;
//*********************************************************
IMPLEMENTATION
//*********************************************************
Uses Unit1;
{$R *.dfm}
Procedure TForm11.Button1Click(Sender: TObject);
Begin
L1:=StrtoInt(Edit1.Text);
kP1:=StrtoInt(Edit2.Text);
Mout1:=StrtoInt(Edit3.Text);
close;
End;
Procedure TForm11.FormCreate(Sender: TObject);
Begin
color:=RGB(200,250,200);
Edit1.Color:=Color;
Edit2.Color:=Color;
Edit3.Color:=Color;
Edit1.Text:=InttoStr(L1);
Edit2.Text:=InttoStr(kP1);
Edit3.Text:=InttoStr(Mout1);
End;
END.
unit Unit12;
//*********************************************************
INTERFACE
//*********************************************************
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, TeEngine, Series, ExtCtrls, TeeProcs, Chart, Grids, StdCtrls;
type
TForm12 = class(TForm)
Chart1: TChart;
Series1: TPointSeries;
Button1: TButton;
SaveDialog1: TSaveDialog;
Button2: TButton;
Edit1: TEdit;
Series2: TLineSeries;
StringGrid2: TStringGrid;
Button3: TButton;
procedure Button3Click(Sender: TObject);
procedure Button2Click(Sender: TObject);
procedure Button1Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
Form12: TForm12;
//*********************************************************
IMPLEMENTATION
//*********************************************************
Uses Unit1;
{$R *.dfm}
Procedure TForm12.Button1Click(Sender: TObject);
Begin
Savedialog1.fileName:=’ModelLog.bmp’;
if Savedialog1.execute then
Chart1.SaveToBitmapFile(Savedialog1.fileName);
End;
Procedure TForm12.Button2Click(Sender: TObject);
i,ii,j,kinp:integer;
Begin
kinp:=strtoint(Edit1.Text);
Series1.Clear;
Series2.Clear;
EA.NOP.SetPsi(Psi1);
for i := 0 to kinp-1 do
begin
ii:=random(high(yetc1)+1);
for j:=0 to kP1-1 do
EA.NOP.Vs[j]:=xetc1[ii,j];
EA.NOP.RPControl;
Series1.AddXY(i,EA.NOP.z[EA.NOP.DNum[0]]);
Series2.AddXY(i,yetc1[ii,1]);
end;
End;
Procedure TForm12.Button3Click(Sender: TObject);
i,j,qq1,qq2:integer;
Begin
EA.NOP.Vs[0]:=strtoint(StringGrid2.Cells[0,1]);
EA.NOP.Vs[1]:=strtoint(StringGrid2.Cells[1,1]);
EA.NOP.Vs[2]:=strtoint(StringGrid2.Cells[2,1]);
EA.NOP.SetPsi(Psi1);
EA.NOP.RPControl;
StringGrid2.Cells[3,1]:=inttostr(EA.NOP.z[EA.NOP.Dnum[0]]);
i:=0;
while (i<np)and(
(EA.NOP.Vs[0]<>xinp[i,0])or(EA.NOP.Vs[1]<>xinp[i,1])or
(EA.NOP.Vs[2]<>xinp[i,2])) do i:=i+1;
if i<np then
StringGrid2.Cells[4,1]:=inttostr(yout[i,0]);
StringGrid2.Cells[5,1]:=inttostr(yout[i,1]);
End;
Procedure TForm12.FormCreate(Sender: TObject);
i,j:integer;
Begin
Color:=clWhite;
Series1.Clear;
Series2.Clear;
EA.NOP.SetPsi(Psi1);
StringGrid2.ColCount:=nx+2;
StringGrid2.RowCount:=2;
for i:=0 to np-1 do
begin
for j:=0 to kP1-1 do
EA.NOP.Vs[j]:=xinp[i,j];
EA.NOP.RPControl;
Series1.AddXY(i,EA.NOP.z[EA.NOP.DNum[0]]);
Series2.AddXY(i,yout[i,0]);
end;
StringGrid2.Cells[0,0]:=’x1′;
StringGrid2.Cells[1,0]:=’x2′;
StringGrid2.Cells[2,0]:=’x3′;
StringGrid2.Cells[3,0]:=’z’;
StringGrid2.Cells[4,0]:=’y’;
StringGrid2.Cells[0,1]:=inttostr(xinp[0,0]);
StringGrid2.Cells[1,1]:=inttostr(xinp[0,1]);
StringGrid2.Cells[2,1]:=inttostr(xinp[0,2]);
End;
END.
unit Unit13;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls, Grids, Unit1;
type
TForm13 = class(TForm)
OpenDialog1: TOpenDialog;
StringGrid1: TStringGrid;
Button1: TButton;
Memo2: TMemo;
Button2: TButton;
procedure Button2Click(Sender: TObject);
procedure FormCreate(Sender: TObject);
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
const
nf:integer = 648;
Form13: TForm13;
Cyfr:set of char;
implementation
{$R *.dfm}
procedure TForm13.Button1Click(Sender: TObject);
i,j,k:integer;
s2:string;
Begin
OpenDialog1.FileName:=’ExpSys.txt’;
if OpenDialog1.Execute then
begin
Memo2.Clear;
Memo2.Lines.LoadFromFile(OpenDialog1.FileName);
for i:=0 to nf-1 do
begin
k:=1;
for j:=1 to length(Memo2.Lines[i]) do
if Memo2.Lines[i][j] in Cyfr then
s2:=s2+Memo2.Lines[i][j]
else
begin
StringGrid1.Cells[k,i+1]:=s2;
s2:=»;
k:=k+1;
end;
end;
end;
End;
procedure TForm13.Button2Click(Sender: TObject);
i,j:integer;
Begin
SetLength(xetc1,nf,nx);
SetLength(yetc1,nf,ny);
for i:=0 to nf-1 do
begin
for j:=0 to nx-1 do
xetc1[i,j]:=StrtoInt(StringGrid1.Cells[j+1,i+1]);
for j:=0 to ny-1 do
yetc1[i,j]:=StrtoInt(StringGrid1.Cells[j+1+nx,i+1]);
end;
close;
End;
procedure TForm13.FormCreate(Sender: TObject);
j,i:integer;
begin
StringGrid1.ColCount:=nx+ny+1;
StringGrid1.RowCount:=nf+1;
Cyfr:=[‘0’..’9′];
for i:=0 to nf-1 do
StringGrid1.Cells[0,i+1]:=inttostr(i);
for j:=0 to nx-1 do
StringGrid1.Cells[j+1,0]:=’x[‘+inttostr(j)+’]’;
for j:=0 to ny-1 do
StringGrid1.Cells[j+1+nx,0]:=’y[‘+inttostr(j)+’]’;
end;
end.
Unit UnitLogObjects;
//*********************************************************
INTERFACE
//*********************************************************
Uses Log02,SysUtils;
type
TArrInt=array of integer;
TArrArrInt=array of TArrInt;
TArr4Int=array [0..3]of integer;
TArrArr4Int=array of TArr4Int;
TArrArrArr4int=array of TArrArr4Int;
TArrReal=array of real;
TArrArrReal=array of TArrReal;
TArrString=array of string;
TProc=Procedure;
TNetOperLog01=class(TObject)
L:integer; //dimention of network operator matrix
Mout:integer;//number of outputs
Vs:TArrInt;//set of variables
kW:integer;//number of unary operations
kV:integer;//number of binary operations
kP:integer;//cardinal of the set of variables
PNum:TArrInt;//vector of number nodes for variables
DNum:TArrInt;//vector of number nodes for outputs
z:TArrInt;//vector of nodes
zs:TArrString;//string for mathematical expression
Psi,Psi0:TArrArrInt;//Network operator matrices
Constructor Create(L1,Mout1,kp1,kw1,kv1:integer);//create of NOP
Procedure SetVs(vs1:TArrInt);
Procedure SetPnum(pnum1:TArrInt);
Procedure SetDnum(dnum1:TArrInt);
Procedure SetPsiBas(Psi1:TArrArrInt);
Procedure SetPsi(Psi1:TArrArrInt);
Procedure GenVar(var w:TArr4Int);
Procedure Variations(w:TArr4Int);
Procedure RPControl;
Procedure PsitoPas;
Procedure PsitoTex;
Procedure PsitoPasStr;
Procedure PsitoTexStr;
Procedure ReadPsi(var Psi1:TArrArrInt);
Procedure ReadPsi0(var Psi1:TArrArrInt);
end;
TGANOPLog=class(TObject)
PopChrStr:TArrArrArr4Int;//массив структурных частей хромосом
HH:integer;// размерность популяции
RR:integer;// число скрещиваемых пар
PP:integer;// число поколений
nfu:integer;//число функционалов
lchr:integer;//длина структурной хромосомы
Epo:integer;//число поколений между эпохами
kel:integer;//число элитарных хромосом
Fuh:TArrArrInt;// массив значений функционалов
Lh:TArrInt;// массив растояний домножества Парето
Pareto:TArrInt;// множество Парето
Son1s,Son2s:TArrArr4Int;//структурные части потомков
L1,L2,L3,L4:integer;// растояния до множества Парето потомков
Fu1,Fu2:TArrInt;// значения функционалов для потомков
alfa:real;//параметр для отбора родителей
pmut:real;//вероятность мутации
NOP:TNetOperLog01;// сетевой оператор
EndGeneration:TProc;
Constructor Create(hh1,pp1,rr1,nfu1,lchr1,Epo1,kel1:integer;
alfa1,pmut1:real;
L1,Mout1,kp1,kw1,kv1:integer);
Procedure GenAlgorithm;// операции генетического алгоритма
Procedure ChoosePareto;
Procedure ImproveChrom(var StrChrom: TArrArr4Int);
Procedure ReadChromosome(k:integer;var Psi1:TArrArrInt);
Procedure Func(var Fu:TArrInt); virtual;// Вычисляет значения функционалов
Function Rast(Fu: TArrInt): integer;
end;
//*********************************************************
IMPLEMENTATION
//*********************************************************
{ TNetOper }
Constructor TNetOperLog01.Create(L1, Mout1, kp1, kw1, kv1: integer);
Begin
inherited Create;
L:=L1;
kP:=kp1;
kv:=kv1;
kw:=kw1;
Mout:=Mout1;
Setlength(Psi,L,L);
Setlength(Psi0,L,L);
Setlength(z,L);
Setlength(zs,L);
Setlength(Vs,kP);
Setlength(Pnum,kP);
Setlength(Dnum,Mout);
End;
Procedure TNetOperLog01.SetDnum(Dnum1: TArrInt);
i:integer;
Begin
for i:=0 to Mout-1 do
Dnum[i]:=Dnum1[i];
End;
Procedure TNetOperLog01.SetPnum(pnum1: TArrInt);
i:integer;
Begin
for i:=0 to kP-1 do
Pnum[i]:=Pnum1[i];
End;
Procedure TNetOperLog01.SetPsi(Psi1:TArrArrInt);
i,j:integer;
Begin
for i:=0 to L-1 do
for j:= 0 to L-1 do
Psi[i,j]:=Psi1[i,j];
End;
Procedure TNetOperLog01.SetPsiBas(Psi1: TArrArrInt);
i,j:integer;
Begin
for i:=0 to L-1 do
for j:= 0 to L-1 do
Psi0[i,j]:=Psi1[i,j];
End;
Procedure TNetOperLog01.SetVs(Vs1: TArrInt);
i:integer;
Begin
for i:=0 to high(Vs1) do
Vs[i]:=Vs1[i];
End;
Procedure TNetOperLog01.ReadPsi(var Psi1: TArrArrInt);
i,j:integer;
Begin
for i:=0 to L-1 do
for j:=0 to L-1 do
Psi1[i,j]:=Psi[i,j];
End;
Procedure TNetOperLog01.ReadPsi0(var Psi1: TArrArrInt);
i,j:integer;
Begin
for i:=0 to L-1 do
for j:=0 to L-1 do
Psi1[i,j]:=Psi0[i,j];
End;
Procedure TNetOperLog01.RPControl;
i,j:integer;
zz:integer;
Begin
for i:=0 to L-1 do
case Psi[i,i] of
0,2,3: z[i]:=0;
1: z[i]:=2;
end;
for i:=0 to kP-1 do
z[Pnum[i]]:=Vs[i];
for i:=0 to L-2 do
for j:=i+1 to L-1 do
if Psi[i,j]<>0 then
begin
case Psi[i,j] of
1: zz:=Phi_1(z[i]);
2: zz:=Phi_2(z[i]);
end;
case Psi[j,j] of
0: z[j]:=Omega_0(z[j],zz);
1: z[j]:=Omega_1(z[j],zz);
2: z[j]:=Omega_2(z[j],zz);
3: z[j]:=Omega_3(z[j],zz);
end;
end;
End;
Procedure TNetOperLog01.Variations(w:TArr4Int);
// Элементарные операции
// 0 — замена недиагонального элемента
// 1 — замена диагонального элемента
// 2 — добавление дуги
// 3 — удаление дуги
i,j,s1,s2:integer;
psipr:TArrArrInt;
Begin
if (w[0]<>0)or(w[1]<>0)or(w[2]<>0) then
case w[0] of
0: if Psi[w[1],w[2]]<>0 then Psi[w[1],w[2]]:=w[3];
1: Psi[w[1],w[1]]:=w[3];
2: if Psi[w[1],w[2]]=0 then Psi[w[1],w[2]]:=w[3];
begin
s1:=0;
for i:=0 to w[2]-1 do
if Psi[i,w[2]]<>0 then s1:=s1+1;
s2:=0;
for j:=w[1]+1 to L-1 do
if (Psi[w[1],j]<>0)then s2:=s2+1;
if s1>1 then
if s2>1 then
Psi[w[1],w[2]]:=0;
end;
end;
End;
Procedure TNetOperLog01.GenVar(var w:TArr4Int);
// Генерация элементарной операции
Begin
w[0]:=random(4);
case w[0] of
0,2,3: // замена недиагонального элемента, добавление и удаление дуги
begin
w[1]:=random(L-1);
w[2]:=random(L-w[1]-1)+w[1]+1;
w[3]:=random(kW)+1;
end;
1: // замена диагонального элемента
begin
w[1]:=random(L);
w[2]:=w[1];
w[3]:=random(kV);
end;
end;
End;
Procedure TNetOperLog01.PsitoPas;
// It tranforms from Psi to Pascal
i,j:integer;
zz:string;
Begin
for i:=0 to L-1 do
case Psi[i,i] of
0,4: zs[i]:=’0′;
1: zs[i]:=’1′;
2: zs[i]:=’-inf’;
3: zs[i]:=’inf’;
end;
for i:=0 to kP-1 do
zs[Pnum[i]]:=’x[‘+inttostr(i)+’]’;
for i:=0 to L-2 do
begin
for j:=i+1 to L-1 do
if Psi[i,j]<>0 then
begin
if Psi[i,j]=1 then
zz:=zs[i]
else
zz:=’Ro_’+inttostr(Psi[i,j])+'(‘+zs[i]+’)’;
if((Psi[j,j]=0)and(zs[j]=’0′))or
((Psi[j,j]=1)and(zs[j]=’1′))or
((Psi[j,j]=2)and(zs[j]=’-inf’))or
((Psi[j,j]=3)and(zs[j]=’inf’))or
((Psi[j,j]=4)and(zs[j]=’0′)) then
zs[j]:=zz
else
zs[j]:=’Xi_’+inttostr(Psi[j,j])+'(‘+zs[j]+’,’+zz+’)’;
end;
end;
End;
Procedure TNetOperLog01.PsitoPasStr;
i,j:integer;
Begin
for j:=L-1 downto 0 do
begin
zs[j]:=’z_’+inttostr(j)+’=’;
case Psi[j,j] of
0: zs[j]:=zs[j]+’Or2(0,’;
1: zs[j]:=zs[j]+’And2(2,’;
2: zs[j]:=zs[j]+’Xor2(0,’;
3: zs[j]:=zs[j]+’Equ2(0,’;
end;
for i:=j-1 downto 0 do
if Psi[i,j]<>0 then
if Psi[i,j]=1 then
zs[j]:=zs[j]+’z_’+inttostr(i)+’,’
else
zs[j]:=zs[j]+’not z_’+inttostr(i)+’,’;
if zs[j,length(zs[j])]=’,’ then
zs[j,length(zs[j])]:=’)’
else
zs[j]:=zs[j]+’)’;
end;
for i:=0 to kP-1 do
zs[Pnum[i]]:=’z_’+inttostr(Pnum[i])+’=x_’+inttostr(i);
End;
Procedure TNetOperLog01.PsitoTex;
// It tranforms from Psi to LaTeX
i,j:integer;
zz:string;
Begin
for i:=0 to L-1 do
case Psi[i,i] of
0,4: zs[i]:=’0′;
1: zs[i]:=’1′;
2: zs[i]:=’-\infinity’;
3: zs[i]:=’\infinity’;
end;
for i:=0 to kP-1 do
zs[Pnum[i]]:=’x_{‘+inttostr(i)+’}’;
for i:=0 to L-2 do
begin
for j:=i+1 to L-1 do
if Psi[i,j]<>0 then
begin
if Psi[i,j]=1 then
zz:=zs[i]
else
zz:=’\rho_{‘+inttostr(Psi[i,j])+’}(‘+zs[i]+’)’;
if((Psi[j,j]=0)and(zs[j]=’0′))or
((Psi[j,j]=1)and(zs[j]=’1′))or
((Psi[j,j]=2)and(zs[j]=’-\infinity’))or
((Psi[j,j]=3)and(zs[j]=’\infinity’))or
((Psi[j,j]=4)and(zs[j]=’0′)) then
zs[j]:=zz
else
zs[j]:=’\chi_{‘+inttostr(Psi[j,j])+’}(‘+zs[j]+’,’+zz+’)’;
end;
end;
End;
Procedure TNetOperLog01.PsitoTexStr;
i,j:integer;
Begin
for j:=L-1 downto 0 do
begin
zs[j]:=’$z_{‘+inttostr(j)+’}=’;
case Psi[j,j] of
2: zs[j]:=zs[j]+’\text{Min}(‘;
3: zs[j]:=zs[j]+’\text{Max}(‘;
4: zs[j]:=zs[j]+’\text{Pol}(‘;
end;
for i:=j-1 downto 0 do
if Psi[i,j]<>0 then
begin
if Psi[i,j]<>1 then
zs[j]:=zs[j]+’\rho_{‘+inttostr(Psi[i,j])+’}(z_{‘+inttostr(i)+’})’
else
zs[j]:=zs[j]+’z_{‘+inttostr(i)+’}’;
case Psi[j,j] of
0:zs[j]:=zs[j]+’+’;
1:zs[j]:=zs[j]+’*’;
end;
end;
if (zs[j,length(zs[j])]=’+’)or(zs[j,length(zs[j])]=’*’) then
zs[j,length(zs[j])]:=’)’
else
zs[j]:=zs[j]+’)’;
zs[j]:=zs[j]+’$\\’;
end;
for i:=0 to kP-1 do
zs[Pnum[i]]:=’z_{‘+inttostr(Pnum[i])+’}=x_{‘+inttostr(i)+’}’;
End;
Procedure TGANOPLog.ChoosePareto;
i,j:integer;
Begin
j:=0;
for i:=0 to HH-1 do
if Lh[i]=0 then
begin
j:=j+1;
setlength(Pareto,j);
Pareto[j-1]:=i;
end;
End;
Constructor TGANOPLog.Create(hh1,pp1,rr1,nfu1,lchr1,Epo1,kel1:integer;
alfa1,pmut1:real;
L1,Mout1,kp1,kw1,kv1:integer);
Begin
Inherited Create;
HH:=hh1;
PP:=pp1;
RR:=rr1;
nfu:=nfu1;
lchr:=lchr1;
Epo:=epo1;
kel:=kel1;
alfa:=alfa1;
pmut:=pmut1;
NOP:=TNetOperLog01.Create(L1, Mout1, kp1,kw1,kv1);
Setlength(PopChrStr,HH,lchr);
Setlength(Fuh,HH,nfu);
Setlength(Lh,HH);
Setlength(Fu1,nfu);
Setlength(Fu2,nfu);
Setlength(Son1s,lchr);
Setlength(Son2s,lchr);
End;
Procedure TGANOPLog.Func(var Fu:TArrInt);
i:integer;
Begin
NOP.RPControl;
for i:=0 to nfu-1 do
Fu[i]:=NOP.z[NOP.Dnum[i]];
End;
Procedure TGANOPLog.GenAlgorithm;
// Генетический алгоритм
i,j,i1,j1,k,pt,rt,k1,k2,lmax,imax,kmin,ks1,ks2:integer;
ksi,su,su1:real;
Fumin:integer;
tflag:boolean;
del:real;
Begin
//генерация популяции
NOP.SetPsiBas(NOP.Psi);
for i:=0 to lchr-1 do
for j:=0 to 3 do
PopChrStr[0,i,j]:=0;
for i:=1 to HH-1 do
for j:=0 to lchr-1 do
NOP.GenVar(PopChrStr[i,j]);
// формируем элиту
for i:=0 to kel-1 do
begin
j:=random(HH-1)+1;
ImproveChrom(PopChrStr[j]);
end;
//вычисление значений функционалов для каждой хромосомы
for i:=0 to HH-1 do
begin
NOP.SetPsi(NOP.Psi0);
for j:=0 to lchr-1 do
NOP.Variations(PopChrStr[i,j]);
Func(Fuh[i]);
end;
//вычисление расстояний до множества Парето
for i:=0 to HH-1 do
Lh[i]:=Rast(Fuh[i]);
//начало цикла поколений
pt:=1; // первое текущее поколение
repeat
//начало цикла скрещивания
rt:=1;//первая пара скрещивания
repeat
//отбор двух родителей
k1:=random(HH);
k2:=random(HH);
ksi:=random;
if (ksi<(1+alfa*Lh[k1])/(1+Lh[k1])) or
(ksi<(1+alfa*Lh[k2])/(1+Lh[k2])) then
begin
//если условие скрещивания выполнено
ks1:=random(lchr);
//скрещивание, получение 4 потомков
for i:=0 to ks1-1 do
begin
Son1s[i]:=PopChrStr[k1,i];
Son2s[i]:=PopChrStr[k2,i];
end;
for i:=ks1 to lchr-1 do
begin
Son1s[i]:=PopChrStr[k2,i];
Son2s[i]:=PopChrStr[k1,i];
end;
//мутация для 1го потомка
if random<pmut then
NOP.GenVar(son1s[random(lchr)]);
//вычисление функционалов для 1го потомка
NOP.SetPsi(NOP.Psi0);;
for j:=0 to lchr-1 do
NOP.Variations(son1s[j]);
Func(Fu1);
//вычисление расстояния для 1го потомка
L1:=Rast(Fu1);
//нахождение хромосомы с наибольшим расстоянием
Lmax:=Lh[0];
imax:=0;
for i:=1 to HH-1 do
if Lh[i]>Lmax then
begin
Lmax:=Lh[i];
imax:=i;
end;
if L1<Lmax then
//если расстояние у 1го потомка меньше, чем наибольшее, то
//…осуществляем замену
begin
for i:=0 to lchr-1 do
PopChrStr[imax,i]:=son1s[i];
for i:=0 to nfu-1 do
Fuh[imax,i]:=Fu1[i];
end;
//вычисляем все расстояния для популяции
for i:=0 to HH-1 do
Lh[i]:=Rast(Fuh[i]);
//мутация для 2го потомка
if random<pmut then
NOP.GenVar(Son2s[random(lchr)]);
//вычисление функционалов для 2го потомка
NOP.SetPsi(NOP.Psi0);;
for j:=0 to lchr-1 do
NOP.Variations(son2s[j]);
Func(Fu2);
//вычисление расстояния для 2го потомка
L2:=Rast(Fu2);
//нахождение хромосомы с наибольшим расстоянием
Lmax:=Lh[0];
imax:=0;
for i:=1 to HH-1 do
if Lh[i]>Lmax then
begin
Lmax:=Lh[i];
imax:=i;
end;
if L2<Lmax then
//если расстояние у 2го потомка меньше, чем наибольшее, то
//…осуществляем замену
begin
for i:=0 to lchr-1 do
PopChrStr[imax,i]:=son2s[i];
for i:=0 to nfu-1 do
Fuh[imax,i]:=Fu2[i];
end;
//вычисляем все расстояния для популяции
for i:=0 to HH-1 do
Lh[i]:=Rast(Fuh[i]);
end;
rt:=rt+1;
//конец цикла скрещивания
until rt>RR;
// генерируем новые хромосомы
pt:=pt+1;
//если эпоха закончилась, то необходимо сменить базис
if pt mod Epo=0 then
begin
//…на наиболее близкую хромосому к утопической
// хромосоме в пространстве нормированных критериев
Fumin:=Fuh[0,1];
kmin:=0;
for i:=1 to HH-1 do
if Fuh[i,1]<Fumin then
begin
Fumin:=Fuh[i,1];
kmin:=i;
end;
if kmin<>0 then
// заменяем базис
// строим матрицу для найденной хромосомы
begin
NOP.SetPsi(NOP.Psi0);
for j:=0 to lchr-1 do
NOP.Variations(PopChrStr[kmin,j]);
// меняем базисную матрицу на новую
NOP.SetPsiBas(NOP.Psi);
//генерируем тождественную хромосому
for i:=0 to lchr-1 do
for j:=0 to 3 do
PopChrStr[0,i,j]:=0;
Func(Fuh[0]);
else
begin
for i:=1 to HH-1 do
for j:=0 to lchr-1 do
NOP.GenVar(PopChrStr[i,j]);
end;
//вычисляем все фунционалы для всей популяции
for i:=1 to HH-1 do
begin
NOP.SetPsi(NOP.Psi0);
for j:=0 to lchr-1 do
NOP.Variations(PopChrStr[i,j]);
Func(Fuh[i]);
end;
// формируем элиту
for i:=0 to kel-1 do
begin
j:=random(HH-1)+1;
ImproveChrom(PopChrStr[j]);
end;
//вычисляем новые расстояния
for i:=0 to HH-1 do
Lh[i]:=Rast(Fuh[i]);
end;
//конец цикла поколений
EndGeneration;
// form1.ProgressBar1.StepIt;
// Form1.Refresh;
until pt>PP;
ChoosePareto;
//строим множество Парето
End;
Procedure TGANOPLog.ImproveChrom(var StrChrom: TArrArr4Int);
i,j,k:integer;
flag:boolean;
Begin
NOP.SetPsi(NOP.Psi0);
Func(Fu1);
k:=-1;
for i:=0 to lchr-1 do
begin
NOP.Variations(StrChrom[i]);
Func(Fu2);
flag:=true;
for j:=0 to nfu-1 do
if Fu2[j]>Fu1[j] then flag:=false;
if flag then
begin
for j:=0 to nfu-1 do
Fu1[j]:=Fu2[j];
k:=i;
end;
end;
for i:=k+1 to lchr-1 do
for j:=0 to 3 do
StrChrom[i,j]:=0;
End;
Function TGANOPLog.Rast(Fu: TArrInt): integer;
var i,j,k,count:integer;
Begin
count:=0;
for i:=0 to HH-1 do
begin
j:=0;
while (j<nfu) and (Fu[j]>=Fuh[i,j]) do j:=j+1;
if j>=nfu then
begin
k:=0;
while (k<nfu) and (Fu[k]=Fuh[i,k]) do k:=k+1;
if k<nfu then count:=count+1;
end;
end;
result:=count;
End;
Procedure TGANOPLog.ReadChromosome(k: integer;var Psi1: TArrArrInt);
i:integer;
Begin
NOP.SetPsi(NOP.Psi0);
for i:=0 to lchr-1 do
NOP.Variations(PopChrStr[k,i]);
NOP.ReadPsi(Psi1);
End;
END.
Unit Log02;
//*********************************************************
INTERFACE
//*********************************************************
Function Phi_1(z:integer):integer;
Function Phi_2(z:integer):integer;
Function Omega_0(z1,z2:integer):integer;
Function Omega_1(z1,z2:integer):integer;
Function Omega_2(z1,z2:integer):integer;
Function Omega_3(z1,z2:integer):integer;
//*********************************************************
IMPLEMENTATION
//*********************************************************
{ TLogFunc }
Function Omega_0(z1, z2: integer): integer;
Begin
if z1>=z2 then result:=z1
else
result:=z2;
End;
Function Omega_1(z1, z2: integer): integer;
Begin
if z1<=z2 then result:=z1
else
result:=z2;
End;
Function Omega_2(z1, z2: integer): integer;
Begin
result:=(z1+z2) mod 4;
End;
Function Omega_3(z1, z2: integer): integer;
Begin
if z1=z2 then result:=2
else
result:=(z1+z2) mod 2;
End;
Function Phi_1(z: integer): integer;
Begin
result:=z;
End;
Function Phi_2(z: integer): integer;
Begin
result:=(z+2)mod 4;
End;
END.
Приложение Б
Унарные операции
— означает остаток от
Бинарные операции
Приложение В
(обязательное)
0 0 2 1 1
0 0 3 2 2
0 1 1 1 1
0 1 2 1 1
0 1 3 2 2
0 2 1 1 1
0 2 2 1 1
0 2 3 2 2
0 3 1 1 1
0 3 2 1 1
0 3 3 2 2
0 4 1 1 1
0 4 2 1 1
0 4 3 2 2
0 7 3 2 2
0 8 1 1 1
0 8 2 2 2
0 8 3 2 2
0 9 1 1 1
0 9 2 1 1
0 9 3 3 3
0 10 2 1 1
0 13 3 2 2
0 14 1 3 3
0 14 2 2 2
0 14 3 2 2
0 15 1 3 3
0 15 2 2 2
0 15 3 2 2
1 0 1 1 1
1 0 2 1 1
1 0 3 2 2
1 1 1 1 1
1 4 3 2 2
1 5 1 1 1
1 5 2 1 1
1 5 3 3 3
1 6 1 1 1
1 6 2 1 1
1 6 3 3 3
1 7 1 1 1
1 7 2 1 1
1 7 3 1 1
1 8 1 0 0
1 8 2 2 2
1 13 2 2 2
1 13 3 2 2
1 14 1 0 0
1 14 2 2 2
1 14 3 2 2
2 2 1 1 1
2 2 2 1 1
2 2 3 2 2
2 3 1 1 1
2 3 2 1 1
2 3 3 2 2
2 4 1 0 0
2 4 2 2 2
2 4 3 2 2
2 8 1 0 0
2 8 2 2 2
2 8 3 2 2
2 9 1 3 3
3 2 2 1 1
3 2 3 2 2
3 3 1 1 1
3 3 2 1 1
3 3 3 2 2
3 4 1 0 0
3 4 2 1 1
3 4 3 2 2
3 5 1 3 3
3 5 1 3 3
3 5 2 1 1
3 5 3 2 2
3 6 1 3 3
3 6 2 2 2
3 6 3 2 2
3 8 1 0 0
3 8 2 1 1
3 8 3 2 2
3 9 1 0 0
3 14 3 3 3
3 15 1 0 0
3 15 2 3 3
3 15 3 3 3
4 0 1 1 1
4 0 2 1 1
4 0 3 2 2
4 1 1 1 1
4 1 2 1 1
4 6 2 2 2
4 6 3 2 2
4 8 1 0 0
4 8 2 1 1
4 8 3 2 2
4 9 1 0 0
4 9 2 1 1
4 9 3 2 2
4 11 2 1 1
4 11 3 2 2
4 12 1 0 0
4 12 2 2 2
4 12 3 2 2
5 1 2 0 0
5 1 3 2 2
5 5 1 1 1
5 5 2 1 1
5 5 3 2 2
5 6 1 1 1
5 6 2 1 1
5 6 3 2 2
5 7 1 1 1
5 7 2 1 1
5 7 3 2 2
5 8 1 0 0
5 8 2 1 1
5 8 3 2 2
5 10 1 0 0
5 10 2 1 1
5 10 3 2 2
5 11 1 0 0
5 11 2 1 1
5 11 3 2 2
5 12 1 0 0
6 7 1 1 1
6 7 2 1 1
6 7 3 2 2
6 8 1 0 0
6 8 2 1 1
6 8 3 2 2
6 9 1 0 0
6 9 2 1 1
6 9 3 2 2
6 10 1 0 0
6 10 2 1 1
6 10 3 2 2
6 11 1 0 0
6 11 2 1 1
6 11 3 2 2
6 12 1 0 0
6 12 2 2 2
6 12 3 2 2
7 3 3 2 2
7 5 1 0 0
7 5 2 0 0
7 5 3 2 2
7 7 1 0 0
7 7 2 1 1
7 7 3 2 2
7 8 1 0 0
7 12 3 2 2
7 13 1 3 3
7 13 2 1 1
7 13 3 2 2
7 14 1 3 3
7 14 2 1 1
7 14 3 2 2
7 15 1 3 3
8 2 3 2 2
8 3 1 1 1
8 3 2 1 1
8 3 3 2 2
8 4 1 1 1
8 4 2 1 1
8 4 3 2 2
8 5 1 0 0
8 5 2 0 0
8 5 3 2 2
8 7 1 0 0
8 7 2 1 1
8 11 2 1 1
8 11 3 2 2
8 12 1 0 0
8 12 2 1 1
8 12 3 2 2
8 13 1 0 0
9 1 3 2 2
9 2 1 1 1
9 2 2 1 1
9 2 3 2 2
9 3 1 1 1
9 3 2 1 1
9 3 3 2 2
9 4 1 1 1
9 4 2 1 1
9 4 3 2 2
9 5 1 0 0
9 5 2 2 2
9 11 1 0 0
9 11 2 1 1
9 11 3 3 3
9 12 1 0 0
9 12 2 0 0
9 12 3 2 2
9 14 1 0 0
9 14 2 1 1
9 14 3 0 0
10 5 1 0 0
10 5 2 1 1
10 5 3 2 2
10 6 1 3 3
10 6 2 1 1
10 6 3 2 2
10 7 1 1 1
10 7 2 1 1
10 9 2 1 1
10 9 3 2 2
10 10 1 0 0
10 10 2 0 0
10 10 3 2 2
10 12 1 0 0
10 12 2 0 0
10 12 3 2 2
11 2 3 2 2
11 3 1 1 1
11 3 2 1 1
11 3 3 2 2
11 4 1 1 1
11 4 2 1 1
11 4 3 3 3
11 5 1 0 0
11 5 3 2 2
11 6 1 0 0
11 6 2 1 1
11 6 3 2 2
11 7 1 0 0
11 7 2 1 1
11 7 3 2 2
11 8 1 0 0
11 8 2 1 1
11 8 3 2 2
11 9 1 0 0
11 15 1 3 3
11 15 2 3 3
11 15 3 2 2
12 0 1 1 1
12 0 2 1 1
12 0 3 2 2
12 1 1 1 1
12 1 2 1 1
12 1 3 2 2
12 5 1 0 0
12 5 2 1 1
12 5 3 2 2
12 6 1 0 0
12 6 2 1 1
12 6 3 2 2
12 7 1 0 0
12 7 2 1 1
12 7 3 2 2
12 13 1 0 0
12 13 2 0 0
12 13 3 2 2
12 14 1 0 0
12 14 2 0 0
12 14 3 2 2
12 15 1 0 0
12 15 2 0 0
13 5 1 1 1
13 5 2 1 1
13 5 3 1 1
13 6 1 1 1
13 6 2 1 1
13 6 3 1 1
13 7 1 1 1
13 7 2 1 1
13 7 3 2 2
13 8 1 0 0
13 8 2 1 1
13 8 3 2 2
13 12 1 0 0
13 12 2 0 0
13 12 3 2 2
13 13 1 0 0
13 13 2 0 0
13 13 3 2 2
13 14 1 0 0
13 14 2 0 0
13 14 3 2 2
14 7 2 1 1
14 7 3 2 2
14 8 1 0 0
14 8 2 1 1
14 8 3 2 2
14 9 1 0 0
14 9 2 1 1
14 9 3 2 2
14 10 1 0 0
14 10 2 1 1
14 10 3 2 2
15 6 1 1 1
15 6 2 1 1
15 6 3 3 3
15 7 1 0 0
15 7 2 1 1
15 7 3 3 3
15 8 1 0 0
15 8 2 1 1
Приложение Г
Графики к исследованию 1:
Рис. 15
Рис. 16
Рис. 17
Рис. 18
Рис. 19
Рис. 20
Рис. 21
Рис. 22
Графики к исследованию 2:
Рис. 23
Рис. 24
Рис. 25
Рис. 26
Рис. 27
Рис. 28
Рис. 29
Рис. 30
Размещено на
