Embed Size (px)
Citation preview
Министерство образования и науки РФ
Федеральное государственное автономное образовательное
учреждение высшего образования
«Санкт-Петербургский государственный электротехнический
университет «ЛЭТИ» им. В.И. Ульянова (Ленина)»
На правах рукописи
Холод Иван Иванович
МОДЕЛИ И МЕТОДЫ ПОСТРОЕНИЯ ПАРАЛЛЕЛЬНЫХ АЛГОРИТМОВ
АНАЛИЗА РАСПРЕДЕЛЕННЫХ ДАННЫХ
05.13.11. – Математическое и программное обеспечение вычислительных машин,
комплексов и компьютерных сетей
Диссертация на соискание ученой степени
доктора технических наук
Консультант: д.т.н., профессор Куприянов Михаил Степанович
Санкт-Петербург 2018
2
СОДЕРЖАНИЕ
ВВЕДЕНИЕ ............................................................................................................................................ 6
1. АНАЛИЗ СУЩЕСТВУЮЩИХ МОДЕЛЕЙ И МЕТОДОВ ПОСТРОЕНИЯ
ПАРАЛЛЕЛЬНЫХ АЛГОРИТМОВ АНАЛИЗА ДАННЫХ ..................................................... 17
1.1 МЕТОДЫ АНАЛИЗА ДАННЫХ ...................................................................................................... 18 1.1.1 Задачи анализа данных ....................................................................................................... 18 1.1.2 Представление моделей знаний ......................................................................................... 19 1.2.2 Алгоритмы анализа данных ............................................................................................... 22
1.2 РАСПРЕДЕЛЕННЫЙ АНАЛИЗ ДАННЫХ ........................................................................................... 27 1.2.1 Распределенный анализ Больших данных ........................................................................ 27 1.2.2 Анализ Больших данных на облачной платформе ........................................................... 33 1.2.3 Анализ данных в системах Интернета вещей .................................................................. 36 1.2.4 Анализ распределенных данных ........................................................................................ 39
1.3 МЕТОДЫ ПОСТРОЕНИЯ ПАРАЛЛЕЛЬНЫХ АЛГОРИТМОВ ................................................................ 41 1.3.1 Этапы построения параллельных алгоритмов ................................................................. 41 1.3.2 Декомпозиция алгоритма ................................................................................................... 42 1.3.3 Анализ зависимостей между блоками ............................................................................... 44 1.3.4 Выбор модели параллельного выполнения ...................................................................... 45 1.3.5 Реализация параллельного алгоритма ............................................................................... 46 1.3.6 Размещение алгоритма на исполнителях .......................................................................... 48 1.3.7 Распараллеливание алгоритмов решения ресурсоемких задач ...................................... 50 1.3.8 Параллельные алгоритмы анализа данных ....................................................................... 51
ВЫВОДЫ ............................................................................................................................................. 57
2. ФОРМАЛЬНОЕ ПРЕДСТАВЛЕНИЕ АЛГОРИТМА АНАЛИЗА ДАННЫХ ................ 59
2.1. ФОРМАЛЬНОЕ ОПИСАНИЕ НАБОРА АНАЛИЗИРУЕМЫХ ДАННЫХ .................................................. 60 2.1.1 Матрица данных .................................................................................................................. 60 2.1.2 Описание распределенных данных ................................................................................... 61
2.2 МОДЕЛЬ ПРЕДСТАВЛЕНИЯ ЗНАНИЙ .............................................................................................. 62 2.2.1 Формальное представление модели знаний ..................................................................... 62 2.2.2 Метаданные набора данных ............................................................................................... 64 2.2.3 Индексация элементов модели знаний ............................................................................. 65 2.2.4 Параметры элементов модели знаний ............................................................................... 66 2.2.5 Пример модели знаний ....................................................................................................... 68 2.2.6 Операции над элементами модели знаний для параллельной обработки ..................... 70
2.3 ФУНКЦИОНАЛЬНАЯ МОДЕЛЬ АЛГОРИТМА АНАЛИЗА ДАННЫХ ..................................................... 73 2.3.1 Расширение теории лямбда-исчислений для описания анализа данных ....................... 73 2.3.2 Функция для выполнения последовательности функций обработки модели ............... 77 2.3.3 Функция условного выполнения ....................................................................................... 79 2.3.4 Функция выполнения цикла ............................................................................................... 82 2.3.5 Пример представления алгоритма в виде функционального выражения ...................... 88
2.4 МЕТОД ОПТИМИЗАЦИИ СТРУКТУРЫ АЛГОРИТМА АНАЛИЗА К ВИДУ РАСПРЕДЕЛЕНИЯ ДАННЫХ .. 94 2.4.1. Оптимизация циклов в зависимости от типа распределения данных ........................... 94 2.4.2. Метод оптимизации структуры алгоритма анализа данных .......................................... 96 2.4.3 Пример адаптации структуры алгоритма анализа данных ............................................. 98
ВЫВОДЫ ........................................................................................................................................... 100
3. ПОСТРОЕНИЕ ПАРАЛЛЕЛЬНЫХ АЛГОРИТМОВ АНАЛИЗА ДАННЫХ.............. 101
3
3.1 МОДЕЛЬ ПАРАЛЛЕЛЬНОГО АЛГОРИТМА АНАЛИЗА ДАННЫХ ....................................................... 102 3.1.1 Функции распараллеливания ........................................................................................... 102 3.1.2 Реализация модели MapReduce с помощью предложенной модели ............................ 107 3.1.3 Оптимальное число параллельных композиций функций обработки модели знаний 111
3.2 УСЛОВИЯ ПАРАЛЛЕЛЬНОГО ВЫПОЛНЕНИЯ ФУНКЦИЙ ОБРАБОТКИ МОДЕЛИ ЗНАНИЙ ................ 114 3.2.1 Условия Бернстайна для алгоритмов анализа данных .................................................. 114 3.2.2 Условия параллельного выполнения при использовании общей памяти .................... 115 3.2.3 Условия параллельного выполнения при использовании распределенной памяти ... 117 3.2.4 Метод проверки условий параллельного выполнения функций обработки модели .. 119 3.2.5 Пример проверки условий параллельного выполнения алгоритма анализа данных . 122
3.3 РАСПАРАЛЛЕЛИВАНИЕ ПОСЛЕДОВАТЕЛЬНОГО АЛГОРИТМА АНАЛИЗА ДАННЫХ ....................... 127 3.3.1 Метод распараллеливания последовательного алгоритма анализа данных ................ 127 3.3.2 Пример распараллеливания алгоритма анализа данных ............................................... 129
ВЫВОДЫ ........................................................................................................................................... 132
4. РАЗМЕЩЕНИЕ АЛГОРИТМА АНАЛИЗА ДАННЫХ В ЗАДАННОЙ СРЕДЕ .......... 133
4.1 СРЕДА ВЫПОЛНЕНИЯ АЛГОРИТМА АНАЛИЗА ДАННЫХ ............................................................... 134 4.1.1 Формальное представление среды выполнения алгоритма анализа данных .............. 134 4.1.2 Типы сред выполнения алгоритма анализа данных ....................................................... 135
4.2 МОДЕЛЬ ИСПОЛНИТЕЛЕЙ ФУНКЦИИ ОБРАБОТКИ МОДЕЛИ ......................................................... 137 4.2.1 Исполнитель композиции функций обработки модели ................................................ 137 4.2.3 Метод построения дерева исполнителей ........................................................................ 138 4.2.5 Пример модели исполнителей для алгоритма анализа данных .................................... 143
4.3. МЕТОД РАЗМЕЩЕНИЯ ФУНКЦИЙ АЛГОРИТМА АНАЛИЗА ДАННЫХ В СРЕДЕ ВЫПОЛНЕНИЯ ....... 145 4.3.1 Постановка задачи ............................................................................................................. 145 4.3.2 Эвристики для размещения исполнителей в среде выполнения .................................. 147 4.3.3 Метод размещение исполнителей до выполнения алгоритма анализа данных .......... 152 4.3.4 Метод размещения исполнителей при выполнении алгоритма анализа данных ....... 155 4.3.5 Пример размещения исполнителей для алгоритма анализа данных ............................ 156
4.4 МЕТОДИКА ПОСТРОЕНИЯ ПАРАЛЛЕЛЬНОГО АЛГОРИТМА АНАЛИЗА ДАННЫХ ДЛЯ ВЫПОЛНЕНИЯ В
ЗАДАННОЙ ВЫЧИСЛИТЕЛЬНОЙ СРЕДЕ .............................................................................................. 158 4.4.1 Основные этапы построения параллельного алгоритма анализа распределенных
данных ......................................................................................................................................... 158 4.4.2 Построения модели знаний для алгоритма анализа данных ......................................... 160 4.4.3 Формирование композиции функций алгоритма анализа данных ............................... 162 4.4.4 Распараллеливание и размещение алгоритма анализа данных .................................... 166
ВЫВОДЫ ........................................................................................................................................... 169
5. БИБЛИОТЕКА ПАРАЛЛЕЛЬНЫХ АЛГОРИТМОВ АНАЛИЗА
РАСПРЕДЕЛЕННЫХ ДАННЫХ .................................................................................................. 170
5.1 ОТЛИЧИЯ РАЗРАБОТАННОЙ БИБЛИОТЕКИ ОТ СУЩЕСТВУЮЩИХ АНАЛОГОВ .............................. 171 5.2 АРХИТЕКТУРА БИБЛИОТЕКИ ....................................................................................................... 173
5.2.1 Структура библиотеки ...................................................................................................... 173 5.2.2 Реализация функции обработки модели ......................................................................... 174 5.2.3 Классы для параллельного выполнения алгоритмов анализа данных ......................... 177 5.2.4 Среда параллельного и распределенного выполнения алгоритмов анализа данных . 178 5.2.5 Выполнение алгоритмов в параллельной/распределенной среде ................................ 180
5.3 ПРОГРАММНАЯ РЕАЛИЗАЦИЯ ИСПОЛНИТЕЛЕЙ ДЛЯ ПАРАЛЛЕЛЬНОГО И РАСПРЕДЕЛЕННОГО
ВЫПОЛНЕНИЯ АЛГОРИТМОВ АНАЛИЗА ДАННЫХ .............................................................................. 183 5.3.1 Исполнители для выполнения в сильно-связанной среде ............................................. 183
4
5.3.2 Исполнители для выполнения в распределенной среде ................................................ 184 5.3.3 Реализация исполнителей на основе потоков ................................................................ 185 5.3.4 Реализация исполнителей на основе акторов ................................................................. 186
5.4 ПРОГРАММНАЯ РЕАЛИЗАЦИЯ ПАРАЛЛЕЛЬНОГО АЛГОРИТМА АНАЛИЗА ДАННЫХ С
ИСПОЛЬЗОВАНИЕМ БИБЛИОТЕКИ ...................................................................................................... 190 5.4.1 Добавление алгоритма анализа данных в библиотеку .................................................. 190 5.4.2 Пример программной реализации алгоритма анализа данных ..................................... 192
ВЫВОДЫ ........................................................................................................................................... 195
6. ЭКСПЕРИМЕНТАЛЬНАЯ ПРОВЕРКА РЕЗУЛЬТАТОВ .............................................. 196
6.1 ПРЕОБРАЗОВАНИЕ ПОСЛЕДОВАТЕЛЬНОЙ ФОРМЫ АЛГОРИТМА АНАЛИЗА ДАННЫХ К
ПАРАЛЛЕЛЬНОЙ ФОРМЕ .................................................................................................................... 197 6.1.1 Условия проведения эксперимента ................................................................................. 197 6.1.2 Результаты экспериментов ............................................................................................... 198 6.1.3 Анализ результатов экспериментов ................................................................................ 200
6.2 ПАРАЛЛЕЛЬНОЕ ВЫПОЛНЕНИЕ АЛГОРИТМОВ АНАЛИЗА ДАННЫХ .............................................. 201 6.2.1 Условия проведения эксперимента ................................................................................. 201 6.2.2 Результаты экспериментов ............................................................................................... 203 6.2.3 Анализ результатов экспериментов ................................................................................ 207
6.3 РАСПРЕДЕЛЕННОЕ ВЫПОЛНЕНИЕ АЛГОРИТМОВ АНАЛИЗА ДАННЫХ .......................................... 213 6.3.1 Условия проведения эксперимента ................................................................................. 213 6.3.2 Результаты экспериментов ............................................................................................... 217 6.3.3 Анализ результатов экспериментов ................................................................................ 222
ВЫВОДЫ ........................................................................................................................................... 230
7. ПРАКТИЧЕСКОЕ ИСПОЛЬЗОВАНИЕ РЕЗУЛЬТАТОВ ИССЛЕДОВАНИЙ В
НАРОДНО-ХОЗЯЙСТВЕННОЙ ДЕЯТЕЛЬНОСТИ ............................................................... 231
7.1 ОБЛАЧНЫЙ СЕРВИС ВЫПОЛНЕНИЯ ИНТЕЛЛЕКТУАЛЬНОГО АНАЛИЗА ДАННЫХ В РАЗЛИЧНЫХ
РАСПРЕДЕЛЕННЫХ СРЕДАХ ............................................................................................................... 232 7.1.1 Целевая задача ................................................................................................................... 232 7.1.2 Решаемые проблемы ......................................................................................................... 233 7.2.3 Используемые подходы .................................................................................................... 237
7.2 ЕДИНОЕ ИНФОРМАЦИОННОЕ ПРОСТРАНСТВО ОТЕЧЕСТВЕННОЙ ОРБИТАЛЬНОЙ ГРУППИРОВКИ 238 7.2.1 Целевая задача ................................................................................................................... 238 7.2.2 Решаемые проблемы ......................................................................................................... 241 7.2.3 Используемые подходы .................................................................................................... 243
7.3 АНАЛИЗ РЕЗУЛЬТАТОВ ВЫПОЛНЕНИЯ СЕАНСОВ СВЯЗИ СРЕДСТВАМИ НАКУ КА ..................... 245 7.3.1 Целевая задача ................................................................................................................... 245 7.3.2 Решаемые проблемы ......................................................................................................... 246 7.3.3 Используемые подходы .................................................................................................... 249
7.4 CБОР ТЕЛЕМЕТРИИ С ТЕРРИТОРИАЛЬНО РАСПРЕДЕЛЕННЫХ ИЗМЕРИТЕЛЬНЫХ СРЕДСТВ ........... 250 7.4.1 Целевая задача ................................................................................................................... 250 7.4.2 Решаемые проблемы ......................................................................................................... 251 7.4.3 Используемые подходы .................................................................................................... 253
ВЫВОДЫ ........................................................................................................................................... 255
ЗАКЛЮЧЕНИЕ ................................................................................................................................ 257
СПИСОК СОКРАЩЕНИЙ И УСЛОВНЫХ ОБОЗНАЧЕНИЙ .............................................. 259
СПИСОК ЛИТЕРАТУРЫ .............................................................................................................. 260
5
ПРИЛОЖЕНИЕ A. МОДЕЛИ ЗНАНИЙ ..................................................................................... 293
A.1 ЭЛЕМЕНТ МОДЕЛИ ЗНАНИЙ - ПРЕДИКАТ .................................................................................... 293 А.2 МОДЕЛЬ ЗНАНИЙ - НАБОР КЛАССИФИКАЦИОННЫХ ПРАВИЛ ..................................................... 294 A.3 МОДЕЛЬ ЗНАНИЙ – НАИВНЫЙ БАЙЕСОВСКИЙ КЛАССИФИКАТОР .............................................. 295 A.4 МОДЕЛЬ ЗНАНИЙ - ДЕРЕВО РЕШЕНИЙ ........................................................................................ 297 A.5. МОДЕЛЬ ЗНАНИЙ - РЕГРЕССИЯ .................................................................................................. 299 А.6 МОДЕЛЬ ЗНАНИЙ - ОПОРНЫЕ ВЕКТОРА ...................................................................................... 301 А.7 КЛАСТЕРНЫЕ МОДЕЛИ ЗНАНИЙ ................................................................................................. 303 А.8 МОДЕЛЬ ЗНАНИЙ – АССОЦИАТИВНЫЕ ПРАВИЛА ....................................................................... 305 А.9 МОДЕЛЬ ПОСЛЕДОВАТЕЛЬНОСТЕЙ ............................................................................................ 307 А.10 МОДЕЛЬ ЗНАНИЙ - НЕЙРОННАЯ СЕТЬ ...................................................................................... 309
ПРИЛОЖЕНИЕ Б. ПРОГРАММНАЯ РЕАЛИЗАЦИЯ ПАРАЛЛЕЛЬНОГО АЛГОРИТ . 311
Б.1 ПРОГРАММНАЯ РЕАЛИЗАЦИЯ НЕ ДЕКОМПОЗИРОВАННОГО АЛГОРИТМА 1R .............................. 311 Б.2 ПРОГРАММНАЯ РЕАЛИЗАЦИЯ БЛОКА ПОДСЧЕТА ВЕКТОРОВ ...................................................... 314 Б.3 ПРОГРАММНАЯ РЕАЛИЗАЦИЯ БЛОКА ДОБАВЛЕНИЯ НОВОГО ПРАВИЛА ..................................... 315 Б.4 ПРОГРАММНАЯ РЕАЛИЗАЦИЯ БЛОКА ВЫБОРА ЛУЧШЕГО ПРАВИЛА ........................................... 317 Б.5 ПРОГРАММНАЯ РЕАЛИЗАЦИЯ ДЕКОМПОЗИРОВАННОГО АЛГОРИТМА 1R ................................... 318 Б.6 ПРОГРАММНАЯ РЕАЛИЗАЦИЯ АЛГОРИТМА 1R РАСПАРАЛЛЕЛЕННОГО ПО ВЕКТОРАМ ............... 319 Б.7 ПРОГРАММНАЯ РЕАЛИЗАЦИЯ АЛГОРИТМА 1R РАСПАРАЛЛЕЛЕННОГО ПО АТРИБУТАМ ............. 320 Б.8 ПРОГРАММНАЯ РЕАЛИЗАЦИЯ ТЕСТА ДЛЯ АЛГОРИТМА 1R ......................................................... 321 Б.9 ПРОГРАММНАЯ РЕАЛИЗАЦИЯ ТЕСТА ДЛЯ ВЫПОЛНЕНИЯ ЭКСПЕРИМЕНТА АЛГОРИТМА 1R ....... 322
ПРИЛОЖЕНИЕ В. ПРИМЕРЫ АЛГОРИТМОВ АНАЛИЗЫ ДАННЫХ. ........................... 323
В.1. АЛГОРИТМ КЛАССИФИКАЦИИ NAÏVE BAYES ............................................................................ 323 В 1.1 Описание алгоритма Naïve Bayes ................................................................................... 323 В.1.2 Модель Naïve Bayes .......................................................................................................... 324 В.1.3 Представление алгоритма Naïve Bayes в виде композиции функций обработки модели
знаний .......................................................................................................................................... 325 В.1.4 Проверка условий параллельного выполнения функций алгоритма Naïve Bayes .... 326 В.1.5 Параллельные формы алгоритма Naïve Bayes ............................................................... 328
В.2 АЛГОРИТМ КЛАСТЕРИЗАЦИИ KMEANS ...................................................................................... 329 В.2.1 Описание алгоритма kMeans ........................................................................................... 329 В.2.2 Модель для алгоритма kMeans ........................................................................................ 330 В.2.3 Представление алгоритма kMeans в виде композиции функций обработки модели
знаний .......................................................................................................................................... 331 В.2.4 Проверка условий параллельного выполнения функций алгоритма kMeans ............. 334 В.2.5 Параллельные формы алгоритма kMeans....................................................................... 341
В.3. АЛГОРИТМ ПОИСКА ЧАСТЫХ НАБОРОВ – APRIORI TID ............................................................ 343 В.3.1 Описание алгоритма Apriori TID .................................................................................... 343 В.3.2 Модель для алгоритма Apriori TID ................................................................................. 344 В.3.3 Представление алгоритма Apriori TID в виде композиции функций обработки
моделей знаний ........................................................................................................................... 347 В.3.4 Проверка условий параллельного выполнения функций алгоритма Apriori TID ...... 348 В.3.5 Параллельные формы алгоритма Apriori TID ................................................................ 353
6
Введение
Актуальность темы исследования.
За последние десятилетия у человечества накоплены значительные объемы
оцифрованных данных, которые содержат полезные знания. Они размещаются в
хранилищах данных или на множестве территориально распределенных узлов,
объединенных как локальными, так и глобальными средствами передачи данных,
образующих распределенные вычислительные среды. С развитием технологии
Интернета вещей (Internet of Things), источниками информации становятся не
только люди, но и устройства (сенсоры, смартфоны, видеокамеры и т.п.)
подключаемые к сети. Они формируют потоки разнородных данных, увеличивая
количество распределенных источников информации. Лавинообразный рост
источников и объемов информации, ее разнородность и распределенный характер
хранения привели к необходимости пересмотра не только технологий сбора и
хранения данных, но также и технологий анализа данных.
Анализ данных позволяет формировать новые знания, содержащие
представления о характере объектов или явлений. К типовым задачам анализа
данных относятся: классификация, кластеризация, нахождение ассоциаций,
выявление аномалий, и др. Для решения таких задач разработано большое число
алгоритмов анализа данных.
Большинство из известных алгоритмов анализа применяются к данным,
хранящимся централизовано. Использование таких алгоритмов в случаях, когда
данные размещены на распределенных источниках, предполагает их наличие в
одном узле хранения данных, что приводит к следующим проблемам:
затрачивается время на передачу информации, что может быть критично
при ее обработке, например, в режиме реального времени;
7
увеличивается сетевой трафик, что снижает возможности использования
каналов связи с низкой пропускной способностью (спутниковых каналов
связи, беспроводных каналов и т.п.);
требуется передача информации, в том числе конфиденциальной, по
открытым каналам передачи данных;
повышается ценность собранной в одном месте информации, что
требует повышенных мер обеспечения ее безопасности и надежности.
Исключить указанные недостатки можно за счет анализа непосредственно
на источнике информации. Подобный подход предполагает также активно
развивающаяся концепция «туманных» вычислений (Fog Сomputing) [1]. Однако
для реализации данной концепции в области анализа данных необходимо
создание новых методов и средств построения параллельных алгоритмов,
позволяющих выполнять анализ больших объемов распределенных данных без их
предварительного сбора в едином хранилище. Кроме того, новые методы и
средства должны учитывать тип распределения данных. Данные могут быть
распределены горизонтально, когда на разных источниках хранится информация
о разных объектах и явлениях, или вертикально, когда на разных источниках
хранится информация о разных характеристиках одних и тех же объектов.
В диссертации предложены методы и модели для построения параллельных
алгоритмов анализа распределенных данных. Полученные результаты позволяют
решить крупную научную проблему, имеющую важное хозяйственное значение в
области разработки распределенных аналитических систем - проблему анализа
распределенных данных. Данная проблема отражена также в рамках программы
«Цифровая экономика Российской Федерации». Ее решение находится на стыке
таких направлений как формирование исследовательских компетенций и
технологических заделов, информационная инфраструктура и информационная
безопасность. При этом она имеет непосредственное отношение к развитию таких
8
сквозных цифровых технологий как: большие данные, системы распределенного
реестра, промышленный интернет и др.
Степень разработанности темы исследования
В настоящее время в области параллельных и распределенных вычислений,
ведется большое число исследований. Можно выделить следующие уровни
распараллеливания: уровень программ, уровень алгоритмов и уровень
распределенных компонент.
Исследования на уровне программ направлены на разработку методов их
автоматического распараллеливания, на этапе компиляции, для выполнения в
параллельной среде. Такие исследования включают в себя методы анализа
зависимостей, оптимизацию циклов и др. В этой области выделяются работы:
Евстигнеева В. А., Бернстайна А., Беренжи У., Псариса К., и др.
Множество исследований посвящено построению параллельных
алгоритмов. Они направлены как на создание общих методов построения и
анализа параллельных алгоритмов, так и на построение параллельных алгоритмов
решения отдельных ресурсоемких задач: систем линейных уравнений,
вычислений с матрицами и векторами, сортировки данных, выполнения операций
над графами, моделирования сложных процессов, а также задач обработки
данных. В эту область существенный клад внесли отечественные и зарубежные
ученные: Абрамов С. М., Болдырев Ю. Я., Бухановский А. В., Воеводин В. В.,
Воеводин Вл. В., Гергель В. П., Демьянович Ю. К., Евтушенко Ю. Г., Каляев А.
В., Каляев И. А., Карпов В. Е., Левин В. К., Малышкин В. Э., Четверушкин Б. Н.,
Шагалиев Р. М., Якобовский М. В., Агравал Р., Амдаль Дж., Боксер Л., Миллер Р.,
Милнер Р., Нильсен М., Огихара М., Ортега Дж., Петри К., Талиа Д., Фостер Я.,
Хоар Ч. и др.
В области построения параллельных алгоритмов анализа данных можно
выделить два основных подхода. Первый подход направлен на распараллеливание
известных и проверенных на практике последовательных алгоритмов, в том
9
числе, и алгоритмов анализа данных. Авторами таких методов и алгоритмов
являются известные отечественные и зарубежные ученные: Вапник В. Н., Горбань
А. М., Дьяконов А. Г., Загоруйко Н. Г., Зиновьев А. Ю., Мерков А.Б., Миркес Е.
М., Пятецкий-Шапиро Г. И., Червоненкис А. Я., Агравал Р., Квинлан Дж.,
Кохонен Т., Уиллиамс У. Т. и др.
Основным недостатком такого подхода является сложность
распараллеливания, связанная с возможным отсутствием внутреннего
параллелизма в таких алгоритмах. Это приводит к высокой трудоемкости
распараллеливания алгоритмов для разных условий выполнения (например, для
работы с общей или распределенной памятью, для анализа горизонтально или
вертикально распределенных данных и т.п.).
Альтернативным подходом является построение новых параллельных
алгоритмов анализа данных, оптимизированных для выполнения в заданных
условиях. Можно выделить работы следующих авторов в этой области: Агравал
Р., Заки М., Каргупта Х., Кумар В., Огихара М. и др.
Недостатком такого подхода является необходимость проверки
корректности новых алгоритмов на наборах данных с разными характеристиками.
Кроме того, при изменении условий выполнения требуется разработка новых
алгоритмов, что ведет к необходимости новых исследований.
На уровне распределенных компонент исследования направлены, в том
числе, на создание новых методов и средств, оптимизирующих выполнение
параллельных алгоритмов в различных распределенных средах и повышающих
возможности их масштабирования. Авторами известных работ в этой области
являются: брамов С. М., Бетелин В. Б., Бурцев В. С., Васильев В. В., Воеводин В.
В., Воеводин Вл. В., Глушков В. М., Евдокимов В. Ф., Евреинов Э. В., Забродин
А. В., Иванников В. П., Игнатьев М. Б., Каляев А. В., Каляев И. А., Косарев Ю. Г.,
Корнеев В. В., Королев Л. Н., Лазарев В. Г., Лацис А. О., Лебедев С. А., Левин В.
К., Левин И. И., Мельников В. А., Митропольский Ю. И., Поспелов Д. А.,
10
Прангишвили И. В., Пухов Г. Е., Рябов Г. Г., Шейнин Ю. Е., Томилин А. Н.,
Хетагуров Я.А., Хорошевский В. Г., Четверушкин Б. Н., Шокин Ю. И., Яненко Н.
Н., Береснев В. Л., Мельник Э. В., Курносов М. Г., Бохари Ш. и др.
В области распределенной обработки данных наиболее популярным
средством является программная модель MapReduce, предложенная
специалистами компании Google Inc. Она предполагает явное разделение
алгоритма обработки данных на две функции: map и reduce, копии которых могут
выполняться параллельно на множестве вычислительных узлов. Это позволяет
эффективно выполнять параллельную обработку данных из единого источника, с
высокой степенью масштабирования. Однако данный подход требует наличие у
распараллеливаемых функций свойств списочного гомоморфизма, не позволяет
использовать общую память и распараллеливать по задачам.
Существующие модели и методы построения параллельных алгоритмов
анализа данных не учитывают тип распределения данных и предполагают их
применение к единому источнику информации. Они позволяют снизить время
выполнения алгоритма анализа, но в случае распределенного хранения данных
необходимость их сбора в едином хранилище требует дополнительных
временных затрат, увеличивает сетевой трафик и повышает требования к
безопасности.
В данной работе предложены модели и методы параллельного построения
алгоритмов анализа данных для выполнения в распределенной среде с
возможностью размещения части функций анализа на источниках информации.
При этом учитывается тип распределения данных, что повышает
производительность, снижает сетевой трафик и не требует повышенных мер
безопасности.
11
Целью работы является разработка моделей и методов построения
параллельных алгоритмов анализа данных с учетом условий их выполнения.
При этом решаются следующие задачи:
1. Анализ существующих моделей, методов и средств построения
параллельных алгоритмов, в том числе алгоритмов анализа данных.
2. Представление модели знаний, ориентированное на параллельное
построение в общей и в распределенной памяти.
3. Представление алгоритма анализа данных в виде композиции
унифицированных функций для его реструктуризации в зависимости от
условий выполнения.
4. Разработка метода оптимизации структуры алгоритма анализа данных в
зависимости от типа распределения данных.
5. Создание модели параллельного алгоритма анализа данных как для
распределенной, так и для общей памяти.
6. Определение условий параллельного выполнения функций алгоритма
анализа данных с использованием общей и распределенной памяти.
7. Разработка метода распараллеливания последовательных алгоритмов
анализа данных по задачам и по данным, для выполнения с использованием
общей и распределенной памяти.
8. Разработка метода размещения функций параллельных алгоритмов анализа
данных в заданной среде выполнения с учетом способа размещения данных.
9. Разработка методики построения параллельных алгоритмов анализа данных
с использованием предложенных моделей и методов.
10. Программная реализация предложенных моделей и методов построения
параллельных алгоритмов анализа данных.
11. Экспериментальные исследования построения параллельных алгоритмов
анализа данных с учетом условий их выполнения.
12
Объектом исследования данной работы являются параллельные
алгоритмы анализа данных.
Предметом исследования данной работы являются модели и методы
построения параллельных алгоритмов анализа данных для выполнения в заданной
среде.
Методология и методы исследований: методология проектирования
параллельных алгоритмов, методы анализа зависимостей, теория алгоритмов,
теория графов, функциональный анализ, методы оценки алгоритмов, теория -
исчислений, теория множеств.
Обоснованность и достоверность результатов, выводов и рекомендаций,
сформулированных в диссертации, подтверждаются корректным применением
математического аппарата, совпадением результатов исследования с
экспериментальными данными и результатами практической апробации,
обсуждением результатов исследования на международных и всероссийских
научных конференциях, а также публикациями результатов исследования в
рецензируемых научных изданиях.
Основные положения, выносимые на защиту
1. Представлена модель знаний, описывающая выявляемые закономерности в
виде списка деревьев и включающая в себя функции, обеспечивающие их
параллельное построение алгоритмом анализа данных в общей и
распределенной памяти [2, 3].
2. Предложена функциональная модель алгоритма анализа данных в виде
композиции унифицированных потокобезопасных функций, которая может
быть сформирована с учетом заданных условий выполнения [4, 5].
3. Разработан метод оптимизации структуры алгоритма анализа данных,
трансформирующий циклы с учетом типа распределения данных для
минимизации времени его выполнения [6].
13
4. Предложена модель параллельного алгоритма анализа данных,
использующая специальные функции высшего порядка, для выполнения как
в общей, так и в распределенной памяти [7, 8, 9, 10, 11].
5. Определены условия параллельного выполнения функций алгоритмов
анализа данных, уточняющие условия Бернстайна и учитывающие
особенности общей и распределенной памяти [3, 7].
6. Предложен метод распараллеливания последовательных алгоритмов анализа
данных, как по задачам, так и по данным, учитывающий возможность
использования общей и распределенной памяти [7, 12].
7. Разработан метод размещения функций алгоритма анализа данных в заданной
среде выполнения, минимизирующий время выполнения алгоритма и сетевой
трафик [13, 14, 15, 16].
8. Предложена методика построения параллельных алгоритмов анализа данных,
использующая предложенные модели и методы и позволяющая
оптимизировать структуру алгоритмов для минимизации времени
выполнения и сетевого трафика с учетом условий выполнения [17, 18].
9. Разработана библиотека для построения параллельных алгоритмов анализа
данных, включающая в себя программные реализации предложенных
моделей и методов и позволяющая учитывать условия их выполнения [19-25].
Научная новизна
1. Модель представления знаний имеет структуру и функции, ориентированные
на ее параллельное построение алгоритмами анализа данных в общей и
распределенной памяти.
2. Функциональная модель алгоритма анализа данных отличается от
существующих представлением вычислительных и структурных блоков
алгоритма в виде унифицированных функций, что позволяет
реструктурировать алгоритм в зависимости от условий его выполнения.
14
3. Метод оптимизации структуры алгоритма анализа данных в отличие от
известных адаптирует структуру алгоритма в соответствии с типом
распределения анализируемых данных.
4. Модель параллельного алгоритма анализа данных, отличающаяся от
существующих возможностью его распараллеливания как по задачам, так и
по данным, для выполнения в общей и распределенной памяти.
5. Условия параллельного выполнения функций алгоритма анализа данных,
уточняющие условия Бернстайна и учитывающие особенности
использования общей и распределенной памяти.
6. Метод распараллеливания последовательного алгоритма анализа данных,
отличающийся от существующих формированием оптимального числа
параллельных ветвей, с учетом типа памяти.
7. Метод размещения функций алгоритма анализа данных в среде выполнения,
оптимизирующий время его выполнения и сетевой трафик с учетом способа
хранения данных.
Теоретическая значимость работы
1. Модель знаний позволяет унифицировать функции алгоритма анализа
данных и осуществить проверку условий возможности их параллельного
выполнения.
2. Функциональная модель алгоритма анализа данных, позволяет проводить
анализ структуры алгоритма с целью выявления потенциальных мест его
распараллеливания.
3. Модель параллельного алгоритма анализа данных обеспечивает его
распараллеливание, как по задачам, так и по данным для выполнения в общей
и распределенной памяти.
15
4. Условия параллельного выполнения функций алгоритмов анализа данных,
позволяют определить возможности их распараллеливания для общей и
распределенной памяти.
Практическая значимость работы
1. Метод оптимизации структуры алгоритма анализа данных, обеспечивает
повышение производительности за счет уменьшения числа переключений
между распределенными источниками данных.
2. Метод распараллеливания последовательного алгоритма анализа данных,
позволяет на основе проверенных практикой последовательных алгоритмов,
строить параллельные алгоритмы, использующие как общую, так и
распределенную память.
3. Метод размещения функций алгоритмов анализа данных, обеспечивает
минимизацию времени выполнения и сетевого трафика анализа
распределенных данных.
4. Методика построения параллельных алгоритмов анализа данных определяет
порядок применения полученных результатов для выполнения анализа
данных в параллельной и распределенной среде без необходимости сбора
информации в едином хранилище.
5. Библиотека параллельных алгоритмов анализа данных обеспечивает
использование полученных результатов при разработке прикладных систем,
выполняющих анализ распределенных данных.
Внедрение результатов работы. Теоретические и практические результаты
работы были использованы в программных средствах, разработанных в СПбГЭТУ
«ЛЭТИ» для облачного сервиса интеллектуального анализа данных в рамках НИР
поддержанных Министерством образования РФ. Также полученные результаты
16
были использованы в АО «НИЦ СПб ЭТУ» при выполнении НИР и ОКР по заказу
отраслевых министерств и ведомств.
Апробация результатов. Результаты работы обсуждались более чем на 30
конференциях, включая: международные конференции в Германии, Польше,
Черногории и России, национальный суперкомпьютерный форум в Переяславль-
Залеском и отраслевые научно-технические конференции.
Публикации. Основное содержание диссертационной работы
опубликовано более чем в 70 печатных работах общим объемом более 60 п.л.
(личный вклад автора – более 50 п.л.), в том числе: 1 диссертация (лично), 7
монографий, 17 статей в журналах, входящих в перечень ВАК, более 30
публикаций в изданиях индексируемых Web of Science/Scopus.
Структура и объем.
Диссертация состоит из введения, 7 глав с выводами по каждой главе,
заключения, 3 приложений и списка литературы, содержащего 371 наименование.
Общий объем работы составляет 353 страницы машинописного текста, включая
79 рисунков и 14 таблиц.
17
1. Анализ существующих моделей и методов построения
параллельных алгоритмов анализа данных
Настоящее время характеризуется широким применением цифровых
технологий и всеобщей информатизацией общества. В результате у человечества
накоплены огромные объемы данных. Однако без их анализа и извлечения новых
полезных знаний они не представляют особой ценности.
За несколько последних десятилетий было разработано большое количество
методов и алгоритмов, как последовательных, так и параллельных, успешно
решающих различные задачи анализа данных: классификации, кластеризации,
выявления аномалий и т.п. Они успешно применяются к данным хранящимся в
базах данных, хранилищам данных и т.п. В то же время, анализ требуется не
только по отношению к данным, предварительно собранным и хранящимся
централизовано, но и к распределенным данным, а также к данным поступающих
от различных устройств: видео- и фотокамер, датчиков, сенсоров и др. С
развитием технологии Интернета вещей, увеличивается число устройств,
объединяемых в сети. По информации издания Gartner1 к 2020 году к Интернету
будет подключено около 26 миллиардов устройств.
В новых условиях требуется не только повышение быстродействия
алгоритмов анализа данных, за счет их распараллеливания, но и их выполнение в
распределенных средах с множеством источников информации. Исследования в
области параллельных и распределенных вычислений ведутся давно на разных
уровнях. В данной главе описан анализ существующих методов и средств
построения параллельных алгоритмов, в том числе алгоритмов анализа данных.
1 Gartner Says the Internet of Things Installed Base Will Grow to 26 Billion Units By 2020. Gartner. 12 December 2013.
Retrieved 2 January 2014
18
1.1 Методы анализа данных
1.1.1 Задачи анализа данных
Под анализом данных (информации) понимают совокупность действий
осуществляемых исследователем в процессе изучения полученных тем или иным
образом данных с целью формирования определенных представлений о характере
явления, описываемого этими данными. Такие представления необходимы для
классификации явления, его ассоциирования и т.п. [26].
Алгоритмы анализа данных обрабатывают массивы информации с целью
получения новых знаний. К наиболее ранним методам анализа данных можно
отнести методы математической статистики [27, 28, 29, 30, 31, 32, 33, 34, 35]. Они
применялись к числовым данным для расчетов разных параметров:
математического ожидания, дисперсии, трендов, аппроксимации и т.п.
Развитием этих методов являются методы интеллектуального анализа:
методы машинного обучения (machine learning) [36, 37, 38, 39], data mining [40, 41,
42, 43, 44, 45, 46, 47], глубинный анализ (deep learning) [49, 50, 51] и т.п.
Интеллектуальный анализ данных (ИАД2) – это процесс обнаружения в
«сырых» данных ранее неизвестных нетривиальных практически полезных и
доступных интерпретации знаний, необходимых для принятия решений в
различных сферах человеческой деятельности [48].
Формальное представление извлеченных знаний будем называть моделью
знаний. Извлеченные модели знаний позволяют выполнять различные
аналитические функции, основными из них являются [41, 44, 52, 53]:
классификация – определение класса объекта по его характеристикам
(множество классов, к которым может быть отнесен объект, заранее
известно);
2В англо язычной литературе для интеллектуального анализа данных используется термин Data Mining.
19
регрессия – определение по известным характеристикам объекта значения
некоторого его параметра (в отличие от задачи классификации значением
параметра является не конечное множество классов, а множество
действительных чисел);
поиск частых наборов – нахождение частых зависимостей (ассоциаций)
между объектами или событиями;
кластеризация – поиск независимых групп (кластеров) и их характеристик
во всем множестве анализируемых данных;
анализ временных рядов – вычисление статистических и других
характеристик данных изменяющихся во времени;
выявление аномалий – поиск выбросов и аномальных значений в данных.
1.1.2 Представление моделей знаний
Знания, извлекаемые алгоритмами анализа данных, представляются для их
использования в системах поддержки принятия решений. Существуют различные
способы формального представления знаний:
продукционные модели;
семантические сети;
фреймы;
логические модели.
Продукционная модель (модель, основанная на правилах) [54] позволяет
представить знания в виде предложений, называемых продукциями, вида:
«Если (условие), то (действие)».
Под условием (антецедентом) понимается некоторое предложение-образец.
Под «действием» (консеквентном) понимается операция, выполняемая при
успешном исходе условия. Достоинством продукционной модели является
наглядность, высокая модульность, легкость внесения дополнений и изменений и
простотой механизм логического вывода. Недостатком является накопление
20
достаточно большого количества (порядка нескольких сотен) продукций, которые
могут противоречить друг другу. Рост противоречивости продукционной модели
может быть ограничен путем введения механизмов исключений и возвратов.
Механизм исключений означает, что вводятся специальные правила-
исключения. Их отличает большая конкретность в сравнении с обобщенными
правилами. При наличии исключения основное правило не применяется.
Механизм возвратов означает, что логический вывод может продолжаться
даже в том случае, если на каком-то этапе вывод привел к противоречию: просто
необходимо отказаться от одного из принятых ранее утверждений и осуществить
возврат к предыдущему состоянию.
Семантическая сеть это ориентированный граф, вершины которого
отображают некоторые понятия предметной области, а дуги – отношения между
ними. Таким образом, семантическая сеть отражает семантику предметной
области в виде понятий и отношений. Идея систематизации на основе каких-либо
семантических отношений не раз возникала в ранние периоды развития науки.
Прародителями современных семантических сетей можно считать
экзистенциальные графы (existential graph), предложенные Чарльзом Пирсом
(Charles Sanders Peirce) в 1909 г [55]. Компьютерные семантические сети были
детально разработаны Ричардом Риченсом в 1956 году в рамках проекта
Кембриджского центра изучения языка по машинному переводу [56]. Количество
типов отношений в семантической сети определяется ее создателем исходя из
конкретных целей. В реальном мире их число стремится к бесконечности.
Фрейм это абстрактный образ для представления некоторого стереотипа
информации. Представление знаний в виде фреймов, организованных в
древовидную структуру было предложено М. Минским в 1979 [57].
Различают фреймы-образцы (прототипы), хранящиеся в базе знаний, и
фреймы-экземпляры, которые создаются для отображения реальных фактических
ситуаций на основе поступающих данных. Модель фрейма является достаточно
21
универсальной, поскольку позволяет отобразить все многообразие знаний о мире
через:
фреймы-структуры, использующиеся для обозначения объектов и понятий
(заем, залог, вексель);
фреймы-роли (менеджер, кассир, клиент);
фреймы-сценарии (банкротство, собрание акционеров, празднование
именин);
фреймы-ситуации (тревога, авария, рабочий режим устройства) и др.
Традиционно структура фрейма может быть представлена как список
свойств:
(ИМЯ ФРЕЙМА
(имя 1-го слота: значение 1-го слота),
(имя 2-го слота: значение 2-го слота),
…
(имя N-го слота: значение N-го слота)
).
Логические модели основываются на классическом исчислении предикатов
I-го порядка, когда предметная область или задача описываются в виде набора
аксиом. Чаще всего эти логические модели строятся при помощи декларативных
языков логического программирования, наиболее известным представителем
которых, является язык Пролог (Prolog). Они удобны для представления
логических взаимосвязей между фактами и хорошо формализованы.
Перечисленные способы представления знаний предназначены для
описания знаний о некоторой предметной области и предназначены для
достаточно широкого применения. В отличие от них алгоритмы анализа
извлекают новые знания, отражающие закономерности в анализируемых данных.
Для их представления используют различные модели:
классификационные правила (продукционные модели);
деревья решений;
22
нейронные сети;
математические функции и т.п.
В области ИАД для описания различных модели знаний используется
стандарт PMML [58]. Он описывает каждую модель знаний на языке XML.
Основной конструкцией языка XML являются элементы, которые могут
содержать в себе другие вложенные конструкции и тем самым формировать
иерархическую структуру в виде дерева. XML элементы могут иметь атрибуты
(чтобы не путать их с атрибутами набора данных, будем называть их свойствами).
Основным недостатком данного стандарта является не универсальность (для
каждой вида знаний вводится своя модель). Кроме того, он не предполагает
параллельное построение таких моделей.
1.2.2 Алгоритмы анализа данных
Существует большое множество алгоритмов, строящих различные модели
знаний. Так, разные алгоритмы классификации строят разные модели знаний
(классификаторы). Выделяют следующие типы классификаторов (Рисунок 1.1):
классификационные правила представляют собой набор правил вида «если
– то», в которых в условной части записываются независимые атрибуты, а в
заключительной – значения целевых атрибутов, и строятся алгоритмами: 1R
[59], Data Squeezer [60], семейства RULES [61] и др.;
Байесовская сеть содержит для каждого независимого атрибута и его
значения вероятности отнесения вектора к тому или иному классу и
строится алгоритмом Naive Bayes [62, 63] и его модификациями: selective
Naive Bayes [64], semi Naive Bayes [65], one-dependence Bayesian classifiers
[66, 67], K-dependence Bayesian classifiers [68], Bayesian network-augmented
Naive Bayes [69], unrestricted Bayesian classifiers [70], и Bayesian multinets
[72];
23
Рисунок 1.1 – Алгоритмы классификации.
деревья решений представляют собой деревья, в узлах которых указываются
независимые атрибуты, а в листьях – значения зависимых атрибутов;
строится алгоритмами: RPART [71], ID3 (Iterative Dichotomiser 3) [72], С4.5
[73], CART (Classification and Regression Trees) [74], CHAID (chi-squared
automatic interaction detector) [75], MARS [83], FACT [77], CRUISE [78, 79],
GUIDE [80], QUEST [81], CTree [82] и др.;
ближайшие соседи являются векторами ближайшими к заданному вектору и
строятся алгоритмами: KNN алгоритм [83], Wavelet Based K-Nearest
Neighbor Partial Distance Search (WKPDS) алгоритм [84], Equal-Average
Nearest Neighbor Search (ENNS) алгоритм [85], Equal-Average Equal-Norm
Nearest Neighbor code word Search (EENNS) алгоритм [86], Equal-Average
Equal-Variance Equal-Norm Nearest Neighbor Search (EEENNS) алгоритм
[87];
24
математическая функция (регрессия) представляет собой функцию
аппроксимации, строящуюся алгоритмами: наименьших квадратов [88, 89],
SVM [90] и его модификации GSVM (granular support vector machines) [91,
92, 93], FSVM (fuzzy support vector machines) [94, 95, 96], TWSVMs (twin
support vector machines) [97, 98, 99], VaR-SVM (value-at-risk support vector
machines) [100], and RSVM (ranking support vector machines) [101].
Алгоритмы кластеризации строят модели, которые описывают кластеры
разными способами (Рисунок 1.2). Различают следующие кластерные модели:
иерархические, формирующие иерархии кластеров (часто представляемых в
виде дендрограмм) и строящиеся:
o агломеративными алгоритмами (строящими дендрограмму снизу
вверх): Ward’s [102], UPGMA [103], SLINK [104, 105], CURE
(Clustering Using Representatives) [106],
o дивизимными алгоритмами (строящими дендрограмму сверху вниз)
SVD (Singular Value Decomposition) [107], DIANA [108];
центроидные, определяющие кластеры с помощью его центра кластера и
строящиеся алгоритмами: Lloyd's [109], SNOB [110], MCLUST [111], k-
means [112], BANG[113];
основанные на распределении, определяющим для каждого вектора
вероятности, с которыми он относится к кластерам: EM алгоритм [114] и
его разновидности [115, 116];
плотностные, описывающие кластеры как области высокой плотности
(сгустки); при этом вектора, не попадающие в эти области,
рассматриваются как шум или границы кластеров: DBSCAN [117, 118],
OPTICS [119], DeLi-Clu [120], Mode Seeking [121] и др.
графовые, описывающие кластеры в виде графов: MST [122], ROCK [123],
Chameleon [124] и др.
25
Рисунок 1.2 – Алгоритмы кластеризации.
Алгоритмы построения ассоциативных правил можно разделить на
следующие категории (Рисунок 1.3):
алгоритм Apriori [125] и его модификации:, Partition [126], MSPS [127],
LAPIN-SPAM [128] и др.
алгоритмы, строящие граф (в том числе дерево) для определения частых
наборов: FP-Growth [129], ECLAT [130], FIN [131], PrePost [132], PPV [133]
и др.;
алгоритмы, использующие хеширование: DHP [134], САRМA[135];
алгоритмы анализа последовательности событий (sequence analyses),
например, алгоритмы PROWL [136, 137] и др.
Рисунок 1.3 – Алгоритмы поиска ассоциативных правил.
26
Алгоритмы анализа временных рядов делятся на три части (Рисунок 1.4):
представления временного ряда:
o основанные на представлении модели: ARMA [138], time series
bitmaps [139];
o не адаптируемых к данным: DFT [140], wavelet functions related topic
[141] и PAA [142];
o адаптируемых к данным: DFT [143] /PAA [144] и индексируемый PLA
[145].
симулирующие (аппроксимирующие измерения): subsequence matching [146]
и full sequence matching [147].
индексирующие: SAMs (SpatialAccess Methods) и TS-Tree [149].
Рисунок 1.4 – Алгоритмы анализа временных рядов.
27
Алгоритмы выявления аномалий ищут шаблоны в данных и затем при
появлении данных, не покрываемых такими шаблонами, считают их выбросами и
аномалиями. Примером такого алгоритма является fuzzy rough sets to identify
outliers [150].
Несмотря на большое разнообразие алгоритмов анализа данных можно
выделить следующие их общие свойства:
1) неизменяемость анализируемых данных;
2) формирование модели знаний, размер которой значительно меньше
объема анализируемых данных;
3) необходимость одного или нескольких проходов как по объектам,
описываемых данными, так и по их характеристикам;
4) извлечение из данных закономерностей сложными функциями, которые
обрабатывают несколько произвольных объектов из набора данных (не
обладающими свойством списочного гомоморфизма).
1.2 Распределенный анализ данных
1.2.1 Распределенный анализ Больших данных
Рост объемов хранимой информации привел к появлению понятия Больших
данных, которые часто определяются тремя V: Volume, Variety и Velocity) [151]:
- большие объемы информации (data volume);
- различные форматы (data variety);
- генерируются с высокой частотой (data velocity).
Анализ таких данных является ресурсоемкой задачей. В связи с этим для
обработки и анализа Больших данных используют средства распределенных
вычислений, реализующие разные модели [148].
28
Наиболее популярной в настоящее время является программная модель
распределенных вычислений MapReduce [152]. Она разделяет обработку данных
на две функции, реализуемые разработчиком: map и reduce:
map - функция принимает два аргумента: ключ k1 и значение v1 и
возвращает набор промежуточных пар ключ/значение [(k2,v2)]:
map :: k1 → v1 → [(k2,v2)];
reduce - функция принимает промежуточный ключ k2 и набор значений
соответствующих ему [v2] и возвращает значение v3:
reduce :: k2 → [v2] →v3.
В функциональном виде работу MapReduce системы можно записать в виде
композиции функций [153]:
mapReduce :: (k1→v1→[(k2,v2)]) -- функция map
→(k2 → [v2] →v3) -- функция reduce
→ [(k1,v1)] -- набор входных пар key/value
→ [(k2, v3)] -- набор выходных пар key/value
mapReducemapreduce =
reducePerKeyreduce -- 3. Применяет функцию reduce к каждой группе
groupByKey -- 2. Группирует по промежуточному ключу
mapPerKeymap -- 1. Применяет функцию map к каждой паре ключ/значение.
При этом функция reduce должна реализовывать функцию списочного
гомоморфизма [154]. Существует достаточно много задач, где данные условия
выполняются [153]:
распределенный поиск слов по регулярному выражению (Distributed GREP);
подсчет частоты обращения к URL адресам (URL Access Frequency);
29
поиск страниц, ссылающихся на определенную ссылку (ReverseWeb-
LinkGraph);
индексирование Web страниц по каждому ключевому слову (Inverted Index)
распределенная сортировка документов (Distributed Sort) и др.
Модель программирования MapReduce успешно применяется и к некоторым
алгоритмам анализа данных. Использующие данную модель платформы Apache
Spark [155] и Apache Hadoop [156] используются для обработки Больших данных
в системах компаний Google, Yandex и др.
Модель MapReduce используется для распределенного выполнения
алгоритмов анализа данных на многоядерных системах. В работе [157] описан
подход, декомпозирующий алгоритмы анализа данных на функции map и reduce.
Однако он применим только к алгоритмам, соответствующих модели
статистических запросов (SQM - Statistical Query Model) и вычисляющих
статистические характеристики в данных или градиент. Основная идея метода
заключается в разделении алгоритма на две функции: map, которая вычисляет
статистику для каждой порции данных и reduce, которая агрегирует полученные
результаты.
Проводятся также исследования по адаптации различных алгоритмов
анализа к модели MapReduce: алгоритмов кластеризации [158], регрессионного
анализа [159], деревьев решений [160, 161], классификации [162, 163] поиска
частых наборов [164, 165] и др.
Также можно выделить различные современные библиотеки
распределенных алгоритмов анализа данных, адаптированных к модели
MapReduce (Таблица 1.1).
30
Таблица 1.1 – Библиотеки алгоритмов анализа для распределенного выполнения
Свойства Apache
Mahout
Apache Spark
MLib
ML Grid
Apache Ignite
SAMOA Vowpal
Wabbit
Модель MapReduce MapReduce MapReduce MapReduce MapReduce
Платформа Apache
Hadoop
Apache Spark
(Akka – Actor
model)
Apache Ignite S4 (Actor
model)
Apache
Hadoop
Источник
данных
Один Один Один Один Один
Задачи
анализа
Classification,
Regression,
Clustering
Classification,
Regression,
Clustering,
Frequent
itemset mining
Classification,
Regression,
Clustering
Classification,
Clustering,
Regression for
data streams
Classification,
Regression
Количество
алгоритмов
7 8 5 5 9
Добавление
новых
Да Да Да Да Да
Номер версии 0.13.0 2.3.0 2.4.0 0.4.0 8.5.0
Дата релиза Дек 2017 Фев 2018 Март 2018 Авг 2016 Дек 2017
Apache Mahout [166] - библиотека алгоритмов data mining, адаптированных
к модели MapReduce, которые могут выполняться на платформе Apache Hadoop
[156]. Она содержит ряд алгоритмов для распределенного выполнения:
классификации (Naive Bayes, Random Forest, Multilayer perceptron classifier
(MLPC)), регрессии (Ordinary Least Squares (OLS), Linear Regression, Support
Vector Machine (SVM)), кластеризации (Canopy-clustering). Она также позволяет
добавлять собственные алгоритмы, декомпозированные на функции map и reduce.
Apache Spark Machine Learning Library (MLlib) [155] библиотека
алгоритмов machine learning, адаптированных к модели MapReduce, которые
могут выполняться на платформе Apache Spark. Она содержит следующие
31
алгоритмы: классификации (Logistic Regression, Random Forest, MLPC, Naive
Bayes), регрессии (Linear Regression, SVM), кластеризации (K-Means), поиска
частых наборов (FP-Growth). Пользователь также может расширять данную
библиотеку.
ML Grid [167] из Apache Ignite 2.0 содержит алгоритмы machine learning
для распределенного выполнения. Она включает в себя следующие алгоритмы:
Linear Regression, K-Means, MLPC, Fuzzy C-Means и k-NN (k-nearest neighbors).
Они могут выполняться на платформе Ignite Compute Grid, которая также
реализует модель MapReduce. Библиотека также является расширяемой.
Для анализа потоковых Больших данных может быть использована
платформа Scalable Advanced Massive Online Analysis (SAMOA) [168-170]. Она
включает в себя распределенные data mining алгоритмы: Vertical Hoeffding Tree
(VHT), Very Fast Decision Tree (VFDT), CluStream, Adaptive Model
Rules (AMRules), PARMA. SAMOA имеет адаптеры для выполнения алгоритмов
на различных платформах: Apache Storm [171, 172], Apache S4 [173] (Simple
Scalable Streaming System) и Apache Samza [174]. Все эти платформы реализуют
модель MapReduce. SAMOA позволяет разработчикам интегрировать
существующие алгоритмы из библиотеки MOA [175].
Vowpal Wabbit (VW) [176] библиотека алгоритмов анализа, начатая как
открытый проект, компанией Yahoo!. В настоящее время она развивается
компанией Microsoft. Она использует платформу Apache Hadoop для
масштабируемых вычислений и содержит несколько алгоритмов data mining для
классификации и регрессии: OLS, Matrix factorization (sparse matrix SVD), Single
layer neural net (with user specified hidden layer node count), Searn (Search and
Learn), Latent Dirichlet Allocation (LDA), Stagewise polynomial approximation, One-
against-all (OAA), Weighted all pairs, Contextual-bandit.
Таким образом, все современные библиотеки алгоритмов анализа Больших
данных используют различные платформы распределенных вычислений,
32
основанных на модели MapReduce. Однако, адаптация алгоритма к данной модели
достаточна трудоемка. Например, для преобразования типового алгоритма
построения деревьев решения C 4.5 к модели MapReduce в работе [160] были
добавлены несколько новых структур данных, а в алгоритм были добавлены
функции подготовки данных, выбора данных и обновления результата. Таким
образом, был создан практически новый алгоритм для адаптации к модели
MapReduce.
Еще одной проблемой использования модели MapReduce для алгоритмов
анализа является необходимость наличия свойства списочного гомоморфизма.
Можно выделить следующие недостатки модели MapReduce,
ограничивающие ее применение для распараллеливания алгоритмов анализа
данных [25]:
не все функции анализа данных обладают свойствами списочного
гомоморфизма;
для реализации модели, необходима явная реструктуризация алгоритма и
его разделение на функции map и reduce;
алгоритм может быть разделен для параллельного выполнения только в
одном месте;
предполагает распараллеливание только по данным.
В общем случае алгоритмы анализа данных часто не ограничивается одним
проходом по набору данных. Кроме того, они имеют циклы не только по набору
данных, но и по другим наборам, в том числе строящимся в процессе выполнения
(набору правил, кластерам, классам, частым наборам и т.п.). Это позволяет
эффективно распараллеливать их не только по набору данных.
Следствием сложности адаптации алгоритмов является небольшое
количество алгоритмов анализа данных, реализованных в описанных библиотеках
(Таблица 1.1).
33
1.2.2 Анализ Больших данных на облачной платформе
Учитывая бурный рост технологий распределенных вычислений и облачных
вычислительных сред, естественным является интеграция технологий анализа
данных, распределенных и облачных вычислений.
В настоящее время существуют системы, которые можно было бы отнести к
облачным технологиям анализа данных. Одним из первых в этой области начал
работать Китайский мобильный институт. В 2007 в нем начались исследования и
разработки в области облачных вычислений. В 2009 году он официально
анонсировал платформу для облачных вычислений BigCloud, включающую в себя
инструменты для параллельного выполнения алгоритмов Data Mining Big Cloud-
Parallel Data Mining (BC-PDM) [178].
BC-PDM представляет собой SaaS платформу, построенную на базе Apache
Hadoop. Пользователи могут загружать данные в хранилище (размещенное в
облаке) из разных источников и применять к ним различные приложения по
управлению данными, анализу данных и бизнес приложения. В состав
приложений анализа входят параллельные приложения выполняющие: ETL
обработку, анализ социальных сетей, анализ текстов (Text Mining), анализ данных
(Data Mining), статистический анализ.
Azure Machine Learning (Azure ML) [177] - SaaS облачный сервис от
компании Microsoft Inc. Он был запущен в Феврале 2015 года. Azure ML
обеспечивает платные сервисы, которые позволяют пользователям выполнять
полный цикл анализа: сбор данных, подготовку к анализу, настройку, анализ
данных и оценку результатов. Сервис ориентирован на пользователей со
знаниями в области анализа данных.
Процесс анализа описывается в виде графа работ (workflow). Каждый узел
графа является модулем, выполняющим определенную подзадачу процесса
анализа (чтение, преобразование, анализ и т.п.). Каждый модуль может
34
выполняться на отдельном узле, т.о. распараллеливание в этом случае
выполняется только на уровне процесса анализа.
Azure ML может выполнять анализ данных, которые заранее размещены в
облаке. Для этого оно содержит различные средства для импорта данных. Для
анализа пользователь может использовать только заранее заданные алгоритмы:
classification (Boosted Decision Trees, Random Forests, Logistic Regression, SVM,
Averaged Perceptron, neural networks), regression (Linear Regression, Boosted
Decision Trees, neural networks), anomaly detection (SVM, PCA) and clustering (K-
Means). Additional algorithms are available for purchase at the Machine Learning
Marketplace.
В апреле 2015 года компания Amazon выпустила на рынок свое решение для
облачного анализа данных Amazon Machine Learning (Amazon ML). Оно
представляет собой сервис для обучения предсказательных моделей [179]. Сервис
обеспечивает все необходимые стадии анализа: подготовку данных, построение
модели, настройку, оценку модели и др. Для использования Amazon ML
пользователю не требуются специальные знаний в области анализа.
Amazon ML решает только задачи классификации и регрессии. Он включает
в себя алгоритмы: binary classification, multiclass classification, and regression.
Новые алгоритмы не могут быть добавлены пользователем самостоятельно. Как и
в случае с Azure ML, сервис Amazon ML позволяет анализировать данные,
размещенные только внутри облака. Для масштабирования вычислений
используется Apache Hadoop.
Компания Google в марте 2016 года представила свою платформу Cloud
Machine Learning (Cloud ML) [180], которая используется для анализа
фотографий, переводов и почты. Она использует алгоритмы машинного обучения
- нейронные сети. Данный сервис Google обеспечивает REST API для
распознавания образов, речи, языковых переводов и т.п. Сервис также не
позволяет расширять состав алгоритмов анализа.
35
В начале 2016 года компания IBM выпустила интеллектуальный
аналитический сервис Watson Analytics [181]. Он решает высокоуровневые
аналитические задачи, взаимодействуя с пользователями посредством запросов на
естественном языке. Watson Analytics анализирует данные, размещенные в
облаке. Пользователи могут использовать только те алгоритмы и методы, которые
уже заложены в сервис.
Основными недостатками описанных систем являются (Таблица 1.2) [182]:
1) необходимость хранения анализируемых данных внутри облака, что в
свою очередь имеет ряд недостатков:
требует дополнительных аппаратных средств для хранения данных;
для обработки актуальных данных нужно или всегда хранить их во
внутреннем хранилище или решать задачу их синхронизации с
источником информации;
при загрузке информации производится преобразование во внутренние
форматы, что может привести к искажению информации и/или вызывать
ошибку при загрузке;
обеспечение конфиденциальности хранящейся во внутреннем хранилище
информации ложится на провайдера сервиса, что не всегда может
удовлетворить владельца информации;
не использует преимуществ работы с общей памятью.
2) привязка только к одной технологии выполнения распределенных
вычислений (в основном Map Reduce и ее реализация на Apache Hadoop), каждая
из которых имеет свои недостатки и может эффективно применяться только при
определенных условиях;
3) решение конечных бизнес-задач, а не отдельных задач анализа
данных, что ограничивает возможности по применению.
36
Таблица 1.2 – Сравнение систем распределенного анализа
Характеристики BC-PDM Azure ML Amazon ML GoogleCloud
ML
Watson
Analytics
Облачная модель SaaS SaaS SaaS SaaS SaaS
Интерфейс
пользователя Web Web Web API Web
Пользовательский
уровень
Разработчик Аналитик Аналитик Разработчик Аналитик
API Нет REST REST REST REST
Масштабируемость
вычислений
Да Да Да Да Да
Место хранения
данных
Внутри
облака
Внутри
облака
Внутри
облака
Внутри облака Внутри
облака
Платформа
распределенных
вычислений
Apache
Hadoop
Vowpal
Wabbit
(Hadoop)
Apache
Hadoop
Apache
Hadoop
-
Полный цикл
анализа
Да Да Да Да Нет
Задачи анализа Classification,
Clustering,
Association
Classification,
Anomaly
detection,
Regression,
Clustering
Classification,
Regression
Classification,
Regression
Classificat,
Regression
Добавление новых
алгоритмов
Нет Из Machine
Learning
Marketplace
Нет Нет Нет
Использование Нет Платный Платный Платный Платный
Из приведенного обзора в области интеграции технологии анализа данных и
облачных технологий следует высокая актуальность данного направления и
наличие различных проблем.
1.2.3 Анализ данных в системах Интернета вещей
В последнее время бурно развивается технология Интернета вещей. Объем
информации, получаемый от различных устройств: датчиков, видеокамер,
мобильных устройств и др., постоянно растет. Период с 2008 по 2009 год
аналитики корпорации Cisco считают «настоящим рождением Интернета вещей»,
так как, по их оценкам, именно в этом промежутке количество устройств,
37
подключённых к глобальной сети, превысило численность населения Земли [183],
тем самым «Интернет людей» стал «Интернетом вещей». По информации3
издания Gartner к 2020 году к Интернету будет подключено около 26 миллиардов
устройств.
Информация, поступающая от таких устройств, также требует анализа.
Большинство систем анализа для IoT строятся на основе многоуровневой
архитектуры (Рисунок 1.5). Как правило, выделяют следующие уровни [184, 185]:
уровень устройств – нижний уровень, на котором размещаются все
подключаемые устройства;
прикладной уровень – верхний уровень, на котором размешаются
прикладные (в том числе аналитические) сервисы;
сетевой уровень – средний уровень, отвечающий за взаимодействие уровня
устройств и прикладного уровня.
Верхний уровень предоставляет централизованные сервисы для решения
различных аналитических задач. IoT системы с централизованным анализом
данных могут быть построены двумя способами:
реализацией собственных сервисов на базе существующих
масштабируемых систем анализа [184] (Рисунок 1.5 а);
интеграцией с существующими облачными сервисами хранения и анализа,
как предлагается в работе [186] (Рисунок 1.5 б).
Для реализации первого способа построения централизованной системы IoT
могут быть использованы системы масштабируемого анализа данных: Apache
Spark Machine Learning Library (MLlib) и Apache Mahout. Для реализации второго
способа, могут быть использованы облачные сервисы анализа описанные выше.
3 "Gartner Says the Internet of Things Installed Base Will Grow to 26 Billion Units By 2020". Gartner. 12 December 2013. Retrieved 2 January 2014.
38
Аналитические
сервисы
Уровень
обработки
данных
Уровень
сбора
данных
Уровень
устройств
Iot система
Iot система
Внешнее облако
а) б)
Рисунок 1.5 – Виды архитектур IoT систем
(а) с собственным облаком, б) с внешним облаком).
Недостатками централизованного подхода является необходимость
пересылки всех данных от источников информации к месту их анализа. Это
увеличивает сетевой трафик и время анализа. При необходимости анализа
больших объемов данных и в режиме реального времени данный недостаток
является существенным ограничением.
Альтернативой централизованным системам являются реализация
популярной в последнее время технологии туманных вычислений (Fog computing)
[1]. Она предполагают наличие вычислительных узлов (Fog узлы) на уровне
устройств и промежуточном уровне IoT-систем (Рисунок 1.6), на которых
выполняется анализ данных без их пересылки в централизованное хранилище.
39
Аналитические
сервисы
Уровень
обработки
Уровень сбора
данных
Уровень
устройств
IoT система
Fog узлы
Рисунок 1.6 – IoT- система с туманными вычислениями.
Популярность подобных архитектур обусловлена отсутствием в них
недостатков обозначенных выше. Туманные вычисления полностью решают или
снижают влияние ряда проблем в распределенных системах:
высокая задержка в сети;
масштабирование источников информации;
трудности, связанные с подвижностью конечных точек;
высокая стоимость полосы пропускания;
территориальная распределенность систем.
Несмотря на достоинства и популярность идеи туманных вычислений,
готовые решения для ее реализации в настоящее время отсутствуют. Это
объясняется как недостаточной проработкой данной концепции, так и высоким
уровнем абстракции ее представления.
1.2.4 Анализ распределенных данных
Необходимость анализа распределенных данных возникает не только в
системах Интернета вещей, но и в других задачах, когда источники данных или
территориально уделены друг от друга или принадлежат разным владельцам. В
таких системах анализу подвергаются распределенные данные. При этом, для
40
выполнения вычислений могут использоваться как узлы, хранящие данные, так и
узлы без данных.
Данные в распределенной среде могут храниться по-разному [187, 188, 189]:
централизованно – все данные хранятся на одном узле;
распределено – данные хранятся на разных узлах, но связаны между
собой, при этом распределение может быть двух видов (Рисунок 1.7):
o горизонтальным;
o вертикальным.
При вертикальном распределении атрибуты одной и той же сущности
хранятся на разных узлах. Типичным примером является хранение информации
об одном человеке в разных инстанциях (в налоговой инспекции о доходах и
расходах, в таможенных органах о перевозимых грузах, в медицинских органах об
истории болезней и т. п.) [190].
При горизонтальном распределении данные о разных сущностях хранятся в
базах, имеющих одинаковую структуру (т. е. набор атрибутов в каждой базе
одинаков). Примером такого хранилища являются базы данных супермаркетов,
находящихся в разных регионах и имеющих собственные хранилища данных.
[190]
Рисунок 1.7 – Виды распределения данных.
41
Описанные выше алгоритмы анализа данных и системы их исполняющие
предназначены для работы только с централизованным хранением данных. В этом
случае для распределенных источников требуется предварительный сбор данных
в едином хранилище, что приводит к следующим проблемам:
затрачивается время на передачу информации, что может быть критично
при ее обработке, например, в режиме реального времени;
увеличивается сетевой трафик, что снижает возможности использования
каналов связи с низкой пропускной способностью (спутниковых каналов
связи, беспроводных каналов и т.п.);
требуется передача информации, в том числе конфиденциальной, по
открытым каналам передачи данных;
повышается ценность собранной в одном месте информации, что требует
повышенных мер обеспечения ее безопасности и надежности.
Избежать указанных недостатков позволяет реализация технологии
туманных вычислений, предполагающая выполнение анализа непосредственно на
источнике информации или близко к нему. Однако для этого требуется
построение параллельных алгоритмов анализа данных с учетом размещения
источников информации для выполнения функций алгоритмов в распределенной
среде.
1.3 Методы построения параллельных алгоритмов
1.3.1 Этапы построения параллельных алгоритмов
Параллельный алгоритм – алгоритм, который может быть реализован по
частям на множестве различных вычислительных устройств с последующим
объединением полученных результатов и получением корректного результата
[191].
42
При разработке последовательных алгоритмов принято считать [192], что
выполняется пять этапов:
1) постановка задачи;
2) создание математической модели;
3) разработка алгоритма решения в рамках созданной математической
модели;
4) написание программы, реализующей разработанный алгоритм;
5) выполнение программы.
При построении параллельных алгоритмов в этой последовательности
появляются дополнительные этапы [192]:
1) постановка задачи;
2) создание математической модели;
3) разработка алгоритма;
4) декомпозиция алгоритма (decomposition);
5) определение независимых блоков;
6) выбор программной модели;
7) реализация параллельного алгоритма;
8) размещение алгоритма на исполнителях (mapping);
9) выполнение программы.
Добавляемые шаги являются достаточно трудоемкими для разработки
параллельных алгоритмов. Для каждого из них проводятся отдельные
исследования и существуют различные методы их выполнения. Рассмотрим
каждый из шагов более подробно.
1.3.2 Декомпозиция алгоритма
Декомпозиция алгоритма делит алгоритм на блоки, состоящие из
подмножеств операций, которые должны быть выполнены совместно и не могут
быть разделены. Некоторые из таких блоков могут быть выполнены в
43
произвольном порядке, следовательно, и параллельно на разных исполнителях.
Такая декомпозиция возможна не всегда. Существуют алгоритмы, которые
принципиально не допускают при своей реализации участия нескольких
исполнителей.
Принципиально различают два вида декомпозиции алгоритмов: по данным
и по задачам [192, 193, 194]. Существует большое число методов декомпозиции
алгоритмов [195]. Основными из них являются:
разделяй и властвуй (Divide-and-Conquer) [196, 197, 198, 199, 200, 202] –
предполагает разделение общей проблемы на более мелкие под проблемы с
последующим их решением и объединением решений в решение общей
проблемы. При этом в зависимости от разделения проблемы, выделяют
следующие разновидности данного метода:
o рекурсивный (recursive) – проблема разделяется рекурсивно до
неделимой (пример - рекурсивная сортировка массива);
o нерекурсивный (non-recursive) – проблема делиться на n частей (n –
число процессоров) (пример – сортировка массива по отдельным
частям);
o сужением (contraction) [201] – проблема сводиться к более мелкой
проблеме (возможно рекурсивно) и ее решение обобщается на исходную
проблему (пример – вычисление префиксной суммы элементов массива).
случайное деление (Randomization) [202] – предполагает случайное разделение
работы между параллельными процессами, как правило, предполагает
случайное разделение данных между процессами, имеет следующие
разновидности:
o случайный отбор (Sampling) – в наборы, которые обрабатываются
параллельно, случайным образом отбираются элементы исходного
набора;
44
o нарушения симметрии (Symmetry breaking) – случайным образом
выбирается элемент из набора одинаковых элементов для разделения на
поднаборы (например, выбор вершины в графе для его разделения, если
все вершины одинаковы);
o балансировка нагрузки (Load balancing) – случайным образом
назначаются элементы общего набора данных к разным поднаборам
(группам), приблизительно одинакового размера;
параллельные указатели (Parallel Pointer Manipulations) [202] – применяются для
работы с наборами данных, имеющими списочную и древовидную структуру,
и декомпозируют задачу, используя несколько указателей на разные элементы
набора. Различают следующие варианты данного метода:
o прыгающий указатель (Pointer Jumping) [196, 203, 204] – для каждой
подзадачи указатель устанавливается на свой элемент и перепрыгивает
на другие;
o сужения графа (GraphContraction) – набор элементов уменьшается до
некоторой необходимой (в зависимости от задачи) области в которой
решается задача и др.;
Существуют и другие методы декомпозиции, но в целом все они зависят от
решаемой задачи и обрабатываемых данных.
1.3.3 Анализ зависимостей между блоками
После декомпозиции алгоритма на отдельные блоки, необходимо
определить какие из них могут выполняться независимо друг от друга [205, 206,
207, 208, 209]. Выделяют следующие виды зависимостей [210]:
зависимость по управлению, которая определяет порядок команд по
отношению к команде условного перехода, т.е. команды, не являющиеся
командами перехода, выполняются только когда выполняются
соответствующие им условия
45
зависимость по данным, которая определяет использование одних и тех
же данных разными командами; различают следующие виды таких
зависимостей [211, 212]:
зависимость по входу; возникает, когда одни и те же данные
поступают на вход нескольким командам;
потоковая зависимость; возникает, когда данные являющиеся
выходом одной команды поступают на вход следующей команды;
антизависимость; возникает, когда данные являющиеся выходом
одной команды поступают на вход предыдущей команды;
зависимость по выходу; возникает, когда выходами нескольких
команд являются одни и те же данные.
Имеются два ограничения, связанные с зависимостями по управлению:
зависящая по управлению команда, не может быть в результате
перемещения поставлена перед командой условного перехода, стать
независимой от него;
команда, не зависимая по управлению от команды условного перехода, не
может быть поставлена после команды условного перехода так, что её
выполнение станет управляться этим условным переходом.
В части зависимости по данным имеются ограничения сформулированные
Бернстайном [213]:
отсутствие антизависимости;
отсутствие потоковой зависимости;
отсутствие зависимости по выходу.
Они являются достаточными, но не необходимыми.
1.3.4 Выбор модели параллельного выполнения
Выбор модели параллельного выполнения алгоритма определяется его
блоками, которые будут выполняться параллельно, схемами взаимодействия
46
между ними, а также средой выполнения. Выделяют следующие модели для
параллельного выполнения [192]:
модель передачи сообщений [214, 215, 216]. Предполагает, что
работающее приложение состоит из набора процессов с различными
адресными пространствами, каждый из которых функционирует на своем
исполнителе. Процессы обмениваются данными с помощью передачи
сообщений через явные операции send/receive. Преимущество модели
заключается в том, что программист осуществляет полный контроль над
решением задачи, недостаток — в сложности программирования.
модель разделяемой памяти [205, 217, 218, 219]. Предполагает, что
приложение состоит из набора потоков исполнения, использующих
разделяемые переменные и примитивы синхронизации.
модель разделенных данных [205, 217, 220]. Предполагает, что
приложение состоит из наборов процессов или потоков, каждый из
которых работает со своим набором данных, обмена информацией при
работе нет. Такая модель применима к ограниченному классу задач.
Первая модель обладает хорошей переносимостью, дает полный контроль
над выполнением, но очень трудоемка. Вторая модель легка для
программирования, но не дает возможности полностью контролировать решение
задачи. Третья модель применима при декомпозиции по данным и в случае если
результаты обработки отдельных частей данных могут быть объединены (в
случаях, если использована декомпозиция по данным: разделяй и властвуй).
1.3.5 Реализация параллельного алгоритма
На этапе программирования необходимо осуществить выбор языка
программирования и средств выполнения алгоритма. Языки программирования с
точки зрения поддержки параллельных вычислений [221, 222, 223] можно
разделить на следующие классы:
47
языки без поддержки параллельных вычислений (C/C++[224, 225],
Паскаль [226, 227], Фортран [228, 229] и др.). Такие языки практически
не могут использоваться для реализации параллельных алгоритмов или
требуют дополнительных программных средств, реализующих
параллельные вычисления;
языки, имеющие поддержку параллельнх вычислений на уровне
синтаксиса (Ада [230], High Performance Fortran [231] и др.) и директив
компилятора (OpenMP [232] и др.) позволяющие распараллеливать
только отдельные структуры, например циклы [233, 234, 235, 236];
языки, имеющие поддержку параллельных вычислений на уровне
программных расширений (Java [237, 238], С# [239, 240] и другие):
библиотек, классов и др.;
языки, структурно поддерживающие параллелизм (функциональные
языки программирования Lisp [241, 242], Haskell [243, 244] и др.) и
предполагающие построение программ из структур, которые могут быть
выполнены параллельно.
Первые три группы языков относятся к императивным языкам
программирования. Они ориентированы на работу в соответствии с моделью
машины Тьюринга [245, 246]. Ее основной идеей является изменение состояния
машины Тьюринга при выполнении каждой инструкции программы. Таким
образом, программы, написанные на императивных языках программирования,
предполагают наличие состояния программы и его изменение в процессе
выполнения. Их основной проблемой при параллельном выполнении является
необходимость обеспечения одновременного доступа к состоянию программы из
параллельных ветвей. Это порождает проблемы синхронизации доступа,
блокировки, гонки и др. Их решение достаточно трудоемкий процесс, как при
разработке, так и при отладке.
48
В отличие от них функциональные языки основаны на теории λ-исчислений
[247, 248] предложенной Алонсо Черчем одновременно с Тьюрингом. Однако в
отличие от машины Тьюринга, в теории λ-исчислений программа представляется
в виде функционального выражения, в котором функции вызываются друг из
друга. Вся информация необходимая для передачи между функциями передается
через их аргументы и возвращаемые значения. Таким образом, программы,
написанные на функциональных языках, не используют внутреннее состояние.
Функции, из которых строится функциональная программа, являются
чистыми. Следовательно, такие функции могут выполняться параллельно без
необходимости дополнительных мер предотвращающих блокировки, гонки и
другие проблемы параллельного выполнения. Теоретически функциональные
выражения, построенные из таких функций, могут быть распараллелены
автоматически.
1.3.6 Размещение алгоритма на исполнителях
На последнем шаге, при запуске программы в вычислительной среде
необходимо сопоставить параллельным блокам, появившимся на предыдущих
этапах разработки параллельных алгоритмов, реальные физические устройства. В
зависимости от выбранной модели программирования это может осуществляться
как лицом, проводящим вычислительный эксперимент, так и операционной
системой.
Кроме информационных связей на размещение влияют и трудоемкость
выполнения каждого блока. Особенно это актуально при выполнении в
гетерогенной среде. В этом случае на более производительные исполнители
должны назначаться более трудоемкие блоки. Здесь также уместно говорить о
статической и динамической схеме распределения трудоемкости.
По времени способы назначения разделяются на две категории [249, 250]:
49
статические— распределение выполняется на этапе написания,
компиляции или старта программы (до реального начала вычислений)
[251, 252, 253];
динамические [254, 255, 256, 257] — распределение осуществляется в
процессе исполнения.
Статический способ более прост и при статических схемах взаимодействия
и распределения трудоемкости между блоками является предпочтительным. В
случае динамических схем, возможно применение динамической балансировки,
однако необходимо помнить, что это требует дополнительных затрат.
Процесс распараллеливания алгоритмов тесно связан с исполнителями, на
которых будет выполняться параллельный алгоритм. Так, при выборе модели
программирования с передачей сообщений, не удастся воспользоваться в качестве
исполнителей потоками, не имеющими средств передачи сообщения. В связи с
этим важным фактором при выборе способа и формы параллельного выполнения
алгоритма является среда выполнения.
Традиционно выделяют среды [97, 98]:
параллельного выполнения – с тесно связанными исполнителями, в том
числи и через общую память;
распределенного выполнения – с исполнителями расположенными в
разных адресных пространствах и, как правило, взаимодействующих
через локальную или глобальную сеть.
В настоящее время широко используются различные парадигмы
выполнения параллельных и распределенных вычислений. В зависимости от их
использования, в качестве исполнителей могут выступать различные средства
[258]:
при многопоточном выполнении [259, 260] исполнителями могут
выступать потоки (нити);
50
при использовании сервисно-ориентированной архитектуры [261, 262] -
сервисы;
при реализации модели акторов [263, 264, 265] - акторы;
при выполнении на основе модели MapReduce [152, 153] - рабочие узлы
(jobs);
при мультиагентном выполнении [266, 267] - агенты.
1.3.7 Распараллеливание алгоритмов решения ресурсоемких задач
На практике, для наиболее ресурсоемких научных задач проведены (и
проводятся) отдельные исследования, в рамках которых предлагаются различные
параллельные алгоритмы [193, 194]:
для матричных вычислений [268, 269, 270, 271];
для решение линейных уравнений [272, 273];
для сортировки массивов данных [274, 275];
для решения задач на графах [276, 277, 278, 279, 280, 281, 282];
для решение дифференциальных уравнений [283, 284, 285];
вычислительной геометрии [286, 287, 288, 289, 290, 292, 293, 294, 295,
296].
Приведенный перечень задач и алгоритмов для их решений не является
полным, однако на основе его можно выделить два основных подхода к созданию
параллельных алгоритмов:
распараллеливание ранее разработанного и хорошо проверенного
последовательного алгоритма;
создание новых параллельных алгоритмов под определенные модели
программирования (или существенная модификация последовательного
алгоритма).
Первый подход более универсален и позволяет использовать накопленный
опыт в решении задач на системах с одним исполнителем. Недостатками такого
51
подхода являются, проблемы распараллеливания некоторых алгоритмов в связи с
отсутствием в них внутреннего параллелизма.
Второй подход, как правило, использует в качестве основы существующий
последовательный алгоритм, но при этом вносит в него существенные
модификации (по сути, создавая новый алгоритм) для возможности
параллельного выполнения. Такой подход является наиболее трудоемким и
позволяет создать алгоритм оптимальный только для определенных условий.
В [194] отмечается что “на текущий момент надёжным вариантом создания
параллельных программ является подходящая реструктуризация проверенных
временем последовательных программ и математических описаний”.
1.3.8 Параллельные алгоритмы анализа данных
В настоящее время в области параллельного анализа данных проводится
большое число исследований. Выделяют два направления [297]:
параллельный анализ данных предназначеный для работы с сильно
связанными системами с общей (разделяемой) или распределенной памятью
и с кластерами (группами) рабочих станций с разделяемой памятью и
быстрым соединением между ними;
распределенный анализ данных предназначеный для работы со
слабосвязанными системами, состоящими из узлов, объединенных в
локальную сеть или территориально распределенными узлами глобальной
сети.
При этом выделяют три основных стратегии построения параллельных
алгоритмов анализа данных [190, 298]:
1) независимый параллелизм, где каждый процессор имеет доступ ко всем
наборам данных, но не взаимодействует с другоми;
2) параллелизм задач, где на каждом процессоре выполняется разный
алгоритм над разделенными или над целыми наборами данных;
52
3) параллелизм типа SPMD (Single Program, Multiple Data – единственная
программа и множество потоков данных), где в нескольких процессорах
выполняется один (одинаковый) алгоритм над разными подмножествами
и затем обмениваются частичными результатами.
Независимый параллелизм используется, когда процессы выполняются
параллельно независимым способом, обычно каждый процесс имеет доступ ко
всем наборам данных и не общается или не синхронизируется с другими
процессами. Согласно параллелизму задач каждый процесс выполняет различные
операции на (различные разделы) набора данных.
Наконец, в параллелизме SPMD набор процессов выполняет параллельно
один алгоритм на разных разделах набора данных, и процессы сотрудничают
между собой, чтобы обмениваться частичными результатами. Эти три стратегии
не обязательно являются альтернативами для параллельного выполнения
алгоритмов анализа данных. Они могут быть объединены, чтобы улучшить
производительность и точность результатов. При этом могут использоваться
различные стратегии разделения данных:
последовательное разделение: отдельные разделы определены без
перекрытия между ними;
разбиение на основе покрытия: некоторые данные могут быть
тиражированы в различные разделы;
разбиение на основе диапазонного запроса: разделы определяются на
основе некоторых запросов, которые выбирают данные по значениям
атрибутов.
В настоящее время разработано большое число параллельных алгоритмов
анализа данных. Примерами являются алгоритмы:
классификации (Рисунок 1.8) [299]: Supervised Learning In Quest (SLIQ)
[300], Scalable PaRallelizatable INndition of decision Trees (SPRINT) [301],
Parallel Decision Tree (PDT) [302], SUBTREE [303], ScalParC (Scalable
53
Parallel Classifier) [304], DP [305], MWK (The Moving-Window-K Algorithm)
[307], ParC4.5 [308], MIL (Multiple Induction Learning) [309], DRL
(Distributed Rule Learner) [310], CRGP [311], Arbiter [312], Combiner [313],
HybStr [314] и др.
кластеризации (Рисунок 1.9) [306]: SQ [314], CLUSTER[315], Pkmeans [316],
MAFIA [317], DCCP2P [318], P-CLUSTER [319], Collaborative [320], DIB
[321], ColHyr [316], CoFD [322], PADMA [323], RACHET [324], CHC [316],
CPCA [325], Parallel k-means [326], Parallel k-harmonic [327], DBDC [328],
PDBSCAN [329], KDEC [330, 331], Strehl Ensemble [333], Fred Ensemble
[334], Jouve Ensemble [335], Merugu Privacy [336], Vaidya Privacy [337],
HP2PC [338], P2P K-means [339], и др.
поиска ассоциативных правил (Рисунок 1.10) [332]: ParEclat, ParMaxEclat,
ParClique и ParMaxClique [340], Pattern-Growth [341], Common Candidate
Partitioned Database (CCPD) [342], Partitioned Candidate Common Database
(PCCD) [342], Asynchronous Parallel Mining (APM) [343], Hash Partitioned
Apriori (HPA) [344], Simply Partitioned Apriori (SPA) [344], Partitioned
Parallel Association Rules (PPAR) [345], PEAR [346], PDM [347], NPA [344],
FDM [348], CD [349], DD [348], DMA [350], IDD, HD (Hybrid Distribution)
[351], SH (Skew Handling) [352] и др.
При этом основные усилия направлены на адаптацию алгоритмов
выполнения алгоритмов только в строго заданных условиях. Изменение условий
приводит к необходимости переработки алгоритма и, по сути, созданию нового
алгоритма.
54
Рисунок 1.8 – Параллельные алгоритмы классификации.
55
Рисунок 1.9 – Параллельные алгоритмы кластеризации.
56
Рисунок 1.10 – Параллельные алгоритмы ассоциирования.
57
Выводы
В данной главе рассмотрены существующие подходы и методы к
построению параллельных алгоритмов, включая алгоритмы анализа данных.
На основе проведенного анализа можно сделать следующие выводы:
1) алгоритмы анализа данных обладают рядом общих свойств:
неизменяемость анализируемых данных;
формирование модели знаний, размер которой значительно меньше
объема анализируемых данных;
необходимость одного или нескольких проходов как по объектам,
описываемых данными, так и по их характеристикам;
извлечение из данных закономерностей сложными функциями,
которые не всегда обладают свойством списочного гомоморфизма.
2) для анализа данных в таких актуальных направлениях как, Большие
данные и Интернет вещей, используют существующие системы
распределенного анализа данных, которые реализуют модель MapReduce
и работают с данными, предварительно собранными в едином хранилище;
3) модель распределенных вычислений MapReduce имеет ограничения при
распараллеливании алгоритмов из-за следующих недостатков:
применяется к функциям со свойствами списочного гомоморфизма;
требуется явная реструктуризация алгоритма для выделения
функций map и reduce;
реализует распараллеливание только по данным;
не использует преимуществ работы с общей памятью;
4) предварительный сбор анализируемых данных в единое хранилище
порождает следующие проблемы:
увеличивается время на передачу информации;
58
увеличивается сетевой трафик, что снижает возможности
использования каналов связи с низкой пропускной способностью;
требуется передача информации, в том числе конфиденциальной, по
открытым каналам передачи данных;
повышается ценность собранной в одном месте информации, что
требует повышенных мер обеспечения ее безопасности и
надежности;
5) реализация технологии туманных вычислений, предполагающая
выполнение анализа непосредственно на источнике информации
позволяет избежать указанных недостатков, однако требует построения
параллельных алгоритмов анализа данных с учетом размещения
источников информации для выполнения функций алгоритмов на узлах
распределенной среды;
6) построение параллельных алгоритмов требует от разработчика реализации
дополнительных трудоемких этапов: декомпозиция алгоритма
(decomposition); определение независимых блоков; выбор программной
модели; реализация параллельного алгоритма; размещение алгоритма на
исполнителях (mapping); при этом для каждого из этапов существуют
различные методы;
7) для каждого типа сложных вычислительных задач разработаны
собственные параллельные алгоритмы их решения, включая алгоритмы
анализа данных.
Таким образом, можно сделать вывод, что в настоящее время
отсутствуют модели и методы для построения параллельных алгоритмов
анализа распределенных данных в соответствии с заданными условиями.
59
2. Формальное представление алгоритма анализа данных
Исходной информацией для алгоритмов анализа данных являются
наборы анализируемых данных. Результатом является модель знаний,
строящаяся алгоритмом и содержащая извлекаемые из данных
закономерности.
Для параллельного выполнения алгоритм должен быть декомпозирован
на блоки, которые могут быть выполнены параллельно. Для алгоритмов
анализа данных такими блоками являются функции, выполняющие
обработку как исходных данных, так и модели знаний, строящейся
алгоритмом.
Параллельное выполнение таких функций означает возможность их
выполнения в произвольном порядке. Такой возможностью обладают
«чистые» функции, используемые в функциональных языках
программирования. «Чистые» функции, обладают следующими свойствами
[353, 354]:
детерминированность, т.е. функция возвращает один и тот же
результат для одинакового набора аргументов;
отсутствие побочных эффектов, т.е. функция не изменяет и не
использует глобальных переменных.
Данные свойства делают функции потокобезопасными и они могут
быть выполнены параллельно. Для дальнейшего анализа свойств алгоритмов
анализа данных и возможности их параллельного выполнения:
формализуем представление анализируемых данных и модели знаний,
строящейся алгоритмами анализа данных;
представим алгоритм анализа данных в виде функционального
выражения, функции которого обладают свойствами «чистых»
функций.
60
2.1 Формальное описание набора анализируемых данных
2.1.1 Матрица данных
Анализ данных выполняется над множеством однородных
анализируемых объектов X (такими объектами являются люди, события,
сделки и т.п.). Каждый из объектов характеризуется множеством A
состоящим из p атрибутов (возраст, пол, вес и т.п.). Атрибут – это отдельное
измеряемое свойство объекта [356]. Атрибут ak можно представить в виде
функции, которая отображает множество объектов X во множество
допустимых для данного атрибута значений Def(ak):
ak : X → Def(ak).
В зависимости от множества значений Def(ak) атрибуты делятся на
следующие типы:
номинальный атрибут, имеющий конечное множество значений:
Def(ak) = Vk = {vk.1, …, vk.q, …, vk.u};
численный атрибут — множество действительных чисел: Def(ak) = R.
Таким образом, каждый объект xj X описывается p-мерным вектором
значений атрибутов [27]:
(a1(xj), a2(xj), …, ak(xj), …, ap(xj)), где
ak(xj) Def(ak) k = 1..p, j = 1..z.
Весь набор данных d D представляют в виде матрицы данных [27]:
d = (ak(xj)),
1, 1
z p
j k =
)(xa...)(xa...)(xa
.........
)(xa...)(xa...)(xa
.........
)(xa...)(xa...)(xa
zpzkz.1
jpjkj1
1p1k11
. (2.1)
61
Каждая строка матрицы данных называется вектором, каждый столбец
– атрибутом.
2.1.2 Описание распределенных данных
При распределенном хранении данные, разделенные между узлами-
источниками, представляют собой части матрицы данных:
d = d1d2…dh…dw, где
dh -подматрица-данных, размещаемая на узле h-м источнике.
Соответственно каждая подматрица данных dh характеризуется своим
набором атрибутов Ah и набором векторов Xh. Таким образом, возможны
следующие типы распределения матрицы данных:
с горизонтальным распределением данных (Рисунок 2.1 (а)):
d1 = (xj.k),
1, 1
y p
j k , d2 = (xj.k),
1, 1
x p
j y k , …, dw = (xj.k),
1, 1
z p
j x k , где
A1...Ah...Aw, A1...Ah...Aw= и A1...Ah...Aw=A
X1=...=Xh=...=Xw = X;
(2.2)
с вертикальным распределением данных (Рисунок 2.1 (б)):
d1 = (xj.k),
1, 1
z g
j k , d2 = (xj.k),
1, 1
z r
j k g , …, dw = (xj.k),
1, 1
z p
j k r , где
A1=...=Ah=...=Aw = A
X1...Xh...Xw, X1...Xh...Xw= и X1...Xh...Xw=X.
(2.3)
Примером вертикально распределенных данных является множество
датчиков, измеряющих различные характеристики одних и тех же объектов
(например, кинематические параметры, собираемые датчиками,
установленными вдоль трассы одних и тех же движущихся объектов).
Примером, горизонтально распределенных источников данных является
множество однотипных датчиков, измеряющих показатели разных объектов
(например, датчики неразрушающего контроля, установленные на разных
зданиях города).
62
(а)
(b)
Рисунок 2.1 – Распределение данных (а) горизонтальное, б) вертикальное).
2.2 Модель представления знаний
2.2.1 Формальное представление модели знаний
Модель знаний содержит закономерности, извлеченные из набора
данных в процессе их анализа. Такие закономерности описываются:
математическими функциями, классификационными правилами, центрами
кластеров и т.п. Формально элемент модели знаний (закономерность) можно
представить кортежем параметров разного типа
e : E ≡ <P, P, …, P>
e = <p1, p2, …, pd, …, pf>.
Интерпретация параметров зависит от типа элемента и его
использования. Например, классификационное правило вида:
if (ak = vk.q) then (at = vt.p)
может быть представлено кортежем:
Источник 1
d1=
1.1 1.g
z.1 z.g
x ... x
... ... ...
x ... x
Источник w
dw=
1.r+1 1.p
z.r+1 z.p
x ... x
... ... ...
x ... x
Источник 1
d1=
1.1 1.p
y.1 y.p
x ... x
... ... ...
x ... x
Источник w
dw=x+1.1 x+1.p
z.1 z.p
x ... x
... ... ...
x ... x
63
e = <ak, '=', vk.q, vt.p>, где
1-й параметр – независимый атрибут ak, который сравнивается с
эталонным значением vk.q;
2-й параметр – операция сравнения;
3-й параметр – сравниваемое эталонное значение vk.q;
4-й параметр – классифицируемое значение (значение зависимого
атрибута) vt.p.
Представим модель знаний в виде списка таких элементов:
m : [E]
m = [e1, e2, …, ev,…, ew]. (2.4)
В связи с тем, что построение элементов модели знаний любого уровня
определяется набором данных, то их число зависит от характеристик данного
набора. Вид зависимости определяется алгоритмом анализа. Таким образом,
можно определить верхнюю границу количества элементов в модели знаний:
νmax(m) = O(|X|, |A|, |Vk|).
В процессе выполнения алгоритма анализа данных над элементами
модели знаний выполняются операции: поиска (извлечения), вставки
(добавления), удаления [4]. В зависимости от алгоритма анализа, те или иные
операции могут выполняться чаще или реже, однако они будут выполняться
все. Допустив, что каждая операция в процессе работы алгоритма в среднем
выполняется приблизительно одинаковое количество раз, все элементы
модели знаний будут организованы в древовидную структуру, для которой
время выполнения всех операций имеет логарифмическую зависимость от
размера, т.е. O(log n). Элемент модели знаний расширим списком дочерних
элементов:
e : E = <[P], [E]>
e = <[p1, p2, …, pd, …, pf], [e1, e2,…, ev, …, ew]>. (2.5)
64
При этом элементы модели знаний, являющиеся дочерними
элементами одного и того же элемента, должны иметь одинаковый набор
свойств.
Таким образом, модель знаний представляет собой лес деревьев,
который может быть представлен как массив (индексированный список)
корневых элементов деревьев [2, 7]:
m = [e0, e1, e2, …, ev,…, ew]. (2.6)
Состав массива и порядок следования элементов в нем строго
определен типом модели и не меняется в процессе работы алгоритма анализа
данных. Например, стандарт PMML [58] версии 4.2 определяет 15 типов
моделей знаний. Кроме того, состав также зависит от особенностей
алгоритма анализа данных, который ее строит.
2.2.2 Метаданные набора данных
При применении построенной модели знаний к новым данным,
необходимо определять соответствует ли она этим данным. Для этого модель
знаний должна хранить информацию о данных (метаданные) по которым она
была построена. Так стандарт PMML для этих целей определяет тэг
MiningSchema, в котором перечисляются атрибуты, используемые в модели
знаний, и их характеристики.
Введем в состав модели знаний (2.6) элементы, описывающие
метаданные набора анализируемых данных. Они включают в себя описание
источника (например, uri к файлу), описание атрибутов и их значений:
e0 = <[curr, size, uri, login, password, ….], [e0.1, e0.2, …, e0.k, …, e0.p]>, где
e0.k – элемент модели знаний, содержащий информацию (номере, имени, роле
и его возможных значениях) о k-м атрибуте ak:
e0.k = <[pos, size, name, role ….], [vk.1, …, vk.q, …, vk.u]>.
65
Таким образом, модель знаний можно представить в виде леса
деревьев, первый из которых, является обязательным и содержит
информацию об анализируемых данных (Рисунок 2.2).
Рисунок 2.2 – Представление модели знаний в виде леса деревьев ее
элементов.
2.2.3 Индексация элементов модели знаний
Для индексации элементов модели знаний используем децимальную
нотацию индексов элементов леса деревьев [357]. Для хранения и обработки
индексов в децимальной нотации используем список целых чисел. Первое
число индекса будет обозначать корневой элемент соответствующего дерева
в модели знаний m[v] ≡ ev. Следующие числа в индексе будут обозначать
позиции элементов модели знаний среди узлов-потомков дерева. Например,
элемент модели знаний m[2, 1, 3] обозначает 3й элемент модели знаний
среди узлов-потоков 1-го узла среди узлов-потомков корневого узла 2-го
дерева модели знаний m. Все множество индексов модели знаний обозначим
символом I.
Для упрощения записи введем следующие соглашения:
определенный элемент модели знаний будем обозначать символом e с
индексом:
ev.1
vk.1
e1 ev
[p1, …, pd, …, pf]
ew
ev.g
g ev.h
g
ev.h.1 ev.h.g ev.h.b
g
e0.1
e0.k
{p1, …, pf}
e0
[curr, size, uri, …]
e0.p
vk.q vk.u
m
66
e2.1.3 ≡ m[2, 1, 3] ≡ ei при i = [2, 1, 3];
для идентификации определенного свойства элемента модели знаний
будем записывать его через точку после самого элемента:
m[2, 1, 3].pd ≡ e2.1.3.pd – свойство pd элемента модели знаний m[2, 1, 3];
для идентификации множества узлов-потомков определенного
элемента модели знаний будем записывать его через точку после
самого элемента:
m[2,1,3].L ≡ e2.1.3.L – множество узлов-потомков L элемента m[2,1,3];
для идентификации множества свойств определенного элемента
модели знаний будем записывать его через точку после самого
элемента:
m[2,1,3].P ≡ e2.1.3.P – множество свойств P элемента m[2,1,3].
2.2.4 Параметры элементов модели знаний
Множество параметров P любого элемента модели знаний можно
разделить на три подмножества:
P = PI ∪ P
C ∪ P
S, где
PI – ключевые параметры, идентифицирующие элемент модели
знаний уникальным образом;
PC – параметры элемента модели знаний, вычисляемые в процессе
анализа данных;
PS – параметры, описывающие текущее состояние элемента модели
знаний.
67
На основании идентифицирующих параметров, введем понятие
идентичности элементов модели знаний.
Определение. Идентичными элементами называются элементы модели
знаний, имеющие одинаковый состав параметров и идентифицирующие
параметры которых равны:
ep ↔ eq если для ∀ pe PIep.P, eq.P, ep.pe= eq.pe.
К параметрам состояния элемента модели знаний PS относятся
параметры, определяющие его текущее состояние. Например, для элементов
модели знаний, являющихся внутренним узлом дерева, обязательным
параметром является позиция дочернего узла (элемента модели знаний)
обрабатываемого в текущий момент времени – curr PS. Используя данный
параметр, введем понятие текущего элемента.
Определение. Текущим узлом-потомком элемента модели знаний является
узел-потомок, находящийся в позиции, определенной свойством curr
родительского элемента модели знаний:
ep.curr ≡ eq где p = [v,…, u], eq ∈ ep.L и q = [v,…, u, ep.curr].
Определение. Текущим элементом модели знаний является элемент,
находящийся в позиции, определенной свойством curr модели знаний:
m.curr ≡ eq где p = [v,…, u], eq∈ ep.L иq = [v,…, u, ep.curr].
В финальной модели знаний (полученной в результате выполнения
всего алгоритма анализа данных) параметры состояния не представляют
интереса и могут быть опущены.
68
Вычисляемые параметры элемента модели знаний PC описывают
содержательную часть, вычисляемую в процессе анализа данных. Примером
вычисляемого свойства может быть ошибка классификационного правила.
Данные параметры являются наиболее ценными в финальной модели знаний.
На основании вычисляемых параметров введем понятие равенства
элементов модели знаний.
Определение. Равными называются элементы модели знаний, вычисляемые
параметры PС которых равны:
ep == eq если для ∀ pe PС, ep.pe= ep.pe.
Каждый элемент модели знаний, имеющий не пустое множество узлов
– потомков L в составе свойств P должен иметь следующие свойства:
size – количество узлов потомков size = |L|;
curr – текущий обрабатываемый узел-потомок.
2.2.5 Пример модели знаний
Примером модели знаний может служить набор правил. В
спецификации PMML набор правил представлен моделью RuleSetModel
(Рисунок 2.3). Данная модель помимо множества атрибутов MiningSchema
включает в себя еще множество правил – RuleSet.
69
Рисунок 2.3 – PMML модель знаний RuleSetModel.
Таким образом, модель знаний для набора правил описывается в виде
следующего набора (для, упрощения описания рассмотрим только
необходимые элементы):
mR=<e0, e1> = {e0, <{curr, size, n}, {e1.1,..,e1.p,..,e1.g}>}, где
n PC– вычисляемый параметр элемента модели знаний e1,
определяющий количество векторов удовлетворяющих правилам
(корректных векторов) входящих в множество e1.L (данное свойство
соответствует атрибуту nbCorrect элемента RuleSet (Рисунок 2.3)).
e2.p – классификационное правило, простейший вид которого может
быть определен как набор параметров:
e1.p = <ak, vk.q, vt.p, n>, где
идентификационными параметрами PI являются:
ak – атрибут akA значение которого проверяется правилом
(соответствует атрибуту field элемента SimplePredicat (Рисунок 2.3));
70
vk.q – значение атрибута ak с которым сравнивается значение вектора
(соответствует атрибуту value элемента SimplePredicate (Рисунок 2.3));
vt.p – предсказываемое правилом значение зависимого атрибута
at,vt.pDef(at) (соответствует атрибуту score элемента SimpleRule
(Рисунок 2.3)).
Вычисляемым параметром PC является параметр n P
C, определяющий
количество корректных векторов, т.е. векторов для которых данное правило
является верным (соответствует атрибуту nbCorrect элемента SimpleRule
(Рисунок 2.3)):
n = |{xj : xjX, (ak(xj) = vk.qи at(xj) = vt.p)}|.
2.2.6 Операции над элементами модели знаний для параллельной обработки
Для обработки модели знаний параллельными функциями алгоритма,
необходимо в каждую функцию передать копию модели знаний. Кроме того,
после выполнения параллельных функций алгоритма, требуется объединение
полученных результатов в единую модель знаний. С учетом представления
модели знаний в виде множества деревьев, функции копирования и
объединения моделей знаний определим рекурсивно через функции
копирования и объединения для: параметров элементов модели знаний,
элементов модели знаний, поддеревьев и деревьев модели знаний. Введем
необходимые функции, основываясь на данных ранее определениях.
Определение. Клонированием параметров элемента модели знаний
называется функция cloneP, выполняемая над параметром элемента модели
знаний pd∈ ep.P и порождающая его эквивалентную копию p’d:
cloneP : P P
clonePpd = p’d, p’d= pd.
71
Определение. Клонированием элемента модели знаний называется функция
cloneE, выполняемая над элементом модели знаний ep и порождающая его
эквивалентную копию e’p, клонированием всех его свойств и дочерних
элементов:
cloneE : E E
cloneE ep = <[cloneP(ep.p1), …, cloneP(ep.pf)], [cloneE(ep.1), …, cloneE(ep.w)]>.
Определение. Клонированием модели знаний называется функция clone,
выполняемая над моделью знаний m и порождающая ее эквивалентную
копию, клонированием всех ее элементов:
clone: M M
clone m = [cloneE(e0), cloneE(e1), …, cloneE(ev) ]. (2.7)
Так как при клонировании модели знаний клонируются все ее
элементы, то время выполнения клонирования линейно зависит от размера
модели знаний:
Θclone = O(|m|).
Определение. Слиянием параметров элементов нескольких однотипных
моделей знаний называется функция merge, которая для параметров
идентичных элементов моделей знаний mp.e ↔ mq.e:
изменяет идентифицирующие параметры PI и параметры состояний
PSне;
применяет заданную операцию агрегирования к вычисляемым
параметрам pdPC:
merge: [P] [[P]] [P]
merge m.e.P [m1.e.P,…, mq.e.P] =
= [pd| pd =
С
S
I
Pесли
Pесли
Pесли
ddqd1d
dd
dd
p,.pe....pe e.p
p, e.p
p,e.p
];
(2.8)
72
Операция агрегирования для каждого вычисляемого параметра
может быть своя и определяется назначением данного параметра. Если хотя
бы для одного вычисляемого свойства не существует операции
агрегирования, то для элемента модели знаний, которому принадлежит
данное свойство, функция merge не применима.
Определение. Объединением элементов модели знаний называется функция
union выполняемая над элементами моделей знаний, имеющих одинаковые
индексы и выполняющая следующую последовательность действий над
объединяемыми элементами модели знаний:
1. слияние;
2. конкатенацию списков их дочерних элементов;
3. объединение их идентичных дочерних элементов;
union: E [E] E
union m.e [m1.e,…,mq.e]=<merge m.e.P [m1.e.P,…,mq.e.P], [e’1,…,e’i,…,e’w]>, где
e’i = i i
i 1 i q i
e , если e принадлежит только одной из моделей
union m.e m .e , ,m .e , если иначе
;
(2.9)
Определение. Объединением однотипных моделей знаний называется
функция join, применяющая функцию union для корневых элементов каждого
дерева моделей знаний, за исключением метаданных:
join : M [M] M
join m [m1,…, mk]=
= [m.e0, union m.e1 [m1.e1,…,mk.e1],…,union m.ev [m1.ev,…,mk.ev]]. (2.10)
Так как при объединении модели знаний выполняется полный проход
только по идентичным элементам, то время выполнения данной функции в
худшем случае линейно зависит от размера модели знаний:
Θjoin = O(|m|).
73
2.3 Функциональная модель алгоритма анализа данных
2.3.1 Расширение теории лямбда-исчислений для описания анализа данных
Как и любой алгоритм, алгоритм анализа данных может быть описан в
терминах теории λ- исчислений [247, 248]. В λ- исчислении редукцией
называют преобразование некоторого λ-терма. Сам λ-терм описывает в том
числе и функциональную зависимость (-выражение) и может иметь вид:
x.e v, где
x – переменная - аргумент функции;
e – выражение, вычисляющее значение на основании аргумента x;
v – значение аргумента, подставляемое вместо аргумента x.
В λ-исчислении определены четыре вида редукций (-, -, - и -
редукции) [248]. Наиболее значимыми редукциями с практической точки
зрения являются -редукция и -редукция:
-редукция выполняет преобразование, в результате которого
выполняется подстановка вместо переменной ее значения:
x.e(x) y e(y);
-редукция выполняет преобразование, в результате которого вместо -
выражения выполняется подстановка результата вычисления:
e(y) z, где z результат вычисления e(y).
Редукции могут применяться к исходному выражению последовательно,
меняя его форму. Если выражение описывает алгоритм, то применение
редукций к такому выражению, соответствует выполнению алгоритма.
74
Представим алгоритм анализа данных в виде -функции,
принимающей в качестве входного аргумента набор данных d D и
возвращающей в качестве результата модель знаний m M:
f: D M. (2.11)
Здесь и далее заглавными буквами будем обозначать типы аргументов
(множества), а прописными переменные этих типов. Например, переменная d
типа D (d D).
Утверждение. Алгоритм анализа данных может быть представлен
композицией -термов
(m.fn(m)) ((m.fn-1(m)) …(m.fs(m)) ….. (m. fr(m)) …. (f0(d)) d)..)),
которая может быть вычислена с помощью последовательного применения
- и - редукций.
Доказательство. Применение - и - редукций к указанному -выражению
должно позволить преобразовать его к результату в виде модели знаний.
Например, для алгоритма из 3х функций -выражение будет выглядеть
следующим образом:
((y.f2(y)) ((y.f1(y)) ((y.f0(y)) d))).
Использовав, аппликативный порядок применения -редукции получим:
((y.f2(y)) ((y.f1(y)) ((y.f0(y)) d)))
((y.f2(y)) ((y.f1(y)) f0(d)))
((y.f2(y)) (f1(f0(d)))
f2(f1(f0(d))).
75
Применив к получившемуся выражению -редукцию получим в
результате модель знаний m, которая будет вычислена последовательным
выполнением функций f0, f1 и f2.
Для упрощения записи, представим алгоритм анализа данных в более
привычном виде – в виде композиции функций
f = fn fn-1… fs … fr … f1 f0. (2.12)
В представленной композиции первая функция f0 принимает в качестве
аргумента набор данных d D и возвращает созданную по нему модель
знаний m0 M:
f0: D M. (2.13)
Для любых алгоритмов функция f0 формирует дерево e0 содержащее
метаданные анализируемого набора данных. Кроме того, она создает
корневые элементы остальных деревьев в соответствии с типом строящейся
модели знаний.
Остальные функции композиции (2.12) fr, r=1..n принимают в качестве
входного аргумента модель знаний mr-1, построенную предыдущей функцией
fr-1 и возвращает измененную модель знаний mr:
fr: M → M. (2.14)
Функции, которым для изменения модели знаний требуются данные,
дополнительно в качестве первого аргумента принимают набор данных dD.
Они имеют тип:
fr: D → M → M. (2.15)
76
Частичное применение такой функции с фиксацией первого аргумента
(набора данных) возвращает функцию к типу (2.14):
fdr: M → M
fdr = fr d.
Таким образом, функция fr, k=1..n для получения результата использует
модель знаний mr-1 и изменяет только результирующую модель знаний mr.
Определение. Функцией обработки модели ФОМ fr будем называть
функцию, принимающую модель знаний mr-1, изменяющую ее и
возвращающую измененную модель знаний mr.
Время выполнения ФОМ во многом определяется сложностью
операций выполняемых в ней и производительностью вычислительного узла,
на котором она выполняется. Для упрощения за время выполнения ФОМ
примем число операций добавления, удаления, извлечения и простейшие
изменения элементов модели знаний. В случае явно высокой трудоемкости
вычислений выполняемой ФОМ может быть использован повышающий
коэффициент. Время выполнения ФОМ fr обозначим как τ(fr).
Выполнение алгоритма анализа данных, представленного в виде
композиции ФОМ, можно изобразить в виде последовательности вызовов
ФОМ (Рисунок 2.4).
Рисунок 2.4 – Последовательное выполнение алгоритма анализа данных.
Определение. Основной последовательностью алгоритма анализа данных
называется композиция ФОМ, выполняющаяся последовательно, начиная с
функции f0.
Необходимо заметить, что ФОМ fr может использовать не все элементы
модели знаний mr-1, являющейся входным аргументом. Кроме того, результат
ее работы может привести к изменению только некоторых элементов
77
итоговой модели знаний mr. Для дальнейшего анализа зависимостей по
данным [211, 212] (data dependency analysis – из теории компиляторов) между
ФОМ используем соответствующие обозначения:
In(fr) - множество элементов входной модели знаний mr-1,
используемых fr в процессе выполнения;
Out(fr) - множество элементов выходной модели знаний mr,
изменяемых fr в процессе выполнения.
2.3.2 Функция для выполнения последовательности функций обработки
модели
Для последовательного выполнения композиции ФОМ введем
функцию:
run: [M → M] →M → M
run [fr, …, fs] m = (fs…fr) m =(fs …(fr mr-1)). (2.16)
Функция run последовательно вызывает ФОМ из переданного ей
списка. Время выполнения функции run вычисляется как суммы времени
выполнения ФОМ из списка:
τ(run [fr, …, fs]) = ( )s
i
i r
f
.
Для преобразования функции run к типу (2.14) необходимо выполнить
ее частичное применение, зафиксировав первый аргумент:
runf: M → M
runf = run [fr, …, fs].
Следовательно, полученная ФОМ runf может быть использована в
качестве элемента списка первого аргумента функции run.
Выполнение всего алгоритма анализа данных также может быть
записано через функцию run следующим образом:
f d = run [f1, …, fn] (f0 d).
78
При этом время выполнения всего алгоритма вычисляется как сумма
времен выполнения ФОМ из основной последовательности и времени
выполнения функции f0:
τ(f) = τ(f0) + τ(run [f1, …, fn]) = 0
1
( ) ( )n
i
i
f f
.
Таким образом, алгоритм анализа данных может быть представлен в
виде иерархической структуры, определяющейся вложенностью ФОМ. Ее
можно представить в виде связанного ациклического графа – дерева
GF= (F, E
F), где
вершинами графа F являются ФОМ, а дугами EF обозначается вложенность
ФОМ. Корнем такого дерева является вызов функции run применительно к
основной последовательности. Потомками каждого узла являются ФОМ на
которые он декомпозирован. Листьями дерева являются не декомпозируемые
ФОМ.
Потомки некоторой ФОМ, в иерархической структуре алгоритма
анализа данных, обозначим Φ. Для функции run потомками являются ФОМ
передаваемые ей в списке (Рисунок 2.5):
Φ(runf) = Φ(run [fr, …, fs]) = {fr, …., fs}.
Рисунок 2.5 – Дерево вложенности функции run.
Таким образом, потомками всего алгоритма анализа данных являются
ФОМ из основной последовательности:
Φ(run [f1, …, fn]) = {f1, …., fr, …., fs, …., fn}.
Будем считать, что выполнение одной ФОМ функцией run
тождественно равно выполнению списка из одной ФОМ:
run [fk] m run fk m = fk m.
run[f1, …,fn]
f1
fs
fr
fn
fn-1
79
Соответственно, потомком последовательности из одной ФОМ,
является она сама:
Φ(run [fk]) = {fk}.
Элементы модели знаний, используемые и изменяемые функцией run,
определяются следующим образом:
In(runf) = In(fr) … In(fs) и
Out(runf) = Out(fr) …Out(fs).
Выполнение алгоритма анализа данных не всегда является
последовательным процессом. В нем, как и в любом алгоритме, могут быть
операторы условного выполнения и циклы. Для их описания в виде
функциональных выражений добавим встроенные функции и покажем, как с
их помощью можно записать перечисленные структурные элементы в
функциональном виде.
2.3.3 Функция условного выполнения
Утверждение. Оператор условного выполнения в алгоритме анализа данных
может быть записан в виде следующей функции высшего порядка:
dec: (M Boolean) (M M) (M M) M M,
dec c ft ff m =if (c m) then (ft m) [else (ff m)], где (2.17)
c – функция, вычисляющая условное выражение, типа:
c: M Boolean;
ft – ФОМ, выполняющаяся, если результат функции c – истина;
ff - ФОМ, выполняющаяся, если результат функции c – ложь.
Альтернативная часть выражения (взятая в квадратные скобки) может
отсутствовать (при отсутствии ФОМ ff).
Частичное применение функции dec c фиксацией первых 3x аргументов
приводит ее к типу (2.14) и позволяет использовать в композиции (2.12):
80
decf: M → M
decf = dec c ft ff.
Доказательство: Покажем, что при использовании функции dec
последовательность обработки модели знаний определяется условием c, т.е.
зависимости по управлению сохраняются. Допустим, имеем алгоритм
анализа данных, представленный композицией:
f = fn fn-1… fr fr-1 … f1 f0.
В нем ФОМ fi это функция decf:
fr = decf = dec c ft ff.
Редуцируем данное выражение:
f fn (fn-1 (… decf (fr-1(…f1(f0(d)…)...)) …
fn (fn-1 (… decf (fr-1(mr-2)…)…))
fn (fn-1 (… dec(c, ft, ff, fr-1(mi-2))…)…)
fn (fn-1 (… if (c fi-1(mi-2)) then (ft fr-1(mr-2)) else (ff fr-1(mr-2)) …)…).
До функции decf выражение выполняется без изменений. Функция decf
управляет выполнением ФОМ ft и ff., т.к. в зависимости от условия c
выполняется или ФОМ ft или ФОМ ff.. При этом на вход этих ФОМ
поступают модели знаний, возвращаемые ФОМ fr-1 (Рисунок 2.6).
Результатом функции decf является модель знаний, обработанная или ФОМ ft
или ФОМ ff. В свою очередь она поступает на вход ФОМ fr+1. Таким образом,
в зависимости от условия с, получаем два функциональных выражения:
dma = fn (fn-1 (… ft (fi-1(…f1(m0)…)..)) – если c – истина;
dma = fn (fn-1 (… ff (fi-1(…f1(m0)…)..)) – если с – ложно.
В этом случае зависимость по управлению не нарушена и оба
выражения являются корректными и могут быть редуцированы (выполнены).
81
Рисунок 2.6 – Выполнение функции dec.
Время выполнения функции dec вычисляется как сумма времени
выполнения условия и максимального времени выполнения ФОМ ft и ff:
τ(dec c ft ff) = τ(с) + max(τ(ft), τ(ff)).
Потомками функции dec в дереве вложенности являются
альтернативные ФОМ (Рисунок 2.7):
Φ(dec) = Φ(dec c ft ff) = {ft, ff}.
Рисунок 2.7 – Дерево вложенности функции dec.
Для алгоритмов анализа данных типовыми являются функции
условного выполнения в зависимости от текущего элемента модели знаний.
Определим для таких функций специальное условие:
сE: E → M → Boolean
сE e m = m[m.curr] == e.
Для применения данного условия в функции dec необходимо
выполнить ее частичное применение с фиксацией первого аргумента:
с = cE e.
В этом случае функцию условного выполнения в зависимости от
текущего элемента модели знаний определим следующим образом:
dece: E (M M) (M M) M M,
dece e ft ff m =if (m[m.curr] == e) then (ft m) [else (ff m)]. (2.18)
dec с ft ff
ft
ff
82
Для преобразования функции dece к типу (2.14) также необходимо
выполнить частичное применение функции, зафиксировав первые 3
аргумента:
decef: M → M
decef = dec e ft ff.
Полученная ФОМ decef может быть использована в качестве элемента
списка первого аргумента функции run.
Элементы модели знаний, используемые и изменяемые ФОМ decef,
определяются следующим образом:
In(decef) = {m.curr} In(ft) In(ff) и
Out(decef) = Out(ft) Out(ff). (2.19)
2.3.4 Функция выполнения цикла
В функциональных языках программирования циклы отсутствуют, в
виду отсутствия состояния программы и операторов присваивания. Для
выполнения итерационных действий без сохранения состояния программы
используется рекурсивный вызов функции. С его помощью запишем циклы
для алгоритма анализа данных.
Утверждение. Оператор цикла в алгоритме анализа данных может быть
записан как рекурсивная функция высшего порядка вида:
loop : (MBoolean)(MM)(MM)(MM)MM)
loop с finit fafter ft m = loop’ finit = loop’ c fafter ft (finit m), где
finit – ФОМ, выполняющаяся перед циклом (инициализирующий цикл);
fafter – ФОМ, выполняющаяся после каждой итерации;
ft – ФОМ, выполняющаяся итерационно;
loop’ – рекурсивно вызывающаяся функция:
83
loop’: (MBoolean)(MM)(MM) M M
loop’ с fafter ft m = if (c m) then (loop’ c fafter ft (fafter ft m))
else (fafter ft m).
Доказательство. Докажем, корректность представления цикла в описанном
виде, применив последовательно - и - редукции, например, для трех
итераций:
loop c finit fafter ft m
loop’ с fafter ft (finit m)
if (c (finit m)) // условие истинно
then (loop’ c fafter ft (fafter ft (finit m)))
if (c (finit m)) // условие истинно
then if (c (fafter ft finit m)) // условие истинно
then (loop’ c fafter ft (fafter ft (fafter ft finit m)))
if (c (finit m)) // условие истинно
then if (c (fafter ft finit m)) // условие истинно
then if (c (fafter ft fafter ft finit m)) // условие ложно
else (fafter ft) (fafter ft fafter ft finit m).
В результате, будет выполнено выражение, записанное в части else:
fafter ft fafter ft fafter ft finit m.
Можно убедиться в том, что данное выражение соответствует логике
выполнения цикла:
инициализация цикла (функция finit) будет выполнена один раз в самом
начале выполнения выражения;
основной блок цикла (функция ft) будет выполнен три раза и
результаты каждого выполнения будут переданы следующему блоку с
пост обработкой функцией fafter.
84
Таким образом, цикл можно представить в виде функции высшего
порядка следующим образом:
loop : (MBoolean)(MM)(MM)(MM)MM)
loop с finit fafter fiter m = loop’ finit = loop’ c fafter fiter (finit m) =
fafter fiter … fafter fiter fafter fiterfinit m.
(2.20)
Время выполнения функции loop вычисляется как время выполнения
условия, ФОМ инициализации finit и произведения числа итераций g и суммы
времен выполнения ФОМ fafter и ft:
τ(loop c finit fafter ft) = τ(с) + τ(finit) + g·(τ(ft) + τ(fafter)).
Особенностью функции цикла является заранее (до выполнения
алгоритма) неизвестное число итераций g. Оно определяется условием с на
этапе выполнения цикла.
Потомком функции loop в дереве вложенности является итерационно
вызываемая ФОМ (Рисунок 2.8):
Φ(loop) = Φ(loop с finit fafter ft) = {ft}.
Рисунок 2.8 – Дерево вложенности функции loop.
Для преобразования функции loop к типу (2.14) необходимо выполнить
ее частичное применение, зафиксировав первые 4 аргумента:
loopf: M → M
loopf = loop с finit fafter ft.
В результате функция loopf может быть выполнена функцией run при
выполнении алгоритма (Рисунок 2.9).
loop c finit fafter ft
ft
85
Рисунок 2.9 – Выполнение функции loop.
Алгоритмы анализа данных, итерационно обрабатывают данные и
элементы строящейся модели. При интерационной обработке векторов
набора данных d, одна и та же ФОМ ft применяется к g векторам, начиная с s-
го. В этом случае, функции, являющиеся аргументами для loop, могут быть
определены следующим образом:
инициализация цикла устанавливает текущим вектором s-й вектор:
finit m = m.curr = s;
последующая функция устанавливает текущим вектором
следующий:
fafter m = m. curr ++;
условная функция, проверяет, что все векторы были обработаны:
c m = (m.curr < s+g).
Таким образом, цикл обработки векторов набора данных может быть
представлен следующим образом:
loopd: Integer Integer (M M) M M
loopd s g ft m = loop (m.curr < s+g) (m.curr= s) (m.curr++) ft m =
= (m.curr++) ft … (m.curr++) ft (m.curr=s).
(2.21)
Вызов функции для обработки всех векторов можно упростить,
зафиксировав первые два аргумента:
loopd ft m = loop (m.curr < z) (m.curr=0) (m.curr++) ft m.
С учетом того, что условная функция c и ФОМ finit и fafter выполняют
простейшие операции, время их выполнения можно приравнять к 1. Таким
образом, время выполнения функции loopd будет вычисляться по формуле:
τ(loopd ft) = 2 + g·(τ(ft) + 1).
86
Утверждение. Цикл по векторам loopd может быть представлен
композицией циклов, выполняющих обработку непересекающихся
подмножеств векторов, образующих полное множество:
loopd s g ft m = (loopd s+g 1 ft)…(loopd 1 1 ft) m.
Доказательство. В соответствие с определением цикла (2.21), развернем
каждую функцию композиции следующим образом:
(loopd 1 1 ft) = (m.curr++) ft (m.curr=1);
…
(loopd s+g 1 ft) = (m.curr++) ft (m.curr=s+g).
Каждая такая функция применяет ФОМ ft к вектору набора данных,
индекс которого инициализируется в начале выполнения цикла. При этом
ФОМ ft применяется один раз, т.к. после инкрементации условие выхода из
цикла становится ложным.
При композиции таких функций, получим следующее выражение:
(loopd s+g 1 ft) … (loopd 2 1 ft) (loopd 1 1 ft) =
= (m.curr++)ft(m.curr=s+g)…ft(m.curr=2)(m.curr++)ft(m.curr=1).
При этом, выполняющиеся последовательно функция инкрементации
(m.curr++) и функция инициализации (m.curr=2) выполняют аналогичные
действия, устанавливая текущим вектором следующий вектор.
Следовательно, одна из этих функций может быть опущена. Таким образом,
будет получено выражение, совпадающее с определением цикла (2.21):
(loopd s+g 1 ft) … (loopd 2 1 ft) (loopd 1 1 ft) =
= (m.curr++)ft…ft (m.curr++)ft(m.curr=1) = loopd s g ft.
Что и требовалось доказать.
Для преобразования функции loopd к типу (2.14) необходимо
выполнить ее частичное применение, зафиксировав первые три аргумента:
87
loopdf: M → M
loopdf = loopd s g ft.
Полученная ФОМ loopdf может быть использована в качестве элемента
списка первого аргумента функции run.
Аналогичным образом, определяется функция цикла, выполняющая
обработку элементов модели знаний. Такой цикл, можно определить как
цикл, применяющий одну и ту же ФОМ ft к g узлам-потомкам элемента
модели знаний идентифицированного индексом i начиная с s-го элемента. В
этом случае функции аргументы функции loop могут быть определены
следующим образом:
инициализация цикла устанавливает текущим элементом модели
знаний элемент с индексом is:
finit m = m[i].curr = s;
последующая функция устанавливает текущим узлом-потомком
следующий элемент:
fafter m = m[i].curr ++;
условная функция, проверяет, что все узлы-потомки были
обработаны:
c m = (m[i].curr < s+g).
Таким образом, цикл обработки последовательности элементов модели
знаний может быть представлен следующим образом:
loope : IntegerInteger I (M M) M M
loope s g i ft m = loop (m[i].curr <s+g) (m[i].curr=s) (m[i].curr++) ft m =
= (m[i].curr++) ft … (m[i].curr++) ft (m[i].curr=s).
(2.22)
Время выполнения функции loope вычисляется аналогино, по формуле:
τ(loope ft) = 2 + g·(τ(ft) + 1).
88
Утверждение. Цикл по элементам модели знаний loope может быть
представлен композицией циклов, выполняющих обработку
непересекающихся подмножеств элементов, образующих полное
множество:
loope s g i ft m = (loope s+g 1 i ft) … (loope 1 1 i ft) m.
Доказательство выполняется аналогично доказательству для цикла по
векторам.
Вызов функции для обработки всех узлов-потомков можно упростить,
зафиксировав первые два аргумента:
loope ft m = loop (m[i].curr < m[i].size) (m m[i].curr=0) (m m[i].curr++) ft m.
Для преобразования функции loope к типу (2.14) необходимо
выполнить ее частичное применение, зафиксировав первые 4 аргумента:
loopef: M → M
loopef = loope s g i ft.
Полученная ФОМ loopef может быть использована в качестве элемента
списка первого аргумента функции run.
Множества используемых и изменяемых элементов модели знаний для
ФОМ loopef определяются следующим образом:
In(loopef)={m[i].curr,m[i].size}In(ft/m[i].curr=s)…In(ft/m[i].curr=s+g)
Out(loopef) = {m[i].curr } Out(ft/m[i].curr=s) …Out(ft/m[i].curr=s+g). (2.23)
где запись ft/m[i].curr=s означает выполнение ФОМ при текущем элементе
модели знаний m[i].curr=s.
2.3.5 Пример представления алгоритма в виде функционального выражения
Рассмотрим возможности распараллеливания алгоритма анализа
данных с помощью предложенного подхода на примере популярного
алгоритма классификации 1R [59]. Алгоритм достаточно прост для
89
демонстрации предлагаемых методов и средств. В то же время алгоритм 1R
содержит в себе структуры, которые позволят рассмотреть их особенности.
Псевдокод алгоритма 1R представлен ниже.
// Для каждого атрибута
1 For k = 0 ...|A|
// Для каждого атрибута подсчитать появление каждого класса
2 For j = 1 …|X|
3 count[k][xj.k][xj.t]++;
4 For q =1 … |Defk|
// найти наиболее частый класс
5 For p = 1 … |Deft|
6 if count[k][vk.q][vt.p] > count[k][vk.q][vt.mi]
7 mi = p;
// сделать правило для класса и значения атрибута
8 R[k].add({ak, vk.q,vt.mi, count[k][vk.q][vt.mi]})
// вычислить ошибку класса
9 correctVectors+=count[k][vk.q][vt.mi]
//Выбрать правило с минимальной ошибкой
10 if(correctVectors > bestCorrectVectors)
11 bestCorrectVectors = correctVectors;
12 R = R[k]
13 correctVectors = 0;
Алгоритм 1R формирует элементы модели знаний в виде простых
правил классификации:
if (ak = vk.q) then (at = vt.p), где
ak:k=1..m - независимые атрибуты, значения которых известны и на
основании которых определяется значение зависимого атрибута;
vk.q – значение независимого атрибута ak (vk.qDefk);
at зависимый (целевой) атрибут значение (class) которого необходимо
определить с помощью правила;
vt.p – значение зависимого атрибута (vt.pDeft).
90
Алгоритм для каждого независимого атрибута ak выполняет подсчет
количества векторов со значениями независимого атрибута ak и значениями
зависимого атрибута at итерационно в цикле по всем векторам (строки 2-3).
Результаты подсчета сохраняются в трехмерном массиве count[][][], где:
первое измерение соответствует независимым атрибутам;
второе измерение соответствует значениям независимого атрибута ak;
третье измерение соответствует значениям зависимого атрибута at.
Далее (строки 5-7) в цикле по значениям зависимого атрибута at
(который выполняется в цикле по значениям независимого атрибута ak)
выполняется поиск максимального количества векторов в массиве count.
Индекс максимального элемента в массиве запоминается в переменной mi ;
Далее (строка 8) создается классификационное правило для каждого
значения vk.q каждого независимого атрибута ak. В заключительной части
правила указывается значение vt.mi зависимого атрибута at (vt.mi Def(at)),
которое наиболее часто встречается у объектов с выбранным значением vk.q
независимого атрибута ak. Созданное правило добавляется в 2-мерный
массив правил-кандидатов R[k] для атрибута ak.
Далее (строка 9), вычисляется сумма подсчитанных ранее корректных
векторов (correctVectors) для созданных правил.
На последнем этапе (строки 10 – 13) осуществляется сравнение
суммарного количества векторов (correctVectors), удовлетворяющих
созданным правилам-кандидатам R[k], с максимальным количеством
(bestCorrectVectors) ранее выбранных правил R. Правила с максимальным
числом векторов сохраняются в итоговом одномерном массиве правил R.
В соответствие с предложенным подходом представим алгоритм 1R в виде
композиции перечисленных ФОМ. При этом функция f0 создает модель
знаний m0M, которая включает в себя следующие четыре дерева:
91
m[0] – дерево метаданных набора данных d, где m[0,k] – элемент модели
знаний, содержащий информацию о k-м атрибуте ak и его значениях;
m[1] – дерево классификационных правил, построенных алгоритмом 1R,
в котором:
o m[1].n параметр, определяющий количество векторов
удовлетворяющих правилам (корректных векторов) входящих в
массив.
o m[1, p] – классификационное правило, простейший вид которого
может быть определен как набор параметров:
m[1,p] = <ak, vk.q, vt.p, n>, где
n – параметр, определяющий количество корректных векторов –
векторов для которых данное правило является верным:
n = |{xj : xjX, (ak(xj) = vk.q и at(xj) = vt.p)}|.
m[2] – дерево простых правил кандидатов;
m[3] – дерево хранящее информацию о количестве векторов для каждой
комбинации: значения независимого атрибута ak, значения зависимого
атрибута at:
o m[3, k] содержит элементы соответствующие значениям
независимого атрибута ak:
m[3, k, q] содержит элементы, соответствующие значению vk.q
независимого атрибута ak:
m[3, k, q].mi индекс (mi: 1..u) значения зависимого атрибута
at (класса) для которого имеется максимальное количество
векторов (соответствует переменной mi) ;
m[3, k, q, p] - количество векторов имеющих
соответствующие значения независимого атрибутов ak и
зависимого атрибута at:
m[3, k, q, p]=|{xj|ak(xj)=vk.q,at(xj)=vt.p, xjX, ak,atA, vk.qDef(ak), vt.pDef(at)}|;
92
Псевдокод алгоритма 1R, использующий элементы описанной модели,
представлен ниже.
// Для каждого атрибута
1 For k = 0 ...|A|
// Для каждого атрибута подсчитать появление каждого класса
2 For j = 1 …|X|
3 m[3,k,d[j,k],d[j,t]]++;
4 For q =1 … |Defk|
// найти наиболее частый класс
5 For p = 1 … |Deft|
6 if m[3,k,m[0,k,q],m[0,t,p]]>m[3,k,m[0,k,q],m[3,k,m[3,k,q]].mi]
7 m[3,k,q].mi = p;
// сделать правило для класса и значения атрибута
8 m[2].add(<m[0,k],m[0,k,q],m[3,k,m[0,k,q]],[3,k,m[0,k,q],
m[3, k, m[3,k,q]].mi]>)
// вычислить ошибку класса
9 m[2].n+= m[3,k, m[0,k,q],m[3, k, m[0,k,q]].mi ]
//Выбрать правило с минимальной ошибкой
10 if(m[2].n > m[1].n)
11 m[1].n = m[2].n;
12 m[1] = m[2];
13 m[2].clear;
Для алгоритма 1R, можно выделить следующие ФОМ:
fd1 - цикл по метаданным с m[0,1] по m[0,p] (строки 1-13):
fd1 = loope [0] (f13f10f4fd2);
fd2 - цикл по векторам набора данных с d[0] по d[z] (строки 2-3):
fd2= loopd fd3;
fd3 – функция выполняющая инкрементацию количества корректных
векторов m[3,k,q,p] для значений vk.q независимого атрибута ak и
значений vt.p зависимого атрибута at (строка 3);
93
f4 - цикл по значениям независимого атрибута ak с m[0,k,1] по
m[0,k,u]:
f4 = loope [0, k] (f9f8f5);
f5 - цикл по значениям зависимого атрибута at с m[0,t,1] по m[0,t,y]:
f5 = loope [0, t] f6;
f6 - функция выполняющая поиск элемента модели знаний с
максимальным значением количества корректных векторов
m[3,k,q,p] среди элементов поддерева m[3,k,q] и запоминающая его
индекс в поле m[3,k,q].mi (строки 6-7);
f8 - функция выполняющая добавление правила m[2,p] с
максимальным количеством корректных векторов, во множество
правил кандидатов m[2] (строка 8);
f9 - функция выполняющая подсчет корректных векторов m[2,p].n
для одного атрибута ak (строка 9);
f10 - функция выполняющая выбор лучшего набора правил (m[1] или
m[2]) для одного атрибута (строки 10-12);
f13 - функция выполняющая удаление набора правил кандидатов из
m[2] для одного атрибута (строка 13);
Таким образом, весь алгоритм 1R в виде композиции (2.14) полученных
функций и функции f0 можно представить в виде следующего
функционального выражения:
1R= (loope [0] f13f10
(loope [0, k] f9f8(loope [0, t] f6))
(loopd fd3))f0
(2.24)
Дерево вложенности алгоритма 1R изображено на рисунке 2.10.
94
Рисунок 2.10 – Дерево вложенности алгоритма 1R.
2.4 Метод оптимизации структуры алгоритма анализа к виду
распределения данных
2.4.1 Оптимизация циклов в зависимости от типа распределения данных
При распределенном хранении данных их обработка усложняется
необходимостью переключения с одного источника на другой. Даже при
хранении данных на одном узле, но в разных источниках (разных файлах, БД
и т.п.) возникают временные затраты на переключение между ними
(связанные с открытием файла, установлением соединения с БД и т.п.). При
хранении данных на разных узлах, временные затраты возрастают на
установление соединения с узлом и передачу данных по сети.
Подобная проблема известна в теории компиляторов, когда
необходимо гарантировать, что элементы многомерных массивов доступны в
том порядке, в котором они хранятся в памяти, т.е. для улучшения
локальности ссылок. Для ее решения применяется операция перестановки
циклов (англ. Loop interchange) [210] с целью оптимизации компилятора.
Она меняет порядок итерационных переменных, относящихся к группе
вложенных циклов. Итерационная переменная, используемая во внутреннем
f0
run[f0, fd1]
loope [0] f15f10f4fd2
looped fd3 loope [0, k] f9f8f5
fd3
f6
loope [0, t] f6 f8 f9
f10 f15
95
цикле, перемещается во внешний цикл, и наоборот. В результате достигается
обработка массива в соответствии с размещением его элементов в памяти.
При анализе данных, временные затраты, необходимые для
переключений между источниками, зависят от вида их распределения и
организации циклов в алгоритме. При горизонтальном распределении
данных (2.2) переключение между источниками происходит после обработки
всех векторов одного источника и переходу к обработке векторов
следующего источника. Количество таких переключений соответствует
числу источников w-1. Однако, если обработка векторов выполняется внутри
некоторого цикла (например, цикла по атрибутам), то количество
переключений умножается на число итераций (например, при вложении в
цикл по атрибутам число переключений будет умножено на число атрибутов
p·(w-1)).
Чтобы устранить данную проблему и минимизировать время,
затраченное на переключение, цикл соответствующий распределению
данных (цикл по векторам при горизонтальном распределении и цикл по
атрибутам при вертикальном распределении) должен быть внешним. В
предлагаемом подходе, данная операция будет заключаться в перестановке
ФОМ, являющихся циклами, например:
loope s g [0] loopd j h fdt loopd f h loope s g [0] fdt.
Данная операция является корректной, т.к. ФОМ fdt и в первом и во
втором случае обрабатывает значения матрицы данных d. Меняется только
порядок изменения индексов.
Более сложный случай, когда ФОМ, вызываемый из внешнего цикла,
является композицией нескольких ФОМ, одним из которых является
перемещаемый цикл:
loope s g i ft-1(loopd j h fdt) ft+1.
96
Проблема заключается в том, что ФОМ участвующие в композиции (ft-1
и ft+1) обрабатывают элементы модели знаний, идентифицируемые только
внешним циклом и простая перестановка циклов, приведет к их
некорректной работе. В связи с этим, перед перестановкой, необходима
операция расщепления (англ. loop fission) [210]. Она также используется в
оптимизации компилятора и разбивает в программе цикл на несколько
циклов, каждый из которых имеет те же индексные границы, однако
содержит только часть тела исходного цикла. В результате, операция
перестановки должна применяться только к ФОМ, являющейся вложенным
циклом:
loope s g i ft-1(loopd j h fdt) ft+1
(loope s g i ft-1) (loope s g i (loopd j h fdt)) (loope s g i ft+1)
(loope s g i ft-1) (loopd j h (loope s g i ft)) (loope s g i ft+1).
2.4.2 Метод оптимизации структуры алгоритма анализа данных
Используя две операции оптимизации цикла: расщепление и
перестановка, опишем метод, оптимизирующий структуру алгоритма анализа
данных представленного в виде (2.12). Он включает в себя следующие общии
шаги:
1. Если данные распределены горизонтально (вертикально), то в
структуре алгоритма найти цикл по векторам (атрибутам) fr.
2. Если найденный цикл fr вложен в цикл fp, то:
a. если |((fp))| > 1 применить к fp операцию расщепления (fission);
b. применить к циклам fp и fr операцию перестановки (interchange);
c. повторить шаг 2.
Далее представлен псевдокод метода.
97
Метод рекурсивно выполняет обход дерева алгоритма анализа данных,
в поисках цикла, соответствующего распределению данных. Необходимо
optimizateStructure (f, flag) – функция оптимизации алгоритма анализа данных в
зависимости от типа распределения данных.
Вход: ФОМ f в которой выполняется оптимизация;
flag – флаг горизонтального распределения данных (true-при горизонтальном
распределении, false -при вертикальном распределении данных).
Выход: измененный алгоритм
optimizateStructure (f, flag)
1. for each fr from Φ(f)
2. if (fr is loop) or (fr is dec) or (fr is run)
3. optimizateStructure (fr, flag)
4. if ((flag) and (fr is loopd)) or ((not flag) and (fr is loope [0])) // fr искомый цикл
5. fp = fr.parent
6. if (fp != null) and (fp is loop) // цикл fr не является внешним
7. if (|(fp)| > 1) // в цикле выполняется композиция ФОМ
8. fp = fission(fp)
9. interchange(fp, fr )
10. return f
fission (f) – функция расщепления цикла.
Вход: ФОМ f – цикл, над которым выполняется операция расщепления.
Выход: композиция расщепленных циклов.
fission (f)
1. fс = null
2. for each fr from Φ(f)
3. fn = clone f
4. fr → fn
5. fc = fc ○ fn
6. return fc
interchange (fp, fr) – функция перестановки циклов.
Вход: ФОМ fp, fr – циклы, над которыми выполняется операция перестановки.
interchange (fp, fr)
1. f =fp
2. fp = fr
3. fr = f
98
заметить, что в методе используется головная рекурсия, которая
обеспечивает выполнение трансформации снизу вверх по дереву.
Если найденный цикл, вызывается из другого цикла, то выполняется
операция перестановки (см. функция interchange). Если найденный цикл
является частью декомпозиции, то перед перестановкой должна быть
выполнена операция расщепления. Она заключается в замене формировании
композиции внешнего цикла, который итерационно вызывает только одну
ФОМ из композиции (см. функция fission). Сформированная композиция
заменяет внешний цикл (строка 9).
За счет использования головной рекурсии, обеспечивается
перемещение необходимого цикла с нижнего уровня на самый верхний
уровень.
2.4.3 Пример адаптации структуры алгоритма анализа данных
В качестве примера рассмотрим оптимизацию алгоритма 1R для
анализа горизонтально распределенных данных. В первоначальном варианте
алгоритма (2.24) внешним является цикл по атрибутам:
fd1 = loope [0] (f13f10f4fd2).
Для выполнения анализа горизонтально распределенных данных,
внешним циклом должен быть цикл по векторам fd2. Таким образом,
оптимизация структуры алгоритма 1R осуществляется вызовом:
optimizateStructure (1R, true).
Данный метод рекурсивно доходит до третьего уровня дерева
алгоритма 1R (Рисунок 2.10), на котором находится искомый цикл fd2.
Найденный цикл вложен во внешний цикл по атрибутам fd1. Кроме того,
цикл fd2 входит в композицию f13f10f4fd2 следовательно, должна
выполняться операция расщепления (fission):
fission(fd1) = (loope [0] f13) (loope [0] f10)(loope [0] f4)(loope [0] fd2).
99
После расщепления выполняется функция перестановки (interchange)
для циклов fd1 и fd2:
interchange(fd1, fd2) = loopd loope [0] fd3.
В результате алгоритм, представленный в виде выражения (2.24), будет
преобразован к виду:
1RH = (loope [0] f13) (loope [0] f10)
(loope [0] (loope [0, -1] f9f8(loope [0, t] f6)))
(loopd (loope [0] fd3)))f0.
(2.25)
При этом дерево вложенности алгоритма 1R будет иметь вид,
изображенный на рисунке 2.11.
Рисунок 2.11 – Дерево вложенности алгоритма 1R.
f0
run[f0, fd1]
loopd f1
loope [0] fd3 loopE [0, -1] f9f8f5
fd3
f6
loopE [0, t] f6 f8 f9
f10 f15
loope [0] f15 loope [0] f10 loope [0] f4
100
Выводы
Для построения параллельных алгоритмов анализа распределенных
данных:
1) модель знаний представлена в виде древовидной структуры
элементов, описывающих закономерности, извлеченные из
анализируемых данных, для которой должны выполняться
следующие условия:
состав и порядок деревьев в модели знаний строго определен и не
должен меняться в процессе ее построения;
обязательным элементом модели знаний является информация о
наборе данных, по которым она построена;
элементы модели знаний, являющиеся узлами-потомками одного
и того же узла должны иметь одинаковый набор свойств.
2) рекурсивно определены следующие функции для параллельной
обработки модели знаний:
функция клонирования, выполняющаяся перед
распараллеливанием алгоритма;
функция объединения, выполняющаяся после параллельного
выполнения.
3) расширена теория λ-исчислений для представления алгоритма
анализа данных в виде композиции унифицированных функций
обработки модели, включая функции для последовательного,
условного и итерационного выполнения;
4) предложен метод оптимизации структуры алгоритма анализа
данных, путем трансформации циклов, в зависимости от способа
распределения данных.
101
3. Построение параллельных алгоритмов анализа данных
При построении параллельного алгоритма анализа данны основной
задачей является поиск его оптимальной структуры с точки зрения
возможности и эффективности параллельного выполнения. Это зависит не
только от самого алгоритма, но и от характеристик набора анализируемых
данных и среды выполнения. Поэтому важным является формирование
разных вариантов параллельного выполнения.
Для параллельного выполнения функций в функциональном
выражении, согласно теореме Черча-Россера, они должны вызываться как
аргументы другой функции. Для этого необходимо определить
преобразования, выполняемые над алгоритмом анализа данных,
представленного как описано в предыдущей главе, в виде композиции
унифицированных функций.
Кроме того, для параллельного выполнения алгоритма анализа данных
декомпозированного на ФОМ необходимо определить какие из них могут
быть выполнены параллельно. Для этого должны быть определены
информационные зависимости между ними. Учитывая, что ФОМ
обмениваются моделями знаний, информационные связи определяются
обрабатываемыми ими элементами моделей знаний.
Таким образом, для анализа информационных зависимостей и
построения параллельных алгоритмов анализа данных необходимо
определить условия, не нарушающие информационные зависимости при
которых параллельное выполнение ФОМ будет корректным. На их
основании может быть разработан метод распараллеливания
последовательного алгоритма анализа данных.
102
3.1 Модель параллельного алгоритма анализа данных
3.1.1 Функции распараллеливания
Представление алгоритма анализа данных в виде функционального
выражения (2.12) упрощает его распараллеливание. В теории λ- исчислений
теорема Черча-Россера [354] гласит:
Если для некоторых λ – термов fk, fs, fr выполняются отношение -
редукции fk→fs и fk→fr, то существует такой терм ft, что fr→ft и fr→fr.
Из теоремы прямо вытекает ромбическое свойство отношения
редукции (Рисунок 3.1). Данное свойство аналогично свойству
конфлюэнтности [148], которое используется для описания абстрактной
модели асинхронных параллельных вычислений [356].
Рисунок 3.1 – Ромбическое свойство отношения редукции.
Учитывая, что λ – терм соответствует функции алгоритма, а его -
редукция соответствует подстановке в ней вместо переменной ее значения,
то в соответствии с теоремой Черча-Россера такое вычисление значений
аргументов функции может выполняться параллельно.
Для параллельного выполнения ФОМ они должны вызываться для
вычисления аргументов некоторой функции. Следовательно, должно быть
выполнено преобразование функционального выражения из
последовательной формы (2.12) в параллельную.
fk
fs fr
ft
103
Для построения параллельных алгоритмов и их выполнения в системах
с общей и распределенной памятью, введем функцию высшего порядка
parallel:
parallel : Boolean [(M M)] M M.
parallel s [f1, …, fr] m = if (s == true) head fork [f1, …, fr] m
else join m (fork [f1, …, fr] m), где
(3.1)
head – функция, возвращающая первый элемент списка.
Функция parallel использует функцию высшего порядка fork, которая
принимает список ФОМ и модель знаний, применяет каждую ФОМ из списка
к модели знаний и полученную модель знаний добавляет в возвращаемый
список:
fork : Boolean [M M] M [M].
fork s [f1, …, fr] m = if (s == true) [f1 m, …, fr m] m
else [f1 clone m, …, fr clone m].
(3.2)
В функциях parallel и fork первый булевский аргумент s определяет
способ выполнения: с общей или распределенной памятью.
Для систем с распределенной памятью, каждая параллельно
выполняющаяся ФОМ работает с аргументами, хранящимися в отдельной
памяти. Для создания отдельных копий модели знаний, должна
использоваться функция клонирования clone (2.7). Параллельно построенные
модели знаний m1,…,mk, также хранящиеся в отдельных областях
распределенной памяти и должны объединяться в единую модель знаний mr
(Рисунок 3.2). Для этого должна быть использована функция объединения
join (2.10).
104
Рисунок 3.2 – Параллельное выполнение для систем с распределенной
памятью.
При параллельном выполнении в системах с общей памятью
необходимо учитывать, что все изменения с моделью знаний, выполняемые
параллельными ФОМ, выполняются над одним и тем же экземпляром модели
знаний, хранящимся в общей памяти. Это означает, что аргументами
параллельных функций является один и тот же экземпляр модели знаний, что
не требует клонирование модели знаний и ее объединения (Рисунок 3.3).
Рисунок 3.3 – Параллельное выполнение для систем с общей памятью.
105
Утверждение. Использование функции parallel преобразует алгоритм
анализа данных из последовательной формы в параллельную:
fn …fs+1fs…frfr-1…f0 = fn…fs+1(parallel s [fr,…,fs])fr-1…f1f0.
Доказательство. Раскроем применение функции parallel к ФОМ в алгоритме
анализа данных для систем с распределенной памятью:
parallel false [fr,…,fs] mr-1 =
join m (fork [fr,…,fs] m) =
join m [(run fr clone m), …, (run fs clone m)] =
join m [m1,…,mk] =
[m.e0, union m.e1 [m1.e1,…,mk.e1],…, union m.ev [m1.ev,…,mk.ev]] =
[m.e0, m.e’1, …, m.e’v] = mr.
В результате выполнения функции fork на третьем шаге
преобразования, функции run для каждого ФОМ вызываются, чтобы
вычислить аргументы списка моделей знаний ([(run fr clone m), …, (run fs
clone m)]). Следовательно, согласно теореме Черча-Россера, они могут быть
выполнены параллельно.
Для систем с общей памятью доказательство данного утверждении
выполняется аналогично.
Частичное применение функции parallel с фиксацией первых двух
аргументов позволяет получить ФОМ (для систем с распределенной и систем
с общей памятью), которая может выполняться функцией run:
1. для систем с общей памятью (Рисунок 3.2):
parallelsf : M M
parallelsf = parallel true [fr,…,fs] = fork[f1, …, fk] m;
2. для систем с распределенной памятью (Рисунок 3.3):
paralleldf : M M
paralleldf = parallel false [fr,…,fs] = join m (fork[f1, …, fk] clone m).
106
Потомками функции parallel в дереве вложенности является множество
параллельно выполняющихся ФОМ (Рисунок 3.4):
Φ(parallel s [fr,…,fs]) = {fr,…,fs}.
Рисунок 3.4 – Дерево вложенности функции parallel
При использовании функции parallel, ФОМ fi, …, fr, выполняемые
параллельно в выражении (3.1), в общем случае могут быть разными. Таким
образом, предложенный подход позволяет выполнять распараллеливание по
задачам.
При применении функции parallel к функциям loopd (2.21) или loope
(2.22), получим распараллеливание одинаковых ФОМ, применяемых для
разных векторов или элементов модели знаний:
fn … fr… f1f0 = fn… (loope s g i ft) …f1f0 =
fn…(( loope s+g 1 i ft) … (loope s+1 1 i ft) (loope s 1 i ft))…f1f0 =
fn…(parallel [(loope s 1 i ft), …, (loope s+g 1 i ft)]…f1f0.
Таким образом, применение функции parallel к циклам loopd (2.21) или
loope (2.22) соответствует распараллеливанию по данным, т.к. одна и та же
ФОМ ft вида (2.14) применяется к разным элементам массива.
Возможность распараллеливания, как по данным, так и по задачам,
является существенным отличием от модели MapReduce. Кроме того, в
отличие от модели MapReduce функция parallel в процессе анализа данных
может быть использована многократно, тем самым позволяя
распараллеливать несколько частей алгоритма. Еще одним существенным
отличием от модели MapReduce является отсутствие необходимости
parallel s [fr,…,fs]
fr fs
107
существенной реструктуризации алгоритма для разделения на функции map
и reduce.
Далее покажем, что модель MapReduce является частным случаем
предложенной модели параллельного алгоритма анализа данных.
3.1.2 Реализация модели MapReduce с помощью предложенной модели
Покажем, что модель MapReduce применительно к алгоритму анализа
данных и ФОМ является частным случаем использования функции parallel
(3.1). Модель MapReduce разделяет обработку данных на две функции: map и
reduce:
функция map создается пользователем и принимает два аргумента: ключ
k1 и значение v1 и возвращает промежуточный результат – пару: ключ и
значение [(k2, v2)]:
map: k1 → v1 → [(k2, v2)];
функция reduce также создается пользователем, принимает
промежуточный ключ k2 и список значений [v2] сопоставленных с этим
ключом и возвращает значение v3 (которое может быть пустым):
reduce: k2 → [v2] →v3.
Необходимо заметить, что в модели MapReduce определение функция
map и reduce отличается от классических одноименных функций высшего
порядка. Однако в данной работе будем использовать определение
предложенное авторами модели MapReduce, чтобы избежать путаницы.
В функциональном виде работу MapReduce системы можно записать в
виде композиции функций [153]:
mapReduce : (K1→V1→[(K2, V2)]) -- функция map
→(K2 → [V2] →V3) -- функция reduce
→ [(K1, V1)] -- набор пар входной ключ/значение
108
→ [(K2, V3)] -- набор пар выходной ключ/значение
mapReducemapreduce =
reducePerKeyreduce -- 3. Применяет функцию reduce к каждой группе
groupByKey -- 2. Группирует значения по промежуточному ключу
mapPerKeymap --1 Применяет функцию map к каждой паре
ключ/значение.
Традиционно модель MapReduce для анализа данных применяется для
параллельной обработки набора данных [155, 166]. Уточним функции map и
reduce для применения к модели знаний описанной выражением (2.4).
Первым входным аргументом функции map (значения V1) может быть
модель знаний mM, а в качестве второго аргумента (ключа K1) может
использоваться индекс iI обрабатываемого элемента модели знаний
(например, i для обработки элемента модели знаний m[i]). В этом случае при
выполнении функции map происходит обработка указанного элемента
модели знаний, в результате которой может изменяться в общем случае
несколько элементов модели знаний, которые могут быть заданы парой (I, E):
индекс изменяемого элемента I и изменяемый элемент модели знаний E.
Таким образом, функция map, применяемая к модели знаний M, может быть
определена следующим образом:
map: I→ M → [(I, E)] .
В этом случае, пользовательская функция map может быть реализована
вызовом функции цикла, который выполняет ФОМ ft для обработки элемента
модели знаний с индексом i:
map i m = pair (loope s 1 i ft) m,
где pair – функция, которая преобразует каждый элемент списка в пару
индекс/элемент:
109
pair: M → [(I, E)]
pair m = [(1, m[1]), (2, m[2]),…, (w, m[w])] .
Функция reduce, для применения к модели знаний M, в качестве
первого аргумента (ключа K2) может принимать индекс элемента модели
знаний I, а в качестве второго аргумента (массива значений [V2]) список
элементов модели знаний [E] соответствующих данному индексу. Она
выполняет объединение элементов моделей знаний с одинаковыми
индексами, но включенных в модели знаний, построенных параллельно.
Результатом функции reduce (значение V3) будет объединенный элемент
модели знаний E. Таким образом, функция reduce, уточненная для анализа
данных, может быть определена следующим образом:
reduce: I → [E] → E.
Таким образом, пользовательская функция reduce может быть
реализована вызовом функции union (2.9), которая выполняет объединение
нескольких элементов моделей знаний.
reduce i [m[i], m1[i], …, mr[i]] = union m[i] [m1[i], …, mr[i]] .
Определив функции map и reduce, рассмотрим выполнение функции
mapReduce, например, для обработки атрибутов включенных в модель
знаний:
mapReduce map reduce [([0,1], m), ([0,2], m), …, ([0,p], m)] .
Функция mapPerKey применяет функцию map к каждой паре
переданного набора пар индекс/элемент модели знаний. Таким образом,
выполнение функции дает следующий результат:
mapPerKeymap [([0,1], m), …, ([0,r], m), …, ([0,p], m)] =
[([0], m1[0]),…,([w], m1[w]),…,
([0], m1[0]),…,([w], mr[w]),…,
([0], mp[0]),…,([w], mp[w])], где
110
[mr[0]… mr[w]] все элементы модели знаний, измененные функцией
map [[0,r], m], которая вызывается функцией mapPerKey.
Функция groupByKey принимает набор промежуточных пар и
группирует их по индексу:
groupByKey [([0], m1[0]),…,([w], m1[w]),… ([0], mp[0]),…,([w], mp[w])]=
[([0], [m1[0],…, mp[0]]),…, ([w], [m1[w],…,mp[w])].
Функция reducePerKey применяет функцию reduce к каждой группе
полученной от groupByKey. Таким образом, выполнение функции
reducePerKey применительно к полученным результатам будет следующее:
reducePerKey reduce [([0], [m1[0], …, mp[0]]),…, ([w], [m1[w], …, mp[w])] =
[reduce ([0], [m1[1],…, mp[w]]),…, reduce ([w], [m1[w], …, mp[w])] =
[union m[0] [m1[0], …, mp[0]], …, union m[w] [m1[w], …, mp[w]]] =
[m[1], …, m[w]].
Такой же результат можно получить, применив функцию parallel (3.1) к
функции цикла по элементам модели знаний loope (2.22):
parallel [loope [0] ft] m = parallel [(loope 1 1 [0] ft), …, (loope p 1 [0] ft)] m =
join m (fork [(loope 1 1 [0] ft) , …, (loope p 1 [0] ft)] m) =
join m ([(loope 1 1 [0] ft) , …, (loope p 1 [0] ft)]) = join m [m1, …,mp] =
[union m[0] [m1[0], …, mp[0]], …, union m[w] [m1[w], …, mp[w]]] =
[m[1],…, m[w]].
В обоих случаях мы получаем список объединенных элементов
моделей знаний измененных функциями (loope 1 1 [0] ft) , …, (loope p 1 [0] ft).
Следовательно, в обоих списках будут получены идентичные элементы
моделей знаний. Таким образом, функция mapReduce является частным
случаем функции parallel примененной для распараллеливания циклов.
111
3.1.3 Оптимальное число параллельных композиций функций обработки
модели знаний
В выражении (3.1) функция parallel параллельно выполняет только
ФОМ. При работе с распределенной памятью функции clone (2.7) и union
(2.9) для каждого ФОМ выполняются последовательно (Рисунок 3.2.). Таким
образом, время выполнения определяется для:
функции parallels как:
τ(parallels) = τ(head) + τ(fork) + maxi=r..s τ(fi);
функции paralleld как:
τ(parallels) = τ(head)+τ(fork)+ ( (clone) (union))s
r
+maxi=r..s τ(fi).
При этом ускорение (Sp) будет достигаться при следующем условии
для:
функции parallels:
Sp =
s
i
i=r
i=r..s i
τ(f )
τ(head)+τ(fork)+max τ(f )
>1;
функции paralleld:
Sp =
s
i
i=r
s
i=r..s i
i=r
τ(f )
τ(fork)+ (τ(clone)+τ(union))+max τ(f )
>1.
112
Введем коэффициент распараллеливания (КР), определяющийся
отношением суммарного времени выполнения операций clone и union и
среднего времени выполнения параллельной ФОМ:
parallel
(clone) (union)k
(f )r
. (3.3)
Используя введенный коэффициент для систем с распределенной
памятью, получим:
..
....
(f )max (f )
( 1) max (f ) ( 1)( (f )) max (f )
s
i
i r i r s ip s
parallel i r s i parallelparallel i i r s i
i r
k kS
k k k kk
,г
де
k = s-r - количество параллельных ФОМ.
Отсюда следует, что ускорение Sp > 1 при распараллеливании в
системах с распределенной памятью будет достигаться только при условии:
1parallel
kk
k
.
Если суммарное время выполнения функций clone и union сравнимо со
средним временем выполнения параллельных ФОМ (kparallel=1), то
параллельное выполнение не эффективно.
При большом числе параллельно выполняющихся ФОМ k >> 1
(характерном при распараллеливании по данным), можно считать, что
ускорение Sp > 1 будет достигаться при условии kparallel < 1. Следовательно,
при распараллеливании по данным необходимо, чтобы время выполнения
параллельно выполняющейся ФОМ было больше суммарного времени
выполнения функций clone и union. В случае распараллеливания простых
(выполняющих элементарные действия) ФОМ fr данное условие может быть
достигнуто за счет их композиции.
113
Для определения оптимального числа параллельных композиций ФОМ
qf, вычислим ускорение Sp функции parallel выполняющей
распараллеливание по данным в распределенной памяти c их учетом:
2( )( )
p
parallelparallel
k q kS
k q k kq k
q
.
Таким образом, для получения ускорения (Sp > 1) при параллельном
выполнении q композиций ФОМ, должно выполняться следующее
неравенство:
2 0parallelq k q k k .
Для определения q найдем минимум данной функции, для чего
дифференцируем ее и определим критические точки:
2 02
parallel
parallel
kq k k q
k
.
Таким образом, при близости суммарного времени выполнения
операций clone (2.7) и union (2.9) к среднему времени выполнения
параллельной ФОМ (kparallel ≈ 1) теоретически в композиции должны
объединяться пары смежных ФОМ (q = k/2).
Для систем с общей памятью, в связи с отсутствием выполнения
функций clone (2.7) и union (2.9) (Рисунок 3.3) КР kparallel (3.3) равен нулю
(kparallel= 0). Следовательно, в системах с общей памятью ОЧПК ФОМ q
может быть максимально большим и равным числу параллельно
выполняющихся ФОМ k.
Таким образом, отсутствие необходимости выполнения функций clone
(2.7) и union (2.9) существенно повышает эффективность распараллеливания,
однако накладывает дополнительные ограничения на условия параллельного
114
выполнения. Рассмотрим условия возможности параллельного выполнения
ФОM более подробно.
3.2 Условия параллельного выполнения функций обработки модели
знаний
3.2.1 Условия Бернстайна для алгоритмов анализа данных
Для корректного выполнения параллельных ФОМ недостаточно
выполнить декомпозицию алгоритма. Необходимо также определить какие
функции могут выполняться параллельно корректно. Корректность
подразумевает одинаковый результат для последовательного выполнения и
для параллельного. Возможность параллельного выполнения определяется
исходя из информационных связей между ФОМ.
Из теории анализа информационных зависимостей известны условия
Бернстайна [213], для параллельно выполняющихся операторов в
программах для ЭВМ. По аналогии с ними можно сформулировать условия
для ФОМ.
Две следующих друг за другом ФОМ fr и fr+1 могут быть выполнены
параллельно, если для них выполняются следующие условия:
отсутствие антизависимости (data anti- dependency):
AD = In(fr) Out(fr+1) = ;
отсутствие потоковой зависимости (data flow dependency):
FD = Out(fr) In(fr+1)= ;
отсутствие зависимости по выходу (output dependency):
OD = Out(fr) Out(fr+1) = .
115
Условия Бернстайна являются достаточными, но не необходимыми.
Кроме того, для параллельного выполнения эти условия могут отличаться
при использовании общей и распределенной памяти.
3.2.2 Условия параллельного выполнения при использовании общей памяти
При параллельном выполнении, с использованием общей памяти, ФОМ
fr и fr+1 строят общую модель знаний. Следовательно, существует
вероятность, что fr+1 изменит модель знаний до выполнения fr. Корректность
параллельного выполнения ФОМ fr и fr+1 определяется равенством:
fr+2fr+1fr mr-1 = fr+2frfr+1 mr-1.
Для уточнения условий Бернстайна, определим понятие
ассоциативности операций.
Определение. Две операции, изменяющие свойства элементов модели
знаний, являются ассоциативными, если порядок их выполнения не имеет
значения:
op+1op = opop+1
Примерами таких операций являются: суммирование, вычитание,
инкрементация и т.п. Операции, меняющие состав модели знаний:
добавление или удаление элементов, не являются ассоциативными.
Сформулируем условия для параллельного выполнения ФОМ с
использованием общей памяти.
Утверждение. Если для ФОМ fr и fr+1 множества AD, FD и OD пустые
(AD=FD=OD = ) или содержат одни и те же элементы модели знаний
(AD=FD=OD ≠ m) над свойствами, которых выполняются только
ассоциативные операции, то параллельное выполнение fr и fr+1 возможно с
использованием общей памяти.
Доказательство. При параллельном выполнении ФОМ fr и fr+1
применительно к модели знаний m, хранящейся в общей памяти, имеем:
116
In(fr) m и Out(fr) m,
In(fr+1) m и Out(fr+1) m.
Следовательно, при условии AD ≠ и выполнении fr+1 до fr, элемент
модели знаний e AD m измененный какой-либо операцией or+1
q fr+1
будет использоваться fr при выполнении. Таким образом, результат
выполнения fr может быть неверным. Однако, если операция orp fr
использует и изменяет один тот же элемент модели знаний e (т.е. e AD
Out(fr)), то меняться будет только он. При этом, если порядок выполнения
операций не имеет значения (операции ассоциативны):
orp o
r+1q = o
r+1qo
rp,
то и итоговый результат изменений элемента e будет одинаковым при любом
порядке выполнении этих операций.
При условии FD ≠ и выполнении fr+1 до fr, элемент модели знаний e
m FD используемый операцией or+1
q fr+1 еще не будет изменен fr. Таким
образом, результат выполнения fr+1 может быть неверным. Однако, если
какая-либо операция orp fr использует и изменяет тот же элемент модели
знаний e (т.е. e FD Out(fr)), то при последующем выполнении fr элемент e
будет изменен еще раз. При этом, если порядок выполнения операций не
имеет значения (операции ассоциативны):
orp o
r+1q = o
r+1qo
rp,
то и итоговый результат изменений элемента e будет одинаковым.
Таким образом, объединив получившиеся множества и их отношения
друг с другом:
In(fr) Out(fr+1) Out(fr) и Out(fr) In(fr+1) Out(fr),
получим, что для возможности параллельного выполнения ФОМ fr и fr+1 при
непустых множествах AD, FD и OD необходимо, чтобы они содержали
одинаковые элементы модели знаний:
117
In(fr) Out(fr+1) Out(fr) In(fr+1)=
In(fr) Out(fr+1) =Out(fr) In(fr+1) = Out(fr) Out(fr+1) = AD=FD=OD,
над которыми должны выполняться только ассоциативные операции из
состава fr и fr+1.
3.2.3 Условия параллельного выполнения при использовании распределенной
памяти
При параллельном выполнении, с использованием распределенной
памяти, ФОМ fr и fr+1 независимо строят разные экземпляры модели знаний
(mr и mr+1 соответственно), получая на вход модель знаний mr-1, построенную
предыдущей ФОМ (Рисунок 3.2). При этом в отличие от последовательного
выполнения, на вход функции fr+1 будет поступать модель знаний mr-1,
построенная функцией fr-1, а не функцией fr. Итоговая модель знаний mr+1
строится путем объединения функцией join моделей знаний построенных fr и
fr+1 в распределенной памяти:
fr+1fr mr-1 = join mr-1 [(fr+1 mr-1), (fr mr-1)].
С учетом этого сформулируем условия для параллельного выполнения
ФОМ с распределенной памятью.
Утверждение. Если для ФОМ fr и fr+1 множества FD и OD пустые (FD
= OD ≠ ) или множество FD является подмножеством OD (FD OD ≠ )
ко всем элементам которого применяются только операции, изменяющие их
вычисляемые свойства, для которых существуют функции агрегирования ,
то параллельное выполнение fr и fr+1 возможно с использованием
распределенной памяти.
Доказательство. В случае последовательного выполнения ФОМ fr и fr+1
имеем:
In(fr) mr-1, Out(fr) и In(fr+1) mr и Out(f+1) mr+1.
118
В случае параллельного выполнения ФОМ fr и fr+1 при использовании
распределенной памяти имеем:
In(fr) и In(fr+1) mr-1, Out(fr) mr, Out(fr+1) mr+1.
Следовательно, при наличии антизависимости между ФОМ fr и fr+1:
AD = In(fr) Out(fr+1) ≠
измененные элементы модели знаний Out(fr+1) (даже в случае если fr+1 будет
выполнен до fr) никогда не будут использованы fr, (т.к. mr-1 ≠ mr+1) и
результат выполнения fr будет корректным. Таким образом, условие
антизависимости не является необходимым для параллельного выполнения
ФОМ с распределенной памятью.
Если присутствует потоковая зависимость:
FD = Out(fr) In(fr+1) ≠ ,
то при параллельном выполнении fr+1 в распределенной памяти она не
сможет использовать элементы модели знаний измененные fr. Следовательно,
результаты выполнения fr+1 могут быть неверными. Однако, в случае если
элементы множества FD изменяются обеими ФОМ (т.е. FD OD) то при
выполнении функции parallel с использованием распределенной памяти
получаем следующее выражение:
paralleld [fr, fr+1] mr-1 =
join mr-1 (fork [fr, fr+1] m) =
join mr-1[(run fr mr-1), (run fr+1 mr-1)] =
join mr-1[m’r,m’r+1] =
[mr-1[0],union mr-1[1] [mr[1], mr+1[1]],…,union mr-1[v] [mr[v], mr+1[v]]].
В соответствии с определением функции union (2.9), к общим
элементам будет применяться функция merge (2.8). Необходимым условием
выполнения функции merge является наличие для всех вычисляемых свойств
функции агрегирования . Таким образом, при FDOD≠, условие наличия
функции агрегирования для вычисляемых свойств изменяемых элементов
119
модели знаний является обязательным условием параллельного выполнения
ФОМ с использованием распределенной памяти.
Аналогичное условие предъявляется к элементам модели знаний
входящих в потоковую зависимость OD, т.к. они должны объединяться
функцией union (2.9) при выполнении функции parallel.
3.2.4 Метод проверки условий параллельного выполнения пары функций
обработки модели
Проверка условий для параллельного выполнения пары смежных ФОМ
fr и fr+1 осуществляется в следующем порядке:
1. проверяется наличие зависимости по выходу OD:
1.1. если зависимость по выход существует (OD ≠ ), то проверяются
множества FD и OD:
1.1.1. если множество OD включает множество FD (FD OD), то они
сравниваются с множеством AD:
1.1.1.1. если множества равны (FD = OD = AD), то проверяется
свойство ассоциативности у всех операций, выполняемых над
элементами модели знаний, входящих в эти множества:
1.1.1.1.1. если свойство ассоциативности есть у всех таких
операций, то ФОМ fr и fr+1 могут выполняться параллельно
с использованием общей памяти (функцией parallels);
1.1.1.2. если множества не совпадают FD ≠ OD ≠ AD, то
проверяется существование функции агрегирования для всех
элементов модели знаний множества OD, к которым
применяются только операции, изменяющие их вычисляемые
свойства:
1.1.1.2.1. если функции агрегирования существуют для всех
элементов модели знаний из множества OD, то ФОМ fr и
120
fr+1 могут выполняться параллельно с использованием
распределенной памяти (функцией paralleld);
1.1.1.2.2. если функции агрегирования существуют не для
всех элементов модели знаний множества OD, то ФОМ fr и
fr+1 не могут выполняться параллельно;
1.1.2. если множество OD не включает множество FD и они не пустые,
то ФОМ fr и fr+1 не могут выполняться параллельно;
1.2. если зависимости по выходу нет (OD = ), то проверяются остальные
множества:
1.2.1. если нет потоковой зависимости (FD = ), то проверить
антизависимость:
1.2.1.1. если антизависимости нет (AD = ), то ФОМ fr и fr+1 могут
выполняться параллельно с использованием общей памяти
(функцией parallels);
1.2.1.2. если антизависимости есть AD ≠ , то ФОМ fr и fr+1 могут
выполняться параллельно с использованием распределенной
памяти (функцией paralleld);
1.2.2. если потоковая зависимость есть FD ≠ , то ФОМ fr и fr+1 не
могут выполняться параллельно.
Псевдокод метода проверки условий параллельного выполнения ФОМ
приведен ниже.
121
verifyParallelize (fr, fr+1) - функция проверки возможности параллельного выполнения
функций алгоритма анализа данных
Вход: пара функций fr и fr+1 для которых выполняется распараллеливание
Выход: функция parallel если параллельное выполнение возможно и null иначе
verifyParallelize(fr, fr+1)
FD = Out(fr) In(fr+1); // множество элементов составляющих потоковую зависимость
AD = In(fr) Out(fr+1); // множество элементов составляющих антизависимость
OD = Out(fr) Out(fr+1); // множество элементов составляющих зависимость по выходу
if (OD ≠ ) // проверка наличия зависимости по выходу
if (FD OD)
if (FD = OD = AD)
for each e from FD // для каждого элемента модели знаний зависимости
if or+1
(or(e))≠o
r(o
r+1(e)) //проверить ассоциативность операций на нем
return null; // если не ассоциаивно, то распараллеливание невозможно
return parallels; // иначе возможно распараллеливание с общей памятью
else
for each e from OD // для каждого элемента модели знаний зависимости
if ! for e// проверить существование функции агрегирования
return null; // если не ассоциаивно, то распараллеливание невозможно
return parallels; // иначе возможно распараллеливание с общей памятью
else if (FD = )
if(AD = )
return parallels; // возможно распараллеливание с общей памятью
else
return paralleld; // возможно распараллеливание с распределенной памятью
else
return null; // иначе распараллеливание невозможно
122
3.2.5 Пример проверки условий параллельного выполнения алгоритма
анализа данных
Для алгоритма 1R и его ФОМ определим множества используемых In и
изменяемых Out элементов модели знаний. В качестве примера, определения
множеств используемых и изменяемых элементов модели знаний,
рассмотрим цикл по векторам fd2:
fd2 = loopd fd3.
Он итерационно вызывает ФОМ fd3 поэтому вначале определяем
множества используемых и изменяемых элементов модели знаний для fd3
выполняющую инкрементацию свойства элемента модели знаний m[3,k,q,p]:
In(fd3)={d[j, k], d[j, t], m[3,k,q,p]}
Out(fd3) = {m[3,k,q,p]} .
Цикл по векторам fd2 анализирует все вектора множества X,
следовательно, iIn(fd3) и iOut(fd3) потенциально включают в себя все
элементы модели знаний, содержащие информацию о количестве векторов
имеющих соответствующие значения независимого атрибутов ak и
зависимого атрибута at. Таким образом, для цикла по векторам fd2 множества
используемых и изменяемых элементов модели знаний будут включать в
себя следующие элементы:
In(fd2)={d[0,k], ..., d[z,k]; d[0,t], ..., d[z,t]; m[3,k]}
Out(fd2) ={m[3,k]}.
В таблице 3.1 приведены множества используемых и изменяемых
элементов модели знаний для всех ФОМ алгоритма 1R. Для удобства
дальнейшего анализа элементы множеств отсортированы в соответствии с их
индексами.
123
Таблица 3.1. Множества используемых и изменяемых элементов модели
знаний ФОМ алгоритма 1R
ФОМ In(fi) Out(fi)
f0 d m[0]
fd1 d, m[0], m[1], m[2], m[3] m[1], m[2], m[3]
fd2 d[0,k], ..., d[z,k]; d[0,t], ..., d[z,t];
m[3,k]
m[3,k]
fd3 d[j, k], d[j, t], m[3,k,q,p] m[3,k,q,p]
f4 m[0,k], m[0,t], m[3,k], m[2].n m[3,k,1].mi,…,m[3,k,u].mi,
m[2], m[2].n
f5 m[0,k,q], m[0,t], m[3,k,q’],
m[3,k,q’,p”]
m[3,k,q’].mi
f6 m[0,k,q], m[0,t,p], m[3,k,q’,p’],
m[3,k,q’,p”]
m[3,k,q’].mi
f8 m[0, k], m[0,k,q], m[3,k,q’],
m[3,k,q’].mi, m[3,k,q’,p”]
m[2]
f9 m[0,k,q], m[3, k, q’].mi,
m[3, k, q’,p”],
m[2].n
m[2].n
f10 m[1].n, m[2].n, m[1], m[2] m[1].n, m[1]
f11 m[2] m[2]
Применяя метод проверки условий параллельного выполнения для
каждой пары ФОМ алгоритма 1R, представленного выражением (2.25),
получим следующие возможности распараллеливания:
функции f0 и fd1 не могут выполняться параллельно, т.к. имеют
потоковую зависимость по элементу модели знаний m[0]:
Out(f0) In(fd1)= {m[0]} ≠ ,
над которым в них выполняются не ассоциативные по отношению друг
124
другу операции добавления и извлечения;
функции fd2 и f4 не могут выполняться параллельно, т.к. имеют
потоковую зависимость по элементу модели знаний m[3,k]:
Out(fd2) In(f4)= {m[3,k]} ≠ ;
над которым в них выполняются не ассоциативные по отношению друг
другу операции инкрементации и сравнения;
функции f4 и f10 не могут выполняться параллельно, т.к. имеют
потоковую зависимость по элементу модели знаний m[2]:
Out(f4) In(f10)= {m[2]} ≠ ,
над которым в них выполняются не ассоциативные по отношению друг
другу операции добавления и извлечения;
функции f10 и f11 могут выполняться параллельно только с
использованием распределенной памяти, т.к.:
o не имеют потоковой зависимости: Out(f10) In(f11)= и зависимости
по выходу: Out(f10) Out(f11) ≠ ;
o имеют антизависимость по элементу модели знаний m[2]:
In(f10) Out(f11) = {m[2]},
над которым в них выполняются не ассоциативные по отношению друг
другу операции удаления и извлечения;
функции f5 и f8 не могут выполняться параллельно, т.к. имеют
потоковую зависимость по свойству элемента модели знаний
m[3,k,q’].mi:
Out(f5) In(f8)= { m[3,k,q’].mi} ≠ ,
над которым в них выполняются не ассоциативные по отношению друг
другу операции поиска (присваивания индекса максимального элемента)
и чтения;
функции f8 и f9 могут выполняться параллельно, т.к.:
o не имеют потоковой зависимости: Out(f8) In(f9) = ;
125
o не имеют антизависимости: In(f8) Out(f9) = ;
o не имеет зависимости по выходу: Out(f8) Out(f9) = .
Возможности распараллеливания по данным для каждого цикла
следующие:
композиция функций f11f10f4fd2 для разных итераций k и k+1 не
может быть распараллелена по данным, т.к. имеется потоковая
зависимость по элементам модели знаний m[1] и m[2]:
Out (f11f10f4f2 для k) In (f11f10f4f2 для k+1) =
{m[1],m[2],m[3,k]}{d,m[0,k+1],m[1],m[2],m[3,k+1]}=
{m[1],m[2]}≠
над которыми в ней выполняются не ассоциативные по отношению друг
другу операции добавления, удаления и извлечения;
композиция функций f9f8f5 для разных итераций q и q+1 может быть
распараллелена по данным, т.к.:
o существует потоковая зависимость и антизависимость по элементу
m[2].n:
Out (f9f8f5 для q)In (f9f8f5 для q+1) =
{m[3,k,q’].mi,m[2], m[2].n}{m[0,k,q+1],m[0,t],m[3,k,q+1],m[2].n}=
{m[2].n} ≠ ,
In (f9f8f5 для q) Out (f9f8f5 для q+1) =
{m[0,k,q], m[0,t], m[3,k,q], m[2].n} {m[3,k,q’].mi, m[2], m[2].n}=
{m[2].n} ≠ ,
над которым выполняется ассоциативная операция инкрементации;
o имеется зависимость по выходу по элементу модели знаний m[2] и
m[2].n:
126
Out (f9f8f5 для q) Out (f9f8f5 для q+1) =
{ m[3,k,q’].mi, m[2], m[2].n } {m[3,k,q’].mi, m[2], m[2].n} =
{m[2], m[2].n } ≠ ,
над которым выполняется ассоциативная операция инкрементации и
для которого существует операции агрегирования - суммирование;
функция f6 для разных итераций p и p+1 не может быть распараллелена
по данным т.к.:
o нет потоковой зависимости:
Out (f6 для p) In (f6 для p+1) =
{m[3,k,q’].mi} {m[0,k,q], m[0,t,p+1], m[3,k,q’,p’], m[3,k,q’,p”]} = ;
o нет антизависимости:
In(f6 для p) Out(f6 для p+1) =
{m[0,k,q], m[0,t,p], m[3,k,q’,p’], m[3,k,q’,p”]} {m[3,k,q’].mi } = ;
o имеется зависимость по выходу по свойству элемента модели знаний
m[3,k,q’].mi:
Out(f6 для p) Out(f6 для p+1) ={m[3,k,q’].mi} {m[3,k,q’].mi} ≠
над которым выполняется не ассоциативная операция поиска
(присваивания индекса максимального элемента), а также
отсутствует функция агрегирования;
функция f3 для разных итераций j и j+1 может быть распараллелена по
данным, т.к.:
o нет потоковой зависимости:
Out (f3 для j) In (f3 для j+1) = {m[3,k,q,p]} { d[j+1, k], d[j+1, t]} = ;
o нет антизависимости:
In (f3 для j) Out (f3 для j+1) ={ d[j, k], d[j, t]} { m[3,k,q,p]} = ;
o имеется зависимость по выходу по элементу модели знаний
m[3,k,q,p]:
127
Out (f3 для j)Out (f3 для j+1) =
{m[3,k,q,p]} {m[3,k,q,p]} = {m[3,k,q,p]} ≠ ;
над которым выполняется ассоциативная операция инкрементации и
для которого существует операция агрегирования – суммирование.
Проведенный анализ условий параллельного выполнения ФОМ
алгоритма 1R, позволяет определить места и способы распараллеливания
алгоритма.
3.3 Распараллеливание последовательного алгоритма анализа данных
3.3.1 Метод распараллеливания последовательного алгоритма анализа данных
Алгоритм анализа данных, представленный в виде композиции ФОМ
(2.12), может быть преобразован в параллельную форму путем передачи в
качестве аргумента в функцию parallel (3.1) тех ФОМ, которые могут быть
выполнены параллельно в соответствии с вышеописанными условиями. В
общем случае в алгоритме анализа данных может быть несколько мест, в
которых ФОМ могут быть выполнены параллельно. Для определения всех
возможностей параллельного выполнения последовательного алгоритма
анализа данных, с учетом ОЧПК, предложен метод распараллеливания. Его
псевдокод приведен ниже.
128
Предложенный метод осуществляет обход дерева вложенности
алгоритма данных в ширину (breadth-first search, BFS) [358]. Для каждого
узла (ФОМ) дерева вложенности выполняется проверка возможности
параллельного выполнения в паре со смежным узлом (ФОМ,
выполняющейся последовательно с текущим). Проверка осуществляется с
помощью создаваемого кортежа pair (строка 4), который хранит пары
parallelize(f) - функция распараллеливания ААД.
Вход: последовательный алгоритм анализа данных f представленный функцией runf.
Выход: алгоритм анализа данных f со всеми возможными распараллеленными ФОМ.
parallelize(f)
1. pair = Ø // инициализация пары ФОМ
2. pt = null // функция распараллеливания parallel
3. for each fr from Φ(f) do // для каждого дочернего ФОМ f
4. добавить fr в pair // добавить анализируемый ФОМ в пару
5. if(|pair| == 2) // если пара сформирована
6. p = verifyParallelize(pair) // проверить условия для пары
7. if (p == null) // если параллельное выполнение невозможно
8. insertParallel(f, pt) // добавить ранее сформированную функцию parallel
9. pt = null // инициализировать функцию распараллеливания
10. else // если параллельное выполнение возможно
11. if (pt != null) // функция распараллеливания не пустая
12. добавить pair в pt // добавить пару ФОМ в функцию parallel
13. else // если функция распараллеливания пустая
14. pt = p // инициализировать ее полученной функцией
15. удалить fr-1 из pair // удалить 1ю ФОМ из пары
16. if (fr is loopef) // если проверяемый ФОМ - цикл loopef = loope is ie ft
17. pl = verifyParallelize(ft(m.curr= is), ft(m.curr= ie) ) // проверить итерации
18. if (pl != null) // если параллельное выполнение возможно
19. заменить fr на pl в f // заменить в композиции ФОМ на parallel
20. parallelize(fr) // выполнить распараллеливание для ФОМ
21. insertParallel(f, pt) // вставить в композицию функцию распараллеливания
insertParallel(f, p) – функция вставки в композицию ФОМ функции parallel.
Вход:f - композиция функции runf;
p - функция parallel
insertParallel(f, p)
if(p is not empty) // если функция parallel содержит распараллеливаемые ФОМ
if(τ(f) > (τ(clone) + τ(union))) // если параллельное выполнение оптимально
в f заменить (p) на p /// заменить ФОМ в композиции на функцию parallel
129
смежных узлов (последовательных ФОМ). Каждая пара проверяется на
возможность распараллеливания (строка 6). Если распараллеливание
возможно, то ФОМ добавляются в ранее созданную (строка 10) или во вновь
создаваемую функцию parallel (строка 14). Для созданной функции parallel
вычисляется КР kparallel. Если он меньше 1 то узлы дерева (ФОМ),
выполняемые параллельно, заменяются в родительском узле созданной
функцией parallel, иначе распараллеливание не выполняется. Далее
вычисляется ОЧПК q. Все ФОМ группируются в q композиций.
Если текущий узел дерева (ФОМ) является циклом (строка 17), то
проверяется возможность параллельного выполнения функции loope,
применяемой к разным элементам модели знаний (строка 18). Если
параллельное выполнение ФОМ возможно, то создается функция parallel для
loope. Текущий узел заменяется в родительском узле созданной функцией
parallel.
3.3.2 Пример распараллеливания алгоритма анализа данных
В соответствии с предложенным методом выполним
распараллеливание алгоритма анализа данных 1R. Последовательное
представление алгоритма 1R (2.24) преобразуется к параллельной форме с
помощью вставки функции parallel. Места вставки определяются на
основании проверки условий параллельного выполнения ФОМ. Для
алгоритма 1R такой анализ описан в разделе 3.2.5. В результате выявлены
следующие потенциальные места распараллеливания:
распараллеливание цикла по векторам fd2 с использованием общей памяти:
parallels [loopd fd3];
распараллеливание цикла по значениям атрибутов f5 с использованием
общей памяти:
parallels [loope [0, k] f5];
130
распараллеливание добавления правила для максимального количества
корректных векторов f8 и подсчета корректных векторов для одного
атрибута ak f9 с использованием общей памяти:
parallels [f8 f9];
распараллеливание добавления правила для максимального количества
корректных векторов f8 и подсчета корректных векторов для одного
атрибута ak f9 с использованием только распределенной памяти:
paralleld [f10 f13].
Необходимо заметить, что вариант распараллеливания цикла по
векторам loopd является традиционным распараллеливанием с помощью
модели MapReduce. Вариант распараллеливания цикла по значениям
атрибутов может быть также реализован с помощью модели MapReduce если
ее применить не к векторам набора данных, а к значениям атрибутов.
Вариант распараллеливания двух ФОМ не реализуем моделью MapReduce,
так как осуществляет распараллеливание по задачам.
Учитывая, что распараллеливание циклов выполняется для общей
памяти, то теоретически ОЧПК q может быть равно числу итераций. Также
распараллеливание f8 и f9 выполняется для общей памяти, следовательно,
параллельное выполнение по одному ФОМ, также может дать ускорение.
В то же время, распараллеливание f10 и f13 не имеет смысла, т.к. оно
может выполняться только с использованием распределенной памяти. В этом
случае среднее время выполнения ФОМ сравнимо с временем выполнения
функций clone (2.7) и union (2.9). Следовательно, их распараллеливание не
имеет смысл т.к. kparallel = 1.
Комбинирование всех возможных вариантов параллельного
выполнения, позволяет получить следующий параллельный вариант
алгоритма 1R:
131
1RPar = (loop [0] f13f10(parallels [loop [0,k] (parallels [f8, f9])
(loop [0,t] f6))
(parallels [loopd fd3]))f0.
(3.4)
Необходимо заметить, что такое комбинирование не осуществимо
моделью MapReduce. На рисунке 3.5 изображено дерево вложенности
параллельного алгоритма 1R.
Рисунок 3.5 – Дерево вложенности параллельного алгоритма 1R.
f0
run[f0, fd1]
loope [0] f13f10parallelsparallels
loopd fd3
loope [0, k] f9f8f5
fd3
f6
loope [0, t] f6
f8 f9
f10 f13 parallels fd2 parallels f4
parallels [f8, f9]
132
Выводы
Для распараллеливания алгоритмов анализа данных, представленных в
виде композиции ФОМ:
1) предложена модель параллельного алгоритма анализа данных, которая
позволяет выполнять распараллеливание с использованием как общей, так
и распределенной памяти и является более общим случаем модели
MapReduce и в отличие от нее:
a. позволяет выполнять распараллеливание, как по данным, так и по
задачам;
b. позволяет выполнять распараллеливание в нескольких местах
алгоритма;
c. не требует реструктуризации алгоритма и выполнения двух
функций map и reduce;
d. позволяет использовать преимущества общей памяти для
построения общей модели знаний без необходимости ее
клонирования и объединения.
2) определены условия параллельного выполнения ФОМ с использованием
как общей, так и разделенной памяти;
3) предложен метод распараллеливания последовательного алгоритма
анализа данных, как по задачам, так и по данным, учитывающий
оптимальное число параллельных композиций ФОМ, для использования
как общей, так и разделенной памяти.
133
4. Размещение алгоритма анализа данных в заданной среде
Для выполнения параллельного алгоритма он должен быть размещен в
среде, поддерживающей параллельные вычисления. Разделяют параллельные
среды, включающие в себя несколько параллельных потоков, работающих с
общей памятью и распределенные среды, включающие отдельные
вычислительные узлы, каждый из которых имеет собственную память и
взаимодействующие друг с другом посредством коммуникационных каналов.
Особенностью размещения в них алгоритмов анализа данных является
необходимость учитывать способ организации источников информации в
среде выполнения: централизованный или распределенный. В случае
распределенного источника необходимо также учитывать тип распределения
данных: горизонтальное или вертикальное распределение. Это влияет как на
структуру параллельного алгоритма, так и на его оптимальное размещение в
вычислительной среде.
В задаче размещения параллельных ветвей алгоритма в параллельной
среде, алгоритм и среда представляются в виде графов. В результате задача
размещения сводится к задаче отображения узлов одного графа на узлы
другого графа. Такая задача является NP полной задачей и не имеет
оптимального решения за конечное время. Для ее решения используются
различные эвристики.
В данной главе описывается метод размещения ФОМ алгоритмов
анализа данных, использующий ряд эвристик. Он оптимизирует время
выполнения алгоритма анализа данных и сетевой трафик, с учетом способа
хранения данных. Также в главе описывается методика построения
параллельных алгоритмов анализа данных, использующая предложенные
модели и методы.
134
4.1 Среда выполнения алгоритма анализа данных
4.1.1 Формальное представление среды выполнения алгоритма анализа
данных
Среду выполнения алгоритмов анализа данных можно представить в
виде направленного графа (Рисунок 4.1):
GN = <N, E>, где (4.1)
Е – множество дуг, соединяющие вершины и соответствующие
средствам передачи данных (СПД) между узлами;
N – множество вершин графа, соответствующие распределенным
узлам, которые в зависимости от места хранения анализируемых
данных можно разделить на два подмножества:
N = NsN
c, где
NsN - узлы источники, которые хранят анализируемые данные:
Ns = {n
s1, n
s2, …, n
sh, …, n
sw};
NcN - вычислительные узлы на которых только выполняется
анализ данных:
Nc = {n
сw+1, n
сw+2, …, n
сy, …, n
сv}.
Рисунок 4.1 – Физическая среда выполнения алгоритмов анализа данных.
ns1
d1
ncw+1
Узлы источники данных Вычислительные узлы
δ(e11)
δ(e1y)
δ(eh1)
δ(ew1)
δ(e1v)
δ(ehy)
δ(ehv) δ(ewy)
δ(ewv)
t11 t
11 t11 t1
s
t11 t
11 t11 t1
s
ncy t
y1 t
y1 ty1 tys
ncv t
v1 t
v1 tv1 tvs
nsh
dh
th1 t
h1 th1 th
s
nsw
dw
tw
1 tw
1 tw
1 tw
s
δ(eyv)
δ(ew+1y)
δ(ew+1v) δ(e1w)
δ(e1h)
δ(ehw)
135
Учитывая, что узлы среды выполнения могут быть
многопроцессорными (многоядерными), на них может выполняться
несколько потоков. Следовательно, любой узел ni N можно представить как
множество процессоров:
ni = {ti1, t
i2, …, t
ie, …, t
iz}.
Каждая дуга представляет собой кортеж:
ehy = <nh, ny, αhy, βhy>, где (4.2)
nhN - исходная вершина дуги;
nyN – входная вершина дуги;
αhy - латентность канала связи между узлами nh и ny;
βhy – пропускная способность канала связи между узлами nh и ny.
Таким образом, время передачи τ сообщения m размером υ(m) по
каналу связи между узлами nh и ny можно вычислить с помощью модели
Хокни (R.Hochney) [359]:
τhy(m) = αhy + υ(m)/ βhy.
C учетом этого, длину дуги ehy будем вычислять как время передачи
сообщения объемом 1 (υ(m) = 1) между узлами nh и ny:
δ(ehy) = αhy + 1/ βhy. (4.3)
4.1.2 Типы сред выполнения алгоритма анализа данных
Среда, в которой выполняется анализ данных, должна иметь минимум
один узел - источник:
|Ns| ≥ 1.
В зависимости от способа хранения данных можно выделить:
среды с централизованным хранением данных:
a. сильно-связанная среда;
b. слабосвязанная среда;
среды с распределенным хранением данных:
136
a. вертикальным распределением;
b. горизонтальным распределением.
При централизованном хранении данных среда имеет один узел
хранения |Ns| = 1. В зависимости от количества вычислительных узлов среды
можно разделить на [17]:
сильно связанную среду с одним вычислительным узлом, который
является узлом-источником |Nс| = |N
s| = |N| = 1 и в котором
процессоры интегрированы высокоскоростными каналами ehy=0
(например: многоядерные или многопроцессорные системы) и
имеют общую память;
распределенную среду с несколькими вычислительными узлами
|Nс| > 1, в которой вычислительные узлы соединены каналами связи,
имеющими ограниченную пропускную способность вносящую
задержку в их взаимодействие ehy>0 (например, сеть
вычислительных узлов).
Примером сильно связанной среды является многоядерные или
многопроцессорные компьютеры, на которых возможно параллельное
выполнение программ.
Примером слабосвязанной среды с централизованным хранением
данных является облачная среда, в которой хранятся данные и которая
предоставляет масштабируемые вычислительные ресурсы для их анализа.
При распределенном хранении данных среда включает в себя
несколько узлов-источников |Ns| > 1. Примером такой среды могут быть
системы Интернета вещей, в которых узлами источниками являются датчики
или другие источники информации. Вычислительными узлами при этом
могут быть как серверы кластера (облака) на которых выполняется анализ
данных, так и промежуточные узлы среды, к которым подключены
источники (в соответствии с технологией туманных вычислений).
137
При распределенном хранении данные, разделенные между узлами-
источниками, представляют собой части матрицы данных d:
d = d1 d2 … dh dw, где
подматрица данных dh размещается на узле источнике nsh.
Необходимо учитывать, что от типа распределения данных зависит не
только способ распараллеливании, но и структура алгоритма, т.к. внешним
циклом должен быть цикл по элементам, которые распределяются по узлам-
источникам (цикл по атрибутам при вертикальном распределении и цикл по
векторам при горизонтальном распределении).
4.2 Модель исполнителей функции обработки модели
4.2.1 Исполнитель композиции функций обработки модели
В параллельных и распределенных средах используется
промежуточное программное обеспечение (midlleware), которое скрывает от
разработчика сложности выполнения и взаимодействия в конкретной
физической среде. Введем понятия исполнителя.
Определение. Исполнитель ФОМ (далее исполнитель) – средство,
обеспечивающее последовательное выполнение композиции ФОМ в заданной
среде выполнения.
В соответствие с определением, работу исполнителя можно описать
следующей функцией высшего порядка:
exec: [M M] M M
exec [fr,…, fs] m = run [fr,…, fs] m. (4.4)
Функция exec принимает список ФОМ, которые должны быть
выполнены последовательно и модель знаний. Для выполнения
последовательности ФОМ используется функция run (2.16). Результатом
выполнения функции exec является измененная модель знаний.
138
Если исполнитель содержит хотя бы одну ФОМ, который использует
набор данных (2.15), то функция такого исполнителя будет иметь вид:
exec: D [M M] M M
exec [fr, …, fs] d m = run [fr, …, fs] d m.
Такой исполнитель будем называть обработчиком.
Исполнитель, не содержащий в своем составе ФОМ типа (2.15) назовем
анализатором. Соответствующая ему функция exec будет иметь вид (4.4)
При частичном применении функции exec с фиксацией первых
параметров:
4) функция анализатора примет вид:
execf: MM
execf= run [fr, …, fs];
5) функция обработчика примет вид:
execdf: M M
execdf = run [fr, …,fs] d.
Основным условием реализации исполнителя является обеспечение:
приема модели знаний;
передачи модели знаний;
выполнение функции run.
Далее рассмотрим средства реализации исполнителей, как для
отдельного узла, так и для отдельного процессора.
4.2.3 Метод построения дерева исполнителей
Множество исполнителей для алгоритма анализа данных можно также
представить в виде связанного ациклического графа – дерева исполнителей:
GH = <H, E
H>, где (4.5)
139
H – множество всех исполнителей выполняющих композиции ФОМ
алгоритма анализа данных:
H = {h0, h1, …, hi, …, hg}, где
hi – исполнитель, который включает в себя множество ФОМ
{fr,…,fs} составляющих композицию fs…fr:
hi = {fr,…, fs}
hi exec [fr,…, fs];
EH – дуги, описывающие взаимодействие (вызовы, подчинение) между
исполнителями:
EH = {(hi, hq) | hiH, hqH}.
В соответствии с определением исполнителя, он должен включать в
себя композицию ФОМ. При этом необходиом учитывать, что на этапе
выполнения алгоритма анализа данных функции, реализующие структурные
операторы алгоритма dec (2.17) и loop (2.20) заменяются композициями
ФОМ, передаваемыми им в виде аргументов. Функция условного
выполнения dec (2.17) заменяется на ФОМ, выполняющуюся в зависимости
от результата функции c. Функция цикла loop (2.20) заменяется композицией
вызовов итерационной ФОМ ft (2.20). Однако, функция parallel (3.1), не
может быть заменена на одну ФОМ, т.к. выполняет все ФОМ передаваемые
ей в списке.
Таким образом, на этапе выполнения алгоритм анализа данных может
быть представлен:
одной композицией ФОМ (соответствующей основной
последовательности) для выполнения которой должен быть создан
единственный исполнитель при последовательной структуре;
несколькими композициями ФОМ (соответствующими основной
последовательности и последовательностям, выполняющимся
140
параллельно функциями parallel), для выполнения которых должны быть
созданы несколько исполнителей при параллельной структуре,.
Псевдокод метода построения дерева исполнителей, приведен ниже.
С учетом этого, для построения дерева исполнителей по дереву
вложенности алгоритма анализа данных необходимо создать исполнителя
для основной последовательности h0. Далее для каждой функции parallel
(3.1), создать исполнителя hi для ФОМ – аргумента этой функции.
Выполнение параллельного алгоритма анализа данных с
использованием исполнителей будет выглядеть, так как это представлено на
Рисунок 4.2 (а – для функции parallels; б – для функции paralleld).
createExecutorTree (f) - функция построения дерева исполнителей.
Вход: алгоритм анализа данных представленный в виде композиции ФОМ.
Выход: корень дерева исполнителей GH.
createExecutorTree(f)
1. h.execH // создать первого исполнителя (корень дерева исполнителей)
2. fullExecutor(h, f) // добавить в исполнителя ФОМ алгоритма
3. return h // вернуть корень дерева исполнителей
fullExecutor(h, f) - функция наполнения исполнителя.
Вход: f - ФОМ которая добавляется в исполнителя h;
h – исполнитель который наполняется.
fullExecutor(h, f)
1. for each fr from Φ(f) do // для каждой ФОМ
2. if (fr is (D M M)) // ФОМ fr обрабатывающая
3. h.exec = execd // исполнитель будет обработчик
4. if (fr is parallel)
5. for each fq from Φ(fr) do // для каждой параллельно выполняющейся ФОМ
6. hq.execH // создать нового исполнителя
7. (h, hq) EH // создать связь между исполнителями
8. fullExecutor(hq, fq) // добавить в исполнителя ФОМ
9. else
10. fullExecutor(h, fr) // добавить в исполнителя ФОМ
11. return h
141
Рисунок 4.2 – Параллельное выполнение алгоритма анализа данных на
исполнителях (а – для функции parallels; б – для функции paralleld).
Таким образом, все множество H можно разбить на подмножества
исполнителей, вызываемых из функций parallel и исполнителя h0,
создаваемого для основной последовательности:
H = h0 H1 … H
k … H
g, где
Hk – подмножество исполнителей, вызываемых из одной функции parallel.
Учитывая, что исполнитель выполняет ФОМ последовательно, время
его работы можно определить как сумму выполнения каждого ФОМ:
( ) ( )s
i t
t r
h f
.
Время выполнения каждого подмножества исполнителей определяется
временем выполнения наиболее долгого исполнителя:
τ(Hk) =
0...|H |max (h )k ii
, где hi Hk. (4.6)
hk
h1
h0 paralleld
f0 fork
fr
)
join
fn d
m0 mr-1
mr-1
mn-
1
ms mn
fs
mr-1
m’s
m’s
clone clone union union
б)
hk
h1
h0
parallels f0 fork
fr
fn d m0 mi-1
mr-1
mn-1 ms mn
fs
)
ms
а)
head
142
Время выполнения всего алгоритма анализа данных (дерева
исполнителей):
τ(f) = τ(h0) + 0...|H |
1
max (h )k
g
iik
, где hi Hk. (4.7)
Данное выражение верно, для последовательно выполняющихся
подмножеств исполнителей. Поэтому исполнители, которые могут
выполняться параллельно, должны объединяться в одно подмножество.
Например, исполнители hi+3, hi+4, и hi+5, hi+6, имеющих общих родителей hi+1, и
hi+2, которые вызываются одной функцией parallel из исполнителя hi (Рисунок
4.3). В этом случае, такие исполнители должны быть объединены в одно
подмножество.
Рисунок 4.3 – Объединение подмножеств исполнителей.
Также необходимо заметить, что до выполнения алгоритма анализа
данных, количество ФОМ, выполняющихся параллельно функцией parallel,
примененной к функции цикла loope (2.22) неизвестно. Это связанно с тем,
что число итераций у данной функции (число элементов модели знаний,
которые обрабатываются в цикле) становится известно только на этапе
выполнения цикла. Таким образом, для ФОМ, распараллеленных по данным,
на этапе инициализации будет создан только один исполнитель, который
будет клонирован на этапе выполнения.
Hf+1
Hf+2
Hf
hi+2 hi+1
hi
parallel parallel
parallel
hi+4 hi+3 hi+6 hi+5
143
Для описания возможностей параллельного выполнения исполнителей
введем понятие потенциал параллелизации, определяющий максимальное
число параллельно выполняющихся исполнителей.
Определение. Потенциал параллелизации (ПП) исполнителя ρ(hi) –
максимально возможное количество параллельно выполняющихся
исполнителей в поддереве, корнем которого он является:
ρ(hi)=
1
1
1,если
g,если
(h ), , h , , h
i
i
q
i p i i i q
p
h лист и не выполняет цикл
h лист и выполняет цикл по g элементам
если h узел дерева а его потомки
(4.8)
4.2.5 Пример модели исполнителей для алгоритма анализа данных
Рассмотрим построение дерева исполнителей для алгоритма 1R
представленного выражением (3.4). В соответствии с описанным методом
построения дерева исполнителей (функция createExecutorTree) для основной
последовательности создается исполнитель h0, являющийся корнем дерева
(Рисунок 4.4). В него включаются ФОМ основной последовательности
(функцией fullExecutor) композиции параллельного алгоритма 1R (3.4):
h0 = {f0, loope [0], f10, f13, parallels fd2, parallels f4}.
В результате включения в него обрабатывающей ФОМ fd1 исполнитель
h0 является обработчиком h0.execd.
Так как исполнитель h0 включает в себя функции parallels fd2 и parallels
f4, то для ФОМ, которые вызываются ими параллельно, создаются
исполнители рекурсивным вызовом функции fullExecutor:
h1 = {loopd fd3}, h2 = {loope [0, k], loope [0, t] f6, parallels [f8, f9]}
Исполнитель h1 является обработчиком, т.к. включает в себя
обрабатывающую ФОМ fd3. Перечисленные исполнители являются
дочерними узлами исполнителя h0. Кроме того исполнитель h2 также
144
содержит ФОМ parallels, а следовательно для его ФОМ-аргументов
создаются отельные исполнители рекурсивным вызовом функции
fullExecutor:
h3 = {f8}, h4 = {f9}
Рисунок 4.4 – Дерево исполнителей для параллельного алгоритма 1R.
Исполнители h1 и h2 включают в себя поддеревья с корневой ФОМ,
являющейся циклом. Следовательно, при выполнении алгоритма анализа
данных они могут быть растиражированы по количеству обрабатываемых
элементов модели знаний.
Исполнители h1, h2, h3 и h4 вызываются из функции для систем с общей
памятью parallels. Следовательно, они могут выполняться в системах с общей
памятью.
Все множество исполнителей можно разбить на три подмножества, в
соответствии с их вызовами из функций parallel следующим образом:
H = h0 H1 H
2 H
3, где H
1 = {h1}; H
2 = {h2}; H
3 = {h3, h4}.
Построенные исполнители имеют следующие ПП:
h4 h3
h2 h1
h0
f0
run[f0, fd1]
loope [0] f13f10parallelsparallels
loopd fd3
loopE [0, k] f9f8f5
fd3
f6
loopE [0, t] f6
f8 f9
f10 f13 parallels fd2 parallels f4
parallels [f8, f9]
145
ρ(h3) = ρ(h4) = 1; ρ(h2) = k·(ρ(h3) + ρ(h4))=2·k; ρ(h1) = z; ρ(h0) = z + 2·k.
4.3. Метод размещения функций алгоритма анализа данных в среде
выполнения
4.3.1 Постановка задачи
Исходными данными для размещения алгоритма анализа данных
являются граф исполнителей GH и граф среды выполнении G
N.
Существует множество вариантов размещения исполнителей (вершин
H графа GH) на вычислительных узлах (вершин N графа G
N). Введем
функцию размещения исполнителей в среде выполнения:
deploy: H × N → L, где
L – множество вариантов (конфигураций) размещения исполнителей на
вычислительных узлах:
L = {l1, l2,…, lb, …,lz}, где
lb – конфигурация, описывающая размещение всех исполнителей из
множества H на узлах выполнения множества N:
lb = {(nh, hi) | nh, hiH}.
В зависимости от выбранной конфигурации lb, изменяется:
время выполнения анализа данных T(lb);
сетевой трафик - объем пересылаемых данных (наборов данных и
моделей знаний) между узлами среды - Ѵ(lb).
В идеальных условиях, когда всех исполнителей можно разместить на
процессорах одного узла, время выполнения будет определяться выражением
(4.7). Однако, в реальных условиях, узла с необходимым числом процессоров
может не существовать. В этом случае, часть исполнителей или должна
выполняться последовательно или быть размещена на других узлах.
146
Время выполнения алгоритма анализа данных при размещении
исполнителей в среде выполнения определяется как сумма времен:
выполнения корневого исполнителя h0 на отдельном процессоре;
выполнения каждого подмножества исполнителей Hf с учетом
размещения исполнителей на узле nh с числом процессоров |nh|;
передачи моделей знаний между узлами.
Таким образом, время выполнения алгоритма анализа данных с
конфигурацией lb может быть рассчитано по формуле:
τ(lb) = τ(h0) + 1..| |
1
(max ( ( ) ( ( ) ( )))| |
qkkh
h N kh yh hy
k h
cH r m m
n
, где (4.9)
ckh – количество исполнителей подмножества Hk размещенных на
узле nh:
Ckh = {(nh, hi) | nh, hiHk}|; (4.10)
rkh – описывает передачу модели знаний m для выполнения ФОМ
fr исполнителю fr hiHk размещенного на узле nh (rih
принимает значение 1 если на узел nh передается модель знаний
mr и значение 0 в противоположном случае):
иначеесли
lhnиlhnиEhhчтотакойhеслиr bihbqh
H
iqq
kh,0
),(),(),(,1. (4.11)
Сетевой трафик определяется как сумма передачи всех моделей знаний
между всеми узлами:
||
1
||
0
)()(H
i
kh
N
h
b rmlV . (4.12)
Задачу размещения алгоритма анализа данных в заданной среде можно
описать как поиск конфигурации lb, при которой, функции T(lb) и Ѵ(lb)
являются минимальными:
147
Lbl min)( ; (4.13)
LblV min)( . (4.14)
Требование минимизации трафика (4.14) достигается за счет
минимизации передаваемых между узлами данных (4.12), что можно достичь
за счет минимизации числа используемых узлов. Требование по
минимизации времени выполнения анализа данных может быть реализовано
за счет максимального распараллеливания процесса анализа по доступным
вычислительным узлам N. Оба требования противоречат друг другу, т.к. с
точки зрения использования вычислительных ресурсов исполнители должны
выполняться на нескольких (в общем случае на всех доступных)
вычислительных узлах, но это приводит к большому числу сетевых
взаимодействий. Альтернативой является размещение всех исполнителей на
одном узле, в этом случае сетевые взаимодействия отсутствуют, но
распараллеливание будет возможно только на средствах, доступных на этом
узле. При этом необходимо учитывать расположение данных, так как при
большом объеме их передача будет значительно увеличивать и сетевой
трафик, и время выполнения алгоритма анализа данных.
Размещение исполнителей по доступным вычислительным ресурсам
является классической обобщенной задачей о назначениях, в которой
требуется найти совершенное парасочетание вершин графов H и N
минимального веса. В общем случае такая задача является NP - полной, т.е.
не имеет точного решения за приемлемое время. Для решения такого рода
задач используют эвристики позволяющие получить приемлемое решение.
4.3.2 Эвристики для размещения исполнителей в среде выполнения
Для решения задачи размещения алгоритма анализа данных в заданной
среде выполнения введем ряд эвристик.
148
Эвристика 1. Исполнители-обработчики должны размещаться на узлах
источниках.
Доказательство: Для доказательства рассмотрим два случая, когда
исполнитель-обработчик hiHk размещается на:
1. узле источнике nhNs, т.е. (nh ,hi) l’b;
2. вычислительном узле nyNc, т.е. (ny ,hi) l”b.
Предположим, что в обоих случаях следующий исполнитель hi+1Hk+1
является вычислителем и размещается на вычислительном узле nyNc (т.е.
(ny, hi+1) l’b и (ny, hi+1) l”b).
В соответствии с формулами (4.9) и (4.12) для первого случая время
выполнения алгоритма анализа данных и сетевой трафик вычисляется
следующим образом:
T(l’b)= …+(hi) + (hi+1) + hy(m)+…;
V(l’b)= (m).
Во втором случае эти показатели будут вычислены следующим
образом:
T(l”b)= …+(hi) + (hi+1) + hy(d)+…;
V(l”b)= (d).
В случае если |d| >> |m| (что является особенностью алгоритмов анализа
данных) T(l’b) << T (l”b) и V(l’b) << V(l”b).
Эвристика 2. Внешним циклом алгоритма анализа данных должен быть
цикл, соответствующий распределению данных (т.е. при горизонтальном
распределении данных внешним циклом должен быть цикл по векторам, при
вертикальном распределении внешним циклом должен быть цикл по
атрибутам).
Доказательство: Предположим, что при горизонтальном распределении
цикл по векторам loopd вложен в цикл по элементам модели знаний
149
(например, цикл по атрибутам loope[1] loopd ft). При распараллеливании по
данным (если выполняются условия параллельного выполнения) для анализа
распределенных по горизонтали данных получим: loope[1] paralleld [loopd ft].
Таким образом, внешний цикл loope [1] входит в состав исполнителя
hiHk, размещенного на вычислительном узле nyN
c, ((ny ,hi) lb). Цикл по
векторам loopd выполняется исполнителями hi+1, …, hi+h,…, hi+wHk+1
вызываемыми из функции paralleld и распределенными по узлам источникам
n1,...,nh,…,nwNs ((n1,hi+1),…,(nh,hi+h),…,(nw,hi+w)lb).
Во внешнем цикле loope функция paralleld вызывается последовательно
на каждой итерации (например, по числу атрибутов p). Следовательно, все
исполнители hi+1, …, hi+h,…, hi+w будут вызываться на каждой итерации
(например, p раз) Hk+1
, …, Hk+p
. Таким образом, в соответствии с формулами
(4.9) и (4.12), время выполнения алгоритма анализа данных и сетевой трафик
вычисляются следующим образом:
T(l’b)=…+(hi)+p·((hi+1)+…+(hi+w))+p·(1y (m)+… +wy(m));
V(l’b)= p·w·(m).
В случае, если внешним циклом будет цикл по векторам loopd loope [1]
ft, при его распараллеливании, для анализа горизонтально распределенных
данных получим paralleld [loopd loope[1] ft]. В этом случае функция paralleld
выполняется один раз, а каждый исполнитель выполняет ФОМ ft в цикле
(например, p раз). В соответствии с формулами (4.9) и (4.12), время
выполнения алгоритма анализа данных и сетевой трафик вычисляются
следующим образом:
T(l”b)=…+(hi)+p·(hi+1)+…+p·(hi+w)+(1y(m)+… +wy(m))+…
V(l’b)=w·(mr)
Таким образом, во втором случае время выполнение алгоритма анализа
данных сокращается за счет меньшего числа передаваемых моделей знаний
(например, в p раз). Во столько же раз уменьшается сетевой трафик.
150
Эвристика 3. Выполнение исполнителя hi и его q потомков на одном узле nh
эффективнее, чем их распределение по нескольким узлам если:
(m) (m)1
| n | (H )
yh hy
k
h
q
для paralleld; (4.15)
(m) (m) (clone) ( )1
| n | (H ) (H )
yh hy
k k
h
q union
для parallels. (4.16)
Доказательство. Для доказательства сравним время выполнения
исполнителей для двух вариантов: при выполнении на одном узле и при
выполнении на нескольких узлах.
При выполнении на одном узле nh исполнителей hi+1,…,hi+qHk,
вызываемых из одной функции paralled (parallels), выполняемой
исполнителем hiHk-1
((ny,hi), (ny,hi+1),…,(ny,hi+q)lb), с учетом выражения
(4.9), время их выполнения будет вычисляться следующим образом:
T(l’b)=…+ τ(hi) +| n |h
q
· τ(Hf)+….
Разница для функций parallels и paralleld заключается в исполнителе hi.
Он, в случае функции paralleld, выполняет дополнительно функции clone
(2.7) и union (2.9) по количеству параллельных исполнителей q.
При выполнении исполнителей hi+1,…,hi+qHk на нескольких узлах
n1,...,nh,…,nwN ((n1,hi+1),…,(nw,hi+q)lb) даже при наилучшем распределении,
при котором все исполнители будут выполняться параллельно ckh ≤ |nh|,
необходимо выполнение функций clone (2.7) и union (2.9). Кроме того, при
таком варианте будет осуществляться передача модели знаний m к каждому
исполнителю и построенной модели знаний m от каждого исполнителя.
Время выполнения функций parallels и paralleld в этом случае будет
вычисляться следующим образом:
T(l”b) =…+ τ(hi)+ τ(Hf)+τyh(m)+ τhy(m)+….
151
Время выполнения функции paralleld на одном узле будет меньше
времени выполнения на нескольких T (l’b) < T (l”b) в случае, если:
τ(hi)+ | n |h
q
· τ(Hf) τ(hi)+ τ(H
f)+τyh(m)+ τhy(m).
Для функции paralleld время выполнения τ(hi) в обоих случаях будет
одинаково. Для функции parallels время выполнения τ(hi) для варианта с
несколькими узлами, будет больше на q·(τ(clone) + τ(union)). Таким образом,
получим:
для функции paralleld:
| n |h
q
· τ(Hf) τ(H
f)+τyh(m)+ τhy(m)
(m) (m)1
| n | (H )
yh hy
k
h
q
;
для функции parallels:
| n |h
q
· τ(Hf) τ(H
f)+τyh(m)+ τhy(m) + q·(τ(clone) + τ(union))
(m) (m) (clone) ( )1
| n | (H ) (H )
yh hy
k k
h
q union
.
Из данной эвристики можно сделать следующие выводы:
если максимальное время выполнения исполнителя τ(Hk) много
больше чем время передачи модели знаний (τyh(m)+τhy(m)) и время
выполнения функций clone (2.7) и union (2.9) (q·(τ(clone) + τ(union)),
то число исполнителей не должно превышать числа свободных
процессоров на узле q |nh|;
для функции paralleld, в случае если время передачи модели знаний
m по сети сравнимо с максимальным временем выполнения
исполнителя (τyh(m)+τhy(m))≈τ(Hk), то выполнение на одном узле
эффективно, даже если число исполнителей в два раза больше
количества имеющихся на узле процессоров: q < 2·|ny|;
152
для функции parallels, в случае если время передачи модели знаний
m по сети сравнимо с максимальным временем выполнения
исполнителя (τyh(m)+τhy(m)) ≈ τ(Hf) и временем выполнения
функций clone (2.7) и union (2.9) (q·(τ(clone) + τ(union)≈τ(Hf)), то
выполнение на одном узле эффективно даже если число
исполнителей в три раза больше количества имеющихся на узле
процессоров: q < 3·|ny|.
4.3.3 Метод размещение исполнителей до выполнения алгоритма анализа
данных
Начальное дерево исполнителей алгоритма анализа GH размещается в
среде выполнения, заданной графом GN, перед выполнением алгоритма.
Такое размещение возможно только для исполнителей, содержащих ФОМ
которые входят в основную последовательность, а также для ФОМ
распараллеленных по задачам, т.к. их количество известно заранее.
Количество исполнителей, содержащих ФОМ распараллеленных по данным,
зависит от количества элементов модели знаний, которые обрабатываются
такой ФОМ. Следовательно, исполнители, выполняющие их, могут
размещаться только на этапе выполнения.
Размещение начального дерева исполнителей алгоритма анализа
данных GH начинается с корневого узла дерева исполнителей h0. Если он
является обработчиком, то он размещается в свободной нити на узле
максимально близком к узлу – источнику n0 Ns (возможно на нем):
l = {(nh, h0)}, nh = miny=0..|N|δ(ey0).
Если корневой исполнитель h0 является анализатором, то размещается
в свободной нити узла nyNc с максимальным числом свободных нитей
оставшихся в среде:
l = {(ny, h0)}, ny= maxi=1..|N||ni|.
153
Далее, если имеет место распределенное хранение данных, то
размещаются исполнители-обработчики. При этом дерево исполнителей
должно быть построено по структуре соответствующей распределению
данных, т.е. из основной последовательности алгоритма (корневого
исполнителя h0) должны вызываться исполнители, выполняющие или цикл
по векторам или цикл по атрибутам (для горизонтального или вертикального
распределения соответственно). Они размещаются непосредственно на узлах
источниках.
Выполняется обход дерева исполнителей. Для каждой функции parallel
в исполнителе hi необходимо определить один из следующих вариантов
размещения его потомков:
на узле nh вместе с родительским исполнителем;
на другом едином узле ny;
на нескольких других узлах ny,…, nw.
Выбор варианта размещения исполнителя зависит от наличия
вычислительных узлов и выполнения условия (4.15) для функции paralleld и
условие (4.16) для функции parallels. Если вычислительных узлов нет или
условия выполняются, то потомки размещаются на том же узле. В противном
случае для всех потомков исполнителей:
1. выбирается потомок исполнитель hi+p с максимальным ПП:
hr = maxp=1...q(ρ(hi+p));
2. для него выбирается узел с максимальным числом процессоров:
ny = maxi=1..|N| |ni|;
3. выбранный потомок исполнитель hr размещается на узле ny:
(ny, hr) lb ;
4. для потомков исполнителя необходимо повторить проверку условия
(4.15) для функции paralleld и условия (4.16) для функции parallels.
154
Ниже представлен псевдокод метода размещения начального дерева
исполнителей.
deployExecutorTree (GH, G
N) - функция размещения исполнителя на узлах среды.
Вход: GH - дерево исполнителей, G
N – среда выполнения.
Выход: конфигурация l размещения исполнителей в среде выполнения.
deployExecutorTree (GH, G
N)
1. l =
2. Hh0 // получить исполнителя - корень дерева исполнителей
3. if (h.exec ==execd)
4. n = miny=0..|N|δ(ey0) // выбрать узел ближайший к данным
5. else
6. n = maxi=1..|N| |ni| // выбрать узел с максимальным числом процессоров
7. deployExecutor(h0, n, GN, l)
8. return l
deployExecutor(h, n, GN) - функция размещения исполнителя.
Вход: h – исполнитель, который размещается; n – узел размещения; GN – среда
выполнения; l – конфигурация размещения исполнителей в среде выполнения.
deployExecutor(h, n, GN, l)
1. {(n, h)} l
2. for each parallel f from h
3. if (4.15) or // для распараллеливания с использованием общей памяти
4. (4.16) // для распараллеливания с использованием распределенной памяти
5. for each hi from f
6. deployExecutor(hi, h.n, GN, l) l // размещаем на родительском узле
7. else
8. for all hi from f
9. hi = maxhf (ρ(h)) // выбираем исполнителя с максимальным ПП
10. n = maxi=1..|N| |ni| // находим узел с максимумом свободных процессоров
11. if(n != Ø) // если узел есть
12. deployExecutor(hi, n, GN, l) l // размещаем на другом узле
13. else
14. deployExecutor(hi, h.n, GN, l) l // размещаем на родительском узле
155
4.3.4 Метод размещения исполнителей при выполнении алгоритма анализа
данных
При выполнении функции parallel, выполняющей распараллеливание
по данным, изменяется дерево исполнителей алгоритма анализа данных GH.
Изменения происходят в части функции параллельного применения одного и
того же ФОМ к разным элементам модели знаний. Такие исполнители также
должны быть размещены на доступных узлах вычислительной среды. Для
этого должны быть определены условие (4.15) для функции paralleld и
условие (4.16) для функции. Если они выполняются (эффективнее размещать
на одном узле) то исполнитель клонируется по количеству доступных на узле
процессоров. Между исполнителями разделяются элементы модели знаний,
обрабатывающиеся параллельной ФОМ. Псевдокод метода размещения
дерева исполнителей представлен ниже.
Если эффективнее (т.е. условия (4.15) и (4.16) не выполняются)
распределить параллельные ФОМ на нескольких узлах, то создаются q
исполнителей. Обрабатываемые элементы модели знаний делятся между
deployLoopExecutor(h, GN) - метод размещения исполнителя цикла
Вход:h – исполнитель который размещается; GN – среда выполнения
Выход: конфигурация размещения исполнителей в среде выполнения
deployLoopExecutor (h, GN)
1. for i =1 to q
2. hi = h.clone
3. if (4.15) or // для распараллеливания с использованием общей памяти
4. (4.16) // для распараллеливания с использованием распределенной памяти
5. {(h.n, hi)} l // все размещаем на одном узле
6. else
7. n = maxi=1..|N| |ni| // выбираем узел с максимальным числом процессоров
8. {( n, h)} l // размещаем на нем
9. return l
156
ними. Сами исполнители размещаются на процессорах узлов, начиная с узла
с наибольшим числом процессоров.
4.3.5 Пример размещения исполнителей для алгоритма анализа данных
Рассмотрим работу метода размещения исполнителей алгоритма
анализа данных 1R для слабосвязанной среды с централизованным
хранением данных на узле n0 Ns:
N = {n0, n1 ,n2}, где |n0| = 4, |n1| = 4, |n2| = 8, n0 NS.
При первичном размещении корневой исполнитель h0, являющийся
вычислителем, размещается на узле с максимальным числом нитей - n2.
Далее последовательно рассматриваются функции parallel, выполняющиеся в
данном исполнителе (Рисунок 4.5).
Первая функция parallels fd2 имеет дугу на исполнителя h1,
выполняющего цикл. В рамках данного цикла выполняется обрабатывающий
ФОМ, т.е. исполнитель является обработчиком и в соответствии с
предложенным методом должен быть размещен на узле источнике n0.
Следующая функция parallels f4 имеет дугу на исполнителя h2, также
выполняющего цикл. Данный исполнитель не содержит обрабатывающих
ФОМ и является анализатором, следовательно, может быть размещен на
вычислительном узле. Для него условие (4.16) примет вид:
4 4
(m) (m)1 (clone) ( )1 2
8 (f ) (f )
yh hy union
,
выполняется, даже не смотря на то, что время τ(f8) может быть большим т.к. в
нем выполняется два вложенных друг в друга цикла. Следовательно,
исполнитель h2 будет размещен на родительском узле n2.
Исполнитель h2 содержит в своем составе функцию распараллеливания
parallels [f8, f9], которая связана с двумя исполнителями-вычислителями h3 и
h4. Условие (4.16):
157
8 9 8 9
(m) (m)2 (clone) ( )1 2
4 max( (f ), (f )) max( (f ), (f ))
yh hy union
,
с учетом, что время выполнения τ(f8) и τ(f9) мало, исполнители h3 и h4 могут
быть размещены на родительском узле n1.
Рисунок 4.5 – Начальное размещение исполнителей для параллельного
алгоритма 1R.
Необходимо заметить, что узел n0 остался не занятым, т.к. размещение
на нем исполнителей привело бы к увеличению сетевого трафика и времени
выполнения алгоритма анализа данных.
На этапе выполнении алгоритма анализа данных 1R при запуске
исполнителя h1 необходимо выполнить тиражирование, т.к. он выполняет
распараллеливание по данным. Так как ФОМ могут выполняться в с
использованием общей памяти, то их следует разместить на одном узле,
выполнив распараллеливание по количеству доступных нитей |n0| = 4
(Рисунок 4.6). Аналогичная ситуация при размещении исполнителя h2.
n2 n0
n1
h4 h3
h2
h1
h0
f0
run[f0, fd1]
loope [0] f13f10parallelsparallels
loopd fd3
loope [0, k] f9f8f5
fd3
f6
loope [0, t] f6
f8 f9
f10 f13 parallels fd2 parallels f4
parallels [f8, f9]
d
158
Рисунок 4.6 – Размещение исполнителей для параллельного алгоритма 1R на
этапе выполнения.
4.4 Методика построения параллельного алгоритма анализа данных для
выполнения в заданной вычислительной среде
4.4.1 Основные этапы построения параллельного алгоритма анализа
распределенных данных
Применение предложенных методов и моделей с целью построения
параллельных алгоритмов анализа распределенных данных с учетом типа
распределения и среды представим в виде методики.
Исходными данными для построения параллельного алгоритма анализа
данных являются:
n2 n0
n1 h2
h1
h0
f0
run[f0, fd1]
loope [0] f13f10parallelsparallels
loopd fd3
loope [0, -1] f9f8f5
fd3
loopE [0, t]f6
f10 f13 parallels fd2 parallels f4
parallels [f8, f9] h1 loopd fd3
fd3
h1 loopd fd3
fd3
h1 loopd fd3
fd3
h2 loope [0, -1] f9f8f5
loopE [0, t]f6
d
h4 h3 f8 f9
h4 h3 f8 f9
parallels [f8, f9] parallels [f8, f9]
h2 loope [0, -1] f9f8f5
loopE [0, t]f6
h4 h3 f8 f9
parallels [f8, f9] parallels [f8, f9]
h2 loope [0, -1] f9f8f5
loope [0, t]f6
h4 h3 f8 f9
parallels [f8, f9]
159
среда выполнения GN
и способ хранения в ней анализируемых
данных;
концепция анализа данных, возможно оформленная в виде
алгоритма (описания, блок схемы, псевдокода и т.п.).
Концепция анализа данных предполагает наличие основных принципов
извлечения знаний, возможно не оформленных в виде алгоритма (т.е.
отсутствует последовательность применения данных принципов для
построения модели знаний). Такие принципы могут быть выражены в виде
математических функций, правил или методов анализа отдельных элементов
набора данных (векторов, атрибутов, значений и т.п.). Данные принципы
могут быть ранее известны и использоваться в существующих алгоритмах
или быть новыми.
Основными этапами построения параллельного алгоритма анализа
распределенных данных являются:
I. построение модели знаний в виде массива элементов (2.6) для
алгоритма анализа;
II. формирование композиции функции f0 типа (2.13) и ФОМ fi, i=1..n типа
(2.14) в виде (2.12);
III. распараллеливание алгоритма анализа данных представленного в виде
композиции функций в соответствии с видом хранения данных;
IV. размещение алгоритма анализа данных в заданной среде выполнения.
Результатами выполнения методики являются:
функциональное описание построенного параллельного алгоритма
анализа данных, соответствующее виду распределения данных;
дерево исполнителей соответствующее построенному
параллельному алгоритму анализа данных;
160
выбранная конфигурация размещения исполнителей на узлах
вычислительной среды, минимизирующая время выполнения
алгоритма анализа данных и сетевой трафик.
4.4.2 Построения модели знаний для алгоритма анализа данных
На первом этапе должна быть определена структура модели знаний,
которая должна включать в себя элементы, описывающие:
итоговые знания, извлеченные из данных алгоритмом анализа;
промежуточные результаты, формируемые и используемые
функциями алгоритма.
Первый вид элементов модели знаний определяется ее типом (базовой
моделью знаний). Он должен быть выбран (Рисунок 4.7) как один из
стандартных типов модели знаний (базовой модели), описанных, например, в
стандарте PMML [58] и представленных в виде массива элементов в
Приложении А.
Второй тип элементов зависит от особенностей алгоритма анализа
данных. Для их выделения в функциях анализа данных необходимо выделить
все не локальные переменные (аргументы функций, глобальные переменные,
используемые в разных функциях и т.п.), используемые для хранения
промежуточных результатов. Переменная добавляется в качестве
вычислительного параметра или в существующий элемент модели знаний
или создается новый элемент (2.5), который добавляется в модель знаний.
Выбор элемента модели знаний определяется его логической
принадлежностью.
Для возможности объединения элементов модели знаний, построенных
параллельно, необходимо определить функцию агрегирования для
добавленного свойства. Если такая функция не может быть задана, то данный
параметр не может вычисляться параллельно.
161
В описании функций алгоритма анализа данных, выделенные
переменные рекомендуется заменить на соответствующие им элементы
моделей знаний и их параметры.
Построение
модели знаний
Выбрать базовую
модель знаний m
Для каждой
функции алгоритма
анализа данных
Для каждой
функции алгоритма
анализа данных
Выделить переменные/
аргументы функции
Для каждой переменной
функции
Для каждой переменной
функции
В модели
знаний m есть элемент
соответствующий
переменной Создать новый
элемент m[i]
Выбрать
элемент m[i]
Да Нет
Добавить переменную в
элемент как выч. параметр p
Определить для параметра p
функцию агрегирования
Формальное описание
алгоритма анализа
данных / функции
анализа данных
Модель знаний m
Рисунок 4.7 – Этап построения модели знаний.
162
Пример, построения модели знаний для алгоритма 1R описан в разделе
2.3.5. Для нее в качестве базовой модели знаний выбрана модель PMML
RuleSetModel.
4.4.3 Формирование композиции функций алгоритма анализа данных
Для представления алгоритма анализа данных в виде композиции ФОМ
(2.12) необходимо сформировать все ФОМ и определить их порядок
выполнения с учетом итерационного выполнения (Рисунок 4.8.)
Формирование ФОМ fr выполняется на основании функций анализа,
применяемых к данным и элементам модели знаний. В ФОМ выделяются
операции связанные между собой общими локальными переменными.
Базовыми в таких ФОМ являются операции, изменяющие элементы модели
знаний, к которым добавляются предшествующие и/или последующие
операции, не меняющие модель знаний. Группировка операций, не
меняющих модель знаний со смежными базовыми операциями, выполняется
исходя из их логической принадлежности к ним. Признаком такой
логической связи может служить использование промежуточных
(локальных) переменных. Такие переменные должны быть локализованы
внутри создаваемой ФОМ. [18]
Если функция анализа, в качестве аргумента, использует элементы
набора данных d, то на ее основе формируется ФОМ fdr имеющий тип (2.15),
иначе, если аргументами являются только элементы модели знаний, то ФОМ
fr типа (2.14). Любой ФОМ изменяет некоторые элементы модели знаний. На
основании используемых и изменяемых элементов модели знаний
формируются соответствующие множества In(fr) и Out(fr).
163
Формирование
композиции ФОМ
Сформировать
ФОМ fr
Для каждой
функции алгоритма
анализа данных
Функция
использует d
Сформировать
ФОМ fr=fdr
Определить In(fr) и Out(fr)
Для каждой
функции алгоритма
анализа данных
Существует
алгоритм анализа
данных
В алгоритме
выделить циклы и
условные переход
Для каждого ФОМ fr
Формальное описание
алгоритма анализа
данных / функции
анализа данных
Для каждого элемента
m[i] из In(fr)
Определить циклы и
условные переход
Упорядочит ФОМ в
композиции
Для каждого элемента
m[i] из In(fr)
Для каждого ФОМ fr
Добавить в
композицию
функции: loop и dec
Сформировать
композицию из
полученных ФОМ
Определить место
ФОМ fr в композиции
Добавить в
композицию функции:
loop и dec
Нет Да
Да Нет
Композиция ФОМ
Модель знаний m
Рисунок 4.8 – Этап формирования композиции ФОМ.
164
Порядок выполнения ФОМ, а также функции условного выполнения
dec (2.17) и циклы loop (2.20), определяются:
при распараллеливании существующего алгоритма анализа данных
(наличия его формального описания) исходя из его структуры;
при построении алгоритма анализа данных, исходя из зависимостей
ФОМ, определяемых множествами In и Out и элементами моделей
знаний, входящими в них.
В случае распараллеливания существующего алгоритма анализа
данных в его структуре должны быть выделены циклы и условные переходы.
Особо выделяются:
циклы, применяющие одинаковые операции к элементам модели
знаний, являющимися потомками одного родителя;
условные операторы, управляющие выполнением разных операций
над элементами модели знаний в зависимости от их свойств.
При построении алгоритма анализа данных рассматривается каждый
элемент модели знаний из множества используемых элементов m[i] Out(fr).
Общие правила определения порядка выполнения ФОМ по отношению к
элементу модели знаний m[i] следующие:
ФОМ fr, добавляющий элемент модели знаний m[i], должен
выполняться до (r < s) первого ФОМ fs, который использует данный
элемент m[i] In(fs);
ФОМ fr, удаляющий элемент модели знаний m[i], должен
выполняться после (r > s) последнего ФОМ fs, который использует
данный элемент m[i] In(fs);
порядок изменения элемента модели знаний m[i] двух ФОМ fr и fs
определяется первоначальной функцией анализа.
Если ФОМ fdr имеющий тип (2.15), должен быть применен ко всем
элементам набора данных, то он должен итерационно выполняться в:
165
цикле по векторам loopd (2.21), если применяется ко всем
векторам набора данных;
в цикле по векторам loopd (2.21) и цикле по атрибутам, если
применяется к каждому значению каждого вектора.
Если ФОМ fr имеющий тип (2.14), должен быть применен ко всем
элементам модели знаний, то он должен итерационно выполняться в цикле
по элементам loope (2.22) с индексом, соответствующим обрабатываемым
элементам модели знаний.
В случае, если ФОМ fr и fs применяются к элементам модели знаний в
зависимости от некоторых условий, то они должны вызываться из функции
dece (2.18), в которой условная функция c должна проверять эти условия.
Выделенные циклы и условные переходы должны быть представлены в
виде соответствующих ФОМ. Циклы, выполняющие итерационное
выполнение ФОМ и завершающиеся по какому-либо условию, должны быть
представлены в виде частично примененной функции loop (2.20). Циклы,
обрабатывающие элементы набора данных, должны быть представлены в
виде частично примененной функции loopd (2.21). Циклы, обрабатывающие
элементы модели знаний, должны быть представлены в виде частично
примененной функции loope (2.22). Условные операторы должны быть
представлены с помощью частичного применения функции dec (2.17).
Все построенные ФОМ должны формировать композицию (2.12), в
соответствии с определенным порядком и вложенностью в циклы и условные
переходы.
Пример формирования композиции ФОМ для существующего
алгоритма анализа данных 1R описан в разделе 2.3.5.
166
4.4.4 Распараллеливание и размещение алгоритма анализа данных
Распараллеливание композиции алгоритма анализа данных должно
выполняться с учетом типа распределения данных (Рисунок 4.9). В случае
распределенного хранения данных (|NS|>1) непосредственно перед
распараллеливанием должна быть изменена композиция алгоритма анализа
данных в соответствии с видом распределения данных (горизонтальное или
вертикальное). Для этого может быть использован метод оптимизации
структуры алгоритма анализа данных (optimizateStructure (f, flag)),
описанный в разделе 2.4. В результате его выполнения внешним циклом
будет или цикл по векторам loopd (2.21) (в случае горизонтального
распределения) или цикл по атрибутам loope [0] (в случае вертикального
распределения).
Пример оптимизации структуры алгоритма 1R для горизонтального
распределения данных описан в разделе 2.4.3.
В случае распределенного хранения данных проверяется возможность
распараллеливания соответствующего цикла для систем с распределенной
памятью [6]. Проверка осуществляется методом проверки условий
параллельного выполнения пары ФОМ verifyParallelize ((loope s 1 i ft), (loope
s+1 1 i ft)). Метод применяется к ФОМ ft, вызываемой итерационно в
соответствующем цикле на разных итерациях s и s+1. Независимо от типа
возвращаемой функции parallel, цикл распараллеливается функцией paralleld.
Если распараллеливание цикла не возможно (метод verifyParallelize
возвращает null), то для анализа данных выбранным алгоритмом необходим
их предварительный сбор в едином хранилище.
167
Выполнение алгоритма
Распараллеливание
алгоритма анализа данных
|NS|>1
Композиция
ФОМ f
Среда
выполнения GN
optimizateStructure (f, flag)
verifyParallelize (ft, ft+1) -> f
parallelize(f)Распараллеленный
алгоритм f
createExecutorTree (f)
Запуск алгоритма f
ФОМ это
parallel [loope]
Для каждой ФОМ
алгоритма анализа данных
Для каждой ФОМ
алгоритма анализа данных
deployLoopExecutor(h, GN)
Да
Модель знаний m
Рисунок 4.9 – Этапы распараллеливания и размещения алгоритма анализа
данных.
В полученной композиции для каждой пары ФОМ и циклов
определяются условия их параллельного выполнения. На основании этой
информации в композиции определяются все возможные места
параллельного выполнения ФОМ и осуществляется вставка функции:
168
parallels, в случае если возможно параллельное выполнение с общей
памятью;
paralleld, в случае если возможно параллельное выполнение с
распределенной памятью.
Проверка возможности параллельного выполнения и вставка функций
parallel выполняется методом распараллеливания последовательного
алгоритма анализа данных parallelize(f).
Пример распараллеливания алгоритма 1R для анализа централизованно
хранящихся данных описан в разделе 3.3.2.
На последнем этапе методики параллельный алгоритм анализа данных
должен быть размещен в заданной среде выполнения. Для этого должны
быть созданы исполнители, объединенные в ациклически связанный граф GH
(дерево). Построение дерева исполнителей GH по параллельному алгоритму
анализа данных осуществляется методом построения модели исполнителей
createExecutorTree (f).
До выполнения алгоритма анализа данных, дерево исполнителей GH,
построенное по нему, должно быть размещено в заданной среде выполнения
GN. Это может быть выполнено методом размещения алгоритма анализа
данных в среде выполнения deployExecutorTree (GH, G
N). При выполнении
алгоритма анализа данных определяется число элементов модели знаний,
которые обрабатываются распараллеливаемыми циклами. Таким образом,
появляется возможность определить необходимое число исполнителей и их
размещение в среде выполнения. Тиражирование исполнителей hi и их
размещение осуществляется методом размещения исполнителя цикла
deployLoopExecutor(h, GN).
169
Выводы
Для решения задачи размещения параллельного алгоритма анализа
данных в заданной среде:
1) определена модель среды выполнения алгоритмов анализа данных в
виде ациклического графа, вершины которого разделены на два
подмножества: узлы-источники, содержащие данные, и
вычислительные узлы;
2) введено понятие исполнителя, обеспечивающего выполнение
композиции ФОМ в заданной среде выполнения;
3) определена модель исполнителей в виде направленного
ациклического графа (дерева) в котором узлами являются
исполнители, а дугами являются вызовы исполнителей;
4) задача размещения алгоритма анализа данных сформулирована как
задача поиска множества паросочетаний (конфигурация)
исполнитель – узел, при котором время выполнения алгоритма
анализа данных и сетевой трафик минимальны;
5) были введены ряд эвристик упрощающих решение данной задачи,
учитывая, что в классической постановке обобщенная задача о
назначениях, в которой требуется найти совершенное паросочетание
вершин графов минимального веса, является NP- полной;
6) определены методы для размещения алгоритма анализа данных на
начальном этапе - до выполнения алгоритма анализа данных, когда
неизвестно количество элементов модели знаний, по которым
выполняются циклы и на этапе выполнения при размещении
композиций ФОМ распараллеленных по данным;
7) описана методика построения параллельных алгоритмов анализа
распределенных данных, объединяющая предложенные в работе
методы и модели.
170
5. Библиотека параллельных алгоритмов анализа
распределенных данных
Для практического применения, полученные результаты были
реализованы в виде каркаса библиотеки алгоритмов анализа данных для
параллельного и распределенного выполнения [24, 25]. Для этого была
расширена библиотека Xelopes компании PrudSys (http://www.prudsys.de/)
[46, 47]. Библиотека реализована на языке программирования Java. Ее ядро
содержит базовые классы для реализации алгоритмов анализа данных. Ее
основным недостатком, является монолитная реализация алгоритмов,
которая не позволяет его распараллелить без изменения кода.
Для устранения этого недостатка, представив алгоритм в виде
отдельных функций алгоритма, ядро данной библиотеки было
модифицировано. Такое представление соответствует функциональной
модели алгоритма анализа данных описанной во 2й главе. Расширенная
версия получила название DXelopes (Distributed Xelopes).
В результате библиотека DXelopes, имеет следующие возможности по
сравнению с существующими библиотеками алгоритмов анализа данных:
построение новых алгоритмов путем комбинации существующих
ФОМ или модификация существующих алгоритмов путем замены
(или модификации) отдельных ФОМ;
преобразование последовательных алгоритмов, построенных в виде
последовательности ФОМ, в параллельные формы для выполнения
в параллельных и распределенных средах;
выполнение параллельных алгоритмов анализа данных в разных
вычислительных средах.
171
5.1 Отличия разработанной библиотеки от существующих аналогов
Библиотека алгоритмов анализа данных для параллельного и
распределенного выполнения DXelopes представляет собой набор
взаимосвязанных классов4. Они реализую следующий базовый функционал
необходимый для выполнения алгоритмов анализа данных:
загрузку данных;
обработку данных (доступ к различным элементам набора данных);
настройку выполнения алгоритмов анализа данных;
хранение результатов выполнения алгоритмов анализа данных –
модели знаний;
построение параллельных алгоритмов анализа данных.
Последнее свойство отличает построенную библиотеку от
существующих (в том числе и от библиотеки Xelopes, на базе которой она
построена). Оно позволяет создавать программную реализацию алгоритма
анализа данных в соответствии с предложенной функциональной моделью, и
тем самым подготовив к выполнению в параллельной и распределенной
среде.
Типовой подход построения библиотек алгоритмов анализа данных,
используемый в таких популярных библиотеках как RapidMiner, Weka и
Xelopes, предполагает добавление новых алгоритмов в виде отдельных
монолитных (не декомпозированных на блоки) классов (Рисунок 5.1 а).
Выполнение таких алгоритмов предполагается в неизменном виде или путем
их модификации.
4Модификация библиотеки Xelopes размещена в открытом репозитории исходных кодов BitBucket и
доступна по ссылке https://bitbucket.org/iiholod/dxelopes4students.
172
Рисунок 5.1 – Подходы добавления новых алгоритмов в библиотеку
(а – существующие библиотеки, б – разработанная библиотека).
В отличие от них разработанная библиотека предполагает
декомпозицию исходного алгоритма анализа данных на ФОМ (Рисунок 5.1
б). При этом часть таких ФОМ может быть заимствована из состава
библиотеки. Таким образом, библиотека позволяет использовать
существующий задел в виде ФОМ и реализовывать только те функции,
которые являются уникальными для алгоритма. Кроме того, такое
построение алгоритма позволяет оперировать ФОМ как неделимой единицей,
размещать и выполнять ее на отдельных вычислительных элементах.
Новый алгоритм
анализа данных
Набор
данных
Библиотека
(Xelopes, RapidMiner, Weka идр.)
Модель
знаний
(результат)
Новый
алгоритм
анализа данных
(монолитный) Модуль чтения и обработки
данных
Модуль сохранения
результата
Существующие алгоритмы
анализа данных
Набор
данных
Библиотека
(DXelopes)
Модель
знаний
(результат)
ФОМ
алгоритма
анализа данных Модуль чтения и обработки
данных
Модуль сохранения
результата
Существующие алгоритмы
анализа данных
Общие ФОМ алгоритмов
анализа данных
ФОМ 1
ФОМ2
ФОМ 3
ФОМ n
ФОМ n-1
ФОМ 1
ФОМ 3
ФОМ n
173
5.2 Архитектура библиотеки
5.2.1 Структура библиотеки
Библиотека DXelopes содержит необходимые базовые классы для
построения параллельных алгоритмов анализа данных. Она разделена на
следующие модули:
ядро библиотеки (Core) построенное в соответствии со
стандартом CWM и включающее в себя:
o средства работы с данными, заимствованные из библиотеки
Xelopes;
o средства сохранения результатов, в соответствии с
предложенным представлением модели знаний;
o средства для настройки задач и алгоритмов анализа данных,
заимствованные из библиотеки Xelopes;
o базовые классы для реализации ФОМ, в соответствии с
функциональной моделью алгоритма анализа данных;
o программную реализацию исполнителей для выполнения в
параллельной и распределенной среде;
алгоритмы классификации (Classification);
алгоритмы кластеризации (Clustering);
алгоритмы поиска ассоциативных правил (Association).
Последние три модуля используют ядро и не зависят друг от друга
(Рисунок 5.2).
174
Рисунок 5.2 – Структура компонентов библиотеки DXelopes.
5.2.2 Реализация функции обработки модели
Для реализации подхода построения алгоритмов анализа данных из
набора ФОМ в библиотеку были добавленные соответствующие классы. Они
позволяют реализовать отдельные блоки алгоритма как ФОМ, интегрировать
их в алгоритм и выполнить его.
В библиотеке ФОМ описывается классом Step (Рисунок 5.3).
Реализация блока алгоритма содержится в методе execute, который
вызывается из публичного метода runStep. Вызов метода execute приводит к
выполнению блока алгоритма. Данный метод в соответствии с выражением
(2.15), в качестве входных аргументов принимает входной набор данных
inputData и модель знаний model. В качестве результата он возвращает
модель знаний. Все функциональные блоки, из которых строятся алгоритмы
анализа данных, должны наследоваться от класса Step и реализовывать метод
execute. Таким образом, все ФОМ будут иметь унифицированный интерфейс.
Для удовлетворения требованию чистоты функции метод execute в классе
Step должен работать только с передаваемыми ему аргументами (входной
набор данных inputData и модель знаний model).
175
Рисунок 5.3 – Диаграмма классов для реализации ФОМ алгоритмов анализа данных.
176
Для реализации композиции ФОМ используется класс StepSequence.
Он реализует функцию run (2.16). Так как функция run также является ФОМ,
то класс StepSequence является наследником класса Step. Объект такого
класса содержит поле sequence - набор объектов класса Step,
соответствующих ФОМ алгоритма, выполняющимся последовательно.
Результат выполнения каждого ФОМ из композиции, возвращаемый методом
execute, передается в качестве аргумента следующему ФОМ в метод execute.
Оператор условного выполнения, соответствующий функции dec
(2.17), реализуется классом DecisionStep. В соответствии с функциональной
моделью условный переход является ФОМ, следовательно, класс
DecisionStep также наследуются от класса Step. Метод execute класса
DecisionStep реализует условный переход. Для этого в классе определен
абстрактный метод condition, соответствующий функции c . Для реализации
ФОМ ft и ff в классе реализованы соответственно два поля:
trueBranch, реализующий композицию ФОМ ft, выполняющихся при
выполнении условия с;
falseBranch, реализующий композицию ФОМ ff, выполняющихся при не
выполнении условия с.
Таким образом, метод execute проверяет условие перехода, вызывая
метод condition, реализованный в классе наследнике, и в зависимости от
результата вызывает выполнение одной из последовательностей.
Класс CycleStep реализует функцию loop (2.20). Она также является
ФОМ, следовательно, также является наследником класса Step. Метод
execute класса CycleStep реализует циклический вызов композиции
функциональных блоков ft, заданных полем iteration. Цикл выполняется до
тех пор, пока верно условие, вычисляемое методом initLoop(),
соответствующим функции c. Для инициализации цикла используется метод
initLoop, соответствующий функции finit. Действия, выполняемые после
177
каждой операцией и соответствующие функции fafter , реализуются методом
afterIteration.
Для алгоритмов DataMining характерным является обработка данных
по векторам (2.21), а также по атрибутам (2.22). Для их реализации
добавлены классы VectorsCycleStep и AttributesCycleStep. Оба они являются
наследниками класса CycleStep и реализуют его методы, описанные выше.
Обработка каждого вектора или атрибута определена композицией ФОМ –
iteration.
Для интеграции ФОМ в алгоритм анализа данных определен класс
MiningAlgorithm. Он содержит в себе композицию всех ФОМ, составляющих
алгоритм анализа данных – steps. Конструирование алгоритма из ФОМ
выполняется в методе initSteps(). Построение модели знаний осуществляется
методом buildModel. Он вызывает метод runAlgorithm, который в свою
очередь вызывает метод execute последовательности steps.
5.2.3 Классы для параллельного выполнения алгоритмов анализа данных
Основным преимуществом декомпозиции алгоритмов анализа данных
на ФОМ является возможность преобразования его к параллельной форме. В
библиотеке для этого добавлен класс ParallelStep (Рисунок 5.4), реализующий
функцию parallel (3.1). Являясь ФОМ, он также наследуется от класса Step.
Его наследники определяют конкретный способ распараллеливания: по
данным или по задачам.
178
Рисунок 5.4 – Диаграмма классов для реализации параллельной формы
алгоритмов анализа данных
Для параллелизации по данным используется класс ParallelByData. Он
включает в себя последовательность ФОМ - branch, которая выполняется
параллельно. В случае параллелизации по данным, последовательность
является общей для всех потоков и применяется к разным частям
обрабатываемых данных.
Для параллелизации по задачам используется класс ParallelByTask. Он
включает в себя список branches разных последовательностей ФОМ. Каждая
из этих последовательностей выполняется параллельно и может
обрабатывать одни и те же данные.
5.2.4 Среда параллельного и распределенного выполнения алгоритмов
анализа данных
Для реализации среды параллельного и распределенного выполнения
алгоритмов анализа данных, в библиотеку добавлены соответствующие
классы. Среда выполнения описывается абстрактным классом
ExecutionEnvironment (Рисунок 5.5).
179
Рисунок 5.5 – Диаграмма классов среды выполнения алгоритмов анализа данных.
Она включает в себя исполнителей, реализованных как объекты класса
ExecutionHandler, непосредственно, выполняющие ФОМ. Класс
ExecutionEnvironment имеет основного исполнителя mainHandler h0, который
выполняет основную последовательность ФОМ заданную в последовательности
steps класса MiningAlgorithm. Кроме того, среда выполнения, содержит набор
исполнителей mainHandler, соответствующий доступным средствам параллельной
или распределенной среды (например, потокам, акторам и т.п.).
Исполнители создаются с помощью класса ExecutionHandlerFactory. Для
создания исполнителей, среда выполнения имеет экземпляр такой фабрики –
executionHandlerFactory. С ее помощью создается необходимое количество
исполнителей, заданное как и другие характеристики среды выполнения, в
настройках settings. Они описываются классом ExecutionSettings, который позволяет
определить следующие характеристики среды:
numberHandlers – количество обработчиков;
systemType – тип системы (многопоточность, модель акторов или др.);
memoryType – тип памяти: распределенная (MemoryType.distributed) или
разделенная (MemoryType.shared).
Для размещения алгоритма в среде выполнения используется метод
deployAlgorithm. Он реализует метод размещения исполнителей в среде выполнения.
Перечисленные классы являются базовыми для описания конкретной среды
выполнения. Наследники этих классов являются адаптерами между библиотекой и
конкретным средством выполнения параллельных или распределенных вычислений.
5.2.5 Выполнение алгоритмов в параллельной/распределенной среде
Для выполнения алгоритма анализа данных в заданной среде выполнения, в
библиотеке реализован класс EMiningBuildTask, являющийся наследником класса
MiningBuildTask стандарта CWM. Его основным назначением является
конфигурирование задачи построения модели знаний и выполнение этой задачи.
181
Конфигурация задачи заключается в установке следующих сущностей данной задачи
(Рисунок 5.6):
набор анализируемых данных, связывает задачу и наследника класса
MiningInputStream, обеспечивающего доступ к данным;
настройки как самой задачи (объект класса MiningFunctionSettings) так и
настроек конкретного алгоритма (объект класса MiningAlgorithmSettings);
алгоритм анализа данных (объект наследника класса MiningAlgorithm), с
помощью которого будет выполняться построением модели знаний;
среда выполнения (объект наследника класса ExecutionEnvironment), в которой
будет выполняться алгоритм.
Рисунок 5.6 – Базовые классы конфигурирования задачи выполнения алгоритма
анализа данных.
182
Построение модели знаний выполняется вызовом метода execute класса
EMiningBuildTask.
Настройки выполнения алгоритма определяют, в том числе и стратегии
параллельного выполнения алгоритма:
dataProcessingStrategy стратегия обработки набора данных:
SingleDataSet обработка всего набора данных каждым параллельным
исполнителем;
SeparatedDataSet разделение данных на части и обработка каждой части
набора данных отдельным исполнителем;
modelProcessingStrategy - выбор стратегии обработки модели знаний;
SingleMiningModel обработка всей модели знаний каждым параллельным
исполнителем;
SeparatedMiningModel разделение модели знаний на части и обработка
каждой части отдельным исполнителем.
Для реализации различных стратегий обработки данных используются
наследники класса MiningInputStream (Рисунок 5.7) для разных форматов хранения
данных (например, класс MiningArffStream наследник MiningInputStream
используется для обработки данных, хранящихся в файле формата ARFF). Доступ к
данным, через объекты данного класса, со стороны параллельных исполнителей
зависит от свойств среды выполнения и выбранной стратегии:
при выборе стратегии обработки всего набора данных каждым исполнителем в
среде выполнения с использованием общей памяти (MemoryType.shared)
иполнителям передается ссылка на единственный объект наследника класса
MiningArffStream ;
при выборе стратегии обработки всего набора данных каждым исполнителем в
среде выполнения с использованием распределенной памяти
(MemoryType.distributed) исполнителям передаются копии объекта наследника
класса MiningArffStream, которые создаются методом clone данного класса.
183
Рисунок 5.7 - Базовые классы для реализации стратегий работы с данными
5.3 Программная реализация исполнителей для параллельного и
распределенного выполнения алгоритмов анализа данных
5.3.1 Исполнители для выполнения в сильно-связанной среде
При выполнении композиции ФОМ в рамках одного узла (например, в сильно
связанной среде) в качестве исполнителей предлагается использовать потоки. Они
выполняются на процессорах узла, являются равнозначными и могут использовать
общую память [8].
Потоки работают в рамках одного процесса, их жизненный цикл управляется
операционной системой (ОС). В связи с этим в разных ОС существуют разные
реализации потоков и операции, управляющие их выполнением. Однако для всех
реализаций, выполняемые в потоке, действия описываются в определенной функции,
которая запускается ОС в рамках выделенного потока. Например, в виртуальной
машине Java, которая является кросс-платформенным интерпретатором, такой
функцией является функция run(). В ней выполняется тело потока.
При использовании потоков в качестве исполнителей взаимодействие между
ними может осуществляться с использованием общей памяти, в которой
размещается модель знаний m. В зависимости от выполнения исполнителя, данное
размещение может варьироваться:
при последовательном выполнении исполнителей, модель знаний в общей
памяти будет общей для них;
184
при параллельном выполнении исполнителей выполняющих ФОМ,
распараллеленных функцией:
o parallels – модель знаний будет общей для исполнителей;
o paralleld – для каждого исполнителя в общей памятью будет
создаваться своя копия модели знаний (т.е. исполнители будут
работать с разделенными участками общей памяти), при этом
взаимодействие будет осуществляться функцией join (2.10).
Таким образом, функция исполнителя exec (4.4) на потоках может быть
реализована следующим образом:
exec f m = run f m. (5.1)
5.3.2 Исполнители для выполнения в распределенной среде
Для выполнения алгоритма анализа данных на нескольких узлах
распределенной среды предлагается использовать акторов [15, 19]. Модель акторов
является обобщенным формализмом, позволяющим описать параллельные и
распределенные вычисления. По утверждению автора модели акторов [263] она
является более общим формализмом, чем -исчисления, позволяя описывать в том
числе параллельные вычисления. При этом в теории -исчислений каждый вызов -
функции может рассматриваться как вызов актора, а передача параметров функции
это пересылка сообщения актору.
Таким образом, при реализации исполнителя как актора, его выполнение будет
активироваться получением им сообщения, которое включает в себя модель знаний
m. После выполнения актор будет возвращать построенную (измененную) модель
знаний m обратно. Выполнение композиции ФОМ (функции run) будет
осуществляться как активность актора. Таким образом, работу актора для ФОМ fr
можно описать двумя событиями (Рисунок 5.8):
request – получение модели знаний и инициация работы актора;
reply – завершение работы актора и отправка измененной модели знаний;
185
Рисунок 5.8 – Отображение ФОМ на акторов.
Функция исполнителя exec (4.4) на акторах может быть реализована
следующим образом:
exec [fr, …, fs] m = replay (run [fr, …, fs] (request m)) (5.2)
Для организации взаимодействия исполнителей, реализованных в виде
акторов, размещенных на разных сетевых узлах, необходимо обеспечение
маршрутизации сообщений между ними. Для этого в систему акторов вводится
специальный актор – диспетчер сообщений r. Таким образом, сеть акторов можно
представить как набор акторов [17]:
0 1' { , , ,..., ,..., }q pA r a a a a , где (5.3)
r – специальный актор – диспетчер сообщений.
qa – актор, выполняющий композицию ФОМ fr, …,fs.
5.3.3 Реализация исполнителей на основе потоков
В многопоточной среде выполнения исполнителями являются потоки. В связи
с этим класс ThreadExecutionHandler, являющийся наследником класса
ExecutionHandler содержит ссылку thread на объект класса Thread (Рисунок 5.9).
Метод start класса ThreadExecutionHandler создает поток и запускает его на
выполнение.
Метод run потока, в соответствии с выражением (5.1), вызывает ФОМ методом
call() класса ExecutionHandler. Для получения результата в классе
ThreadExecutionHandler реализован метод getModel. Он ожидает окончания
выполнения потока и возвращает модель знаний, построенную потоком.
Для настройки многопоточной среды выполнения используется класс
ThreadSettings, наследник класса ExecutionSettings. Он добавляет возможность
Actor ai
[fi [request: m , reply-to: ai-1]]
[ai-1 [reply: m]]
Act: run [fr, …, fs]
{m}
{m}
Actor ai-1
186
указать тип памяти используемой средой – memoryType. Она может быть
разделяемой MemoryType.shared или распределенной MemoryType.distributed.
Рисунок 5.9 – Классы реализации исполнителей на основе потоков.
Вся многопоточная среда описывается классом
MultiThreadedExecutionEnvironment наследником класса ExecutionEnvironment. Он
реализует метод инициализации среды initEnvironment(), создавая с помощью
фабрики исполнителей (класса ThreadExecutionHandlerFactory) главного исполнителя
и шаблон исполнителя для многопоточной среды выполнения. Фабрика
исполнителей – класс ThreadExecutionHandlerFactory, является наследником класса
ExecutionHandlerFactory.
5.3.4 Реализация исполнителей на основе акторов
Среда выполнения, использующая модель акторов, включает в себя актор-
маршрутизатор и набор акторов-обработчиков (5.3). Библиотека интегрирована с
187
одной из популярных реализаций модели акторов – AKKA5. Адаптером между
библиотекой и акторами является класс ActorExecutionHandler, наследник класса
ExecutionHandler (Рисунок 5.10). Для взаимодействия с акторами он содержит
ссылку на ящик сообщений – inbox. Реализация метода start заключается в
размещении в ящике для актора-маршрутизатора сообщения, содержащего:
функциональный блок, набор данных и модель знаний. Сообщение реализуется
классом ExecuteJob. Он содержит композицию ФОМ и модель знаний согласно
выражению (5.2).
Для получения результата класс ActorExecutionHandler реализует метод
getModel, в котором получает сообщение из ящика inbox. Сообщение реализуется
классом ExecuteResult и содержит построенную модель знаний.
Непосредственно для выполнения ФОМ в среде создаются акторы-
исполнители. Они описываются классом ActorWorker, который реализует метод
onReceive, вызываемый при получении сообщения. В данном методе выполняется
применение ФОМ к набору данных и модели знаний. Вся цепочка вызова от
обработчика до актора описывается диаграммой последовательности (Рисунок 5.10).
Рисунок 5.10 – Диаграмма последовательности выполнения ФОМ актором.
5 Akka Documentation. http://akka.io/docs/
Рисунок 5.11 – Классы реализации исполнителей на основе акторов.
Среда акторов описывается классом ActorsClusterExecutionEnvironment,
наследником класса ExecutionEnvironment. Он реализует метод initEnvironment,
в котором создается кластер акторов (Рисунок 5.12). Кластер включает в себя
заданное пользователем количество вычислительных узлов, на которых
развернуты библиотека DXelopes и библиотека AKKA. На каждом узеле
разворачивается система акторов с одинаковым именем и разными адресами
системы. Каждая система содержит заданное число акторов.
Маршрутизатор R размещается в каждой системе акторов кластера, но
работающим считается только актор, находящийся в самой старой системе из
всех, объединенных в кластер. Маршрутизатор перенаправляет сообщения из
внешней среды от ActorExecutionHandler к акторам-исполнителям.
Рисунок 5.12 – Кластер акторов
Кластер акторов можно представить в виде иерархии объектов. Корнем
иерархии является сам кластер. Его дочерними узлами - системы акторов. В
каждой системе существует иерархия акторов, все акторы создаваемые
пользователем и используемые для нужд пользователя являются потомками
системного актора user. В данном случае, в каждой системе акторов есть только
один потомок актора user - это актор-посредник Prx R для взаимодействия с
актором-одиночкой маршрутизатором R. Акторы посредники во всех системах,
входящих в кластер указывают на одного и того же актора-одиночку, который
находится только в одной системе во всем кластере. Актор-маршрутизатор
создает все акторы-обработчики в системе, при этом он является родителем для
190
вычислителей только в своей системе акторв. На остальные исполнители
маршрутизатор имеет ссылки, а их родителями на самом деле являются акторы-
посредники в их системах.
Для настройки выполнения алгоритма анализа данных в среде акторов
используется класс ActorsClusterExecutionSettings, наследник класса
ExecutionSettings. Он добавляет следующие параметры характерные для среды
акторов:
logicalUnitsNumber – количество логических модулей;
maxActorsNumber – максимальное количество акторов в модуле;
port – номер порта среды акторов;
actorsCalculatorsNumber – количество акторов-обработчиков.
Таким образом, для запуска алгоритма анализа данных в среде
построенной на основе моделе акторов, пользователь должен только задать
настройки среды, указанные выше, и инициализировать ее, вызвав метод
initEnvironment класса ActorCloudExecutionSettings
5.4 Программная реализация параллельного алгоритма анализа данных с
использованием библиотеки
5.4.1 Добавление алгоритма анализа данных в библиотеку
В зависимости от исходного вида описания реализуемого алгоритма
анализа данных, возможно три основных подхода добавления нового алгоритма
в библиотеку DXelopes:
при наличии реализации алгоритма анализа данных, возможна ее
адаптация и последующая декомпозиция на ФОМ;
при наличии алгоритма в описательном виде возможны два подхода:
o реализация алгоритма в виде ФОМ (если описание алгоритма
достаточно формализовано и позволяет выделить отдельные
блоки алгоритма);
191
o реализация алгоритма в монолитном виде и его последующая
декомпозицич на ФОМ (в случае если описание алгоритма
недостаточно формализовано и не позволяет декомпозировать
его на блоки сразу).
Рисунок 5.13 – Программная реализация алгоритма анализа данных.
Общая последовательность реализации алгоритма для разработанной
библиотеки включает следующие шаги (Рисунок 5.13):
1. Реализовать (или найти готовую реализацию) алгоритма или
a. адаптировать реализацию алгоритма для библиотеки
(использовать методы обработки данных и методы сохранения
результата);
2. Декомпозировать алгоритм на ФОМ;
3. Блоки, которые отсутствуют в библиотеке, реализовать в виде ФОМ;
4. Интегрировать ФОМ (из состава библиотеки и вновь реализованные) в
алгоритм анализа данных.
Очевидно, что такая реализация алгоритма анализа данных добавляет
дополнительную трудоемкость в виде 2-4 шага. Однако, это окупается за счет:
Реализация
алгоритма
Формализованное
описание алгоритма
Реализация монолитного
алгоритма в библиотеке
DXelopes
Декомпозиция на блоки
Реализация
функциональных блоков
Интегрировать
функциональные блоки
в алгоритм
Преобразовать к
параллельной форме
Не формализовнное
описание алгоритма
192
возможности использования существующего кода (ФОМ из состава
алгоритма);
возможности простой адаптации алгоритма к параллельному и
распределенному выполнению.
5.4.2 Пример программной реализации алгоритма анализа данных
Рассмотрим программную реализацию алгоритма анализа данных на
примере алгоритма 1R (3.4).
На первом шаге выполняется программная реализация алгоритма к
библиотеке DXelopes. Алгоритм не декомпозируется. Основной задачей
является подключение его к данным и отладка для построения корректной
модели знаний. Программная реализация алгоритма 1R приведена в
Приложении Б.
Далее на основе выражения (2.24) реализуем каждый ФОМ, на которые он
декомпозирован, классом – наследником класса Step (Рисунок 5.14):
1. цикл по атрибутам fd1 - класс AttributesCycleStep;
2. цикл по векторам fd2 - класс VectorsCycleStep;
3. цикл по значениям независимого атрибута f4 - класс
CurrentAttributeValuesCycleStep;
4. цикл по значениям зависимого атрибута f5 - класс
CycleByTargetValues;
5. функция подсчета количества корректных векторов fd3 - класс
IncrementOneRule;
6. функция добавления нового правила f8 - класс AddingOneRule;
7. функция выбора лучшего правила f10 - класс SelectBetterScoreRule.
Рисунок 5.14 – Диаграмма классов программной реализации алгоритма 1R.
194
Из перечисленных функций только ФОМ fd3, f8 и f10 являются
уникальными для алгоритма 1R. Остальные ФОМ характерны для всех
алгоритмов анализа данных или для алгоритмов классификации (к которым
относиться алгоритм 1R). Соответствующие ФОМ есть в составе библиотеки,
поэтому необходимо использовать их. Код классов приведен в листингах 2- 4
Приложения 2.
На следующем шаге необходимо реализовать алгоритм 1R как
последовательность ФОМ. Код метода initSteps соответствующего класса
приведен в листинге 5 Приложения 2.
Для преобразования последовательной формы алгоритма к разным
параллельным формам, достаточно добавить соответствующие объекты
класса ParallelStep, выполняющие распараллеливание по данным или по
задачам. Примеры реализации параллельных форм алгоритма1R приведены в
листингах 6 (строка 7) и 7 (строка 6) Приложения 2.
Для отладки и проверки построенного алгоритма реализован тест, в
котором для заданного набора данных реализована автоматическая проверка
построенной модели. Для алгоритма 1R в листинге 8 Приложения 2 приведен
пример такого теста.
Для проведения экспериментов реализованный алгоритм должен быть
помещен в соответствующую среду выполнения и запущен на наборах
данных с разными характеристиками. Для алгоритма 1R в листинге 9
Приложения 2 приведен пример такого теста.
195
Выводы
В данной главе описана библиотека параллельных алгоритмов анализа
данных, реализующая разработанные модели и методы. Она включает в себя:
1) базовые классы для реализации ФОМ с унифицированным
интерфейсом и свойствами чистой функции, что делает их
потокобезопастными;
2) типовые функции для алгоритмов анализа данных: условные переходы,
циклы, циклы по векторам и атрибутам;
3) функции распараллеливания алгоритмов анализа данных по задачам и
по данным;
4) среду выполнения, которая включает в себя исполнителей
реализованных как потоки, для сильносвязанной среды и как акторы,
для распределенной среды;
5) классы, реализующие адаптеры к многопоточной среде для
выполнения алгоритмов анализа данных в сильносвязанной среде
выполнения;
6) классы, реализующие адаптеры к кластеру акторов для выполнения
алгоритмов анализа данных в распределенной среде выполнения.
В данной главе также описан порядок программной реализации
алгоритмов анализа данных с использованием описанной библиотеки.
196
6. Экспериментальная проверка результатов
Полученные в работе результаты позволяют:
выполнить распараллеливание алгоритма анализа данных
изменением нескольких строк в соответствии с видом
распределения данных;
повысить производительность алгоритма анализа данных за счет его
параллельного выполнения, как в системах с общей, так и с
распределенной памятью;
выполнять анализ распределенных данных, размещая ФОМ на
источниках информации, минимизирую время выполнения и
сетевой трафик.
Для подтверждения перечисленных возможностей был выполнен ряд
экспериментов, со следующими алгоритмами анализа данных:
алгоритм построения классификационных правил 1R;
алгоритм построения вероятностной модели NaïveBayes;
алгоритм кластеризации kMeans;
алгоритм поиска частых наборов Apriori.
Перечисленные алгоритмы решают различные задачи анализа и имеют
разные свойства. Последовательная и параллельная форма алгоритмов были
реализованы по предложенной методике и описаны в Приложении В.
В рамках экспериментов было выполнено сравнение:
измененных строк кода при преобразовании последовательной
формы алгоритма анализа данных в параллельную;
времени выполнения параллельных алгоритмов с
последовательными;
времени и сетевого трафика выполнения анализа распределенных
данных с размещением ФОМ на источниках информации и со
сбором информации в едином хранилище.
197
6.1 Преобразование последовательной формы алгоритма анализа
данных к параллельной форме
6.1.1 Условия проведения эксперимента
Сравнение изменений, которые должны быть сделаны, чтобы
преобразовать последовательную форму алгоритма анализа данных к
последовательной форме, проводились на исходных текстах программ
реализованных в описанной библиотеке алгоритмов:
построения классификационных правил 1R;
построения вероятностной модели NaïveBayes;
кластеризации kMeans;
поиска частых наборов Apriori.
Для всех перечисленных алгоритмов были реализованы ФОМ в виде
соответствующих классов и классы, реализующие их композицию
(наследники класса MiningAlgorithm). Такая реализация соответствует
последовательной форме алгоритма.
Далее, в соответствии с предложенной методикой, были определены
параллельные формы алгоритма для анализа, централизованно хранящихся
данных, а также горизонтально и вертикально хранящихся данных.
Реализованные формы алгоритмов были проверены на одинаковых тестовых
данных. Полученные результаты совпадают, что доказывает корректность
работы последовательной и параллельных реализаций алгоритмов в виде
композиции ФОМ.
Учитывая, что при реализации разных вариантов сами ФОМ не
изменялись, сравнению подлежали только классы, реализующие их
композиции (классы наследники класса MiningAlgorithm).
Для сравнения изменений в коде, использовалась метрика, измеряющая
выполняемые строчки кода (ELOC – Executable Lines of Code) [360].
Учитывая, что в классе, реализующем композицию ФОМ, выполняемые
198
строчки кода создают объекты соответствующих классов, то данная метрика
является адекватной.
6.1.2 Результаты экспериментов
В качестве результатов эксперимента приведены метрики ELOC
(Таблица 6.1) реализации алгоритмов анализа данных в библиотеке,
являющейся программной реализацией полученных результатов. В таблице
6.1. приведены метрики для каждого из рассмотренных алгоритмов. В
качестве метрик использованы:
сумма ELOC для реализаций всех ФОМ алгоритма (колонка 3
Таблица 6.1);
ELOC реализации композиции ФОМ последовательной формы
алгоритма анализа данных (колонка 4 Таблица 6.1);
ELOC реализации композиции ФОМ параллельной формы
алгоритма анализа для анализа централизованно хранящихся
данных (колонка 5 Таблица 6.1);
ELOC реализации композиции ФОМ параллельной формы
алгоритма анализа для анализа горизонтально распределенных
данных (колонка 6 Таблица 6.1);
ELOC реализации композиции ФОМ параллельной формы
алгоритма анализа для анализа вертикально распределенных данных
(колонка 7 Таблица 6.1).
199
Таблица 6.1 Сравнение необходимых изменений при преобразовании последовательной формы в параллельные (ELOC)
Алгоритм Метрика ФОМ
алгоритма
анализа
данных
Последовательная
форма алгоритма
анализа данных
Параллельная форма алгоритма анализа данных
централизованное
хранение
Горизонтальное
распределение
Вертикальное
распределение
1 2 3 4 5 6 7
1R Всего ELOC 61 11 18 18 19
Измененные ELOC - - 7 7 8
% изменений - - 10 10 11
NaïveBayes Всего ELOC 23 4 6 6 9
Измененные ELOC - - 2 2 5
% изменений - - 7 7 19
kMeans Всего ELOC 243 18 20 20 26
Измененные ELOC - - 2 2 8
% изменений - - 1 1 3
Apriori Всего ELOC 432 23 27 27 -
Измененные ELOC - - 4 4 -
% изменений - - 1 1 -
200
Для каждого алгоритма приведено:
общее значение метрики ELOC (Всего ELOC);
число измененных строк для параллельных форм алгоритма
относительно последовательной формы (Измененные ELOC);
процент изменения кода реализации всего алгоритма анализа
данных (% изменений).
6.1.3 Анализ результатов экспериментов
Результаты экспериментов показывают небольшой процент (от 1% до
10%) изменений, вносимых в программную реализацию алгоритмов анализа
данных при их преобразовании из последовательной формы в параллельную.
В случае алгоритма Naïve Bayes более высокий процент (19%) объясняется
общим небольшим числом строк кода. В абсолютном выражении при
распараллеливании для анализа:
централизовано хранящихся данных число изменяемых строк (6
ELOC) определяется числом мест распараллеливания (колонка 5);
распределенных данных большинство изменений (до 8 ELOC)
связано с оптимизацией циклов и как следствие множеством
перестановок в композиции ФОМ (колонки 6 и 7).
Необходимо заметить, что в обоих случаях при преобразовании не
изменяются программные реализации самих ФОМ. При этом именно эта
часть алгоритмов анализа данных является наиболее емкой (составляет от
всего алгоритма от 70 до 90%).
Таким образом, можно сделать вывод, что за счет локализации
изменений в композиции ФОМ, преобразование последовательной формы
алгоритма анализа данных в параллельную, с учетом вида хранения данных,
требует изменения не более 10% программного кода.
201
6.2 Параллельное выполнение алгоритмов анализа данных
6.2.1 Условия проведения эксперимента
Для подтверждения повышения производительности алгоритмов
анализа данных за счет их параллельного выполнения с использованием как
общей, так и распределенной памяти был выполнен ряд экспериментов. На
их основании было выполнено сравнение времени работы алгоритмов
анализа данных, реализованных с использованием полученных результатов, с
алгоритмами, реализованными в наиболее распространенных в настоящее
время библиотеках.
Для экспериментов были использованы данные размещенные в
открытом репозитории Kaggle:
обезличенные анкетные данные о здоровье женщин в разных
штатах Индии6 для алгоритмов классификации;
данные о ценных покупках7 для алгоритмов поиска частых наборов.
Набор данных с анкетной информацией был опубликован в 2015 году
Департаментом здравоохранения и благосостояния семьи правительства
Индии. Основой для этих данных послужил опрос более 4 миллионов
женщин из Индии, с разными условиями проживания, медицинской
страховкой и негативными состояниями. Информация может быть
использована для возможности предсказания исхода беременности, на основе
различных атрибутов – представляющих собой вопросы о состоянии
здоровья, условиях проживания и т.д. Для экспериментов, были выделены
основные 68 атрибутов.
В наборе данных по ценным покупкам содержится обезличенная
информация по покупкам, совершаемым покупателями в разные периоды
времени. В качестве идентификатора транзакции используется
идентификатор покупателя (id) и дата покупки (date). В качестве
6 https://www.kaggle.com/rajanand/ahs-woman-1
7 https://www.kaggle.com/c/acquire-valued-shoppers-challenge
202
идентификатора элемента используется категория товара (category)
(например, газированная вода) и торговая марка товара (brand). Таким
образом, используется четыре атрибута. Всего набор данных содержит
информацию о 350 миллионах купленных товаров более чем 300 тысячами
покупателей за период более одного года.
Для выполнения экспериментов было сформировано несколько
наборов данных разного объема (Таблица 6.2 и Таблица 6.2). Каждый набор
содержал подмножество векторов большего набора (т.е. набор объемом 100
Мб, содержал подмножество векторов из набора объемом 500 Мб и т.д.).
Набор с максимальным объемом содержал все вектора. Наборы имеют
названия, содержащие в себе значение размера (например, набор объемом
1Гб называется ds1, набор объемом 2Гб называется ds2 и т.д.).
Все наборы данных были сохранены в файлах формата CSV. Данный
формат легковесен, не содержит никакой метаинформации и легко читается,
что очень важно при чтении больших объемов данных.
Эксперименты проводились для всех описанных выше алгоритмов
анализа данных на многоядерном компьютере со следующей конфигурацией:
CPU: Intel Xenon (12 cores) 2.9 ГГц, ОЗУ: 4 Гб, ОС: Windows 7, JDK 1.7.
Параллельные алгоритмы выполнялись на 2х, 4х, 8ми и 12ти ядрах.
Для сравнения эксперименты выполнялись со следующими формами
алгоритмов анализа данных (описанных в данной работе):
последовательной формой;
параллельной формой исходного алгоритма;
параллельной формой c распараллеливанием по векторам;
параллельной формой с распараллеливанием по атрибутам.
Распараллеливание исходного алгоритма анализа данных,
соответствует параллельной форме, используемой при централизованном
хранении данных. Предварительная оптимизация циклов при этом не
выполняется и распараллеливание осуществляется по всем возможным
ФОМ.
203
Распараллеливание алгоритма анализа данных по векторам
предполагает предварительное перемещение цикла по векторам в основную
последовательность. Параллельное выполнение такой формы алгоритма
анализа данных возможно на любое число ядер. В этом случае между ядрами
разделяется все множество векторов. Таким образом, эксперименты для
данного варианта выполнялись на 2х, 4х, 8ми и 12ти ядрах.
Распараллеливание алгоритма анализа данных по атрибутам
предполагает предварительное перемещение цикла по атрибутам в основную
последовательность. При этом выполняется параллельный анализ
независимых атрибутов, которых в экспериментальном наборе данных всего
68. Таким образом, эксперименты для данного варианта выполнялись на 2х,
4х, 8ми и 12ти ядрах.
Для сравнения с другими реализациями алгоритмов анализа данных,
выполнялись эксперименты с наиболее популярными, свободно
распространяемыми библиотеками алгоритмов анализа данных с открытым
кодом: RapidMiner и WEKA, а также с системой выполняющей параллельные
вычисления на основе модели MapReduce – Apache Spark MLLib. Для нее
эксперименты также выполнялись на 2х, 4х, 8ми и 12ти ядрах.
Все эксперименты выполнялись по 10 раз в одинаковых условиях.
Аномальные значения (существенно отличающиеся от средних) из
результатов экспериментов исключались. Остальные результаты были
усреднены и представлены в Таблица 6.4.
6.2.2 Результаты экспериментов
Результаты экспериментов для разных алгоритмов анализа данных
представлены в Таблица 6.4.
204
Таблица 6.2. Экспериментальные наборы данных для алгоритмов классификации и кластеризации
Наборы данных ds1 ds2 ds3 ds4 ds5 ds6 ds7 ds8 ds9 ds10
Количество векторов (миллион) 50 99 151 200 251 299 352 401 448 503
Количество атрибутов 9 9 9 9 9 9 9 9 9 9
Объем данных (Гб) 1 2 3 4 5 6 7 8 9 10
Таблица 6.3. Экспериментальные наборы данных для алгоритмов поиска частых наборов
Наборы данных ds1 ds2 ds3 ds4 ds5 ds6 ds7 ds8 ds9 ds10
Количество векторов (миллион) 35 72 105 143 178 212 245 280 316 350
Количество атрибутов 4 4 4 4 4 4 4 4 4 4
Объем данных (Гб) 1 2 3 4 5 6 7 8 9 10
Таблица 6.4. Результаты экспериментов (сек.)
Библиотека Форма алгоритма Ядер ds1 ds2 ds3 ds4 ds5 ds6 ds7 ds8 ds9 ds10
1 2 3 4 5 6 7 8 9 10 11 12 13
Weka 1R 1 14 27 41 53 65 75 85 102 113 128
Naïve Bayes 1 12 22 34 44 54 62 71 85 94 106
kMeans 1 27 52 79 101 124 143 163 195 216 245
Apriori 1 51 96 147 190 232 268 304 364 403 458
RapidMiner 1R 1 24 46 71 91 111 128 145 174 193 219
Naïve Bayes 1 20 38 59 76 92 107 121 145 161 182
kMeans 1 47 88 135 174 213 246 279 334 370 420
205
Библиотека Форма алгоритма Ядер ds1 ds2 ds3 ds4 ds5 ds6 ds7 ds8 ds9 ds10
1 2 3 4 5 6 7 8 9 10 11 12 13
Apriori 1 88 165 253 325 397 459 521 624 691 784
Apache Spark
MLLib
1R 1 22 42 65 81 94 117 133 160 177 201
2 21 28 38 48 62 69 78 90 102 111
4 17 18 22 29 39 41 44 50 55 63
8 12 15 16 20 24 25 26 29 32 36
12 11 13 15 16 17 20 21 22 24 26
Naïve Bayes 1 17 32 49 61 71 89 101 121 134 152
2 10 17 27 34 37 48 55 67 71 77
4 6 10 16 19 21 26 29 36 39 42
8 4 6 9 10 12 14 16 17 20 23
12 3 4 5 6 8 8 9 10 12 15
kMeans 1 43 81 124 154 180 225 256 306 339 385
2 40 53 73 91 111 129 149 172 195 213
4 33 35 43 53 71 71 83 96 106 121
8 23 28 30 38 43 48 51 56 61 68
12 20 25 28 30 33 38 40 43 46 51
Apriori 1 80 151 232 289 316 421 478 572 634 739
2 76 143 192 211 248 351 389 467 511 557
4 61 98 123 154 179 203 243 299 354 398
8 49 57 68 89 121 153 184 213 237 267
206
Библиотека Форма алгоритма Ядер ds1 ds2 ds3 ds4 ds5 ds6 ds7 ds8 ds9 ds10
1 2 3 4 5 6 7 8 9 10 11 12 13
12 40 51 62 75 87 91 109 132 151 176
DXelopes 1R 1 18 29 40 53 72 78 95 113 123 130
1RParall 2 12 19 24 33 39 43 49 58 64 69
4 10 12 16 18 24 26 28 31 34 38
8 7 8 11 12 14 16 19 20 21 22
12 6 7 8 10 10 12 13 14 15 16
NB 1 15 24 33 44 59 65 79 94 111 127
NBParall 2 8 13 17 24 31 35 41 51 58 64
4 5 7 9 13 17 19 21 26 28 35
8 3 4 5 7 9 10 11 13 16 19
12 2 3 4 5 6 6 7 8 10 12
kMeans 1 35 55 76 101 124 150 173 193 219 247
kMeansParall 2 25 37 46 58 75 83 94 110 122 131
4 18 23 30 35 44 48 53 60 64 74
8 14 16 21 25 29 35 37 39 41 43
12 12 14 16 18 21 23 25 28 29 31
Apriori 1 55 103 142 189 212 280 323 361 409 434
AprioriParall 2 47 69 86 108 154 163 176 206 228 304
4 34 43 56 65 97 90 99 112 120 189
8 26 38 47 58 67 73 79 87 101 122
12 22 28 37 40 46 52 58 67 76 84
207
Результаты экспериментов сгруппированы по:
библиотеке алгоритмов анализа данных, участвовавшей в
экспериментах (столбец 1);
алгоритмам анализа данных и их параллельным формам, для
которых проводились эксперименты (столбец 2);
количеству ядер (столбец 3).
В столбцах 4-13 указано время выполнения формы алгоритма на
указанном числе ядер при анализе соответствующего набора данных. Время
выполнения указано в секундах.
6.2.3 Анализ результатов экспериментов
Анализ полученных результатов показал общие зависимости для всех
алгоритмов анализа данных. Отличие заключается во времени выполнения,
которое зависит от сложности конкретного алгоритма.
Для анализа полученных результатов выполнено сравнение времени
выполнения параллельных форм алгоритмов с их последовательной
реализацией (Рисунок 6.1- Рисунок 6.4). Также было выполнено сравнение
эффективности этих алгоритмов (Рисунок 6.5 - Рисунок 6.8).
В первую очередь необходимо отметить, что параллельные варианты
всех алгоритмов выполняются быстрее, чем их последовательные формы.
При этом, время выполнения последовательного алгоритма в библиотеке
Xelopes больше времени выполнения последовательного алгоритма из
библиотеки WEKA (при этом оно значительно меньше времени выполнения
алгоритма из библиотеки RapidMinier). Это объясняется унифицированной
реализацией алгоритма анализа данных в библиотеке DXelopes и накладными
расходами необходимыми для этого. При этом, при распараллеливании
алгоритма даже на 2 потока выполнение алгоритмов анализа данных в
библиотеке DXelopes становится быстрее, чем в библиотеке Weka.
208
Рисунок 6.1 – Сравнение времени выполнения
параллельного алгоритма 1R.
Рисунок 6.2 – Сравнение времени выполнения
параллельного алгоритма Naïve Bayes.
209
Рисунок 6.3 – Сравнение времени выполнения
параллельного алгоритма kMeans.
Рисунок 6.4 – Сравнение времени выполнения
параллельного алгоритма Apriori.
210
Рисунок 6.5 – Сравнение эффективности параллельного
алгоритма 1R.
Рисунок 6.6 – Сравнение эффективности параллельного
алгоритма Naïve Bayes.
211
Рисунок 6.7 – Сравнение эффективности параллельного
алгоритма kMeans.
Рисунок 6.8 – Сравнение эффективности параллельного
алгоритма Apriori.
212
Также необходимо заметить, что эффективность распараллеливания
алгоритмов анализа данных растет с увеличением объема анализируемых
данных (Рисунок 6.5 - Рисунок 6.8). Так при объеме данных в 1 Гб
эффективность для 4–12 ядер практически не изменяется. В то время как для
данных объемом более 2 Гб она продолжает увеличиваться.
Это объясняется соразмерностью времени, затраченного на
выполнение анализа данных и времени на распараллеливание (связанного с
созданием/завершением потоков, запуском потоков, разделением циклов и
т.п.). При этом время, необходимое для распараллеливания, увеличивается с
ростом числа потоков. При небольших объемах данных время анализа
сравнимо со временем распараллеливания для 4 и более потоков. При
увеличении объема данных время анализа растет, при этом время
распараллеливания не изменяется. Таким образом, эффективность
распараллеливания наиболее эффективна при анализе больших объемов
данных. Аппроксимируя полученные зависимости эффективности от объема
данных, можно сделать вывод, что с увеличением объемов данных,
масштабируемость распараллеливания будет увеличиваться.
Реализация всех вариантов распараллеливания алгоритмов анализа
данных, в библиотеке DXelopes показывает лучший результат, чем их
реализация в Apache Spark MLLib. Предложенный подход имеет лучший
результат, как при увеличении объема анализируемых данных, так и при и
увеличении числа ядер. Это объясняется использованием в Apache Spark
распределенной памяти и необходимостью последующего объединения
полученных результатов, что требует дополнительного времени.
Высокая эффективность алгоритма Naïve Bayes объясняется его
особенностями. Он выполняет один проход по данным и формирует модель
знаний, которая не зависит от объема данных (зависит только от количества
атрибутов). Кроме того, он позволяет построение модели знаний в общей
памяти, т.к. не имеет жестких информационных зависимостей между
блоками алгоритма. Это позволяет выполнять алгоритм без дополнительных
213
операций по объединению результатов, полученных параллельными ветвями
алгоритма.
Очевидно, что в алгоритмах с более сложной структурой не удастся
достигнуть такой же эффективности. Так алгоритм Apriori, имеет худшую
эффективность. Особенно низкими результаты оказались для Apache Spark
MLLib. Это связано с большим размером модели знаний, формируемой
алгоритмом Apriori. Число элементов такой модели знаний напрямую
зависит от объема анализируемых транзакций и входящих в нее объектов.
При этом, из-за необходимости объединения моделей знаний, построенных в
распределенной памяти Apache Spark, время выполнения значительно
увеличивается.
Таким образом, декомпозиция последовательного алгоритма на ФОМ
замедляет выполнение алгоритма. Однако, простое преобразование их к
параллельной форме, позволяет значительно ускорить выполнение алгоритма
на многоядерном процессоре. При этом эффективность повышается с
увеличением объема анализируемых данных и при небольших размерах
строящейся модели знаний.
6.3 Распределенное выполнение алгоритмов анализа данных
6.3.1 Условия проведения эксперимента
Для подтверждения уменьшения времени выполнения алгоритма и
сетевого трафика при анализе распределенных данных с использованием
полученных результатов, были выполнены эксперименты в виртуальной
распределенной среде. Для виртуализации использовалась система Microsoft
Hyper-V. Она была установлена на кластере, включающем в себя следующие
вычислительные ресурсы:
вычислительный узел IBM FlexSystem x240 со следующими
характеристиками:
o процессор IntelXeon 2.9GHz (2 CPU с 6 ядрами);
214
o оперативная память 128 GB;
o производительность сервера 200 GFlops;
вычислительный узел IBM FlexSystem p260 со следующими
характеристиками:
o процессор Power7 3.3GHz (2 CPU с 4 ядрами);
o оперативная память 128 GB;
o производительность сервера 400 GFlops;
две системы хранения данных Storwizev700 с объемом хранилища
13,6 TB.
Распределенная среда представляла собой набор виртуальных машин,
объединенных в виртуальную сеть, в которой эмулировались задержки и
низкая пропускная способность (Рисунок 6.9). Каждой виртуальной машине
было выделено по 2 ядра. Все виртуальные машины работали под
управлением ОС Windows 10. Кроме того, на них были установлены JDK
версии 1.7 и 1.8, библиотека параллельных алгоритмов анализа данных
DXelopes и библиотека модели акторов AKKA..
На части виртуальных машин были размещены наборы данных для
анализа. Для экспериментов были использованы наборы данных из
публичных репозиториев, описанных в предыдущем разделе.
Для выполнения экспериментов с централизованным хранением
информации набор данных размещался на одном узле, а алгоритм анализа
данных выполнялся на другом узле (Рисунок 6.9 а). При этом сам алгоритм
выполнялся на максимальном числе ядер - 12.
215
Рисунок 6.9 – Виртуальная распределенная среда (а - с централизованным
хранением данных; б – с распределенным хранением данных).
Для выполнения экспериментов с распределенными данными они были
разбиты на равные 2, 4 и 8 наборов (Таблица 6.5):
по векторам (горизонтально) для всех алгоритмов анализа данных;
по атрибутам (вертикально) для алгоритмов классификации и
кластеризации.
При вертикальном разбиении сопоставление векторов выполнялось по
их порядковому номеру в наборе. Необходимо также заметить, что для
алгоритмов поиска частых наборов, вертикальное распределение не имеет
смысла, т.к. данные хранятся в виде транзакций, которые не могут быть
разделены.
Виртуальная машина
DXelopes AKKA
Виртуальная машина
DXelopes AKKA ds10
Виртуальная машина
DXelopes AKKA ds2
Виртуальная машина
DXelopes AKKA ds1
Виртуальная машина
DXelopes AKKA
Виртуальная машина
ds
б)
а)
t1 t12
t1 t2
t1 t2
t1 t2
216
Все поднаборы данных были размещены на распределенных узлах. При
этом библиотека алгоритмов анализа данных устанавливалась, в том числе и
на узлах с данными (Рисунок 6.9, б).
Эксперименты проводились для всех описанных выше алгоритмов
анализа данных. В соответствии с типом распределения данных,
использовались соответствующие формы параллельных алгоритмов:
для централизованного хранения информации использовалась
параллельная форма исходного алгоритма (*Parall);
для горизонтального распределения данных использовалась
параллельная форма c распараллеливанием по векторам
(*ParallHor);
для вертикального распределения данных использовалась
параллельная форма с распараллеливанием по атрибутам
(*ParallVer).
При централизованном хранении все алгоритмы анализа данных
выполнялись на 12 потоках. При анализе распределенных данных, ФОМ,
выполняющиеся на узлах-источниках, дополнительно были распараллелены
по векторам на 2 потока. Для распределенного выполнения был сформирован
кластер акторов (Рисунок 6.10), объединяющий виртуальные машины.
Рисунок 6.10 –Схема организации кластера акторов.
217
Узлы кластера соединены посредством протокола UDP, поэтому для
имитации низкой пропускной способности СПД использовался троттлинг
канала. Уровень троттлинга, используемый для экспериментов – 2 Мбит/с.
Для сравнения с другими реализациями параллельных алгоритмов
анализа данных в экспериментах участвовал Apache Spark MLLib. Он работал
на вычислительном узле, выполняя алгоритм анализа данных на 12 ядрах.
При этом данные также хранились на других 2х, 4х, и 8ми виртуальных
машинах.
Все эксперименты выполнялись по 10 раз в одинаковых условиях.
Аномальные значения (существенно отличающиеся от средних) из
результатов экспериментов исключались. Остальные результаты были
усреднены и представлены в.
6.3.2 Результаты экспериментов
Время выполнения алгоритмов анализа распределенных данных
представлены в Таблица 6.7, сетевой трафик в Таблица 6.8. Результаты
экспериментов сгруппированы по:
алгоритмам анализа данных, для которых проводились
эксперименты (столбец 1).
библиотеке алгоритмов анализа данных, участвовавшей в
экспериментах (столбец 2).
218
Таблица 6.5. Экспериментальные наборы данных для алгоритмов классификации и кластеризации
Наборы данных Централ.
хранение
Горизонтально
распределенные данные
Вертикально распределенные
данные
ds ds1, ds2 ds1-ds4 ds1-ds8 ds1, ds2 ds1-ds4 ds1-ds8
Количество векторов (миллион) 503 251 126 63 503 503 503
Количество атрибутов 68 68 68 68 34 17 8
Объем данных (Гб) 10 5 2,5 1,25 5 2,5 1,25
Таблица 6.6. Экспериментальные наборы данных для алгоритмов поиска частых наборов
Наборы данных Централ.
хранение
Горизонтально распределенные данные
ds ds1, ds2 ds1-ds4 ds1-ds8
Количество векторов (миллион) 350 125 62 31
Количество атрибутов 4 4 4 4
Объем данных (Гб) 10 5 2,5 1,25
219
Таблица 6.7. Результаты экспериментов (время выполнения, сек.)
Aлгоритм Библиотека Централ.
хранение
Горизонтально распределенные данные Вертикально распределенные данные
ds ds1, ds2 ds1-ds4 ds1-ds8 ds1, ds2 ds1-ds4 ds1-ds8
1 2 - 2Мб/с - 2Мб/с - 2Мб/с - 2Мб/с - 2Мб/с - 2Мб/с - 2Мб/с
3 4 5 6 7 8 9 10 11 12 13 14 15 16
1R
Spark MLLib 31 >4x104 34 >4x10
4 37 >4x104 40 >4x10
4 36 >4x104 39 >4x10
4 42 >4x104
DXelopes 21 25 39 45 23 27 18 23 40 46 24 31 20 26
NB Spark MLLib 25 >4x104 28 >4x10
4 30 >4x104 33 >4x10
4 29 >4x104 31 >4x10
4 34 >4x104
DXelopes 20 25 37 42 21 26 15 21 39 45 25 30 17 23
kMeans Spark MLLib 56 >4x104 62 >4x10
4 67 >4x104 73 >4x10
4 64 >4x104 70 >4x10
4 76 >4x104
DXelopes 36 41 83 89 56 62 32 38 82 87 51 57 29 36
Apriori Spark MLLib 179 >4x104 197 >4x10
4 215 >4x104 233 >4x10
4
DXelopes 87 >7x103 270 >7x10
3 190 >7x10
3 122 >7x10
3
220
Таблица 6.8. Результаты экспериментов (сетевой трафик, Мб.)
Библиотека Форма
алгоритма
Централ.
хранение
Горизонтально
распределенные данные
Вертикально распределенные
данные
ds ds1, ds2 ds1-ds4 ds1-ds8 ds1, ds2 ds1-ds4 ds1-ds8
1 2 3 4 5 6 7 8 9
1R
Spark MLLib 12000 14000 16000 19000 14000 16000 19000
DXelopes 12000 23 34 56 25 39 63
NB Spark MLLib 12000 13000 15000 18000 13000 15000 18000
DXelopes 12000 14 16 18 16 19 21
kMeans Spark MLLib 34000 37000 42000 51000 37000 42000 51000
DXelopes 34000 122 132 146 234 438 988
Apriori Spark MLLib 24000 26000 34000 42000
DXelopes 24000 3000 3000 3000
221
Для каждого алгоритма анализа данных приведено время выполнения
(Таблица 6.7) для:
централизованного хранения данных, при котором анализ выполнялся с
передачей данных от узла-источнику к узлу, на котором выполнялся
анализ:
o без ограничений на СПД (столбец 3);
o с ограничение в 2 Мбит/с (столбец 4);
горизонтально распределенных данных на:
o 2х узлах источниках:
без ограничений на СПД (столбец 5);
с ограничение в 2 Мбит/с (столбец 6);
o 4 узлах источниках:
без ограничений на СПД (столбец 7);
с ограничение в 2 Мбит/с (столбец 8);
o 8 узлах источниках:
без ограничений на СПД (столбец 9);
с ограничение в 2 Мбит/с (столбец 10);
вертикально распределенных данных на:
o 2х узлах источниках:
без ограничений на СПД (столбец 11);
с ограничение в 2 Мбит/с (столбец 12);
o 4 узлах источниках:
без ограничений на СПД (столбец 13);
с ограничение в 2 Мбит/с (столбец 14);
o 8 узлах источниках:
без ограничений на СПД (столбец 15);
с ограничение в 2 Мбит/с (столбец 16);
Для каждого алгоритма анализа данных приведен сетевой трафик (Таблица
6.8) для:
централизованного хранения данных (столбец 3);
222
горизонтально распределенных данных на:
o 2х узлах источниках (столбец 4);
o 4 узлах источниках (столбец 5);
o 8 узлах источниках (столбец 6);
вертикально распределенных данных на:
o 2х узлах источниках (столбец 7);
o 4 узлах источниках (столбец 8);
o 8 узлах источниках (столбец 9).
6.3.3 Анализ результатов экспериментов
Для анализа результатов было выполнено сравнение времени выполнения
(Рисунок 6.11 - Рисунок 6.14) алгоритмов анализа централизованно и
распределено хранящихся данных, а также сравнение сетевого трафика,
возникающего в процессе анализа (Рисунок 6.16 - Рисунок 6.19). Кроме того,
было выполнено сравнение времени выполнения алгоритмов анализа данных без
ограничения и с ограничением пропускной способности СПД (Рисунок 6.15).
Необходимо заметить, что диаграммы на рисунках 6.15 – 6.19 имеют
логарифмическую шкалу, в связи с существенной разницей в порядках
полученных величин.
Использование общей памяти невозможно при анализе распределенных
данных. В связи с этим необходимо выполнение объединения результатов,
полученных при распределенном анализе. Это требует дополнительного времени,
к времени распараллеливания. В этой связи время выполнения анализа данных
распределенных по 2м, 4м и 8ми узлам с учетом дополнительного
распараллеливания на каждом узле на 2 потока больше времени параллельного
анализа на соответствующем числе потоках (Таблица 6.4).
223
Рисунок 6.11 – Сравнение времени выполнения распределенного алгоритма 1R
(а) при горизонтальном распределении; б) при вертикальном распределении).
Рисунок 6.12 – Сравнение времени выполнения распределенного алгоритма Naïve Bayes
(а) при горизонтальном распределении; б) при вертикальном распределении).
224
Рисунок 6.13 – Сравнение времени выполнения распределенного алгоритма KMeans
(а) при горизонтальном распределении; б) при вертикальном распределении).
Рисунок 6.14 – Сравнение времени выполнения распределенного алгоритма Apriori
при горизонтальном распределении.
225
Рисунок 6.15 – Сравнение времени выполнения распределенных алгоритмов
при уровне троттлинга - 2Мбит/с.
226
Рисунок 6.16 – Сравнение сетевого трафика распределенного алгоритма 1R
(а) при горизонтальном распределении; б) при вертикальном распределении).
Рисунок 6.17 – Сравнение сетевого трафика распределенного алгоритма Naïve Bayes
(а) при горизонтальном распределении; б) при вертикальном распределении).
227
Рисунок 6.18 – Сравнение сетевого трафика распределенного алгоритма kMeans
(а) при горизонтальном распределении; б) при вертикальном распределении).
Рисунок 6.19 – Сравнение сетевого трафика распределенного алгоритма Apriori
при горизонтальном распределении.
228
Дополнительное время также затрачивается на пересылку моделей знаний.
В данном случае, оно составляет порядка 5-10 секунд, т.к. объем трафика не
превышает пропускную способность каналов связи (для случая без ограничений
пропускной способности СПД). Кроме того, эксперименты проводились на
виртуальных машинах в одном кластере, следовательно, латентность сети была
минимальна.
Время выполнения анализа вертикально и горизонтально распределенных
данных не одинаково, однако отличается незначительно. Это связано с разными
операциями, выполняемыми при объединении моделей знаний, строящимися
алгоритмами:
при горизонтальном распределении, объединение заключается, как
правило, в выполнении функции агрегирования для вычисляемых
параметров элементов модели знаний (например, суммирования
количества корректных векторов для алгоритма 1R);
при вертикальном распределении, как правило, происходит объединение
списков элементов моделей знаний (например, классификационных
правил, построенных для разных атрибутов, в алгоритме 1R).
По своей вычислительной сложности данные операции соизмеримы и время
для разных типов распределения данных отличается незначительно. При этом
время анализа не меняется в зависимости от типа распределения данных, т.к. в
обоих случаях выполняется одна и та же ФОМ алгоритма, меняется только
порядок анализа ими значений атрибутов векторов:
при горизонтальном распределении блок применяется ко всем атрибутам
каждого вектора;
при вертикальном распределении блок применяется к каждому атрибуту
всех векторов.
Сетевой трафик незначительно отличается для разного типа распределения
данных и количества распределенных узлов. Увеличение сетевого трафика при
увеличении числа распределенных источников, связано с увеличением числа
пересылаемых моделей знаний. При наличии двух узлов передается две модели
229
знаний, при четырех узлах четыре модели знаний. Для алгоритмов 1R, Naïve
Bayes и kMeans, размер модели знаний не зависит от объема данных,
следовательно, для разных узлов объем передаваемой информации будет
одинаков. Таким образом, для этих алгоритмов сетевой трафик напрямую зависит
от числа распределенных источников. В отличие от них, алгоритм Apriori строит
модель знаний, имеющую большой размер, который зависит от анализируемых
данных. Следовательно, в совокупности сетевой трафик для алгоритма Apriori при
увеличении числа узлов-источников меняется незначительно.
В результате сравнения анализа распределенных данных в библиотеке
DXelopes и Apache Spark MLLib можно сделать следующие выводы:
перенос ФОМ на узлы-источники позволяет сократить время на
выполнение анализа данных при увеличении числа узлов-источников за
счет распараллеливания алгоритма;
сетевой трафик в подходе с переносом части вычислений на узел
источников, значительно меньше (в десятки раз), чем при сборе всех
данных на локальном узле;
при наличии ограничений на пропускную способность СПД в варианте с
переносом ФОМ на узлы источники время выполнения алгоритма
увеличивается незначительно, в то время как в варианте с передачей
данных к месту анализа время выполнения увеличивается в сотни раз.
для алгоритмов анализа данных, строящих модели знаний большого
размера (например, для алгоритма Apriori с объемом модели знаний до 1
ГБ) разница между двумя вариантами, как во времени выполнении, так и
в сетевом трафике меньше, однако преимущества остаются.
Таким образом, можно сделать вывод, что при большом числе узлов-
источников для алгоритмов анализа данных, строящих модели знаний малого
объема, подход с переносом вычислений «ближе» к данным дает существенное
повышение производительности и снижение сетевого трафика.
230
Выводы
В данной главе приведены результаты экспериментов выполненных с
помощью программной реализации, описанной в предыдущей главе на
вычислительном кластере. Результаты экспериментов позволили подтвердить
следующие результаты:
1) предложенная функциональная модель алгоритма анализа данных,
позволяет оптимизировать структуру алгоритма в соответствии с типом
распределения данных и соответствующее распараллеливание
минимальным числом изменением в коде (не более 10%);
2) предложенный подход позволяет распараллеливать алгоритмы анализа
данных с увеличением производительности, который зависит от
сложности алгоритма, а также от размера строящейся модели знаний;
3) выполненная программная реализация работает быстрее аналогичных
библиотек, причем производительность существенно возрастает при
параллельном выполнении алгоритмов и использовании преимуществ
работы с общей памятью;
4) предложенный подход позволяет оптимизировать параллельные формы
алгоритмов анализа в зависимости от вида хранения данных, обеспечивая
распределение ФОМ по узлам-источникам, что в свою очередь позволяет
существенно (в сотни раз):
a. повысить производительность выполнения анализа;
b. снизить сетевой трафик при выполнении анализа.
5) повышение производительности и снижение сетевого трафика для
варианта с выполнением анализа на узлах-источниках зависит от
сложности алгоритма и размера строящейся модели.
231
7. Практическое использование результатов исследований в
народно-хозяйственной деятельности
В настоящее время повышается актуальность анализа распределенных
данных большого объема. Часто такие данные хранятся в среде, имеющей каналы
передачи данных с низкой пропускной способностью (спутниковые,
беспроводные и др.). Они не позволяют передавать данные больших объемов от
источников к месту выполнения алгоритмов анализа. Невозможность передачи
данных также может быть связана с конфиденциальным характером информации.
Предложенные методы и модели были успешно использованы при решении
следующих прикладных задач в разных сферах народно-хозяйственной
деятельности:
создание облачного сервиса выполнения ИАД в различных распределенных
средах;
решения аналитических задач в рамках единого информационного
пространства отечественной орбитальной группировки с целью повышения
устойчивости и оперативности управления ею;
анализ результатов выполнения сеансов связи средствами наземного
автоматизированного комплекса управления космическими аппаратами с
целью оценки достаточности средств и выработки рекомендаций по
дооснащению, планированию запусков КА и эксплуатации средств НАКУ;
сбор телеметрии с территориально распределенных измерительных средств от
движущихся объектов по каналам связи, имеющим ограниченную пропускную
способность в режиме реального времени.
232
7.1 Облачный сервис выполнения интеллектуального анализа данных в
различных распределенных средах
7.1.1 Целевая задача
Облачный сервис выполнения ИАД в различных средах разрабатывался в
рамках гранта «Математические методы, распределенные вычислительные и
когнитивные технологии и быстрые алгоритмы интеллектуального анализа и
обеспечения безопасности и непрерывности данных для моделирования и
управления антропогенными системами», поддержанного Министерством
образования РФ (Госзадание – 2014-2016 г.). Проект направлен на разработку
платформы ИАД из разных распределенных источников с использованием
масштабируемых вычислительных ресурсов на основе облачных вычислений [25].
Несмотря на интенсивное развитие облачных вычислений, систем ИАД и
обработки данных большого объема нерешенными проблемами сегодня остаются:
отсутствие библиотек параллельных алгоритмов анализа данных для
исследователей и разработчиков, системы распараллеливания и тестирования
алгоритмов анализа данных для разработчиков, on-line системы анализа данных
для аналитиков, предоставляющие масштабируемые вычислительные ресурсы.
Разработанный проект позволяет в значительной степени устранить эти
проблемы.
Данная платформа создана в интересах:
1. разработчиков программ и алгоритмов (исследователей) в области анализа
данных, предоставляя среду и вычислительные мощности для отладки и
исследования параллельных и распределенных версий алгоритмов, а также
фреймворк и средство для локальной разработки и отладки алгоритмов;
2. аналитиков, предоставляя сервисы ИАД различными методами, обработки
данных (преобразования, очистки и т.п.) на «неограниченных»
вычислительных ресурсах.
В настоящее время реализован прототип платформы, развернутый на базе
факультета компьютерных технологий и информатики Санкт-Петербургского
233
Государственного электротехнического университета “ЛЭТИ”, успешно
использующийся в учебном процессе.
Платформа предоставляет сервисы для анализа данных, хранящихся, в том
числе, вне облака, как в интересах аналитиков, так и в интересах разработчиков
(исследователей) в области ИАД. Архитектура платформы (Рисунок 7.1)
позволяет расширять различные сервисы, в том числе и «частные» сервисы для
использования ограниченным кругом лиц [361]. Кроме того, она позволяет
распараллеливать, тестировать и оценивать характеристики разрабатываемых
алгоритмов и программ анализа данных, подбирать оптимальную структуру
алгоритма при заданной архитектуре вычислительной среды, подбирать
оптимальную архитектуру вычислительной среды для реализации алгоритмов,
извлечения данных из хранилища, построения конечных моделей.
Разработанная платформа может быть размещена на аппаратных средствах
заказчика, создавая тем самым основу приватного облака интеллектуального
анализа. Это обеспечит заказчику возможность использовать все преимущества
платформы без необходимости передачи данных другому исполнителю.
7.1.2 Решаемые проблемы
Основной проблемой применения алгоритмов ИАД в распределенных
системах является необходимость распараллеливания таких алгоритмов и их
адаптации к распределенному выполнению в различных вычислительных средах.
Для решения этих проблем были применены результаты, полученные в данной
работе.
Ядром разрабатываемой платформы является библиотека распределенных
алгоритмов анализа данных (Рисунок 7.1). Принципы, заложенные в библиотеку,
позволяют расширять ее новыми алгоритмами ИАД, в том числе с
использованием уже имеющихся ФОМ, а также выполнять их параллельно и
распределенно.
Наличие в библиотеке адаптеров к разным распределенным системам
(Рисунок 7.2) позволяют интегрировать библиотеку с новыми системами
234
распределенных вычислений. За счет этого уже имеющиеся в библиотеки
алгоритмы будут работать на новых распределенных системах без необходимости
их модернизации (тем самым позволяя проводить новые исследования и получать
более производительный анализ без дополнительных усилий).
Наличие в библиотеке адаптеров к ETL средствам позволяет интегрировать
библиотеку с новыми средствам извлечения, обработки и загрузки данных
(помимо CloverETL), которые могут быть интегрированы в платформу. Это
позволяет расширить возможности платформы в части обработки данных, а также
при необходимости использовать более привычные для пользователя средства
[362].
Распределенные системы представляют собой пул заранее подготовленных
(имеющих предустановленное и настроенное ПО) виртуальных машин,
объединенных в кластеры распределенных вычислений [21-16]. В таких
виртуальных кластерах установлены и настроены системы распределенных
вычислений (в настоящее время реализована интеграция с системами: Java
Threads и Akka (модель акторов)).
235
Облако интеллектуального анализа данных
Библиотека распределенных
алгоритмов Data Mining (DXelopes)
Модуль преобразования и загрузки
данных (CloverETL)
Модуль загрузки
данных
формата
Модуль загрузки
данных
формата
Модуль загрузки
данных
формата
Модуль очистки
данных
формата
Модуль очистки
данных
формата
Модуль очистки
данных
форматаМодуль
преобразования
данных
Модуль
преобразования
данных
Модуль
преобразования
данных
Алгоритм Data
MiningАлгоритм Data
MiningАлгоритм Data
Mining
Адаптер к
распределенной
системе
Адаптер к
распределенной
системе
Адаптер к
распределенной
системе
Облачные технологии
Распределенные системы
ПО
промежуточного
уровня
AKKAApache Hadoop
Модуль управления
пользователями
Модуль управления
проектами
Репозиторий метаданных
Data Mining
БД проектов
БД пользователей
Модуль управления
анализом
Источники
данных
Источники
данных
Источники
данных
Источники
данных
Адаптер к
средствам ETLАдаптер к
средствам ETL
ГипервизорыМенеджеры
VM
Сетевые
менеджеры
Виртуализация
ресурсовФХ
AP
I C
DM
We
b и
нте
рф
ей
с
Сторонние
системы
Аналитик
Разработчик
Источники
данных
Источники
данных
Рисунок 7.1 – Функциональная архитектура платформы ИАД из разных распределенных источников
236
Кластер распределенных вычислений
Виртуальная машина
Виртуальная
машина
Виртуальная
машина
Виртуальная
машина
Виртуальная
машинаОС
DXelopes
Элементы распределенной системы:
Акторы, Jobы и дрA
PI D
Xe
lop
es
Алгоритм Data
MiningАлгоритм Data
MiningАлгоритм Data
Mining
Адаптер к распределенной системе
Адаптер к средствам ETL
Модуль преобразования и загрузки данных
(CloverETL)
Модуль анализа
AP
I R
ES
T
Модуль
управления
Рисунок 7.2 – Конфигурация кластера распределенных вычислений
237
7.2.3 Используемые подходы
Разработанная платформа использует следующие результаты, полученные в
данной работе:
1. функциональная модель алгоритма анализа данных;
2. модель параллельного алгоритма анализа данных;
3. метод распараллеливания последовательных алгоритмов анализа данных;
4. метод размещения функций алгоритмов анализа данных в среде
выполнения;
5. программная реализация модели параллельного выполнения алгоритма
анализа данных в виде библиотеки.
Библиотека предоставляет возможности по выполнению всего цикла
анализа [24, 363]:
формирования логического представления данных для применения к ним
алгоритмов интеллектуального анализа;
настройки анализа: настройки строящейся модели знаний, настройки
алгоритма анализа, настройки условий выполнения (среды
параллельного/распределенного выполнения);
выполнения анализа – построения с помощью выбранного алгоритма
модели знаний;
просмотра (визуализации) построенной модели знаний;
оценки построенной модели знаний;
применения построенной модели знаний к новым данным.
Библиотека устанавливается на каждую виртуальную машину (Рисунок 7.2),
участвующую в распределенном анализе [21 - 16].
Технология обработки данных включает в себя:
извлечение данных из указанных пользователем источников (различных
форматов);
очистку и преобразование данных, необходимое для их дальнейшего
анализа (применения к ним алгоритмов ИАД);
238
интеграцию данных из разных распределенных источников, если это
необходимо для выполнения анализа;
передачу данных непосредственно алгоритму анализа или в хранилище
облака или в другое (вне облака) указанное пользователем место.
Для работы с данными используются ETL инструменты, обеспечивающие
указанные фазы: выгрузки, преобразования и загрузки данных. На рынке
достаточно популярными в настоящее время являются, в том числе и свободно
распространяемые инструменты типа CloverETL и Pentaho (на первой стадии в
платформу интегрирован только CloverETL). К этим инструментам в библиотеке
распределенных алгоритмов ИАД могут быть разработаны адаптеры. С их
помощью ETL инструменты на выходе (фазе загрузка) предоставляют данные в
формате, к которому могут быть применены алгоритмы, имеющиеся в
библиотеке. Достоинством таких инструментов является их расширяемость. В
разрабатываемой платформе они могут быть расширены средствами:
чтения данных из различных форматов;
преобразования данных;
интеграции распределенных данных;
очистки данных и др.
Возможности расширения позволяют пользователю расширять средства
необходимыми обработчиками, такими как, чтения собственных форматов,
специфичные преобразования (в том числе и криптографические) и т.п.
7.2 Единое информационное пространство отечественной орбитальной
группировки
7.2.1 Целевая задача
Концепция построения единого информационного пространства
отечественной орбитальной группировки разрабатывалась в рамках НИР МО РФ
в Главном испытательном центре испытаний и управления космическими
239
средствами (ГИЦИУ КС) имени Г.С. Титова, который отвечает ее управление
[364]. В его подчинение входят территориально распределенные подразделения.
В настоящее время в нем функционируют различные автоматизированные
информационно-аналитические системы, разработанные в рамках разных ОКР.
Данные системы разрабатывались разными предприятиями, в разные годы и в
результате имеют существенные различия, в части [365]:
аппаратных платформ: используются ПЭВМ и сервера закупленные в
период с 90-х годов прошлого века, до настоящего времени;
операционных систем (ОС): используются ОС семейства Windows
(Windows NT, 2000 и др.), МС ВС, AstraLinux и др.
систем управления базами данных (СУБД): используется Oracle,
PostgreSQL, Линтер и др.;
архитектур: клиент-серверные, терминальные, «настольные», тонкого
клиента и др.
протоколов взаимодействия: FTP, SOAP и др.
Независимая разработка каждой системы приводит к дублированию в них:
информационной составляющей в части: нормативно-справочной
информации, характеристик объектов и т.п.
прикладной составляющей в части: сбора и ведения информации, решения
функциональных задач, подготовки аналитических отчетов и др.
Такая ситуация приводит к следующим проблемам в эксплуатации систем:
сложность замены (модернизации) как аппаратных, так и программных
средств в связи с их разнородностью;
повышенные требования к квалификации эксплуатирующего персонала в
связи с необходимостью знаний различных технологий (ОС, СУБД и др.);
быстрое устаревание аппаратной составляющей и не возможность ее
замены в связи с сильной зависимостью от программного обеспечения;
240
сложность обеспечения безопасности информации в связи с
использованием различных средств безопасности и различным уровнем
сертификации;
не равномерная загрузка вычислительных средств;
высокое электропотребление при простоях систем;
невозможность получения аналитики по совокупности информации,
хранящейся в разных системах.
Проблемы усугубляются с разработкой каждой новой системы, т.к
разрабатываются они, как правило, независимо от уже существующих, тем самым
внося свою лепту в разнородность используемых средств.
Создание единого информационного пространства решает следующие
задачи [365]:
размещение существующих и вновь разрабатываемых АС на
вычислительных ресурсах облака в защищенной среде;
централизованный доступ к единой НСИ, актуальным характеристикам
контролируемой информации и др.;
проверка доступа, достоверности и др. виды обработки едиными
унифицированными алгоритмами;
решение аналитических и расчетных задач, в том числе статический и
интеллектуальный анализ для выработки рекомендаций;
разграничение доступа к информации в зависимости от грифа информации
и уровня доступа пользователя и др.
Для решения указанных задач на базе полученных в работе результатов
создается защищенная облачная платформа с единым информационным
пространством (Рисунок 7.3) [365, 366]. Данная платформа будет включать в себя
два уровня: физический уровень и виртуальный уровень.
На физическом уровне будет размещаться аппаратно-программное
обеспечение, реализующее необходимые функции для работы виртуального
уровня.
241
7.2.2 Решаемые проблемы
Выполнение анализа на базе информации интегрированной из
эксплуатируемых в ГИКЦ КС систем в рамках единого информационного
пространства решает следующие задачи:
оценивание технического состояния и возможностей своих сил и
средств;
генерирование возможных сценариев действий и отбор среди них
нескольких наилучших и предъявление их для принятия решения;
оценивание состава и возможностей орбитальных группировок.
Для решения перечисленных задач используется следующая информация из
единого информационного пространства:
информация о составе, состоянии и качестве функционирования
отечественных космических систем;
информация о перспективных космических программах и сроках их
выполнения;
информация о состоянии и программ действия отечественных
космических полигонов и трасс вывода КА на орбиту;
тактические, технические, весогабаритные и специальные
характеристики отечественных КА, ракет-носителей и разгонных блоков;
242
Рисунок 7.3 – Архитектура интегрированной информационно-аналитической защищенной платформы.
координатная и некоординатная информация от подчиненных средств
наблюдения за космическими объектами (НАКУ и КОС);
информация по предстоящим и выполненным запускам и маневрам
отечественных КА;
информации о параметрах движения отечественного КА
информация по разрушениям отечественных КА (причина разрушения,
район разрушения, степень загрязнения космического пространства
продуктами разрушения и другая информация;
информации о прекращении функционирования отечественного КА
Интеграция данной информации в едином физическом хранилище
осложнятся следующим проблемами:
неоднозначность – в разных системах одни и те же сущности имеют
различные способы кодирования (например, номера КА), используют
различные единицы измерений и т.д.
дублирование – наличие одинаковой информации в разных
источниках;
противоречие – наличие различной информации в разных источниках
об одном объекте или событии;
разнородность информации – информация, хранящаяся в разных
источниках, имеет разные форматы, принципы представления и
хранения.
7.2.3 Используемые подходы
Для решения перечисленных задач, с учетом физически разделенного
хранения информации, был построен макет динамического информационного
пространства на виртуальном уровне (рис. 7.4) [366]. Такое пространство не
аккумулирует всю информацию в одном месте. Информация хранится в
исходных местах. Динамическое пространство выполняет роль посредника
между ними и аналитическими сервисами, запрашивающими необходимую
информацию [367].
244
При выполнении анализа в динамическом информационном пространстве
используются следующие результаты, полученные в данной работе:
1. функциональная модель алгоритма анализа данных;
2. метод оптимизации структуры алгоритма анализа данных;
3. модель параллельного алгоритма анализа данных;
4. метод распараллеливания последовательных алгоритмов анализа данных;
5. метод размещения функций алгоритмов анализа данных в среде
выполнения;
6. программная реализация модели параллельного выполнения алгоритма
анализа данных в виде библиотеки.
При выполнении алгоритма анализа данных, размещенных на
территориально распределенных источниках, выполняется его декомпозиция на
ФОМ (Рисунок 7.4). Далее в зависимости от типа распределения данных
выполняется оптимизация его структуры и распараллеливание. Параллельно
выполняющиеся ФОМ инициализируются на источниках. Им предоставляется
информация (метаданные) о данных, анализ которых должен производиться.
После выполнения анализа, параллельно выполняющиеся ФОМ,
отправляют результаты обратно в аналитический центр. Полученные
результаты объединяются и пользователю выдается интегрированный
результат. Таким образом, конечный пользователь работает с динамическим
информационным пространством, не замечая его распределенной структуры.
245
Единое информационное пространство
Аналитический центр
Источник информации 1 Источник информации N
Виртуальное единое
информационное
пространство
Анализ данныхДекомпозиция алгоритма
Отправка ФОМ на
источник 1Настройка
перевода
Отправка ФОМ на
источник N
Анализ данных из
источника N
Анализ данных из
источника 1
Объединение результата
Получение результата
от источника 2
Получение результата
от источника 1
Рисунок 7.4 – Архитектура динамического информационного пространства.
Основным недостатком такого подхода является низкая скорость
выполнения алгоритмов. Задержки возможны вследстви передачи сообщений
по сетям. Однако в случае, когда источники информации размещаются в
«облаке» данная проблема нивелируется.
7.3 Анализ результатов выполнения сеансов связи средствами НАКУ КА
7.3.1 Целевая задача
Одной из задач системы планирования средств наземного
автоматизированного комплекса управления (НАКУ) космическими
аппаратами (КА) [364] является долгосрочное планирование. Целью
долгосрочного планирования является выработка рекомендаций по
эксплуатации технических средств НАКУ.
246
Решение задачи долгосрочного планирования предполагает оценку
достаточности средств НАКУ на будущий период. Оценка выполняется на
основании следующей информации, собранной за предыдущий период:
1) модель технологических циклов управления КА (модель ТЦУ);
2) нормативно-справочная информация;
3) планы и результаты выполнении сеансов связи с КА;
4) оперативный план применения средств НАКУ.
Основной проблемой оценки достаточности средств является вероятность
появления, как новых КА, так и новых технических средств НАКУ. В связи с
этим оценка проводится применительно не к конкретному типу КА и
техническому средству, а к категории, которая характеризуется типом
взаимодействия технического средства и КА. В этом случае, новые КА и
технические средства, могут быть отнесены к категории на основании
характера взаимодействия.
Для определения категорий взаимодействия технических средств и КА
решается задача кластеризации. Для отнесения КА и технического средства к
одной из категорий, решается задача классификации.
7.3.2 Решаемые проблемы
Одним из основных источников данных для решения задачи
долгосрочного планирования является оперативный план применения средств
НАКУ. Оперативный план включает в себя планируемые сеансы связи, а также
результаты их выполнения. Показателями загрузки средства НАКУ являются
число проведенных сеансов связи и продолжительность использования
технического средства в этих сеансах в течение определенного интервала
времени. Прогнозируемые значения этих показателей формируются и
используются при решении задач долгосрочного планирования применительно
к конкретным интервалам времени, исходя из определенной для этих
интервалов перспективной космической обстановки. Продолжительность
интервалов, для которых определяются прогнозируемые значения загрузки
247
средств НАКУ, составляет одни сутки при формировании прогноза на месяц
или квартал и один месяц при формировании прогноза на год. Исходными
данными для вычисления этих прогнозируемых значений являются результаты
статистической обработки данных о загрузке средств НАКУ за
предшествующий период. Продолжительность этого периода должна
составлять не менее полугода при прогнозировании суточных показателей
загрузки и не менее 3 лет при прогнозировании месячных показателей.
Все КА, с которыми может связываться данное средство, разделяются на
типы таким образом, что КА одного типа имеют примерно одинаковую частоту
и продолжительность сеансов связи со средствами НАКУ данного типа.
Выделяются также отдельные этапы полета КА, существенно отличающиеся
частотой или продолжительностью сеансов связи (например, этап выведения на
орбиту, обычный орбитальный полет, коррекция орбиты). Каждые сутки полета
каждого КА привязываются к определенному этапу полета. Выборки значений
показателя суточной загрузки средства (числа сеансов и продолжительности
связи) формируются для каждой пары (КА, этап полета) для всех суток из
периода оценивания, когда средство реально задействовано (не находится на
ТО), а КА находится на данном этапе полета. Затем выборки по каждому
показателю, относящиеся к КА одного типа, объединяются.
Выборки для определения месячных показателей загрузки формируются
по данным о месячных загрузках средств НАКУ аналогичным образом.
Отличие заключается лишь в том, что здесь отсутствует понятие этапа полета -
вместо привязки месяца к этапу полета просто проверяется, что большую часть
данного месяца КА находился в полете.
После формирования выборок проводится их статистическая обработка.
По каждой получившейся i - той выборке объема in каждого показателя
загруженности iinii XXX ,...,, 21 вычисляются среднее значение
in
j
ij
i
i Xn
X1
1 и
оценка дисперсии
in
j
iij
i
i XXn
S1
22 )(1
1. Если выборка оказалась пустой, или
248
имеет слишком малый объем для получения сколько-нибудь достоверных
оценок (например, при 5in ), эти оценки не строятся, а вместо них берутся
некоторые априорно заданные значения.
С применением описанного алгоритма, для каждого конкретного средства
НАКУ формируются модель статистической загрузки, представленная в форме
таблицы статистических оценок показателей суточной и месячной загрузки,
содержащей следующие поля:
- тип КА;
- этап полета КА (только для суточной загрузки);
- среднесуточное (среднемесячное) число сеансов связи с КА;
- дисперсия числа сеансов связи;
- среднесуточная (среднемесячная) продолжительность связи с КА;
- дисперсия продолжительности связи;
Формирование моделей статистической загрузки, по сути является
классической задачей кластеризации, в которой необходимо выделить
категории сеансов управления КА относящиеся к разным типам КА и средств
НАКУ по статистической информации о КА и средствах НАКУ действующих в
прошлый период.
Далее решается задача классификации для КА и средств НАКУ
действующих в прогнозируемый период. Задача усложняется тем, что в
будущем могут действовать КА и средства НАКУ не функционирующие ранее,
и следовательно не имеющие по себе статистики. Таким образом, их
необходимо классифицировать по имеющейся информации, отнеся к одной из
моделей статистической загрузки.
Учитывая, что оперативный план может включать в себя до 20 000
сеансов связи в сутки, а статистический анализ необходимо проводить за
период не менее полугода при прогнозировании суточных показателей загрузки
и не менее 3 лет при прогнозировании месячных показателей то объем
анализируемой информации измеряется десятками миллионов сеансов связи.
249
7.3.3 Используемые подходы
Для оперативной обработки нескольких десятков миллионов сеансов
связи для задачи кластеризации и построения статистической модели загрузки,
а также задачи классификации для отнесения сочетания КА и средства НАКУ к
одной из построенных моделей, требуются производительные алгоритмы
анализа. Учитывая, что на серверах использовался многоядерный процессор,
было принято решение о распараллеливании алгоритмов кластеризации и
классификации для повышения производительности. При решении данной
задачи были использованы следующие результаты, полученные в данной
работе:
1. функциональная модель алгоритма анализа данных;
2. метод оптимизации структуры алгоритма анализа данных;
3. модель параллельного алгоритма анализа данных;
4. метод распараллеливания последовательных алгоритмов анализа данных.
В процессе разработки были исследованы следующие алгоритмы:
кластеризации для решения задачи построения модели
статистической загрузки: kMeans, Fazzy –kMeans, FOREL и EM
классификации для определения подходящей модели к новому КА
и/или средству НАКУ: 1R, Naïve Bayes, C4.5.
Каждый из перечисленных алгоритмов был декомпозирован на ФОМ.
Для них были построены разные параллельные формы. Построенные
параллельные формы алгоритмов были выполнены на сервере на выборке
данных. На основе полученных экспериментальных результатах были выбраны
оптимальные параллельные формы. Это позволило достичь необходимой
производительности для решения задачи долгосрочного планирования.
250
7.4 Cбор телеметрии с территориально распределенных измерительных
средств
7.4.1 Целевая задача
Технический прогресс последних десятилетий привел к резкому
повышению требований к оперативности принимаемых решений. Основой для
них всегда является актуальная информация об объекте управления,
получаемая от различных измерительных средств (ИС). От скорости, полноты и
достоверности с которой будет собрана, обработана и представлена
измерительная информация (ИИ), лицу (системе) принимающему решения, в
конечном счете, зависит эффективность управления.
Решение перечисленных задач за последние десятилетия существенно
усложнилось в связи с появлением разнородных ИС и СПД. Большинство
современных систем, анализируют данные, полученные от различного рода
датчиков, фото- и видео-регистраторов, систем контроля, и т.п. Подобные
источники генерируют потоки информации в реальном режиме времени,
которые в том числе передаются по СПД с низкой пропускной способностью:
спутниковым каналам связи, радиорелейным линиям, каналам сотовой связи.
Данная проблема является актуальной для систем анализа испытаний
движущихся объектов (ДО). Для анализа их работы ИС собирают различные
данные: телеметрическую информацию, траекторную информацию и др. Для
этого используются разные типы измерительных устройств:
радиолокационные, оптические, телеметрические и др. Все они
устанавливаются на измерительные пункты (ИП), расположенные по трассе
испытаний ДО, которая может иметь протяженность в несколько сотен
километров. Информация, формируемая всеми ИС, относится к классу Больших
данных (которые часто определяются тремя V: Volume, Variety и Velocity)
[151], т.к.:
251
ИС формируют большие объемы информации (data volume), включая
телеметрию и видеоинформацию (до нескольких ТБ за десятки минут
испытаний);
данные формируются в различных форматах (data variety), включая
фото и видеоизображения, телеметрию и др.;
измерения выполняются с высокой частотой (data velocity), в
результате чего генерация данных происходит с высокой скоростью (в
режиме реального времени);
При этом возникают следующие проблемы сбора и обработки
информации, затрудняющие принятие решений в режиме реального времени:
необходимость наведения ИС на объект испытаний;
территориальная удаленность ИП друг от друга и от места сбора
информации;
информация, получаемая на разных ИП, в значительной мере
дублируется, т.к. зоны видимости ИП ДО имеют пересечение;
необходимость использования каналов связи с низкой пропускной
способностью.
В результате возникают проблемы, как с вычислительными, так и с
сетевыми ресурсами, которые требуют постоянного наращивания в связи с
ростом объемов передаваемой информации. В связи с этим потребовались
новые подходы к обработке данных, которые бы обеспечили доставку
необходимой информации от ИС до центра обработки ИИ в режиме реального
времени по доступным каналам передачи данных [368].
7.4.2 Решаемые проблемы
В процессе испытаний ИИ о ДО принимается несколькими ИП,
оборудованными различными ИС и расположенными по трассе перемещения
ДО. Зоны видимости ДО для каждого ИП разные, но имеют существенные
пересечения. В связи с этим от всех ИП поступает дублирующаяся информация
разного качества, зависящая от качества приема ИИ от ДО (Рисунок 7.5). На
252
нем заштрихованные области в потоках ИИ обозначают дублируемые данные,
по которым необходимо принимать решения о выборе [368 - 371].
ИП 1
Измерительные
средства
ИП 2
Измерительные
средства
ИП j
Измерительные
средства
ИП n
Измерительные
средства
ДОТрасса перемещения ДО
Зона видимости
ИП1
Зона видимости
ИП2
Зона видимости
ИПjЗона видимости
ИПj
ИИ от ИП1
ИИ от ИП2
ИИ от ИПj
ИИ от ИПn
Единый поток ИИ t
Рисунок 7.5 – Сбор измерительной информации распределенными
пунктами.
Для формирования единого потока ИИ (поступающего в пункт
управления) в режиме реального времени осуществляется следующий порядок
действий для ИИ, поступающей в каждый момент времени t:
получение ИИ от ИС на каждом ИП;
передача ИИ от ИП в центр обработки ИИ;
сбор всей ИИ от всех ИП в центре обработки ИИ;
оценка качества потока полученного от каждого ИП;
выбор лучшей ИИ и ее передача в рамках единого потока ИИ.
Недостатками такого подхода являются:
высокий сетевой трафик в СПД между ИП и центром обработки ИИ, в
связи с передачей от ИП всей ИИ, даже той, которая в итоге не будет
передана в рамках единого потока ИИ;
253
большое количество вычислений в центре обработки ИИ связанных с
оценкой качества каждого из пришедших потоков и их объединения
(количество вычислений напрямую зависит от числа ИП и ИС на них).
Ситуация усугубляется следующими факторами:
ИИ должна быть доставлена в виде единого потока ИИ в реальном
режиме времени для обеспечения оперативного управления ЛО;
ИИ от ИП поступает на всем протяжении наблюдения (даже если ЛО
вышел из зоны видимости ИП);
ЛО может быть несколько, и потоки ИИ множатся в зависимости от
числа ЛО;
каналы связи с ИП могут иметь низкую пропускную способность.
Таким образом, для достижения доставки ИИ в реальном режиме времени
до пункта управления, приходиться ограничивать ИИ, передаваемую с ИП в
центр обработки ИИ, что не всегда приемлемо.
7.4.3 Используемые подходы
Для уменьшения сетевого трафика, возникающего при сборе телеметрии,
используется подход, предполагающий передачу по сети только тех кадров,
которые в итоге будут включаться в единый поток [368]. Для этого оценка
качества кадра телеметрии вычисляется на измерительном пункте и передается
в центр обработки. В центре обработки осуществляется сбор оценок качества и
выбор наилучшего. Наилучший кадр запрашивается у соответствующего ИП и
передается в центр обработки для включения в единый поток. Недостатком
такого подхода является увеличение времени на формирование единого потока
от момента снятия измерений, связанное с предварительным сбором и оценкой
качества ИИ. [368, 370].
Для сокращения времени формирования единого потока принимается
решение о выборе кадра на основании прогноза изменения качества ИИ в
каждый момент времени. Прогнозируя изменение качества потока измерений,
заранее определяются моменты времени, когда нужно передавать информацию
254
для включения в единый поток. При этом основной задачей является
прогнозирование качества ИИ на период времени достаточный для
переключения ИС на прием. Такой прогноз выполняется моделями знаний,
получаемых с помощью алгоритмов ИАД, используемых, в том числе для
анализа временных рядов (logical regression, SVM) [369, 371].
В этом случае значение оценки качества аппроксимируется на будущий
период. Однако для улучшения точности предсказания, используются не только
предшествующие значения оценки качества, но и дополнительные атрибуты,
влияющие на качество ИИ. Примерами таких атрибутов могут быть: расстояние
от ИС до ДО, освещенность в районе ДО, скорость перемещения ДО и др.
Состав таких атрибутов может быть разным и определяется для каждой
совокупности ДО и ИС отдельно. Модель знаний построена алгоритмами ИАД
по наборам таких векторов полученных в результате предыдущих измерений
подобного рода объектов данным ИС.
При таком подходе формирование единого потока в каждый момент
времени выполняется параллельно на каждом ИП и в центре обработки, что
позволяет экономить время. Таким образом, время формирования единого
потока при рассмотренном подходе является минимальным.
Недостатком такого подхода является потенциальное снижение качества
единого потока, связанное с ошибками предсказания. Степень снижения
зависит от качества построенной модели знаний. Однако необходимо заметить,
что даже подход с полным сбором измерений не позволяет достичь 100%
качества для всей ИИ, т.к. могут существовать моменты времени, когда со всех
ИП приходят кадры с качеством ниже 100%. Таким образом, системы анализа
ИИ допускает возможность работы с кадрами низкого качества. Следовательно,
критерий качества ИИ не является критичным.
255
Выводы
В данной главе описано практическое применение полученных
результатов в народно-хозяйственной деятельности. Полученные результаты
были успешно использованы при выполнении НИРОКР и по заказу отраслевых
министерств и ведомств в решении следующих задач:
1) создание облачного сервиса выполнения интеллектуального анализа данных
в различных распределенных средах, которое может служить основой для
построения ситуационных центров и единых информационных пространств;
2) анализ результатов взаимодействия технических средств наземного
автоматизированного комплекса управления космическими аппаратами с
целью оценки достаточности средств на будущий период;
3) построения единого информационного пространства для управления
отечественной орбитальной группировки;
4) сбор измерительной информации с территориально распределенных
измерительных средств от движущихся объектов по каналам связи,
имеющим ограниченную пропускную способность в режиме реального
времени.
Кроме того, результаты были использованы в следующих НИР
поддержанных Министерством образования РФ:
1. «Математические методы, распределенные вычислительные и
когнитивные технологии и быстрые алгоритмы интеллектуального
анализа и обеспечения безопасности и непрерывности данных для
моделирования и управления антропогенными системами» (Госзадание –
2014-2016 г.г.).
2. «Разработка методов и средств распределенного выполнения
интеллектуального анализа больших объемов разнородных данных в
облачной среде» (Госзадание – 2014-2016 г.г.).
3. «Разработка моделей и методов принятия решений в задачах анализа
результатов тестирования знаний при профессиональном отборе
256
сотрудников в высших учебных заведениях в условиях
неопределенности» (РФФИ -2015 г.).
4. «Создание методов априорной оценки работы алгоритмов
интеллектуального анализа в гетерогенной распределенной среде»
(РФФИ – 2011-2013 г.г.).
5. «Разработка теоретических основ проектирования сервисно -
ориентированной информационно-аналитической системы анализа
данных на базе технологии облачных вычислений» (РФФИ – 2011 г.г.).
6. «Многоагентная технология интеллектуального анализа данных и
извлечения знаний» (2005 – 2006 г.г.).
257
Заключение
По результатам диссертационного исследования можно сформулировать
ряд выводов.
1. Проведен анализ существующих моделей, методов и средств
построения параллельных алгоритмов, который показал, что они не
позволяют выполнять построение параллельных алгоритмов анализа
данных с учетом условий их выполнения.
2. Представлена модель знаний, которая описывает найденные в данных
закономерности в виде леса деревьев унифицированных элементов и
определяет функции, обеспечивающие их параллельное построение в
общей и распределенной памяти.
3. Предложена функциональная модель алгоритма анализа данных,
расширяющая теорию λ-исчислений и представляющая его в виде
композиции унифицированных потокобезопасных функций, которая
может быть перестроена в зависимости от условий выполнения
алгоритма.
4. Разработан метод оптимизации структуры алгоритма анализа данных,
трансформирующий циклы алгоритма в зависимости от типа
распределения данных.
5. Предложена модель параллельного алгоритма анализа данных,
позволяющая проводить распараллеливание, как по данным, так и по
задачам, для выполнения в общей и распределенной памяти.
6. Определены условия параллельного выполнения функций алгоритмов
анализа данных, уточняющие условия Бернстайна и определяющие
требования к информационным зависимостям для общей и
распределенной памяти.
7. Предложен метод распараллеливания последовательных алгоритмов
анализа данных, как по задачам, так и по данным, формирующий
258
оптимальное число параллельных ветвей, с учетом особенностей их
выполнения.
8. Разработан метод размещения функций алгоритмов анализа данных в
среде выполнения, минимизирующий время выполнения алгоритма и
сетевой трафик c учетом хранения данных.
9. Предложена методика построения параллельных алгоритмов анализа
данных, использующая предложенные модели и методы и
позволяющая оптимизировать структуру параллельного алгоритма для
минимизации времени выполнения и сетевого трафика с учетом
условий выполнения.
10. Разработана библиотека параллельных алгоритмов анализа данных
для выполнения в заданной среде, включающая в себя программные
реализации предложенных моделей и методов.
11. Проведены экспериментальные исследования построения
параллельных алгоритмов анализа данных с учетом условий
выполнения, которые подтвердили достоверность полученных
результатов.
Результаты работы использованы в учебном процессе, исследованиях
поддержанных Министерством образования и науки РФ, а также в ряде НИР и
ОКР выполненных по заказу отраслевых министерств и ведомств, что
подтверждается актами о внедрении.
259
Список сокращений и условных обозначений
ДО - движущийся объект
ИАД - интеллектуальный анализ данных
ИИ - измерительная информация
ИП - измерительный пункт
ИС - измерительные средства
КА - космический аппарат
НАКУ - наземный автоматизированный комплекс управления
ОС - операционная система
ОЧПК - оптимального числа параллельных композиций
ПП - потенциал параллелизации
СПД - средства передачи данных
ФОМ - функция обработки модели
ЭВМ - электронно вычислительная машина
260
Список литературы
1. Bonomi, F., Fog Computing and its Role in the Internet of Things [Text] / R.
Milito, J. Zhu, S. Addepalli // Proceeding of MCC. - 2012, pp. 13-16.
2. Kholod, I., Unification of Mining Model for Parallel Processing [Text]/ I. Kholod,
A. Shorov. // Proceeding of 2017 IEEE North West Russia Section Young
Researchers in Electrical and Electronic Engineering Conference. – 2017. pp. 450–
455.
3. Холод, И.И. Метод определения возможностей параллельного выполнения
функций алгоритмов анализа данных [Текст] / И.И. Холод // Программные
продукты и системы. – 2018. – №2. – С. 268-274.
4. Kholod, I. The formal model of data mining algorithms for parallelize algorithms.
[Text]/ I. Kholod, Z. Karshiyev, A. Shorov // Soft Computing in Computer and
Information Science. AISC. – 2015. –vol. 342. – pp. 385–394.
5. Kholod, I. Decomposition of Data Mining Algorithms into Unified Functional
Blocks [Text] / I. Kholod, M. Kupriyanov, A. Shorov // Mathematical Problems in
Engineering. – 2016. - 11 pages.
6. Холод И.И. Архитектура системы разработки алгоритмов интеллектуального
анализа распределённых данных / Холод И.И. // Известия СПбГЭТУ «ЛЭТИ». -
2011. – № 9. – с.48-55.
7. Kholod, I. A functional approach to parallelizing data mining algorithms in java.
[Text]/ I. Kholod, A. Shorov, S. Gorlatch // Springer LNCS. – 2017. – vol. 10421. –
pp. 459–472.
8. Kholod, I. Parallelization of data mining algorithms for multicore processors.
[Text]/ I. Kholod, M. Kuprianov, A. Shorov // Proceeding of 4th Mediterranean
Conference on Embedded Computing (MECO). – 2015. – pp. 262–267.
9. Kholod, I. Data Mining Algorithms Parallelizing in Functional Programming
Language for Execution in Cluster. [Text] / I. Kholod, A. Malov, S. Rodionov //
Springer LNCS. – 2015. - vol. 9247. - pp. 140–152.
10. Kholod, I. Constructing Parallel Association Algorithms from Function Blocks.
[Text] / I. Kholod, M. Kuprianov, A. Shorov // Springer LNAI. – 2015. – vol. 9165.
– pp. 62–68.
261
11. Kholod, I. Creation of Data Mining Algorithms as Functional Expression for
Parallel and Distributed Execution [Text] / I. Kholod, I. Petuhov // Springer LNCS. –
2015 – vol. 9251. – pp. 62–68.
12. Холод, И. И. Метод построения параллельных алгоритмов
интеллектуального анализа данных из потоконезависимых функциональных
блоков [Текст] / И. И. Холод, З. А. Каршиев // ИЗВЕСТИЯ СПбГЭТУ «ЛЭТИ».
- 2013. - № 8. - C. 38-45.
13. Холод, И.И. Возможности выполнения алгоритмов интеллектуального
анализа в распределенных системах. [Текст] / И. И. Холод // ИЗВЕСТИЯ
СПбГЭТУ «ЛЭТИ». - 2014. - № 9. - C. 38-44.
14. Холод, И.И. Сбор измерительной информации с распределенных
измерительных средств в режиме реального времени [Текст]/ И.И. Холод. //
ИЗВЕСТИЯ СПбГЭТУ «ЛЭТИ». - 2016. - № 10. - C. 34-40.
15. Kholod, I. Application of actor model for distributed execution of data mining
algorithms. [Text] / I. Kholod, I. Petuhov, N. Kapustin // Proceeding of Soft
Computing and Measurements (SCM). – 2015. - pp. 208–210.
16. Kholod, I. Data Mining for the Internet of Things with Fog Nodes. [Text] / I.
Kholod, I. Petuhov, M. Efimova // Springer LNCS. – 2016. - vol. 9870. - pp. 25–36.
17 Холод, И. И. Метод оценки эффективности анализа данных в
распределенной среде [Текст]/ И.И. Холод, И.В. Петухов // ИЗВЕСТИЯ
СПбГЭТУ «ЛЭТИ». – 2017. - № 1. - C. 16-22.
18. Холод, И.И. Методика распараллеливания алгоритмов интеллектуального
анализа данных. [Текст] / И.И. Холод, З. А. Каршиев // ИЗВЕСТИЯ СПбГЭТУ
«ЛЭТИ». – 2013. - № 3. - C. 38-45.
19. Kholod, I. Creation of Data Mining Cloud Service on the Actor Model. [Text] / I.
Kholod, I. Petuhov, N. Kapustin // Springer LNCS. – 2015. - vol. 9247. - pp. 585–
599.
20. Kholod, I. Distributed Execution Environment for Data Mining as Service. [Text]
/ I. Kholod, K. Borisenko // Proceeding of 2016 IEEE North West Russia Section
Young Researchers in Electrical and Electronic Engineering Conference. – 2016. -
pp. 236–241.
262
21. Kholod, I. Cloud for Distributed Data Analysis Based on the Actor Model. [Text]
/ I. Kholod, I. Petukhov, A. Shorov // Scientific Programming. – 2016. - vol. 2016. -
11 pages.
22. Kholod, I. Parallel and Distributed Data Mining in Cloud. [Text] / I. Kholod, M.
Kuprianov, I. Petukhov // Springer LNAI. – 2016. - vol. 9728. - pp. 349–362.
23. Kholod, I. Distributed Data Mining Based on Actors for Internet of Things. [Text]
/ I. Kholod, M. Kuprianov, I. Petukhov // Proceeding 5th Mediterranean Conference
on Embedded Computing (MECO). - 2016. - pp. 262–267.
24. Kholod, I. Framework for multi threads execution of data mining algorithms.
[Text] / I. Kholod // Proceeding of 2015 IEEE North West Russia Section Young
Researchers in Electrical and Electronic Engineering Conference. – 2015. – pp. 74–
80.
25. Куприянов М. С. Информационные системы интеллектуального анализа
данных и процессов (проблема Big Date) [Текст] / М. С. Куприянов, И. И.
Холод, А. В. Шоров, Ю. А. Шичкина // ИЗВЕСТИЯ СПбГЭТУ «ЛЭТИ». - 2016.
- № 5. - C. 42-54.
26. Социологический словарь. [Текст] / отв. ред. Г.В. Осипов, Л.Н. Москвичев.
М.: Норма, 2008. - 608 с.
27. Hastie, T. The elements of statistical learning: data mining, inference and
prediction. [Text] / Hastie, T., Tibshirani, R., Friedman, J. - Springer.: - New York,
2001. - 533 p.
28. Вальд, А. Последовательный анализ [Текст]: пер. с англ./ А. Вальд. — М.:
Физматгиз, 1960. — 328 с.
29. Ширяев, В. Д. Статистический последовательный анализ. Оптимальные
правила остановки [Текст]/ В. Д. Ширяев. — М.: Наука, 1976. - 272 с.
30. Харман, Г. Современный факторный анализ. [Текст]/ Г. Харман. — М.:
Статистика, 1972. — 486 с.
31. Айвазян, С. А. Прикладная статистика: основы моделирования и первичная
обработка данных. [Текст]/ С. А. Айвазян, И. С. Енюков, Л. Д. Мешалкин. —
М.: Финансы и статистика, 1983. — 471 с.
263
32. Айвазян, С. А. Прикладная статистика: исследование зависимостей [Текст]/
С. А. Айвазян, И. С. Енюков, Л. Д. Мешалкин. — М.: Финансы и статистика,
1985. —487с.
33. Айвазян, С. А. Прикладная статистика: классификация и снижение
размерности. [Текст]/ С. А. Айвазян, В. М. Бухштабер, И. С. Енюков, Л. Д.
Мешалкин. — М.: Финансы и статистика, 1989. — 607 с.
34. Вапник, В. Н. Восстановление зависимостей по эмпирическим данным.
[Текст]/ В. Н. Вапник. — М.: Наука, 1979. – 448 с.
35. Vapnik, V.N. Statistical learning theory. [Text] / V.N. Vapnik. — N.Y.: John
Wiley & Sons, Inc., 1998. — 740 p.
36. Флах, П. Машинное обучение. [Текст] / Флах П. — М.: ДМК Пресс, 2015. —
400 с.
37. Mitchell, T. Machine Learning. [Text] / T. Mitchell. — McGraw-Hill
Science/Engineering/Math, 1997. — 414 p.
38. Michalski, R. S. Machine Learning: An Artificial Intelligence Approach. [Text] /
R. S. Michalski, J. G. Carbonell, T. M. Mitchell. — Berlin.: Springer-Verlag Berlin
Heidelberg, 1983. — 572 p.
39. Wang, L. Machine Learning for Human Motion Analysis. [Text] / L. Wang, L.
Cheng, G. Zhao. — IGI Global, 2009. — 318 p.
40. Witten, I.H. Data Mining: Practical Machine Learning Tools and Techniques.
[Text] / I.H. Witten, E. Frank — Morgan Kaufmann, 2005. — 560 p.
41. Чубукова, И. А. Data Mining: учебное пособие. [Текст]/ И. А. Чубукова —
М.: Интернет-университет информационных технологий: БИНОМ:
Лаборатория знаний, 2006. — 382 с.
42. Дюк, В., Data Mining: учебный курс. [Текст]/ В. Дюк, А.Самойленко —
СПб.: Изд. Питер, 2001. — 368 с.
43. Han, J. Data mining: Concepts and Techniques. [Text]/ Han J., Kamber M. –
Morgan Kaufmann Publishers. – 2001. – 744 p.
44. Методы и модели анализа данных: OLAP и Data Mining. [Текст]/ А.А.
Барсегян [и др.] – СПб.: БХВ-Петербург, 2004. – 336 с.
264
45. Технологии анализа данных. Data Mining, Visual Mining, Text Mining, OLAP.
[Текст] /А.А. Барсегян [и др.]. – СПб.: БХВ-Петербург, 2007. – 384 с.
46. Анализ данных и процессов. [Текст] /А.А.Барсегян [и др.]. – СПб.: БХВ-
Петербург, 2009. – 512 с.
47. Analysis of Data and Processes: From Standard to Realtime Data Mining. [Text]/
A. Barsegian. – Re Di Roma-Verlag. 2014. – 299 p.
48. Piatetsky-Shapiro, Knowledge Discovery in Databases. [Text]/ G. Piatetsky-Shapiro,
W. Frawley. – AAAI Press/MIT Press. 1991. – 539 p.
49. Schmidhuber, J. Deep Learning in Neural Networks: An Overview. [Text]/ J.
Schmidhuber // Neural Networks. – 2015. – vol. 61 – p. 85–117.
50. Bengio, Y. Deep Learning [Text]/ Y. Bengio, Y. LeCun, G. Hinton // Nature. –
2015. –vol. 521 - p. 436–444.
51. Deng, L. Deep Learning: Methods and Applications [Text]/ L. Deng, D. Yu,
Foundations and Trends in Signal Processing. – 2014. – vol. 7 (3–4) – p. 1–199.
52. JSRs: Java Specification Requests. JSR 73: Data mining API.
(http://www.jcp.org/en/jsr/detail?id=73).
53. JSRs: Java Specification Requests. JSR 247: Data mining 2.0.
(http://www.jcp.org/en/jsr/detail?id=247).
54. Гаврилова, Т. А. Базы знаний интеллектуальных систем. Учебник. [Текст] /
Т. А. Гаврилова, В. Ф. Хорошевский — СПб.: Питер, 2000 – 384 c.
55. Roberts, D. The Existential Graphs of Charles S. Peirce. [Text]/ D. Roberts. –
Paris.: Mouton &Co,1973 – 169 p.
56. Lehmann, F. Semantic networks in artificial intelligence. [Text]/ F. Lehmann, E.
Y. Rodin. - NewYork: Pergamon Press, 1992 - p. 758.
57. Минский, М. Фреймы для представления знаний : Пер. с англ. [Текст]/ М.
Минский – М.: Энергия, 1979 – 152 c.
58. Data Mining Group. PMML 4.2. - General Structure (http://dmg.org/pmml/v4-2-
1/GeneralStructure.html).
59. Holte, R.C. Very Simple Classification Rules Perform Wellon Most Commonly
Used Datasets. [Text]/ R.C. Holte // Machine Learning. – 1993. – vol. 11. - p 63-90.
265
60. Kurgan, L. A. Highly Scalable and Robust Rule Learner: Performance Evaluation
and Comparison [Text]/ L. A. Kurgan, K. J. Cios, S. Dick // IEEE SYSTEMS, MAN,
AND CYBERNETICS—PART B: CYBERNETICS. – 2006.- vol. 36. - p. 32–53.
61. Aksoy, S. A review of rules family of algorithms [Text]/ S. Aksoy //
Mathematical and Computational Applicationsю – 2008ю - vol. 13. - pp. 51–60.
62. Minsky, M. Steps to ward artificial intelligence [Text]/ M. Minsky Proceedings of
the IRE. – 1961. - vol.49, no.1. - pp.8–30.
63. Langley, P. Induction of selective Bayesian classifiers [Text]/ P. Langley, S. Sage
// Proceedings of the 10th International Conference on Uncertainty in Artificial
Intelligence. – 1994 - p.399–406.
64. Kononenko, I. Semi-naive Bayesian classifier [Text]/ I. Kononenko // Springer
LNAI.– 1991. - vol. 482, p.206–219.
65. Zhengand, F. Tree Augmented Naïve Bayes [Text]/ F. Zhengand, G. I. Webb, //
Springer. - 2010. – p. 990-991.
66. Jiang, L.Learning tree augmented naive bayes for ranking [Text]/ L. Jiang, H.
Zhang, Z. Cai, J. Su, // Proceedings of the 10th International Conference on Database
Systems for Advanced Applications (DASFAA’05). – 2005. - p. 688–698.
67. Sahami M. Learning limited dependence Bayesian classifiers [Text]/ M. Sahami
// Proceedings of the 2nd International Conferenceon Knowledge Discovery and Data
Mining. – 1996. - pp. 335–338.
68. Friedman, N. Learning belief networks in the presence of missing value sand
hidden variables [Text]/ N. Friedman / Proceedings of the 14th International
Conferenceon Machine Learning. – 1997. - p.125–133.
69. Lei, Y. Visual tracker using sequential Bayesian learning: discriminative,
generative, and hybrid[Text]/ Y. Lei, X. Q. Ding, S. J. Wang // IEEE Transactions on
Systems, Man, and Cybernetics, Part B: Cybernetics. – 2008. - vol.38, no.6. - p.1578–
1591.
70. Geiger, D. Knowledge representation and inference in similarity networks and
Bayesian multinets [Text]/ D. Geiger, D. Heckerman // Artificial Intelligence. – 1996.
- vol.82, no.1-2. - p.45–74.
71. Therneau, T. M. RPART: recursive partitioning. [Text]/ T. M. Therneau, B. R.
Atkinson //R package version 3. – 2008. – p. 1-41.
266
72. Quinlan, J. R. Induction of decision trees [Text]/ J. R. Quinlan // Machine
Learning. – 1986. - vol.1, no.1. - pp.81–106.
73. Quinlan, J. R. C4.5: Programs for Machine Learning [Text]/ J. R. Quinlan. -
Morgan Kaufmann, 1993. – 302 p.
74. Breiman, L. Classification and regression trees. [Text]/ L. Breiman, J. H.
Friedman, R. A. Olshen, C. J. Stone. - Monterey: Brooks/Cole Publishing, 1984. –
358 p.
75. Diepen, M. Evaluating chi-squared automatic interaction detection [Text]/ M.
Diepen, P. H. Franses // Information Systems/ - 2006/ - vol. 31, no.8. - pp. 814 – 831.
76. Friedman, J. H. Multivariate Adaptive Regression Splines [Text]/ J. H. Friedman
// The Annals of Statistics. – 1991. – vol. 19 n.1. – p. 1-67.
77. Loh, W. Y. Tree-structured classification via generalized discriminant analysis
[Text]/ W. Y. Loh, N. Vanichsetakul // J Am Stat Assoc. – 1988. – vol. 83. – p. 715 –
728.
78. Kim, H. Classification trees with unbiased multiway splits [Text]/ H. Kim, WY.
Loh // J Am Stat Assoc. - 2001. – vol.96. – p. 589– 604.
79. Kim, H. Classification trees with bivariate linear discriminant node models
[Text]/ H. Kim, WY. Loh // J Comput Graphical Stat. – 2003. – vol. 12. – p. 512 –
530.
80. Loh, WY Improving the precision of classification trees. [Text]/ WY Loh, C.
Chen, W. Hordle, A. Unwin // Ann Appl Stat. – 2009. – vol.3. – p.1710 – 1737.
81. Loh, WY. Split selection methods for classification trees [Text]/ WY. Loh, Y.
Shih // Stat Sin. – 1997. – vol.7. – p.815–840.
82. Hothorn, T. Unbiased recursive partitioning: a conditional inference framework
[Text]/ T. Hothorn, K. Hornik, A. Zeileis // J Comput Graphical Stat. – 2006. –
vol.15. – p. 651–674.
83. Larose, D. T. k-nearest neighbor algorithm [Text]/ D. T. Larose // Discovering
Knowledge in Data: An Introduction to Data Mining. – 2005. - pp.90–106.
84. Hwangand, W. J. Fast kNN classification algorithm based on partial distance
search [Text]/ W. J. Hwangand, K.W.Wen // Electronics Letters. – 1998. - vol.34,
no.21. - p. 2062 – 2063.
267
85. Jeng-Shyang, P. Fast k-nearest neighbors classification algorithm [Text]/ P. Jeng-
Shyang, Q. Yu-Long, S. Sheng-He // IEICE Transactions on Fundamentals of
Electronics, Communications and Computer Sciences. – 2004. - vol. 87, no. 4. - p.
961–963.
86. Pan, J.-S. An efficient encoding algorithm for vector quantization based on
subvector technique [Text]/ J.-S.Pan, Z.-M.Lu, S.-H.Sun // IEEE Transactions on
Image Processing. – 2003. - vol. 12, no. 3. - p. 265 – 270.
87. Lu, Z.-M. Equal-average equal-variance equalnorm nearest neighbor search
algorithm for vector quantization [Text]/ Z.-M. Lu, S.-H. Sun // IEICE Transactions
on Information and Systems. – 2003. - vol. 86, no.3. - p.660 – 663.
88. Linear Models: Least Squares and Alternatives. Springer Series in Statistics
[Text]/ C. R. Rao, et al. - Berlin: Springer. – 1995. - 353 p.
89. Wolberg, J. Data Analysis Using the Method of Least Squares: Extracting the
Most Information from Experiments [Text]/ J. Wolberg. - Berlin: Springer. - 2005. –
250 p.
90. Cortes, C. Support-vector networks [Text]/ C. Cortes, V. Vapnik // Machine
Learning. Springer. – 1995. – vol. 20 n.3. – p. 273 – 297.
91. Tang, Y. Granular support vector machines for medical binary classification
problems [Text]/ Y. Tang, B. Jin, Y. Sun, Y.-Q. Zhang // Proceedings of the IEEE
Symposium on Computational Intelligence in Bioinformatics and Computational
Biology (CIBCB’04). – 2004. - p.73 – 78.
92. Guo H.-S., A novel learning model-kernel granular support vector machine
[Text]/ H.-S. Guo, W.-J. Wang, C.-Q. Men // Proceedings of the International
Conferenceon Machine Learning and Cybernetics. – 2009. - p. 930 – 935.
93. Lian, K. Study on a GAbased SVM decision-tree multi-classification strategy
[Text]/ K. Lian, J. Huang, H. Wang, B. Long //Acta Electronica Sinica. – 2008. -
vol.36, no.8. - pp.1502 – 1507.
94. Lin, C.-F. Fuzzy support vector machines [Text]/ C.-F. Lin, S.-D. Wang // IEEE
Transactions on Neural Networksю – 2002. - vol. 13, no. 2. - p. 464 – 471.
95. Huang, H.-P. Fuzzy support vector machines for pattern recognition and data
mining [Text]/ H.-P.Huang, Y.-H.Liu // International Journal of Fuzzy Systems. –
2002. - vol.4, no.3. - p.826 – 835.
268
96. Yanand, W.-Y. Multi-class fuzzy support vector machine based on dismissing
margin [Text]/ W.-Y.Yanand, Q. He // Proceedings of the International Conferenceon
Machine Learning and Cybernetics. – 2009. - p.1139–1144.
97. Tian, Z.Qi,Y. Robust twin support vector machine for pattern classification
[Text]/ Z.Qi,Y.Tian, Y.Shi // Pattern Recognition. – 2013. - vol.46, no.1. - p. 305 –
316.
98. Khemchandani, R. Twin support vector machines for pattern classification [Text]/
R. Khemchandani, S. Chandra // IEEE Transactions on Pattern Analysis and Machine
Intelligenceю – 2007. - vol. 29, no. 5. - p. 905– 910.
99. Qi, Z. Structural twin support vector machine for classification [Text]/ Z. Qi, Y.
Tian, Y. Shi // Knowledge-Based Systems. – 2013. - vol. 43, p. 74–81.
100. Tsyurmasto, P. Value-atrisk support vector machine: stability to outliers [Text]/
P. Tsyurmasto, M. Zabarankin, S. Uryasev // Journal of Combinatorial Optimization.
– 2014. - vol. 28, no.1. - p.218–232.
101. Herbrich, R. Large margin rank boundaries for ordinal regression [Text]/ R.
Herbrich, T. Graepel, K. Obermayer // Advances in Neural Information Processing
Systems. – 1999. - pp.115–132.
102. Ward, J. H. Hierarchical Grouping to Optimize an Objective Function [Text]/ J.
H. Ward // Journal of the American Statistical Association. – 1963. – vol. 58 n. 301. –
p. 236 – 244.
103. Sokal, R. A statistical method for evaluating systematic relationships. [Text]/ R.
Sokal, C. Michener // University of Kansas Science Bulletin. – 1958. – vol. 38. – p.
1409–1438.
104. Sibson, R. SLINK: an optimally efficient algorithm for the single-link cluster
method. [Text]/ R. Sibson // The Computer Journal. British Computer Society. –
1973. –vol. 16 n.1. – p. 30–34.
105. Defays, D. An efficient algorithm for a complete link method [Text]/ D. Defays
// The Computer Journal. British Computer Society. – 1977. - vol. 20 n. 4 – p.364–
366.
106. Guha, S. CURE: an efficient clustering algorithm for large databases [Text]/ S.
Guha, R. Rastogi, K. Shim // ACM SIGMOD Record. – 1998. - vol. 27, no.2. - p.73–
84.
269
107. Berry, M. W. Understanding Search Engines: Mathematical Modeling and Text
Retrieval [Text]/ M. W. Berry, M. Browne. – SIAM, 2005. - 136 p.
108. Kaufman, L. Finding Groups in Data - An Introduction to Cluster Analysis.
[Text]/ L. Kaufman, P. J. Roussew. - Hoboken, New Jersey: John Wiley & Sons, Inc.,
2005. – 355 p.
109. Lloyd, S. P. Least squares quantization in PCM [Text]/ S. P. Lloyd, // IEEE
Transactions on Information Theory. – 1982. – vol. 28 n. 2. – p. 129–137.
110. Wallace, C.S. Intrinsic classification by MML the Snob program [Text]/
Wallace C. S., Dowe D. L. // Proceedings of the 7th Australian Joint Conference on
Artificial Intelligence. – 1994. - pp.37–44.
111. Fraley, C. MCLUST version 3 :an Rpackage for normal mixture modeling and
model-based clustering. Technical Report No. 504. [Text]/ C.Fraley, A.E.Raftery. -
Seattle : Department of Statistics University of Washington, 2006. – 58 p.
112. MacQueen, J. B. Some Methods for classification and Analysis of Multivariate
Observations [Text]/ J. B. MacQueen // Proceedings of 5th Berkeley Symposium on
Mathematical Statistics and Probability. University of California Press. - 1967. - p.
281–297.
113. Schikuta, E. The BANG-clustering system: grid based data analysis [Text]/ E.
Schikuta, M. Erhart // Advances in Intelligent Data Analysis Reasoning about Data.
LNCS Springer. – 1997. - vol. 1280. - pp.513–524.
114. Dempster, A. P. Maximum likelihood from incomplete data via the EM
algorithm [Text]/ A. P. Dempster, N. M. Laird, D. B. Rubin // Journal of the Royal
Statistical Society. – 1977. – vol.39. n.1. p. 1 – 38.
115. Neal, R. A view of the EM algorithm that justifies incremental, sparse, and other
variants [Text]/ R. Neal, G. E. Hinton // In Learning in Graphical Models. – 1998. - p
355–368.
116. McLachlan, G. J. The EM Algorithm and Extensions [Text]/ G. J. McLachlan,
T. Krishnan. - New York:Wiley,. 1997. – 400 p.
117. Agrawal, J. Modification of density based spatial clustering algorithm for large
data base using naive’s bayes’ theorem [Text]/ J. Agrawal et. al. // Proceedings of the
4th International Conference on Communication Systems and Network
Technologies(CSNT’14). – 2014. - pp.419–423.
270
118. Ester, M. A density-based algorithm for discovering clusters in large spatial data
bases with noise [Text]/ M. Ester et. al. // Proceedings of the 2nd International
Conference on Knowledge Discovery and Data Mining (KDD’96). – 1996. - p. 226 –
231.
119. Ankerst, M. OPTICS: Ordering Points To Identify the Clustering Structure
[Text]/ Ankerst, M. et. al. // ACM SIGMOD international conference on
Management of data. ACM Press. – 1999. - p. 49–60.
120. Achtert, E. DeLi-Clu: Boosting Robustness, Completeness, Usability, and
Efficiency of Hierarchical Clustering by a Closest Pair Ranking. [Text]/ Achtert, E.;
Böhm, C.; Kröger, P. // Advances in Knowledge Discovery and Data Mining. LNCS
Springer. – 2006. – vol. 3918. – p. 119–128.
121. Cheng, Y. Mean Shift, Mode Seeking, and Clustering [Text]/ Y. Cheng // IEEE
Transactions on Pattern Analysis and Machine Intelligence. IEEE. - 1995. – vol.17
n.8. – p. 790–799.
122. Barrow, J. D. Minimal spanning trees, filaments and galaxy clustering. [Text]/
J.D. Barrow, S.P. Bhavsar, D.H. Sonoda // Mon. Not. R. Astron. Soc. – 1985. – vol.
216. – p.17–35.
123. Guha, S. ROCK: a robust clustering algorithm for categorical attributes [Text]/
S. Guha, R. Rastogi, K. Shim // Proceedings of the 15th international conference on
data engeneering. – Elsevier Ltd, 1999. - p. 512–521.
124. Karypis, G. Chameleon: hierarchical clustering using dynamic modeling [Text]/
G. Karypis, E.-H. Han, V. Kumar // IEEE Comput. – 1999. – vol. 32. n. 8. – p. 68–
75.
125. Agrawal, R. Fast Algorithms for Mining Association Rules [Text]/ R. Agrawal,
R. Srikant // Proceedings of the 20th VLDB Conference. – San Francisco: Morgan
Kaufmann Publishers Inc, 1994. - p. 487–499.
126. Savasere, A. An Efficient Algorithm for Mining Association Rules in Large
Databases [Text]/ A. Savasere, E. Omiecinskia, Sh. Navathe // Proceedings of the
21th VLDB Conference. – San Francisco: Morgan Kaufmann Publishers Inc, 1995. -
p. 432 – 444.
127. Luo, C. Efficient mining of maximal sequential patterns using multiple samples
[Text]/ C. Luo, S. M. Chung // Proceedings of the 5th SIAM International Conference
on Data Mining (SDM’05). – SIAM, 2005. - pp. 415–426.
271
128. Yang, Z. LAPIN-SPAM: an improved algorithm for mining sequential pattern
[Text]/ Z. Yang, M. Kitsuregawa // Proceedings of the 21st International Conference
on Data Engineering Workshops. - IEEE Computer Society, 2005. - p. 1222 – 1226.
129. Han, J. Mining frequent patterns by pattern-growth: methodology and
implications [Text]/ J.Han and J.Pei // ACM SIGKDD Explorations Newsletter. –
2000. - vol.2, no.2. - p.14–20.
130. Zaki, M. J. Scalable algorithms for association mining [Text]/ M. J. Zaki. //
IEEE Transactions on Knowledge and Data Engineering. – 2000. – vol. 12 n.3. -
372–390.
131. Deng, Z. H. Fast mining frequent itemsets using
Nodesets.http://www.sciencedirect.com/science/article/pii/S0957417414000463 [Text]/ Z. H.
Deng, S. L. Lv // Expert Systems with Applications. – 2014. – vol. 41 n.10. – p.
4505–4512.
132. Deng, Z. H. A New Algorithm for Fast Mining Frequent Itemsets Using N-Lists
[Text]/ Z. H. Deng, Z. Wang， J. Jiang // SCIENCE CHINA Information Sciences. –
2012. – vol. 55 n. 9. – p. 2008 - 2030.
133. Deng, Z. H. A New Fast Vertical Method for Mining Frequent Patterns [Text]/
Z. H. Deng, Z. Wang // International Journal of Computational Intelligence Systems.
– 2010. – vol. 3 n. 6. – p. 733 - 744.
134. Park, J. S. Using a Hash-Based Method with Transaction Trimming and
Database Scan Reduction for Mining Association Rules [Text]/ J. S. Park, M.-S
Chen, P.S. Yu // IEEE Transactions on Knowledge and Data Engineering. – 1997. -
vol. 9. - p. 813–825.
135. Hidber, C. Online Association Rule Mining [Text]/ C. Hidber // SIGMOD 1999,
Proceedings ACM SIGMOD International Conference on Management of Data. –
NY.: CM, 1999. - pp.145-156.
136. Huang, K. Prowl: an efficient frequent continuity mining algorithm on event
sequences [Text]/ K. Huang, C. Chang, K. Lin // Data Warehousing and Knowledge
Discovery. LNCS Springer. – 2004. - vol. 3181 . - pp. 351–360.
137. Huang, K. Y. Efficient mining of frequent episodes from complex sequences
[Text]/ Y. Huang, C. H. Chang // Information Systems. – 2008. - vol.33, no.1. - p.96–
114.
272
138. Kalpakis, K. Distance measures for effective clustering of ARIMA time-series
[Text]/ K.Kalpakis, D. Gada, V. Puttagunta // Proceedings of the IEEE International
Conference on Data Mining (ICDM ’01). – IEEE, 2001. - pp. 273–280.
139. Kumar, N. Time-series bitmaps: a practical visualization tool for working with
large time series databases [Text]/ N. Kumar, et. al. // Proceedings of the 5th SIAM
International Conference on Data Mining (SDM ’05). – SIAM, 2005. - p. 531–535.
140. Chan, F. K.-P. Haar wavelets for efficient similarity search of time-series: with
and without time warping [Text]/ F. K.-P. Chan, A. W.-C. Fu, and C. Yu // IEEE
Transactions on Knowledge and Data Engineering. – 2003. - vol. 15, no. 3. - p. 686–
705.
141. Shasha, D. E. High Performance Discovery in Time Series: Techniques and
Case Studies [Text]/ D. E. Shasha,Y. Zhu. - Springer, 2004. – 190 p.
142. Keogh, E. Dimensionality reduction for fast similarity search in large time series
databases [Text]/ E. Keogh, et. al. // Knowledge and Information Systems. - 2001. -
vol. 3, no. 3. - p. 263–286.
143. Vlachos, M. Indexing time-series under conditions of noise [Text]/ M. Vlachos,
D. Gunopulos, G. Das // Data Mining in Time Series Databases. – 2004. - vol. 57. - p.
67–100.
144. Megalooikonomou, V. A dimensionality reduction technique for efficient
similarity analysis of time series databases [Text]/ V. Megalooikonomou, G. Li, Q.
Wang // Proceedings of the 13th ACM International Conference on Information and
KnowledgeManagement (CIKM ’04). – NY.:ACM, 2004. - p. 160–161.
145. Chen, Q. Indexable PLA for efficient similarity search [Text]/ Q. Chen, et. al. //
Proceedings of the 33rd International Conference onVery LargeData Bases. - VLDB
Endowment, 2007. - p. 435 – 446.
146. Dong, X. L., Research on shapebased time series similarity measure [Text]/ X.
L. Dong, C. K. Gu, Z. O. Wang // Proceedings of the International Conference on
Machine Learning and Cybernetics. – 2006. - pp. 1253–1258.
147. Megalooikonomou, V. A multiresolution symbolic representation of time series
[Text]/ V. Megalooikonomou, Q. Wang, G. Li, C. Faloutsos // Proceedings of the
21st International Conference onData Engineering (ICDE ’05). – IEEE, 2005. – p.
668–679.
273
148. Топорков, В. В. Модели распределенных вычислений [Текст]/ В. В
Топорков — М.: ФИЗМАТЛИТ, 2004. - 320 с.
149. Assent, I. The TStree: efficient time series search and retrieval [Text]/ I. Assent,
et. al // Proceedings of the 11th International Conference on Extending Database
Technology: Advances in Database Technology (EDBT ’08). – NY.:ACM, 2008. -
p.252–263.
150. Gogoi, P. A survey of outlier detection methods in network anomaly
identification [Text]/ P. Gogoi, et.al. // The Computer Journal. – 2011. - vol. 54, no.
4. - p. 570–588.
151. Laney, D. 3-D Data Management: Controlling Data Volume, Velocity and
Variety. META Group Research Note, Stamford. [Text]/ D. Laney - META Group
Inc, 2001 – (https://blogs.gartner.com/doug-laney/files/2012/01/ad949-3D-Data-
Management-Controlling-Data-Volume-Velocity-and-Variety.pdf)
152. Dean, J. MapReduce: Simplified data processing on large clusters [Text]/ J.
Dean, S. Ghemawat // Proceedings of Operating Systems Design and
Implementation. – NY.:ACM, 2004. – p. 107 – 113.
153. Lammel, R. Google’s MapReduce programming model — revisited [Text]/ R.
Lammel // Science of Computer Programming. – 2008. – vol. 70 n.1. - p.1 – 30,
2008.
154. Gorlatch, S. Extracting and implementing list homomorphisms in parallel
program development [Text]/ S. Gorlatch // Science of Computer Programming. –
1999. – vol.33, n.1. – p. 1–27.
155. Machine Learning Library (MLlib) Guide. -
(http://spark.apache.org/docs/latest/mllib-guide.html).
156. Apache Hadoop – (http://hadoop.apache.org)
157. Ng, A. Y., Map-Reduce for machine learning on multicore [Text]/ A. Y. Ng,
et.al. // Proceedings of the Twentieth Annual Conference on Neural Information
Processing Systems. – NY.:ACM, 2006. - p. 281-288.
158. Ajin, V. W. Big Data and Clustering Algorithms [Text]/ V. W. Ajin, D. K.
Lekshmy // Proceeding of International Conference on Research Advances in
Integrated Navigation Systems (RAINS - 2016). - IEEE, 2016. – p. 1-5.
274
159. Kiran, M. Verification and Validation of MapReduce Program Model for
Parallel Support Vector Machine [Text]/ Kiran, M., et. al. // International Journal of
Computer Science Issues. – 2013. – vol. 10 n.3. - p. 317-325.
160. Dai, W. A MapReduce Implementation of C4.5 Decision Tree Algorithm [Text]/
W. Dai, W. Ji // International Journal of Database Theory and Application. – 2014. –
vol. 7. n.1 - p. 49-60.
161. Han, J. A Scalable Random Forest Algorithm Based on MapReduce [Text]/ J.
Han, Y. Liu, X. Sun // 4th IEEE International Conference on Software Engineering
and Service Science. – IEEE, 2013. - p. 849-852.
162. Ayma, V. A. Classification algorithms for Big data analysis, a Map Reduce
approach [Text]/ V. A. Ayma, et.al. // The International Archives of the
Photogrammetry, Remote Sensing and Spatial Information Sciences. – 2015. – vol.
XL-3/W2. – p. 1 -10.
163. Pakize, S. Comparative Study of Classification Algorithms Based On
MapReduce Model [Text]/ S. Pakize, A. Gandomi // International Journal of
Innovative Research in Advanced Engineering. – vol. 1. n. 7. - p. 215-254.
164. Lin, M.Y. Apriori-based frequent itemset mining algorithms on MapReduce
[Text]/ M.Y. Lin, P.Y. Lee, S.C. Hsueh // Proceedings of the international conference
on ubiquitous information management and communication. – NY.: ACM. – 2012. -
p. 76:1–76:8.
165. Leung, C.S. Reducing the search space for big data mining for interesting
patterns from uncertain data [Text]/ C. S. Leung, R. MacKinnon, F. Jiang //
Proceedings of the international congress on big data. – IEEE, 2014. - p. 315–322.
166. Ingersoll, G. Introducing Apache Mahout [Text]/ G. Ingersoll –
(http://www.ibm.com/developerworks/java/library/j-mahout/)
167. Apache Ignite. Documentation. Machine Learning. –
(https://apacheignite.readme.io/docs/machine-learning)
168. De Francisci Morales, G.. SAMOA: Scalable Advanced Massive Online
Analysis [Text]/ G. De Francisci Morales, A. Bifet // Journal of Machine Learning
Research. – 2015. – vol. 16. – p. 149−153.
275
169. Bifet, A. Big Data Stream Learning with SAMOA [Text]/ A. Bifet, G. De
Francisci Morales // 2014 IEEE International Conference on Data Mining Workshop.
– IEEE, 2014. – p. 1-7.
170. De Francisci Morales G. SAMOA: A Platform for Mining Big Data Streams
[Text]/ G. De Francisci Morales // RAMSS’13: 2nd International Workshop on Real-
Time Analysis and Mining of Social Streams @WWW’13. – NY.: ACM, 2013 – p.
777 - 778.
171. Goetz, P. T. Storm blueprints: Patterns for distributed real-time computation
[Text]/ P. Taylor Goetz, , Brian O'Neill. - Packt Publishing Ltd, 2014 – 336 p.
172. Toshniwal, A. Storm @Twitter [Text]/ A. Toshniwal, et. al. // SIGMOD. -
ACM, 2014. – p. 147 – 156.
173. Neumeyer, L. S4: Distributed Stream Computing Platform [Text]/ L. Neumeyer,
et. al. // ICDMW ’10: 10th International Conference on Data Mining Workshops. –
IEEE, 2010. – p. 170–177.
174. Samza. Comparison Introduction. – 2016. –
(http://samza.apache.org/learn/documentation/ latest/comparisons/introduction.html).
175. Bifet, A. MOA: Massive Online Analysis [Text]/ A. Bifet, et. al. // Journal of
Machine Learning Research. - 2010. - (http://moa. cms.waikato.ac.nz/).
176. Langford, J. Vowpal wabbit [Text]/ J. Langford, A. Strehl, L. Li. -2007. –
(http://hunch.net/ ~vw).
177. Gronlund, C. J. Introduction to machine learning on Microsoft Azure. A guide
for technical professional [Text]/ C. J. Gronlund. - Chappell & Associates, 2015 –
(https://azure.microsoft.com/en-gb/documentation/articles/machine-learning-what-is-
machine-learning/).
178. Yu, L. BC-PDM: data mining, social network analysis and text mining system
based on cloud computing [Text]/ Yu, L., et. al. // Proceedings of the 18th ACM
SIGKDD international conference on Knowledge discovery and data mining. –
ACM, 2008. - p. 1496-1499.
179. Barr, J. Amazon Machine Learning – Make Data-Driven Decisions at Scale.
Amazon Machine Learning [Text]/ J. Barr. – 2016. -
(https://aws.amazon.com/ru/blogs/aws/amazon-machine-learning-make-data-driven-
decisions-at-scale/).
276
180. Google Cloud Machine Learning at Scale.
(https://cloud.google.com/products/machine-learning/).
181. Lally, A. Question analysis: How Watson reads a clue [Text]/ Lally, A. et. al. //
IBM Journal of Research and Development. – 2012. – vol. 56, n.3.4. – p. 1-2.
182. Холод, И.И. Архитектура «облака» интеллектуального анализа данных на
основе библиотеки алгоритмов с блочной структурой [Текст]/ И.И. Холод //
ИЗВЕСТИЯ СПбГЭТУ «ЛЭТИ». – 2014. - № 6. - C. 34-40.
183. Evans, D. The Internet of Things. How the Next Evolution of the Internet Is
Changing Everything. Cisco White Paper. [Text]/ D. Evans. - Cisco Systems, 2011. –
p. 1-7.
184. Tsai, C.-W. Future internet of things: open issues and challenges [Text]/ C.-W.
Tsai, C.-F. Lai, A. V. Vasilakos // Wireless Networks. – 2014. - vol. 20, n. 8. - p.
2201–2217.
185. Chen, F. Data Mining for the Internet of Things: Literature Review and
Challenges [Text]/ F. Chen. et.al. // International Journal of Distributed Sensor
Networks. – 2015.– vol.2015, article ID 431047. - 14 p. –
(http://dx.doi.org/10.1155/2015/431047)
186. Gubbi, J. Internet of Things (IoT): A Vision, Architectural Elements, and Future
Directions [Text]/ J. Gubbi, et.al. // Future Generation Computer Systems. – 2013. –
vol. 29, issue 7. – p. 1645–1660.
187. Холод, И. И. Выбор типа параллельного выполнения алгоритмов
интеллектуального анализа данных в зависимости от вида распределения
данных [Текст]/ И. И. Холод // Сборник докладов XVI Международной
конференции по мягким вычислениям и измерениям SCM`2013. – .СПБ.: Изд-во
СПбГЭТУ «ЛЭТИ», 2013. - том 1. - с. 158-162.
188. Интеллектуальный анализ распределенных данных на базе облачных
вычислений [Текст]/М.С. Куприянов, и др. - СПБ.: Изд-во СПбГЭТУ «ЛЭТИ»,
2011. - 148 с.
189. Интеллектуальный анализ данных в распределенных системах [Текст]/
М.С. Куприянов, и др. - СПб.: Изд-во СПбГЭТУ «ЛЭТИ», 2012. - 110 с.
277
190. Каршиев, З. А. Средства создания параллельных алгоритмов
интеллектуального анализа данных [Текст]: дис... канд. тех. наук: 05.13.11:/
Каршиев, Зайнидин Абдувалиевич. -СПб., 2013. -183 с.
191. Миллер, Р. Последовательные и параллельные алгоритмы: общий подход
[Текст]/Р. Миллер, Л. Боксер. - М. : БИНОМ, 2006. - 406 с.
192. Карпов, В. Е. Введение в распараллеливание алгоритмов и программ
[Текст]/В. Е. Карпов // Компьютерные исследования и моделирование. – 2010, –
Т. 2, № 3, – С. 231–272
193. Гергель, В.П. Теория и практика параллельных вычислений [Текст]/ В.П.
Гергелью - М.: Интернет-университет информационных технологий.; БИНОМ:
Лаборатория знаний, 2007 – 423 с.
194. Воеводин, В. В. Параллельные вычисления [Текст]/ В. В. Воеводин, Вл. В.
Воеводиню - СПБ: ВХВ-Петербург, 2002. – 608 с.
195. Foster, I. Designing and Building Parallel Programs: Concepts and Tools for
Software Engineering. Reading [Text]/ I. Foster. - MA: Addison-Wesley, 1995. –
370 p.
196. Miller, R. Algorithms Sequential and Parallel: A Unified Approach [Text]/ R.
Miller, L. Boxer. - Cengage Learning, 2013. - 450 p.
197. Cormen, T.H. Introduction to Algorithms, 3rd ed. [Text]/ T.H. Cormen, et.al. -
The MIT Press, 2009. – 1312 p.
198. Miller, R. Efficient parallel convex hull algorithms [Text]/ R. Miller, Q.F. Stout
// IEEE Transactions on Computers. – 1988. – n. 37. – p. 1605–1619.
199. Leighton, F.T. Introduction to Parallel Algorithms and Architectures: Arrays,
Trees, Hypercubes [Text]/ F.T. Leighton. – CA.: Morgan Kaufmann Publishers,
1992. – 847 p.
200. Itzhaky, S. Deriving Divide-and-Conquer Dynamic Programming Algorithms
Using Solver-Aided Transformations [Text]/ S. Itzhaky, et. al. //Proceedings of the
ACM SIGPLAN International Conference on Object-Oriented Programming,
Systems, Languages & Applications (OOPSLA 2016). - Amsterdam:ACM, 2016. -
p. 145-164.
201. Quinn, M. J. Parallel Computing Theory and Practice [Text]/ M. J. Quinn. –
NY.: McGraw-Hill, Inc, 1994. – 446 p.
278
202. Chowdhury, R. A. Basic Parallel Algorithmic Techniques. [Text]/ R. A.
Chowdhury. - Department of Computer Science SUNY Stony Brook Spring, 2012. –
463 p.
203. Karp, R.M. A survey of parallel algorithms for shared memory machines [Text]/
R.M. Karp, V. Ramachandran // Handbook of Theoretical Computer Science:
Algorithms and Complexity. - The MIT Press, 1990. – p. 869–941.
204. JaJa, J. An Introduction to Parallel Algorithms / J. JaJa. – Massachusetts:
Addison-Wesley, 1992. – 576 p.
205. Гергель, В.П. Высоко производительные вычисления для многоядерных
многопроцессорных систем. Учебник. [Текст]/ В.П. Гергель. - ННГУим.
Н.И.Лобачевского, 2010 – 421 с.
206. Гергель, В.П. Теория и практика параллельных вычислений [Текст]/
Гергель В.П. – М.: Интуит, 2016. — 500 c.
207. Гергель, В.П. Основы параллельных вычислений для многопроцессорных
вычислительных систем [Текст]/ В.П. Гергель, Р.Г. Стронгин. - Н.Новгород,
ННГУ, 2003. – 84 с.
208. Воеводин, В.В. Математические основы параллельных вычислений
[Текст]/ В.В. Воеводин. - М.: Наука, 1986. - 296 стр.
209. Абрамов, В. Μ. Анализ алгоритмов в целях распараллеливания
вычислений [Текст]/ В. Μ. Абрамов // Вычислительные системы и
автоматизация научных исследований. - М.: МФТИ, 1980. - с. 53—63.
210. Muchnick, S. S. Advanced Compiler Design and Implementation [Text]/
Muchnick S. S. — San Francisco: Morgan Kaufmann Publishers, 1997. — 856 с.
211. Banerjee, U. Data dependence in ordinary programs [Text]/ U. Banerjee // Univ.
III. Technical Rep. –– Urbana, 1976. –– p. 76–837.
212. Banerjee, U. An introduction to a formal theory of dependence analysis [Text]/
U. Banerjee // The J. of Supercomputing. –– 1988. –– Vol. 2. –– p. 133–149.
213 Bernstein, A. J. Program Analysis for Parallel Processing [Text]/ A. J. Bernstein
// IEEE Trans. on Electronic Computers. – IEEE, 1966. – p. 757-762.
214. Корнеев, В. В. Параллельное программирование в MPI [Текст]/ В. В.
Корнеев. - Новосибирск: Изд-во ИВМиМГ СО РАН, 2002. - 215 с.
279
215. Group, W. Using MPI. Portable Parallel Programming with the Message-
Passing Interface [Text]/ W Group et.al. // Scientific Programming. -1996. – p.275-
276.
216. Quinn, M.J. Parallel Programming in C with MPI and OpenMP [Text]/ M.J.
Quinn. – NY: McGraw-Hill, 2003. – 544 p.
217. Andrews, G.R. Foundations of Multithreading, Parallel and Distributed
Programming [Text]/ G.R. Andrews - Addison-Wesley, 1999. – 664 p.
218. Kurzak, J. Scientific Computing with Multicore and Accelerators [Text]/ J.
Kurzak, D.A. Bader, J. Dongarraю - Boca Raton: CRC Press, 2010. – 514 p.
219. Rauber, T. Parallel Programming for Multicore and Cluster Systems [Text]/ T.
Rauber, G. Rünger. – NY.: Springer-Verlag, 2010. – 516 p.
220. Проблемы вычислений в распределенной среде [Текст]/ Подред. С. В.
Емельянова, А.П. Афанасьева. - М.: ИСАРАН, 2003. -288 c.
221. Немнюгин, С. Параллельное программирование для многопроцессорных
вычислительных систем [Текст]/ С. Немнюгин, О. Стесик – СПб.: БХВ-
Петербург, 2002. – 400 c.
222. Богачев, К.Ю. Основы параллельного программирования [Текст]/ К.Ю.
Богачев. - М.: БИНОМ. Лабораториязнаний, 2003. - 324 с.
223. Себеста, Р. В. Основные концепции языков программирования [Текст]/ Р.
В. Себеста. — 5-е изд. — М.: «Вильямс», 2001. — С. 672.
224. Бьёрн, С. Язык программирования C++ [Текст]/ Бьёрн С. — 3-е изд. —
СПб.; М.: Невский диалект — Бином, 1999. — 991 с.
225. Шилдт, Г. Теория и практика С++ для профессионалов [Текст]/ Г.
Шилдт. — СПб.: BHV — Санкт-Петербург, 1996. – 416 с.
226. Вирт, Н. Паскаль. Руководство для пользователя и описание языка [Текст]/
Н. Вирт, К. Йенсен — М.: Финансы и статистика, 1982. — 151 с.
227. Культин, Н.Б. Delphi 6. Программирование на Object Pascal [Текст]/
Культин Н.Б. — СПб.:БХВ-Петербург, 2001.— 528 с.
228. Карпов, В.Э.. Классическая теория компиляторов — Учебное пособие
[Текст]/ В.Э. Карпов - 2-е изд. — Москва, 2011.— 91с.
280
229. Бартеньев, О.В. Современный Фортран [Текст]/ О.В. Бартеньев — М.:
Диалог МИФИ, 2005. – 449 с.
230. Бар, Р. Дж. Язык Ада в проектировании систем [Текст]/ Р. Бар — М.:
«Мир», 1988. — С. 318.
231. Горелик, А.М. Программирование на современном Фортране. [Текст]/
А.М. Горелик. — Москва: Финансы и статистика, 2006. — 352с.
232. Chandra, R. Parallel Programming in OpenMP [Text]/ Chandra, R. et. al. -
Morgan Kaufinann Publishers, 2000. – 231 p.
233. Вальковский, В.А. Параллельное выполнение циклов. Метод
параллелепипедов [Текст]/ В.А. Вальковский // Кибернетика. – 1982. - N 2. - с.
51-62.
234. Вальковский, В. А. Параллельное выполнение циклов. Метод пирамид
[Текст]/ В.А. Вальковский // Кибернетика. – 1983. - N 5. - с. 51-55.
235. Вольф, М. Перестановка циклов. Векторизация программ: теория, методы,
реализация [Текст]/ Вольф М // Сб. статей. - М.: Мир. 1991. - С. 48 – 65.
236. Штейнберг, Б. Я. Математические методы распараллеливания
рекуррентных циклов для суперкомпьютеров с параллельной памятью [Текст]/
Б. Я. Штейнберг - Ростов-на-Дону: Изд-во Ростовского университета, 2004. -
192 с.
237. Эккель, Б.. Философия Java / Б. Эккель — 3-е изд. — СПб.: Питер, 2003. —
976 с.
238. Шилдт, Г. Java 8. Полное руководство [Текст]/ Г. Шилдт - 9-е издание. —
М.: «Вильямс», 2015. — 1376 с.
239. Скит, Д. C# для профессионалов: тонкости программирования [Текст]/ Д.
Скит - 3-е издание. — М.: «Вильямс», 2014. — 608 с.
240. Хейлсберг, А. Язык программирования C#. Классика Computers Science
[Текст]/ А. Хейлсберг, М. Торгерсен, С. Вилтамут - 4-е издание.—
СПб.:«Питер», 2012.— 784с.
241. Грэм, П.. ANSI Common Lisp [Текст]/ П. Грэм — СПб.: Символ-Плюс,
2012. — 448 с.
281
242. Хювёнен, Э. Мир Лиспа. В 2-х т. [Текст]/ Э. Хювёнен, Й. Сеппянен — М.:
Мир, 1990. -
243. Душкин, Р. В. Функциональное программирование на языке Haskell
[Текст]/ Р. В. Душкин .—М.: ДМК Пресс,, 2008.— 544 с.
244. B. O’Sullivan. Real World Haskell [Text]/ B. O’Sullivan, J. Goerzen, D. Stewart
— O’Reilly, 2008 — 710 c.
245. Эббинхауз, Г.Д. Машины Тьюринга и рекурсивные функции [Текст]/
Эббинхауз Г.Д. [и др.]. — М.: Мир, 1972. — 262 с.
246. Turing, A. M. On Computable Numbers, with an Application to the
Entscheidungs problem [Text]/ A. M. Turing // Proceedings of the London
Mathematical Society— 1937. — vol.42. — p.230–265.
247. Church, A. A set of postulates for the foundation of logic [Text]/ A. Church //
Annals of Mathematics. Series 2. – 1932. – vol. 33 n. 2 – p. 346–366.
248. Barendregt, H. P. The Lambda Calculus: Its Syntax and Semantics [Text]/ H. P.
Barendregt // Studies in Logic and the Foundations of Mathematics. - 1981. - vol 103.
– 638 p.
249. Ali, H. H. Task Scheduling in Parallel and Distributed Systems [Text]/ H. H.
Ali, H. El-Rewini, T. G. Lewis // PTR Prentice Hall. - 1994.
250. Bokhari, S. H. On the mapping problem [Text]/ S. H. Bokhari // IEEE
Transaction on Computers - 1981.- vol.30, n 3. - p. 207 - 214.
251. Lo, V. M. Heuristic Algorithms for Task Assignment in Distributed Systems
[Text]/ V. M. Lo // IEEE Transaction on Computers. – 1988 - vol.37, n.11. – p. 1384-
1397.
252. Braun, T. D. A Comparison Study of Static Mapping Heuristic for a Class of
Meta-task [Text]/ T. D. Braun et. al. // Proceedings. Eighth Heterogeneous
Computing Workshop (HCW'99). – IEEE,1999. – p.1-16.
253. Хорошевский, В.Г. Алгоритмы распределения ветвей параллельных
программ по процессорным ядрам вычислительных систем [Текст] /В.Г.
Хорошевский, М.Г. Курносов // Автометрия. - 2008. - Т. 44,№ 2. - С. 56-67.
282
254. Yadav, V. K. Relaible Task Allocation in heterogeneous Distributed System
with random node Failure: Load Sharing approach [Text]/ V. K. Yadav, M. P. Yadav,
D. K. Yadav // International conference on Computing Sciences. – 2012 - p. 187-192.
255. Semchedine, F. Task Assignment policies in distributed server systems: A
survey [Text]/ F. Semchedine, L. B. Medjkoune, D. Aissani // Journal of network and
Computer Applications. – 2011. - p. 1123-1129.
256. Kaur, S. A Review of Load Balancing Strategies for Distributed Systems [Text]/
S. Kaur, G. Kaur // International Journal of Computer Applications . – 2015. – vol.
121, n.18. – p. 45-47.
257. Patni, J. Ch. Load balancing strategies for Grid computing [Text]/ J. Ch. Patni //
- IEEE, 2011. - p. 239-243.
258. Bertsekas, D.P. Parallel and Distributed Computation. Numerical Methods
[Text]/ D.P. Bertsekas, J.N. Tsitsiklis — NJ.:Prentice Hall, Englewood Cliffs, 1989.
– 715 p.
259. Butenhof, D. R. Programming with POSIX Threads [Text]/ D. R. Butenhof. -
Addison-Wesley, 1997. – 400 p.
260. Lewis, B. Threads Primer: A Guide to Multithreaded Programming [Text]/ B.
Lewis. - Prentice Hall, 1995. – 352 p.
261. Thomas, E. Service-Oriented Architecture (SOA): Concepts, Technology and
Design [Text]/ E. Thomas. - Prentice Hall Professional Technical Reference, 2005 –
c. 760.
262. Биберштейн, Н. Компас в мире сервис-ориентированной архитектуры
(SOA) [Текст]/ Н. Биберштейн. - КУДИЦ-Пресс. 2007 – c. 256.
263. Hewitt, C.. A universal modular ACTOR formalism for artificial intelligence
[Text]/ C. Hewitt, P. Bishop, R. Steiger // In IJCAI. - 1973. - p 235-245.
264. Hewitt, C. Actors and continuous functional [Text]/ C. Hewitt, H. Baker. -
Cambridge. Massachusetts. USA: Massachusetts Institute of Technology, 1977. – 290
p.
265. Clinger, W. Foundations of Actor Semantics [Text]/ W. Clinger. - Cambridge.
Massachusetts. USA: Massachusetts Institute of Technology, 1981. – 178 p.
283
266. Wooldridge, M. An Introduction to MultiAgent Systems [Text]/ M.
Wooldridge. - John Wiley & Sons Ltd, 2002. - 366 p.
267. Ferber, J. Multi-Agent Systems: An Introduction to Artificial Intelligence
[Text]/ J. Ferberю - Addison-Wesley, 1999. – 528 p.
268. Miller, R. Parallel Algorithms for Regular Architectures: Meshes and Pyramids
[Text]/ R. Miller, Q.F. Stout. - Cambridge, Massachusetts : The MIT Press, 1996. –
310 p.
269. Boxer, L. Efficient Coarse Grained Permutation Exchanges and Matrix
Multiplication [Text]/ L. Boxer // Parallel Processing Letters. – 2009. – vol.19. – p.
477–484.
270. Almasi, G. S. Highly Parallel Computing [Text]/ G. S. Almasi, A. Gottlieb. –
NY.: The Benjamin/Cummings Publishing Company, 1994. – 689 p.
271. Stout, G.W. High Performance Computing [Text]/ G.W. Stout. - Massachusetts :
Addison-Wesley, 1995. – p. 1 -5.
272. Самарский, А. А. Численные методы [Текст]/ А. А.Самарский, А.В. Гулин
— М.: Наука. Гл. ред. физ-мат. лит., 1989.— 432 с.
273. Dongarra, J.J. Numerical Linear Algebra for High Performance Computers
(Software, Environments, Tools) [Text]/ Dongarra J.J., et.al. - Soc. for Industrial &
Applied Math., 1999. – 336 p.
274. Akl, S.G. Parallel Sorting Algorithms [Text]/ S.G. Akl. – Orlando, FL:
Academic Press, 1985. – 244 p.
275. Kumar, V. Introduction to Parallel Computing [Text]/ V. Kumar, et. al. — The
Benjamin/Cummings Publishing Company, Inc., 2003. – 656 p.
276. Barnard, S. PMRSB: Parallel multilevel recursive spectral bisection [Text]/ S.
Barnard //Proceding Supercomputing '95.- IEEE, 1995 – p. 234-243.
277. Gilbert, J. A parallel graph partitioning algorithm for a message-passing
multiprocessor [Text]/ J. Gilbert, E. Zmijewski // International Journal of Parallel
Programming. - 1987. - p. 498 – 513.
278. Heath, M. Cartesian parallel nested dissection algorithm [Text]/ M. Heath, P. A.
Raghavan // SIAM Journal of Matrix Analysis and Applications. - 1995. – vol.16.
n.1. - p. 235-253.
284
279. Karypis, G. A parallel algorithm for multilevel graph partitioning and sparse
matrix ordering [Text]/ G. Karypis, V. Kumar // Journal of Parallel and Distributed
Computing. - 1988. – vol.48, n.1. – p. 71-95.
280. Karypis, G. Parallel multilevel k-way partitioning scheme for irregular graphs
[Text]/ G. Karypis, V. Kumar // Siam Review. - 1999. – vol.41, n.2. - p. 278 – 300.
281. Raghavan, P. Parallel ordering using edge contraction. Technical Report CS-95-
293 [Text]/ P. Raghavan // Parallel Computing. - 1995.–vol.23. – n 8. – p.1045-1067.
282. Walshaw, C. Parallel optimization algorithms for multilevel mesh partitioning.
Techical Report 99/IM/44 [Text]/ C. Walshaw, M. Cross.// Parallel Computing-
1999. - vol.26. – n 12. – p. 1635-1660.
283. Asaithambi, N. S. Numerical Analysis: Theory and Practice [Text]/ N. S.
Asaithambi. - Fort Worth : Saunders College Publishing, 1995. – 830 p.
284. Burden, R. L. Numerical Analysis [Text]/ R.L. Burden and J.D. Faires. - Boston
: PWS-Kent Publishing Company, 1993. – 912 p.
285. Yakowitz, S. An Introduction to Numerical Computations [Text]/ S. Yakowitz,
F.Szidarovszky. - NJ.: Prentice Hall, Upper Saddle River, 1990. – 462 p.
286. Akl, S.G. Parallel Computational Geometry [Text]/ S.G. Akl, K.A. Lyons. //
Algorithmica - Prentice Hall, 1993. – p. 293-327.
287. Lee, C.C. On a Cover-Circle Minimization Problem [Text]/ C.C. Lee, D.T. Lee
// Information Processing Letters. – 1984. – vol. 18. - 180–185.
288. Bertossi, A. A. Parallel circle-cover algorithms / A.A. Bertossi // Information
Processing Letters. – 1988 - vol. 27. – p.133–139.
289. Atallah, M.J. An Optimal Parallel Algorithm for the Minimum Circle-Cover
Problem [Text]/ M.J. Atallah, D.Z. Chen // Information Processing Letters. - 1989 -
vol. 32 – p. 159–165.
290. Boxer, L. A Parallel Circle-Cover Minimization Algorithm [Text]/ L. Boxer, R.
Miller // Information Processing Letters. – 1989. – vol. 32 – p. 57–60.
291. Sarkar, D. An Optimal Parallel Circle-Cover Algorithm [Text]/ D. Sarkar, I.
Stojmenovic // Information Processing Letters. – 1989. – vol.32. – p. 3–6.
285
292. Kahng, A. B. Optimal Algorithms for Extracting Spatial Regularity in Images
[Text]/ A.B. Kahng, G. Robins // Pattern Recognition Letters. – 1991 - vol. 12 – p.
757–764.
293. Boxer, L. Parallel Algorithms for All Maximal Equally Spaced Collinear Sets
and All Maximal Regular Coplanar Lattices [Text]/ L. Boxer, R. Miller // Pattern
Recognition Letters. - 1993-. vol. 14. – p. 17–22.
294. Boxer, L. Scalable Parallel Algorithms for Geometric Pattern Recognition
[Text]/ L. Boxer, R. Miller, A. Rau-Chaplin // Journal of Parallel and Distributed
Computing. – 1999. - vol. 58. – p. 466–486.
295. Robins, G. On Detecting Spatial Regularity in Noisy Images [Text]/ G. Robins,
B.L. Robinson, B.S. Sethi // Information Processing Letters. - 1999. – vol. 69. – p.
189–195.
296. Boxer, L. A Parallel Algorithm for Approximate Regularity [Text]/ L. Boxer, R.
Miller // Information Processing Letters. – 2001. – vol. 80. - p. 311–316.
297. Sujni, P. Parallel and Distributed Data mining [Text]/ P. Sujni // New
Fundamental Technologies in Data mining. – 2011. - p. 43-54.
298. Talia, D. Parallelism in Knowledge Discovery Techniques [Text]/ D. Talia //
Proceedings of the 6th International Conference on Applied Parallel Computing
Advanced Scientific Computing. - London, UK.: Springer-Verlag, 2002. - p. 127–
138.
299. Satuluri, V. A survey of parallel algorithms for classification [Text]/ V. Satulur.
- 2007. – (http://citeseerx.ist.psu. edu/viewdoc/summary?doi=10.1.1.126.5567).
300. Zaki, M.J. Parallel classification for data mining on shared memory
multiprocessors [Text]/ M. J. Zaki, C.T. Ho, R. Agrawal // 15th IHHH Intl. Conf. on
Data Engineering. – IEEE,1999. – p. 1 – 8.
301. Mehta, M. SLIQ: A fast scalable classier for data mining [Text]/ M. Mehta, R.
Agrawal, J. Rissanen // Proc. of the Fifth Intl Conference on Extending Database
Technology (HDBT). – 1996. – p. 18 -33.
302. Shafer, J. Sprint: A scalable parallel classier for data mining [Text]/ J. Shafer, R.
Agrawal, M. Mehta // 22nd VLDB Conference. - 1996. - 544--555
303. Kufrin, R. Decision trees on parallel processors [Text]/ R. Kufrin // Parallel
Processing for Artificial Intelligence. - Elsevier-Science, 1997 – p. 11 – 20.
286
304. Joshi, M. ScalParC: A New Scalable and Efficient Parallel Classification
Algorithm for Mining Large Datasets [Text]/ M. Joshi, G. Karypis, V. Kumar //
Proceedings of the First Merged International Parallel Processing Symposium and
Symposium on Parallel and Distributed Processing. – IEEE,1998. – p. 1-8.
305. Chattratichat, J. Large scale data mining: Challenges and responses [Text]/ J.
Chattratichat, et al. // In 3rd Intl. Conf. on Knowledge Discovery and Data mining. –
AAAI, 1997. – p.143 – 146.
306. Kim, W. Parallel clustering algorithms: survey. [Text]/ W. Kim. – Spring, 2009.
– 32 p.
307. Zaki, M.J. Agrawal R. Parallel classification for data mining on shared memory
multiprocessors [Text]/ M.J. Zaki, C.T. Ho // 15th IEEE Intl. Conf. on Data
Engineering. – IEEE, 1999. – p. 1 -22.
308. Amado, N. Exploiting Parallelism in Decision Tree Induction [Text]/ N. Amado,
J. Gama, F. Silva. //Parallel and Distributed computing for Machine Learning.
Cavtat-Dubrovnik, Croatia. - 2003. – 1-9.
309. Williams, G. J. Inducing and Combining Decision Structures for Expert
Systems. PhD thesis [Text]/ Williams G. J. - The Australian National University,
1990. – 183 p.
310. Provost, F. J. Scaling up: Distributed machine learning with cooperation [Text]/
F. J. Provost, D. N. Hennessy // Thirteenth National Conference on Artificial
Intelligence (AAAI-96). - 1996. - p. 74–79.
311. Hall, O. L. Learning rules from distributed data [Text]/ O. L. Hall, N. Chawla,
W. K. Bowyer // In Workshop on Large – Scale Parallel KDD Systems (KDD99). -
1999. p. 77–83.
312. Chan, P. Experiments on multistrategy learning by meta-learning [Text]/ Chan
P., Stolfo S. // Proceeding of the second international conference on information
knowledge management. - AAAI Press, 1993. - p. 314-323.
313. Chan, P. Toward scalable learning with non-uniform class and cost distribution:
A case study in credit card fraud detection. [Text]/ Chan P., Stolfo S. // Proceeding of
the fourth international conference on knowledge discovery and data mining. - AAAI
Press, 1998. – p.164 – 168.
287
314. Chan, P. Toward parallel and distributed learning by meta-learning [Text]/ Chan
P., Stolfo S. // Working notes AAAI work knowledge discovery in database. - AAAI
Press, 1993. - p. 227-240.
315. Ranka, S. Clustering on a Hypercube Multicomputer [Text]/ S. Ranka, S.Sahni //
IEEE Transactions on Parallel and Distributed Systems. - 1991.– vol. 2, n.2. - p. 129–
137.
316. Johnson, H. Collective, Hierarchical Clustering From Distributed,
Heterogeneous Data. [Text]/ H. Johnson, H. Kargupta // In Large-Scale Parallel KDD
Systems. Lecture Notes in Computer Science, Springer. – 1999. - vol. 1759. - p.
221–244.
317. Goil, S. H. N. MAFIA: Efficient and scalable subspace clustering for very large
data sets. Technical Report 9906-010 [Text]/ S. H. N. Goil, A. Choudhary - Center
for Parallel and Distributed Computing, Northwestern University. - 1999. – 20 p.
318. Judd, D. Large-scale parallel data clustering [Text]/ D. Judd, P. McKinley, A.
Jain // Intl Conf. Pattern Recognition. – IEEE, 1996. – p. 871 – 876.
319. Kashef, R. Cooperative Clustering Model and Its Applications. PhD thesis
[Text]/ R. Kashef. - University of Waterloo, Department of Electrical and Computer
Enginnering, 2008. – 170 p.
320. Hammouda, K. M. Distributed collaborative web document clustering using
cluster keyphrase summaries [Text]/ K. M. Hammouda, M. S. Kamel // Information
Fusion. – 2008. – vol. 9, n.4. - p 465 – 480.
321. Deb, D. Distributed document clustering using word-clusters [Text]/ D. Deb, R.
A. Angryk // Computational Intelligenceand Data mining. CIDM 2007. IHHH
Symposium. – 2007. - p. 376–383.
322. Li, T. Algorithms for Clustering High Dimensional and Distributed Data [Text]/
T. Li, S. Zhu, M. Ogihara // Intelligent Data Analysis Journal. – 2003. – 7(4) – p. 1-
36.
323. Kargupta, H. Scalable, distributed data mining using an agent based architecture
[Text]/ H. Kargupta, I. Hamzaoglu, B. Stafford // Proceedings the Third International
Conference on the Knowledge Discovery and Data mining. - Menlo Park, California:
AAAI Press, 1997 - p. 211–214.
288
324. Samatova, N. F. An efficient cover-based merging of clustering hierarchies from
distributed datasets [Text]/ N. F. Samatova et.al. // Distrib. Parallel Databases. –
2002. - 11(2). - p. 157–180.
325. Kargupta, H. Distributed clustering using collective principal component
analysis [Text]/ Kargupta H., et.al. // Knowl. Inf. Syst. – 2001. - 3(4). - p. 422–448.
326. Dhillon, I. S. A data-clustering algorithm on distributed memory
multiprocessors [Text]/ I. S. Dhillon, D. S. Modha // Workshop on Large-Scale
Parallel KDD Systems. -. London : Springer-Verlag, 2000. - p. 245–260.
327. Zhang, B. Accurate recasting of parameter estimation algorithms using sufficient
statistics for efficient parallel speed-up: Demonstrated for center-based data
clustering algorithms [Text]/ B. Zhang, Hsu Meichun, G. Forman // In PKDD ’00. -
London: Springer-Verlag, 2000. - p. 243–254.
328. Januzaj, E. DBDC: Density based distributed clustering [Text]/ E. Januzaj, H.-P.
Kriegel, M. Pfeifle // EDBT. Lecture Notes in Computer Science. Springer. - 2004. -
vol. 2992 - p. 88–105.
329. Xu, X. A fast parallel clustering algorithm for large spatial databases [Text]/ X.
Xu, J. Jager, H.-P. Kriegel // Data Min. Knowl. Discov. - 1999. - 3(3). - p. 263–290.
330. Klusch, M. Agent-based distributed data mining: The KDEC scheme. Intelligent
Information Agents: The AgentLink Perspective [Text]/ M. Klusch, S. Lodi, G. Moro
// Lecture Notes in Computer Science. Springer. - 2003. - vol. 2586. – p. 104-122.
331. Klusch, M. Distributed clustering based on sampling local density estimates
[Text]/ M. Klusch, S. Lodi, G. Moro // International Joint Conference on Artificial
Intelligence (IJCAI), Acapulco, Mexico. - 2003. – p. 485-490.
332. Zaki, M. Parallel and distributed association mining: a survey [Text]/ M. Zaki //
IEEE Concurrency.- 1999. - 7(4). - p.14– 25.
333. Strehl, A. Cluster ensembles – a knowledge reuse framework for combining
multiple partitions [Text]/ A. Strehl, J. Ghosh // Mach. Learn. Res. - 2003. - 3. - P.
583–617.
334. Fred, A. L. N Data clustering using evidence accumulation [Text]/ A. L. N.
Fred, A. K. Jain // Pattern Recognition proceedings 16th International Conference. -
London : Springer-Verlag, 2002. - vol.4. - p. 443–452.
289
335. Nicoloyannis, J. A method for aggregating partitions, applications in k.d.d.
[Text]/ J. Nicoloyannis, N. Nicoloyannis // PAKD. Lecture Notes in Computer
Science. Springer. - 2003. - vol. 2637. - p. 411–422.
336. Merugu, S. Privacy-preserving distributed clustering using generative models
[Text]/ S. Merugu, J. Ghosh // ICDM. IEEE Computer Society. – IEEE, 2003. - p.
211–218.
337. Vaidya, J. Privacy-preserving k-means clustering over vertically partitioned data
[Text]/ J. Vaidya, C. Clifton // KDD. ACM. – NY.: ACM, 2003. - p. 206–215.
338. Hammouda, K. M. HP2PC: Scalable hierarchically-distributed peer-to-peer
clustering [Text]/ K. M. Hammouda, M. S. Kamel // In SDM. SIAM. – IEEE, 2007. –
p. 681 – 698.
339. Datta, S. K-means clustering over a large, dynamic network [Text]/ S. Datta, C.
Giannella, H. Kargupta // Proceedings of the 2006 SIAM International Conference on
Data Mining. – SIAM, 2006. – p. 153 – 164.
340. Zaki, M. J. Parallel algorithms for discovery of association rules [Text]/ Zaki M.
J., et. al. // Data mining and Knowledge Discovery. An International Journal, special
issue on Scalable High-Performance Computing for KDD. – 1997. - 1(4). - p. 343–
373.
341. Pramudiono, I. Tree structure based parallel frequent pattern mining on PC
cluster [Text]/ I. Pramudiono, M. Kitsuregawa // Proc. of the 14th Int’l Conf. on
Database and Expert Systems Applications. – Springer, 2003. - p. 537–547.
342. Zaki, M.J. Parallel data mining for association rules on shared-memory multi-
processors [Text]/ Zaki M. J., et. al. //Supercomputing'96. – Springer, 1996. – p.1-18.
343. Cheung, D. Asynchronous parallel algorithm for mining association rules on
shared-memory multi-processors [Text]/ D. Cheung, K.Hu, S. Xia // 10th ACM
Symp. Parallel Algorithms and Architectures. – NY.:ACM, 1998. – p. 279-288.
344. Shintani, T. Hash based parallel algorithms for mining association rules [Text]/
T. Shintani, M.Kitsuregawa // 4th Intl. Parallel and Distributed Info. Systems. –
IEEE, 1996. – p. 19-30.
345. Zaki, M.J. Parallel algorithms for fast discovery of association rules/ Zaki M. J.,
et. al. // Data mining and Knowledge Discovery: An International Journal. -1997. –
vol.1(4). – p. 343-373.
290
346. Mueller. Fast Sequential and ParallelAlgorithms for Association Rule Mining: A
Comparison [Text]/ Mueller // Tech. Report CS-TR-3515. - College Park, Md: Univ.
of Maryland,1995 – 76 p.
347. Park, J.S. Efficient Parallel Data mining for Association Rules [Text]/ J. S. Park,
M. Chen, P. S. Yu // Proc. ACM Intl Conf. Information and Knowledge
Management. - NY.: ACM Press. - 1995. - p. 31–36.
348. Cheung, D. A Fast Distributed Algorithm for Mining Association Rules [Text]/
D. Cheung et al. // Proc. 4th Intl Conf. Parallel and Distributed Information Systems.
– IEEE, 1996. - p. 31–42.
349. Agrawal, R. Parallel Mining of Association Rules [Text]/ R. Agrawal, J. C.
Shafer // IEEE Transactions on Knowledge and Data Engineering. – 1996. - vol. 8, n.
6. - p. 962 - 969.
350. Han, E.-H. Scalable Parallel Data Mining For Association Rules [Text]/ E.-H.
Han, G. Karypis, V. Kumar // Proceedings of the ACM SIGMOD Conference. –
1997. - p. 277-288.
351. Zaki, M. J. New Parallel Algorithms for Fast Discovery of Association Rules
[Text]/ M. J. Zaki, et.al // Data Mining and Knowledge Discovery. - 1997. - vol. 1, n.
4. - p. 343-373.
352. Harada, L. Dynamic Skew Handling in Parallel Mining of Association Rules
[Text]/ L. Harada et. al. // Proceedings of the 7th International Conference on
Information and Knowledge Management. – 1998. - p.76-85.
353. Себеста, Р.У. Основные концепции языков программирования [Текст]/ Р.У.
Себеста— 5-е изд. — М.: Вильямс, 2001. – 672 c.
354. Church, A. Some properties of conversion [Text]/ A. Church, J. Barkley Rosser
// Trans. AMS. - 1936. – 39. - 472-482.
355. Keller, R. M. A fundamental theorem of asynchronous parallel computation
[Text]/ Keller R. M // Proc. of the Sagamore Comput. Conf. Parallel Process. Lecture
Notes on Computer Science. V. 24. — Berlin: Springer-Verlag, 1975. — p. 102-112.
356. Bishop, C. Pattern recognition and machine learning [Text]/ Bishop, C. - Berlin:
Springer, 2006 – 738 p.
357. Кнут, Д. Искусство программирования, том 1. Основные алгоритмы
[Текст]/ Д. Кнут — 3-е изд.— М.: «Вильямс», 2006. — С. 720.
291
358 Lee, C. Y. An algorithm for path connection and its applications [Text]/ C. Y.
Lee // IRE Transactions on Electronic Computers. – 1961. - EC-10(3). - p. 346–365.
359 Hockney, R. W.. The communication challenge for MPP: Intel Paragon and
Meiko CS2 [Text]/ Roger W. Hockney // Parallel Computing. —1994. — Vol. 20,
no. 3. — P. 389–398
360 Vu, N. A SLOC Counting Standard [Text]/ Vu N. et.al. - Center for Systems and
Software Engineering , University of Southern California, 2007. – p. 1-15.
361. Холод, И.И. Архитектура «облака» интеллектуального анализа данных на
основе библиотеки алгоритмов с блочной структурой [Текст]/ И.И. Холод //
ИЗВЕСТИЯ СПбГЭТУ «ЛЭТИ». – 2014. - № 6. - C. 34-40.
362 Холод, И.И. Подготовка распределенных разнородных данных к
интеллектуальному анализу данных [Текст]/ И.И. Холод и др. // Сборник
докладов XVIII Международной конференции по мягким вычислениям и
измерениям SCM`2015. – СПб.: изд. Известия-ЛЭТИ, 2015. - с. 205-207.
363 Холод, И. И. Интерфейс к облачному сервису интеллектуального анализа
данных [Текст]/ И. И. Холод, И. А. Строев, О. С. Беляева // Сборник докладов
XVIII Международной конференции по мягким вычислениям и
измерениям SCM`2015. – СПб.: изд. Известия-ЛЭТИ, 2015. - с. 202-204.
364 Макаренко, Д.М. На орбитальных рубежах [Текст]/ Д.В. Макаренко, А. Ю.
Потюпкин. – М.: Academia, – 2008. – 280 с.
365 Холод, И.И. Построение единого унифицированного информационно-
аналитического пространства на базе защищенных облачных технологий
[Текст]/ И.И. Холод, Е.В. Постников // III Всероссийская научно-техническая
конференция. Радиотехнические Информационные Системы ВКО-2015. – М.:
изд-во МГТУ им. Н.Э. Баумана, 2015 –c.405 – 412.
366 Холод, И. И. Единая информационно-аналитическая платформа на базе
защищенных облачных технологий для космических войск [Текст]/ И.И. Холод,
С.А. Беляев, А. И. Вайнтрауб // II Всероссийская научно-техническая
конференция. Теоретические и прикладные проблемы развития и
совершенствования автоматизированных систем управления военного
назначенияю – 2015. - с.230 – 238.
367 Холод, И.И. Технология трёхмерного моделирования космической
обстановки на основании информации, поступающей в реальном времени
292
[Текст]/ И.И. Холод, С.А. Беляев, В.А. Ежов // III Всероссийская научно-
техническая конференция. Современные проблемы создания и эксплуатации
вооружения, военной и специальной техники. – 2016. - с.217-221.
368 Холод, И.И. Сбор измерительной информации с распределенных
измерительных средств в режиме реального времени [Текст]/ И.И. Холод. //
ИЗВЕСТИЯ СПбГЭТУ «ЛЭТИ». - 2016. - № 9. - C. 34-40.
369 Kholod, I. Distributed Measurement Data Gathering about Moving Objects
[Text]/ I. Kholod, N. Plokhoy, A. Shorov // Wireless Communications and Mobile
Computing. -2017. - vol. 2017. – p. 1-13.
370 Kholod, I. Fog computing for telemetry gathering from moving objects [Text]/ I.
Kholod, N. Plokhoi, A. Shorov // Springer. Lecture Notes in Computer Science. –
2017. – vol. 10531. - p. 498-509.
371 Kholod, I. A. Smart collection of measurement from moving objects [Text]/
Kholod, I. et. al. // Vibroengineering Procedia. – 2017. – vol. 12. - p. 166-171.
293
Приложение A. Модели знаний
A.1 Элемент модели знаний - предикат
Одним из основных элементов многих моделей знаний является предикат,
который описывает некоторое условное выражение. В стандарте PMML он
представлен как тип PREDICATE (Рисунок А.1).
Рисунок А.1 – PMML модель предиката.
Формально он может быть описан как элемент модели знаний:
e = <{aj, op, vj.q, bo}, {e1, e2, …, ei, …, eg}>, где
aj – атрибут входного набора данных ajA;
op – операция сравнения принимающая одно из следующих значений:
equal, notEqual, lessThan, lessOrEqual, greaterThan, greaterOrEqual,
isMissing, isNotMissing;
vj.q – значение атрибута aj (vj.qD(aj));
294
bo – булевский оператор, принимающий одно из следующих
значений: and, or, xor или surrogate;
ei – предикат входящий в состав составного предиката.
А.2 Модель знаний - набор классификационных правил
В стандарте PMML набор правил представлен моделью RuleSet (Рисунок
А.2.). В соответствии с этим модель знаний, представляющая набор правил
описывается следующим образом:
mR = {e0, e1} = {e0, <{curr, size, n}, {e1.1, e1.2, …, e1.p, …, e1.g}>}, где
n PC– вычисляемый параметр элемента модели знаний e1,
определяющий количество векторов удовлетворяющих правилам
(корректных векторов) входящих в множество e1.L (данное свойство
соответствует атрибуту nbCorrect элемента RuleSet);
e2.p – классификационное правило, простейший вид которого может быть
определен как набор параметров:
e1.p = <p, n>, где
идентификационными параметрами PI являются:
p – предикат правила (соответствует элементу SimplePredicat);
вычисляемым параметром PC является: n P
C свойство, определяющее
количество корректных векторов – векторов для которых данное
правило является верным (соответствует атрибуту nbCorrect элемента
SimpleRule на):
n = |{xj : xjX, (ak(xj) = vk.qи at(xj) = vt.p)}|.
295
Рисунок А.2 – PMML модель знаний – набор классификационных правил.
A.3 Модель знаний – наивный байесовский классификатор
В стандарте PMML модель знаний, описывающая наивный байесовский
классификатор (Naïve Base), представлена PMML моделью NaiveBayesModel
(Рисунок А.3). В соответствии с этим модель знаний, представляющая
байесовскую модель, описывается следующим образом:
mNB = {e0, e1, e2}, где
e1 – множество частот для значений независимых атрибутов
(соответствует BayesInputs в NaiveBayesModel):
296
e1 = <{curr, size, n}, {e1.1, e1.2, …, e1.i, …, e1.m}>, где
e1.i - количество векторов для каждого значения независимого атрибута aj
и каждого значения целевого атрибута (соответствует BayesInput в
NaiveBayesModel), являющееся множеством:
e1.i = <{curr, size, n}, {e1.i.1, e1.i.2, …., e1.i.j, …, e1.i.k}>, где
e1.i.j - распределение векторов со значением vi.j атрибута ai по значениям
целевого атрибута at.
e2 – множество (соответствует BayesOutputs в NaiveBayesModel):
e2 = <{curr, size, n}, { e1.1, e1.2, …, e1.v, …, e1.k}>, где
o e1.v - распределение всех векторов по значениям целевого атрибута,
аналогично описанному выше..
В случае категориального типа целевого атрибут at, такое распределение
описывается следующим элементом модели знаний:
e1.i.j = <{ vt.p , n i.j.p }, Ø>, где
vt.p PI – идентификационный параметр, значение целевого атрибута at
vt.qD(at);
n i.j.p PC – вычисляемый параметр, количество векторов у которых
независимый атрибут ai имеет значении vi.j , а целевой атрибут at имеет
значение vt.q.
В случае числового типа целевого атрибута at, данное распределение
описывается как Гаусовское или Пуасоновское.
297
Рисунок А.3 – PMML модель знаний – наивный байесовский классификатор.
A.4 Модель знаний - дерево решений
В стандарте PMML модель знаний дерево решений представлена
моделью TreeModel (Рисунок А.4). В соответствии с ним модель знаний,
представляющая дерево решений, описывается следующим образом:
mDT = {e0, e1}, где
298
Рисунок А.4 – PMML модель знаний – дерево решений.
299
e1 – корневой узел дерева:
e1 = <{curr, size, n, p, с }, {e1.1, e1.2, …, e1.i, …, e1.m}>, где
p – предикат узла, определяет условие, по которому вектора относятся к
данному узлу дерева;
c – количество векторов, входящих в узел;
v – значение целевого атрибута (класс) к которому относятся все вектора
данного узла, для неконечных узлов данный элемент может быть
пропущен.
Каждый дочерний узел дерева e1.i представляет собой такую же
структуру. Листья дерева решений имеют пустое множество дочерних
элементов.
A.5. Модель знаний - регрессия
В стандарте PMML регрессия представлена моделью RegressionModel
(Рисунок А.5). В соответствии с ним модель знаний, представляющая
регрессионную модель, описывается следующим образом:
mreg= {e0, e1, e2}, где
e1 – множество коэффициентов для независимых атрибутов:
e1 = <{curr, size, n}, {e1.1, e1.2, …, e1.j, …, e1.p}>, где
o e1.j – коэффициент для независимого атрибута aj:
e1.j = <{aj, v, e, c}, Ø>, где
aj – независимый атрибут для которого определен коэффициент;
v – значение атрибута для которого определен коэффициент
(актуально для категориальных атрибутов);
c – коэффициент;
e – экспонента, для линейной зависимости (не полиномиальной)
e=1;
300
Рисунок А.5 – PMML модель знаний – регрессия.
e2 – множество комбинаций атрибутов через умножение:
e2 = <{curr, size, n}, {e2.1, e2.2, …, e2.i, …, e2.g}>, где
301
o e1.i – комбинации нескольких атрибутов перемноженных друг на
друга:
e2.i= <{ c, A’}, Ø>, где
с – коэффициент;
A’ – множество комбинируемых атрибутов.
А.6 Модель знаний - опорные вектора
В стандарте PMML опорные вектора представлены моделью
SupportVectorMachineModel (Рисунок А.6). В соответствии с этим модель
знаний, представляющая модель опорных векторов, описывается следующим
образом:
mSVM = {e0, e1, e2, e3}, где
e1 – множество опорных векторов:
e1 = <{curr, size, n}, {e1.1, e1.2, …, e1.k, …, e1.g}>, где
e1.k – опорный вектор представляющий собой набор координат в
пространстве измерений по атрибутам входного набора данных:
e1.k = <{v1, v2, …,vj, …,vp}, Ø>, где
v – значение координаты опорного вектора для атрибуту aj ;
e2 – множество машин опорных векторов для каждой категории целевого
атрибута:
e2 = <{curr, size, n}, {e2.1, e1.2, …, e2.r, …, e2.q}>, где
e2.r – машина опорных векторов для категории vt.r целевого атрибута at:
e2.r = <{ vt.r , nvt.r }, Ø>, где
vt.r – категория целевого атрибута для которого выполняется
классификация;
nvt.r – альтернативная категория целевого атрибута;
e3 – множество коэффициентов для опорных векторов:
e3 = <{cf1, cf2, …, cfk, …, cfg}, Ø>.
302
Рисунок А. 6– PMML модель знаний – регрессия.
303
А.7 Кластерные модели знаний
В стандарте PMML кластеры представлены моделью ClusteringModel.
Она позволяет описать несколько типов кластеров (Рисунок А.7): центроидные
(center-based) и распределенные (distribution-based). Кроме того, она позволяет
описать кластеры с помощью карт Кохонена. Все типы представляют модель в
виде множества кластеров, отличие заключается в представлении самого
кластера. Таким образом, формально данные модели можно представить как
множество кластеров:
mC={ e0, e1 }, где
e1 – множество кластеров:
e1 = <{curr, size, n}, {e1.1, e1.2, …, e1.i, …, e1.n}>, где
e1.i – кластер, описываемый в зависимости от типа кластера:
o для центроидного представления кластера в модели записываются
координаты центра кластера:
e1 =<{v1.r,…, vj.q,…, vm.w}, Ø>, где vj.qD(aj) и ajA.
o для распределенного представления кластер в модели знаний
записывается в виде распределения векторов по каждому полю:
e1= <{curr, size, n}, { e1.1, e1.2, …., e1.j, …, e1.w}>, где
e1.j – распределение векторов по атрибуту aj, которое
описывается набором различных значений (количество
векторов, макcимальное, минимальное, среднее значение,
дисперсия и т.п.):
e1.j = <{tfj, mfj, ifj, carj, … , ftj}, Ø>
o для представления кластеров в виде карты Кохонена используются
координаты в 3х измерениях карты Кохонена:
e1 = <{ с1, с2, с3}, Ø>
304
Рисунок А.7 – PMML модель знаний – кластеры.
305
А.8 Модель знаний – ассоциативные правила
В стандарте PMML ассоциативные правила представлены моделью
AssociationModel (Рисунок А.8). В соответствии с ним модель знаний,
представляющая ассоциативны правила, описывается следующим образом
mA = {e0, e1, e2 , e3 }, где
e1 – множество анализируемых элементов входящих в состав транзакций:
e1 = <{curr, size, n}, {e1.1, e1.2, …, e1.i, …, e1.m}>, где
o e1.i – анализируемый элемент транзакции:
e1.i = <{id}, Ø>
e2 – множества частых наборов:
e2 = <{curr, size, n}, {e2.1, e2.2, …, e2.k, …, e2.q}>, где
o e2.k – множество частых k – элементных наборов:
e2.k = <{curr, size, n}, {e2.k.1, e2.k.2, …, e2.k.p, …, e2.k.v}>, где
o e2.k.p – частый k-элементный набор:
e2.k.p= <{id1, id2, …, idk}, Ø>
e3 – множество ассоциативных правил:
e3 = <{curr, size, n}, {e3.1, e3.2, …, e3.i, …, e3.n}>, где
o e3.i – ассоциативное правило:
e3.i = <{ xi, yi }, Ø>, где
xi={ e1.i: e1.i e1.L} – условная часть правила, содержащая
набор элементов e1.i из всего множества элементов e1.L;
yi={ e1.i: e1.i e1.L }) – заключительная часть правила, также содержащая
набор элементов e1.i из всего множества элементов e1.L.
306
Рисунок А.8 – PMML модель знаний – ассоциативные правила.
307
А.9 Модель последовательностей
В стандарте PMML последовательности представлены моделью
SequenceModel (Рисунок А.9). В соответствии с ним модель знаний,
представляющая последовательности, описывается следующим образом:
mS = {e0, e1, e2, e3, e4 }, где
e1 – множество элементов транзакций (аналогично элементу e1 в модели
ассоциативных правил mA);
e2 – множество наборов элементов:
e2 = <{curr, size, n}, {e2.1, e2.2, …, e2.v, …, e2.w}>, где
o e2.v – набор элементов:
e2.w = <{id1, id2, …, idk}, Ø>
e3 – упорядоченное множество наборов элементов:
e3 = <{curr, size, n}, {e3.1, e3.2, …, e3.f, …, e3.e}>, где
o e3.f – набор элементов e1.i e1.L и время его появления t:
e3.f = <{ e1.i, t}, Ø>
e4 –множество ассоциативных правила последовательностей:
e4 = <{curr, size, n}, {e4.1, e4.2, …, e4.x, …, e4.z}>, где
o e4.x – ассоциативное правило последовательности:
e4.x = <{xx, t1, yx, t2 }, Ø>, где
xx – упорядоченное множество последовательностей
являющейся условной частью правила
yx – упорядоченное множество последовательностей
являющейся заключительной частью правила
t1 - время между последовательностями условной и
заключительной частями
t2 – общее время от 1й последовательности условной части до
последней последовательности заключительной части.
308
Рисунок А.9 – PMML модель знаний – последовательности.
309
А.10 Модель знаний - нейронная сеть
В стандарте PMML нейронная сеть представлена моделью NeuralNetwork
(Рисунок А.10). В соответствии с ним модель знаний, представляющая
нейронную сеть, описывается следующим образом:
mnn = {e0, e1, e2 , e3}, где
e1 – множество входных нейронов:
e1 = <{curr, size, n}, {e1.1, e1.2, …, e1.p, …, e1.q}>
o e1.p – входной нейрон, соответствующий атрибуту данных:
o e1.p = <{f(ai)}, Ø};
e2 – множество уровней нейронной сети:
e2 = <{curr, size, n}, {e2.1, e2.2, …, e2.f, …, e2.e}>, где
o e2.f – слой нейронов:
e2.f = <{curr, size, n}, {e2.f.1, e2.f.2, …, e2.f.r, …, e2.f.u}>, где
e2.f.r - нейрон уровня e2.f включает в себя связи с множеством
нейронов предыдущего уровня:
e2.f.r = <{ e2.f-1.1, e2.f-1.2, …, e2.f-1.r, …, e2.f-1.u}, Ø>;
e3 - множество выходных нейронов:
e3 = <{curr, size, n}, {e3.1, e3.2, …, e3.p, …, e3.q}>
310
Рисунок А.10 – PMML модель знаний – нейронная сеть.
Приложение Б. Программная реализация параллельного алгоритма 1R
Б.1 Программная реализация не декомпозированного алгоритма 1R
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
@Override
protected EMiningModel runAlgorithm(MiningInputStream inputData, EMiningModel model) throws MiningException {
try {
buildClassifier( inputData, model);
} catch (Exception e) {
e.printStackTrace();
}
return model;
}
public void buildClassifier(MiningInputStream inputData, EMiningModel model) throws Exception {
target = ((ClassificationFunctionSettings) miningSettings).getTarget();
indexTarget = inputData.getLogicalData().getAttributeIndex( target );
// for each attribute ...
int currentAttr = 0;
while (currentAttr < inputData.getLogicalData().getAttributesNumber()){
ELogicalAttribute attribute = inputData.getLogicalData().getAttribute(currentAttr);
if(currentAttr != indexTarget){
try{
model = newNominalRule(currentAttr, attribute, inputData, model);
// SELECT BEST RULES
if(((RuleSetModel)model).getCandidateCorrectVectors() > ((RuleSetModel)model).getCorrectVectors()){
//fChange = true;
((RuleSetModel)model).setCorrectVectors(((RuleSetModel)model).getCandidateCorrectVectors());
((OneRuleMiningModel)model).selectCandidates();
}
((OneRuleMiningModel)model).cleareRuleCandidates();
((RuleSetModel)model).setCandidateCorrectVectors(0);
} catch (Exception ex) {
ex.printStackTrace();
}
}
312
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
currentAttr++;
}
}
public EMiningModel newNominalRule(int currentAttr, ELogicalAttribute attr, MiningInputStream inputData, EMiningModel model)
throws Exception {
int currentVector = 0;
int cv = inputData.getVectorsNumber();
while (currentVector < cv){
// CALCULATE COUNTS
MiningVector i = ((MiningArrayStream)inputData).getVector(currentVector);
if(i.isMissing(currentAttr)){
((OneRuleMiningModel)model).setMissingValueCount(currentAttr,(int) i.getValue(currentAttr),
((OneRuleMiningModel)model).getMissingValueCount(currentAttr,(int) i.getValue(currentAttr)) + 1);
}
else{
((OneRuleMiningModel)model).counts[currentAttr][(int) i.getValue(currentAttr)][(int) i.getValue(indexTarget)]++;
}
currentVector ++;
}
int sc = attr.getCategoricalProperties().getSize();
for (int value = 0; value < sc; value++) {
// ADD ONE RULE
int maximum = 0;
int maxIndex = 0;
int summ = 0;
int size = ((OneRuleMiningModel)model).counts[currentAttr][value].length;
for (int i = 0; i < size; i++) {
if ((i == 0) || (((OneRuleMiningModel)model).counts[currentAttr][value][i] > maximum)) {
maxIndex = i;
maximum = ((OneRuleMiningModel)model).counts[currentAttr][value][i];
summ =+ maximum;
}
}
SimplePredicate predicate = new SimplePredicate(attr, value, Operator.EQUAL);
SimpleRule r = new SimpleRule(predicate);
r.setNumberOfPredicatedVectors(((OneRuleMiningModel)model).counts[currentAttr][value][maxIndex]);
313
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.
94.
r.setScore(attr.getCategoricalProperties().getValue(maxIndex).toString());
if(summ != 0)
r.setError(1 - ((OneRuleMiningModel)model).counts[currentAttr][value][maxIndex]/summ);
((OneRuleMiningModel)model).addRuleCandidate(r);
((RuleSetModel)model).setCandidateCorrectVectors(((RuleSetModel)model)
.getCandidateCorrectVectors() + ((OneRuleMiningModel)model).counts[currentAttr][value][maxIndex]);
}
return model;
}
public int maxIndex(int[] ints) {
int maximum = 0;
int maxIndex = 0;
for (int i = 0; i < ints.length; i++) {
if ((i == 0) || (ints[i] > maximum)) {
maxIndex = i;
maximum = ints[i];
}
}
return maxIndex;
}
314
Б.2 Программная реализация блока подсчета векторов
public class CalculateVectorsCount extends Step {
private final ELogicalAttribute target;
private final int indexTarget;
public CalculateVectorsCount(EMiningFunctionSettings settings) throws MiningException {
super(settings);
target = ((ClassificationFunctionSettings) settings).getTarget();
indexTarget = ((ClassificationFunctionSettings) settings).getLogicalData().getAttributeIndex( target );
}
@Override
protected EMiningModel execute(MiningInputStream inputData, EMiningModel model) throws MiningException {
return execute(model.getCurentVector(),
model.getCurrentAttribute(),
inputData.getVector(model.getCurentVector()),
(OneRuleMiningModel)model);
}
protected EMiningModel execute(int indexCurrentVector, int indexCurrentAttribute, MiningVector vector,
OneRuleMiningModel model) throws MiningException{
if(vector.isMissing(indexCurrentAttribute)){
model.setMissingValueCount(indexCurrentAttribute,(int) vector.getValue(indexCurrentAttribute),
model.getMissingValueCount(indexCurrentAttribute,(int) vector.getValue(indexCurrentAttribute)) + 1);
}
else{
model.setCount(indexCurrentAttribute, (int)vector.getValue(indexCurrentAttribute),
(int)vector.getValue(indexTarget),
model.getCount(indexCurrentAttribute, (int) vector.getValue(indexCurrentAttribute),
(int)vector.getValue(indexTarget)) + 1);
}
return model;
}
}
315
Б.3 Программная реализация блока добавления нового правила
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
public class AddingOneRule extends Step {
private final ELogicalAttribute target;
private final int indexTarget;
public AddingOneRule(EMiningFunctionSettings settings) throws MiningException {
super(settings);
target = ((ClassificationFunctionSettings) settings).getTarget();
indexTarget = ((ClassificationFunctionSettings) settings).getLogicalData().getAttributeIndex( target );
}
@Override
protected EMiningModel execute(MiningInputStream inputData, EMiningModel model) throws MiningException {
int indexCurrentAttribute = model.getCurrentAttribute();
ELogicalAttribute attribute = inputData.getLogicalData().getAttribute(indexCurrentAttribute);
int indexValue = model.getCurrentAttributeValue();
return execute(indexCurrentAttribute,
indexValue,
attribute,
(OneRuleMiningModel)model);
}
protected EMiningModel execute(int indexCurrentAttribute, int indexValue, ELogicalAttribute attribute,
OneRuleMiningModel model) throws MiningException {
int maximum = 0;
int maxIndex = 0;
int summ = 0;
int size = target.getCategoricalProperties().getSize();
for (int i = 0; i < size; i++) {
if ((i == 0) || (model.getCount(indexCurrentAttribute, indexValue, i) > maximum)) {
maxIndex = i;
maximum = model.getCount(indexCurrentAttribute, indexValue, i);
}
summ += model.getCount(indexCurrentAttribute, indexValue, i);
}
316
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
SimplePredicate predicate = new SimplePredicate(attribute, indexValue, Operator.EQUAL);
SimpleRule r = new SimpleRule(predicate);
r.setNumberOfPredicatedVectors(model.getCount(indexCurrentAttribute, indexValue, maxIndex));
r.setScore(target.getCategoricalProperties().getValue(maxIndex).toString());
if(summ > 0)
r.setError(1 - model.getCount(indexCurrentAttribute, indexValue, maxIndex)/summ);
model.addRuleCandidate(r);
model.setCandidateCorrectVectors(model.getCandidateCorrectVectors()
+ model.getCount(indexCurrentAttribute, indexValue, maxIndex));
return model;
}
}
317
Б.4 Программная реализация блока выбора лучшего правила
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
public class SelectTheBestRule extends Step {
public SelectTheBestRule(EMiningFunctionSettings settings) throws MiningException {
super(settings);
}
@Override
protected EMiningModel execute(MiningInputStream inputData, EMiningModel model) throws MiningException {
return execute((OneRuleMiningModel) model);
}
protected EMiningModel execute(OneRuleMiningModel model) throws MiningException {
if(model.getCandidateCorrectVectors() > model.getCorrectVectors()){
model.setCorrectVectors(model.getCandidateCorrectVectors());
model.selectCandidates();
}
model.cleareRuleCandidates();
model.setCandidateCorrectVectors(0);
return model;
}
}
318
Б.5 Программная реализация декомпозированного алгоритма 1R
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
@Override
protected void initSteps() throws MiningException {
VectorsCycleStep vectorsCycleStep = new VectorsCycleStep(miningSettings,
new CalculateVectorsCount(miningSettings));
CurrentAttributeValuesCycleStep currentAttributeValuesCycleStep =
new CurrentAttributeValuesCycleStep(miningSettings,
new AddingOneRule(miningSettings));
IfCurrentAttributNotTarget ifCurrentAttributNotTarget = new IfCurrentAttributNotTarget(miningSettings,
vectorsCycleStep,
currentAttributeValuesCycleStep,
new SelectTheBestRule(miningSettings));
AttributesCycleStep attributesCycleStep = new AttributesCycleStep(miningSettings, ifCurrentAttributNotTarget);
steps = new StepSequence(miningSettings, attributesCycleStep);
steps.addListenerExecute(new StepExecuteTimingListner());
}
319
Б.6 Программная реализация алгоритма 1R распараллеленного по векторам
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
@Override
protected void initSteps() throws MiningException {
VectorsCycleStep vectorsCycleStep = new VectorsCycleStep(miningSettings,
new CalculateVectorsCount(miningSettings));
ParallelByData vectorCycleParallel = new ParallelByData( miningSettings, vectorsCycleStep);
CurrentAttributeValuesCycleStep currentAttributeValuesCycleStep =
new CurrentAttributeValuesCycleStep(miningSettings,
new AddingOneRule(miningSettings));
IfCurrentAttributNotTarget ifCurrentAttributNotTarget =
new IfCurrentAttributNotTarget(miningSettings,
vectorCycleParallel,
currentAttributeValuesCycleStep,
new SelectTheBestRule(miningSettings));
AttributesCycleStep attributesCycleStep =
new AttributesCycleStep(miningSettings, ifCurrentAttributNotTarget);
steps = new StepSequence(miningSettings, attributesCycleStep);
steps.addListenerExecute(new StepExecuteTimingListner());
}
320
Б.7 Программная реализация алгоритма 1R распараллеленного по атрибутам
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
@Override
protected void initSteps() throws MiningException {
VectorsCycleStep vectorsCycleStep = new VectorsCycleStep(miningSettings,
new CalculateVectorsCount(miningSettings));
ParallelByData vectorCycleParallel = new ParallelByData( miningSettings, vectorsCycleStep);
CurrentAttributeValuesCycleStep currentAttributeValuesCycleStep =
new CurrentAttributeValuesCycleStep(miningSettings,
new AddingOneRule(miningSettings));
IfCurrentAttributNotTarget ifCurrentAttributNotTarget =
new IfCurrentAttributNotTarget(miningSettings,
vectorsCycleStep, //vectorCycleParallel,
currentAttributeValuesCycleStep,
new SelectTheBestRule(miningSettings));
AttributesCycleStep attributesCycleStep = new AttributesCycleStep(miningSettings, ifCurrentAttributNotTarget);
ParallelByData attributesCycleParallel = new ParallelByData( miningSettings, attributesCycleStep);
steps = new StepSequence(miningSettings, attributesCycleParallel);
steps.addListenerExecute(new StepExecuteTimingListner());
}
321
Б.8 Программная реализация теста для алгоритма 1R
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
public class OneRuleAlgorithmTest extends RuleSetModelTest {
protected MiningAlgorithm algorithm;
protected EMiningAlgorithmSettings algorithmSettings;
@Before
public void setUp() throws Exception {
// Create and tuning algorithm settings
algorithmSettings = new EMiningAlgorithmSettings();
algorithmSettings.setName(OneRuleAlgorithm.class.getSimpleName());
algorithmSettings.setClassname(OneRuleAlgorithm.class.getName());
algorithmSettings.setAlgorithm("1R");
}
@Test
public void test4WeatherNominal() {
try {
setInputData4WeatherNominal();
setMiningSettings4WeatherNominal(algorithmSettings);
algorithm = new OneRuleAlgorithm(miningSettings);
model = (RuleSetModel) algorithm.buildModel(inputData);
System.out.println("calculation time [s]: " + (double)algorithm.getTimeSpentToBuildModel()); ///1000000.0
verifyModel4WeatherNominal();
} catch (MiningException e) {
// TODO Auto-generated catch block
e.printStackTrace();
fail();
}
}
}
322
Б.9 Программная реализация теста для выполнения эксперимента алгоритма 1R
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
public class OneRRulesCycleParallelAlgorithmLoadTest extends ClassificationLoadlTest {
private final int NUMBER_HANDLERS = 2;
protected MiningAlgorithm algorithm;
@Test
public void test1R(){
ExecutionSettings executionSettings = new ExecutionSettings();
executionSettings.setNumberHandlers(NUMBER_HANDLERS);
executionSettings.setMemoryType(MemoryType.shared);
MultiThreadedExecutionEnvironment environment;
try {
environment = new MultiThreadedExecutionEnvironment(executionSettings);
System.out.println("----- 1RRulesCycleParallelAlgorithm -------");
for(int i=0; i < dataSets.length; i++){
setSettings(i);
miningSettings.setAlgorithmSettings(new EMiningAlgorithmSettings());
miningSettings.getAlgorithmSettings().setDataSplitType(DataSplitType.block);
miningSettings.getAlgorithmSettings().setDataProcessingStrategy(DataProcessingStrategy.SingleDataSet);
miningSettings.getAlgorithmSettings().setModelProcessingStrategy(MiningModelProcessingStrategy.SeparatedMiningModel);
algorithm = new OneRuleAttributesCycleParallelAlgorithm(miningSettings);
EMiningBuildTask buildTask = new EMiningBuildTask();
buildTask.setInputStream(inputData);
buildTask.setMiningAlgorithm(algorithm);
buildTask.setMiningSettings(miningSettings);
buildTask.setExecutionEnvironment(environment);
System.out.println("Start algorithm");
miningModel = (ClassificationMiningModel) buildTask.execute();
System.out.println("Finish algorithm");
verifyModel();
}
} catch (MiningException e) {
e.printStackTrace();
fail();
}
}
}
Приложение В. Примеры алгоритмов анализы данных.
В.1. Алгоритм классификации Naïve Bayes
В 1.1 Описание алгоритма Naïve Bayes
Алгоритм классификации Naive Bayes строит модель знаний на
основании нескольких независимых переменных. Он использует формулу
Байеса для расчета условной вероятности ).( rcyP того, что некоторый объект
ji относится к классу rc (т. е. rcy ):
).(/)()|()|( EPcyPcyEPEcyP rrr
где E событие, соответствующее равенству независимых переменных
определенным значениям, а )(EP - вероятность его наступления
В результате формируются правила, в условных частях которых
сравниваются все независимые переменные с соответствующими возможными
значениями. В заключительной части присутствуют все возможные значения
зависимой переменной:
если 1
1 pcx и 2
2 dcx и ... mbm cx , тогда rcy .
Для каждого из этих правил по формуле Байеса определяется его
вероятность. Псевдокод алгоритма Naïve Bayes представлен ниже:
Название naive (наивный) происходит от наивного предположения, что все
рассматриваемые переменные независимы друг от друга. В действительности
это не всегда так, но на практике данный алгоритм находит применение.
1. for j = 1 … z // цикл по векторам
2. //инкрементация количества векторов со значением xj.t;
tcount[ xj.t ]++;
3. for k = 1 ...p // цикл по атрибутам
4. //инкрементация количества векторов со значениями xj.k и xj.t;
count[k, xj.k, xj.t]++;
5. c;
6. end for;
324
В.1.2 Модель Naïve Bayes
Спецификация PMML представляет модель знаний для Naïve Bayes
алгоритма как NaïveBayesModel модель. Она содержит два списка:
BayesOutput – набор пар <value, count>, где
o value значение vt.p зависимого атрибута at (vt.p Deft),
o count – количество векторов со значениями xj.t = vt.p зависимого атрибута;
BayesInputs – набор пар <value, count> для каждого значения vk.q (атрибут value
тэга PairCounts) независимого атрибута ak (атрибут fieldName тэга
BayesInput) и здесь count количество векторов со значениями xj.k = vk.q
независимого атрибута ak и со значением xj.t = vt.p зависимого атрибута at.
Массив деревьев решений модели знаний для алгоритма Naïve Bayes
(инициализируется функцией f0) расширяется следующими элементами:
m[1] дерево, содержащие информацию о количестве векторов m[1,p] для
каждого значением xj.t = vt.p зависимого атрибута at (соответствует парам
BayesOutputs модели NaïveBayesModel);
m[2] дерево, содержащие информацию о количестве векторов m[2,k,q,p] для
каждого значения xj.k = vk.q каждого независимого атрибута ak и каждого
значения xj.t = vt.p зависимого атрибута at (соответствует парам BayesIntputs
модели NaïveBayesModel).
Подробнее модель для алгоритма Naïve Base описана в приложении
разделе А.1.2. С применением описанного представления модели знаний для
алгоритма Naïve Bayes псевдокод алгоритма будет иметь вид представленный
ниже:
1. For j = 1 … z // цикл по векторам
2. //инкрементация количества векторов со значением xj.t;
m[1,d[j,t]] ++;
3. For k = 1 ...p // цикл по атрибутам
4. //инкрементация количества векторов со значениями xj.k и xj.t;
m[2,k, d[j,k], d[j,t]] ++;
5. end for;
6. end for;
325
В.1.3 Представление алгоритма Naïve Bayes в виде композиции функций
обработки модели знаний
В соответствии с предложенным подходом алгоритм Naïve Bayes
представлен как композиция следующих ФОМ:
fd1 цикл по векторам с d[1] по d[z] (срока 1 псевдокода):
f1 = loopd d[1] d[z] f3f2;
fd2 инкрементирует количество значение векторов m[1,d[j,t]].count со
значением vt.p зависимого t-th атрибута (срока 2 псевдокода);
fd3 цикл по метаданным с m[0,1] по m[0,p] (срока 3 псевдокода):
f3 = loope m[0,1] m[0,p] f4;
fd4 инкрементирует количество векторов m[2, k, d[j,k], d[j,t]].count со
значением vk.q независимого k-th атрибута и со значением vt.p зависимого
t-th атрибута (срока 4 псевдокода).
Таким образом, мы можем представить Naïve Bayes алгоритм как композицию
функций:
NB = fd1f0 = (loopd d[0] d[z] fd3fd2)f0 =
(loopd d[0] d[z] (loope m[0,1] m[0,p] fd4)fd2)f0
Дерево вложенности алгоритма Naïve Bayes изображено на рисунке В.1.
326
Рисунок В.1 – Дерево вложенности алгоритма Naïve Bayes.
В.1.4 Проверка условий параллельного выполнения функций алгоритма
Naïve Bayes
Множества используемых и изменяемых элементов, полученные на
основании псевдокода, представлены в таблице В.1.
Таблица В.1. Множества In и Out для FMBs алгоритма Naïve Bayes
ФОМ In Out
f0 d m[0], m[1], m[2]
f1 d, m[1], m[2] m[1], m[2]
f2 d[j,t], m[1,p’] m[1,p’]
f3 d, m[2] m[2]
f4 d[j,k], d[j,t], m[2,k,q’,p’] m[2,k,q’,p’]
Для алгоритма Naïve Bayes возможности распараллеливания по задачам для
каждого уровня композиции будет следующая:
функции f0 и fd1 не могут выполняться параллельно, т.к. имеют
потоковую зависимость по элементам модели знаний m[1] и m[2]:
Out(f0) In(fd1)= {m[1], m[2]} ≠ ;
над которыми в них выполняются не ассоциативные по отношению друг
другу операции добавления и инкрементации;
функции fd2 и fd3 могут выполняться параллельно, т.к.:
f0
run[f0, fd1]
loopd d[0] d[z] fd3fd2
loope m[0,1] m[0,p] fd4 fd2
fd
4
327
o не имеют потоковой зависимости: Out(fd2) In(fd3) = ;
o не имеют антизависимости: In(fd2) Out(fd3) = ;
o не имеет зависимости по выходу: Out(fd2) Out(fd3) = .
Возможности распараллеливания по данным для каждого цикла будут
следующие:
композиция функций fd3fd2 для разных итераций j и j+1 может быть
распараллелена по данным, т.к.:
o существует потоковая зависимость и антизависимость по элементам
модели знаний m[1,p’], m[2,k,p’,q’]:
Out (fd3fd2 для j) In (fd3fd2 для j+1) =
{d[j,k], d[j,t], m[1,p’], m[2,k,p’,q’]} {m[1,p’], m[2,k,p’,q’]}=
{ m[1,p’], m[2,k,p’,q’]} ≠
In (fd3fd2 для j) Out (fd3fd2 для j+1) =
{ m[1,p’], m[2,k,p’,q’]} {d[j+1,k], d[j+1,t], m[1,p’], m[2,k,p’,q’]}=
{ m[1,p’], m[2,k,p’,q’]} ≠
над которым выполняется ассоциативная операция инкрементации;
o имеется зависимость по выходу по элементам модели знаний m[1,p’] и
m[2,k,p’,q’]:
Out (fd3fd2 для j) Out (fd3fd2 для j +1) =
{ m[1,p’], m[2,k,p’,q’]} { m[1,p’], m[2,k,p’,q’]} =
{ m[1,p’], m[2,k,p’,q’]} ≠ ;
над которым выполняется ассоциативная операция инкрементации и
для которого существует операции агрегирования - суммирование;
функция fd3 для разных итераций k и k+1 может быть распараллелена по
данным, т.к.:
o нет потоковой зависимости:
Out (fd3 для k) In (fd3 для k+1) =
{ m[2,k,q’,p’]} { d[j,k+1], d[j,t], m[2,k+1,q’,p’]} = ;
328
o нет антизависимости:
In (fd3 для k) Out (fd3 для k+1) =
{ d[j,k], d[j,t], m[1,p’], m[2,k,p’,q’]} { m[2,k+1,q’,p’]} = ;
o нет зависимости по выходу:
Out (fd3 для k) Out (fd3 для k+1) = {m[2,k,q’,p’]} {m[2,k+1,q’,p’]} = .
В.1.5 Параллельные формы алгоритма Naïve Bayes
С учетом возможностей параллельного выполнения ФОМ алгоритма
Naïve Bayes его распараллеливание может быть выполнено следующим
образом:
NBParAll = (parallels [loopd d[0] d[z] (
parallels [fd2,(parallels [loope m[0,1] m[0,p] fd4])]
)])f0.
Дерево вложенности параллельного алгоритма Naïve Bayes изображено
на рисунке В.2.
Рисунок В.2. – Дерево вложенности параллельного алгоритма Naïve Bayes.
f0
run[f0, fd1]
loopd d[0] d[z] fd3fd2
loope m[0,1] m[0,p] fd4
fd2
fd4
parallels
parallels
parallels
329
В.2 Алгоритм кластеризации kMeans
В.2.1 Описание алгоритма kMeans
Алгоритм кластеризации kMeans разбивает множество векторов, из
входного набора данных d, на заданное c число кластеров, основываясь на мере
расстояния от вектора до центра кластера. При этом на начальном шаге центры
кластеров могут задаваться произвольно: случайным образом, выбором первых
векторов и т.п. Далее для каждого вектора определяется ближайший кластер и
на этом основании определяется его принадлежность. После перераспределения
всех векторов высчитываются новые центры кластеров, как центры масс и
процесс перераспределения повторяется. Процесс повторяется до тех пор, пока
меняются центры кластеров.
Псевдокод алгоритма kMeans представлен ниже:
1. for i=1 to c // для каждого кластера
2. for k=1 to p // для каждого атрибута
3. ci.k = random() // добавить i-й кластер со случайным центром
4. end for;
5. end for;
6. while CentroidsChanged==true
7. for j=1 to z // для каждого вектора
8. for i=1 to c // для каждого кластера
9. for k=1 to p // для каждого атрибута вектора
10. r[k] = dist(xj.k, ci.k) //найти расстояние между вектором xj и
// центром i-го кластера по k-й координате
11. end for
12. d = dist(r)// расстояние между вектором xj и центром i-го кластера
13. if (d<dmin ) // если расстояние меньше предыдущего то
14. dmin = d; // запомнить меньшее расстояние
15. imin = i; // и ближайщий кластер
16. end if
17. end for;
18. mass[imin] += dmin; // увеличить массу кластера
19. count[imin]++; // инкрементировать число векторов в кластере
20. end for;
21. for i=1 to c // для каждого кластера
22. // вычислить центр масс кластера
for k=1 to p // для каждого атрибута
23. ci.k = mass[i, k] / count[i];
24. end for
25. end for;
26. end while;
330
В.2.2 Модель для алгоритма kMeans
Алгоритм kMeans относится к центроидным алгоритмам кластеризации,
задавая кластеры их центрами. В связи с этим модель знаний, строящаяся
алгоритмом kMeans, представляет собой множество кластеров, заданных
координатами их центров.
Таким образом, для алгоритма kMeans модель знаний должна быть
расширена:
m[1] - дерево, содержащее информацию о кластере m[1, i], где
o m[1].cc – флаг изменения центров кластеров;
o m[1, i, k].v – k-я координата центра кластера;
o m[1, i].n – количество векторов отнесенных к данному кластеру.
m[2] - дерево, содержащее информацию о принадлежности каждого j-го
вектора i-му кластеру m[2,j].i, где
o m[2, j].i – индекс кластера к которому относится вектор;
o m[2, j].d – расстояние между вектором и центром кластера к которому
относится вектор;
o m[2, j, i].d - расстояние между j-м вектором и центром i-го кластера
Таким образом, псевдокод алгоритма kMeans изменится, так как это
представлено ниже:
331
1. for i=1 to c // для каждого кластера
2. for k=1 to p // для каждого атрибута
3. m[1, i, k] = random() // добавить i-й кластер со случайным центром
4. end for;
5. end for;
6. while m[1].cc ==false
7. for j=1 to z // для каждого вектора
8. for i=1 to c // для каждого кластера
9. for k=1 to p // для каждого атрибута вектора
10. r=|d[j,k]-m[1,i,k].v| // расстояние между вектором j и центром
11. m[2,j,i].d+=r*r // i-го кластера по k-й координате
12. end for
13. //найти расстояние между вектором xj и центром i-го кластера
m[2,j, i].d = sqrt(m[2,j,i]].d)
14. if (m[2,j,i].d<m[2,j].d) //если расстояние меньше предыдущего то
15. m[2,j].i=i; // и ближайший кластер
16. m[2,j].d= m[2,j,i].d
17. end if
18. end for;
19. for k=1 to p
20. // суммировать длину k-й координаты кластера
m[1, m[2,j].i, k].m += d[j,k];
21. end for
22. m[1, m[2,j].i].n ++; // инкрементировать число векторов в кластере
23. end for;
24. for i=1 to c // для каждого кластера
25. // вычислить центр масс кластера
for k=1 to p // для каждого атрибута
26. kold = m[1, i, k].v;
27. m[1, i, k].v = m[1, i, k].m / m[1, i].n // вычислить центр по k-й координате
28. m[1].cc &= | kold - m[1, i, k].v| > eps;
29. end for
30. end for;
31. end while;
В.2.3 Представление алгоритма kMeans в виде композиции функций обработки
модели знаний
В соответствии с предложенным подходом алгоритм kMeans представлен
как композиция следующих ФОМ:
f1 цикл по кластерам с m[1,1] по m[1,c] (срока 1):
332
f1 = loope m[1,1] m[1,c] f2;
f2 цикл по атрибутам с m[0,1] по m[0,p] (срока 2):
f2 = loope m[0,1] m[0,p] f3;
f3 вычисление значения k-й координаты генератором случайных чисел (срока
3);
f6 цикл пока изменяются центры кластеров (срока 6):
f6 = loop (m[1].cc==true) finit fafter f24f7, где
o finit инициализирует цикл функцией:
finit = (m[1].cc =true);
o fafter выполняет вычисление после каждой итерации:
fafter = (m[1].cc ==true);
fd7 цикл по векторам с d[0] по d[z] (срока 7):
fd7 = loopd d[0] d[z] f22fd19fd8;
f8 цикл по кластерам с m[1,1] по m[1,c] (срока 8):
fd8 = loope m[1,1] m[1,c] f14f13fd9;
f9 цикл по атрибутам с m[0,1] по m[0,p] (срока 9):
fd9 = loope m[0,1] m[0,p] fd10;
fd10 вычисление расстояния между j-м вектором и центром i-го кластера по k-
й координате (сроки 10-11);
f13 вычисление общего расстояния между j-м вектором и центром i-го
кластера (сроки 13);
f14 выбор наименьшего расстояние от j-го вектора до центров i-го кластера и
ранее найденного (сроки 14-17);
f19 цикл по атрибутам с m[0,1] по m[0,p] (срока 18):
fd19 = loope m[0,1] m[0,p] fd20;
333
fd20 вычислить сумму длин k-й координаты кластера (сроки 20);
f22 инкрементировать число векторов в кластере (сроки 22);
f24 цикл по кластерам с m[1,1] по m[1,c] (срока 24):
f24 = loope m[1,1] m[1,c] f25;
f25 цикл по атрибутам с m[0,1] по m[0,p] (срока 25):
f25 = loope m[0,1] m[0,p] f26;
f26 вычислить центр по k-й координате (сроки 26)
Таким образом, мы можем представить kMeans алгоритм как композицию
функций:
kMeans = f6f1f0 =
(loop (m[1].cc==true) finit fafter f24fd7)
(loope m[1,1] m[1,c] f2)f0 =
(loop (m[1].cc==true) finit fafter
(loope m[1,1] m[1,c] f25)
(loopd d[0] d[z] f22fd19fd8)) (loope m[1,1] m[1,c]
(loope m[0,1] m[0,p] f3))f0 =
(loop (m[1].cc==true) finit fafter (loope m[1,1] m[1,c]
loope m[0,1] m[0,p] f26)
(loopd d[0] d[z] f22
(loope m[0,1] m[0,p] fd20)
(loope m[1,1] m[1,c] f14f13fd9))) (loope m[1,1] m[1,c]
(loope m[0,1] m[0,p] f3))f0 =
(loop (m[1].cc==true) finit fafter (loope m[1,1] m[1,c]
loope m[0,1] m[0,p] f26)
(loopd d[0] d[z] f22
(loope m[0,1] m[0,p] fd20)
(loope m[1,1] m[1,c] f14f13
(loope m[0,1] m[0,p] fd10)))) (loope m[1,1] m[1,c]
(loope m[0,1] m[0,p] f3))f0 =
334
Дерево вложенности алгоритма kMeans изображена на рисунке В.3.
Рисунок В.3 – Дерево вложености алгоритма kMeans.
В.2.4 Проверка условий параллельного выполнения функций алгоритма kMeans
Множества используемых и изменяемых элементов, полученные на
основании псевдокода, представлены в таблице В.2.
Для алгоритма kMeans возможности распараллеливания по задачам для
каждого уровня композиции будут следующие:
функции f0 и f1 не могут выполняться параллельно, т.к. имеют потоковую
зависимость по элементу модели знаний m[1]:
Out(fd0) In(f1)= {m[1]} ≠ ;
над которым в них выполняются не ассоциативные по отношению друг другу
операции добавления и извлечения;
функции f1 и fd6 не могут выполняться параллельно, т.к. имеют
потоковую зависимость по элементам модели знаний m[1,1,1].v,…,
m[1,c,p].v:
Out(f1) In(fd6)= { m[1,1,1].v,…, m[1,c,p].v:} ≠ ;
над которыми в них выполняются не ассоциативные по отношению друг
другу операции инициализации и извлечения;
f0
run[f0, f1, fd6]
loope m[1,1] m[1,c] f2
loope m[0,1] m[0,p]
loope m[1,1] m[1,c] f3
fd20
loope m[0,1] m[0,p]
f13
fd10
f26 f14
loop (m[1].cc==true) finit fafter f24fd7
loopd d[0] d[z] f22f19fd8 loope m[1,1] m[1,c] f25
loope m[0,1] m[0,p]
loope m[0,1] m[0,p]
f22
335
Таблица В.2. Множества In и Out для FMBs алгоритма kMeans
ФОМ In Out
fd0 d m[0], m[1], m[2]
f1 m[1,1],…, m[1,c]. m[1,1,1].v,…, m[1,c,p].v
f2 m[1,i,1],…, m[1,i,p] m[1,i,1].v,…, m[1,i,p].v,
f3 m[1, i, k] m[1, i, k].v
fd6 d, m[1].cc, m[1, 1].n, …,m[1, c].n m[1, 1, 1].d, …, m[1, c, p].d,
m[1,1,1].v,…, m[1,c,p].v, m[2,1].i, …, m[2,z].i,
m[2,1,1].d, …, m[2,z,c].d m[2,1,1,1].v,…, m[2,z,c,p].v
m[1].cc, m[1, 1].n, …,m[1, c].n m[1, 1, 1].d, …, m[1, c, p].d m[1, 1, 1].v,…, m[1, c, p].v
m[2,1].i, …, m[2,z].i, m[2,1,1].d, …, m[2,z,c].d
m[2,1,1,1].v,…, m[2,z,c,p].v
fd7 d, m[1, 1].n, …,m[1, c].n m[1, 1, 1].d, …, m[1, c, p].d,
m[1,1,1].v,…, m[1,c,p].v, m[2,1].i, …, m[2,z].i,
m[2,1,1].d, …, m[2,z,c].d m[2,1,1,1].v,…, m[2,z,c,p].v
m[1, 1].n, …,m[1, c].n m[1, 1, 1].d, …, m[1, c, p].d
m[2,1].i, …, m[2,z].i,
m[2,1,1].d, …, m[2,z,c].d m[2,1,1,1].v,…, m[2,z,c,p].v
fd8 d[j], m[2,j].i, m[1,1,1].v,…, m[1,c,p].v, m[2,j,1].d, …, m[2,j,c].d
m[2,j,1,1].v,…, m[2,j,c,p].v
m[2,j].i m[2,j,1].d, …, m[2,j,c].d
m[2,j,1,1].v,…, m[2,j,c,p].v
fd9 d[j], m[2,j,i].d, m[1,i,1].v,…, m[1,i,p].v, m[2,j,i,1].v,…, m[2,j,i,p].v
m[2,j,i].d m[2,j,i,1].v,…, m[2,j,i,p].v
fd10 d[j,k], m[1,i,k].v, m[2,j,i].d, m[2,j,i,k].v m[2,j,i,k].v, m[2,j,i].d
f13 m[2,j, i].d m[2, j, i].d
f14 m[2,j,i'].d, m[2,j,i].d, m[2,j].i m[2,j].i
fd19 m[2,j].i, m[1, i', 1].d, …, m[1, i', p].d, m[1, i', 1].v, …, m[1, i', p].v
m[1, i', 1].d, …, m[1, i', p].d
fd20 m[2,j].i, m[1,i',k].d, d[j,k] m[1, i', k].d
f22 m[2,j].i, m[1, i'].n m[1, i'].n
f24 m[1].cc, m[1, 1, 1].d,…, m[1, c, p].d, m[1, 1, 1].v,…, m[1, c, p].v,
m[1, 1].n, …, m[1, c].n,
m[1].cc m[1, 1, 1].v,…, m[1, c, p].v,
m[1, 1].n, …, m[1, c].n,
f25 m[1].cc, m[1, i, 1].d,…, m[1, i, p].d, m[1, i, 1].v,…, m[1, i, p].v,
m[1, i].n,
m[1].cc, m[1, i, 1].v,…, m[1, i, p].v,
f26 m[1, i, k].v, m[1, i, k].d, m[1, i].n, m[1].cc m[1, i, k].v, m[1].cc
336
функции fd7 и f24 не могут выполняться параллельно, т.к. имеют
потоковую зависимость по элементам модели знаний m[1,1].n,…,m[1,c].n
и m[1,1,1].d,…,m[1,c,p].d:
Out(fd7)In(f24)={m[1,1].n,…,m[1,c].n, m[1,1,1].d,…,m[1,c,p].d}≠;
над которыми в них выполняются не ассоциативные по отношению друг
другу операции вычисления и извлечения;
функции fd8 и f19 не могут выполняться параллельно, т.к. имеют
потоковую зависимость по элементу модели знаний m[2,j].i:
Out(fd8)In(f19)={m[2,j].i}≠;
над которым в них выполняются не ассоциативные по отношению друг
другу операции вычисления (поиска) и извлечения.
функции f19 и f22 могут выполняться параллельно, т.к.:
o не имеют потоковой зависимости: Out(f19) In(f22) = ;
o не имеют антизависимости: In(f19) Out(f22) = ;
o не имеет зависимости по выходу: Out(f19) Out(f22) = .
функции fd9 и f13 не могут выполняться параллельно, т.к. имеют
потоковую зависимость по элементу модели знаний m[2,j,i].d:
Out(fd9)In(f13)={m[2,j,i].d}≠;
над которым в них выполняются не ассоциативные по отношению друг
другу операции вычисления и извлечения.
функции fd13 и f14 не могут выполняться параллельно, т.к. имеют
потоковую зависимость по элементу модели знаний m[2, j, i].d:
Out(f13)In(f14)={ m[2, j, i].d }≠;
над которым в них выполняются не ассоциативные по отношению друг
другу операции вычисления и сравнения.
Возможности распараллеливания по данным для каждого цикла будут
следующие:
в цикле f1 ФОМ f2 для разных итераций i и i+1 может быть
распараллелена по данным, т.к.:
337
o нет потоковой зависимости:
Out (f2 для i) In (f2 для i+1) =
{ m[1,i,1].v,…, m[1,i,p].v } { m[1,i+1,1],…, m[1,i+1,p]} = ;
o нет антизависимости:
In (f2 для i) Out (f2 для i+1) =
{ m[1,i,1],…, m[1,i,p]} { m[1,i+1,1].v,…, m[1,i+1,p].v } = ;
o нет зависимости по выходу:
Out (f2 для i) Out (f2 для i+1) =
{ m[1,i,1].v,…, m[1,i,p].v } { m[1,i+1,1].v,…, m[1,i+1,p].v } = .
в цикле f2 ФОМ f3 для разных итераций k и k+1 может быть
распараллелена по данным, т.к.:
o нет потоковой зависимости:
Out (f3 для k) In (f3 для k+1) =
{ m[1, i, k].v } { m[1, i, k+1]} = ;
o нет антизависимости:
In (f3 для k) Out (f3 для k+1) =
{ m[1, i, k]} { m[1, i, k+1].v } = ;
o нет зависимости по выходу:
Out (f3 для k) Out (f3 для k+1) =
{m[1, i, k].v} {m[1, i, k+1].v} = .
в цикле fd6 композиция ФОМ f24fd7 для разных итераций не может быть
распараллелена по данным, т.к. существует потоковая зависимость по
всем изменяемым элементам модели знаний Out(fd6) над которыми
выполняются не ассоциативные операции;
в цикле fd7 композиция ФОМ f22f19f8 для разных итераций j и j+1 может
быть распараллелена по данным, т.к.:
o существует потоковая зависимость, антизависимость и зависимость по
элементам модели знаний m[1,i'].n, m[1,i',1].d,…,m[1,i',p].d:
338
Out (f22f19f8 для j) In (f22f19f8для j+1) =
{m[1,i'].n, m[1,i',1].d,…,m[1,i',p].d, m[2,j].i, m[2,j,1].d,…,m[2,j,c].d,
m[2,j,1,1].v,…,m[2,j,c,p].v}
{d[j+1], m[1,i'].n, m[1,i',1].d,…,m[1,i',p].d, m[1,1,1].v,…, m[1,c,p].v,
m[2,j+1].i, m[2,j+1].d, m[2,j+1,1].d,…,m[2,j+1,c].d,
m[2,j+1,1,1].v,…,m[2,j+1,c,p].v}=
{m[1,i'].n, m[1,i',1].d,…,m[1,i',p].d} ≠
In (f22f19f8 для j) Out (f22f19f8 для j+1) =
{d[j], m[1,i'].n, m[1,i',1].d,…,m[1,i',p].d, m[1,1,1].v,…, m[1,c,p].v, m[2,j].i,
m[2,j,1].d,…,m[2,j,c].d, m[2,j,1,1].v,…,m[2,j,c,p].v}
{m[1,i'].n, m[1,i',1].d,…,m[1,i',p].d, m[2,j+1].d, m[2,j+1].i,
m[2,j+1,1].d,…,m[2,j+1,c].d, m[2,j+1,1,1].v,…,m[2,j+1,c,p].v} =
{m[1,i'].n, m[1,i',1].d,…,m[1,i',p].d} ≠
Out (f22f19f8 для j) Out (f22f19f8 для j +1) =
{m[1,i'].n, m[1,i',1].d,…,m[1,i',p].d, m[2,j].i, m[2,j,1].d,…,m[2,j,c].d,
m[2,j,1,1].v,…,m[2,j,c,p].}
{ m[1,i'].n, m[1,i',1].d,…,m[1,i',p].d, m[2,j+1].d, m[2,j+1].i,
m[2,j+1,1].d,…,m[2,j+1,c].d, m[2,j+1,1,1].v,…,m[2,j+1,c,p].} =
{ m[1,i'].n, m[1,i',1].d,…,m[1,i',p].d } ≠ ;
над которыми выполняются ассоциативные операции: инкрементации
(над m[1,i'].n) и суммирования (над m[1,i',1].d,…,m[1,i',p].d) и для которых
существуют операции агрегирования - суммирование;
в цикле fd8 композиция ФОМ f14f13fd9 для разных итераций i и i+1
может быть распараллелена по данным, т.к.:
o существует потоковая зависимость и антизависимость по параметру
элемента модели знаний m[2,j].i:
Out(f14f13fd9 для i) In(f14f13fd9 для i+1) =
{m[2,j,i].d, m[2,j,i,1].v,…,m[2,j,i,p].v, m[2,j].i}
339
{d[j], m[2,j,i+1].d, m[1,i+1,1].v,…,m[1,i+1,p].v,
m[2,j,i+1,1].v,…,m[2,j,i+1,p].v, m[2,j].i} = {m[2,j].i} ≠
In (f14f13fd9 для i) Out (f14f13fd9 для i+1) =
{d[j],m[2,j,i].d,m[1,i,1].v,…,m[1,i,p].v,m[2,j,i,1].v,…,m[2,j,i,p].v,m[2,j].i}
{m[2,j,i+1].d, m[2,j,i+1,1].v,…,m[2,j,i+1,p].v, m[2,j].i} =
{m[2,j].i} ≠
над которым выполняет ассоциативная операция - выбор минимального;
o существует зависимость по выходу по параметру элемента модели
знаний m[2,j].i:
In (f14f13fd9 для i) Out (f14f13fd9 для i+1) =
{ m[2,j,i].d, m[2,j,i,1].v,…,m[2,j,i,p].v, m[2,j].i }
{m[2,j,i+1].d, m[2,j,i+1,1].v,…,m[2,j,i+1,p].v, m[2,j].i} =
{m[2,j].i } ≠
над которым выполняет ассоциативная операция выбор минимального и
для которого существуют операции агрегирования – выбор минимального;
в цикле fd9 ФОМ fd10 для разных итераций k и k+1 может быть
распараллелена по данным, т.к.:
o существует потоковая зависимость, антизависимость и зависимость по
выходу по параметру элемента модели знаний m[2,j,i].d:
Out (fd10 для k) In (fd10 для k+1) =
{m[2,j,i,k].v, m[2,j,i].d}{d[j,k+1], m[1,i,k+1].v, m[2,j,i].d, m[2,j,i,k+1].v}=
{m[2,j,i].d} ≠
In (fd10 для k) Out (fd10 для k+1) =
{d[j,k], m[1,i,k].v, m[2,j,i].d, m[2,j,i,k].v}{m[2,j,i,k+1].v, m[2,j,i].d}=
{m[2,j,i].d} ≠
Out (fd10 для k) Out (fd10 для k+1) =
{ m[2,j,i,k].v, m[2,j,i].d }{m[2,j,i,k+1].v, m[2,j,i].d} = {m[2,j,i].d} ≠ ;
над которым выполняется ассоциативная операция суммирования и для
340
которого существует операция агрегирования - суммирование;
в цикле fd19 ФОМ fd20 для разных итераций k и k+1 может быть
распараллелена по данным, т.к.:
o отсутствует потоковая зависимость, антизависимость и зависимость по
выходу:
Out (fd20 для k) In (fd20 для k+1) =
{ m[1, i', k].d }{ m[2,j].i, m[1, i', k+1].d, m[2, j, i', k+1].v }=
In (fd20 для k) Out (fd20 для k+1) =
{m[2,j].i, m[1, i', k].d, m[2, j, i', k].v} {m[1, i', k+1].d}=
Out (fd20 для k) Out (fd20 для k+1) ={m[1, i', k].d} {m[1, i', k+1].d}= ;
в цикле f24 ФОМ f25 для разных итераций i и i+1 может быть
распараллелена по данным, т.к.:
o существует потоковая зависимость, антизависимость и зависимость по
выходу по параметру элемента модели знаний m[1].cc:
Out (f25 для i) In (f25 для i+1) =
{m[1].cc, m[1, i, 1].v,…, m[1, i, p].v}
{m[1].cc, m[1,i+1,1].d,…,m[1,i+1,p].d, m[1,i+1,1].v,…,m[1,i+1, p].v, m[1,i+1].n}=
{m[1].cc} ≠ ;
In (f25 для i) Out (f25 для i+1) =
{m[1].cc, m[1,i,1].d,…,m[1,i,p].d, m[1,i,1].v,…,m[1,i, p].v, m[1,i].n}
{m[1].cc, m[1, i+1, 1].v,…, m[1, i+1, p].v}= {m[1].cc} ≠ ;
Out (f25 для i) Out (f25 для i+1) =
{m[1].cc,m[1, i,1].v,…,m[1,i,p].v}{m[1].cc,m[1,i+1,1].v,…,m[1,i+1,p].v}=
{m[1].cc} ≠ ;
над которым выполняется ассоциативная операция конъюнкции и для
которого существует операция агрегирования - конъюнкция;
в цикле f25 ФОМ f26 для разных итераций k и k+1 может быть
распараллелена по данным, т.к.:
o существует потоковая зависимость, антизависимость и зависимость по
341
выходу по параметру элемента модели знаний m[1].cc:
Out (f26 для k) In (f26 для k+1) =
{m[1, i, k].v, m[1].cc} {m[1, i, k+1].v, m[1, i, k+1].d, m[1, i].n, m[1].cc} =
{m[1].cc} ≠ ;
In (f26 для k) Out (f26 для k+1) =
{m[1, i, k].v, m[1, i, k].d, m[1, i].n, m[1].cc}{m[1, i, k+1].v, m[1].cc} =
{m[1].cc} ≠ ;
Out (f26 для k) Out (f26 для k+1) =
{ m[1, i, k].v, m[1].cc }{m[1, i, k+1].v, m[1].cc} = {m[1].cc} ≠ ;
над которым выполняется ассоциативная операция конъюнкции и для
которого существует операция агрегирования - конъюнкция;
функция f3 для разных итераций k и k+1 может быть распараллелена по
данным, т.к.:
o нет потоковой зависимости:
Out (f3 для k) In (f3 для k+1) =
{m[2,k,q’,p’]} {d[j,k+1], d[j,t], m[2,k+1,q’,p’]} = ;
o нет антизависимости:
In (f3 для k) Out (f3 для k+1) =
{d[j,k], d[j,t], m[1,p’], m[2,k,p’,q’]} {m[2,k+1,q’,p’]} = ;
o нет зависимости по выходу:
Out (f3 для k) Out (f3 для k+1) = {m[2,k,q’,p’]} {m[2,k+1,q’,p’]} = .
В.2.5 Параллельные формы алгоритма kMeans
С учетом возможностей параллельного выполнения ФОМ алгоритма
kMeans его распараллеливание может быть выполнено следующим образом:
kMeansPar = (loop (m[1].cc==true) finit fafter
(parallels [loope m[1,1] m[1,c]
parallels [loope m[0,1] m[0,p] f26]])
(parallels [loopd d[0] d[z]
342
(parallels [(parallels [loope m[0,1] m[0,p] f20]), f22])
(parallels [loope m[1,1] m[1,c] f14f13
(parallels [loope m[0,1] m[0,p] fd10]])]))
(parallels [loope m[1,1] m[1,c]
(parallels [loope m[0,1] m[0,p] f3])])f0 =
Дерево вложенности параллельного алгоритма kMeans изображено на
рисунке В.4.
Рисунок В.4. Дерево вложенности параллельного алгоритма kMeans
f0
run[f0, f1, fd6]
loope m[1,1] m[1,c] f2
loope m[0,1] m[0,p]
loope m[1,1] m[1,c] f3
f20
loope m[0,1] m[0,p] f13
fd10
f26 f14
loop (m[1].cc==true) finit fafter f24fd7
loopd d[0] d[z] f22f19fd8 loope m[1,1] m[1,c] f25
loope m[0,1] m[0,p]
loope m[0,1] m[0,p]
f22
parallels
parallels
parallels
parallels
parallels
parallels
parallels
parallels
parallels
343
В.3. Алгоритм поиска частых наборов – Apriori TID
В.3.1 Описание алгоритма Apriori TID
Поиск частых наборов F осуществляется в множестве транзакций T
состоящих из элементов множества I. В основе алгоритма лежит понятие
частого набора. Под частотой понимается количество транзакций |T|, в которых
содержится данный набор элементов i ϵ I.
Для определения частого набора используется понятие поддержка (Supp),
вычисляема как отношения числа транзакций TF, содержащих набор элементов
F, к общему числу транзакций:
SuppF = |TF| / |T|.
Частый набор — набор элементов с поддержкой больше заданного порога
либо равной ему. Этот порог называется минимальной поддержкой.
Для поиска частых набор в 1994 году Срикантом Р. И Агравалом Р. был
предложен алгоритм Apriori TID , который использует принцип: поддержка
любого набора элементов не может быть больше поддержки любого его
поднабора:
EF SuppSupp для .FE
В настоящее время существует множество алгоритмов поиска частых
наборов, являющихся модификациями данного алгоритма. Псевдокод
алгоритма представлен ниже:
344
В.3.2 Модель для алгоритма Apriori TID
Спецификация PMML представляет модель знаний для частых наборов из
двух спиcков:
Item – множество всех элементов I;
ItemSet – множество всех частых наборов L.
// Создать список транзакций T из набора данных d
1. for j = 1 … z // цикл по векторам {
2. T.add(t={xj.1| xj.0 == t.tid, tT})
3. end for
// Cоздать множество 1-эдементных наборов L1 L
4. for q =1…s // для каждой транзакции tq T
5. for p = 1… u // для каждого элемента в транзакции iq.p I
6. {iq.p}.count ++;
7. if ({iq.p}.count >= minsupport)
8. L1.add({iq.p})
9. end for
10. end for
// Cоздать множества k-элементных наборов Lk L
11. for k=2..w // для всех множеств частых наборов Lk L
//генерировать новых k-элементных кандидатов Ck = apriori-gen(Lk-1)
12. for r=1..v // для всех наборов из множества k-1-элементных Lk-1
13. for h=r+1…v//для наборов из множества k-1-элементных Lk-1 с r-го
14. if (lr[0]=lh[0] & .. & lr[k-2]=lh[k-2] & lr[k-1]<lh[k-1])
15. ck = {lr[0], .., lr[k-2], lr[k-1], lh[k-1]
16. for q =1… s // для каждой транзакции tq T
17. if(ck tq)
18. ck.count++
19. if (ip.count >= minsupport)
20. Lk.add(ck)
21. end for
22. end if
23. end for
24. end for
25. end for
345
Для алгоритма Apriori TID мы также добавили в модель знаний
множество транзакций T. Кроме того, множество всех частых наборов было
разбито на подмножества частых наборов по их размерам:
L = {L1, …, Lk, …, Lm}.
Таким образом, массив деревьев решений модели знаний для алгоритма
Apriori (инициализируется функцией f0) расширяется следующими элементами:
m[1] дерево, содержащее информацию о множестве элементов ig I:
m[2] дерево, содержащее информацию обо всех частых наборах Lk ⸦ L:
o m[2,k] множество k-элементных наборов lr Lk,:
m[2,k,r] k-элементных набор lr содержащий элементы:
m[2,k,r,f] элементы входящие в него ik.r.f I и ik.r.f lr;
m[2,k,r].n количество транзакций в которые данный
набор входит;
m[3] дерево, содержащее информацию о транзакциях tq T, где:
o m[3,q] транзакция tq, которая содержит:
m[3,q,p] элементы входящие в нее iq.p I и iq.p tq;
m[3,q].tid идентификатор транзакции.
С применением описанного представления модели знаний для алгоритма
Apriori TID псевдокод алгоритма будет иметь вид представленный ниже:
346
// Создать список транзакций T из набора данных d
1. for j = 1 … z // цикл по векторам {
2. i = m[1].get(d[j.1])
3. t = m[3].get(d[j.0])
4. t.add(i);
5. end for
// Cоздать множество 1-эдементных наборов L1 L
6. for q =1… s // для каждой транзакции tq T
7. for p = 1… u // для каждого элемента в транзакции iq.p I
8. i= m[1].get(m[3,q,p])
9. i.n ++;
10. if (c.n >= minsupport)
11. m[2,1].add({i})
12. end for
13. end for
// Cоздать множества k-элементных наборов Lk L
14. for k=2.. w // для всех множеств частых наборов Lk L
//генерировать новых k-элементных кандидатов Ck = apriori-gen(Lk-1)
15. for r=1.. v // для всех наборов из множества k-1-элементных Lk-1
16. for h=r+1… v//для наборов из множества k-1-элементных Lk-1 с r-го
17. if (m[2,k-1,r,0]=m[2,k-1,h,0]&..&
m[2,k-1,r,k-2]=m[2,k-1,h,k-2] &
m[2,k-1,r,k-1]< m[2,k-1,h,k-1])
18. m[2,k].add( {m[2,k-1,r,0], .., m[2,k-1,r,k-1], m[2,k-1,h,k-1]})
19. for q =1… s // для каждой транзакции tq T
20. ck = m[2,k].last();
21. if(ck m[3,q])
22. ck.n++
23. end for
24. ck = m[2,k].last();
25. if (ck.n < minsupport)
26. m[2,k].remove(ck)
27. end if
28. end for
29. end for
30. end for
347
В.3.3 Представление алгоритма Apriori TID в виде композиции функций
обработки моделей знаний
В соответствии с предложенным подходом алгоритм Apriori TID
представлен как композиция следующих ФОМ:
fd1 цикл по векторам с d[1] по d[z] (срока 1):
fd1 = loopd d[1] d[z] fd2;
fd2 формирование транзакции (сроки 2-4);
f3 цикл по транзакциям с m[3,1] по m[3,s] (срока 6):
f3 = loope m[3,1] m[3,s] f4;
f4 цикл по элементам транзакции с m[3,q,1] по m[3,q,u] (срока 7):
f4 = loope m[3,q,1] m[3,q,u] f5;
f5 формирование частого одноэлементного набора (сроки 8-11);
f6 цикл по множеству частых наборов с m[2,1] по m[2,w] (срока 14):
f6 = loope m[2,1] m[2,w] f7;
f7 цикл по k-1 элементным наборам с m[2,k,1] по m[2,k,v] (срока 15):
f7 = loope m[2,k,1] m[2,k,v] f8;
f8 цикл по k-1 элементным наборам с m[2,k,r] по m[2,k,v] (срока 16):
f8 = loope m[2,k,r] m[2,k,v] f11f10f9;
f9 формирование k-элементного кандидата (сроки 17-18);
f10 цикл по транзакциям с m[3,1] по m[3,s] (срока 19):
f10 = loope m[3,1] m[3,s] f11;
f11 подсчет транзакций для k-элементного кандидата (сроки 20-22);
f12 формирование k-элементного частого набора (сроки 24-26);
348
Таким образом, мы можем представить алгоритм Apriori TID как
композицию функций:
ATID = f6f3f1f0 =
(loope m[2,1] m[2,w] f7)( loope m[3,1] m[3,s] f4)(loopd d[1] d[z] f2)f0 =
(loope m[2,1] m[2,w] (loope m[2,k,1] m[2,k,v]
(loope m[2,k,r] m[2,k,v] f11(loope m[3,1] m[3,s] f10) f9)))
(loope m[3,1] m[3,s] (loope m[3,q,1] m[3,q,u] f5))
(loopd d[1] d[z] f2)f0
Дерево вложенности алгоритма Apriori TID изображена на рисунке В.5.
Рисунок В.5 – Дерево вложенности алгоритма Apriori TID.
В.3.4 Проверка условий параллельного выполнения функций алгоритма Apriori
TID
Множества используемых и изменяемых элементов, полученные на основании
псевдокода, представлены в таблице В.3.
f0
run[f0, fd1, f3, f6]
loopd d[1] d[z] f2
fd2
f9
loope m[2,1] m[2,w] f7
loope m[3,q,1] m[3,q,u] f5 loope m[2,k,1] m[2,k,v] f8
loope m[2,k,r] m[2,k,v] f12f10f9 f5
loope m[3,1] m[3,s] f4
f12 loope m[3,1] m[3,s] f11
f11
349
Таблица В.3. Множества In и Out для FMBs алгоритма Apriori
ФОМ In Out
f0 d m[1]
fd1 d m[1], m[3]
fd2 d[j.0], d[j.1], m[1], m[3,q,p]
f3 m[1,1],…, m[1,m]
m[3,1,1], ..., m[3,1,u], …, m[3,s,1], ..., m[3,s,u]
m[1,1],…, m[1,m]
m[2,1,1], …, m[2,1,v]
f4 m[1,1],…, m[1,m]
m[3,q,1], ..., m[3,q,u]
m[1,1],…, m[1,m]
m[2,1,1], …, m[2,1,v]
f5 m[1,i], m[3,q,p] m[1,i].n, m[2,1,f]
f6 m[2,2,1,0], ..., m[2,2,1,1]…
m[2,w,v,0], .., m[2,w,v,w-1]
m[2,1,1], …, m[2,s,v]
f7 m[2,k-1,1,0],..,m[2,k-1,1,k-1]…
m[2,k-1,v,0], .., m[2,k-1,v,k-1]
m[3,1],…, m[3,s]
m[2,k,1], …, m[2,k,v]
f8 m[2,k-1,r,0],..,m[2,k-1,r,k-1]…
m[2,k-1,v,0], .., m[2,k-1,v,k-1]
m[3,1],…, m[3,s]
m[2,k,1], …, m[2,k,v]
f9 m[2,k-1,r,0], .., m[2,k-1,r,k-1]
m[2,k-1,h,0], .., m[2,k-1,h,k-1]
m[2,k,f]
f10 m[2,k,f].n, m[3,1],…, m[3,s] m[2,k,f].n
f11 m[3,q], m[2,k,f].n m[2,k,f].n
f12 m[2,k,f].n m[2,k,f]
Для алгоритма Apriori TID возможности распараллеливания по задачам
для каждого уровня композиции будут следующие:
функции fd1 и f3 не могут выполняться параллельно, т.к. имеют
потоковую зависимость по элементам модели знаний m[1] и m[3]:
Out(fd1) In(f3)= { m[1], m[3]} ≠
над которыми выполняются не ассоциативные по отношению друг другу
350
операции добавления и извлечения;
функции f3 и f6 не могут выполняться параллельно, т.к. имеют потоковую
зависимость по элементам модели знаний m[2,1,1], …, m[2,1,v] для
первой итерации цикла f6:
Out(f3) In(f6)= {m[2,1,1], …, m[2,1,v]} ≠
над которыми выполняются не ассоциативные по отношению друг другу
операции добавления и извлечения;
функции f9 и f10 не могут выполняться параллельно, т.к. имеют потоковую
зависимость по элементам модели знаний m[2,k,f]:
Out(f9) In(f10)= {m[2,k,f]} ≠
над которыми выполняются не ассоциативные по отношению друг другу
операции добавления и изменения (инкрементации);
функции f10 и f12 не могут выполняться параллельно, т.к. имеют
потоковую зависимость по элементам модели знаний m[2,k,f].n:
Out(f10) In(f12)= {m[2,k,f].n} ≠
над которыми выполняются не ассоциативные по отношению друг другу
операции инкрементации и сравнение.
Возможности распараллеливания по данным для каждого цикла будут
следующие:
цикл по транзакциям fd1 может быть распараллелен т.к., ФОМ fd2 для
разных итераций j и j+1:
o не существует потоковой зависимости и антизависимости:
Out (fd2 для j)In (fd2 для j+1) = {m[3,q,p]}{d[j+1,0], d[j+1,1]} = ;
In (fd2 для j)Out (fd2 для j+1) = {d[j+1,0], d[j+1,1]}{ m[3,q,p]}= ;
o возможна зависимость по выходу по элементу модели знаний m[3,q,p]:
Out(fd2 для j) Out (fd2 для j +1) = {m[3,q,p]} ≠
над которым выполняется операция добавление (дублирование
элемента в транзакции допустимо, если это допустимо в данных);
351
цикл f3 для разных итераций q и q+1 может быть распараллелен по
данным:
o возможна потоковая зависимость, антизависимость и зависимость по
выходу по элементам m[1,1],…, m[1,m]:
Out(f3 для q)In(f3 для q+1)={m[1,1],…,m[1,m],m[2,1,1],…,m[2,1,v]}
{m[1,1],…,m[1,m],m[3,q,1],...,m[3,q,u]} ≠ ;
In(f3 для q) Out(f3 для q+1)={m[1,1],…,m[1,m],m[3,q,1],...,m[3,q,u]}
{m[1,1],…, m[1,m],m[2,1,1],…,m[2,1,v]} ≠ ;
Out(f3 для q)Out(f3 для q+1)={m[1,1],…, m[1,m],m[2,1,1],…,m[2,1,v]}
{m[1,1],…, m[1,m],m[2,1,1],…,m[2,1,v]} ≠ ;
над которыми выполняется ассоциативная по отношению друг другу
операция инкрементации;
цикл f4 для разных итераций p и p+1 может быть распараллелен по
данным, т.к.:
o возможна потоковая зависимость, антизависимость и зависимость по
выходу по элементу m[1,i]:
Out(f3 для q)In(f3 для q+1)={m[1,i].n, m[2,1,f]} {m[1,i], m[3,q,p]} ≠ ;
In(f3 для q) Out(f3 для q+1)={m[1,i], m[3,q,p]} {m[1,i].n, m[2,1,f]} ≠ ;
Out(f3 для q)Out(f3 для q+1)={m[1,i].n, m[2,1,f]}{m[1,i].n, m[2,1,f]} ≠ ;
над которым выполняется ассоциативная по отношению друг другу
операция инкрементации;
цикл f6 для разных итераций k и k+1 не может быть распараллелен по
данным, т.к.:
o имеется потоковая зависимость по элементам m[2,k,1], …, m[2,k,v]:
Out(f6 для k)In(f6 для k+1)=
{m[2,k,1], …, m[2,k,v]} {m[2,k,1,0],..,m[2,k,v,k], m[3,1],…, m[3,s]} ≠
над которым выполняется не ассоциативная по отношению друг другу
операции добавления и извлечения;
цикл f7 для разных итераций r и r+1 может быть распараллелен по
данным, т.к. отсутствует потоковая зависимость, антизависимости и
зависимость по выходу:
352
Out(f7 для r)In(f7 для r+1)={m[2,k,1],…,m[2,k,v]} {m[2,k-1,r+1,0],..,
m[2,k-1,r+1,k-1], m[2,k-1,v,0],..,m[2,k-1,v,k-1],m[3,1],…,m[3,s]} = ;
In(f7 для r) Out(f7 для r+1)=
{m[2,k-1,r,0],..,m[2,k-1,r,k-1], m[2,k-1,v,0],..,m[2,k-1,v,k-1],m[3,1],..,m[3,s]}
{m[2,k,1],…,m[2,k,v]} = ;
Out(f7 для r) Out(f7 для r+1)=
{m[2,k,1],…,m[2,k,v] } {m[2,k,1],…,m[2,k,v]} = ;
Отсутствие зависимости по выходу по элементам m[2,k,1],…,m[2,k,v]
объясняется тем, что создаваемые частые наборы являются уникальными,
а значит не могут пересекаться в разных итерациях.
цикл f8 для разных итераций h и h+1 может быть распараллелен по
данным, т.к.:
o отсутствует потоковая зависимость, антизависимость и зависимость по
выходу:
Out(f8 для h)In(f8 для h+1)={m[2,k,f]}
{m[2,k,f],m[2,k-1,r,0],...,m[2,k-1,r,k-1],m[2,k-1,h+1,0],..,m[2,k-1,h+1,k-1]}=;
In (f8 для h) Out (f8 для h+1) =
{m[2,k,f],m[2,k-1,r,0],...,m[2,k-1,r,k-1],m[2,k-1,h+1,0],…,m[2,k-1,h+1,k-1]}
{m[2,k,f]} =;
Out (f8 для h) Out (f8 для h+1) = {m[2,k,f]}{m[2,k,e]} =;
Отсутствие зависимости по выходу по элементам m[2,k,f] объясняется тем,
что создаваемые частые наборы являются уникальными, а значит не могут
пересекаться в разных итерациях.
цикл f10 для разных итераций q и q+1 может быть распараллелен по
данным, т.к. возможна потоковая зависимость, антизависимость и
зависимость по выходу по элементу m[2,k,f].n:
Out(f10 для q)In(f10 для q+1)={m[2,k,f].n } {m[3,q+1], m[2,k,f].n } ≠ ;
In(f10 для q) Out(f10 для q+1)={m[3,q+1], m[2,k,f].n} {m[2,k,f].n } ≠ ;
Out(f10 для q)Out(f10 для q+1)={m[2,k,f].n } {m[2,k,f].n } ≠ ;
над которым выполняется ассоциативная по отношению друг другу
операция инкрементации.
353
В.3.5 Параллельные формы алгоритма Apriori TID
С учетом возможностей параллельного выполнения ФОМ алгоритма
Apriori TID его распараллеливание может быть выполнено следующим
образом:
apriori = (loope m[2,1] m[2,w] (parallels (loope m[2,k,1] m[2,k,v]
(parallels (loope m[2,k,r] m[2,k,v] f11
( parallels (loope m[3,1] m[3,s] f10)) f9)))))
(parallels (loope m[3,1] m[3,s] (parallels (loope m[3,q,1] m[3,q,u] f5))))
(parallels (loopd d[1] d[z] f2))f0
Дерево вложенности параллельного алгоритма Apriori TID изображено на
рисунке В.6:
Рисунок В.6 – Дерево вложенности параллельного алгоритма Apriori TID.
f0
run[f0, fd1, f3, f6]
loopd d[1] d[z] f2
fd2
f9
loope m[2,1] m[2,w] f7
loope m[3,q,1] m[3,q,u] f5
loope m[2,k,1] m[2,k,v] f8
loope m[2,k,r] m[2,k,v] f12f10f9 f5
loope m[3,1] m[3,s] f4
loope m[3,1] m[3,s] f11
f11
parallels parallels
parallels
parallels
parallels
parallels
f12
